refactor: rename variables and forbid command overwrite

Author: FabianKramm

cmd/overwrite_command.go

@@ -260,29 +260,17 @@ Additional run commands:
 	rootCmd.AddCommand(NewCompletionCmd())
 
 	// check overwrite commands
-	rootCmd.AddCommand(replaceCommand("dev", rawConfig, f, globalFlags, NewDevCmd))
-	rootCmd.AddCommand(replaceCommand("deploy", rawConfig, f, globalFlags, NewDeployCmd))
-	rootCmd.AddCommand(replaceCommand("build", rawConfig, f, globalFlags, NewBuildCmd))
-	rootCmd.AddCommand(replaceCommand("purge", rawConfig, f, globalFlags, NewPurgeCmd))
+	rootCmd.AddCommand(NewDevCmd(f, globalFlags))
+	rootCmd.AddCommand(NewDeployCmd(f, globalFlags))
+	rootCmd.AddCommand(NewBuildCmd(f, globalFlags))
+	rootCmd.AddCommand(NewPurgeCmd(f, globalFlags))
 
 	// Add plugin commands
 	plugin.AddPluginCommands(rootCmd, plugins, "")
 	variable.AddPredefinedVars(plugins)
 	return rootCmd
 }
 
-func replaceCommand(command string, rawConfig *RawConfig, f factory.Factory, globalFlags *flags.GlobalFlags, fallback func(f factory.Factory, globalFlags *flags.GlobalFlags) *cobra.Command) *cobra.Command {
-	if rawConfig != nil && rawConfig.CommandsConfig != nil && rawConfig.Resolver != nil && rawConfig.CommandsConfig.Commands != nil {
-		// get command
-		overwriteCommand, ok := rawConfig.CommandsConfig.Commands[command]
-		if ok && !overwriteCommand.DisableReplace {
-			return NewOverwriteCmd(f, globalFlags, overwriteCommand, rawConfig.Resolver.ResolvedVariables())
-		}
-	}
-
-	return fallback(f, globalFlags)
-}
-
 func disableKlog() {
 	flagSet := &flag.FlagSet{}
 	klog.InitFlags(flagSet)

cmd/root.go

@@ -77,7 +77,7 @@ devspace --dependency my-dependency run any-command --any-command-flag
 
 	if rawConfig != nil && rawConfig.CommandsConfig != nil {
 		for _, cmd := range rawConfig.CommandsConfig.Commands {
-			runCmd.AddCommand(NewOverwriteCmd(f, globalFlags, cmd, rawConfig.Resolver.ResolvedVariables()))
+			runCmd.AddCommand(NewSpecificRunCommand(f, globalFlags, cmd, rawConfig.Resolver.ResolvedVariables()))
 		}
 	}
 	runCmd.Flags().StringVar(&cmd.Dependency, "dependency", "", "Run a command from a specific dependency")
@@ -308,3 +308,60 @@ func ExecuteCommand(ctx context.Context, cmd *latest.CommandConfig, variables ma
 	shellArgs = append(shellArgs, args...)
 	return command.CommandWithEnv(ctx, dir, stdout, stderr, stdin, extraEnv, shellCommand, shellArgs...)
 }
+
+// RunCommandCmd holds the cmd flags of an run command
+type RunCommandCmd struct {
+	*flags.GlobalFlags
+
+	Command   *latest.CommandConfig
+	Variables map[string]interface{}
+
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewSpecificRunCommand creates a new run command
+func NewSpecificRunCommand(f factory.Factory, globalFlags *flags.GlobalFlags, command *latest.CommandConfig, variables map[string]interface{}) *cobra.Command {
+	cmd := &RunCommandCmd{
+		GlobalFlags: globalFlags,
+		Command:     command,
+		Variables:   variables,
+		Stdout:      os.Stdout,
+		Stderr:      os.Stderr,
+	}
+
+	description := command.Description
+	longDescription := command.Description
+	if description == "" {
+		description = "Runs command: " + command.Name
+		longDescription = description
+	}
+	if len(description) > 64 {
+		if len(description) > 64 {
+			description = description[:61] + "..."
+		}
+	}
+
+	runCmd := &cobra.Command{
+		Use:   command.Name,
+		Short: description,
+		Long:  longDescription,
+		Args:  cobra.ArbitraryArgs,
+		RunE: func(cobraCmd *cobra.Command, _ []string) error {
+			args, err := ParseArgs(cobraCmd, cmd.GlobalFlags, f.GetLog())
+			if err != nil {
+				return err
+			}
+
+			plugin.SetPluginCommand(cobraCmd, args)
+			return cmd.Run(f, args)
+		},
+	}
+	runCmd.DisableFlagParsing = true
+	return runCmd
+}
+
+func (cmd *RunCommandCmd) Run(f factory.Factory, args []string) error {
+	devCtx := devspacecontext.NewContext(context.Background(), cmd.Variables, f.GetLog())
+	return executeCommandWithAfter(devCtx.Context(), cmd.Command, args, cmd.Variables, devCtx.WorkingDir(), cmd.Stdout, cmd.Stderr, os.Stdin, devCtx.Log())
+}

cmd/run.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"github.com/loft-sh/devspace/cmd/flags"
 	"github.com/loft-sh/devspace/pkg/devspace/build"
-	config2 "github.com/loft-sh/devspace/pkg/devspace/config"
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader"
 	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
@@ -27,8 +26,6 @@ import (
 	"github.com/loft-sh/devspace/pkg/util/interrupt"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/loft-sh/devspace/pkg/util/message"
-	"github.com/loft-sh/devspace/pkg/util/ptr"
-	"github.com/loft-sh/devspace/pkg/util/survey"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -62,8 +59,6 @@ type RunPipelineCmd struct {
 	ForceDeploy bool
 	SkipDeploy  bool
 
-	Terminal bool
-
 	ShowUI bool
 
 	// used for testing to allow interruption
@@ -91,7 +86,6 @@ func (cmd *RunPipelineCmd) AddFlags(command *cobra.Command) {
 	command.Flags().BoolVar(&cmd.SkipPush, "skip-push", cmd.SkipPush, "Skips image pushing, useful for minikube deployment")
 	command.Flags().BoolVar(&cmd.SkipPushLocalKubernetes, "skip-push-local-kube", cmd.SkipPushLocalKubernetes, "Skips image pushing, if a local kubernetes environment is detected")
 
-	command.Flags().BoolVar(&cmd.Terminal, "terminal", cmd.Terminal, "Open a terminal instead of showing logs")
 	command.Flags().BoolVar(&cmd.ShowUI, "show-ui", cmd.ShowUI, "Shows the ui server")
 }
 
@@ -110,14 +104,8 @@ func NewRunPipelineCmd(f factory.Factory, globalFlags *flags.GlobalFlags) *cobra
 #######################################################
 Execute a pipeline
 #######################################################`,
-		Args: cobra.MaximumNArgs(1),
+		Args: cobra.ArbitraryArgs,
 		RunE: func(cobraCmd *cobra.Command, args []string) error {
-			if len(args) == 0 && cmd.Pipeline == "" {
-				return fmt.Errorf("please specify a pipeline through --pipeline or argument")
-			} else if len(args) == 1 && cmd.Pipeline == "" {
-				cmd.Pipeline = args[0]
-			}
-
 			return cmd.Run(cobraCmd, args, f, "run-pipeline", "runPipelineCommand")
 		},
 	}
@@ -132,6 +120,20 @@ func (cmd *RunPipelineCmd) RunDefault(f factory.Factory) error {
 
 // Run executes the command logic
 func (cmd *RunPipelineCmd) Run(cobraCmd *cobra.Command, args []string, f factory.Factory, commandName, hookName string) error {
+	dashArgs := []string{}
+	if cobraCmd.ArgsLenAtDash() > -1 {
+		dashArgs = args[cobraCmd.ArgsLenAtDash():]
+		args = args[:cobraCmd.ArgsLenAtDash()]
+	}
+
+	if len(args) > 1 {
+		return fmt.Errorf("please specify only 1 pipeline to execute. E.g. devspace run-pipeline my-pipe -- other args")
+	} else if len(args) == 0 && cmd.Pipeline == "" {
+		return fmt.Errorf("please specify a pipeline through --pipeline or argument")
+	} else if len(args) == 1 && cmd.Pipeline == "" {
+		cmd.Pipeline = args[0]
+	}
+
 	if cmd.log == nil {
 		cmd.log = f.GetLog()
 	}
@@ -157,15 +159,15 @@ func (cmd *RunPipelineCmd) Run(cobraCmd *cobra.Command, args []string, f factory
 	}
 
 	// set command in context
-	cmd.Ctx = values.WithCommand(cmd.Ctx, commandName)
+	cmd.Ctx = values.WithFlags(cmd.Ctx, cobraCmd.Flags())
 	options := cmd.BuildOptions(cmd.ToConfigOptions())
 	ctx, err := initialize(cmd.Ctx, f, false, options, cmd.log)
 	if err != nil {
 		return err
 	}
 
 	return runWithHooks(ctx, hookName, func() error {
-		return runPipeline(ctx, options)
+		return runPipeline(ctx, dashArgs, options)
 	})
 }
 
@@ -176,7 +178,6 @@ type CommandOptions struct {
 	ConfigOptions *loader.ConfigOptions
 
 	Pipeline string
-	Terminal bool
 	ShowUI   bool
 	UIPort   int
 }
@@ -245,12 +246,6 @@ func initialize(ctx context.Context, f factory.Factory, allowFailingKubeClient b
 	// add root name to context
 	ctx = values.WithRootName(ctx, configInterface.Config().Name)
 
-	// adjust config
-	err = adjustConfig(configInterface, options, logger)
-	if err != nil {
-		return nil, err
-	}
-
 	// create devspace context
 	devCtx := devspacecontext.NewContext(ctx, configInterface.Variables(), logger).
 		WithConfig(configInterface).
@@ -295,50 +290,6 @@ func updateLastKubeContext(ctx devspacecontext.Context) error {
 	return nil
 }
 
-func adjustConfig(conf config2.Config, options *CommandOptions, log log.Logger) error {
-	// check if terminal is enabled
-	c := conf.Config()
-	if options.Terminal {
-		if len(c.Dev) == 0 {
-			return errors.New("No dev config available in DevSpace config")
-		}
-
-		devNames := make([]string, 0, len(c.Dev))
-		for k := range c.Dev {
-			devNames = append(devNames, k)
-		}
-
-		// if only one image exists, use it, otherwise show image picker
-		devName := ""
-		if len(devNames) == 1 {
-			devName = devNames[0]
-		} else {
-			var err error
-			devName, err = log.Question(&survey.QuestionOptions{
-				Question: "Where do you want to open a terminal to?",
-				Options:  devNames,
-			})
-			if err != nil {
-				return err
-			}
-		}
-
-		// adjust dev config
-		for k := range c.Dev {
-			if k == devName {
-				if c.Dev[devName].Terminal == nil {
-					c.Dev[devName].Terminal = &latest.Terminal{}
-				}
-				c.Dev[devName].Terminal.Enabled = ptr.Bool(true)
-			} else {
-				c.Dev[devName].Terminal = nil
-			}
-		}
-	}
-
-	return nil
-}
-
 func runWithHooks(ctx devspacecontext.Context, command string, fn func() error) (err error) {
 	err = hook.ExecuteHooks(ctx, nil, command+":before:execute")
 	if err != nil {
@@ -405,13 +356,12 @@ func (cmd *RunPipelineCmd) BuildOptions(configOptions *loader.ConfigOptions) *Co
 			},
 		},
 		ConfigOptions: configOptions,
-		Terminal:      cmd.Terminal,
 		Pipeline:      cmd.Pipeline,
 		ShowUI:        cmd.ShowUI,
 	}
 }
 
-func runPipeline(ctx devspacecontext.Context, options *CommandOptions) error {
+func runPipeline(ctx devspacecontext.Context, args []string, options *CommandOptions) error {
 	var configPipeline *latest.Pipeline
 	if ctx.Config().Config().Pipelines != nil && ctx.Config().Config().Pipelines[options.Pipeline] != nil {
 		configPipeline = ctx.Config().Config().Pipelines[options.Pipeline]
@@ -459,7 +409,7 @@ func runPipeline(ctx devspacecontext.Context, options *CommandOptions) error {
 	defer stderrWriter.Close()
 
 	// start pipeline
-	err = pipe.Run(ctx.WithLogger(log.NewStreamLoggerWithFormat(stdoutWriter, stderrWriter, ctx.Log().GetLevel(), log.TimeFormat)))
+	err = pipe.Run(ctx.WithLogger(log.NewStreamLoggerWithFormat(stdoutWriter, stderrWriter, ctx.Log().GetLevel(), log.TimeFormat)), args)
 	if err != nil {
 		return err
 	}

cmd/run_pipeline.go

@@ -10,9 +10,9 @@ deployments:
 pipelines:
   deploy:
     run: |-
-      echo '{"helm": {"values": {"containers": [{"image":"alpine"}]}}}' > ${devspace.tempFolder}/deployment.yaml
+      echo '{"helm": {"values": {"containers": [{"image":"alpine"}]}}}' > ${DEVSPACE_TMPDIR}/deployment.yaml
       
-      create_deployments test1 test2 test3 test4 --from-file test1:${devspace.tempFolder}/deployment.yaml \
+      create_deployments test1 test2 test3 test4 --from-file test1:${DEVSPACE_TMPDIR}/deployment.yaml \
                                                  --from test2:base \
                                                  --set test3:helm.values.containers[0].image=alpine \
                                                  --set-string test4:helm.values.containers[0].image=alpine \

e2e/tests/deploy/testdata/helm_concurrent_new/devspace.yaml

@@ -20,7 +20,7 @@ pipelines:
   deploy:
     run: |-
       echo ${devspace.name} > name.txt
-      echo ${devspace.tempFolder} > temp.txt
+      echo ${DEVSPACE_TMPDIR} > temp.txt
       
       run_dependency_pipelines --all > dependency.txt
       

e2e/tests/imports/testdata/local/devspace.yaml

@@ -12,4 +12,4 @@ pipelines:
     run: |-
       echo ${IMPORT3}
       echo ${devspace.name} > dependency-name.txt
-      echo ${devspace.tempFolder} > dependency-temp.txt
+      echo ${DEVSPACE_TMPDIR} > dependency-temp.txt