2023-05-23 12:06:33 +04:00
// Package wsbuilder provides the Builder object, which encapsulates the common business logic of inserting a new
// workspace build into the database.
package wsbuilder
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"net/http"
2023-10-03 09:23:45 +01:00
"time"
2023-05-23 12:06:33 +04:00
2026-01-08 15:24:11 +04:00
"github.com/google/uuid"
2024-05-23 09:53:51 +02:00
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsyntax"
2023-07-15 09:07:19 +03:00
"github.com/sqlc-dev/pqtype"
2023-05-23 12:06:33 +04:00
"golang.org/x/xerrors"
2023-10-18 15:08:02 -05:00
"github.com/coder/coder/v2/coderd/audit"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/db2sdk"
2024-12-02 20:54:32 +00:00
"github.com/coder/coder/v2/coderd/database/dbauthz"
2023-09-01 19:50:12 +03:00
"github.com/coder/coder/v2/coderd/database/dbtime"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/dynamicparameters"
"github.com/coder/coder/v2/coderd/files"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/httpapi"
2026-02-27 14:26:48 +00:00
"github.com/coder/coder/v2/coderd/httpapi/httperror"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/prebuilds"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/provisionerdserver"
"github.com/coder/coder/v2/coderd/rbac"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/rbac/policy"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/tracing"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/util/ptr"
2026-02-03 17:52:07 +00:00
"github.com/coder/coder/v2/coderd/util/slice"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/codersdk"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/provisioner/terraform/tfparse"
"github.com/coder/coder/v2/provisionersdk"
sdkproto "github.com/coder/coder/v2/provisionersdk/proto"
previewtypes "github.com/coder/preview/types"
2023-05-23 12:06:33 +04:00
)
// Builder encapsulates the business logic of inserting a new workspace build into the database.
//
// Builder follows the so-called "Builder" pattern where options that customize the kind of build you get return
// a new instance of the Builder with the option applied.
//
// Example:
//
// b = wsbuilder.New(workspace, transition).VersionID(vID).Initiator(me)
// build, job, err := b.Build(...)
type Builder struct {
// settings that control the kind of build you get
2023-06-29 15:22:21 +02:00
workspace database . Workspace
trans database . WorkspaceTransition
version versionTarget
state stateTarget
logLevel string
deploymentValues * codersdk . DeploymentValues
2025-05-20 10:09:53 -05:00
experiments codersdk . Experiments
2025-07-22 13:39:26 +10:00
usageChecker UsageChecker
2023-06-29 15:22:21 +02:00
2025-06-23 15:04:09 -05:00
richParameterValues [] codersdk . WorkspaceBuildParameter
initiator uuid . UUID
reason database . BuildReason
templateVersionPresetID uuid . UUID
2023-05-23 12:06:33 +04:00
// used during build, makes function arguments less verbose
2025-06-23 12:35:15 -05:00
ctx context . Context
store database . Store
fileCache * files . CacheCloser
2023-05-23 12:06:33 +04:00
// cache of objects, so we only fetch once
2025-04-16 15:54:06 +02:00
template * database . Template
templateVersion * database . TemplateVersion
templateVersionJob * database . ProvisionerJob
2025-05-20 10:09:53 -05:00
terraformValues * database . TemplateVersionTerraformValue
2025-06-23 11:31:53 -05:00
templateVersionParameters * [] previewtypes . Parameter
2025-04-16 15:54:06 +02:00
templateVersionVariables * [] database . TemplateVersionVariable
templateVersionWorkspaceTags * [] database . TemplateVersionWorkspaceTag
lastBuild * database . WorkspaceBuild
lastBuildErr * error
lastBuildParameters * [] database . WorkspaceBuildParameter
lastBuildJob * database . ProvisionerJob
parameterNames * [] string
parameterValues * [] string
2025-06-23 12:35:15 -05:00
templateVersionPresetParameterValues * [] database . TemplateVersionPresetParameter
parameterRender dynamicparameters . Renderer
2025-07-03 14:35:44 -05:00
workspaceTags * map [ string ] string
2026-01-27 19:01:17 -06:00
task * database . Task
hasTask * bool // A workspace without a task will have a nil `task` and false `hasTask`.
2023-06-02 11:16:46 +02:00
2025-05-14 14:15:36 +02:00
prebuiltWorkspaceBuildStage sdkproto . PrebuiltWorkspaceBuildStage
2023-06-02 11:16:46 +02:00
verifyNoLegacyParametersOnce bool
2026-02-12 13:40:47 -08:00
buildMetrics * Metrics
2023-05-23 12:06:33 +04:00
}
2025-07-22 13:39:26 +10:00
type UsageChecker interface {
2026-01-27 19:01:17 -06:00
CheckBuildUsage ( ctx context . Context , store database . Store , templateVersion * database . TemplateVersion , task * database . Task , transition database . WorkspaceTransition ) ( UsageCheckResponse , error )
2025-07-22 13:39:26 +10:00
}
type UsageCheckResponse struct {
Permitted bool
Message string
}
type NoopUsageChecker struct {}
var _ UsageChecker = NoopUsageChecker {}
2026-01-27 19:01:17 -06:00
func ( NoopUsageChecker ) CheckBuildUsage ( _ context . Context , _ database . Store , _ * database . TemplateVersion , _ * database . Task , _ database . WorkspaceTransition ) ( UsageCheckResponse , error ) {
2025-07-22 13:39:26 +10:00
return UsageCheckResponse {
Permitted : true ,
}, nil
}
2023-05-23 12:06:33 +04:00
// versionTarget expresses how to determine the template version for the build.
//
// The zero value of this struct means to use the version from the last build. If there is no last build,
// the build will fail.
//
// setting active: true means to use the active version from the template.
//
// setting specific to a non-nil value means to use the provided template version ID.
//
// active and specific are mutually exclusive and setting them both results in undefined behavior.
type versionTarget struct {
active bool
specific * uuid . UUID
}
// stateTarget expresses how to determine the provisioner state for the build.
//
// The zero value of this struct means to use state from the last build. If there is no last build, no state is
// provided (i.e. first build on a newly created workspace).
//
// setting orphan: true means not to send any state. This can be used to deleted orphaned workspaces
//
// setting explicit to a non-nil value means to use the provided state
//
// orphan and explicit are mutually exclusive and setting them both results in undefined behavior.
type stateTarget struct {
orphan bool
explicit * [] byte
}
2025-07-22 13:39:26 +10:00
func New ( w database . Workspace , t database . WorkspaceTransition , uc UsageChecker ) Builder {
return Builder { workspace : w , trans : t , usageChecker : uc }
2023-05-23 12:06:33 +04:00
}
// Methods that customize the build are public, have a struct receiver and return a new Builder.
func ( b Builder ) VersionID ( v uuid . UUID ) Builder {
// nolint: revive
b . version = versionTarget { specific : & v }
return b
}
func ( b Builder ) ActiveVersion () Builder {
// nolint: revive
b . version = versionTarget { active : true }
return b
}
func ( b Builder ) State ( state [] byte ) Builder {
// nolint: revive
b . state = stateTarget { explicit : & state }
return b
}
func ( b Builder ) Orphan () Builder {
// nolint: revive
b . state = stateTarget { orphan : true }
return b
}
func ( b Builder ) LogLevel ( l string ) Builder {
// nolint: revive
b . logLevel = l
return b
}
2023-06-29 15:22:21 +02:00
func ( b Builder ) DeploymentValues ( dv * codersdk . DeploymentValues ) Builder {
// nolint: revive
b . deploymentValues = dv
return b
}
2025-05-20 10:09:53 -05:00
func ( b Builder ) Experiments ( exp codersdk . Experiments ) Builder {
// nolint: revive
cpy := make ( codersdk . Experiments , len ( exp ))
copy ( cpy , exp )
b . experiments = cpy
return b
}
2023-05-23 12:06:33 +04:00
func ( b Builder ) Initiator ( u uuid . UUID ) Builder {
// nolint: revive
b . initiator = u
return b
}
func ( b Builder ) Reason ( r database . BuildReason ) Builder {
// nolint: revive
b . reason = r
return b
}
func ( b Builder ) RichParameterValues ( p [] codersdk . WorkspaceBuildParameter ) Builder {
// nolint: revive
b . richParameterValues = p
return b
}
2025-05-12 16:19:03 +02:00
// MarkPrebuild indicates that a prebuilt workspace is being built.
2025-04-14 15:34:50 +02:00
func ( b Builder ) MarkPrebuild () Builder {
// nolint: revive
2025-05-12 16:19:03 +02:00
b . prebuiltWorkspaceBuildStage = sdkproto . PrebuiltWorkspaceBuildStage_CREATE
2025-04-14 15:34:50 +02:00
return b
}
2025-05-12 16:19:03 +02:00
// MarkPrebuiltWorkspaceClaim indicates that a prebuilt workspace is being claimed.
func ( b Builder ) MarkPrebuiltWorkspaceClaim () Builder {
2025-04-24 09:39:38 -04:00
// nolint: revive
2025-05-12 16:19:03 +02:00
b . prebuiltWorkspaceBuildStage = sdkproto . PrebuiltWorkspaceBuildStage_CLAIM
2025-04-24 09:39:38 -04:00
return b
}
2023-05-23 12:06:33 +04:00
// SetLastWorkspaceBuildInTx prepopulates the Builder's cache with the last workspace build. This allows us
// to avoid a repeated database query when the Builder's caller also needs the workspace build, e.g. auto-start &
// auto-stop.
//
// CAUTION: only call this method from within a database transaction with RepeatableRead isolation. This transaction
// MUST be the database.Store you call Build() with.
func ( b Builder ) SetLastWorkspaceBuildInTx ( build * database . WorkspaceBuild ) Builder {
// nolint: revive
b . lastBuild = build
return b
}
// SetLastWorkspaceBuildJobInTx prepopulates the Builder's cache with the last workspace build job. This allows us
// to avoid a repeated database query when the Builder's caller also needs the workspace build job, e.g. auto-start &
// auto-stop.
//
// CAUTION: only call this method from within a database transaction with RepeatableRead isolation. This transaction
// MUST be the database.Store you call Build() with.
func ( b Builder ) SetLastWorkspaceBuildJobInTx ( job * database . ProvisionerJob ) Builder {
// nolint: revive
b . lastBuildJob = job
return b
}
2025-04-14 15:34:50 +02:00
func ( b Builder ) TemplateVersionPresetID ( id uuid . UUID ) Builder {
// nolint: revive
b . templateVersionPresetID = id
return b
}
2026-02-12 13:40:47 -08:00
func ( b Builder ) BuildMetrics ( m * Metrics ) Builder {
// nolint: revive
b . buildMetrics = m
return b
}
2023-05-23 12:06:33 +04:00
type BuildError struct {
// Status is a suitable HTTP status code
Status int
Message string
Wrapped error
}
func ( e BuildError ) Error () string {
2025-07-03 08:33:45 -05:00
if e . Wrapped == nil {
return e . Message
}
2023-05-23 12:06:33 +04:00
return e . Wrapped . Error ()
}
func ( e BuildError ) Unwrap () error {
return e . Wrapped
}
2025-07-03 08:33:45 -05:00
func ( e BuildError ) Response () ( int , codersdk . Response ) {
2026-02-27 14:26:48 +00:00
// If the wrapped error knows how to produce its own response
// (e.g. DiagnosticError with Validations), prefer that over
// the generic BuildError response.
if inner , ok := httperror . IsResponder ( e . Wrapped ); ok {
return inner . Response ()
}
2025-07-03 08:33:45 -05:00
return e . Status , codersdk . Response {
Message : e . Message ,
Detail : e . Error (),
}
}
2023-05-23 12:06:33 +04:00
// Build computes and inserts a new workspace build into the database. If authFunc is provided, it also performs
// authorization preflight checks.
func ( b * Builder ) Build (
ctx context . Context ,
store database . Store ,
2025-06-23 12:35:15 -05:00
fileCache * files . Cache ,
2024-05-15 09:46:35 -05:00
authFunc func ( action policy . Action , object rbac . Objecter ) bool ,
2023-10-18 15:08:02 -05:00
auditBaggage audit . WorkspaceBuildBaggage ,
2023-05-23 12:06:33 +04:00
) (
2024-12-11 13:38:13 +02:00
* database . WorkspaceBuild , * database . ProvisionerJob , [] database . GetEligibleProvisionerDaemonsByProvisionerJobIDsRow , error ,
2023-05-23 12:06:33 +04:00
) {
2023-10-18 15:08:02 -05:00
var err error
b . ctx , err = audit . BaggageToContext ( ctx , auditBaggage )
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , xerrors . Errorf ( "create audit baggage: %w" , err )
2023-10-18 15:08:02 -05:00
}
2023-05-23 12:06:33 +04:00
2025-06-23 12:35:15 -05:00
b . fileCache = files . NewCacheCloser ( fileCache )
// Always close opened files during the build
defer b . fileCache . Close ()
2023-05-23 12:06:33 +04:00
// Run the build in a transaction with RepeatableRead isolation, and retries.
// RepeatableRead isolation ensures that we get a consistent view of the database while
// computing the new build. This simplifies the logic so that we do not need to worry if
// later reads are consistent with earlier ones.
2023-10-18 17:07:21 -05:00
var workspaceBuild * database . WorkspaceBuild
var provisionerJob * database . ProvisionerJob
2024-12-11 13:38:13 +02:00
var provisionerDaemons [] database . GetEligibleProvisionerDaemonsByProvisionerJobIDsRow
2023-10-18 17:07:21 -05:00
err = database . ReadModifyUpdate ( store , func ( tx database . Store ) error {
var err error
b . store = tx
2024-12-02 20:54:32 +00:00
workspaceBuild , provisionerJob , provisionerDaemons , err = b . buildTx ( authFunc )
2023-10-18 17:07:21 -05:00
return err
})
if err != nil {
2026-02-12 13:40:47 -08:00
b . recordBuildMetrics ( provisionerJob , err )
2024-12-02 20:54:32 +00:00
return nil , nil , nil , xerrors . Errorf ( "build tx: %w" , err )
2023-05-23 12:06:33 +04:00
}
2026-02-12 13:40:47 -08:00
b . recordBuildMetrics ( provisionerJob , nil )
2024-12-02 20:54:32 +00:00
return workspaceBuild , provisionerJob , provisionerDaemons , nil
2023-05-23 12:06:33 +04:00
}
2026-02-12 13:40:47 -08:00
// recordBuildMetrics records the workspace build enqueue metric if metrics are
// configured. It determines the appropriate build reason label, using "prebuild"
// for prebuild operations instead of the database reason.
func ( b * Builder ) recordBuildMetrics ( job * database . ProvisionerJob , err error ) {
if b . buildMetrics == nil {
return
}
if job == nil || ! job . Provisioner . Valid () {
return
}
// Determine the build reason for metrics. Prebuilds use BuildReasonInitiator
// in the database but we want to track them separately in metrics.
buildReason := string ( b . reason )
if b . prebuiltWorkspaceBuildStage == sdkproto . PrebuiltWorkspaceBuildStage_CREATE {
buildReason = provisionerdserver . BuildReasonPrebuild
}
b . buildMetrics . RecordBuildEnqueued ( string ( job . Provisioner ), buildReason , string ( b . trans ), err )
}
2023-05-23 12:06:33 +04:00
// buildTx contains the business logic of computing a new build. Attributes of the new database objects are computed
// in a functional style, rather than imperative, to emphasize the logic of how they are defined. A simple cache
// of database-fetched objects is stored on the struct to ensure we only fetch things once, even if they are used in
// the calculation of multiple attributes.
//
// In order to utilize this cache, the functions that compute build attributes use a pointer receiver type.
2024-05-15 09:46:35 -05:00
func ( b * Builder ) buildTx ( authFunc func ( action policy . Action , object rbac . Objecter ) bool ) (
2024-12-11 13:38:13 +02:00
* database . WorkspaceBuild , * database . ProvisionerJob , [] database . GetEligibleProvisionerDaemonsByProvisionerJobIDsRow , error ,
2023-05-23 12:06:33 +04:00
) {
if authFunc != nil {
err := b . authorize ( authFunc )
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , err
2023-05-23 12:06:33 +04:00
}
}
err := b . checkTemplateVersionMatchesTemplate ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , err
2023-05-23 12:06:33 +04:00
}
err = b . checkTemplateJobStatus ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , err
2023-05-23 12:06:33 +04:00
}
2025-07-22 13:39:26 +10:00
err = b . checkUsage ()
if err != nil {
return nil , nil , nil , err
}
2023-05-23 12:06:33 +04:00
err = b . checkRunningBuild ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , err
2023-05-23 12:06:33 +04:00
}
template , err := b . getTemplate ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError { http . StatusInternalServerError , "failed to fetch template" , err }
2023-05-23 12:06:33 +04:00
}
templateVersionJob , err := b . getTemplateVersionJob ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError {
2023-05-23 12:06:33 +04:00
http . StatusInternalServerError , "failed to fetch template version job" , err ,
}
}
// if we haven't been told specifically who initiated, default to owner
if b . initiator == uuid . Nil {
b . initiator = b . workspace . OwnerID
}
// default reason is initiator
if b . reason == "" {
b . reason = database . BuildReasonInitiator
}
workspaceBuildID := uuid . New ()
input , err := json . Marshal ( provisionerdserver . WorkspaceProvisionJob {
2025-05-12 16:19:03 +02:00
WorkspaceBuildID : workspaceBuildID ,
LogLevel : b . logLevel ,
PrebuiltWorkspaceBuildStage : b . prebuiltWorkspaceBuildStage ,
2023-05-23 12:06:33 +04:00
})
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError {
2023-05-23 12:06:33 +04:00
http . StatusInternalServerError ,
"marshal provision job" ,
err ,
}
}
traceMetadataRaw , err := json . Marshal ( tracing . MetadataFromContext ( b . ctx ))
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError { http . StatusInternalServerError , "marshal metadata" , err }
2023-05-23 12:06:33 +04:00
}
2024-05-23 09:53:51 +02:00
tags , err := b . getProvisionerTags ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , err // already wrapped BuildError
2024-05-23 09:53:51 +02:00
}
2023-05-23 12:06:33 +04:00
2023-09-01 19:50:12 +03:00
now := dbtime . Now ()
2023-05-23 12:06:33 +04:00
provisionerJob , err := b . store . InsertProvisionerJob ( b . ctx , database . InsertProvisionerJobParams {
ID : uuid . New (),
CreatedAt : now ,
UpdatedAt : now ,
InitiatorID : b . initiator ,
OrganizationID : template . OrganizationID ,
Provisioner : template . Provisioner ,
Type : database . ProvisionerJobTypeWorkspaceBuild ,
StorageMethod : templateVersionJob . StorageMethod ,
FileID : templateVersionJob . FileID ,
Input : input ,
Tags : tags ,
TraceMetadata : pqtype . NullRawMessage {
Valid : true ,
RawMessage : traceMetadataRaw ,
},
2025-07-30 19:09:53 -05:00
LogsOverflowed : false ,
2023-05-23 12:06:33 +04:00
})
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError { http . StatusInternalServerError , "insert provisioner job" , err }
}
// nolint:gocritic // The user performing this request may not have permission
// to read all provisioner daemons. We need to retrieve the eligible
// provisioner daemons for this job to show in the UI if there is no
// matching provisioner daemon.
2026-02-23 22:46:17 -06:00
provisionerDaemons , err := b . store . GetEligibleProvisionerDaemonsByProvisionerJobIDs ( dbauthz . AsWorkspaceBuilder ( b . ctx ), [] uuid . UUID { provisionerJob . ID })
2024-12-02 20:54:32 +00:00
if err != nil {
// NOTE: we do **not** want to fail a workspace build if we fail to
// retrieve provisioner daemons. This is just to show in the UI if there
// is no matching provisioner daemon for the job.
2024-12-11 13:38:13 +02:00
provisionerDaemons = [] database . GetEligibleProvisionerDaemonsByProvisionerJobIDsRow {}
2023-05-23 12:06:33 +04:00
}
templateVersionID , err := b . getTemplateVersionID ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError { http . StatusInternalServerError , "compute template version ID" , err }
2023-05-23 12:06:33 +04:00
}
buildNum , err := b . getBuildNumber ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError { http . StatusInternalServerError , "compute build number" , err }
2023-05-23 12:06:33 +04:00
}
state , err := b . getState ()
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , BuildError { http . StatusInternalServerError , "compute build state" , err }
2023-05-23 12:06:33 +04:00
}
2023-07-25 09:14:38 -04:00
var workspaceBuild database . WorkspaceBuild
err = b . store . InTx ( func ( store database . Store ) error {
2025-08-20 11:02:53 +02:00
names , values , err := b . getParameters ()
if err != nil {
// getParameters already wraps errors in BuildError
return err
}
if b . templateVersionPresetID == uuid . Nil {
presetID , err := prebuilds . FindMatchingPresetID ( b . ctx , b . store , templateVersionID , names , values )
if err != nil {
return BuildError { http . StatusInternalServerError , "find matching preset" , err }
}
b . templateVersionPresetID = presetID
}
2023-07-25 09:14:38 -04:00
err = store . InsertWorkspaceBuild ( b . ctx , database . InsertWorkspaceBuildParams {
2025-04-14 15:34:50 +02:00
ID : workspaceBuildID ,
CreatedAt : now ,
UpdatedAt : now ,
WorkspaceID : b . workspace . ID ,
TemplateVersionID : templateVersionID ,
BuildNumber : buildNum ,
ProvisionerState : state ,
InitiatorID : b . initiator ,
Transition : b . trans ,
JobID : provisionerJob . ID ,
Reason : b . reason ,
Deadline : time . Time {}, // set by provisioner upon completion
MaxDeadline : time . Time {}, // set by provisioner upon completion
TemplateVersionPresetID : uuid . NullUUID {
UUID : b . templateVersionPresetID ,
Valid : b . templateVersionPresetID != uuid . Nil ,
},
2023-07-25 09:14:38 -04:00
})
if err != nil {
2023-10-18 17:07:21 -05:00
code := http . StatusInternalServerError
if rbac . IsUnauthorizedError ( err ) {
2023-12-08 23:03:46 -06:00
code = http . StatusForbidden
2025-01-08 15:15:30 +02:00
} else if database . IsUniqueViolation ( err ) {
// Concurrent builds may result in duplicate
// workspace_builds_workspace_id_build_number_key.
code = http . StatusConflict
2023-10-18 17:07:21 -05:00
}
return BuildError { code , "insert workspace build" , err }
2023-07-25 09:14:38 -04:00
}
2026-01-27 19:01:17 -06:00
task , err := b . getWorkspaceTask ()
if err != nil {
return BuildError { http . StatusInternalServerError , "get task by workspace id" , err }
}
2025-10-13 12:57:06 +03:00
// If this is a task workspace, link it to the latest workspace build.
2026-01-27 19:01:17 -06:00
if task != nil {
2025-10-13 12:57:06 +03:00
_ , err = store . UpsertTaskWorkspaceApp ( b . ctx , database . UpsertTaskWorkspaceAppParams {
TaskID : task . ID ,
WorkspaceBuildNumber : buildNum ,
WorkspaceAgentID : uuid . NullUUID {}, // Updated by the provisioner upon job completion.
WorkspaceAppID : uuid . NullUUID {}, // Updated by the provisioner upon job completion.
})
if err != nil {
return BuildError { http . StatusInternalServerError , "upsert task workspace app" , err }
}
}
2023-07-25 09:14:38 -04:00
err = store . InsertWorkspaceBuildParameters ( b . ctx , database . InsertWorkspaceBuildParametersParams {
WorkspaceBuildID : workspaceBuildID ,
Name : names ,
Value : values ,
})
if err != nil {
return BuildError { http . StatusInternalServerError , "insert workspace build parameters: %w" , err }
}
workspaceBuild , err = store . GetWorkspaceBuildByID ( b . ctx , workspaceBuildID )
if err != nil {
return BuildError { http . StatusInternalServerError , "get workspace build" , err }
}
2025-06-23 14:07:42 +01:00
// If the requestor is trying to orphan-delete a workspace and there are no
// provisioners available, we should complete the build and mark the
// workspace as deleted ourselves.
// There are cases where tagged provisioner daemons have been decommissioned
// without deleting the relevant workspaces, and without any provisioners
// available these workspaces cannot be deleted.
// Orphan-deleting a workspace sends an empty state to Terraform, which means
// it won't actually delete anything. So we actually don't need to execute a
// provisioner job at all for an orphan delete, but deleting without a workspace
// build or provisioner job would result in no audit log entry, which is a deal-breaker.
hasActiveEligibleProvisioner := false
for _ , pd := range provisionerDaemons {
age := now . Sub ( pd . ProvisionerDaemon . LastSeenAt . Time )
if age <= provisionerdserver . StaleInterval {
hasActiveEligibleProvisioner = true
break
}
}
if b . state . orphan && ! hasActiveEligibleProvisioner {
2026-02-23 22:46:17 -06:00
// nolint: gocritic // User won't necessarily have the permission to do this so we act as a system user.
if err := store . UpdateProvisionerJobWithCompleteWithStartedAtByID ( dbauthz . AsWorkspaceBuilder ( b . ctx ), database . UpdateProvisionerJobWithCompleteWithStartedAtByIDParams {
2025-06-23 14:07:42 +01:00
CompletedAt : sql . NullTime { Valid : true , Time : now },
Error : sql . NullString { Valid : false },
ErrorCode : sql . NullString { Valid : false },
ID : provisionerJob . ID ,
StartedAt : sql . NullTime { Valid : true , Time : now },
UpdatedAt : now ,
}); err != nil {
return BuildError { http . StatusInternalServerError , "mark orphan-delete provisioner job as completed" , err }
}
// Re-fetch the completed provisioner job.
if pj , err := store . GetProvisionerJobByID ( b . ctx , provisionerJob . ID ); err == nil {
provisionerJob = pj
}
if err := store . UpdateWorkspaceDeletedByID ( b . ctx , database . UpdateWorkspaceDeletedByIDParams {
ID : b . workspace . ID ,
Deleted : true ,
}); err != nil {
return BuildError { http . StatusInternalServerError , "mark workspace as deleted" , err }
}
}
2023-07-25 09:14:38 -04:00
return nil
}, nil )
2023-05-23 12:06:33 +04:00
if err != nil {
2024-12-02 20:54:32 +00:00
return nil , nil , nil , err
2023-05-23 12:06:33 +04:00
}
2024-12-02 20:54:32 +00:00
return & workspaceBuild , & provisionerJob , provisionerDaemons , nil
2023-05-23 12:06:33 +04:00
}
func ( b * Builder ) getTemplate () ( * database . Template , error ) {
if b . template != nil {
return b . template , nil
}
t , err := b . store . GetTemplateByID ( b . ctx , b . workspace . TemplateID )
if err != nil {
return nil , xerrors . Errorf ( "get template %s: %w" , b . workspace . TemplateID , err )
}
b . template = & t
return b . template , nil
}
func ( b * Builder ) getTemplateVersionJob () ( * database . ProvisionerJob , error ) {
if b . templateVersionJob != nil {
return b . templateVersionJob , nil
}
v , err := b . getTemplateVersion ()
if err != nil {
return nil , xerrors . Errorf ( "get template version so we can get provisioner job: %w" , err )
}
j , err := b . store . GetProvisionerJobByID ( b . ctx , v . JobID )
if err != nil {
return nil , xerrors . Errorf ( "get template provisioner job %s: %w" , v . JobID , err )
}
b . templateVersionJob = & j
return b . templateVersionJob , err
}
func ( b * Builder ) getTemplateVersion () ( * database . TemplateVersion , error ) {
if b . templateVersion != nil {
return b . templateVersion , nil
}
id , err := b . getTemplateVersionID ()
if err != nil {
return nil , xerrors . Errorf ( "get template version ID so we can get version: %w" , err )
}
v , err := b . store . GetTemplateVersionByID ( b . ctx , id )
if err != nil {
return nil , xerrors . Errorf ( "get template version %s: %w" , id , err )
}
b . templateVersion = & v
return b . templateVersion , err
}
func ( b * Builder ) getTemplateVersionID () ( uuid . UUID , error ) {
if b . version . specific != nil {
return * b . version . specific , nil
}
if b . version . active {
t , err := b . getTemplate ()
if err != nil {
return uuid . Nil , xerrors . Errorf ( "get template so we can get active version: %w" , err )
}
return t . ActiveVersionID , nil
}
// default is prior version
bld , err := b . getLastBuild ()
if err != nil {
return uuid . Nil , xerrors . Errorf ( "get last build so we can get version: %w" , err )
}
return bld . TemplateVersionID , nil
}
2026-01-27 19:01:17 -06:00
// getWorkspaceTask returns the task associated with the workspace, if any.
// If no task exists, it returns (nil, nil).
func ( b * Builder ) getWorkspaceTask () ( * database . Task , error ) {
if b . hasTask != nil {
return b . task , nil
}
t , err := b . store . GetTaskByWorkspaceID ( b . ctx , b . workspace . ID )
if err != nil {
if xerrors . Is ( err , sql . ErrNoRows ) {
b . hasTask = ptr . Ref ( false )
//nolint:nilnil // No task exists.
return nil , nil
}
return nil , xerrors . Errorf ( "get task: %w" , err )
}
b . task = & t
b . hasTask = ptr . Ref ( true )
return b . task , nil
}
2025-05-20 10:09:53 -05:00
func ( b * Builder ) getTemplateTerraformValues () ( * database . TemplateVersionTerraformValue , error ) {
if b . terraformValues != nil {
return b . terraformValues , nil
}
v , err := b . getTemplateVersion ()
if err != nil {
return nil , xerrors . Errorf ( "get template version so we can get terraform values: %w" , err )
}
vals , err := b . store . GetTemplateVersionTerraformValues ( b . ctx , v . ID )
if err != nil {
2025-06-23 12:35:15 -05:00
if ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , xerrors . Errorf ( "builder get template version terraform values %s: %w" , v . JobID , err )
}
// Old versions do not have terraform values, so we can ignore ErrNoRows and use an empty value.
vals = database . TemplateVersionTerraformValue {
TemplateVersionID : v . ID ,
UpdatedAt : time . Time {},
CachedPlan : nil ,
CachedModuleFiles : uuid . NullUUID {},
ProvisionerdVersion : "" ,
}
2025-05-20 10:09:53 -05:00
}
b . terraformValues = & vals
2025-06-23 12:35:15 -05:00
return b . terraformValues , nil
}
func ( b * Builder ) getDynamicParameterRenderer () ( dynamicparameters . Renderer , error ) {
if b . parameterRender != nil {
return b . parameterRender , nil
}
tv , err := b . getTemplateVersion ()
if err != nil {
return nil , xerrors . Errorf ( "get template version to get parameters: %w" , err )
}
job , err := b . getTemplateVersionJob ()
if err != nil {
return nil , xerrors . Errorf ( "get template version job to get parameters: %w" , err )
}
tfVals , err := b . getTemplateTerraformValues ()
if err != nil {
return nil , xerrors . Errorf ( "get template version terraform values: %w" , err )
}
2025-07-21 13:02:31 -05:00
variableValues , err := b . getTemplateVersionVariables ()
if err != nil {
return nil , xerrors . Errorf ( "get template version variables: %w" , err )
}
2025-06-23 12:35:15 -05:00
renderer , err := dynamicparameters . Prepare ( b . ctx , b . store , b . fileCache , tv . ID ,
dynamicparameters . WithTemplateVersion ( * tv ),
dynamicparameters . WithProvisionerJob ( * job ),
dynamicparameters . WithTerraformValues ( * tfVals ),
2025-07-21 13:02:31 -05:00
dynamicparameters . WithTemplateVariableValues ( variableValues ),
2025-06-23 12:35:15 -05:00
)
if err != nil {
return nil , xerrors . Errorf ( "get template version renderer: %w" , err )
}
b . parameterRender = renderer
return renderer , nil
2025-05-20 10:09:53 -05:00
}
2023-05-23 12:06:33 +04:00
func ( b * Builder ) getLastBuild () ( * database . WorkspaceBuild , error ) {
if b . lastBuild != nil {
return b . lastBuild , nil
}
// last build might not exist, so we also store the error to prevent repeated queries
// for a non-existing build
if b . lastBuildErr != nil {
return nil , * b . lastBuildErr
}
bld , err := b . store . GetLatestWorkspaceBuildByWorkspaceID ( b . ctx , b . workspace . ID )
if err != nil {
err = xerrors . Errorf ( "get workspace %s last build: %w" , b . workspace . ID , err )
b . lastBuildErr = & err
return nil , err
}
b . lastBuild = & bld
return b . lastBuild , nil
}
2025-06-23 12:35:15 -05:00
// firstBuild returns true if this is the first build of the workspace, i.e. there are no prior builds.
func ( b * Builder ) firstBuild () ( bool , error ) {
_ , err := b . getLastBuild ()
if xerrors . Is ( err , sql . ErrNoRows ) {
// first build!
return true , nil
}
if err != nil {
return false , err
}
return false , nil
}
2023-05-23 12:06:33 +04:00
func ( b * Builder ) getBuildNumber () ( int32 , error ) {
bld , err := b . getLastBuild ()
if xerrors . Is ( err , sql . ErrNoRows ) {
// first build!
return 1 , nil
}
if err != nil {
return 0 , xerrors . Errorf ( "get last build to compute build number: %w" , err )
}
return bld . BuildNumber + 1 , nil
}
func ( b * Builder ) getState () ([] byte , error ) {
if b . state . orphan {
// Orphan means empty state.
return nil , nil
}
if b . state . explicit != nil {
return * b . state . explicit , nil
}
// Default is to use state from prior build
bld , err := b . getLastBuild ()
if xerrors . Is ( err , sql . ErrNoRows ) {
// last build does not exist, which implies empty state
return nil , nil
}
if err != nil {
return nil , xerrors . Errorf ( "get last build to get state: %w" , err )
}
2026-02-23 22:46:17 -06:00
// nolint: gocritic // Workspace builder needs to read provisioner state for the new build.
state , err := b . store . GetWorkspaceBuildProvisionerStateByID ( dbauthz . AsWorkspaceBuilder ( b . ctx ), bld . ID )
if err != nil {
return nil , xerrors . Errorf ( "get workspace build provisioner state: %w" , err )
}
return state . ProvisionerState , nil
2023-05-23 12:06:33 +04:00
}
func ( b * Builder ) getParameters () ( names , values [] string , err error ) {
2024-05-23 09:53:51 +02:00
if b . parameterNames != nil {
return * b . parameterNames , * b . parameterValues , nil
}
2025-06-23 12:35:15 -05:00
// Always reject legacy parameters.
err = b . verifyNoLegacyParameters ()
if err != nil {
return nil , nil , BuildError { http . StatusBadRequest , "Unable to build workspace with unsupported parameters" , err }
}
if b . usingDynamicParameters () {
names , values , err = b . getDynamicParameters ()
} else {
names , values , err = b . getClassicParameters ()
}
if err != nil {
return nil , nil , xerrors . Errorf ( "get parameters: %w" , err )
}
b . parameterNames = & names
b . parameterValues = & values
return names , values , nil
}
func ( b * Builder ) getDynamicParameters () ( names , values [] string , err error ) {
lastBuildParameters , err := b . getLastBuildParameters ()
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to fetch last build parameters" , err }
}
presetParameterValues , err := b . getPresetParameterValues ()
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to fetch preset parameter values" , err }
}
render , err := b . getDynamicParameterRenderer ()
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to get dynamic parameter renderer" , err }
}
firstBuild , err := b . firstBuild ()
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to check if first build" , err }
}
2025-06-23 15:08:18 -05:00
buildValues , err := dynamicparameters . ResolveParameters ( b . ctx , b . workspace . OwnerID , render , firstBuild ,
2025-06-23 12:35:15 -05:00
lastBuildParameters ,
b . richParameterValues ,
presetParameterValues )
2025-06-23 15:08:18 -05:00
if err != nil {
2026-02-27 14:26:48 +00:00
return nil , nil , BuildError { http . StatusBadRequest , "resolve parameters" , err }
2025-06-23 12:35:15 -05:00
}
names = make ([] string , 0 , len ( buildValues ))
values = make ([] string , 0 , len ( buildValues ))
for k , v := range buildValues {
names = append ( names , k )
values = append ( values , v )
}
return names , values , nil
}
func ( b * Builder ) getClassicParameters () ( names , values [] string , err error ) {
2023-05-23 12:06:33 +04:00
templateVersionParameters , err := b . getTemplateVersionParameters ()
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to fetch template version parameters" , err }
}
lastBuildParameters , err := b . getLastBuildParameters ()
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to fetch last build parameters" , err }
}
2025-06-23 12:35:15 -05:00
presetParameterValues , err := b . getPresetParameterValues ()
2023-05-23 12:06:33 +04:00
if err != nil {
2025-06-23 12:35:15 -05:00
return nil , nil , BuildError { http . StatusInternalServerError , "failed to fetch preset parameter values" , err }
2023-05-23 12:06:33 +04:00
}
2025-04-23 09:15:49 -07:00
2025-05-28 10:00:39 -05:00
lastBuildParameterValues := db2sdk . WorkspaceBuildParameters ( lastBuildParameters )
resolver := codersdk . ParameterResolver {
Rich : lastBuildParameterValues ,
}
2023-05-23 12:06:33 +04:00
for _ , templateVersionParameter := range templateVersionParameters {
2025-06-23 11:31:53 -05:00
tvp , err := db2sdk . TemplateVersionParameterFromPreview ( templateVersionParameter )
2023-05-23 12:06:33 +04:00
if err != nil {
return nil , nil , BuildError { http . StatusInternalServerError , "failed to convert template version parameter" , err }
}
2025-04-23 09:15:49 -07:00
2025-05-19 16:15:15 -05:00
value , err := resolver . ValidateResolve (
tvp ,
2025-06-23 12:35:15 -05:00
b . findNewBuildParameterValue ( templateVersionParameter . Name , presetParameterValues ),
2025-05-19 16:15:15 -05:00
)
if err != nil {
// At this point, we've queried all the data we need from the database,
// so the only errors are problems with the request (missing data, failed
// validation, immutable parameters, etc.)
return nil , nil , BuildError { http . StatusBadRequest , fmt . Sprintf ( "Unable to validate parameter %q" , templateVersionParameter . Name ), err }
2023-05-23 12:06:33 +04:00
}
2025-04-23 09:15:49 -07:00
2023-05-23 12:06:33 +04:00
names = append ( names , templateVersionParameter . Name )
values = append ( values , value )
}
2024-05-23 09:53:51 +02:00
b . parameterNames = & names
b . parameterValues = & values
2023-05-23 12:06:33 +04:00
return names , values , nil
}
2025-06-23 12:35:15 -05:00
func ( b * Builder ) findNewBuildParameterValue ( name string , presets [] database . TemplateVersionPresetParameter ) * codersdk . WorkspaceBuildParameter {
for _ , v := range presets {
2025-04-16 15:54:06 +02:00
if v . Name == name {
return & codersdk . WorkspaceBuildParameter {
Name : v . Name ,
Value : v . Value ,
}
}
}
2023-05-23 12:06:33 +04:00
for _ , v := range b . richParameterValues {
if v . Name == name {
return & v
}
}
return nil
}
func ( b * Builder ) getLastBuildParameters () ([] database . WorkspaceBuildParameter , error ) {
if b . lastBuildParameters != nil {
return * b . lastBuildParameters , nil
}
bld , err := b . getLastBuild ()
if xerrors . Is ( err , sql . ErrNoRows ) {
// if the build doesn't exist, then clearly there can be no parameters.
b . lastBuildParameters = & [] database . WorkspaceBuildParameter {}
return * b . lastBuildParameters , nil
}
if err != nil {
return nil , xerrors . Errorf ( "get last build to get parameters: %w" , err )
}
values , err := b . store . GetWorkspaceBuildParameters ( b . ctx , bld . ID )
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , xerrors . Errorf ( "get last build %s parameters: %w" , bld . ID , err )
}
b . lastBuildParameters = & values
return values , nil
}
2025-06-23 11:31:53 -05:00
func ( b * Builder ) getTemplateVersionParameters () ([] previewtypes . Parameter , error ) {
2023-05-23 12:06:33 +04:00
if b . templateVersionParameters != nil {
return * b . templateVersionParameters , nil
}
tvID , err := b . getTemplateVersionID ()
if err != nil {
return nil , xerrors . Errorf ( "get template version ID to get parameters: %w" , err )
}
tvp , err := b . store . GetTemplateVersionParameters ( b . ctx , tvID )
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , xerrors . Errorf ( "get template version %s parameters: %w" , tvID , err )
}
2026-02-03 17:52:07 +00:00
b . templateVersionParameters = ptr . Ref ( slice . List ( tvp , dynamicparameters . TemplateVersionParameter ))
2025-06-23 11:31:53 -05:00
return * b . templateVersionParameters , nil
2023-05-23 12:06:33 +04:00
}
2024-12-17 21:57:03 +00:00
func ( b * Builder ) getTemplateVersionVariables () ([] database . TemplateVersionVariable , error ) {
if b . templateVersionVariables != nil {
return * b . templateVersionVariables , nil
}
tvID , err := b . getTemplateVersionID ()
if err != nil {
return nil , xerrors . Errorf ( "get template version ID to get variables: %w" , err )
}
tvs , err := b . store . GetTemplateVersionVariables ( b . ctx , tvID )
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , xerrors . Errorf ( "get template version %s variables: %w" , tvID , err )
}
b . templateVersionVariables = & tvs
return tvs , nil
}
2023-06-02 11:16:46 +02:00
// verifyNoLegacyParameters verifies that initiator can't start the workspace build
// if it uses legacy parameters (database.ParameterSchemas).
func ( b * Builder ) verifyNoLegacyParameters () error {
if b . verifyNoLegacyParametersOnce {
return nil
2023-05-23 12:06:33 +04:00
}
2023-06-02 11:16:46 +02:00
b . verifyNoLegacyParametersOnce = true
// Block starting the workspace with legacy parameters.
if b . trans != database . WorkspaceTransitionStart {
return nil
2023-05-23 12:06:33 +04:00
}
2023-06-02 11:16:46 +02:00
templateVersionJob , err := b . getTemplateVersionJob ()
if err != nil {
return xerrors . Errorf ( "failed to fetch template version job: %w" , err )
}
parameterSchemas , err := b . store . GetParameterSchemasByJobID ( b . ctx , templateVersionJob . ID )
if xerrors . Is ( err , sql . ErrNoRows ) {
return nil
}
if err != nil {
return xerrors . Errorf ( "failed to get parameter schemas: %w" , err )
}
if len ( parameterSchemas ) > 0 {
return xerrors . Errorf ( "Legacy parameters in use on this version are not supported anymore. Contact your administrator for assistance." )
}
return nil
2023-05-23 12:06:33 +04:00
}
func ( b * Builder ) getLastBuildJob () ( * database . ProvisionerJob , error ) {
if b . lastBuildJob != nil {
return b . lastBuildJob , nil
}
bld , err := b . getLastBuild ()
if err != nil {
return nil , xerrors . Errorf ( "get last build to get job: %w" , err )
}
job , err := b . store . GetProvisionerJobByID ( b . ctx , bld . JobID )
if err != nil {
return nil , xerrors . Errorf ( "get build provisioner job %s: %w" , bld . JobID , err )
}
b . lastBuildJob = & job
return b . lastBuildJob , nil
}
2024-05-23 09:53:51 +02:00
func ( b * Builder ) getProvisionerTags () ( map [ string ] string , error ) {
2025-07-03 14:35:44 -05:00
if b . workspaceTags != nil {
return * b . workspaceTags , nil
}
var tags map [ string ] string
var err error
if b . usingDynamicParameters () {
tags , err = b . getDynamicProvisionerTags ()
} else {
tags , err = b . getClassicProvisionerTags ()
}
if err != nil {
return nil , xerrors . Errorf ( "get provisioner tags: %w" , err )
}
b . workspaceTags = & tags
return * b . workspaceTags , nil
}
func ( b * Builder ) getDynamicProvisionerTags () ( map [ string ] string , error ) {
// Step 1: Mutate template manually set version tags
templateVersionJob , err := b . getTemplateVersionJob ()
if err != nil {
return nil , BuildError { http . StatusInternalServerError , "failed to fetch template version job" , err }
}
annotationTags := provisionersdk . MutateTags ( b . workspace . OwnerID , templateVersionJob . Tags )
tags := map [ string ] string {}
for name , value := range annotationTags {
tags [ name ] = value
}
// Step 2: Fetch tags from the template
render , err := b . getDynamicParameterRenderer ()
if err != nil {
return nil , BuildError { http . StatusInternalServerError , "failed to get dynamic parameter renderer" , err }
}
names , values , err := b . getParameters ()
if err != nil {
return nil , xerrors . Errorf ( "tags render: %w" , err )
}
vals := make ( map [ string ] string , len ( names ))
for i , name := range names {
if i >= len ( values ) {
return nil , BuildError {
http . StatusInternalServerError ,
fmt . Sprintf ( "parameter names and values mismatch, %d names & %d values" , len ( names ), len ( values )),
xerrors . New ( "names and values mismatch" ),
}
}
vals [ name ] = values [ i ]
}
output , diags := render . Render ( b . ctx , b . workspace . OwnerID , vals )
tagErr := dynamicparameters . CheckTags ( output , diags )
if tagErr != nil {
2026-02-27 14:26:48 +00:00
return nil , BuildError { http . StatusBadRequest , "workspace tags validation failed" , tagErr }
2025-07-03 14:35:44 -05:00
}
for k , v := range output . WorkspaceTags . Tags () {
tags [ k ] = v
}
return tags , nil
}
func ( b * Builder ) getClassicProvisionerTags () ( map [ string ] string , error ) {
2024-05-23 09:53:51 +02:00
// Step 1: Mutate template version tags
templateVersionJob , err := b . getTemplateVersionJob ()
if err != nil {
return nil , BuildError { http . StatusInternalServerError , "failed to fetch template version job" , err }
}
annotationTags := provisionersdk . MutateTags ( b . workspace . OwnerID , templateVersionJob . Tags )
tags := map [ string ] string {}
for name , value := range annotationTags {
tags [ name ] = value
}
2024-12-17 21:57:03 +00:00
// Step 2: Mutate workspace tags:
// - Get workspace tags from the template version job
// - Get template version variables from the template version as they can be
// referenced in workspace tags
// - Get parameters from the workspace build as they can also be referenced
// in workspace tags
// - Evaluate workspace tags given the above inputs
2024-05-23 09:53:51 +02:00
workspaceTags , err := b . getTemplateVersionWorkspaceTags ()
if err != nil {
return nil , BuildError { http . StatusInternalServerError , "failed to fetch template version workspace tags" , err }
}
2024-12-17 21:57:03 +00:00
tvs , err := b . getTemplateVersionVariables ()
if err != nil {
return nil , BuildError { http . StatusInternalServerError , "failed to fetch template version variables" , err }
}
varsM := make ( map [ string ] string )
for _ , tv := range tvs {
// FIXME: do this in Terraform? This is a bit of a hack.
if tv . Value == "" {
varsM [ tv . Name ] = tv . DefaultValue
} else {
varsM [ tv . Name ] = tv . Value
}
}
2024-05-23 09:53:51 +02:00
parameterNames , parameterValues , err := b . getParameters ()
if err != nil {
return nil , err // already wrapped BuildError
}
2024-12-17 21:57:03 +00:00
paramsM := make ( map [ string ] string )
for i , name := range parameterNames {
paramsM [ name ] = parameterValues [ i ]
}
2024-05-23 09:53:51 +02:00
2024-12-17 21:57:03 +00:00
evalCtx := tfparse . BuildEvalContext ( varsM , paramsM )
2024-05-23 09:53:51 +02:00
for _ , workspaceTag := range workspaceTags {
expr , diags := hclsyntax . ParseExpression ([] byte ( workspaceTag . Value ), "expression.hcl" , hcl . InitialPos )
if diags . HasErrors () {
return nil , BuildError { http . StatusBadRequest , "failed to parse workspace tag value" , xerrors . Errorf ( diags . Error ())}
}
val , diags := expr . Value ( evalCtx )
if diags . HasErrors () {
return nil , BuildError { http . StatusBadRequest , "failed to evaluate workspace tag value" , xerrors . Errorf ( diags . Error ())}
}
// Do not use "val.AsString()" as it can panic
2024-12-17 21:57:03 +00:00
str , err := tfparse . CtyValueString ( val )
2024-05-23 09:53:51 +02:00
if err != nil {
return nil , BuildError { http . StatusBadRequest , "failed to marshal cty.Value as string" , err }
}
tags [ workspaceTag . Key ] = str
}
return tags , nil
}
func ( b * Builder ) getTemplateVersionWorkspaceTags () ([] database . TemplateVersionWorkspaceTag , error ) {
if b . templateVersionWorkspaceTags != nil {
return * b . templateVersionWorkspaceTags , nil
}
templateVersion , err := b . getTemplateVersion ()
if err != nil {
return nil , xerrors . Errorf ( "get template version: %w" , err )
}
workspaceTags , err := b . store . GetTemplateVersionWorkspaceTags ( b . ctx , templateVersion . ID )
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , xerrors . Errorf ( "get template version workspace tags: %w" , err )
}
b . templateVersionWorkspaceTags = & workspaceTags
return * b . templateVersionWorkspaceTags , nil
}
2025-06-23 12:35:15 -05:00
func ( b * Builder ) getPresetParameterValues () ([] database . TemplateVersionPresetParameter , error ) {
if b . templateVersionPresetParameterValues != nil {
return * b . templateVersionPresetParameterValues , nil
}
if b . templateVersionPresetID == uuid . Nil {
return [] database . TemplateVersionPresetParameter {}, nil
}
// Fetch and cache these, since we'll need them to override requested values if a preset was chosen
presetParameters , err := b . store . GetPresetParametersByPresetID ( b . ctx , b . templateVersionPresetID )
if err != nil {
return nil , xerrors . Errorf ( "failed to get preset parameters: %w" , err )
}
b . templateVersionPresetParameterValues = ptr . Ref ( presetParameters )
return * b . templateVersionPresetParameterValues , nil
}
2023-05-23 12:06:33 +04:00
// authorize performs build authorization pre-checks using the provided authFunc
2024-05-15 09:46:35 -05:00
func ( b * Builder ) authorize ( authFunc func ( action policy . Action , object rbac . Objecter ) bool ) error {
2023-05-23 12:06:33 +04:00
// Doing this up front saves a lot of work if the user doesn't have permission.
// This is checked again in the dbauthz layer, but the check is cached
// and will be a noop later.
2024-05-15 09:46:35 -05:00
var action policy . Action
2023-05-23 12:06:33 +04:00
switch b . trans {
case database . WorkspaceTransitionDelete :
2024-05-15 09:46:35 -05:00
action = policy . ActionDelete
2026-01-27 09:08:12 -08:00
case database . WorkspaceTransitionStart :
action = policy . ActionWorkspaceStart
if b . workspace . DormantAt . Valid {
// Dormant workspaces can't be started directly; they are
// first "woken" by unsetting dormancy, which makes the
// workspace.start permission apply.
action = policy . ActionUpdate
}
case database . WorkspaceTransitionStop :
action = policy . ActionWorkspaceStop
2023-05-23 12:06:33 +04:00
default :
2023-06-22 00:33:22 -04:00
msg := fmt . Sprintf ( "Transition %q not supported." , b . trans )
return BuildError { http . StatusBadRequest , msg , xerrors . New ( msg )}
2023-05-23 12:06:33 +04:00
}
2025-06-20 17:36:32 +01:00
2025-06-24 16:33:21 +01:00
// Try default workspace authorization first
authorized := authFunc ( action , b . workspace )
2025-06-20 17:36:32 +01:00
// Special handling for prebuilt workspace deletion
2025-06-24 16:33:21 +01:00
if ! authorized && action == policy . ActionDelete && b . workspace . IsPrebuild () {
authorized = authFunc ( action , b . workspace . AsPrebuild ())
2025-06-20 17:36:32 +01:00
}
if ! authorized {
2025-02-27 05:23:18 -06:00
if authFunc ( policy . ActionRead , b . workspace ) {
// If the user can read the workspace, but not delete/create/update. Show
// a more helpful error. They are allowed to know the workspace exists.
return BuildError {
Status : http . StatusForbidden ,
Message : fmt . Sprintf ( "You do not have permission to %s this workspace." , action ),
Wrapped : xerrors . New ( httpapi . ResourceForbiddenResponse . Detail ),
}
}
2023-05-23 12:06:33 +04:00
// We use the same wording as the httpapi to avoid leaking the existence of the workspace
2023-06-22 00:33:22 -04:00
return BuildError { http . StatusNotFound , httpapi . ResourceNotFoundResponse . Message , xerrors . New ( httpapi . ResourceNotFoundResponse . Message )}
2023-05-23 12:06:33 +04:00
}
template , err := b . getTemplate ()
if err != nil {
return BuildError { http . StatusInternalServerError , "failed to fetch template" , err }
}
// If custom state, deny request since user could be corrupting or leaking
// cloud state.
if b . state . explicit != nil || b . state . orphan {
2024-05-15 09:46:35 -05:00
if ! authFunc ( policy . ActionUpdate , template . RBACObject ()) {
2023-06-22 00:33:22 -04:00
return BuildError { http . StatusForbidden , "Only template managers may provide custom state" , xerrors . New ( "Only template managers may provide custom state" )}
2023-05-23 12:06:33 +04:00
}
}
2024-05-15 11:09:42 -05:00
if b . logLevel != "" && ! authFunc ( policy . ActionRead , rbac . ResourceDeploymentConfig ) {
2023-05-23 12:06:33 +04:00
return BuildError {
http . StatusBadRequest ,
2023-06-29 15:22:21 +02:00
"Workspace builds with a custom log level are restricted to administrators only." ,
xerrors . New ( "Workspace builds with a custom log level are restricted to administrators only." ),
}
}
if b . logLevel != "" && b . deploymentValues != nil && ! b . deploymentValues . EnableTerraformDebugMode {
return BuildError {
http . StatusBadRequest ,
"Terraform debug mode is disabled in the deployment configuration." ,
xerrors . New ( "Terraform debug mode is disabled in the deployment configuration." ),
2023-05-23 12:06:33 +04:00
}
}
return nil
}
func ( b * Builder ) checkTemplateVersionMatchesTemplate () error {
template , err := b . getTemplate ()
if err != nil {
return BuildError { http . StatusInternalServerError , "failed to fetch template" , err }
}
templateVersion , err := b . getTemplateVersion ()
if xerrors . Is ( err , sql . ErrNoRows ) {
return BuildError { http . StatusBadRequest , "template version does not exist" , err }
}
if err != nil {
return BuildError { http . StatusInternalServerError , "failed to fetch template version" , err }
}
if ! templateVersion . TemplateID . Valid || templateVersion . TemplateID . UUID != template . ID {
return BuildError {
http . StatusBadRequest ,
"template version doesn't match template" ,
xerrors . Errorf ( "templateVersion.TemplateID = %+v, template.ID = %s" ,
templateVersion . TemplateID , template . ID ),
}
}
return nil
}
func ( b * Builder ) checkTemplateJobStatus () error {
templateVersion , err := b . getTemplateVersion ()
if err != nil {
return BuildError { http . StatusInternalServerError , "failed to fetch template version" , err }
}
templateVersionJob , err := b . getTemplateVersionJob ()
if err != nil {
return BuildError {
http . StatusInternalServerError , "failed to fetch template version job" , err ,
}
}
2023-10-04 20:57:46 -05:00
templateVersionJobStatus := codersdk . ProvisionerJobStatus ( templateVersionJob . JobStatus )
2023-05-23 12:06:33 +04:00
switch templateVersionJobStatus {
case codersdk . ProvisionerJobPending , codersdk . ProvisionerJobRunning :
2023-06-22 00:33:22 -04:00
msg := fmt . Sprintf ( "The provided template version is %s. Wait for it to complete importing!" , templateVersionJobStatus )
2023-05-23 12:06:33 +04:00
return BuildError {
http . StatusNotAcceptable ,
2023-06-22 00:33:22 -04:00
msg ,
xerrors . New ( msg ),
2023-05-23 12:06:33 +04:00
}
case codersdk . ProvisionerJobFailed :
2023-06-22 00:33:22 -04:00
msg := fmt . Sprintf ( "The provided template version %q has failed to import: %q. You cannot build workspaces with it!" , templateVersion . Name , templateVersionJob . Error . String )
2023-05-23 12:06:33 +04:00
return BuildError {
http . StatusBadRequest ,
2023-06-22 00:33:22 -04:00
msg ,
xerrors . New ( msg ),
2023-05-23 12:06:33 +04:00
}
case codersdk . ProvisionerJobCanceled :
2023-06-22 00:33:22 -04:00
msg := fmt . Sprintf ( "The provided template version %q has failed to import: %q. You cannot build workspaces with it!" , templateVersion . Name , templateVersionJob . Error . String )
2023-05-23 12:06:33 +04:00
return BuildError {
http . StatusBadRequest ,
2023-06-22 00:33:22 -04:00
msg ,
xerrors . New ( msg ),
2023-05-23 12:06:33 +04:00
}
}
return nil
}
2025-07-22 13:39:26 +10:00
func ( b * Builder ) checkUsage () error {
templateVersion , err := b . getTemplateVersion ()
if err != nil {
return BuildError { http . StatusInternalServerError , "Failed to fetch template version" , err }
}
2026-01-27 19:01:17 -06:00
task , err := b . getWorkspaceTask ()
if err != nil {
return BuildError { http . StatusInternalServerError , "Failed to fetch workspace task" , err }
}
resp , err := b . usageChecker . CheckBuildUsage ( b . ctx , b . store , templateVersion , task , b . trans )
2025-07-22 13:39:26 +10:00
if err != nil {
return BuildError { http . StatusInternalServerError , "Failed to check build usage" , err }
}
if ! resp . Permitted {
return BuildError { http . StatusForbidden , "Build is not permitted: " + resp . Message , nil }
}
return nil
}
2023-05-23 12:06:33 +04:00
func ( b * Builder ) checkRunningBuild () error {
job , err := b . getLastBuildJob ()
if xerrors . Is ( err , sql . ErrNoRows ) {
// no prior build, so it can't be running!
return nil
}
if err != nil {
return BuildError { http . StatusInternalServerError , "failed to fetch prior build" , err }
}
2023-10-04 20:57:46 -05:00
if codersdk . ProvisionerJobStatus ( job . JobStatus ). Active () {
2023-06-22 00:33:22 -04:00
msg := "A workspace build is already active."
2023-05-23 12:06:33 +04:00
return BuildError {
http . StatusConflict ,
2023-06-22 00:33:22 -04:00
msg ,
xerrors . New ( msg ),
2023-05-23 12:06:33 +04:00
}
}
return nil
}
2025-05-20 10:09:53 -05:00
func ( b * Builder ) usingDynamicParameters () bool {
2025-06-12 17:15:05 +01:00
tpl , err := b . getTemplate ()
if err != nil {
return false // Let another part of the code get this error
}
if tpl . UseClassicParameterFlow {
2025-05-20 10:09:53 -05:00
return false
}
2025-06-12 17:15:05 +01:00
return true
2025-05-20 10:09:53 -05:00
}