feat: implement commands.*.after

Author: FabianKramm

cmd/overwrite_command.go

@@ -66,5 +66,5 @@ func NewOverwriteCmd(f factory.Factory, globalFlags *flags.GlobalFlags, command
 
 func (cmd *OverwriteCmd) Run(f factory.Factory, args []string) error {
 	devCtx := devspacecontext.NewContext(context.Background(), f.GetLog())
-	return ExecuteCommand(devCtx.Context, cmd.Command, cmd.Variables, args, devCtx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
+	return executeCommandWithAfter(devCtx.Context, cmd.Command, args, cmd.Variables, devCtx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin, devCtx.Log)
 }

cmd/run.go

@@ -11,6 +11,7 @@ import (
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"
 	"github.com/loft-sh/devspace/pkg/util/command"
 	"github.com/loft-sh/devspace/pkg/util/exit"
+	"github.com/loft-sh/devspace/pkg/util/interrupt"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"io"
 	"mvdan.cc/sh/v3/interp"
@@ -158,11 +159,57 @@ func (cmd *RunCmd) RunRun(f factory.Factory, args []string) error {
 		}
 
 		ctx = ctx.AsDependency(dep)
-		return ExecuteConfigCommand(ctx.Context, ctx.Config, args[0], args[1:], ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
+		commandConfig, err := findCommand(ctx.Config, args[0])
+		if err != nil {
+			return err
+		}
+
+		return executeCommandWithAfter(ctx.Context, commandConfig, args[1:], ctx.Config.Variables(), ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin, ctx.Log)
 	}
 
-	// Execute command
-	return ExecuteConfigCommand(ctx.Context, ctx.Config, args[0], args[1:], ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
+	commandConfig, err := findCommand(ctx.Config, args[0])
+	if err != nil {
+		return err
+	}
+
+	return executeCommandWithAfter(ctx.Context, commandConfig, args[1:], ctx.Config.Variables(), ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin, ctx.Log)
+}
+
+func findCommand(config config.Config, name string) (*latest.CommandConfig, error) {
+	// Find command
+	if config.Config().Commands == nil || config.Config().Commands[name] == nil {
+		return nil, errors.Errorf("couldn't find command '%s' in devspace config", name)
+	}
+
+	return config.Config().Commands[name], nil
+}
+
+func executeCommandWithAfter(ctx context.Context, command *latest.CommandConfig, args []string, variables map[string]interface{}, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader, log log.Logger) (err error) {
+	err = interrupt.Global.Run(func() error {
+		return ExecuteCommand(ctx, command, variables, args, dir, stdout, stderr, stdin)
+	}, func() {
+		if command.After != "" {
+			vars := variables
+			vars["COMMAND_INTERRUPT"] = "true"
+			err = executeShellCommand(ctx, command.After, vars, args, dir, stdout, stderr, stdin)
+			if err != nil {
+				log.Errorf("error executing after command: %v", err)
+			}
+		}
+	})
+	if command.After != "" {
+		vars := variables
+		if err != nil {
+			vars["COMMAND_ERROR"] = err.Error()
+			log.Error(err)
+		}
+		err = executeShellCommand(ctx, command.After, vars, args, dir, stdout, stderr, stdin)
+		if err != nil {
+			return errors.Wrap(err, "error executing after command")
+		}
+		return nil
+	}
+	return err
 }
 
 func ParseArgs(cobraCmd *cobra.Command, globalFlags *flags.GlobalFlags, log log.Logger) ([]string, error) {
@@ -221,14 +268,25 @@ func LoadCommandsConfig(configLoader loader.ConfigLoader, configOptions *loader.
 		WithConfig(commandsInterface), nil
 }
 
-// ExecuteConfigCommand executes a command from the config
-func ExecuteConfigCommand(ctx context.Context, config config.Config, name string, args []string, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader) error {
-	if config.Config().Commands == nil || config.Config().Commands[name] == nil {
-		return errors.Errorf("couldn't find command '%s' in devspace config", name)
+func executeShellCommand(ctx context.Context, shellCommand string, variables map[string]interface{}, args []string, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader) error {
+	extraEnv := map[string]string{}
+	for k, v := range variables {
+		extraEnv[k] = fmt.Sprintf("%v", v)
+	}
+
+	// execute the command in a shell
+	err := engine.ExecuteSimpleShellCommand(ctx, dir, stdout, stderr, stdin, extraEnv, shellCommand, args...)
+	if err != nil {
+		if status, ok := interp.IsExitStatus(err); ok {
+			return &exit.ReturnCodeError{
+				ExitCode: int(status),
+			}
+		}
+
+		return errors.Wrap(err, "execute command")
 	}
 
-	cmd := config.Config().Commands[name]
-	return ExecuteCommand(ctx, cmd, config.Variables(), args, dir, stdout, stderr, stdin)
+	return nil
 }
 
 // ExecuteCommand executes a command from the config

pkg/devspace/config/config.go

@@ -80,7 +80,12 @@ func (c *config) LocalCache() localcache.Cache {
 }
 
 func (c *config) Variables() map[string]interface{} {
-	return c.resolvedVariables
+	newVariables := map[string]interface{}{}
+	for k, v := range c.resolvedVariables {
+		newVariables[k] = v
+	}
+
+	return newVariables
 }
 
 func (c *config) Path() string {

pkg/devspace/config/versions/latest/schema.go

@@ -1324,6 +1324,12 @@ type CommandConfig struct {
 	// Command is the command that should be executed. For example: 'echo 123'
 	Command string `yaml:"command" json:"command"`
 
+	// After is executed after the command was run. It is executed also when
+	// the command was interrupted which will set the env variable COMMAND_INTERRUPT
+	// to true as well as when the command errored which will set the error string to
+	// COMMAND_ERROR.
+	After string `yaml:"after" json:"after"`
+
 	// DisableReplace signals DevSpace to not replace the default command. E.g.
 	// dev does not replace devspace dev.
 	DisableReplace bool `yaml:"disableReplace,omitempty" json:"disableReplace,omitempty"`

pkg/devspace/pipeline/engine/basichandler/commands/is_empty.go

@@ -0,0 +1,22 @@
+package commands
+
+import (
+	"mvdan.cc/sh/v3/interp"
+	"strings"
+)
+
+func IsEmpty(args []string) error {
+	// its possible that there are 0 args
+	// because bash will omit an empty string
+	// as argument
+	if len(args) > 1 {
+		return interp.NewExitStatus(1)
+	} else if len(args) == 0 {
+		return interp.NewExitStatus(0)
+	}
+
+	if strings.TrimSpace(args[0]) == "" {
+		return interp.NewExitStatus(0)
+	}
+	return interp.NewExitStatus(1)
+}

pkg/devspace/pipeline/engine/basichandler/commands/is_equal.go

@@ -2,13 +2,29 @@ package commands
 
 import (
 	"mvdan.cc/sh/v3/interp"
+	"strings"
 )
 
 func IsEqual(args []string) error {
-	if len(args) != 2 {
+	if len(args) > 2 {
 		return interp.NewExitStatus(1)
 	}
 
+	// one of the arguments is an empty string
+	if len(args) == 1 {
+		if strings.TrimSpace(args[0]) == "" {
+			return interp.NewExitStatus(0)
+		}
+
+		return interp.NewExitStatus(1)
+	}
+
+	// both arguments are empty strings
+	if len(args) == 0 {
+		return interp.NewExitStatus(0)
+	}
+
+	// compare arguments
 	if args[0] == args[1] {
 		return interp.NewExitStatus(0)
 	}

pkg/devspace/pipeline/engine/basichandler/commands/is_os.go

@@ -6,7 +6,12 @@ import (
 )
 
 func IsOS(args []string) error {
-	if len(args) != 1 {
+	if len(args) > 1 {
+		return interp.NewExitStatus(1)
+	}
+
+	// is empty string?
+	if len(args) == 0 {
 		return interp.NewExitStatus(1)
 	}
 

pkg/devspace/pipeline/engine/basichandler/handler.go

@@ -23,6 +23,9 @@ var BasicCommands = map[string]func(ctx context.Context, args []string) error{
 	"is_equal": func(ctx context.Context, args []string) error {
 		return enginecommands.IsEqual(args)
 	},
+	"is_empty": func(ctx context.Context, args []string) error {
+		return enginecommands.IsEmpty(args)
+	},
 	"is_true": func(ctx context.Context, args []string) error {
 		return enginecommands.IsTrue(args)
 	},