feat: add run_command & refactor commands

Author: FabianKramm

cmd/list/commands.go

@@ -70,6 +70,10 @@ func (cmd *commandsCmd) RunListProfiles(f factory.Factory, cobraCmd *cobra.Comma
 
 	rows := [][]string{}
 	for _, command := range commands {
+		if command.Internal {
+			continue
+		}
+
 		rows = append(rows, []string{
 			command.Name,
 			command.Command,

cmd/list/vars.go

@@ -7,7 +7,6 @@ import (
 	"sort"
 
 	"github.com/loft-sh/devspace/cmd/flags"
-	"github.com/loft-sh/devspace/pkg/devspace/config/loader"
 	"github.com/loft-sh/devspace/pkg/util/factory"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/loft-sh/devspace/pkg/util/message"
@@ -61,7 +60,7 @@ func (cmd *varsCmd) RunListVars(f factory.Factory, cobraCmd *cobra.Command, args
 	}
 
 	// Fill variables config
-	config, err := configLoader.LoadWithParser(context.Background(), nil, nil, loader.NewWithCommandsParser(), cmd.ToConfigOptions(), logger)
+	config, err := configLoader.Load(context.Background(), nil, cmd.ToConfigOptions(), logger)
 	if err != nil {
 		return err
 	}

cmd/run.go

@@ -3,8 +3,13 @@ package cmd
 import (
 	"context"
 	"fmt"
+	"github.com/loft-sh/devspace/pkg/devspace/config"
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
+	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine"
+	"github.com/loft-sh/devspace/pkg/util/command"
+	"github.com/loft-sh/devspace/pkg/util/exit"
 	"io"
+	"mvdan.cc/sh/v3/interp"
 	"os"
 	"strings"
 
@@ -168,10 +173,10 @@ func (cmd *RunCmd) RunRun(f factory.Factory, args []string) error {
 	if err != nil {
 		return err
 	}
-	commands := commandsInterface.Config().Commands
 
 	// create context
-	ctx := devspacecontext.NewContext(context.Background(), f.GetLog())
+	ctx := devspacecontext.NewContext(context.Background(), f.GetLog()).
+		WithConfig(commandsInterface)
 
 	// check if we should execute a dependency command
 	if cmd.Dependency != "" {
@@ -191,7 +196,8 @@ func (cmd *RunCmd) RunRun(f factory.Factory, args []string) error {
 			return fmt.Errorf("couldn't find dependency %s", cmd.Dependency)
 		}
 
-		return dep.Command(ctx.Context, args[0], args[1:])
+		ctx = ctx.AsDependency(dep)
+		return ExecuteConfigCommand(ctx.Context, ctx.Config, args[0], args[1:], ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
 	}
 
 	// Save variables
@@ -201,7 +207,56 @@ func (cmd *RunCmd) RunRun(f factory.Factory, args []string) error {
 	}
 
 	// Execute command
-	return dependency.ExecuteCommand(ctx.Context, commands, args[0], args[1:], ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
+	return ExecuteConfigCommand(ctx.Context, ctx.Config, args[0], args[1:], ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
+}
+
+// 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 {
+	shellCommand := ""
+	var shellArgs []string
+	var appendArgs bool
+	for _, cmd := range config.Config().Commands {
+		if cmd.Name == name {
+			shellCommand = cmd.Command
+			shellArgs = cmd.Args
+			appendArgs = cmd.AppendArgs
+			break
+		}
+	}
+
+	extraEnv := map[string]string{}
+	for k, v := range config.Variables() {
+		extraEnv[k] = fmt.Sprintf("%v", v)
+	}
+
+	if shellCommand == "" {
+		return errors.Errorf("couldn't find command '%s' in devspace config", name)
+	}
+	if shellArgs == nil {
+		if appendArgs {
+			// Append args to shell command
+			for _, arg := range args {
+				arg = strings.Replace(arg, "'", "'\"'\"'", -1)
+
+				shellCommand += " '" + arg + "'"
+			}
+		}
+
+		// execute the command in a shell
+		err := engine.ExecuteSimpleShellCommand(ctx, dir, stdout, stderr, stdin, nil, shellCommand, args...)
+		if err != nil {
+			if status, ok := interp.IsExitStatus(err); ok {
+				return &exit.ReturnCodeError{
+					ExitCode: int(status),
+				}
+			}
+
+			return errors.Wrap(err, "execute command")
+		}
+	}
+
+	shellArgs = append(shellArgs, args...)
+	return command.CommandWithEnv(ctx, dir, stdout, stderr, stdin, nil, shellCommand, shellArgs...)
 }
 
 func getCommands(f factory.Factory) (map[string]*latest.CommandConfig, error) {

examples/pipelines/devspace.yaml

@@ -6,6 +6,14 @@ dependencies:
     source:
       path: dep2.yaml
 
+commands:
+  test2:
+    command: |
+      build_images tes
+  test:
+    command: |
+      run_command test2 abc
+
 pipelines:
   helper:
     steps:
@@ -14,7 +22,7 @@ pipelines:
   dev:
     steps:
       - run: |-
-          sleep 30
+          SWAG=fabi run_command test abc
           #run_dependency_pipelines --all --pipeline dev
           
           #export TEST=$(run_pipelines helper)

pkg/devspace/command/command.go

@@ -1,50 +1 @@
 package command
-
-import (
-	"context"
-	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine"
-	"io"
-	"strings"
-
-	"github.com/loft-sh/devspace/pkg/util/command"
-
-	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
-
-	"github.com/pkg/errors"
-)
-
-// ExecuteCommand executes a command from the config
-func ExecuteCommand(ctx context.Context, commands map[string]*latest.CommandConfig, name string, args []string, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader) error {
-	shellCommand := ""
-	var shellArgs []string
-	var appendArgs bool
-	for _, cmd := range commands {
-		if cmd.Name == name {
-			shellCommand = cmd.Command
-			shellArgs = cmd.Args
-			appendArgs = cmd.AppendArgs
-			break
-		}
-	}
-
-	if shellCommand == "" {
-		return errors.Errorf("couldn't find command '%s' in devspace config", name)
-	}
-
-	if shellArgs == nil {
-		if appendArgs {
-			// Append args to shell command
-			for _, arg := range args {
-				arg = strings.Replace(arg, "'", "'\"'\"'", -1)
-
-				shellCommand += " '" + arg + "'"
-			}
-		}
-
-		// execute the command in a shell
-		return engine.ExecuteSimpleShellCommand(ctx, dir, stdout, stderr, stdin, nil, shellCommand, args...)
-	}
-
-	shellArgs = append(shellArgs, args...)
-	return command.Command(ctx, dir, stdout, stderr, stdin, shellCommand, shellArgs...)
-}

pkg/devspace/config/loader/parser.go

@@ -23,18 +23,6 @@ type defaultParser struct{}
 
 func (d *defaultParser) Parse(ctx context.Context, originalRawConfig map[string]interface{}, rawConfig map[string]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, map[string]interface{}, error) {
 	// delete the commands, since we don't need it in a normal scenario
-	delete(rawConfig, "commands")
-
-	return fillVariablesAndParse(ctx, resolver, rawConfig, log)
-}
-
-func NewWithCommandsParser() Parser {
-	return &withCommandsParser{}
-}
-
-type withCommandsParser struct{}
-
-func (d *withCommandsParser) Parse(ctx context.Context, originalRawConfig map[string]interface{}, rawConfig map[string]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, map[string]interface{}, error) {
 	return fillVariablesAndParse(ctx, resolver, rawConfig, log)
 }
 
@@ -111,9 +99,9 @@ func fillVariablesAndParse(ctx context.Context, resolver variable.Resolver, prep
 	return latestConfig, preparedConfigInterface.(map[string]interface{}), nil
 }
 
-func Convert(prepatedConfig map[string]interface{}, log log.Logger) (*latest.Config, error) {
+func Convert(preparedConfig map[string]interface{}, log log.Logger) (*latest.Config, error) {
 	// Now convert the whole config to latest
-	latestConfig, err := versions.Parse(prepatedConfig, log)
+	latestConfig, err := versions.Parse(preparedConfig, log)
 	if err != nil {
 		return nil, errors.Wrap(err, "convert config")
 	}

pkg/devspace/config/loader/variable/runtime/runtime_variable.go

@@ -28,6 +28,7 @@ var Locations = []string{
 	"/dev/replacePods/*/replaceImage",
 	"/dev/terminal/imageSelector",
 	"/pipelines/**",
+	"/commands/**",
 }
 
 // NewRuntimeVariable creates a new variable that is loaded during runtime

pkg/devspace/dependency/dependency.go

@@ -1,13 +1,11 @@
 package dependency
 
 import (
-	"context"
 	"github.com/loft-sh/devspace/pkg/devspace/config"
 	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 	"github.com/loft-sh/devspace/pkg/devspace/dependency/types"
 	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
-	"os"
 )
 
 // Dependency holds the dependency config and has an id
@@ -41,10 +39,6 @@ func (d *Dependency) DependencyConfig() *latest.DependencyConfig { return d.depe
 
 func (d *Dependency) Children() []types.Dependency { return d.children }
 
-func (d *Dependency) Command(ctx context.Context, command string, args []string) error {
-	return ExecuteCommand(ctx, d.localConfig.Config().Commands, command, args, d.absolutePath, os.Stdout, os.Stderr, os.Stdin)
-}
-
 func skipDependency(name string, skipDependencies []string) bool {
 	for _, sd := range skipDependencies {
 		if sd == name {

pkg/devspace/dependency/manager.go

@@ -2,21 +2,15 @@ package dependency
 
 import (
 	"bytes"
-	"context"
 	"github.com/loft-sh/devspace/pkg/devspace/build"
-	"github.com/loft-sh/devspace/pkg/devspace/command"
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader"
-	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
 	"github.com/loft-sh/devspace/pkg/devspace/dependency/types"
 	"github.com/loft-sh/devspace/pkg/devspace/hook"
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"
-	"github.com/loft-sh/devspace/pkg/util/exit"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
-	"io"
-	"mvdan.cc/sh/v3/interp"
 	"strings"
 )
 
@@ -53,22 +47,6 @@ func (m *manager) ResolveAll(ctx *devspacecontext.Context, options ResolveOption
 	return dependencies, nil
 }
 
-// ExecuteCommand executes a given command from the available commands
-func ExecuteCommand(ctx context.Context, commands map[string]*latest.CommandConfig, cmd string, args []string, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader) error {
-	err := command.ExecuteCommand(ctx, commands, cmd, args, dir, stdout, stderr, stdin)
-	if err != nil {
-		if status, ok := interp.IsExitStatus(err); ok {
-			return &exit.ReturnCodeError{
-				ExitCode: int(status),
-			}
-		}
-
-		return errors.Wrap(err, "execute command")
-	}
-
-	return nil
-}
-
 // BuildOptions has all options for building all dependencies
 type BuildOptions struct {
 	BuildOptions build.Options

pkg/devspace/dependency/resolver.go

@@ -203,7 +203,7 @@ func (r *resolver) resolveDependency(ctx *devspacecontext.Context, dependencyCon
 			return err
 		}
 
-		dConfigWrapper, err = configLoader.LoadWithParser(ctx.Context, nil, client, loader.NewWithCommandsParser(), cloned, ctx.Log)
+		dConfigWrapper, err = configLoader.Load(ctx.Context, client, cloned, ctx.Log)
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("loading config for dependency %s", dependencyName))
 		}