Files
coder/coderd/dynamicparameters/resolver.go
T
Steven Masley d544f394d4 fix(coderd): keep parameter values when the render is incomplete (#29108)
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.
2026-09-08 17:20:53 +00:00

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 = &parameter.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
}