mirror of https://github.com/databricks/cli.git
99 lines
3.4 KiB
Go
99 lines
3.4 KiB
Go
package mutator
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/databricks/cli/bundle"
|
|
"github.com/databricks/cli/libs/diag"
|
|
"github.com/databricks/cli/libs/dyn"
|
|
"github.com/databricks/cli/libs/dyn/convert"
|
|
"github.com/databricks/cli/libs/dyn/dynvar"
|
|
"github.com/databricks/cli/libs/log"
|
|
)
|
|
|
|
type resolveVariableReferences struct {
|
|
prefixes []string
|
|
}
|
|
|
|
func ResolveVariableReferences(prefixes ...string) bundle.Mutator {
|
|
return &resolveVariableReferences{prefixes: prefixes}
|
|
}
|
|
|
|
func (*resolveVariableReferences) Name() string {
|
|
return "ResolveVariableReferences"
|
|
}
|
|
|
|
func (m *resolveVariableReferences) Validate(ctx context.Context, b *bundle.Bundle) error {
|
|
return nil
|
|
}
|
|
|
|
func (m *resolveVariableReferences) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
prefixes := make([]dyn.Path, len(m.prefixes))
|
|
for i, prefix := range m.prefixes {
|
|
prefixes[i] = dyn.MustPathFromString(prefix)
|
|
}
|
|
|
|
// The path ${var.foo} is a shorthand for ${variables.foo.value}.
|
|
// We rewrite it here to make the resolution logic simpler.
|
|
varPath := dyn.NewPath(dyn.Key("var"))
|
|
|
|
err := b.Config.Mutate(func(root dyn.Value) (dyn.Value, error) {
|
|
// Synthesize a copy of the root that has all fields that are present in the type
|
|
// but not set in the dynamic value set to their corresponding empty value.
|
|
// This enables users to interpolate variable references to fields that haven't
|
|
// been explicitly set in the dynamic value.
|
|
//
|
|
// For example: ${bundle.git.origin_url} should resolve to an empty string
|
|
// if a bundle isn't located in a Git repository (yet).
|
|
//
|
|
// This is consistent with the behavior prior to using the dynamic value system.
|
|
//
|
|
// We can ignore the diagnostics return valuebecause we know that the dynamic value
|
|
// has already been normalized when it was first loaded from the configuration file.
|
|
//
|
|
normalized, _ := convert.Normalize(b.Config, root, convert.IncludeMissingFields)
|
|
lookup := func(path dyn.Path) (dyn.Value, error) {
|
|
// Future opportunity: if we lookup this path in both the given root
|
|
// and the synthesized root, we know if it was explicitly set or implied to be empty.
|
|
// Then we can emit a warning if it was not explicitly set.
|
|
return dyn.GetByPath(normalized, path)
|
|
}
|
|
|
|
// Resolve variable references in all values.
|
|
root, err := dynvar.Resolve(root, func(path dyn.Path) (dyn.Value, error) {
|
|
// Rewrite the shorthand path ${var.foo} into ${variables.foo.value}.
|
|
if path.HasPrefix(varPath) && len(path) == 2 {
|
|
path = dyn.NewPath(
|
|
dyn.Key("variables"),
|
|
path[1],
|
|
dyn.Key("value"),
|
|
)
|
|
}
|
|
|
|
// Perform resolution only if the path starts with one of the specified prefixes.
|
|
for _, prefix := range prefixes {
|
|
if path.HasPrefix(prefix) {
|
|
return lookup(path)
|
|
}
|
|
}
|
|
|
|
return dyn.InvalidValue, dynvar.ErrSkipResolution
|
|
})
|
|
if err != nil {
|
|
return dyn.InvalidValue, err
|
|
}
|
|
|
|
// Normalize the result because variable resolution may have been applied to non-string fields.
|
|
// For example, a variable reference may have been resolved to a integer.
|
|
root, diags := convert.Normalize(b.Config, root)
|
|
for _, diag := range diags {
|
|
// This occurs when a variable's resolved value is incompatible with the field's type.
|
|
// Log a warning until we have a better way to surface these diagnostics to the user.
|
|
log.Warnf(ctx, "normalization diagnostic: %s", diag.Summary)
|
|
}
|
|
return root, nil
|
|
})
|
|
|
|
return diag.FromErr(err)
|
|
}
|