fix: variable resolver issue

Author: FabianKramm

cmd/run.go

@@ -77,7 +77,7 @@ devspace --dependency my-dependency run any-command --any-command-flag
 
 	if rawConfig != nil && rawConfig.Config != nil {
 		for _, cmd := range rawConfig.Config.Commands {
-			runCmd.AddCommand(NewSpecificRunCommand(f, globalFlags, cmd, rawConfig.Resolver.ResolvedVariables()))
+			runCmd.AddCommand(NewSpecificRunCommand(cmd))
 		}
 	}
 	runCmd.Flags().StringVar(&cmd.Dependency, "dependency", "", "Run a command from a specific dependency")
@@ -309,7 +309,7 @@ func ExecuteCommand(ctx context.Context, cmd *latest.CommandConfig, variables ma
 	return command.CommandWithEnv(ctx, dir, stdout, stderr, stdin, extraEnv, shellCommand, shellArgs...)
 }
 
-// RunCommandCmd holds the cmd flags of an run command
+// RunCommandCmd holds the cmd flags of a run command
 type RunCommandCmd struct {
 	*flags.GlobalFlags
 
@@ -321,15 +321,7 @@ type RunCommandCmd struct {
 }
 
 // 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,
-	}
-
+func NewSpecificRunCommand(command *latest.CommandConfig) *cobra.Command {
 	description := command.Description
 	longDescription := command.Description
 	if description == "" {
@@ -348,24 +340,9 @@ func NewSpecificRunCommand(f factory.Factory, globalFlags *flags.GlobalFlags, co
 		Long:  longDescription,
 		Args:  cobra.ArbitraryArgs,
 		RunE: func(cobraCmd *cobra.Command, originalArgs []string) error {
-			args, err := ParseArgs(cobraCmd, cmd.GlobalFlags, f.GetLog())
-			if err != nil {
-				return err
-			}
-
-			if cmd.ConfigPath != "" {
-				return cobraCmd.Parent().RunE(cobraCmd, originalArgs)
-			}
-
-			plugin.SetPluginCommand(cobraCmd, args)
-			return cmd.Run(f, args)
+			return cobraCmd.Parent().RunE(cobraCmd, originalArgs)
 		},
 	}
 	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())
-}

pkg/devspace/config/loader/variable/resolver.go

@@ -23,23 +23,32 @@ var AlwaysResolvePredefinedVars = []string{"DEVSPACE_NAME", "DEVSPACE_TMPDIR", "
 // NewResolver creates a new resolver that caches resolved variables in memory and in the provided cache
 func NewResolver(localCache localcache.Cache, predefinedVariableOptions *PredefinedVariableOptions, flags []string, log log.Logger) (Resolver, error) {
 	memoryCache := map[string]interface{}{}
+	err := MergeVarsWithFlags(memoryCache, flags)
+	if err != nil {
+		return nil, err
+	}
+
+	return &resolver{
+		memoryCache: memoryCache,
+		localCache:  localCache,
+		options:     predefinedVariableOptions,
+		log:         log,
+	}, nil
+}
+
+func MergeVarsWithFlags(vars map[string]interface{}, flags []string) error {
 	for _, cmdVar := range flags {
 		idx := strings.Index(cmdVar, "=")
 		if idx == -1 {
-			return nil, errors.Errorf("wrong --var format: %s, expected 'key=val'", cmdVar)
+			return errors.Errorf("wrong --var format: %s, expected 'key=val'", cmdVar)
 		}
 
 		name := strings.TrimSpace(cmdVar[:idx])
 		value := convertStringValue(strings.TrimSpace(cmdVar[idx+1:]))
-		memoryCache[name] = value
+		vars[name] = value
 	}
 
-	return &resolver{
-		memoryCache: memoryCache,
-		localCache:  localCache,
-		options:     predefinedVariableOptions,
-		log:         log,
-	}, nil
+	return nil
 }
 
 type resolver struct {