Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
package mutator
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"context"
|
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
|
|
"github.com/databricks/cli/bundle"
|
|
|
|
|
"github.com/databricks/cli/bundle/config"
|
|
|
|
|
"github.com/databricks/cli/bundle/config/resources"
|
|
|
|
|
"github.com/databricks/cli/bundle/config/variable"
|
2024-03-25 14:18:47 +00:00
|
|
|
"github.com/databricks/cli/libs/diag"
|
2024-02-19 10:44:51 +00:00
|
|
|
"github.com/databricks/cli/libs/dyn"
|
|
|
|
|
"github.com/databricks/databricks-sdk-go/service/compute"
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
"github.com/databricks/databricks-sdk-go/service/jobs"
|
2024-02-19 10:44:51 +00:00
|
|
|
"github.com/stretchr/testify/assert"
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
func TestResolveVariableReferences(t *testing.T) {
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Bundle: config.Bundle{
|
|
|
|
|
Name: "example",
|
|
|
|
|
},
|
|
|
|
|
Workspace: config.Workspace{
|
|
|
|
|
RootPath: "${bundle.name}/bar",
|
|
|
|
|
FilePath: "${workspace.root_path}/baz",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Apply with an invalid prefix. This should not change the workspace root path.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags := bundle.Apply(context.Background(), b, ResolveVariableReferences("doesntexist"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
require.Equal(t, "${bundle.name}/bar", b.Config.Workspace.RootPath)
|
|
|
|
|
require.Equal(t, "${workspace.root_path}/baz", b.Config.Workspace.FilePath)
|
|
|
|
|
|
|
|
|
|
// Apply with a valid prefix. This should change the workspace root path.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags = bundle.Apply(context.Background(), b, ResolveVariableReferences("bundle", "workspace"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
require.Equal(t, "example/bar", b.Config.Workspace.RootPath)
|
|
|
|
|
require.Equal(t, "example/bar/baz", b.Config.Workspace.FilePath)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestResolveVariableReferencesToBundleVariables(t *testing.T) {
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Bundle: config.Bundle{
|
|
|
|
|
Name: "example",
|
|
|
|
|
},
|
|
|
|
|
Workspace: config.Workspace{
|
|
|
|
|
RootPath: "${bundle.name}/${var.foo}",
|
|
|
|
|
},
|
|
|
|
|
Variables: map[string]*variable.Variable{
|
|
|
|
|
"foo": {
|
2024-06-26 10:25:32 +00:00
|
|
|
Value: "bar",
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Apply with a valid prefix. This should change the workspace root path.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags := bundle.Apply(context.Background(), b, ResolveVariableReferences("bundle", "variables"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
require.Equal(t, "example/bar", b.Config.Workspace.RootPath)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestResolveVariableReferencesToEmptyFields(t *testing.T) {
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Bundle: config.Bundle{
|
|
|
|
|
Name: "example",
|
|
|
|
|
Git: config.Git{
|
|
|
|
|
Branch: "",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
Resources: config.Resources{
|
|
|
|
|
Jobs: map[string]*resources.Job{
|
|
|
|
|
"job1": {
|
|
|
|
|
JobSettings: &jobs.JobSettings{
|
|
|
|
|
Tags: map[string]string{
|
|
|
|
|
"git_branch": "${bundle.git.branch}",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Apply for the bundle prefix.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags := bundle.Apply(context.Background(), b, ResolveVariableReferences("bundle"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
Use dynamic configuration model in bundles (#1098)
## Changes
This is a fundamental change to how we load and process bundle
configuration. We now depend on the configuration being represented as a
`dyn.Value`. This representation is functionally equivalent to Go's
`any` (it is variadic) and allows us to capture metadata associated with
a value, such as where it was defined (e.g. file, line, and column). It
also allows us to represent Go's zero values properly (e.g. empty
string, integer equal to 0, or boolean false).
Using this representation allows us to let the configuration model
deviate from the typed structure we have been relying on so far
(`config.Root`). We need to deviate from these types when using
variables for fields that are not a string themselves. For example,
using `${var.num_workers}` for an integer `workers` field was impossible
until now (though not implemented in this change).
The loader for a `dyn.Value` includes functionality to capture any and
all type mismatches between the user-defined configuration and the
expected types. These mismatches can be surfaced as validation errors in
future PRs.
Given that many mutators expect the typed struct to be the source of
truth, this change converts between the dynamic representation and the
typed representation on mutator entry and exit. Existing mutators can
continue to modify the typed representation and these modifications are
reflected in the dynamic representation (see `MarkMutatorEntry` and
`MarkMutatorExit` in `bundle/config/root.go`).
Required changes included in this change:
* The existing interpolation package is removed in favor of
`libs/dyn/dynvar`.
* Functionality to merge job clusters, job tasks, and pipeline clusters
are now all broken out into their own mutators.
To be implemented later:
* Allow variable references for non-string types.
* Surface diagnostics about the configuration provided by the user in
the validation output.
* Some mutators use a resource's configuration file path to resolve
related relative paths. These depend on `bundle/config/paths.Path` being
set and populated through `ConfigureConfigFilePath`. Instead, they
should interact with the dynamically typed configuration directly. Doing
this also unlocks being able to differentiate different base paths used
within a job (e.g. a task override with a relative path defined in a
directory other than the base job).
## Tests
* Existing unit tests pass (some have been modified to accommodate)
* Integration tests pass
2024-02-16 19:41:58 +00:00
|
|
|
|
|
|
|
|
// The job settings should have been interpolated to an empty string.
|
|
|
|
|
require.Equal(t, "", b.Config.Resources.Jobs["job1"].JobSettings.Tags["git_branch"])
|
|
|
|
|
}
|
2024-02-19 10:44:51 +00:00
|
|
|
|
|
|
|
|
func TestResolveVariableReferencesForPrimitiveNonStringFields(t *testing.T) {
|
2024-03-25 14:18:47 +00:00
|
|
|
var diags diag.Diagnostics
|
2024-02-19 10:44:51 +00:00
|
|
|
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Variables: map[string]*variable.Variable{
|
|
|
|
|
"no_alert_for_canceled_runs": {},
|
|
|
|
|
"no_alert_for_skipped_runs": {},
|
|
|
|
|
"min_workers": {},
|
|
|
|
|
"max_workers": {},
|
|
|
|
|
"spot_bid_max_price": {},
|
|
|
|
|
},
|
|
|
|
|
Resources: config.Resources{
|
|
|
|
|
Jobs: map[string]*resources.Job{
|
|
|
|
|
"job1": {
|
|
|
|
|
JobSettings: &jobs.JobSettings{
|
|
|
|
|
NotificationSettings: &jobs.JobNotificationSettings{
|
|
|
|
|
NoAlertForCanceledRuns: false,
|
|
|
|
|
NoAlertForSkippedRuns: false,
|
|
|
|
|
},
|
|
|
|
|
Tasks: []jobs.Task{
|
|
|
|
|
{
|
|
|
|
|
NewCluster: &compute.ClusterSpec{
|
|
|
|
|
Autoscale: &compute.AutoScale{
|
|
|
|
|
MinWorkers: 0,
|
|
|
|
|
MaxWorkers: 0,
|
|
|
|
|
},
|
|
|
|
|
AzureAttributes: &compute.AzureAttributes{
|
|
|
|
|
SpotBidMaxPrice: 0.0,
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ctx := context.Background()
|
|
|
|
|
|
|
|
|
|
// Initialize the variables.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags = bundle.ApplyFunc(ctx, b, func(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
|
|
|
err := b.Config.InitializeVariables([]string{
|
2024-02-19 10:44:51 +00:00
|
|
|
"no_alert_for_canceled_runs=true",
|
|
|
|
|
"no_alert_for_skipped_runs=true",
|
|
|
|
|
"min_workers=1",
|
|
|
|
|
"max_workers=2",
|
|
|
|
|
"spot_bid_max_price=0.5",
|
|
|
|
|
})
|
2024-03-25 14:18:47 +00:00
|
|
|
return diag.FromErr(err)
|
2024-02-19 10:44:51 +00:00
|
|
|
})
|
2024-03-25 14:18:47 +00:00
|
|
|
require.NoError(t, diags.Error())
|
2024-02-19 10:44:51 +00:00
|
|
|
|
|
|
|
|
// Assign the variables to the dynamic configuration.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags = bundle.ApplyFunc(ctx, b, func(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
|
|
|
err := b.Config.Mutate(func(v dyn.Value) (dyn.Value, error) {
|
2024-02-19 10:44:51 +00:00
|
|
|
var p dyn.Path
|
|
|
|
|
var err error
|
|
|
|
|
|
|
|
|
|
// Set the notification settings.
|
|
|
|
|
p = dyn.MustPathFromString("resources.jobs.job1.notification_settings")
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("no_alert_for_canceled_runs")), dyn.V("${var.no_alert_for_canceled_runs}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("no_alert_for_skipped_runs")), dyn.V("${var.no_alert_for_skipped_runs}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
// Set the min and max workers.
|
|
|
|
|
p = dyn.MustPathFromString("resources.jobs.job1.tasks[0].new_cluster.autoscale")
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("min_workers")), dyn.V("${var.min_workers}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("max_workers")), dyn.V("${var.max_workers}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
// Set the spot bid max price.
|
|
|
|
|
p = dyn.MustPathFromString("resources.jobs.job1.tasks[0].new_cluster.azure_attributes")
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("spot_bid_max_price")), dyn.V("${var.spot_bid_max_price}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
return v, nil
|
|
|
|
|
})
|
2024-03-25 14:18:47 +00:00
|
|
|
return diag.FromErr(err)
|
2024-02-19 10:44:51 +00:00
|
|
|
})
|
2024-03-25 14:18:47 +00:00
|
|
|
require.NoError(t, diags.Error())
|
2024-02-19 10:44:51 +00:00
|
|
|
|
|
|
|
|
// Apply for the variable prefix. This should resolve the variables to their values.
|
2024-03-25 14:18:47 +00:00
|
|
|
diags = bundle.Apply(context.Background(), b, ResolveVariableReferences("variables"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
2024-02-19 10:44:51 +00:00
|
|
|
assert.Equal(t, true, b.Config.Resources.Jobs["job1"].JobSettings.NotificationSettings.NoAlertForCanceledRuns)
|
|
|
|
|
assert.Equal(t, true, b.Config.Resources.Jobs["job1"].JobSettings.NotificationSettings.NoAlertForSkippedRuns)
|
|
|
|
|
assert.Equal(t, 1, b.Config.Resources.Jobs["job1"].JobSettings.Tasks[0].NewCluster.Autoscale.MinWorkers)
|
|
|
|
|
assert.Equal(t, 2, b.Config.Resources.Jobs["job1"].JobSettings.Tasks[0].NewCluster.Autoscale.MaxWorkers)
|
|
|
|
|
assert.Equal(t, 0.5, b.Config.Resources.Jobs["job1"].JobSettings.Tasks[0].NewCluster.AzureAttributes.SpotBidMaxPrice)
|
|
|
|
|
}
|
2024-06-26 10:25:32 +00:00
|
|
|
|
|
|
|
|
func TestResolveComplexVariable(t *testing.T) {
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Bundle: config.Bundle{
|
|
|
|
|
Name: "example",
|
|
|
|
|
},
|
|
|
|
|
Variables: map[string]*variable.Variable{
|
|
|
|
|
"cluster": {
|
|
|
|
|
Value: map[string]any{
|
|
|
|
|
"node_type_id": "Standard_DS3_v2",
|
|
|
|
|
"num_workers": 2,
|
|
|
|
|
},
|
|
|
|
|
Type: variable.VariableTypeComplex,
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
Resources: config.Resources{
|
|
|
|
|
Jobs: map[string]*resources.Job{
|
|
|
|
|
"job1": {
|
|
|
|
|
JobSettings: &jobs.JobSettings{
|
|
|
|
|
JobClusters: []jobs.JobCluster{
|
|
|
|
|
{
|
|
|
|
|
NewCluster: compute.ClusterSpec{
|
|
|
|
|
NodeTypeId: "random",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ctx := context.Background()
|
|
|
|
|
|
|
|
|
|
// Assign the variables to the dynamic configuration.
|
|
|
|
|
diags := bundle.ApplyFunc(ctx, b, func(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
|
|
|
err := b.Config.Mutate(func(v dyn.Value) (dyn.Value, error) {
|
|
|
|
|
var p dyn.Path
|
|
|
|
|
var err error
|
|
|
|
|
|
|
|
|
|
p = dyn.MustPathFromString("resources.jobs.job1.job_clusters[0]")
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("new_cluster")), dyn.V("${var.cluster}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
return v, nil
|
|
|
|
|
})
|
|
|
|
|
return diag.FromErr(err)
|
|
|
|
|
})
|
|
|
|
|
require.NoError(t, diags.Error())
|
|
|
|
|
|
|
|
|
|
diags = bundle.Apply(ctx, b, ResolveVariableReferences("bundle", "workspace", "variables"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
|
|
|
|
require.Equal(t, "Standard_DS3_v2", b.Config.Resources.Jobs["job1"].JobSettings.JobClusters[0].NewCluster.NodeTypeId)
|
|
|
|
|
require.Equal(t, 2, b.Config.Resources.Jobs["job1"].JobSettings.JobClusters[0].NewCluster.NumWorkers)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestResolveComplexVariableReferencesToFields(t *testing.T) {
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Bundle: config.Bundle{
|
|
|
|
|
Name: "example",
|
|
|
|
|
},
|
|
|
|
|
Variables: map[string]*variable.Variable{
|
|
|
|
|
"cluster": {
|
|
|
|
|
Value: map[string]any{
|
|
|
|
|
"node_type_id": "Standard_DS3_v2",
|
|
|
|
|
"num_workers": 2,
|
|
|
|
|
},
|
|
|
|
|
Type: variable.VariableTypeComplex,
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
Resources: config.Resources{
|
|
|
|
|
Jobs: map[string]*resources.Job{
|
|
|
|
|
"job1": {
|
|
|
|
|
JobSettings: &jobs.JobSettings{
|
|
|
|
|
JobClusters: []jobs.JobCluster{
|
|
|
|
|
{
|
|
|
|
|
NewCluster: compute.ClusterSpec{
|
|
|
|
|
NodeTypeId: "random",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ctx := context.Background()
|
|
|
|
|
|
|
|
|
|
// Assign the variables to the dynamic configuration.
|
|
|
|
|
diags := bundle.ApplyFunc(ctx, b, func(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
|
|
|
err := b.Config.Mutate(func(v dyn.Value) (dyn.Value, error) {
|
|
|
|
|
var p dyn.Path
|
|
|
|
|
var err error
|
|
|
|
|
|
|
|
|
|
p = dyn.MustPathFromString("resources.jobs.job1.job_clusters[0].new_cluster")
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("node_type_id")), dyn.V("${var.cluster.node_type_id}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
return v, nil
|
|
|
|
|
})
|
|
|
|
|
return diag.FromErr(err)
|
|
|
|
|
})
|
|
|
|
|
require.NoError(t, diags.Error())
|
|
|
|
|
|
|
|
|
|
diags = bundle.Apply(ctx, b, ResolveVariableReferences("bundle", "workspace", "variables"))
|
|
|
|
|
require.NoError(t, diags.Error())
|
|
|
|
|
require.Equal(t, "Standard_DS3_v2", b.Config.Resources.Jobs["job1"].JobSettings.JobClusters[0].NewCluster.NodeTypeId)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestResolveComplexVariableReferencesWithComplexVariablesError(t *testing.T) {
|
|
|
|
|
b := &bundle.Bundle{
|
|
|
|
|
Config: config.Root{
|
|
|
|
|
Bundle: config.Bundle{
|
|
|
|
|
Name: "example",
|
|
|
|
|
},
|
|
|
|
|
Variables: map[string]*variable.Variable{
|
|
|
|
|
"cluster": {
|
|
|
|
|
Value: map[string]any{
|
|
|
|
|
"node_type_id": "Standard_DS3_v2",
|
|
|
|
|
"num_workers": 2,
|
|
|
|
|
"spark_conf": "${var.spark_conf}",
|
|
|
|
|
},
|
|
|
|
|
Type: variable.VariableTypeComplex,
|
|
|
|
|
},
|
|
|
|
|
"spark_conf": {
|
|
|
|
|
Value: map[string]any{
|
|
|
|
|
"spark.executor.memory": "4g",
|
|
|
|
|
"spark.executor.cores": "2",
|
|
|
|
|
},
|
|
|
|
|
Type: variable.VariableTypeComplex,
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
Resources: config.Resources{
|
|
|
|
|
Jobs: map[string]*resources.Job{
|
|
|
|
|
"job1": {
|
|
|
|
|
JobSettings: &jobs.JobSettings{
|
|
|
|
|
JobClusters: []jobs.JobCluster{
|
|
|
|
|
{
|
|
|
|
|
NewCluster: compute.ClusterSpec{
|
|
|
|
|
NodeTypeId: "random",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ctx := context.Background()
|
|
|
|
|
|
|
|
|
|
// Assign the variables to the dynamic configuration.
|
|
|
|
|
diags := bundle.ApplyFunc(ctx, b, func(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
|
|
|
err := b.Config.Mutate(func(v dyn.Value) (dyn.Value, error) {
|
|
|
|
|
var p dyn.Path
|
|
|
|
|
var err error
|
|
|
|
|
|
|
|
|
|
p = dyn.MustPathFromString("resources.jobs.job1.job_clusters[0]")
|
|
|
|
|
v, err = dyn.SetByPath(v, p.Append(dyn.Key("new_cluster")), dyn.V("${var.cluster}"))
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
return v, nil
|
|
|
|
|
})
|
|
|
|
|
return diag.FromErr(err)
|
|
|
|
|
})
|
|
|
|
|
require.NoError(t, diags.Error())
|
|
|
|
|
|
|
|
|
|
diags = bundle.Apply(ctx, b, bundle.Seq(ResolveVariableReferencesInComplexVariables(), ResolveVariableReferences("bundle", "workspace", "variables")))
|
|
|
|
|
require.ErrorContains(t, diags.Error(), "complex variables cannot contain references to another complex variables")
|
|
|
|
|
}
|
