147 lines
3.9 KiB
Go
147 lines
3.9 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"google.golang.org/genproto/googleapis/rpc/errdetails"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"github.com/hashicorp/vagrant-plugin-sdk/component"
|
|
"github.com/hashicorp/vagrant-plugin-sdk/proto/vagrant_plugin_sdk"
|
|
"github.com/hashicorp/vagrant-plugin-sdk/terminal"
|
|
"github.com/hashicorp/vagrant/internal/client"
|
|
"github.com/hashicorp/vagrant/internal/server/proto/vagrant_server"
|
|
)
|
|
|
|
type DynamicCommand struct {
|
|
*baseCommand
|
|
|
|
name string
|
|
synopsis string
|
|
help string
|
|
parent *DynamicCommand
|
|
flags []*component.CommandFlag
|
|
primary bool
|
|
}
|
|
|
|
func (c *DynamicCommand) Run(args []string) int {
|
|
if err := c.Init(
|
|
WithArgs(args),
|
|
WithFlags(c.Flags()),
|
|
); err != nil {
|
|
return 1
|
|
}
|
|
|
|
var r *vagrant_server.Job_CommandResult
|
|
err := c.Do(c.Ctx, func(ctx context.Context, cl *client.Client, modifier client.JobModifier) (err error) {
|
|
cmdArgs := &vagrant_plugin_sdk.Command_Arguments{
|
|
Args: c.args,
|
|
Flags: []*vagrant_plugin_sdk.Command_Arguments_Flag{},
|
|
}
|
|
for f, v := range c.flagData {
|
|
cmdFlag := &vagrant_plugin_sdk.Command_Arguments_Flag{Name: f.LongName}
|
|
switch f.Type {
|
|
case component.FlagBool:
|
|
cmdFlag.Type = vagrant_plugin_sdk.Command_Arguments_Flag_BOOL
|
|
cmdFlag.Value = &vagrant_plugin_sdk.Command_Arguments_Flag_Bool{
|
|
Bool: v.(bool),
|
|
}
|
|
case component.FlagString:
|
|
cmdFlag.Type = vagrant_plugin_sdk.Command_Arguments_Flag_STRING
|
|
cmdFlag.Value = &vagrant_plugin_sdk.Command_Arguments_Flag_String_{
|
|
String_: v.(string),
|
|
}
|
|
}
|
|
cmdArgs.Flags = append(cmdArgs.Flags, cmdFlag)
|
|
}
|
|
|
|
c.Log.Debug("collected argument flags",
|
|
"flags", cmdArgs.Flags,
|
|
"args", args,
|
|
"remaining", c.args,
|
|
)
|
|
|
|
cOp := &vagrant_server.Job_CommandOp{
|
|
Command: c.name,
|
|
Component: &vagrant_server.Component{
|
|
Type: vagrant_server.Component_COMMAND,
|
|
Name: c.name,
|
|
},
|
|
CliArgs: cmdArgs,
|
|
}
|
|
|
|
r, err = cl.Command(ctx, cOp, modifier)
|
|
|
|
// If nothing failed but we didn't get a Result back, something may
|
|
// have gone wrong on the far side so we need to interpret the error.
|
|
if err == nil && !r.RunResult {
|
|
runErrorStatus := status.FromProto(r.RunError)
|
|
details := runErrorStatus.Details()
|
|
userError := false
|
|
for _, msg := range details {
|
|
switch m := msg.(type) {
|
|
case *errdetails.LocalizedMessage:
|
|
// Errors from Ruby with LocalizedMessages are user-facing,
|
|
// so can be output directly.
|
|
userError = true
|
|
cl.UI().Output(m.Message, terminal.WithErrorStyle())
|
|
// All user-facing errors from Ruby use a 1 exit code. See
|
|
// Vagrant::Errors::VagrantError.
|
|
r.ExitCode = 1
|
|
}
|
|
}
|
|
// If there wasn't a user-facing error, just assign the returned
|
|
// error (if any) from the response and assign that back out so it
|
|
// can be displayed as an unexpected error.
|
|
if !userError {
|
|
err = runErrorStatus.Err()
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
cl.UI().Output("Running of task "+c.name+" failed unexpectedly\n", terminal.WithErrorStyle())
|
|
cl.UI().Output("Error: "+err.Error(), terminal.WithErrorStyle())
|
|
}
|
|
|
|
c.Log.Debug("result from operation", "task", c.name, "result", r)
|
|
|
|
return err
|
|
})
|
|
|
|
if err != nil {
|
|
c.Log.Error("Got error from task, so exiting 255", "error", err)
|
|
return int(-1)
|
|
}
|
|
|
|
c.Log.Info("Task did not error, so exiting with provided code", "code", r.ExitCode)
|
|
return int(r.ExitCode)
|
|
}
|
|
|
|
func (c *DynamicCommand) Synopsis() string {
|
|
return c.synopsis
|
|
}
|
|
|
|
func (c *DynamicCommand) Help() string {
|
|
fset := c.generateCliFlags(c.Flags())
|
|
return formatHelp(fmt.Sprintf("%s\n%s\n", c.help, fset.Display()))
|
|
}
|
|
|
|
func (c *DynamicCommand) Flags() component.CommandFlags {
|
|
return c.flagSet(flagSetOperation, func(opts []*component.CommandFlag) []*component.CommandFlag {
|
|
return append(c.flags, opts...)
|
|
})
|
|
}
|
|
|
|
func (c *DynamicCommand) Primary() bool {
|
|
return c.primary
|
|
}
|
|
|
|
func (c *DynamicCommand) fullName() string {
|
|
var v string
|
|
if c.parent != nil {
|
|
v = c.parent.fullName() + " "
|
|
}
|
|
return v + c.name
|
|
}
|