Merge pull request #2086 from mcastellini/print_eager_vars

Resolve all config paths at the same time for devspace print

Author: FabianKramm

cmd/print.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"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/versions/latest"
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
 	"github.com/loft-sh/devspace/pkg/devspace/dependency"
@@ -87,8 +88,10 @@ func (cmd *PrintCmd) Run(f factory.Factory) error {
 		log.Warnf("Unable to create new kubectl client: %v", err)
 	}
 
+	parser := loader.NewEagerParser()
+
 	// load config
-	config, err := configLoader.Load(context.Background(), client, configOptions, log)
+	config, err := configLoader.LoadWithParser(context.Background(), nil, client, parser, configOptions, log)
 	if err != nil {
 		return err
 	}
@@ -99,7 +102,7 @@ func (cmd *PrintCmd) Run(f factory.Factory) error {
 		WithKubeClient(client)
 
 	// resolve dependencies
-	dependencies, err := dependency.NewManager(ctx, configOptions).ResolveAll(ctx, dependency.ResolveOptions{})
+	dependencies, err := dependency.NewManagerWithParser(ctx, configOptions, parser).ResolveAll(ctx, dependency.ResolveOptions{})
 	if err != nil {
 		log.Warnf("Error resolving dependencies: %v", err)
 	}

pkg/devspace/config/loader/parser.go

@@ -29,7 +29,7 @@ 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
-	return fillVariablesAndParse(ctx, resolver, rawConfig, log)
+	return fillVariablesExcludeAndParse(ctx, resolver, rawConfig, log)
 }
 
 func NewCommandsPipelinesParser() Parser {
@@ -45,7 +45,7 @@ func (c *commandsPipelinesParser) Parse(ctx context.Context, originalRawConfig m
 		return nil, nil, err
 	}
 
-	return fillVariablesAndParse(ctx, resolver, preparedConfig, log)
+	return fillVariablesExcludeAndParse(ctx, resolver, preparedConfig, log)
 }
 
 func NewCommandsParser() Parser {
@@ -61,7 +61,7 @@ func (c *commandsParser) Parse(ctx context.Context, originalRawConfig map[string
 		return nil, nil, err
 	}
 
-	return fillVariablesAndParse(ctx, resolver, preparedConfig, log)
+	return fillVariablesExcludeAndParse(ctx, resolver, preparedConfig, log)
 }
 
 func NewProfilesParser() Parser {
@@ -106,9 +106,27 @@ func (p *profilesParser) Parse(ctx context.Context, originalRawConfig map[string
 	return retConfig, rawMap, nil
 }
 
-func fillVariablesAndParse(ctx context.Context, resolver variable.Resolver, preparedConfig map[string]interface{}, log log.Logger) (*latest.Config, map[string]interface{}, error) {
+func NewEagerParser() Parser {
+	return &eagerParser{}
+}
+
+type eagerParser struct{}
+
+func (e *eagerParser) 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 fillAllVariablesAndParse(ctx, resolver, rawConfig, log)
+}
+
+func fillAllVariablesAndParse(ctx context.Context, resolver variable.Resolver, preparedConfig map[string]interface{}, log log.Logger) (*latest.Config, map[string]interface{}, error) {
+	return fillVariablesAndParse(ctx, resolver, preparedConfig, log)
+}
+
+func fillVariablesExcludeAndParse(ctx context.Context, resolver variable.Resolver, preparedConfig map[string]interface{}, log log.Logger) (*latest.Config, map[string]interface{}, error) {
+	return fillVariablesAndParse(ctx, resolver, preparedConfig, log, runtime.Locations...)
+}
+
+func fillVariablesAndParse(ctx context.Context, resolver variable.Resolver, preparedConfig map[string]interface{}, log log.Logger, excludedPaths ...string) (*latest.Config, map[string]interface{}, error) {
 	// fill in variables and expressions (leave out
-	preparedConfigInterface, err := resolver.FillVariablesExclude(ctx, preparedConfig, runtime.Locations)
+	preparedConfigInterface, err := resolver.FillVariablesExclude(ctx, preparedConfig, excludedPaths)
 	if err != nil {
 		return nil, nil, err
 	}

pkg/devspace/dependency/manager.go

@@ -31,6 +31,12 @@ func NewManager(ctx devspacecontext.Context, configOptions *loader.ConfigOptions
 	}
 }
 
+func NewManagerWithParser(ctx devspacecontext.Context, configOptions *loader.ConfigOptions, parser loader.Parser) Manager {
+	return &manager{
+		resolver: NewResolver(ctx, configOptions).WithParser(parser),
+	}
+}
+
 type ResolveOptions struct {
 	SkipDependencies []string
 	Dependencies     []string

pkg/devspace/dependency/resolver.go

@@ -24,6 +24,7 @@ import (
 // ResolverInterface defines the resolver interface that takes dependency configs and resolves them
 type ResolverInterface interface {
 	Resolve(ctx devspacecontext.Context) ([]types.Dependency, error)
+	WithParser(parser loader.Parser) ResolverInterface
 }
 
 // Resolver implements the resolver interface
@@ -32,6 +33,7 @@ type resolver struct {
 
 	BaseCache  localcache.Cache
 	BaseConfig *latest.Config
+	BaseParser loader.Parser
 
 	ConfigOptions *loader.ConfigOptions
 }
@@ -90,6 +92,16 @@ func (r *resolver) Resolve(ctx devspacecontext.Context) ([]types.Dependency, err
 	return children, nil
 }
 
+func (r *resolver) WithParser(parser loader.Parser) ResolverInterface {
+	if r == nil {
+		return nil
+	}
+
+	n := *r
+	n.BaseParser = parser
+	return &n
+}
+
 func (r *resolver) resolveRecursive(ctx devspacecontext.Context, basePath, parentConfigName string, currentDependency *Dependency, dependencies []*latest.DependencyConfig) error {
 	if currentDependency != nil {
 		currentDependency.children = []types.Dependency{}
@@ -206,7 +218,11 @@ func (r *resolver) resolveDependency(ctx devspacecontext.Context, dependencyConf
 			return err
 		}
 
-		dConfigWrapper, err = configLoader.Load(ctx.Context(), client, cloned, ctx.Log())
+		if r.BaseParser == nil {
+			dConfigWrapper, err = configLoader.Load(ctx.Context(), client, cloned, ctx.Log())
+		} else {
+			dConfigWrapper, err = configLoader.LoadWithParser(ctx.Context(), nil, client, r.BaseParser, cloned, ctx.Log())
+		}
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("loading config for dependency %s", dependencyName))
 		}