Closes #29099 ([ENG-3324](https://linear.app/codercom/issue/ENG-3324)). Follow-up to #29102, which stopped the loss propagating through stop builds but left start builds truncating. ## What this does A render carrying a `module_not_loaded` diagnostic could not see the whole template, so a parameter's absence from it is not evidence the template stopped declaring that parameter. Keep the unmatched values instead of deleting them. ## Why preserve rather than fail provisionerd resolves modules itself, so only coderd's render is degraded. Keeping the value produces a correct apply and the workspace keeps building. Failing the build would turn silent data loss into an inability to start every workspace on an affected template version. A complete render is still authoritative and still narrows the set, so unrelated warnings and legitimate parameter removals behave exactly as before. ## Tests - `TestResolveParameters/IncompleteRender`: complete render drops, `module_not_loaded` preserves previous and build values, unrelated warning drops. - `TestDynamicParametersModuleCachePurged` now continues into the start build. On `main` it fails with `start build must not drop the module parameter`. <details> <summary>Notes for the reviewer</summary> ### Detection `preview` tags the warning with `types.DiagnosticCode(diag, types.DiagnosticModuleNotLoaded)`, so the check is `previewtypes.ExtractDiagnosticExtra(diag).Code == previewtypes.DiagnosticModuleNotLoaded` over the second render's diagnostics. Adding future completeness codes is a one-line change in `incompleteRender`. ### Departure from the issue's sketch The issue proposed also gating on `v.Source != sourceDefault`, to keep discarding values that only ever came from a default. That check cannot fire: `sourceDefault` is only assigned to parameters present in the render output, so an unmatched value is never default-sourced. A default stored by an earlier build arrives as `sourcePrevious` and is indistinguishable from user input at this layer. The condition is omitted rather than left in as dead code. ### Not covered Nothing surfaces the degraded render to the operator. `wsbuilder` has no logger, and `render.go` still discards preview's diagnostics (`Logger: slog.New(slog.DiscardHandler)`). That is the follow-up work listed in the issue. </details> --- 🤖 Authored by Coder Agents on behalf of @Emyrk.
267 lines
9.9 KiB
Go
267 lines
9.9 KiB
Go
package dynamicparameters
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/hashicorp/hcl/v2"
|
|
|
|
"github.com/coder/coder/v2/coderd/database"
|
|
"github.com/coder/coder/v2/coderd/util/slice"
|
|
"github.com/coder/coder/v2/codersdk"
|
|
previewtypes "github.com/coder/preview/types"
|
|
"github.com/coder/terraform-provider-coder/v2/provider"
|
|
)
|
|
|
|
type parameterValueSource int
|
|
|
|
const (
|
|
sourceDefault parameterValueSource = iota
|
|
sourcePrevious
|
|
sourceBuild
|
|
sourcePreset
|
|
)
|
|
|
|
type parameterValue struct {
|
|
Value string
|
|
Source parameterValueSource
|
|
}
|
|
|
|
// ResolveParameters determines the parameter values to store for a build. The
|
|
// transition is required because only a start build may narrow the set of
|
|
// stored values.
|
|
//
|
|
//nolint:revive // firstbuild is a control flag to turn on immutable validation
|
|
func ResolveParameters(
|
|
ctx context.Context,
|
|
ownerID uuid.UUID,
|
|
renderer Renderer,
|
|
firstBuild bool,
|
|
transition database.WorkspaceTransition,
|
|
previousValues []database.WorkspaceBuildParameter,
|
|
buildValues []codersdk.WorkspaceBuildParameter,
|
|
presetValues []database.TemplateVersionPresetParameter,
|
|
) (map[string]string, error) {
|
|
previousValuesMap := slice.ToMapFunc(previousValues, func(p database.WorkspaceBuildParameter) (string, string) {
|
|
return p.Name, p.Value
|
|
})
|
|
|
|
// Start with previous
|
|
values := parameterValueMap(slice.ToMapFunc(previousValues, func(p database.WorkspaceBuildParameter) (string, parameterValue) {
|
|
return p.Name, parameterValue{Source: sourcePrevious, Value: p.Value}
|
|
}))
|
|
|
|
// Add build values (overwrite previous values if they exist)
|
|
for _, buildValue := range buildValues {
|
|
values[buildValue.Name] = parameterValue{Source: sourceBuild, Value: buildValue.Value}
|
|
}
|
|
|
|
// Add preset values (overwrite previous and build values if they exist)
|
|
for _, preset := range presetValues {
|
|
values[preset.Name] = parameterValue{Source: sourcePreset, Value: preset.Value}
|
|
}
|
|
|
|
// originalInputValues is going to be used to detect if a user tried to change
|
|
// an immutable parameter after the first build.
|
|
// The actual input values are mutated based on attributes like mutability
|
|
// and ephemerality.
|
|
originalInputValues := make(map[string]parameterValue, len(values))
|
|
for name, value := range values {
|
|
// Store the original values for later use.
|
|
originalInputValues[name] = value
|
|
}
|
|
|
|
// Render the parameters using the values that were supplied to the previous build.
|
|
//
|
|
// This is how the form should look to the user on their workspace settings page.
|
|
// This is the original form truth that our validations should initially be based on.
|
|
output, diags := renderer.Render(ctx, ownerID, previousValuesMap)
|
|
if diags.HasErrors() {
|
|
// Top level diagnostics should break the build. Previous values (and new) should
|
|
// always be valid. If there is a case where this is not true, then this has to
|
|
// be changed to allow the build to continue with a different set of values.
|
|
|
|
return nil, parameterValidationError(diags)
|
|
}
|
|
|
|
// The user's input now needs to be validated against the parameters.
|
|
// Mutability & Ephemeral parameters depend on sequential workspace builds.
|
|
//
|
|
// To enforce these, the user's input values are trimmed based on the
|
|
// mutability and ephemeral parameters defined in the template version.
|
|
for _, parameter := range output.Parameters {
|
|
// Ephemeral parameters should not be taken from the previous build.
|
|
// They must always be explicitly set in every build.
|
|
// So remove their values if they are sourced from the previous build.
|
|
if parameter.Ephemeral {
|
|
v := values[parameter.Name]
|
|
if v.Source == sourcePrevious {
|
|
delete(values, parameter.Name)
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is the final set of values that will be used. Any errors at this stage
|
|
// are fatal. Additional validation for immutability has to be done manually.
|
|
output, diags = renderer.Render(ctx, ownerID, values.ValuesMap())
|
|
if diags.HasErrors() {
|
|
return nil, parameterValidationError(diags)
|
|
}
|
|
|
|
// parameterNames is going to be used to remove any excess values left
|
|
// around without a parameter.
|
|
parameterNames := make(map[string]struct{}, len(output.Parameters))
|
|
parameterError := parameterValidationError(nil)
|
|
for _, parameter := range output.Parameters {
|
|
parameterNames[parameter.Name] = struct{}{}
|
|
|
|
// Validate mutability constraints.
|
|
if !firstBuild && !parameter.Mutable {
|
|
// previousValuesMap should be used over the first render output
|
|
// for the previous state of parameters. The previous build
|
|
// should emit all values, so the previousValuesMap should be
|
|
// complete with all parameter values (user specified and defaults)
|
|
originalValue, ok := previousValuesMap[parameter.Name]
|
|
|
|
// Immutable parameters should not be changed after the first build.
|
|
// If the value matches the previous input value, that is fine.
|
|
//
|
|
// If the previous value is not set, that means this is a new parameter. New
|
|
// immutable parameters are allowed. This is an opinionated choice to prevent
|
|
// workspaces failing to update or delete. Ideally we would block this, as
|
|
// immutable parameters should only be able to be set at creation time.
|
|
if ok && parameter.Value.AsString() != originalValue {
|
|
var src *hcl.Range
|
|
if parameter.Source != nil {
|
|
src = ¶meter.Source.HCLBlock().TypeRange
|
|
}
|
|
|
|
// An immutable parameter was changed, which is not allowed.
|
|
// Add a failed diagnostic to the output.
|
|
parameterError.Extend(parameter.Name, hcl.Diagnostics{
|
|
&hcl.Diagnostic{
|
|
Severity: hcl.DiagError,
|
|
Summary: "Immutable parameter changed",
|
|
Detail: fmt.Sprintf("Parameter %q is not mutable, so it can't be updated after creating a workspace.", parameter.Name),
|
|
Subject: src,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
// Validate monotonic constraints. Monotonic parameters
|
|
// require the value to only increase or only decrease
|
|
// relative to the previous build.
|
|
if !firstBuild {
|
|
prevStr, hasPrev := previousValuesMap[parameter.Name]
|
|
// Only validate on currently valid parameters. Do not load extra diagnostics if
|
|
// the parameter is already invalid.
|
|
if hasPrev && parameter.Value.Valid() {
|
|
MonotonicValidationLoop:
|
|
for _, v := range parameter.Validations {
|
|
if v.Monotonic == nil || *v.Monotonic == "" {
|
|
continue
|
|
}
|
|
|
|
validation := &provider.Validation{
|
|
Monotonic: *v.Monotonic,
|
|
MinDisabled: true,
|
|
MaxDisabled: true,
|
|
}
|
|
prev := prevStr
|
|
if err := validation.Valid(provider.OptionType(parameter.Type), parameter.Value.AsString(), &prev); err != nil {
|
|
parameterError.Extend(parameter.Name, hcl.Diagnostics{
|
|
&hcl.Diagnostic{
|
|
Severity: hcl.DiagError,
|
|
Summary: fmt.Sprintf("Parameter %q monotonicity", parameter.Name),
|
|
Detail: err.Error(),
|
|
},
|
|
})
|
|
break MonotonicValidationLoop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: Fix the `hcl.Diagnostics(...)` type casting. It should not be needed.
|
|
if hcl.Diagnostics(parameter.Diagnostics).HasErrors() {
|
|
// All validation errors are raised here for each parameter.
|
|
parameterError.Extend(parameter.Name, hcl.Diagnostics(parameter.Diagnostics))
|
|
}
|
|
|
|
// If the parameter has a value, but it was not set explicitly by the user at any
|
|
// build, then save the default value. An example where this is important is if a
|
|
// template has a default value of 'region = us-west-2', but the user never sets
|
|
// it. If the default value changes to 'region = us-east-1', we want to preserve
|
|
// the original value of 'us-west-2' for the existing workspaces.
|
|
//
|
|
// parameter.Value will be populated from the default at this point. So grab it
|
|
// from there.
|
|
if _, ok := values[parameter.Name]; !ok && parameter.Value.IsKnown() && parameter.Value.Valid() {
|
|
values[parameter.Name] = parameterValue{
|
|
Value: parameter.Value.AsString(),
|
|
Source: sourceDefault,
|
|
}
|
|
}
|
|
}
|
|
|
|
// Delete any values that do not belong to a parameter. This is to not save
|
|
// parameter values that have no effect. These leaky parameter values can cause
|
|
// problems in the future, as it makes it challenging to remove values from the
|
|
// database
|
|
//
|
|
// Two conditions must hold before a value can be discarded.
|
|
//
|
|
// Only a start build may narrow the stored set. A stop or delete build does not
|
|
// change which parameters a workspace has, so a parameter missing from this
|
|
// render is not evidence the user removed it. Dropping the value there persists
|
|
// the reduced set and the following start build reads it as the previous state,
|
|
// which loses the value even when that build renders the parameter correctly.
|
|
//
|
|
// The render must also be complete. An incomplete one does not report every
|
|
// parameter the template declares, so absence from the output means nothing.
|
|
// Keeping those values is safe, because provisionerd resolves modules itself
|
|
// and the build still applies them correctly. Dropping them destroys user data.
|
|
if transition == database.WorkspaceTransitionStart && !incompleteRender(diags) {
|
|
for k := range values {
|
|
if _, ok := parameterNames[k]; !ok {
|
|
delete(values, k)
|
|
}
|
|
}
|
|
}
|
|
|
|
if parameterError.HasError() {
|
|
// If there are any errors, return them.
|
|
return nil, parameterError
|
|
}
|
|
|
|
// Return the values to be saved for the build.
|
|
return values.ValuesMap(), nil
|
|
}
|
|
|
|
type parameterValueMap map[string]parameterValue
|
|
|
|
func (p parameterValueMap) ValuesMap() map[string]string {
|
|
values := make(map[string]string, len(p))
|
|
for name, paramValue := range p {
|
|
values[name] = paramValue.Value
|
|
}
|
|
return values
|
|
}
|
|
|
|
// incompleteRender reports whether the render could not see the whole template.
|
|
// Parameters missing from such a render are missing because the renderer could
|
|
// not reach their source, not because the template stopped declaring them.
|
|
func incompleteRender(diags hcl.Diagnostics) bool {
|
|
for _, diag := range diags {
|
|
// A module that fails to load takes every parameter it declares with it.
|
|
// This happens when the template version has no cached module files.
|
|
if previewtypes.ExtractDiagnosticExtra(diag).Code == previewtypes.DiagnosticModuleNotLoaded {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|