2022-11-07 19:10:49 -06:00
package provisionerdserver
import (
"context"
2025-05-12 13:50:07 -06:00
"crypto/sha256"
2022-11-07 19:10:49 -06:00
"database/sql"
2025-05-12 13:50:07 -06:00
"encoding/hex"
2022-11-07 19:10:49 -06:00
"encoding/json"
"errors"
"fmt"
2022-11-22 13:22:56 -05:00
"net/http"
2022-11-07 19:10:49 -06:00
"net/url"
"reflect"
2025-03-03 21:46:49 +08:00
"slices"
2024-08-27 16:35:28 +02:00
"sort"
2022-12-02 15:14:45 -05:00
"strconv"
2023-02-15 18:24:15 +01:00
"strings"
2026-08-11 11:04:51 -05:00
"sync"
2022-11-14 11:57:33 -06:00
"sync/atomic"
2022-11-07 19:10:49 -06:00
"time"
"github.com/google/uuid"
2023-07-15 09:07:19 +03:00
"github.com/sqlc-dev/pqtype"
2023-05-03 18:02:35 -05:00
semconv "go.opentelemetry.io/otel/semconv/v1.14.0"
"go.opentelemetry.io/otel/trace"
2022-11-22 13:01:28 +02:00
"golang.org/x/exp/maps"
2023-03-17 15:25:08 -05:00
"golang.org/x/oauth2"
2022-11-07 19:10:49 -06:00
"golang.org/x/xerrors"
protobuf "google.golang.org/protobuf/proto"
2026-01-08 10:29:41 +04:00
"cdr.dev/slog/v3"
2026-03-16 12:36:26 -05:00
"github.com/coder/coder/v2/coderd/aiseats"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/apikey"
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/dbauthz"
2023-09-01 19:50:12 +03:00
"github.com/coder/coder/v2/coderd/database/dbtime"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database/pubsub"
2023-09-30 14:30:01 -05:00
"github.com/coder/coder/v2/coderd/externalauth"
2024-07-08 15:38:50 +02:00
"github.com/coder/coder/v2/coderd/notifications"
2025-05-14 14:15:36 +02:00
"github.com/coder/coder/v2/coderd/prebuilds"
2024-01-10 09:13:30 -06:00
"github.com/coder/coder/v2/coderd/promoauth"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/schedule"
"github.com/coder/coder/v2/coderd/telemetry"
"github.com/coder/coder/v2/coderd/tracing"
2025-08-20 23:48:38 +10:00
"github.com/coder/coder/v2/coderd/usage"
"github.com/coder/coder/v2/coderd/util/slice"
2024-11-01 14:17:05 +11:00
"github.com/coder/coder/v2/coderd/wspubsub"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/codersdk"
2025-05-14 14:15:36 +02:00
"github.com/coder/coder/v2/codersdk/agentsdk"
2025-08-20 23:48:38 +10:00
"github.com/coder/coder/v2/codersdk/drpcsdk"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/provisioner"
"github.com/coder/coder/v2/provisionerd/proto"
"github.com/coder/coder/v2/provisionersdk"
sdkproto "github.com/coder/coder/v2/provisionersdk/proto"
2025-08-20 23:48:38 +10:00
"github.com/coder/quartz"
2022-11-07 19:10:49 -06:00
)
2025-05-12 13:50:07 -06:00
const (
tarMimeType = "application/x-tar"
)
2023-12-18 16:44:52 +00:00
const (
// DefaultAcquireJobLongPollDur is the time the (deprecated) AcquireJob rpc waits to try to obtain a job before
// canceling and returning an empty job.
DefaultAcquireJobLongPollDur = time . Second * 5
// DefaultHeartbeatInterval is the interval at which the provisioner daemon
// will update its last seen at timestamp in the database.
DefaultHeartbeatInterval = time . Minute
2024-11-28 12:57:43 +00:00
// StaleInterval is the amount of time after the last heartbeat for which
// the provisioner will be reported as 'stale'.
StaleInterval = 90 * time . Second
2023-12-18 16:44:52 +00:00
)
2022-11-10 16:37:33 -06:00
2023-08-30 14:48:35 +04:00
type Options struct {
2024-01-10 09:13:30 -06:00
OIDCConfig promoauth . OAuth2Config
2023-09-30 14:30:01 -05:00
ExternalAuthConfigs [] * externalauth . Config
2026-03-16 12:36:26 -05:00
AISeatTracker aiseats . SeatTracker
2024-11-25 16:25:36 +00:00
2026-08-11 11:04:51 -05:00
// KeyID is the provisioner key the daemon authenticated with, or the
// zero value if it did not authenticate with a key.
KeyID uuid . UUID
// SessionCancel terminates the daemon's session. Required when KeyID is a
// deletable provisioner key; optional otherwise.
SessionCancel context . CancelFunc
2024-11-25 16:25:36 +00:00
// Clock for testing
Clock quartz . Clock
2023-09-19 10:25:57 +04:00
// AcquireJobLongPollDur is used in tests
AcquireJobLongPollDur time . Duration
2023-12-18 16:44:52 +00:00
// HeartbeatInterval is the interval at which the provisioner daemon
// will update its last seen at timestamp in the database.
HeartbeatInterval time . Duration
// HeartbeatFn is the function that will be called at the interval
// specified by HeartbeatInterval.
// The default function just calls UpdateProvisionerDaemonLastSeenAt.
// This is mainly used for testing.
HeartbeatFn func ( context . Context ) error
2023-08-30 14:48:35 +04:00
}
type server struct {
2025-05-14 12:21:36 -05:00
apiVersion string
2023-10-16 13:50:07 +01:00
// lifecycleCtx must be tied to the API server's lifecycle
// as when the API server shuts down, we want to cancel any
// long-running operations.
lifecycleCtx context . Context
2023-07-20 06:35:41 -07:00
AccessURL * url . URL
ID uuid . UUID
2026-08-11 11:04:51 -05:00
KeyID uuid . UUID
sessionCancel context . CancelFunc
2024-03-18 12:48:13 -05:00
OrganizationID uuid . UUID
2023-07-20 06:35:41 -07:00
Logger slog . Logger
Provisioners [] database . ProvisionerType
2023-09-30 14:30:01 -05:00
ExternalAuthConfigs [] * externalauth . Config
2023-09-19 10:25:57 +04:00
Tags Tags
2023-07-20 06:35:41 -07:00
Database database . Store
Pubsub pubsub . Pubsub
2023-09-19 10:25:57 +04:00
Acquirer * Acquirer
2023-07-20 06:35:41 -07:00
Telemetry telemetry . Reporter
Tracer trace . Tracer
QuotaCommitter * atomic . Pointer [ proto . QuotaCommitter ]
Auditor * atomic . Pointer [ audit . Auditor ]
TemplateScheduleStore * atomic . Pointer [ schedule . TemplateScheduleStore ]
UserQuietHoursScheduleStore * atomic . Pointer [ schedule . UserQuietHoursScheduleStore ]
DeploymentValues * codersdk . DeploymentValues
2024-07-24 13:38:21 -03:00
NotificationsEnqueuer notifications . Enqueuer
2025-05-14 14:52:22 +02:00
PrebuildsOrchestrator * atomic . Pointer [ prebuilds . ReconciliationOrchestrator ]
2025-08-20 23:38:09 +10:00
UsageInserter * atomic . Pointer [ usage . Inserter ]
2026-03-16 12:36:26 -05:00
AISeatTracker aiseats . SeatTracker
2025-11-12 14:26:15 -06:00
Experiments codersdk . Experiments
2022-11-10 16:37:33 -06:00
2024-01-10 09:13:30 -06:00
OIDCConfig promoauth . OAuth2Config
2023-07-20 06:35:41 -07:00
2024-11-25 16:25:36 +00:00
Clock quartz . Clock
2023-09-19 10:25:57 +04:00
acquireJobLongPollDur time . Duration
2023-12-18 16:44:52 +00:00
heartbeatInterval time . Duration
heartbeatFn func ( ctx context . Context ) error
2025-08-28 15:00:26 +01:00
2026-08-11 11:04:51 -05:00
// jobMu guards activeJobs and terminationPending.
jobMu sync . Mutex
// activeJobs tracks jobs claimed by this session that have not yet been
// completed or failed. The in-tree provisioner daemon runs jobs serially,
// so at most one entry is expected; the protocol does not enforce this.
activeJobs map [ uuid . UUID ] struct {}
// terminationPending records a termination request that arrived while a
// job was active; it is performed when the last active job finishes.
terminationPending bool
2025-08-28 15:00:26 +01:00
metrics * Metrics
2023-07-20 06:35:41 -07:00
}
2023-09-13 16:36:43 +04:00
// We use the null byte (0x00) in generating a canonical map key for tags, so
// it cannot be used in the tag keys or values.
2025-03-26 01:56:39 -05:00
var ErrTagsContainNullByte = xerrors . New ( "tags cannot contain the null byte (0x00)" )
2023-09-13 16:36:43 +04:00
2026-08-11 11:04:51 -05:00
// ErrProvisionerKeyDeleted is returned from job acquisition when the
// provisioner key the daemon authenticated with no longer exists.
var ErrProvisionerKeyDeleted = xerrors . New ( "provisioner key was deleted" )
2023-09-13 16:36:43 +04:00
type Tags map [ string ] string
func ( t Tags ) ToJSON () ( json . RawMessage , error ) {
r , err := json . Marshal ( t )
if err != nil {
return nil , err
}
return r , err
}
func ( t Tags ) Valid () error {
for k , v := range t {
if slices . Contains ([] byte ( k ), 0x00 ) || slices . Contains ([] byte ( v ), 0x00 ) {
2025-03-26 01:56:39 -05:00
return ErrTagsContainNullByte
2023-09-13 16:36:43 +04:00
}
}
return nil
}
2026-08-11 11:04:51 -05:00
// Server is the provisioner daemon DRPC server plus session-lifecycle hooks
// used by the serve handlers.
type Server interface {
proto . DRPCProvisionerDaemonServer
// TerminateSession cancels the session once no acquired job is
// active. Safe to call from any goroutine.
TerminateSession ()
}
2025-05-14 12:21:36 -05:00
func NewServer (
lifecycleCtx context . Context ,
apiVersion string ,
2023-08-30 14:48:35 +04:00
accessURL * url . URL ,
id uuid . UUID ,
2024-03-18 12:48:13 -05:00
organizationID uuid . UUID ,
2023-08-30 14:48:35 +04:00
logger slog . Logger ,
provisioners [] database . ProvisionerType ,
2023-09-19 10:25:57 +04:00
tags Tags ,
2023-08-30 14:48:35 +04:00
db database . Store ,
ps pubsub . Pubsub ,
2023-09-19 10:25:57 +04:00
acquirer * Acquirer ,
2023-08-30 14:48:35 +04:00
tel telemetry . Reporter ,
tracer trace . Tracer ,
quotaCommitter * atomic . Pointer [ proto . QuotaCommitter ],
auditor * atomic . Pointer [ audit . Auditor ],
templateScheduleStore * atomic . Pointer [ schedule . TemplateScheduleStore ],
userQuietHoursScheduleStore * atomic . Pointer [ schedule . UserQuietHoursScheduleStore ],
2025-08-20 23:38:09 +10:00
usageInserter * atomic . Pointer [ usage . Inserter ],
2023-08-30 14:48:35 +04:00
deploymentValues * codersdk . DeploymentValues ,
options Options ,
2024-07-08 15:38:50 +02:00
enqueuer notifications . Enqueuer ,
2025-05-14 14:52:22 +02:00
prebuildsOrchestrator * atomic . Pointer [ prebuilds . ReconciliationOrchestrator ],
2025-08-28 15:00:26 +01:00
metrics * Metrics ,
2025-11-12 14:26:15 -06:00
experiments codersdk . Experiments ,
2026-08-11 11:04:51 -05:00
) ( Server , error ) {
2023-10-16 13:50:07 +01:00
// Fail-fast if pointers are nil
if lifecycleCtx == nil {
return nil , xerrors . New ( "ctx is nil" )
}
2026-08-11 11:04:51 -05:00
// A deletable key's session must be cancelable, otherwise key deletion
// cannot terminate it.
if codersdk . IsDeletableProvisionerKey ( options . KeyID ) && options . SessionCancel == nil {
return nil , xerrors . New ( "SessionCancel is required when KeyID is a deletable provisioner key" )
}
2023-08-30 14:48:35 +04:00
if quotaCommitter == nil {
return nil , xerrors . New ( "quotaCommitter is nil" )
}
if auditor == nil {
return nil , xerrors . New ( "auditor is nil" )
}
if templateScheduleStore == nil {
return nil , xerrors . New ( "templateScheduleStore is nil" )
}
if userQuietHoursScheduleStore == nil {
return nil , xerrors . New ( "userQuietHoursScheduleStore is nil" )
}
2025-08-20 23:38:09 +10:00
if usageInserter == nil {
return nil , xerrors . New ( "usageCollector is nil" )
}
2023-08-30 14:48:35 +04:00
if deploymentValues == nil {
return nil , xerrors . New ( "deploymentValues is nil" )
}
2023-09-19 10:25:57 +04:00
if acquirer == nil {
return nil , xerrors . New ( "acquirer is nil" )
}
if tags == nil {
return nil , xerrors . Errorf ( "tags is nil" )
}
if err := tags . Valid (); err != nil {
return nil , xerrors . Errorf ( "invalid tags: %w" , err )
}
2026-03-16 12:36:26 -05:00
if options . AISeatTracker == nil {
options . AISeatTracker = aiseats . Noop {}
}
2023-09-19 10:25:57 +04:00
if options . AcquireJobLongPollDur == 0 {
options . AcquireJobLongPollDur = DefaultAcquireJobLongPollDur
}
2023-12-18 16:44:52 +00:00
if options . HeartbeatInterval == 0 {
options . HeartbeatInterval = DefaultHeartbeatInterval
}
2024-11-25 16:25:36 +00:00
if options . Clock == nil {
options . Clock = quartz . NewReal ()
}
2023-12-18 16:44:52 +00:00
s := & server {
2023-10-16 13:50:07 +01:00
lifecycleCtx : lifecycleCtx ,
2025-05-14 12:21:36 -05:00
apiVersion : apiVersion ,
2023-08-30 14:48:35 +04:00
AccessURL : accessURL ,
ID : id ,
2026-08-11 11:04:51 -05:00
KeyID : options . KeyID ,
sessionCancel : options . SessionCancel ,
2024-03-18 12:48:13 -05:00
OrganizationID : organizationID ,
2023-08-30 14:48:35 +04:00
Logger : logger ,
Provisioners : provisioners ,
2023-09-29 14:13:20 -05:00
ExternalAuthConfigs : options . ExternalAuthConfigs ,
2023-08-30 14:48:35 +04:00
Tags : tags ,
Database : db ,
Pubsub : ps ,
2023-09-19 10:25:57 +04:00
Acquirer : acquirer ,
2024-07-24 13:38:21 -03:00
NotificationsEnqueuer : enqueuer ,
2023-08-30 14:48:35 +04:00
Telemetry : tel ,
Tracer : tracer ,
QuotaCommitter : quotaCommitter ,
Auditor : auditor ,
TemplateScheduleStore : templateScheduleStore ,
UserQuietHoursScheduleStore : userQuietHoursScheduleStore ,
DeploymentValues : deploymentValues ,
OIDCConfig : options . OIDCConfig ,
2024-11-25 16:25:36 +00:00
Clock : options . Clock ,
2023-09-19 10:25:57 +04:00
acquireJobLongPollDur : options . AcquireJobLongPollDur ,
2023-12-18 16:44:52 +00:00
heartbeatInterval : options . HeartbeatInterval ,
heartbeatFn : options . HeartbeatFn ,
2025-05-14 14:52:22 +02:00
PrebuildsOrchestrator : prebuildsOrchestrator ,
2025-08-20 23:38:09 +10:00
UsageInserter : usageInserter ,
2026-03-16 12:36:26 -05:00
AISeatTracker : options . AISeatTracker ,
2026-08-11 11:04:51 -05:00
activeJobs : map [ uuid . UUID ] struct {}{},
2025-08-28 15:00:26 +01:00
metrics : metrics ,
2025-11-12 14:26:15 -06:00
Experiments : experiments ,
2023-12-18 16:44:52 +00:00
}
2023-12-18 17:11:50 +00:00
if s . heartbeatFn == nil {
s . heartbeatFn = s . defaultHeartbeat
}
2023-12-18 16:44:52 +00:00
go s . heartbeatLoop ()
return s , nil
2023-08-30 14:48:35 +04:00
}
2023-07-20 06:35:41 -07:00
// timeNow should be used when trying to get the current time for math
// calculations regarding workspace start and stop time.
2024-11-25 16:25:36 +00:00
func ( s * server ) timeNow ( tags ... string ) time . Time {
return dbtime . Time ( s . Clock . Now ( tags ... ))
2022-11-07 19:10:49 -06:00
}
2023-12-18 16:44:52 +00:00
// heartbeatLoop runs heartbeatOnce at the interval specified by HeartbeatInterval
// until the lifecycle context is canceled.
func ( s * server ) heartbeatLoop () {
tick := time . NewTicker ( time . Nanosecond )
defer tick . Stop ()
for {
select {
case <- s . lifecycleCtx . Done ():
s . Logger . Debug ( s . lifecycleCtx , "heartbeat loop canceled" )
return
case <- tick . C :
if s . lifecycleCtx . Err () != nil {
return
}
start := s . timeNow ()
hbCtx , hbCancel := context . WithTimeout ( s . lifecycleCtx , s . heartbeatInterval )
2024-01-09 14:38:56 +04:00
if err := s . heartbeat ( hbCtx ); err != nil && ! database . IsQueryCanceledError ( err ) {
2024-04-24 09:36:36 +01:00
s . Logger . Warn ( hbCtx , "heartbeat failed" , slog . Error ( err ))
2023-12-18 16:44:52 +00:00
}
2026-08-11 11:04:51 -05:00
// The key check rides the heartbeat tick so a session whose deletable
// key is gone terminates within one interval. Transient errors are
// logged and the session is left running.
if deleted , err := s . keyDeleted ( hbCtx ); err != nil && ! database . IsQueryCanceledError ( err ) {
s . Logger . Warn ( hbCtx , "check provisioner key on heartbeat" , slog . Error ( err ))
} else if deleted {
s . Logger . Warn ( hbCtx , "provisioner key deleted, canceling session" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
s . TerminateSession ()
}
2023-12-18 16:44:52 +00:00
hbCancel ()
elapsed := s . timeNow (). Sub ( start )
nextBeat := s . heartbeatInterval - elapsed
// avoid negative interval
if nextBeat <= 0 {
nextBeat = time . Nanosecond
}
tick . Reset ( nextBeat )
}
}
}
// heartbeat updates the last seen at timestamp in the database.
// If HeartbeatFn is set, it will be called instead.
func ( s * server ) heartbeat ( ctx context . Context ) error {
select {
case <- ctx . Done ():
return nil
default :
return s . heartbeatFn ( ctx )
}
}
2023-12-18 17:11:50 +00:00
func ( s * server ) defaultHeartbeat ( ctx context . Context ) error {
//nolint:gocritic // This is specifically for updating the last seen at timestamp.
return s . Database . UpdateProvisionerDaemonLastSeenAt ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateProvisionerDaemonLastSeenAtParams {
ID : s . ID ,
LastSeenAt : sql . NullTime { Time : s . timeNow (), Valid : true },
})
}
2026-08-11 11:04:51 -05:00
// keyDeleted reports whether the provisioner key no longer exists.
func ( s * server ) keyDeleted ( ctx context . Context ) ( bool , error ) {
if ! codersdk . IsDeletableProvisionerKey ( s . KeyID ) {
return false , nil
}
_ , err := s . Database . GetProvisionerKeyByID (
//nolint:gocritic // Callers' contexts cannot read provisioner keys
// (provisionerd actor or no actor at all), so scope the read to this
// narrow subject.
dbauthz . AsSystemReadProvisionerDaemons ( ctx ), s . KeyID )
if errors . Is ( err , sql . ErrNoRows ) {
return true , nil
}
if err != nil {
return false , xerrors . Errorf ( "get provisioner key: %w" , err )
}
return false , nil
}
// TerminateSession cancels the session. Cancellation is deferred while a job
// claimed by this session is active so the daemon can report the job's
// result; the last active job's completion performs it. Requires a configured
// sessionCancel.
func ( s * server ) TerminateSession () {
s . jobMu . Lock ()
if len ( s . activeJobs ) > 0 {
s . terminationPending = true
s . jobMu . Unlock ()
s . Logger . Info ( s . lifecycleCtx , "deferring session cancellation until active jobs finish" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
return
}
s . jobMu . Unlock ()
s . sessionCancel ()
}
// jobStarted records a job claimed by this session as active.
func ( s * server ) jobStarted ( id uuid . UUID ) {
s . jobMu . Lock ()
defer s . jobMu . Unlock ()
s . activeJobs [ id ] = struct {}{}
}
// jobFinished removes an active job and performs a termination deferred while
// jobs were active. The daemon may not receive the final RPC response when
// this cancels the session; the job's outcome is already persisted.
func ( s * server ) jobFinished ( id uuid . UUID ) {
s . jobMu . Lock ()
delete ( s . activeJobs , id )
terminate := s . terminationPending && len ( s . activeJobs ) == 0
s . jobMu . Unlock ()
if ! terminate {
return
}
s . Logger . Warn ( s . lifecycleCtx , "canceling session after job completion" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
s . sessionCancel ()
}
2022-11-07 19:10:49 -06:00
// AcquireJob queries the database to lock a job.
2023-09-19 10:25:57 +04:00
//
// Deprecated: This method is only available for back-level provisioner daemons.
2023-08-30 14:48:35 +04:00
func ( s * server ) AcquireJob ( ctx context . Context , _ * proto . Empty ) ( * proto . AcquiredJob , error ) {
2023-02-15 16:14:37 +00:00
//nolint:gocritic // Provisionerd has specific authz rules.
ctx = dbauthz . AsProvisionerd ( ctx )
2026-08-11 11:04:51 -05:00
if deleted , err := s . keyDeleted ( ctx ); err != nil {
return nil , xerrors . Errorf ( "acquire job: check provisioner key: %w" , err )
} else if deleted {
s . Logger . Warn ( ctx , "provisioner key deleted, rejecting job acquisition" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
s . TerminateSession ()
return nil , xerrors . Errorf ( "acquire job: %w" , ErrProvisionerKeyDeleted )
}
2023-09-19 10:25:57 +04:00
// Since AcquireJob blocks until a job is available, we set a long (5s by default) timeout. This allows back-level
// provisioner daemons to gracefully shut down within a few seconds, but keeps them from rapidly polling the
// database.
acqCtx , acqCancel := context . WithTimeout ( ctx , s . acquireJobLongPollDur )
defer acqCancel ()
2026-08-11 11:04:51 -05:00
job , err := s . Acquirer . AcquireJob ( acqCtx , s . OrganizationID , s . ID , s . Provisioners , s . Tags , s . KeyID )
2025-06-18 22:50:53 -04:00
if database . IsQueryCanceledError ( err ) {
2023-09-19 10:25:57 +04:00
s . Logger . Debug ( ctx , "successful cancel" )
2022-11-07 19:10:49 -06:00
return & proto . AcquiredJob {}, nil
}
2026-08-11 11:04:51 -05:00
if errors . Is ( err , ErrProvisionerKeyDeleted ) {
s . Logger . Warn ( ctx , "provisioner key deleted, rejecting job acquisition" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
s . TerminateSession ()
}
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "acquire job: %w" , err )
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "locked job from database" , slog . F ( "job_id" , job . ID ))
2026-08-11 11:04:51 -05:00
s . jobStarted ( job . ID )
pj , err := s . acquireProtoJob ( ctx , job )
if err != nil {
s . jobFinished ( job . ID )
return nil , err
}
return pj , nil
2023-09-19 10:25:57 +04:00
}
2022-11-07 19:10:49 -06:00
2023-09-19 10:25:57 +04:00
type jobAndErr struct {
job database . ProvisionerJob
err error
}
// AcquireJobWithCancel queries the database to lock a job.
func ( s * server ) AcquireJobWithCancel ( stream proto . DRPCProvisionerDaemon_AcquireJobWithCancelStream ) ( retErr error ) {
//nolint:gocritic // Provisionerd has specific authz rules.
streamCtx := dbauthz . AsProvisionerd ( stream . Context ())
defer func () {
closeErr := stream . Close ()
s . Logger . Debug ( streamCtx , "closed stream" , slog . Error ( closeErr ))
if retErr == nil {
retErr = closeErr
}
}()
2026-08-11 11:04:51 -05:00
if deleted , err := s . keyDeleted ( streamCtx ); err != nil {
return xerrors . Errorf ( "acquire job: check provisioner key: %w" , err )
} else if deleted {
s . Logger . Warn ( streamCtx , "provisioner key deleted, rejecting job acquisition" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
s . TerminateSession ()
return xerrors . Errorf ( "acquire job: %w" , ErrProvisionerKeyDeleted )
}
2023-09-19 10:25:57 +04:00
acqCtx , acqCancel := context . WithCancel ( streamCtx )
defer acqCancel ()
recvCh := make ( chan error , 1 )
go func () {
_ , err := stream . Recv () // cancel is the only message
recvCh <- err
}()
jec := make ( chan jobAndErr , 1 )
go func () {
2026-08-11 11:04:51 -05:00
job , err := s . Acquirer . AcquireJob ( acqCtx , s . OrganizationID , s . ID , s . Provisioners , s . Tags , s . KeyID )
2023-09-19 10:25:57 +04:00
jec <- jobAndErr { job : job , err : err }
}()
var recvErr error
var je jobAndErr
select {
case recvErr = <- recvCh :
acqCancel ()
je = <- jec
case je = <- jec :
}
2025-06-18 22:51:13 -04:00
if database . IsQueryCanceledError ( je . err ) {
2023-09-19 10:25:57 +04:00
s . Logger . Debug ( streamCtx , "successful cancel" )
err := stream . Send ( & proto . AcquiredJob {})
if err != nil {
// often this is just because the other side hangs up and doesn't wait for the cancel, so log at INFO
s . Logger . Info ( streamCtx , "failed to send empty job" , slog . Error ( err ))
return err
}
return nil
}
2026-08-11 11:04:51 -05:00
if errors . Is ( je . err , ErrProvisionerKeyDeleted ) {
s . Logger . Warn ( streamCtx , "provisioner key deleted, rejecting job acquisition" ,
slog . F ( "provisioner_key_id" , s . KeyID ))
s . TerminateSession ()
}
2023-09-19 10:25:57 +04:00
if je . err != nil {
return xerrors . Errorf ( "acquire job: %w" , je . err )
}
logger := s . Logger . With ( slog . F ( "job_id" , je . job . ID ))
logger . Debug ( streamCtx , "locked job from database" )
2026-08-11 11:04:51 -05:00
s . jobStarted ( je . job . ID )
2023-09-19 10:25:57 +04:00
if recvErr != nil {
logger . Error ( streamCtx , "recv error and failed to cancel acquire job" , slog . Error ( recvErr ))
// Well, this is awkward. We hit an error receiving from the stream, but didn't cancel before we locked a job
// in the database. We need to mark this job as failed so the end user can retry if they want to.
2026-08-11 11:04:51 -05:00
s . failAcquiredJob ( logger , je . job . ID , "connection to provisioner daemon broken" )
s . jobFinished ( je . job . ID )
2023-09-19 10:25:57 +04:00
return recvErr
}
pj , err := s . acquireProtoJob ( streamCtx , je . job )
if err != nil {
2026-08-11 11:04:51 -05:00
// acquireProtoJob marks the job failed itself.
s . jobFinished ( je . job . ID )
2023-09-19 10:25:57 +04:00
return err
}
err = stream . Send ( pj )
if err != nil {
s . Logger . Error ( streamCtx , "failed to send job" , slog . Error ( err ))
2026-08-11 11:04:51 -05:00
// The job was locked but never delivered, so mark it failed instead of
// leaving it assigned to a worker that does not have it.
s . failAcquiredJob ( logger , je . job . ID , "connection to provisioner daemon broken" )
s . jobFinished ( je . job . ID )
2023-09-19 10:25:57 +04:00
return err
}
return nil
}
2026-08-11 11:04:51 -05:00
// failAcquiredJob marks a job that was claimed but never delivered to the
// daemon as failed. It uses a fresh context so the update succeeds even when
// the session context is canceled.
func ( s * server ) failAcquiredJob ( logger slog . Logger , jobID uuid . UUID , message string ) {
now := s . timeNow ()
err := s . Database . UpdateProvisionerJobWithCompleteByID (
//nolint:gocritic // Provisionerd has specific authz rules.
dbauthz . AsProvisionerd ( context . Background ()),
database . UpdateProvisionerJobWithCompleteByIDParams {
ID : jobID ,
2022-11-07 19:10:49 -06:00
CompletedAt : sql . NullTime {
2026-08-11 11:04:51 -05:00
Time : now ,
2022-11-07 19:10:49 -06:00
Valid : true ,
},
2026-08-11 11:04:51 -05:00
UpdatedAt : now ,
2022-11-07 19:10:49 -06:00
Error : sql . NullString {
2026-08-11 11:04:51 -05:00
String : message ,
2022-11-07 19:10:49 -06:00
Valid : true ,
},
2026-08-11 11:04:51 -05:00
ErrorCode : sql . NullString {},
2022-11-07 19:10:49 -06:00
})
2026-08-11 11:04:51 -05:00
if err != nil {
logger . Error ( s . lifecycleCtx , "error updating failed job" , slog . Error ( err ))
}
}
func ( s * server ) acquireProtoJob ( ctx context . Context , job database . ProvisionerJob ) ( * proto . AcquiredJob , error ) {
// Marks the acquired job as failed with the error message provided. The
// update runs on a fresh context so it succeeds even when the session
// context is canceled; otherwise the claimed job would stay assigned to
// this worker until the job reaper.
failJob := func ( errorMessage string ) error {
err := s . Database . UpdateProvisionerJobWithCompleteByID (
//nolint:gocritic // Provisionerd has specific authz rules.
dbauthz . AsProvisionerd ( context . Background ()),
database . UpdateProvisionerJobWithCompleteByIDParams {
ID : job . ID ,
CompletedAt : sql . NullTime {
Time : s . timeNow (),
Valid : true ,
},
Error : sql . NullString {
String : errorMessage ,
Valid : true ,
},
ErrorCode : job . ErrorCode ,
UpdatedAt : s . timeNow (),
})
2022-11-07 19:10:49 -06:00
if err != nil {
return xerrors . Errorf ( "update provisioner job: %w" , err )
}
return xerrors . Errorf ( "request job was invalidated: %s" , errorMessage )
}
2023-08-30 14:48:35 +04:00
user , err := s . Database . GetUserByID ( ctx , job . InitiatorID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get user: %s" , err ))
}
2023-05-03 18:02:35 -05:00
jobTraceMetadata := map [ string ] string {}
if job . TraceMetadata . Valid {
err := json . Unmarshal ( job . TraceMetadata . RawMessage , & jobTraceMetadata )
if err != nil {
return nil , failJob ( fmt . Sprintf ( "unmarshal metadata: %s" , err ))
}
2022-11-07 19:10:49 -06:00
}
2023-05-03 18:02:35 -05:00
protoJob := & proto . AcquiredJob {
JobId : job . ID . String (),
CreatedAt : job . CreatedAt . UnixMilli (),
Provisioner : string ( job . Provisioner ),
UserName : user . Username ,
TraceMetadata : jobTraceMetadata ,
}
2026-02-12 13:40:47 -08:00
// jobTransition and jobBuildReason are used for metrics; only set for workspace builds.
var jobTransition string
var jobBuildReason string
2022-11-07 19:10:49 -06:00
switch job . Type {
case database . ProvisionerJobTypeWorkspaceBuild :
var input WorkspaceProvisionJob
err = json . Unmarshal ( job . Input , & input )
if err != nil {
return nil , failJob ( fmt . Sprintf ( "unmarshal job input %q: %s" , job . Input , err ))
}
2023-08-30 14:48:35 +04:00
workspaceBuild , err := s . Database . GetWorkspaceBuildByID ( ctx , input . WorkspaceBuildID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get workspace build: %s" , err ))
}
2023-08-30 14:48:35 +04:00
workspace , err := s . Database . GetWorkspaceByID ( ctx , workspaceBuild . WorkspaceID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get workspace: %s" , err ))
}
2023-08-30 14:48:35 +04:00
templateVersion , err := s . Database . GetTemplateVersionByID ( ctx , workspaceBuild . TemplateVersionID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get template version: %s" , err ))
}
2023-08-30 14:48:35 +04:00
templateVariables , err := s . Database . GetTemplateVersionVariables ( ctx , templateVersion . ID )
2023-02-15 18:24:15 +01:00
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , failJob ( fmt . Sprintf ( "get template version variables: %s" , err ))
}
2023-08-30 14:48:35 +04:00
template , err := s . Database . GetTemplateByID ( ctx , templateVersion . TemplateID . UUID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get template: %s" , err ))
}
2023-08-30 14:48:35 +04:00
owner , err := s . Database . GetUserByID ( ctx , workspace . OwnerID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get owner: %s" , err ))
}
2026-01-09 11:33:34 -06:00
// Fetch the file id of the cached module files if it exists.
versionModulesFile := ""
2026-02-05 14:38:55 -06:00
if ! template . DisableModuleCache {
tfvals , err := s . Database . GetTemplateVersionTerraformValues ( ctx , templateVersion . ID )
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
// Older templates (before dynamic parameters) will not have cached module files.
return nil , failJob ( fmt . Sprintf ( "get template version terraform values: %s" , err ))
}
if err == nil && tfvals . CachedModuleFiles . Valid {
versionModulesFile = tfvals . CachedModuleFiles . UUID . String ()
}
2026-01-09 11:33:34 -06:00
}
2024-05-29 11:43:08 +01:00
var ownerSSHPublicKey , ownerSSHPrivateKey string
if ownerSSHKey , err := s . Database . GetGitSSHKey ( ctx , owner . ID ); err != nil {
if ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , failJob ( fmt . Sprintf ( "get owner ssh key: %s" , err ))
}
} else {
ownerSSHPublicKey = ownerSSHKey . PublicKey
ownerSSHPrivateKey = ownerSSHKey . PrivateKey
}
2024-08-15 13:40:15 -05:00
ownerGroups , err := s . Database . GetGroups ( ctx , database . GetGroupsParams {
HasMemberID : owner . ID ,
2024-04-05 15:06:17 -04:00
OrganizationID : s . OrganizationID ,
})
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get owner group names: %s" , err ))
}
ownerGroupNames := [] string {}
for _ , group := range ownerGroups {
2024-08-29 10:55:00 -06:00
ownerGroupNames = append ( ownerGroupNames , group . Group . Name )
2024-04-05 15:06:17 -04:00
}
2024-11-01 14:17:05 +11:00
msg , err := json . Marshal ( wspubsub . WorkspaceEvent {
Kind : wspubsub . WorkspaceEventKindStateChange ,
WorkspaceID : workspace . ID ,
})
if err != nil {
return nil , failJob ( fmt . Sprintf ( "marshal workspace update event: %s" , err ))
}
err = s . Pubsub . Publish ( wspubsub . WorkspaceEventChannel ( workspace . OwnerID ), msg )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "publish workspace update: %s" , err ))
}
2023-03-17 15:25:08 -05:00
var workspaceOwnerOIDCAccessToken string
2025-04-23 08:45:26 -05:00
// The check `s.OIDCConfig != nil` is not as strict, since it can be an interface
// pointing to a typed nil.
if ! reflect . ValueOf ( s . OIDCConfig ). IsNil () {
2026-03-06 10:51:27 -06:00
workspaceOwnerOIDCAccessToken , err = ObtainOIDCAccessToken ( ctx , s . Logger , s . Database , s . OIDCConfig , owner . ID )
2023-03-17 15:25:08 -05:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "obtain OIDC access token: %s" , err ))
}
}
2023-05-17 23:29:22 -05:00
var sessionToken string
switch workspaceBuild . Transition {
case database . WorkspaceTransitionStart :
2023-08-30 14:48:35 +04:00
sessionToken , err = s . regenerateSessionToken ( ctx , owner , workspace )
2023-05-17 23:29:22 -05:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "regenerate session token: %s" , err ))
}
case database . WorkspaceTransitionStop , database . WorkspaceTransitionDelete :
2023-08-30 14:48:35 +04:00
err = deleteSessionToken ( ctx , s . Database , workspace )
2023-05-17 23:29:22 -05:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "delete session token: %s" , err ))
}
}
2022-11-07 19:10:49 -06:00
transition , err := convertWorkspaceTransition ( workspaceBuild . Transition )
if err != nil {
return nil , failJob ( fmt . Sprintf ( "convert workspace transition: %s" , err ))
}
2026-02-12 13:40:47 -08:00
jobTransition = string ( workspaceBuild . Transition )
// Prebuilds use BuildReasonInitiator in the database but we want to
// track them separately in metrics. Check the initiator ID to detect
// prebuild jobs.
if job . InitiatorID == database . PrebuildsSystemUserID {
jobBuildReason = BuildReasonPrebuild
} else {
jobBuildReason = string ( workspaceBuild . Reason )
}
2022-11-07 19:10:49 -06:00
2025-05-12 15:32:00 -05:00
// A previous workspace build exists
var lastWorkspaceBuildParameters [] database . WorkspaceBuildParameter
if workspaceBuild . BuildNumber > 1 {
// TODO: Should we fetch the last build that succeeded? This fetches the
// previous build regardless of the status of the build.
buildNum := workspaceBuild . BuildNumber - 1
previous , err := s . Database . GetWorkspaceBuildByWorkspaceIDAndBuildNumber ( ctx , database . GetWorkspaceBuildByWorkspaceIDAndBuildNumberParams {
WorkspaceID : workspaceBuild . WorkspaceID ,
BuildNumber : buildNum ,
})
// If the error is ErrNoRows, then assume previous values are empty.
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , xerrors . Errorf ( "get last build with number=%d: %w" , buildNum , err )
}
if err == nil {
lastWorkspaceBuildParameters , err = s . Database . GetWorkspaceBuildParameters ( ctx , previous . ID )
if err != nil {
return nil , xerrors . Errorf ( "get last build parameters %q: %w" , previous . ID , err )
}
}
}
2023-08-30 14:48:35 +04:00
workspaceBuildParameters , err := s . Database . GetWorkspaceBuildParameters ( ctx , workspaceBuild . ID )
2023-01-17 11:22:11 +01:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get workspace build parameters: %s" , err ))
}
2024-02-21 11:18:38 -07:00
dbExternalAuthProviders := [] database . ExternalAuthProvider {}
err = json . Unmarshal ( templateVersion . ExternalAuthProviders , & dbExternalAuthProviders )
if err != nil {
return nil , xerrors . Errorf ( "failed to deserialize external_auth_providers value: %w" , err )
}
externalAuthProviders := make ([] * sdkproto . ExternalAuthProvider , 0 , len ( dbExternalAuthProviders ))
for _ , p := range dbExternalAuthProviders {
2023-09-29 14:13:20 -05:00
link , err := s . Database . GetExternalAuthLink ( ctx , database . GetExternalAuthLinkParams {
2024-02-21 11:18:38 -07:00
ProviderID : p . ID ,
2023-03-22 14:37:08 -05:00
UserID : owner . ID ,
})
if errors . Is ( err , sql . ErrNoRows ) {
continue
}
if err != nil {
2023-09-29 14:13:20 -05:00
return nil , failJob ( fmt . Sprintf ( "acquire external auth link: %s" , err ))
2023-03-22 14:37:08 -05:00
}
2023-09-30 14:30:01 -05:00
var config * externalauth . Config
2023-09-29 14:13:20 -05:00
for _ , c := range s . ExternalAuthConfigs {
2024-02-21 11:18:38 -07:00
if c . ID != p . ID {
2023-03-22 14:37:08 -05:00
continue
}
config = c
break
}
// We weren't able to find a matching config for the ID!
if config == nil {
2023-09-29 14:13:20 -05:00
s . Logger . Warn ( ctx , "workspace build job is missing external auth provider" ,
2024-02-21 11:18:38 -07:00
slog . F ( "provider_id" , p . ID ),
2023-03-22 14:37:08 -05:00
slog . F ( "template_version_id" , templateVersion . ID ),
slog . F ( "workspace_id" , workspaceBuild . WorkspaceID ))
continue
}
2024-06-03 09:33:49 -05:00
refreshed , err := config . RefreshToken ( ctx , s . Database , link )
if err != nil && ! externalauth . IsInvalidTokenError ( err ) {
2024-02-21 11:18:38 -07:00
return nil , failJob ( fmt . Sprintf ( "refresh external auth link %q: %s" , p . ID , err ))
2023-03-22 14:37:08 -05:00
}
2024-06-03 09:33:49 -05:00
if err != nil {
// Invalid tokens are skipped
2023-03-22 14:37:08 -05:00
continue
}
2023-09-29 14:13:20 -05:00
externalAuthProviders = append ( externalAuthProviders , & sdkproto . ExternalAuthProvider {
2024-02-21 11:18:38 -07:00
Id : p . ID ,
2024-06-03 09:33:49 -05:00
AccessToken : refreshed . OAuthAccessToken ,
2023-03-22 14:37:08 -05:00
})
}
2025-04-17 15:42:23 -05:00
allUserRoles , err := s . Database . GetAuthorizationUserRoles ( ctx , owner . ID )
2025-03-02 15:54:44 -05:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get owner authorization roles: %s" , err ))
}
ownerRbacRoles := [] * sdkproto . Role {}
2025-04-17 15:42:23 -05:00
roles , err := allUserRoles . RoleNames ()
if err == nil {
for _ , role := range roles {
if role . OrganizationID != uuid . Nil && role . OrganizationID != s . OrganizationID {
continue // Only include site wide and org specific roles
}
orgID := role . OrganizationID . String ()
if role . OrganizationID == uuid . Nil {
orgID = ""
}
ownerRbacRoles = append ( ownerRbacRoles , & sdkproto . Role { Name : role . Name , OrgId : orgID })
2025-03-02 15:54:44 -05:00
}
}
2025-05-14 14:15:36 +02:00
runningAgentAuthTokens := [] * sdkproto . RunningAgentAuthToken {}
if input . PrebuiltWorkspaceBuildStage == sdkproto . PrebuiltWorkspaceBuildStage_CLAIM {
// runningAgentAuthTokens are *only* used for prebuilds. We fetch them when we want to rebuild a prebuilt workspace
// but not generate new agent tokens. The provisionerdserver will push them down to
// the provisioner (and ultimately to the `coder_agent` resource in the Terraform provider) where they will be
// reused. Context: the agent token is often used in immutable attributes of workspace resource (e.g. VM/container)
// to initialize the agent, so if that value changes it will necessitate a replacement of that resource, thus
// obviating the whole point of the prebuild.
agents , err := s . Database . GetWorkspaceAgentsByWorkspaceAndBuildNumber ( ctx , database . GetWorkspaceAgentsByWorkspaceAndBuildNumberParams {
WorkspaceID : workspace . ID ,
BuildNumber : 1 ,
})
if err != nil {
s . Logger . Error ( ctx , "failed to retrieve running agents of claimed prebuilt workspace" ,
slog . F ( "workspace_id" , workspace . ID ), slog . Error ( err ))
}
for _ , agent := range agents {
runningAgentAuthTokens = append ( runningAgentAuthTokens , & sdkproto . RunningAgentAuthToken {
AgentId : agent . ID . String (),
Token : agent . AuthToken . String (),
})
}
}
2026-02-23 22:46:17 -06:00
provisionerStateRow , err := s . Database . GetWorkspaceBuildProvisionerStateByID ( ctx , workspaceBuild . ID )
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get workspace build provisioner state: %s" , err ))
}
2022-11-07 19:10:49 -06:00
protoJob . Type = & proto . AcquiredJob_WorkspaceBuild_ {
WorkspaceBuild : & proto . AcquiredJob_WorkspaceBuild {
2025-11-13 07:50:17 -06:00
WorkspaceBuildId : workspaceBuild . ID . String (),
WorkspaceName : workspace . Name ,
2026-02-23 22:46:17 -06:00
State : provisionerStateRow . ProvisionerState ,
2025-11-13 07:50:17 -06:00
RichParameterValues : convertRichParameterValues ( workspaceBuildParameters ),
PreviousParameterValues : convertRichParameterValues ( lastWorkspaceBuildParameters ),
VariableValues : asVariableValues ( templateVariables ),
ExternalAuthProviders : externalAuthProviders ,
2023-08-25 10:10:15 +04:00
Metadata : & sdkproto . Metadata {
2023-08-30 14:48:35 +04:00
CoderUrl : s . AccessURL . String (),
2023-03-17 15:25:08 -05:00
WorkspaceTransition : transition ,
WorkspaceName : workspace . Name ,
WorkspaceOwner : owner . Username ,
WorkspaceOwnerEmail : owner . Email ,
2024-01-17 13:20:45 +01:00
WorkspaceOwnerName : owner . Name ,
2024-04-05 15:06:17 -04:00
WorkspaceOwnerGroups : ownerGroupNames ,
2023-03-17 15:25:08 -05:00
WorkspaceOwnerOidcAccessToken : workspaceOwnerOIDCAccessToken ,
WorkspaceId : workspace . ID . String (),
WorkspaceOwnerId : owner . ID . String (),
2023-09-13 11:09:08 -05:00
TemplateId : template . ID . String (),
2023-03-17 15:25:08 -05:00
TemplateName : template . Name ,
2025-11-13 07:50:17 -06:00
TemplateVersionId : templateVersion . ID . String (),
2023-03-17 15:25:08 -05:00
TemplateVersion : templateVersion . Name ,
2023-05-17 23:29:22 -05:00
WorkspaceOwnerSessionToken : sessionToken ,
2024-05-29 11:43:08 +01:00
WorkspaceOwnerSshPublicKey : ownerSSHPublicKey ,
WorkspaceOwnerSshPrivateKey : ownerSSHPrivateKey ,
2024-06-27 10:07:30 +02:00
WorkspaceBuildId : workspaceBuild . ID . String (),
2024-11-13 15:34:58 +00:00
WorkspaceOwnerLoginType : string ( owner . LoginType ),
2025-03-02 15:54:44 -05:00
WorkspaceOwnerRbacRoles : ownerRbacRoles ,
2025-05-14 14:15:36 +02:00
RunningAgentAuthTokens : runningAgentAuthTokens ,
2025-05-12 16:19:03 +02:00
PrebuiltWorkspaceBuildStage : input . PrebuiltWorkspaceBuildStage ,
2026-01-09 11:33:34 -06:00
TemplateVersionModulesFile : versionModulesFile ,
2022-11-07 19:10:49 -06:00
},
2026-05-21 09:19:29 -06:00
LogLevel : input . LogLevel ,
2022-11-07 19:10:49 -06:00
},
}
case database . ProvisionerJobTypeTemplateVersionDryRun :
var input TemplateVersionDryRunJob
err = json . Unmarshal ( job . Input , & input )
if err != nil {
return nil , failJob ( fmt . Sprintf ( "unmarshal job input %q: %s" , job . Input , err ))
}
2023-08-30 14:48:35 +04:00
templateVersion , err := s . Database . GetTemplateVersionByID ( ctx , input . TemplateVersionID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , failJob ( fmt . Sprintf ( "get template version: %s" , err ))
}
2023-08-30 14:48:35 +04:00
templateVariables , err := s . Database . GetTemplateVersionVariables ( ctx , templateVersion . ID )
2023-02-15 18:24:15 +01:00
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return nil , failJob ( fmt . Sprintf ( "get template version variables: %s" , err ))
}
2022-11-07 19:10:49 -06:00
protoJob . Type = & proto . AcquiredJob_TemplateDryRun_ {
TemplateDryRun : & proto . AcquiredJob_TemplateDryRun {
2023-01-23 15:01:22 +01:00
RichParameterValues : convertRichParameterValues ( input . RichParameterValues ),
2023-02-15 18:24:15 +01:00
VariableValues : asVariableValues ( templateVariables ),
2023-08-25 10:10:15 +04:00
Metadata : & sdkproto . Metadata {
2023-08-30 14:48:35 +04:00
CoderUrl : s . AccessURL . String (),
2022-11-07 19:10:49 -06:00
WorkspaceName : input . WorkspaceName ,
2025-06-05 14:25:36 -05:00
// There is no owner for a template import, but we can assume
// the "Everyone" group as a placeholder.
WorkspaceOwnerGroups : [] string { database . EveryoneGroup },
2022-11-07 19:10:49 -06:00
},
},
}
case database . ProvisionerJobTypeTemplateVersionImport :
2023-02-15 18:24:15 +01:00
var input TemplateVersionImportJob
err = json . Unmarshal ( job . Input , & input )
if err != nil {
return nil , failJob ( fmt . Sprintf ( "unmarshal job input %q: %s" , job . Input , err ))
}
2023-08-30 14:48:35 +04:00
userVariableValues , err := s . includeLastVariableValues ( ctx , input . TemplateVersionID , input . UserVariableValues )
2023-02-17 09:07:45 +01:00
if err != nil {
return nil , failJob ( err . Error ())
}
2025-11-12 12:46:39 -06:00
templateID := ""
if input . TemplateID . Valid {
templateID = input . TemplateID . UUID . String ()
}
2022-11-07 19:10:49 -06:00
protoJob . Type = & proto . AcquiredJob_TemplateImport_ {
TemplateImport : & proto . AcquiredJob_TemplateImport {
2023-02-17 09:07:45 +01:00
UserVariableValues : convertVariableValues ( userVariableValues ),
2023-08-25 10:10:15 +04:00
Metadata : & sdkproto . Metadata {
2023-08-30 14:48:35 +04:00
CoderUrl : s . AccessURL . String (),
2025-06-05 14:25:36 -05:00
// There is no owner for a template import, but we can assume
// the "Everyone" group as a placeholder.
WorkspaceOwnerGroups : [] string { database . EveryoneGroup },
2025-11-12 12:46:39 -06:00
TemplateId : templateID ,
TemplateVersionId : input . TemplateVersionID . String (),
2022-11-07 19:10:49 -06:00
},
},
}
}
switch job . StorageMethod {
case database . ProvisionerStorageMethodFile :
2023-08-30 14:48:35 +04:00
file , err := s . Database . GetFileByID ( ctx , job . FileID )
2022-11-07 19:10:49 -06:00
if err != nil {
2025-06-13 12:46:26 -05:00
return nil , failJob ( fmt . Sprintf ( "get file by id: %s" , err ))
2022-11-07 19:10:49 -06:00
}
protoJob . TemplateSourceArchive = file . Data
default :
return nil , failJob ( fmt . Sprintf ( "unsupported storage method: %s" , job . StorageMethod ))
}
2025-05-12 10:31:38 -05:00
if protobuf . Size ( protoJob ) > drpcsdk . MaxMessageSize {
return nil , failJob ( fmt . Sprintf ( "payload was too big: %d > %d" , protobuf . Size ( protoJob ), drpcsdk . MaxMessageSize ))
2022-11-07 19:10:49 -06:00
}
2026-02-12 13:40:47 -08:00
// Record the time the job spent waiting in the queue.
if s . metrics != nil && job . StartedAt . Valid && job . Provisioner . Valid () {
2026-02-20 16:12:17 -07:00
// These timestamps lose their monotonic clock component after a Postgres
// round-trip, so the subtraction is based purely on wall-clock time. Floor at
// 1ms as a defensive measure against clock adjustments producing a negative
// delta while acknowledging there's a non-zero queue time.
queueWaitSeconds := max ( job . StartedAt . Time . Sub ( job . CreatedAt ). Seconds (), 0.001 )
2026-02-12 13:40:47 -08:00
s . metrics . ObserveJobQueueWait ( string ( job . Provisioner ), string ( job . Type ), jobTransition , jobBuildReason , queueWaitSeconds )
}
2022-11-07 19:10:49 -06:00
return protoJob , err
}
2023-08-30 14:48:35 +04:00
func ( s * server ) includeLastVariableValues ( ctx context . Context , templateVersionID uuid . UUID , userVariableValues [] codersdk . VariableValue ) ([] codersdk . VariableValue , error ) {
2023-02-17 09:07:45 +01:00
var values [] codersdk . VariableValue
values = append ( values , userVariableValues ... )
if templateVersionID == uuid . Nil {
return values , nil
}
2023-08-30 14:48:35 +04:00
templateVersion , err := s . Database . GetTemplateVersionByID ( ctx , templateVersionID )
2023-02-17 09:07:45 +01:00
if err != nil {
2023-02-27 10:18:19 -06:00
return nil , xerrors . Errorf ( "get template version: %w" , err )
2023-02-17 09:07:45 +01:00
}
if templateVersion . TemplateID . UUID == uuid . Nil {
return values , nil
}
2023-08-30 14:48:35 +04:00
template , err := s . Database . GetTemplateByID ( ctx , templateVersion . TemplateID . UUID )
2023-02-17 09:07:45 +01:00
if err != nil {
2023-02-27 10:18:19 -06:00
return nil , xerrors . Errorf ( "get template: %w" , err )
2023-02-17 09:07:45 +01:00
}
if template . ActiveVersionID == uuid . Nil {
return values , nil
}
2023-08-30 14:48:35 +04:00
templateVariables , err := s . Database . GetTemplateVersionVariables ( ctx , template . ActiveVersionID )
2023-02-17 09:07:45 +01:00
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
2023-02-27 10:18:19 -06:00
return nil , xerrors . Errorf ( "get template version variables: %w" , err )
2023-02-17 09:07:45 +01:00
}
for _ , templateVariable := range templateVariables {
var alreadyAdded bool
for _ , uvv := range userVariableValues {
if uvv . Name == templateVariable . Name {
alreadyAdded = true
break
}
}
if alreadyAdded {
continue
}
values = append ( values , codersdk . VariableValue {
Name : templateVariable . Name ,
Value : templateVariable . Value ,
})
}
return values , nil
}
2023-08-30 14:48:35 +04:00
func ( s * server ) CommitQuota ( ctx context . Context , request * proto . CommitQuotaRequest ) ( * proto . CommitQuotaResponse , error ) {
ctx , span := s . startTrace ( ctx , tracing . FuncName ())
2023-05-03 18:02:35 -05:00
defer span . End ()
2023-02-15 16:14:37 +00:00
//nolint:gocritic // Provisionerd has specific authz rules.
ctx = dbauthz . AsProvisionerd ( ctx )
2022-11-14 11:57:33 -06:00
jobID , err := uuid . Parse ( request . JobId )
if err != nil {
return nil , xerrors . Errorf ( "parse job id: %w" , err )
}
2023-08-30 14:48:35 +04:00
job , err := s . Database . GetProvisionerJobByID ( ctx , jobID )
2022-11-14 11:57:33 -06:00
if err != nil {
return nil , xerrors . Errorf ( "get job: %w" , err )
}
if ! job . WorkerID . Valid {
return nil , xerrors . New ( "job isn't running yet" )
}
2023-08-30 14:48:35 +04:00
if job . WorkerID . UUID . String () != s . ID . String () {
2022-11-14 11:57:33 -06:00
return nil , xerrors . New ( "you don't own this job" )
}
2023-08-30 14:48:35 +04:00
q := s . QuotaCommitter . Load ()
2022-11-14 11:57:33 -06:00
if q == nil {
// We're probably in community edition or a test.
return & proto . CommitQuotaResponse {
Budget : - 1 ,
Ok : true ,
}, nil
}
return ( * q ). CommitQuota ( ctx , request )
}
2023-08-30 14:48:35 +04:00
func ( s * server ) UpdateJob ( ctx context . Context , request * proto . UpdateJobRequest ) ( * proto . UpdateJobResponse , error ) {
ctx , span := s . startTrace ( ctx , tracing . FuncName ())
2023-05-03 18:02:35 -05:00
defer span . End ()
2023-02-15 16:14:37 +00:00
//nolint:gocritic // Provisionerd has specific authz rules.
ctx = dbauthz . AsProvisionerd ( ctx )
2022-11-07 19:10:49 -06:00
parsedID , err := uuid . Parse ( request . JobId )
if err != nil {
return nil , xerrors . Errorf ( "parse job id: %w" , err )
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "stage UpdateJob starting" , slog . F ( "job_id" , parsedID ))
job , err := s . Database . GetProvisionerJobByID ( ctx , parsedID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "get job: %w" , err )
}
if ! job . WorkerID . Valid {
return nil , xerrors . New ( "job isn't running yet" )
}
2023-08-30 14:48:35 +04:00
if job . WorkerID . UUID . String () != s . ID . String () {
2022-11-07 19:10:49 -06:00
return nil , xerrors . New ( "you don't own this job" )
}
2023-08-30 14:48:35 +04:00
err = s . Database . UpdateProvisionerJobByID ( ctx , database . UpdateProvisionerJobByIDParams {
2022-11-07 19:10:49 -06:00
ID : parsedID ,
2024-11-25 16:25:36 +00:00
UpdatedAt : s . timeNow (),
2022-11-07 19:10:49 -06:00
})
if err != nil {
return nil , xerrors . Errorf ( "update job: %w" , err )
}
2025-07-30 19:09:53 -05:00
if len ( request . Logs ) > 0 && ! job . LogsOverflowed {
2023-10-03 09:23:45 +01:00
//nolint:exhaustruct // We append to the additional fields below.
2022-11-07 19:10:49 -06:00
insertParams := database . InsertProvisionerJobLogsParams {
JobID : parsedID ,
}
2025-07-30 19:09:53 -05:00
newLogSize := 0
overflowedErrorMsg := "Provisioner logs exceeded the max size of 1MB. Will not continue to write provisioner logs for workspace build."
lenErrMsg := len ( overflowedErrorMsg )
var (
createdAt time . Time
level database . LogLevel
stage string
source database . LogSource
output string
)
2022-11-07 19:10:49 -06:00
for _ , log := range request . Logs {
2025-07-30 19:09:53 -05:00
// Build our log params
level , err = convertLogLevel ( log . Level )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "convert log level: %w" , err )
}
2025-07-30 19:09:53 -05:00
source , err = convertLogSource ( log . Source )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "convert log source: %w" , err )
}
2025-07-30 19:09:53 -05:00
createdAt = time . UnixMilli ( log . CreatedAt )
stage = log . Stage
output = log . Output
// Check if we would overflow the job logs (not leaving enough room for the error message)
willOverflow := int64 ( job . LogsLength ) + int64 ( newLogSize ) + int64 ( lenErrMsg ) + int64 ( len ( output )) > 1048576
if willOverflow {
s . Logger . Debug ( ctx , "provisioner job logs overflowed 1MB size limit in database" , slog . F ( "job_id" , parsedID ))
err = s . Database . UpdateProvisionerJobLogsOverflowed ( ctx , database . UpdateProvisionerJobLogsOverflowedParams {
ID : parsedID ,
LogsOverflowed : true ,
})
if err != nil {
s . Logger . Error ( ctx , "failed to set logs overflowed flag" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
}
level = database . LogLevelWarn
output = overflowedErrorMsg
}
newLogSize += len ( output )
insertParams . CreatedAt = append ( insertParams . CreatedAt , createdAt )
insertParams . Level = append ( insertParams . Level , level )
insertParams . Stage = append ( insertParams . Stage , stage )
insertParams . Source = append ( insertParams . Source , source )
insertParams . Output = append ( insertParams . Output , output )
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "job log" ,
2022-11-07 19:10:49 -06:00
slog . F ( "job_id" , parsedID ),
2025-07-30 19:09:53 -05:00
slog . F ( "stage" , stage ),
slog . F ( "output" , output ))
// Don't write any more logs because there's no room.
if willOverflow {
break
}
}
err = s . Database . UpdateProvisionerJobLogsLength ( ctx , database . UpdateProvisionerJobLogsLengthParams {
ID : parsedID ,
LogsLength : int32 ( newLogSize ), // #nosec G115 - Log output length is limited to 1MB (2^20) which fits in an int32.
})
if err != nil {
// Even though we do the runtime check for the overflow, we still check for the database error
// as well.
if database . IsProvisionerJobLogsLimitError ( err ) {
err = s . Database . UpdateProvisionerJobLogsOverflowed ( ctx , database . UpdateProvisionerJobLogsOverflowedParams {
ID : parsedID ,
LogsOverflowed : true ,
})
if err != nil {
s . Logger . Error ( ctx , "failed to set logs overflowed flag" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
}
return & proto . UpdateJobResponse {
Canceled : job . CanceledAt . Valid ,
}, nil
}
s . Logger . Error ( ctx , "failed to update logs length" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
return nil , xerrors . Errorf ( "update logs length: %w" , err )
2022-11-07 19:10:49 -06:00
}
2023-04-11 14:49:28 -05:00
2023-08-30 14:48:35 +04:00
logs , err := s . Database . InsertProvisionerJobLogs ( ctx , insertParams )
2022-11-07 19:10:49 -06:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "failed to insert job logs" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
2022-11-07 19:10:49 -06:00
return nil , xerrors . Errorf ( "insert job logs: %w" , err )
}
2025-07-30 19:09:53 -05:00
2023-04-11 14:49:28 -05:00
// Publish by the lowest log ID inserted so the log stream will fetch
// everything from that point.
2022-11-07 19:10:49 -06:00
lowestID := logs [ 0 ]. ID
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "inserted job logs" , slog . F ( "job_id" , parsedID ))
2023-05-31 10:15:58 +04:00
data , err := json . Marshal ( provisionersdk . ProvisionerJobLogsNotifyMessage {
2022-11-08 17:56:16 +02:00
CreatedAfter : lowestID - 1 ,
2022-11-07 19:10:49 -06:00
})
if err != nil {
return nil , xerrors . Errorf ( "marshal: %w" , err )
}
2023-08-30 14:48:35 +04:00
err = s . Pubsub . Publish ( provisionersdk . ProvisionerJobLogsNotifyChannel ( parsedID ), data )
2022-11-07 19:10:49 -06:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "failed to publish job logs" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
2023-06-22 20:09:33 +02:00
return nil , xerrors . Errorf ( "publish job logs: %w" , err )
2022-11-07 19:10:49 -06:00
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "published job logs" , slog . F ( "job_id" , parsedID ))
2022-11-07 19:10:49 -06:00
}
2024-05-20 15:30:19 +02:00
if len ( request . WorkspaceTags ) > 0 {
templateVersion , err := s . Database . GetTemplateVersionByJobID ( ctx , job . ID )
if err != nil {
s . Logger . Error ( ctx , "failed to get the template version" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
return nil , xerrors . Errorf ( "get template version by job id: %w" , err )
}
for key , value := range request . WorkspaceTags {
_ , err := s . Database . InsertTemplateVersionWorkspaceTag ( ctx , database . InsertTemplateVersionWorkspaceTagParams {
TemplateVersionID : templateVersion . ID ,
Key : key ,
Value : value ,
})
if err != nil {
return nil , xerrors . Errorf ( "update template version workspace tags: %w" , err )
}
}
}
2022-11-07 19:10:49 -06:00
if len ( request . Readme ) > 0 {
2023-08-30 14:48:35 +04:00
err := s . Database . UpdateTemplateVersionDescriptionByJobID ( ctx , database . UpdateTemplateVersionDescriptionByJobIDParams {
2022-11-07 19:10:49 -06:00
JobID : job . ID ,
Readme : string ( request . Readme ),
2024-11-25 16:25:36 +00:00
UpdatedAt : s . timeNow (),
2022-11-07 19:10:49 -06:00
})
if err != nil {
return nil , xerrors . Errorf ( "update template version description: %w" , err )
}
}
2023-02-15 18:24:15 +01:00
if len ( request . TemplateVariables ) > 0 {
2023-08-30 14:48:35 +04:00
templateVersion , err := s . Database . GetTemplateVersionByJobID ( ctx , job . ID )
2023-02-15 18:24:15 +01:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "failed to get the template version" , slog . F ( "job_id" , parsedID ), slog . Error ( err ))
2023-02-15 18:24:15 +01:00
return nil , xerrors . Errorf ( "get template version by job id: %w" , err )
}
var variableValues [] * sdkproto . VariableValue
var variablesWithMissingValues [] string
for _ , templateVariable := range request . TemplateVariables {
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "insert template variable" , slog . F ( "template_version_id" , templateVersion . ID ), slog . F ( "template_variable" , redactTemplateVariable ( templateVariable )))
2023-02-15 18:24:15 +01:00
2023-02-18 18:32:09 -06:00
value := templateVariable . DefaultValue
2023-02-15 18:24:15 +01:00
for _ , v := range request . UserVariableValues {
if v . Name == templateVariable . Name {
value = v . Value
break
}
}
if templateVariable . Required && value == "" {
variablesWithMissingValues = append ( variablesWithMissingValues , templateVariable . Name )
}
variableValues = append ( variableValues , & sdkproto . VariableValue {
Name : templateVariable . Name ,
Value : value ,
Sensitive : templateVariable . Sensitive ,
})
2023-08-30 14:48:35 +04:00
_ , err = s . Database . InsertTemplateVersionVariable ( ctx , database . InsertTemplateVersionVariableParams {
2023-02-15 18:24:15 +01:00
TemplateVersionID : templateVersion . ID ,
Name : templateVariable . Name ,
Description : templateVariable . Description ,
Type : templateVariable . Type ,
DefaultValue : templateVariable . DefaultValue ,
Required : templateVariable . Required ,
Sensitive : templateVariable . Sensitive ,
Value : value ,
})
if err != nil {
return nil , xerrors . Errorf ( "insert parameter schema: %w" , err )
}
}
if len ( variablesWithMissingValues ) > 0 {
return nil , xerrors . Errorf ( "required template variables need values: %s" , strings . Join ( variablesWithMissingValues , ", " ))
}
return & proto . UpdateJobResponse {
Canceled : job . CanceledAt . Valid ,
VariableValues : variableValues ,
}, nil
}
2022-11-07 19:10:49 -06:00
return & proto . UpdateJobResponse {
Canceled : job . CanceledAt . Valid ,
}, nil
}
2023-08-30 14:48:35 +04:00
func ( s * server ) FailJob ( ctx context . Context , failJob * proto . FailedJob ) ( * proto . Empty , error ) {
ctx , span := s . startTrace ( ctx , tracing . FuncName ())
2023-05-03 18:02:35 -05:00
defer span . End ()
2023-02-15 16:14:37 +00:00
//nolint:gocritic // Provisionerd has specific authz rules.
ctx = dbauthz . AsProvisionerd ( ctx )
2022-11-07 19:10:49 -06:00
jobID , err := uuid . Parse ( failJob . JobId )
if err != nil {
return nil , xerrors . Errorf ( "parse job id: %w" , err )
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "stage FailJob starting" , slog . F ( "job_id" , jobID ))
job , err := s . Database . GetProvisionerJobByID ( ctx , jobID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "get provisioner job: %w" , err )
}
2023-08-30 14:48:35 +04:00
if job . WorkerID . UUID . String () != s . ID . String () {
2022-11-07 19:10:49 -06:00
return nil , xerrors . New ( "you don't own this job" )
}
if job . CompletedAt . Valid {
return nil , xerrors . Errorf ( "job already completed" )
}
job . CompletedAt = sql . NullTime {
2024-11-25 16:25:36 +00:00
Time : s . timeNow (),
2022-11-07 19:10:49 -06:00
Valid : true ,
}
job . Error = sql . NullString {
String : failJob . Error ,
Valid : failJob . Error != "" ,
}
2023-03-08 16:32:00 +01:00
job . ErrorCode = sql . NullString {
String : failJob . ErrorCode ,
Valid : failJob . ErrorCode != "" ,
}
2022-11-07 19:10:49 -06:00
2023-08-30 14:48:35 +04:00
err = s . Database . UpdateProvisionerJobWithCompleteByID ( ctx , database . UpdateProvisionerJobWithCompleteByIDParams {
2022-11-07 19:10:49 -06:00
ID : jobID ,
CompletedAt : job . CompletedAt ,
2024-11-25 16:25:36 +00:00
UpdatedAt : s . timeNow (),
2022-11-07 19:10:49 -06:00
Error : job . Error ,
2023-03-08 16:32:00 +01:00
ErrorCode : job . ErrorCode ,
2022-11-07 19:10:49 -06:00
})
if err != nil {
return nil , xerrors . Errorf ( "update provisioner job: %w" , err )
}
2023-08-30 14:48:35 +04:00
s . Telemetry . Report ( & telemetry . Snapshot {
2022-11-07 19:10:49 -06:00
ProvisionerJobs : [] telemetry . ProvisionerJob { telemetry . ConvertProvisionerJob ( job )},
})
switch jobType := failJob . Type .( type ) {
case * proto . FailedJob_WorkspaceBuild_ :
var input WorkspaceProvisionJob
err = json . Unmarshal ( job . Input , & input )
if err != nil {
return nil , xerrors . Errorf ( "unmarshal workspace provision input: %w" , err )
}
2023-03-08 01:14:58 +11:00
2023-03-10 10:39:02 -06:00
var build database . WorkspaceBuild
2024-07-16 10:48:17 +02:00
var workspace database . Workspace
2023-08-30 14:48:35 +04:00
err = s . Database . InTx ( func ( db database . Store ) error {
2023-07-14 15:07:48 -08:00
build , err = db . GetWorkspaceBuildByID ( ctx , input . WorkspaceBuildID )
2023-03-08 01:14:58 +11:00
if err != nil {
return xerrors . Errorf ( "get workspace build: %w" , err )
}
2024-07-16 10:48:17 +02:00
workspace , err = db . GetWorkspaceByID ( ctx , build . WorkspaceID )
if err != nil {
return xerrors . Errorf ( "get workspace: %w" , err )
}
2023-07-14 15:07:48 -08:00
if jobType . WorkspaceBuild . State != nil {
2023-09-22 16:22:07 +01:00
err = db . UpdateWorkspaceBuildProvisionerStateByID ( ctx , database . UpdateWorkspaceBuildProvisionerStateByIDParams {
2023-07-14 15:07:48 -08:00
ID : input . WorkspaceBuildID ,
2024-11-25 16:25:36 +00:00
UpdatedAt : s . timeNow (),
2023-07-14 15:07:48 -08:00
ProvisionerState : jobType . WorkspaceBuild . State ,
})
if err != nil {
return xerrors . Errorf ( "update workspace build state: %w" , err )
}
2025-08-13 12:45:46 +01:00
deadline := build . Deadline
maxDeadline := build . MaxDeadline
if workspace . IsPrebuild () {
deadline = time . Time {}
maxDeadline = time . Time {}
}
2023-09-22 16:22:07 +01:00
err = db . UpdateWorkspaceBuildDeadlineByID ( ctx , database . UpdateWorkspaceBuildDeadlineByIDParams {
ID : input . WorkspaceBuildID ,
2024-11-25 16:25:36 +00:00
UpdatedAt : s . timeNow (),
2025-08-13 12:45:46 +01:00
Deadline : deadline ,
MaxDeadline : maxDeadline ,
2023-09-22 16:22:07 +01:00
})
if err != nil {
return xerrors . Errorf ( "update workspace build deadline: %w" , err )
}
2023-03-08 01:14:58 +11:00
}
return nil
}, nil )
2022-11-07 19:10:49 -06:00
if err != nil {
2023-03-08 01:14:58 +11:00
return nil , err
2022-11-07 19:10:49 -06:00
}
2023-03-08 01:14:58 +11:00
2024-07-16 10:48:17 +02:00
s . notifyWorkspaceBuildFailed ( ctx , workspace , build )
2026-07-07 09:18:30 -07:00
// Wake the orchestrator before the workspace event publish
// below, which returns on error, so a failed UI event cannot
// skip the wake.
if err := wspubsub . PublishWorkspaceBuildOrchestrationWake ( ctx , s . Pubsub ); err != nil {
s . Logger . Warn ( ctx , "failed to publish workspace build orchestration wake" , slog . Error ( err ))
}
2024-11-01 14:17:05 +11:00
msg , err := json . Marshal ( wspubsub . WorkspaceEvent {
Kind : wspubsub . WorkspaceEventKindStateChange ,
WorkspaceID : workspace . ID ,
})
2022-11-07 19:10:49 -06:00
if err != nil {
2024-11-01 14:17:05 +11:00
return nil , xerrors . Errorf ( "marshal workspace update event: %s" , err )
}
err = s . Pubsub . Publish ( wspubsub . WorkspaceEventChannel ( workspace . OwnerID ), msg )
if err != nil {
return nil , xerrors . Errorf ( "publish workspace update: %w" , err )
2022-11-07 19:10:49 -06:00
}
2026-03-13 20:37:41 -07:00
// Publish workspace build update to the all builds channel if the experiment is enabled.
if s . Experiments . Enabled ( codersdk . ExperimentWorkspaceBuildUpdates ) {
err = wspubsub . PublishWorkspaceBuildUpdate ( ctx , s . Pubsub , codersdk . WorkspaceBuildUpdate {
WorkspaceID : workspace . ID ,
WorkspaceName : workspace . Name ,
BuildID : build . ID ,
Transition : string ( build . Transition ),
JobStatus : string ( database . ProvisionerJobStatusFailed ),
BuildNumber : build . BuildNumber ,
})
if err != nil {
s . Logger . Warn ( ctx , "failed to publish workspace build update" , slog . Error ( err ))
}
}
2022-11-07 19:10:49 -06:00
case * proto . FailedJob_TemplateImport_ :
}
2022-11-22 13:22:56 -05:00
// if failed job is a workspace build, audit the outcome
if job . Type == database . ProvisionerJobTypeWorkspaceBuild {
2023-08-30 14:48:35 +04:00
auditor := s . Auditor . Load ()
build , err := s . Database . GetWorkspaceBuildByJobID ( ctx , job . ID )
2023-01-23 13:14:47 +02:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "audit log - get build" , slog . Error ( err ))
2022-11-22 13:22:56 -05:00
} else {
auditAction := auditActionFromTransition ( build . Transition )
2023-08-30 14:48:35 +04:00
workspace , err := s . Database . GetWorkspaceByID ( ctx , build . WorkspaceID )
2023-01-23 13:14:47 +02:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "audit log - get workspace" , slog . Error ( err ))
2022-11-22 13:22:56 -05:00
} else {
2023-01-24 10:53:04 -05:00
previousBuildNumber := build . BuildNumber - 1
2023-08-30 14:48:35 +04:00
previousBuild , prevBuildErr := s . Database . GetWorkspaceBuildByWorkspaceIDAndBuildNumber ( ctx , database . GetWorkspaceBuildByWorkspaceIDAndBuildNumberParams {
2023-01-24 10:53:04 -05:00
WorkspaceID : workspace . ID ,
BuildNumber : previousBuildNumber ,
})
if prevBuildErr != nil {
2023-03-10 10:39:02 -06:00
previousBuild = database . WorkspaceBuild {}
2023-01-24 10:53:04 -05:00
}
2023-01-30 13:43:29 -05:00
2022-12-02 15:14:45 -05:00
// We pass the below information to the Auditor so that it
// can form a friendly string for the user to view in the UI.
2023-01-30 13:43:29 -05:00
buildResourceInfo := audit . AdditionalFields {
WorkspaceName : workspace . Name ,
BuildNumber : strconv . FormatInt ( int64 ( build . BuildNumber ), 10 ),
BuildReason : database . BuildReason ( string ( build . Reason )),
2024-03-22 15:10:32 -05:00
WorkspaceID : workspace . ID ,
2022-11-22 13:22:56 -05:00
}
2022-12-06 13:33:21 -05:00
wriBytes , err := json . Marshal ( buildResourceInfo )
2022-11-22 13:22:56 -05:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "marshal workspace resource info for failed job" , slog . Error ( err ))
2024-10-31 17:55:42 -05:00
wriBytes = [] byte ( "{}" )
2022-11-22 13:22:56 -05:00
}
2023-10-18 15:08:02 -05:00
bag := audit . BaggageFromContext ( ctx )
2023-12-07 17:11:57 -06:00
audit . BackgroundAudit ( ctx , & audit . BackgroundAuditParams [ database . WorkspaceBuild ]{
2022-11-22 13:22:56 -05:00
Audit : * auditor ,
2023-08-30 14:48:35 +04:00
Log : s . Logger ,
2022-11-22 13:22:56 -05:00
UserID : job . InitiatorID ,
2023-09-28 11:29:12 -05:00
OrganizationID : workspace . OrganizationID ,
2023-12-07 17:11:57 -06:00
RequestID : job . ID ,
2023-10-18 15:08:02 -05:00
IP : bag . IP ,
2022-11-22 13:22:56 -05:00
Action : auditAction ,
2023-01-24 10:53:04 -05:00
Old : previousBuild ,
2022-11-22 13:22:56 -05:00
New : build ,
Status : http . StatusInternalServerError ,
AdditionalFields : wriBytes ,
})
}
}
}
2023-05-31 10:15:58 +04:00
data , err := json . Marshal ( provisionersdk . ProvisionerJobLogsNotifyMessage { EndOfLogs : true })
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "marshal job log: %w" , err )
}
2023-08-30 14:48:35 +04:00
err = s . Pubsub . Publish ( provisionersdk . ProvisionerJobLogsNotifyChannel ( jobID ), data )
2022-11-07 19:10:49 -06:00
if err != nil {
2023-08-30 14:48:35 +04:00
s . Logger . Error ( ctx , "failed to publish end of job logs" , slog . F ( "job_id" , jobID ), slog . Error ( err ))
2022-11-07 19:10:49 -06:00
return nil , xerrors . Errorf ( "publish end of job logs: %w" , err )
}
2026-08-11 11:04:51 -05:00
s . jobFinished ( jobID )
2022-11-07 19:10:49 -06:00
return & proto . Empty {}, nil
}
2024-07-16 10:48:17 +02:00
func ( s * server ) notifyWorkspaceBuildFailed ( ctx context . Context , workspace database . Workspace , build database . WorkspaceBuild ) {
var reason string
if build . Reason . Valid () && build . Reason == database . BuildReasonInitiator {
2024-08-27 16:35:28 +02:00
s . notifyWorkspaceManualBuildFailed ( ctx , workspace , build )
return
2024-07-16 10:48:17 +02:00
}
reason = string ( build . Reason )
2024-07-24 13:38:21 -03:00
if _ , err := s . NotificationsEnqueuer . Enqueue ( ctx , workspace . OwnerID , notifications . TemplateWorkspaceAutobuildFailed ,
2024-07-16 10:48:17 +02:00
map [ string ] string {
2024-07-29 11:20:04 -03:00
"name" : workspace . Name ,
"reason" : reason ,
2024-07-16 10:48:17 +02:00
}, "provisionerdserver" ,
// Associate this notification with all the related entities.
workspace . ID , workspace . OwnerID , workspace . TemplateID , workspace . OrganizationID ,
); err != nil {
s . Logger . Warn ( ctx , "failed to notify of failed workspace autobuild" , slog . Error ( err ))
}
}
2024-08-27 16:35:28 +02:00
func ( s * server ) notifyWorkspaceManualBuildFailed ( ctx context . Context , workspace database . Workspace , build database . WorkspaceBuild ) {
templateAdmins , template , templateVersion , workspaceOwner , err := s . prepareForNotifyWorkspaceManualBuildFailed ( ctx , workspace , build )
if err != nil {
s . Logger . Error ( ctx , "unable to collect data for manual build failed notification" , slog . Error ( err ))
return
}
for _ , templateAdmin := range templateAdmins {
2024-10-15 21:02:02 +02:00
templateNameLabel := template . DisplayName
if templateNameLabel == "" {
templateNameLabel = template . Name
}
labels := map [ string ] string {
"name" : workspace . Name ,
"template_name" : templateNameLabel ,
"template_version_name" : templateVersion . Name ,
"initiator" : build . InitiatorByUsername ,
"workspace_owner_username" : workspaceOwner . Username ,
"workspace_build_number" : strconv . Itoa ( int ( build . BuildNumber )),
}
2024-08-27 16:35:28 +02:00
if _ , err := s . NotificationsEnqueuer . Enqueue ( ctx , templateAdmin . ID , notifications . TemplateWorkspaceManualBuildFailed ,
2024-10-15 21:02:02 +02:00
labels , "provisionerdserver" ,
2024-08-27 16:35:28 +02:00
// Associate this notification with all the related entities.
workspace . ID , workspace . OwnerID , workspace . TemplateID , workspace . OrganizationID ,
); err != nil {
s . Logger . Warn ( ctx , "failed to notify of failed workspace manual build" , slog . Error ( err ))
}
}
}
// prepareForNotifyWorkspaceManualBuildFailed collects data required to build notifications for template admins.
// The template `notifications.TemplateWorkspaceManualBuildFailed` is quite detailed as it requires information about the template,
// template version, workspace, workspace build, etc.
func ( s * server ) prepareForNotifyWorkspaceManualBuildFailed ( ctx context . Context , workspace database . Workspace , build database . WorkspaceBuild ) ([] database . GetUsersRow ,
database . Template , database . TemplateVersion , database . User , error ,
) {
users , err := s . Database . GetUsers ( ctx , database . GetUsersParams {
RbacRole : [] string { codersdk . RoleTemplateAdmin },
})
if err != nil {
return nil , database . Template {}, database . TemplateVersion {}, database . User {}, xerrors . Errorf ( "unable to fetch template admins: %w" , err )
}
usersByIDs := map [ uuid . UUID ] database . GetUsersRow {}
var userIDs [] uuid . UUID
for _ , user := range users {
usersByIDs [ user . ID ] = user
userIDs = append ( userIDs , user . ID )
}
var templateAdmins [] database . GetUsersRow
if len ( userIDs ) > 0 {
orgIDsByMemberIDs , err := s . Database . GetOrganizationIDsByMemberIDs ( ctx , userIDs )
if err != nil {
return nil , database . Template {}, database . TemplateVersion {}, database . User {}, xerrors . Errorf ( "unable to fetch organization IDs by member IDs: %w" , err )
}
for _ , entry := range orgIDsByMemberIDs {
if slices . Contains ( entry . OrganizationIDs , workspace . OrganizationID ) {
templateAdmins = append ( templateAdmins , usersByIDs [ entry . UserID ])
}
}
}
sort . Slice ( templateAdmins , func ( i , j int ) bool {
return templateAdmins [ i ]. Username < templateAdmins [ j ]. Username
})
template , err := s . Database . GetTemplateByID ( ctx , workspace . TemplateID )
if err != nil {
return nil , database . Template {}, database . TemplateVersion {}, database . User {}, xerrors . Errorf ( "unable to fetch template: %w" , err )
}
templateVersion , err := s . Database . GetTemplateVersionByID ( ctx , build . TemplateVersionID )
if err != nil {
return nil , database . Template {}, database . TemplateVersion {}, database . User {}, xerrors . Errorf ( "unable to fetch template version: %w" , err )
}
workspaceOwner , err := s . Database . GetUserByID ( ctx , workspace . OwnerID )
if err != nil {
return nil , database . Template {}, database . TemplateVersion {}, database . User {}, xerrors . Errorf ( "unable to fetch workspace owner: %w" , err )
}
return templateAdmins , template , templateVersion , workspaceOwner , nil
}
2025-06-13 12:46:26 -05:00
func ( s * server ) UploadFile ( stream proto . DRPCProvisionerDaemon_UploadFileStream ) error {
var file * sdkproto . DataBuilder
// Always terminate the stream with an empty response.
2026-01-09 11:33:34 -06:00
//nolint:errcheck // We can't do much about send errors here.
2025-06-13 12:46:26 -05:00
defer stream . SendAndClose ( & proto . Empty {})
2026-01-09 11:33:34 -06:00
file , err := provisionersdk . HandleReceivingDataUpload ( stream )
if err != nil {
return err
2025-06-13 12:46:26 -05:00
}
fileData , err := file . Complete ()
if err != nil {
return xerrors . Errorf ( "complete file upload: %w" , err )
}
// Just rehash the data to be sure it is correct.
hashBytes := sha256 . Sum256 ( fileData )
hash := hex . EncodeToString ( hashBytes [:])
var insert database . InsertFileParams
switch file . Type {
case sdkproto . DataUploadType_UPLOAD_TYPE_MODULE_FILES :
insert = database . InsertFileParams {
ID : uuid . New (),
Hash : hash ,
CreatedAt : dbtime . Now (),
CreatedBy : uuid . Nil ,
Mimetype : tarMimeType ,
Data : fileData ,
}
default :
return xerrors . Errorf ( "unsupported file upload type: %s" , file . Type )
}
//nolint:gocritic // Provisionerd actor
_ , err = s . Database . InsertFile ( dbauthz . AsProvisionerd ( s . lifecycleCtx ), insert )
if err != nil {
// Duplicated files already exist in the database, so we can ignore this error.
if ! database . IsUniqueViolation ( err , database . UniqueFilesHashCreatedByKey ) {
return xerrors . Errorf ( "insert file: %w" , err )
}
}
s . Logger . Info ( s . lifecycleCtx , "file uploaded to database" ,
slog . F ( "type" , file . Type . String ()),
slog . F ( "hash" , hash ),
slog . F ( "size" , len ( fileData )),
// new_insert indicates whether the file was newly inserted or already existed.
slog . F ( "new_insert" , err == nil ),
)
return nil
}
2026-01-09 11:33:34 -06:00
// DownloadFile pulls the requested file from the database and sends it over the protobuf stream in chunks.
func ( s * server ) DownloadFile ( request * proto . FileRequest , stream proto . DRPCProvisionerDaemon_DownloadFileStream ) error {
//nolint:errcheck
defer stream . CloseSend ()
//nolint:gocritic // Provisionerd is the actor here.
ctx := dbauthz . AsProvisionerd ( stream . Context ())
// A graceful error message will help debugging.
fail := func ( err error ) error {
2026-03-13 19:53:20 +02:00
if sendErr := stream . Send ( & sdkproto . FileUpload {
2026-01-09 11:33:34 -06:00
Type : & sdkproto . FileUpload_Error {
Error : & sdkproto . FailedFile {
Error : err . Error (),
},
},
2026-03-13 19:53:20 +02:00
}); sendErr != nil {
s . Logger . Warn ( ctx , "failed to send error response on download stream" ,
slog . Error ( sendErr ),
slog . F ( "original_error" , err . Error ()),
)
}
2026-01-09 11:33:34 -06:00
return err
}
if request . FileId == "" || request . FileId == uuid . Nil . String () {
return fail ( xerrors . New ( "file id is required" ))
}
fid , err := uuid . Parse ( request . FileId )
if err != nil {
return fail ( xerrors . Errorf ( "invalid file id: %w" , err ))
}
file , err := s . Database . GetFileByID ( ctx , fid )
if err != nil {
return fail ( xerrors . Errorf ( "get file: %w" , err ))
}
switch request . UploadType {
case sdkproto . DataUploadType_UPLOAD_TYPE_MODULE_FILES :
// This check is not perfect. If these conditions are not true, then the file is not a modules file.
if file . CreatedBy != uuid . Nil || file . Mimetype != tarMimeType {
return fail ( xerrors . Errorf ( "file %s is not a modules file" , fid ))
}
2026-06-24 12:09:22 -05:00
// Ensure the requested module file belongs to a template version in
// this provisioner daemon's organization. Without this, any
// authenticated provisioner could download cached module archives
// (Terraform source) belonging to other organizations (ANT-2026-22440).
ok , err := s . Database . HasTemplateVersionsUsingCachedModuleFileInOrg ( ctx , database . HasTemplateVersionsUsingCachedModuleFileInOrgParams {
FileID : fid ,
OrganizationID : s . OrganizationID ,
})
if err != nil {
return fail ( xerrors . Errorf ( "authorize module file: %w" , err ))
}
if ! ok {
s . Logger . Warn ( ctx , "module file download rejected: file not referenced by any template version in daemon org" ,
slog . F ( "file_id" , fid ),
slog . F ( "organization_id" , s . OrganizationID ),
)
// Use the same error as the metadata check above so the handler
// does not confirm the existence of files in other organizations.
return fail ( xerrors . Errorf ( "file %s is not a modules file" , fid ))
}
2026-01-09 11:33:34 -06:00
default :
return fail ( xerrors . Errorf ( "unsupported file upload type: %s" , request . UploadType ))
}
2026-05-27 14:30:11 -04:00
upload , chunks , err := sdkproto . BytesToDataUpload ( sdkproto . DataUploadType_UPLOAD_TYPE_MODULE_FILES , file . Data )
if err != nil {
return fail ( xerrors . Errorf ( "prepare file upload: %w" , err ))
}
2026-01-09 11:33:34 -06:00
err = stream . Send ( & sdkproto . FileUpload {
Type : & sdkproto . FileUpload_DataUpload { DataUpload : upload },
})
if err != nil {
return fail ( xerrors . Errorf ( "send file upload: %w" , err ))
}
for i , c := range chunks {
if ctx . Err () != nil {
return fail ( ctx . Err ())
}
err = stream . Send ( & sdkproto . FileUpload {
Type : & sdkproto . FileUpload_ChunkPiece { ChunkPiece : c },
})
if err != nil {
return fail ( xerrors . Errorf ( "send chunk piece %d: %w" , i , err ))
}
}
return nil
2026-01-09 11:23:32 -06:00
}
2022-11-07 19:10:49 -06:00
// CompleteJob is triggered by a provision daemon to mark a provisioner job as completed.
2023-08-30 14:48:35 +04:00
func ( s * server ) CompleteJob ( ctx context . Context , completed * proto . CompletedJob ) ( * proto . Empty , error ) {
ctx , span := s . startTrace ( ctx , tracing . FuncName ())
2023-05-03 18:02:35 -05:00
defer span . End ()
2023-02-15 16:14:37 +00:00
//nolint:gocritic // Provisionerd has specific authz rules.
ctx = dbauthz . AsProvisionerd ( ctx )
2022-11-07 19:10:49 -06:00
jobID , err := uuid . Parse ( completed . JobId )
if err != nil {
return nil , xerrors . Errorf ( "parse job id: %w" , err )
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "stage CompleteJob starting" , slog . F ( "job_id" , jobID ))
job , err := s . Database . GetProvisionerJobByID ( ctx , jobID )
2022-11-07 19:10:49 -06:00
if err != nil {
return nil , xerrors . Errorf ( "get job by id: %w" , err )
}
2023-08-30 14:48:35 +04:00
if job . WorkerID . UUID . String () != s . ID . String () {
2022-11-07 19:10:49 -06:00
return nil , xerrors . Errorf ( "you don't own this job" )
}
telemetrySnapshot := & telemetry . Snapshot {}
// Items are added to this snapshot as they complete!
2023-08-30 14:48:35 +04:00
defer s . Telemetry . Report ( telemetrySnapshot )
2022-11-07 19:10:49 -06:00
switch jobType := completed . Type .( type ) {
case * proto . CompletedJob_TemplateImport_ :
2025-05-21 16:48:51 +02:00
err = s . completeTemplateImportJob ( ctx , job , jobID , jobType , telemetrySnapshot )
2023-01-17 11:22:11 +01:00
if err != nil {
2025-05-21 16:48:51 +02:00
return nil , err
2023-01-17 11:22:11 +01:00
}
2025-05-21 16:48:51 +02:00
case * proto . CompletedJob_WorkspaceBuild_ :
err = s . completeWorkspaceBuildJob ( ctx , job , jobID , jobType , telemetrySnapshot )
if err != nil {
return nil , err
}
case * proto . CompletedJob_TemplateDryRun_ :
err = s . completeTemplateDryRunJob ( ctx , job , jobID , jobType , telemetrySnapshot )
if err != nil {
return nil , err
}
default :
if completed . Type == nil {
return nil , xerrors . Errorf ( "type payload must be provided" )
}
return nil , xerrors . Errorf ( "unknown job type %q; ensure coderd and provisionerd versions match" ,
reflect . TypeOf ( completed . Type ). String ())
}
2023-01-17 11:22:11 +01:00
2025-05-21 16:48:51 +02:00
data , err := json . Marshal ( provisionersdk . ProvisionerJobLogsNotifyMessage { EndOfLogs : true })
if err != nil {
return nil , xerrors . Errorf ( "marshal job log: %w" , err )
}
err = s . Pubsub . Publish ( provisionersdk . ProvisionerJobLogsNotifyChannel ( jobID ), data )
if err != nil {
s . Logger . Error ( ctx , "failed to publish end of job logs" , slog . F ( "job_id" , jobID ), slog . Error ( err ))
return nil , xerrors . Errorf ( "publish end of job logs: %w" , err )
}
s . Logger . Debug ( ctx , "stage CompleteJob done" , slog . F ( "job_id" , jobID ))
2026-08-11 11:04:51 -05:00
s . jobFinished ( jobID )
2025-05-21 16:48:51 +02:00
return & proto . Empty {}, nil
}
// completeTemplateImportJob handles completion of a template import job.
// All database operations are performed within a transaction.
func ( s * server ) completeTemplateImportJob ( ctx context . Context , job database . ProvisionerJob , jobID uuid . UUID , jobType * proto . CompletedJob_TemplateImport_ , telemetrySnapshot * telemetry . Snapshot ) error {
var input TemplateVersionImportJob
err := json . Unmarshal ( job . Input , & input )
if err != nil {
return xerrors . Errorf ( "template version ID is expected: %w" , err )
}
// Execute all database operations in a transaction
return s . Database . InTx ( func ( db database . Store ) error {
2025-03-24 10:01:50 -06:00
now := s . timeNow ()
2025-05-21 16:48:51 +02:00
// Process resources
2022-11-07 19:10:49 -06:00
for transition , resources := range map [ database . WorkspaceTransition ][] * sdkproto . Resource {
database . WorkspaceTransitionStart : jobType . TemplateImport . StartResources ,
database . WorkspaceTransitionStop : jobType . TemplateImport . StopResources ,
} {
for _ , resource := range resources {
2023-08-30 14:48:35 +04:00
s . Logger . Info ( ctx , "inserting template import job resource" ,
2022-11-07 19:10:49 -06:00
slog . F ( "job_id" , job . ID . String ()),
slog . F ( "resource_name" , resource . Name ),
slog . F ( "resource_type" , resource . Type ),
slog . F ( "transition" , transition ))
2025-05-21 16:48:51 +02:00
if err := InsertWorkspaceResource ( ctx , db , jobID , transition , resource , telemetrySnapshot ); err != nil {
2026-06-11 15:02:41 -04:00
s . warnWorkspaceAppRebindRejected ( ctx , jobID , err )
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert resource: %w" , err )
2022-11-07 19:10:49 -06:00
}
}
}
2025-05-21 16:48:51 +02:00
// Process modules
2024-11-16 21:56:19 +01:00
for transition , modules := range map [ database . WorkspaceTransition ][] * sdkproto . Module {
database . WorkspaceTransitionStart : jobType . TemplateImport . StartModules ,
} {
for _ , module := range modules {
s . Logger . Info ( ctx , "inserting template import job module" ,
slog . F ( "job_id" , job . ID . String ()),
slog . F ( "module_source" , module . Source ),
slog . F ( "module_version" , module . Version ),
slog . F ( "module_key" , module . Key ),
slog . F ( "transition" , transition ))
2025-05-21 16:48:51 +02:00
if err := InsertWorkspaceModule ( ctx , db , jobID , transition , module , telemetrySnapshot ); err != nil {
return xerrors . Errorf ( "insert module: %w" , err )
2024-11-16 21:56:19 +01:00
}
}
}
2022-11-07 19:10:49 -06:00
2025-05-21 16:48:51 +02:00
// Process rich parameters
2023-01-17 11:22:11 +01:00
for _ , richParameter := range jobType . TemplateImport . RichParameters {
2023-08-30 14:48:35 +04:00
s . Logger . Info ( ctx , "inserting template import job parameter" ,
2023-01-17 11:22:11 +01:00
slog . F ( "job_id" , job . ID . String ()),
slog . F ( "parameter_name" , richParameter . Name ),
2023-07-10 13:44:03 +02:00
slog . F ( "type" , richParameter . Type ),
slog . F ( "ephemeral" , richParameter . Ephemeral ),
2023-01-17 11:22:11 +01:00
)
options , err := json . Marshal ( richParameter . Options )
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "marshal parameter options: %w" , err )
2023-01-17 11:22:11 +01:00
}
2023-05-30 14:57:06 +02:00
var validationMin , validationMax sql . NullInt32
if richParameter . ValidationMin != nil {
validationMin = sql . NullInt32 {
Int32 : * richParameter . ValidationMin ,
Valid : true ,
}
}
if richParameter . ValidationMax != nil {
validationMax = sql . NullInt32 {
Int32 : * richParameter . ValidationMax ,
Valid : true ,
}
}
2025-05-29 08:55:19 -05:00
pft , err := sdkproto . ProviderFormType ( richParameter . FormType )
if err != nil {
return xerrors . Errorf ( "parameter %q: %w" , richParameter . Name , err )
}
dft := database . ParameterFormType ( pft )
if ! dft . Valid () {
list := strings . Join ( slice . ToStrings ( database . AllParameterFormTypeValues ()), ", " )
return xerrors . Errorf ( "parameter %q field 'form_type' not valid, currently supported: %s" , richParameter . Name , list )
}
2025-05-21 16:48:51 +02:00
_ , err = db . InsertTemplateVersionParameter ( ctx , database . InsertTemplateVersionParameterParams {
2023-02-07 09:36:13 +01:00
TemplateVersionID : input . TemplateVersionID ,
Name : richParameter . Name ,
2023-04-03 14:37:47 +02:00
DisplayName : richParameter . DisplayName ,
2023-02-07 09:36:13 +01:00
Description : richParameter . Description ,
Type : richParameter . Type ,
2025-05-29 08:55:19 -05:00
FormType : dft ,
2023-02-07 09:36:13 +01:00
Mutable : richParameter . Mutable ,
DefaultValue : richParameter . DefaultValue ,
Icon : richParameter . Icon ,
Options : options ,
ValidationRegex : richParameter . ValidationRegex ,
ValidationError : richParameter . ValidationError ,
2023-05-30 14:57:06 +02:00
ValidationMin : validationMin ,
ValidationMax : validationMax ,
2023-02-07 09:36:13 +01:00
ValidationMonotonic : richParameter . ValidationMonotonic ,
2023-03-07 16:38:31 +01:00
Required : richParameter . Required ,
2023-06-30 12:41:55 +02:00
DisplayOrder : richParameter . Order ,
2023-07-10 13:44:03 +02:00
Ephemeral : richParameter . Ephemeral ,
2023-01-17 11:22:11 +01:00
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert parameter: %w" , err )
2023-01-17 11:22:11 +01:00
}
}
2025-05-21 16:48:51 +02:00
// Process presets and parameters
err := InsertWorkspacePresetsAndParameters ( ctx , s . Logger , db , jobID , input . TemplateVersionID , jobType . TemplateImport . Presets , now )
2025-02-17 13:00:44 +02:00
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert workspace presets and parameters: %w" , err )
2025-02-17 13:00:44 +02:00
}
2025-05-21 16:48:51 +02:00
// Process external auth providers
2023-02-27 10:18:19 -06:00
var completedError sql . NullString
2023-09-29 14:13:20 -05:00
for _ , externalAuthProvider := range jobType . TemplateImport . ExternalAuthProviders {
2023-03-22 14:37:08 -05:00
contains := false
2023-09-29 14:13:20 -05:00
for _ , configuredProvider := range s . ExternalAuthConfigs {
2024-02-21 11:18:38 -07:00
if configuredProvider . ID == externalAuthProvider . Id {
2023-03-22 14:37:08 -05:00
contains = true
break
}
}
if ! contains {
2023-02-27 10:18:19 -06:00
completedError = sql . NullString {
2024-02-21 11:18:38 -07:00
String : fmt . Sprintf ( "external auth provider %q is not configured" , externalAuthProvider . Id ),
2023-02-27 10:18:19 -06:00
Valid : true ,
}
break
}
}
2024-02-21 11:18:38 -07:00
// Fallback to `ExternalAuthProvidersNames` if it was specified and `ExternalAuthProviders`
// was not. Gives us backwards compatibility with custom provisioners that haven't been
// updated to use the new field yet.
var externalAuthProviders [] database . ExternalAuthProvider
if providersLen := len ( jobType . TemplateImport . ExternalAuthProviders ); providersLen > 0 {
externalAuthProviders = make ([] database . ExternalAuthProvider , 0 , providersLen )
for _ , provider := range jobType . TemplateImport . ExternalAuthProviders {
externalAuthProviders = append ( externalAuthProviders , database . ExternalAuthProvider {
ID : provider . Id ,
Optional : provider . Optional ,
})
}
} else if namesLen := len ( jobType . TemplateImport . ExternalAuthProvidersNames ); namesLen > 0 {
externalAuthProviders = make ([] database . ExternalAuthProvider , 0 , namesLen )
for _ , providerID := range jobType . TemplateImport . ExternalAuthProvidersNames {
externalAuthProviders = append ( externalAuthProviders , database . ExternalAuthProvider {
ID : providerID ,
})
}
}
externalAuthProvidersMessage , err := json . Marshal ( externalAuthProviders )
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "failed to serialize external_auth_providers value: %w" , err )
2024-02-21 11:18:38 -07:00
}
2025-05-21 16:48:51 +02:00
err = db . UpdateTemplateVersionExternalAuthProvidersByJobID ( ctx , database . UpdateTemplateVersionExternalAuthProvidersByJobIDParams {
2023-09-29 14:13:20 -05:00
JobID : jobID ,
2025-03-24 10:01:50 -06:00
ExternalAuthProviders : externalAuthProvidersMessage ,
UpdatedAt : now ,
2023-02-27 10:18:19 -06:00
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "update template version external auth providers: %w" , err )
2023-02-27 10:18:19 -06:00
}
2025-08-19 10:29:51 +02:00
err = db . UpdateTemplateVersionFlagsByJobID ( ctx , database . UpdateTemplateVersionFlagsByJobIDParams {
2025-06-24 12:36:37 +02:00
JobID : jobID ,
2025-08-19 10:41:33 +02:00
HasExternalAgent : sql . NullBool {
Bool : jobType . TemplateImport . HasExternalAgents ,
Valid : true ,
},
UpdatedAt : now ,
2025-06-24 12:36:37 +02:00
})
if err != nil {
2026-09-11 03:48:56 +02:00
return xerrors . Errorf ( "update template version external agent: %w" , err )
2025-06-24 12:36:37 +02:00
}
2023-02-27 10:18:19 -06:00
2025-05-21 16:48:51 +02:00
// Process terraform values
2025-05-12 13:50:07 -06:00
plan := jobType . TemplateImport . Plan
moduleFiles := jobType . TemplateImport . ModuleFiles
// If there is a plan, or a module files archive we need to insert a
// template_version_terraform_values row.
if len ( plan ) > 0 || len ( moduleFiles ) > 0 {
// ...but the plan and the module files archive are both optional! So
// we need to fallback to a valid JSON object if the plan was omitted.
if len ( plan ) == 0 {
plan = [] byte ( "{}" )
}
// ...and we only want to insert a files row if an archive was provided.
var fileID uuid . NullUUID
if len ( moduleFiles ) > 0 {
hashBytes := sha256 . Sum256 ( moduleFiles )
hash := hex . EncodeToString ( hashBytes [:])
2026-03-27 15:08:30 +00:00
//nolint:gocritic // Acting as provisionerd
file , err := db . GetFileByHashAndCreator ( dbauthz . AsProvisionerd ( ctx ), database . GetFileByHashAndCreatorParams { Hash : hash , CreatedBy : uuid . Nil })
2025-05-12 13:50:07 -06:00
switch {
case err == nil :
// This set of modules is already cached, which means we can reuse them
fileID = uuid . NullUUID {
Valid : true ,
UUID : file . ID ,
}
case ! xerrors . Is ( err , sql . ErrNoRows ):
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "check for cached modules: %w" , err )
2025-05-12 13:50:07 -06:00
default :
2026-03-27 15:08:30 +00:00
//nolint:gocritic // Acting as provisionerd
file , err = db . InsertFile ( dbauthz . AsProvisionerd ( ctx ), database . InsertFileParams {
2025-05-12 13:50:07 -06:00
ID : uuid . New (),
Hash : hash ,
CreatedBy : uuid . Nil ,
CreatedAt : dbtime . Now (),
Mimetype : tarMimeType ,
Data : moduleFiles ,
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert template version terraform modules: %w" , err )
2025-05-12 13:50:07 -06:00
}
fileID = uuid . NullUUID {
Valid : true ,
UUID : file . ID ,
}
}
}
2025-06-13 12:46:26 -05:00
if len ( jobType . TemplateImport . ModuleFilesHash ) > 0 {
hashString := hex . EncodeToString ( jobType . TemplateImport . ModuleFilesHash )
//nolint:gocritic // Acting as provisioner
file , err := db . GetFileByHashAndCreator ( dbauthz . AsProvisionerd ( ctx ), database . GetFileByHashAndCreatorParams { Hash : hashString , CreatedBy : uuid . Nil })
if err != nil {
return xerrors . Errorf ( "get file by hash, it should have been uploaded: %w" , err )
}
fileID = uuid . NullUUID {
Valid : true ,
UUID : file . ID ,
}
}
2025-05-21 16:48:51 +02:00
err = db . InsertTemplateVersionTerraformValuesByJobID ( ctx , database . InsertTemplateVersionTerraformValuesByJobIDParams {
2025-05-14 12:21:36 -05:00
JobID : jobID ,
UpdatedAt : now ,
CachedPlan : plan ,
CachedModuleFiles : fileID ,
ProvisionerdVersion : s . apiVersion ,
2025-04-16 09:14:35 -07:00
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert template version terraform data: %w" , err )
2025-04-16 09:14:35 -07:00
}
2025-03-24 10:01:50 -06:00
}
2025-05-21 16:48:51 +02:00
// Mark job as completed
err = db . UpdateProvisionerJobWithCompleteByID ( ctx , database . UpdateProvisionerJobWithCompleteByIDParams {
2022-11-07 19:10:49 -06:00
ID : jobID ,
2025-03-24 10:01:50 -06:00
UpdatedAt : now ,
2022-11-07 19:10:49 -06:00
CompletedAt : sql . NullTime {
2025-03-24 10:01:50 -06:00
Time : now ,
2022-11-07 19:10:49 -06:00
Valid : true ,
},
2023-10-03 09:23:45 +01:00
Error : completedError ,
ErrorCode : sql . NullString {},
2022-11-07 19:10:49 -06:00
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "update provisioner job: %w" , err )
2022-11-07 19:10:49 -06:00
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "marked import job as completed" , slog . F ( "job_id" , jobID ))
2025-03-24 10:01:50 -06:00
2025-05-21 16:48:51 +02:00
return nil
}, nil ) // End of transaction
}
// completeWorkspaceBuildJob handles completion of a workspace build job.
// Most database operations are performed within a transaction.
func ( s * server ) completeWorkspaceBuildJob ( ctx context . Context , job database . ProvisionerJob , jobID uuid . UUID , jobType * proto . CompletedJob_WorkspaceBuild_ , telemetrySnapshot * telemetry . Snapshot ) error {
var input WorkspaceProvisionJob
err := json . Unmarshal ( job . Input , & input )
if err != nil {
return xerrors . Errorf ( "unmarshal job data: %w" , err )
}
workspaceBuild , err := s . Database . GetWorkspaceBuildByID ( ctx , input . WorkspaceBuildID )
if err != nil {
return xerrors . Errorf ( "get workspace build: %w" , err )
}
var workspace database . Workspace
var getWorkspaceError error
// Execute all database modifications in a transaction
err = s . Database . InTx ( func ( db database . Store ) error {
// It's important we use s.timeNow() here because we want to be
// able to customize the current time from within tests.
now := s . timeNow ()
workspace , getWorkspaceError = db . GetWorkspaceByID ( ctx , workspaceBuild . WorkspaceID )
if getWorkspaceError != nil {
s . Logger . Error ( ctx ,
"fetch workspace for build" ,
slog . F ( "workspace_build_id" , workspaceBuild . ID ),
slog . F ( "workspace_id" , workspaceBuild . WorkspaceID ),
)
return getWorkspaceError
2022-11-07 19:10:49 -06:00
}
2025-08-13 12:45:46 +01:00
// Prebuilt workspaces must not have Deadline or MaxDeadline set,
// as they are managed by the prebuild reconciliation loop, not the lifecycle executor
deadline := time . Time {}
maxDeadline := time . Time {}
2025-05-21 16:48:51 +02:00
2025-08-13 12:45:46 +01:00
if ! workspace . IsPrebuild () {
templateScheduleStore := * s . TemplateScheduleStore . Load ()
2022-11-07 19:10:49 -06:00
2025-08-13 12:45:46 +01:00
autoStop , err := schedule . CalculateAutostop ( ctx , schedule . CalculateAutostopParams {
Database : db ,
TemplateScheduleStore : templateScheduleStore ,
UserQuietHoursScheduleStore : * s . UserQuietHoursScheduleStore . Load (),
// `now` is used below to set the build completion time.
WorkspaceBuildCompletedAt : now ,
Workspace : workspace . WorkspaceTable (),
// Allowed to be the empty string.
WorkspaceAutostart : workspace . AutostartSchedule . String ,
})
2023-03-08 01:14:58 +11:00
if err != nil {
2025-08-13 12:45:46 +01:00
return xerrors . Errorf ( "calculate auto stop: %w" , err )
2023-03-08 01:14:58 +11:00
}
2025-08-13 12:45:46 +01:00
if workspace . AutostartSchedule . Valid {
templateScheduleOptions , err := templateScheduleStore . Get ( ctx , db , workspace . TemplateID )
2024-12-02 21:02:36 +00:00
if err != nil {
2025-08-13 12:45:46 +01:00
return xerrors . Errorf ( "get template schedule options: %w" , err )
}
nextStartAt , err := schedule . NextAllowedAutostart ( now , workspace . AutostartSchedule . String , templateScheduleOptions )
if err == nil {
err = db . UpdateWorkspaceNextStartAt ( ctx , database . UpdateWorkspaceNextStartAtParams {
ID : workspace . ID ,
NextStartAt : sql . NullTime { Valid : true , Time : nextStartAt . UTC ()},
})
if err != nil {
return xerrors . Errorf ( "update workspace next start at: %w" , err )
}
2024-12-02 21:02:36 +00:00
}
}
2025-08-13 12:45:46 +01:00
deadline = autoStop . Deadline
maxDeadline = autoStop . MaxDeadline
2022-11-07 19:10:49 -06:00
}
2025-05-21 16:48:51 +02:00
err = db . UpdateProvisionerJobWithCompleteByID ( ctx , database . UpdateProvisionerJobWithCompleteByIDParams {
ID : jobID ,
UpdatedAt : now ,
CompletedAt : sql . NullTime {
Time : now ,
Valid : true ,
},
Error : sql . NullString {},
ErrorCode : sql . NullString {},
})
if err != nil {
return xerrors . Errorf ( "update provisioner job: %w" , err )
}
err = db . UpdateWorkspaceBuildProvisionerStateByID ( ctx , database . UpdateWorkspaceBuildProvisionerStateByIDParams {
ID : workspaceBuild . ID ,
ProvisionerState : jobType . WorkspaceBuild . State ,
UpdatedAt : now ,
})
if err != nil {
return xerrors . Errorf ( "update workspace build provisioner state: %w" , err )
}
err = db . UpdateWorkspaceBuildDeadlineByID ( ctx , database . UpdateWorkspaceBuildDeadlineByIDParams {
ID : workspaceBuild . ID ,
2025-08-13 12:45:46 +01:00
Deadline : deadline ,
MaxDeadline : maxDeadline ,
2025-05-21 16:48:51 +02:00
UpdatedAt : now ,
})
if err != nil {
return xerrors . Errorf ( "update workspace build deadline: %w" , err )
}
agentTimeouts := make ( map [ time . Duration ] bool ) // A set of agent timeouts.
// This could be a bulk insert to improve performance.
for _ , protoResource := range jobType . WorkspaceBuild . Resources {
2025-10-13 12:57:06 +03:00
for _ , protoAgent := range protoResource . GetAgents () {
if protoAgent == nil {
continue
}
// By default InsertWorkspaceResource ignores the protoAgent.Id
2026-09-11 03:48:56 +02:00
// and generates a new one, but we insert these using the
// InsertWorkspaceResourceWithAgentIDsFromProto option so the
// inserted agents keep the IDs assigned here.
2025-10-13 12:57:06 +03:00
agentID := uuid . New ()
protoAgent . Id = agentID . String ()
2025-05-21 16:48:51 +02:00
dur := time . Duration ( protoAgent . GetConnectionTimeoutSeconds ()) * time . Second
agentTimeouts [ dur ] = true
2026-01-30 17:19:19 +00:00
for _ , dc := range protoAgent . GetDevcontainers () {
dc . Id = uuid . New (). String ()
if dc . GetSubagentId () != "" {
2026-09-11 03:48:56 +02:00
dc . SubagentId = uuid . New (). String ()
2026-01-30 17:19:19 +00:00
}
}
2025-05-21 16:48:51 +02:00
}
2025-10-13 12:57:06 +03:00
err = InsertWorkspaceResource (
ctx ,
db ,
job . ID ,
workspaceBuild . Transition ,
protoResource ,
telemetrySnapshot ,
// Ensure that the agent IDs we set previously
// are written to the database.
InsertWorkspaceResourceWithAgentIDsFromProto (),
)
2025-05-21 16:48:51 +02:00
if err != nil {
2026-06-11 15:02:41 -04:00
s . warnWorkspaceAppRebindRejected ( ctx , jobID , err )
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert provisioner job: %w" , err )
}
}
2026-05-18 08:33:29 -04:00
// Soft-delete agents from prior builds now that this build's
// agents have been inserted. Waiting until completion (rather
// than build creation) avoids bricking running workspaces
// whose agents would otherwise be deleted while the new build
// is still queued or provisioning. See #25155.
err = db . SoftDeletePriorWorkspaceAgents ( ctx , database . SoftDeletePriorWorkspaceAgentsParams {
WorkspaceID : workspaceBuild . WorkspaceID ,
CurrentBuildID : workspaceBuild . ID ,
})
if err != nil {
return xerrors . Errorf ( "soft delete prior workspace agents: %w" , err )
}
2025-05-21 16:48:51 +02:00
for _ , module := range jobType . WorkspaceBuild . Modules {
if err := InsertWorkspaceModule ( ctx , db , job . ID , workspaceBuild . Transition , module , telemetrySnapshot ); err != nil {
return xerrors . Errorf ( "insert provisioner job module: %w" , err )
}
}
2025-11-03 13:46:38 +02:00
_ , hasExternalAgent := slice . Find ( jobType . WorkspaceBuild . Resources , func ( resource * sdkproto . Resource ) bool {
return resource . Type == "coder_external_agent"
})
2025-08-19 10:29:51 +02:00
if err := db . UpdateWorkspaceBuildFlagsByID ( ctx , database . UpdateWorkspaceBuildFlagsByIDParams {
2025-06-24 12:36:37 +02:00
ID : workspaceBuild . ID ,
2025-08-19 10:41:33 +02:00
HasExternalAgent : sql . NullBool {
Bool : hasExternalAgent ,
Valid : true ,
},
2025-11-03 13:46:38 +02:00
UpdatedAt : now ,
2025-08-08 18:06:32 +01:00
}); err != nil {
2026-09-11 03:48:56 +02:00
return xerrors . Errorf ( "update workspace build external agent flag: %w" , err )
2025-06-24 12:36:37 +02:00
}
2025-05-21 16:48:51 +02:00
// Insert timings inside the transaction now
2024-08-21 14:18:58 +02:00
// nolint:exhaustruct // The other fields are set further down.
params := database . InsertProvisionerJobTimingsParams {
JobID : jobID ,
}
2025-05-21 16:48:51 +02:00
for _ , t := range jobType . WorkspaceBuild . Timings {
2025-05-29 13:36:06 +01:00
start := t . GetStart ()
if ! start . IsValid () || start . AsTime (). IsZero () {
s . Logger . Warn ( ctx , "timings entry has nil or zero start time" , slog . F ( "job_id" , job . ID . String ()), slog . F ( "workspace_id" , workspace . ID ), slog . F ( "workspace_build_id" , workspaceBuild . ID ), slog . F ( "user_id" , workspace . OwnerID ))
continue
}
end := t . GetEnd ()
if ! end . IsValid () || end . AsTime (). IsZero () {
s . Logger . Warn ( ctx , "timings entry has nil or zero end time, skipping" , slog . F ( "job_id" , job . ID . String ()), slog . F ( "workspace_id" , workspace . ID ), slog . F ( "workspace_build_id" , workspaceBuild . ID ), slog . F ( "user_id" , workspace . OwnerID ))
2024-08-21 14:18:58 +02:00
continue
}
var stg database . ProvisionerJobTimingStage
if err := stg . Scan ( t . Stage ); err != nil {
s . Logger . Warn ( ctx , "failed to parse timings stage, skipping" , slog . F ( "value" , t . Stage ))
continue
}
2025-11-19 09:34:19 -06:00
// Scan does not guarantee validity
if ! stg . Valid () {
s . Logger . Warn ( ctx , "invalid stage, will fail insert based one enum" , slog . F ( "value" , t . Stage ))
continue
}
2024-08-21 14:18:58 +02:00
params . Stage = append ( params . Stage , stg )
params . Source = append ( params . Source , t . Source )
params . Resource = append ( params . Resource , t . Resource )
params . Action = append ( params . Action , t . Action )
params . StartedAt = append ( params . StartedAt , t . Start . AsTime ())
params . EndedAt = append ( params . EndedAt , t . End . AsTime ())
}
2025-05-21 16:48:51 +02:00
_ , err = db . InsertProvisionerJobTimings ( ctx , params )
2024-08-21 14:18:58 +02:00
if err != nil {
2025-11-19 09:34:19 -06:00
// A database error here will "fail" this transaction. Making this error fatal.
// If this error is seen, add checks above to validate the insert parameters. In
// production, timings should not be a fatal error.
2024-08-21 14:18:58 +02:00
s . Logger . Warn ( ctx , "failed to update provisioner job timings" , slog . F ( "job_id" , jobID ), slog . Error ( err ))
2025-11-19 09:34:19 -06:00
return xerrors . Errorf ( "update provisioner job timings: %w" , err )
2024-08-21 14:18:58 +02:00
}
2025-05-21 16:48:51 +02:00
// On start, we want to ensure that workspace agents timeout statuses
// are propagated. This method is simple and does not protect against
// notifying in edge cases like when a workspace is stopped soon
// after being started.
//
// Agent timeouts could be minutes apart, resulting in an unresponsive
2025-05-29 13:36:06 +01:00
// experience, so we'll notify after every unique timeout seconds
2025-05-21 16:48:51 +02:00
if ! input . DryRun && workspaceBuild . Transition == database . WorkspaceTransitionStart && len ( agentTimeouts ) > 0 {
timeouts := maps . Keys ( agentTimeouts )
slices . Sort ( timeouts )
var updates [] <- chan time . Time
for _ , d := range timeouts {
s . Logger . Debug ( ctx , "triggering workspace notification after agent timeout" ,
slog . F ( "workspace_build_id" , workspaceBuild . ID ),
slog . F ( "timeout" , d ),
)
// Agents are inserted with `dbtime.Now()`, this triggers a
// workspace event approximately after created + timeout seconds.
updates = append ( updates , time . After ( d ))
2024-07-08 15:38:50 +02:00
}
2025-05-21 16:48:51 +02:00
go func () {
for _ , wait := range updates {
select {
case <- s . lifecycleCtx . Done ():
// If the server is shutting down, we don't want to wait around.
s . Logger . Debug ( ctx , "stopping notifications due to server shutdown" ,
slog . F ( "workspace_build_id" , workspaceBuild . ID ),
)
return
case <- wait :
// Wait for the next potential timeout to occur.
msg , err := json . Marshal ( wspubsub . WorkspaceEvent {
Kind : wspubsub . WorkspaceEventKindAgentTimeout ,
WorkspaceID : workspace . ID ,
})
if err != nil {
s . Logger . Error ( ctx , "marshal workspace update event" , slog . Error ( err ))
break
}
if err := s . Pubsub . Publish ( wspubsub . WorkspaceEventChannel ( workspace . OwnerID ), msg ); err != nil {
if s . lifecycleCtx . Err () != nil {
// If the server is shutting down, we don't want to log this error, nor wait around.
s . Logger . Debug ( ctx , "stopping notifications due to server shutdown" ,
slog . F ( "workspace_build_id" , workspaceBuild . ID ),
)
return
}
s . Logger . Error ( ctx , "workspace notification after agent timeout failed" ,
slog . F ( "workspace_build_id" , workspaceBuild . ID ),
slog . Error ( err ),
)
}
}
}
}()
2022-11-22 13:22:56 -05:00
}
2025-05-21 16:48:51 +02:00
if workspaceBuild . Transition != database . WorkspaceTransitionDelete {
// This is for deleting a workspace!
return nil
2025-05-14 14:52:22 +02:00
}
2025-05-21 16:48:51 +02:00
err = db . UpdateWorkspaceDeletedByID ( ctx , database . UpdateWorkspaceDeletedByIDParams {
ID : workspaceBuild . WorkspaceID ,
Deleted : true ,
2024-11-01 14:17:05 +11:00
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "update workspace deleted: %w" , err )
2024-11-01 14:17:05 +11:00
}
2025-12-11 13:04:13 +00:00
2026-05-18 08:33:29 -04:00
// Soft-delete any agents tied to this workspace so the
// aws-instance-identity handler (which filters on
// workspace_agents.deleted) doesn't keep seeing orphaned rows
// after the workspace itself is deleted. See #25155.
if err := db . SoftDeleteWorkspaceAgentsByWorkspaceID ( ctx , workspaceBuild . WorkspaceID ); err != nil {
return xerrors . Errorf ( "soft delete workspace agents: %w" , err )
}
2025-05-21 16:48:51 +02:00
return nil
}, nil )
if err != nil {
return xerrors . Errorf ( "complete job: %w" , err )
}
// Post-transaction operations (operations that do not require transactions or
// are external to the database, like audit logging, notifications, etc.)
// audit the outcome of the workspace build
if getWorkspaceError == nil {
// If the workspace has been deleted, notify the owner about it.
if workspaceBuild . Transition == database . WorkspaceTransitionDelete {
s . notifyWorkspaceDeleted ( ctx , workspace , workspaceBuild )
}
auditor := s . Auditor . Load ()
auditAction := auditActionFromTransition ( workspaceBuild . Transition )
previousBuildNumber := workspaceBuild . BuildNumber - 1
previousBuild , prevBuildErr := s . Database . GetWorkspaceBuildByWorkspaceIDAndBuildNumber ( ctx , database . GetWorkspaceBuildByWorkspaceIDAndBuildNumberParams {
WorkspaceID : workspace . ID ,
BuildNumber : previousBuildNumber ,
})
if prevBuildErr != nil {
previousBuild = database . WorkspaceBuild {}
}
// We pass the below information to the Auditor so that it
// can form a friendly string for the user to view in the UI.
buildResourceInfo := audit . AdditionalFields {
WorkspaceName : workspace . Name ,
BuildNumber : strconv . FormatInt ( int64 ( workspaceBuild . BuildNumber ), 10 ),
BuildReason : database . BuildReason ( string ( workspaceBuild . Reason )),
WorkspaceID : workspace . ID ,
}
wriBytes , err := json . Marshal ( buildResourceInfo )
2022-11-07 19:10:49 -06:00
if err != nil {
2025-05-21 16:48:51 +02:00
s . Logger . Error ( ctx , "marshal resource info for successful job" , slog . Error ( err ))
2022-11-07 19:10:49 -06:00
}
2025-05-14 14:15:36 +02:00
2025-05-21 16:48:51 +02:00
bag := audit . BaggageFromContext ( ctx )
2025-05-14 14:15:36 +02:00
2025-05-21 16:48:51 +02:00
audit . BackgroundAudit ( ctx , & audit . BackgroundAuditParams [ database . WorkspaceBuild ]{
Audit : * auditor ,
Log : s . Logger ,
UserID : job . InitiatorID ,
OrganizationID : workspace . OrganizationID ,
RequestID : job . ID ,
IP : bag . IP ,
Action : auditAction ,
Old : previousBuild ,
New : workspaceBuild ,
Status : http . StatusOK ,
AdditionalFields : wriBytes ,
})
}
if s . PrebuildsOrchestrator != nil && input . PrebuiltWorkspaceBuildStage == sdkproto . PrebuiltWorkspaceBuildStage_CLAIM {
// Track resource replacements, if there are any.
orchestrator := s . PrebuildsOrchestrator . Load ()
if resourceReplacements := jobType . WorkspaceBuild . ResourceReplacements ; orchestrator != nil && len ( resourceReplacements ) > 0 {
// Fire and forget. Bind to the lifecycle of the server so shutdowns are handled gracefully.
go ( * orchestrator ). TrackResourceReplacement ( s . lifecycleCtx , workspace . ID , workspaceBuild . ID , resourceReplacements )
2025-05-14 14:15:36 +02:00
}
2025-05-21 16:48:51 +02:00
}
2025-08-28 15:00:26 +01:00
// Update workspace (regular and prebuild) timing metrics
2025-11-14 12:26:32 +00:00
// Only consider 'start' workspace builds
if s . metrics != nil && workspaceBuild . Transition == database . WorkspaceTransitionStart {
// Get the updated job to report the metrics with correct data
updatedJob , err := s . Database . GetProvisionerJobByID ( ctx , jobID )
if err != nil {
s . Logger . Error ( ctx , "get updated job from database" , slog . Error ( err ))
} else
// Only consider 'succeeded' provisioner jobs
if updatedJob . JobStatus == database . ProvisionerJobStatusSucceeded {
presetName := ""
if workspaceBuild . TemplateVersionPresetID . Valid {
preset , err := s . Database . GetPresetByID ( ctx , workspaceBuild . TemplateVersionPresetID . UUID )
if err != nil {
if ! errors . Is ( err , sql . ErrNoRows ) {
s . Logger . Error ( ctx , "get preset by ID for workspace timing metrics" , slog . Error ( err ))
2025-08-28 15:00:26 +01:00
}
2025-11-14 12:26:32 +00:00
} else {
presetName = preset . Name
2025-08-28 15:00:26 +01:00
}
2025-11-14 12:26:32 +00:00
}
2025-08-28 15:00:26 +01:00
2025-11-14 12:26:32 +00:00
buildTime := updatedJob . CompletedAt . Time . Sub ( updatedJob . StartedAt . Time ). Seconds ()
flags := WorkspaceTimingFlags {
// Is a prebuilt workspace creation build
IsPrebuild : input . PrebuiltWorkspaceBuildStage . IsPrebuild (),
// Is a prebuilt workspace claim build
IsClaim : input . PrebuiltWorkspaceBuildStage . IsPrebuiltWorkspaceClaim (),
// Is a regular workspace creation build
// Only consider the first build number for regular workspaces
IsFirstBuild : workspaceBuild . BuildNumber == 1 ,
}
// Only track metrics for prebuild creation, prebuild claims and workspace creation
if flags . IsTrackable () {
2025-08-28 15:00:26 +01:00
s . metrics . UpdateWorkspaceTimingsMetrics (
ctx ,
2025-11-14 12:26:32 +00:00
flags ,
2025-08-28 15:00:26 +01:00
workspace . OrganizationName ,
workspace . TemplateName ,
presetName ,
buildTime ,
)
}
}
}
2026-07-07 09:18:30 -07:00
// Wake the orchestrator before the workspace event publish below,
// which returns on error, so a failed UI event cannot skip the
// wake.
if err := wspubsub . PublishWorkspaceBuildOrchestrationWake ( ctx , s . Pubsub ); err != nil {
s . Logger . Warn ( ctx , "failed to publish workspace build orchestration wake" ,
slog . Error ( err ),
)
}
2025-05-21 16:48:51 +02:00
msg , err := json . Marshal ( wspubsub . WorkspaceEvent {
Kind : wspubsub . WorkspaceEventKindStateChange ,
WorkspaceID : workspace . ID ,
})
if err != nil {
return xerrors . Errorf ( "marshal workspace update event: %s" , err )
}
err = s . Pubsub . Publish ( wspubsub . WorkspaceEventChannel ( workspace . OwnerID ), msg )
if err != nil {
return xerrors . Errorf ( "update workspace: %w" , err )
}
2026-03-13 20:37:41 -07:00
// Publish workspace build update to the all builds channel if the experiment is enabled.
if s . Experiments . Enabled ( codersdk . ExperimentWorkspaceBuildUpdates ) {
err = wspubsub . PublishWorkspaceBuildUpdate ( ctx , s . Pubsub , codersdk . WorkspaceBuildUpdate {
WorkspaceID : workspace . ID ,
WorkspaceName : workspace . Name ,
BuildID : workspaceBuild . ID ,
Transition : string ( workspaceBuild . Transition ),
JobStatus : string ( database . ProvisionerJobStatusSucceeded ),
BuildNumber : workspaceBuild . BuildNumber ,
})
if err != nil {
s . Logger . Warn ( ctx , "failed to publish workspace build update" , slog . Error ( err ))
}
}
2025-05-21 16:48:51 +02:00
if input . PrebuiltWorkspaceBuildStage == sdkproto . PrebuiltWorkspaceBuildStage_CLAIM {
s . Logger . Info ( ctx , "workspace prebuild successfully claimed by user" ,
slog . F ( "workspace_id" , workspace . ID ))
err = prebuilds . NewPubsubWorkspaceClaimPublisher ( s . Pubsub ). PublishWorkspaceClaim ( agentsdk . ReinitializationEvent {
WorkspaceID : workspace . ID ,
Reason : agentsdk . ReinitializeReasonPrebuildClaimed ,
2026-04-02 23:51:02 +02:00
OwnerID : workspace . OwnerID ,
2025-05-21 16:48:51 +02:00
})
if err != nil {
s . Logger . Error ( ctx , "failed to publish workspace claim event" , slog . Error ( err ))
}
}
return nil
}
// completeTemplateDryRunJob handles completion of a template dry-run job.
// All database operations are performed within a transaction.
func ( s * server ) completeTemplateDryRunJob ( ctx context . Context , job database . ProvisionerJob , jobID uuid . UUID , jobType * proto . CompletedJob_TemplateDryRun_ , telemetrySnapshot * telemetry . Snapshot ) error {
// Execute all database operations in a transaction
return s . Database . InTx ( func ( db database . Store ) error {
now := s . timeNow ()
// Process resources
2022-11-07 19:10:49 -06:00
for _ , resource := range jobType . TemplateDryRun . Resources {
2023-08-30 14:48:35 +04:00
s . Logger . Info ( ctx , "inserting template dry-run job resource" ,
2022-11-07 19:10:49 -06:00
slog . F ( "job_id" , job . ID . String ()),
slog . F ( "resource_name" , resource . Name ),
slog . F ( "resource_type" , resource . Type ))
2025-05-21 16:48:51 +02:00
err := InsertWorkspaceResource ( ctx , db , jobID , database . WorkspaceTransitionStart , resource , telemetrySnapshot )
2022-11-07 19:10:49 -06:00
if err != nil {
2026-06-11 15:02:41 -04:00
s . warnWorkspaceAppRebindRejected ( ctx , jobID , err )
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "insert resource: %w" , err )
2022-11-07 19:10:49 -06:00
}
}
2025-05-21 16:48:51 +02:00
// Process modules
2024-11-16 21:56:19 +01:00
for _ , module := range jobType . TemplateDryRun . Modules {
s . Logger . Info ( ctx , "inserting template dry-run job module" ,
slog . F ( "job_id" , job . ID . String ()),
slog . F ( "module_source" , module . Source ),
)
2025-05-21 16:48:51 +02:00
if err := InsertWorkspaceModule ( ctx , db , jobID , database . WorkspaceTransitionStart , module , telemetrySnapshot ); err != nil {
return xerrors . Errorf ( "insert module: %w" , err )
2024-11-16 21:56:19 +01:00
}
}
2022-11-07 19:10:49 -06:00
2025-05-21 16:48:51 +02:00
// Mark job as complete
err := db . UpdateProvisionerJobWithCompleteByID ( ctx , database . UpdateProvisionerJobWithCompleteByIDParams {
2022-11-07 19:10:49 -06:00
ID : jobID ,
2025-05-21 16:48:51 +02:00
UpdatedAt : now ,
2022-11-07 19:10:49 -06:00
CompletedAt : sql . NullTime {
2025-05-21 16:48:51 +02:00
Time : now ,
2022-11-07 19:10:49 -06:00
Valid : true ,
},
2023-10-03 09:23:45 +01:00
Error : sql . NullString {},
ErrorCode : sql . NullString {},
2022-11-07 19:10:49 -06:00
})
if err != nil {
2025-05-21 16:48:51 +02:00
return xerrors . Errorf ( "update provisioner job: %w" , err )
2022-11-07 19:10:49 -06:00
}
2023-08-30 14:48:35 +04:00
s . Logger . Debug ( ctx , "marked template dry-run job as completed" , slog . F ( "job_id" , jobID ))
2022-11-07 19:10:49 -06:00
2025-05-21 16:48:51 +02:00
return nil
}, nil ) // End of transaction
2022-11-07 19:10:49 -06:00
}
2024-07-08 15:38:50 +02:00
func ( s * server ) notifyWorkspaceDeleted ( ctx context . Context , workspace database . Workspace , build database . WorkspaceBuild ) {
var reason string
2024-07-16 10:48:17 +02:00
initiator := build . InitiatorByUsername
2024-07-08 15:38:50 +02:00
if build . Reason . Valid () {
switch build . Reason {
case database . BuildReasonInitiator :
if build . InitiatorID == workspace . OwnerID {
// Deletions initiated by self should not notify.
return
}
reason = "initiated by user"
case database . BuildReasonAutodelete :
reason = "autodeleted due to dormancy"
2024-07-16 10:48:17 +02:00
initiator = "autobuild"
2024-07-08 15:38:50 +02:00
default :
reason = string ( build . Reason )
}
} else {
reason = string ( build . Reason )
s . Logger . Warn ( ctx , "invalid build reason when sending deletion notification" ,
slog . F ( "reason" , reason ), slog . F ( "workspace_id" , workspace . ID ), slog . F ( "build_id" , build . ID ))
}
2024-07-24 13:38:21 -03:00
if _ , err := s . NotificationsEnqueuer . Enqueue ( ctx , workspace . OwnerID , notifications . TemplateWorkspaceDeleted ,
2024-07-08 15:38:50 +02:00
map [ string ] string {
2024-07-16 10:48:17 +02:00
"name" : workspace . Name ,
"reason" : reason ,
"initiator" : initiator ,
2024-07-08 15:38:50 +02:00
}, "provisionerdserver" ,
// Associate this notification with all the related entities.
workspace . ID , workspace . OwnerID , workspace . TemplateID , workspace . OrganizationID ,
); err != nil {
s . Logger . Warn ( ctx , "failed to notify of workspace deletion" , slog . Error ( err ))
}
}
2023-08-30 14:48:35 +04:00
func ( s * server ) startTrace ( ctx context . Context , name string , opts ... trace . SpanStartOption ) ( context . Context , trace . Span ) {
return s . Tracer . Start ( ctx , name , append ( opts , trace . WithAttributes (
2023-05-03 18:02:35 -05:00
semconv . ServiceNameKey . String ( "coderd.provisionerd" ),
)) ... )
}
2024-11-16 21:56:19 +01:00
func InsertWorkspaceModule ( ctx context . Context , db database . Store , jobID uuid . UUID , transition database . WorkspaceTransition , protoModule * sdkproto . Module , snapshot * telemetry . Snapshot ) error {
module , err := db . InsertWorkspaceModule ( ctx , database . InsertWorkspaceModuleParams {
ID : uuid . New (),
CreatedAt : dbtime . Now (),
JobID : jobID ,
Transition : transition ,
Source : protoModule . Source ,
Version : protoModule . Version ,
Key : protoModule . Key ,
})
if err != nil {
return xerrors . Errorf ( "insert provisioner job module %q: %w" , protoModule . Source , err )
}
snapshot . WorkspaceModules = append ( snapshot . WorkspaceModules , telemetry . ConvertWorkspaceModule ( module ))
return nil
}
2025-02-17 13:00:44 +02:00
func InsertWorkspacePresetsAndParameters ( ctx context . Context , logger slog . Logger , db database . Store , jobID uuid . UUID , templateVersionID uuid . UUID , protoPresets [] * sdkproto . Preset , t time . Time ) error {
for _ , preset := range protoPresets {
logger . Info ( ctx , "inserting template import job preset" ,
slog . F ( "job_id" , jobID . String ()),
slog . F ( "preset_name" , preset . Name ),
)
if err := InsertWorkspacePresetAndParameters ( ctx , db , templateVersionID , preset , t ); err != nil {
return xerrors . Errorf ( "insert workspace preset: %w" , err )
}
}
return nil
}
func InsertWorkspacePresetAndParameters ( ctx context . Context , db database . Store , templateVersionID uuid . UUID , protoPreset * sdkproto . Preset , t time . Time ) error {
err := db . InTx ( func ( tx database . Store ) error {
2025-06-19 11:08:48 -04:00
var (
desiredInstances sql . NullInt32
ttl sql . NullInt32
schedulingEnabled bool
schedulingTimezone string
prebuildSchedules [] * sdkproto . Schedule
)
2025-04-07 10:35:28 +02:00
if protoPreset != nil && protoPreset . Prebuild != nil {
desiredInstances = sql . NullInt32 {
Int32 : protoPreset . Prebuild . Instances ,
Valid : true ,
}
2025-05-26 20:31:24 +01:00
if protoPreset . Prebuild . ExpirationPolicy != nil {
ttl = sql . NullInt32 {
Int32 : protoPreset . Prebuild . ExpirationPolicy . Ttl ,
Valid : true ,
}
}
2025-06-19 11:08:48 -04:00
if protoPreset . Prebuild . Scheduling != nil {
schedulingEnabled = true
schedulingTimezone = protoPreset . Prebuild . Scheduling . Timezone
prebuildSchedules = protoPreset . Prebuild . Scheduling . Schedule
}
2025-04-07 10:35:28 +02:00
}
2025-07-28 15:02:26 +01:00
2025-02-17 13:00:44 +02:00
dbPreset , err := tx . InsertPreset ( ctx , database . InsertPresetParams {
2025-05-26 20:31:24 +01:00
ID : uuid . New (),
TemplateVersionID : templateVersionID ,
Name : protoPreset . Name ,
CreatedAt : t ,
DesiredInstances : desiredInstances ,
InvalidateAfterSecs : ttl ,
2025-06-19 11:08:48 -04:00
SchedulingTimezone : schedulingTimezone ,
2025-06-24 12:19:19 +02:00
IsDefault : protoPreset . GetDefault (),
2025-07-28 15:02:26 +01:00
Description : protoPreset . Description ,
Icon : protoPreset . Icon ,
2025-11-20 17:12:25 +01:00
LastInvalidatedAt : sql . NullTime {},
2025-02-17 13:00:44 +02:00
})
if err != nil {
return xerrors . Errorf ( "insert preset: %w" , err )
}
2025-06-19 11:08:48 -04:00
if schedulingEnabled {
for _ , schedule := range prebuildSchedules {
_ , err := tx . InsertPresetPrebuildSchedule ( ctx , database . InsertPresetPrebuildScheduleParams {
PresetID : dbPreset . ID ,
CronExpression : schedule . Cron ,
DesiredInstances : schedule . Instances ,
})
if err != nil {
return xerrors . Errorf ( "failed to insert preset prebuild schedule: %w" , err )
}
}
}
2025-02-17 13:00:44 +02:00
var presetParameterNames [] string
var presetParameterValues [] string
for _ , parameter := range protoPreset . Parameters {
presetParameterNames = append ( presetParameterNames , parameter . Name )
presetParameterValues = append ( presetParameterValues , parameter . Value )
}
_ , err = tx . InsertPresetParameters ( ctx , database . InsertPresetParametersParams {
TemplateVersionPresetID : dbPreset . ID ,
Names : presetParameterNames ,
Values : presetParameterValues ,
})
if err != nil {
return xerrors . Errorf ( "insert preset parameters: %w" , err )
}
2025-04-07 10:35:28 +02:00
2025-02-17 13:00:44 +02:00
return nil
}, nil )
2026-08-26 11:00:31 +07:00
if database . IsUniqueViolation ( err , database . UniqueIndexUniquePresetName ) {
return xerrors . Errorf ( "duplicate preset name, must be unique per template: %q" , protoPreset . Name )
}
2025-02-17 13:00:44 +02:00
if err != nil {
return xerrors . Errorf ( "insert preset and parameters: %w" , err )
}
return nil
}
2025-10-13 12:57:06 +03:00
type insertWorkspaceResourceOptions struct {
useAgentIDsFromProto bool
}
// InsertWorkspaceResourceOption represents a functional option for
// InsertWorkspaceResource.
type InsertWorkspaceResourceOption func ( * insertWorkspaceResourceOptions )
// InsertWorkspaceResourceWithAgentIDsFromProto allows inserting agents into the
// database using the agent IDs defined in the proto resource.
func InsertWorkspaceResourceWithAgentIDsFromProto () InsertWorkspaceResourceOption {
return func ( opts * insertWorkspaceResourceOptions ) {
opts . useAgentIDsFromProto = true
}
}
func InsertWorkspaceResource ( ctx context . Context , db database . Store , jobID uuid . UUID , transition database . WorkspaceTransition , protoResource * sdkproto . Resource , snapshot * telemetry . Snapshot , opt ... InsertWorkspaceResourceOption ) error {
opts := & insertWorkspaceResourceOptions {}
for _ , o := range opt {
o ( opts )
}
2022-11-07 19:10:49 -06:00
resource , err := db . InsertWorkspaceResource ( ctx , database . InsertWorkspaceResourceParams {
ID : uuid . New (),
2023-09-01 19:50:12 +03:00
CreatedAt : dbtime . Now (),
2022-11-07 19:10:49 -06:00
JobID : jobID ,
Transition : transition ,
Type : protoResource . Type ,
Name : protoResource . Name ,
Hide : protoResource . Hide ,
Icon : protoResource . Icon ,
2022-11-14 11:57:33 -06:00
DailyCost : protoResource . DailyCost ,
2022-11-07 19:10:49 -06:00
InstanceType : sql . NullString {
String : protoResource . InstanceType ,
Valid : protoResource . InstanceType != "" ,
},
2024-11-16 21:56:19 +01:00
ModulePath : sql . NullString {
String : protoResource . ModulePath ,
// empty string is root module
Valid : true ,
},
2022-11-07 19:10:49 -06:00
})
if err != nil {
return xerrors . Errorf ( "insert provisioner job resource %q: %w" , protoResource . Name , err )
}
snapshot . WorkspaceResources = append ( snapshot . WorkspaceResources , telemetry . ConvertWorkspaceResource ( resource ))
2022-12-22 15:20:35 -08:00
var (
agentNames = make ( map [ string ] struct {})
appSlugs = make ( map [ string ] struct {})
)
2026-08-19 16:16:51 -06:00
// Agents can't connect to compute that these transitions tore down, so any
// agent Terraform still reports for them would only surface as unhealthy.
protoAgents := protoResource . Agents
if transition == database . WorkspaceTransitionStop || transition == database . WorkspaceTransitionDelete {
protoAgents = nil
}
for _ , prAgent := range protoAgents {
2025-02-20 16:09:26 +11:00
// Similar logic is duplicated in terraform/resources.go.
if prAgent . Name == "" {
return xerrors . Errorf ( "agent name cannot be empty" )
}
// In 2025-02 we removed support for underscores in agent names. To
// provide a nicer error message, we check the regex first and check
// for underscores if it fails.
if ! provisioner . AgentNameRegex . MatchString ( prAgent . Name ) {
if strings . Contains ( prAgent . Name , "_" ) {
return xerrors . Errorf ( "agent name %q contains underscores which are no longer supported, please use hyphens instead (regex: %q)" , prAgent . Name , provisioner . AgentNameRegex . String ())
}
return xerrors . Errorf ( "agent name %q does not match regex %q" , prAgent . Name , provisioner . AgentNameRegex . String ())
}
2025-02-20 12:51:25 +11:00
// Agent names must be case-insensitive-unique, to be unambiguous in
// `coder_app`s and CoderVPN DNS names.
if _ , ok := agentNames [ strings . ToLower ( prAgent . Name )]; ok {
2022-12-22 15:20:35 -08:00
return xerrors . Errorf ( "duplicate agent name %q" , prAgent . Name )
}
2025-02-20 12:51:25 +11:00
agentNames [ strings . ToLower ( prAgent . Name )] = struct {}{}
2022-12-22 15:20:35 -08:00
2022-11-07 19:10:49 -06:00
var instanceID sql . NullString
if prAgent . GetInstanceId () != "" {
instanceID = sql . NullString {
String : prAgent . GetInstanceId (),
Valid : true ,
}
}
2023-12-11 16:10:18 +02:00
env := make ( map [ string ] string )
2026-03-18 15:43:28 +01:00
// Apply extra envs with merge strategy support.
// When multiple coder_env resources define the same name,
// the merge_strategy controls how values are combined.
if err := MergeExtraEnvs ( env , prAgent . ExtraEnvs ); err != nil {
return err
2023-12-11 16:10:18 +02:00
}
// Allow the agent defined envs to override extra envs.
for k , v := range prAgent . Env {
env [ k ] = v
}
var envJSON pqtype . NullRawMessage
if len ( env ) > 0 {
data , err := json . Marshal ( env )
2022-11-07 19:10:49 -06:00
if err != nil {
return xerrors . Errorf ( "marshal env: %w" , err )
}
2023-12-11 16:10:18 +02:00
envJSON = pqtype . NullRawMessage {
2022-11-07 19:10:49 -06:00
RawMessage : data ,
Valid : true ,
}
}
authToken := uuid . New ()
if prAgent . GetToken () != "" {
authToken , err = uuid . Parse ( prAgent . GetToken ())
if err != nil {
return xerrors . Errorf ( "invalid auth token format; must be uuid: %w" , err )
}
}
2025-05-15 15:32:52 +01:00
apiKeyScope := database . AgentKeyScopeEnumAll
if prAgent . ApiKeyScope == string ( database . AgentKeyScopeEnumNoUserData ) {
apiKeyScope = database . AgentKeyScopeEnumNoUserData
}
2022-11-07 19:10:49 -06:00
agentID := uuid . New ()
2025-10-13 12:57:06 +03:00
if opts . useAgentIDsFromProto {
agentID , err = uuid . Parse ( prAgent . Id )
if err != nil {
return xerrors . Errorf ( "invalid agent ID format; must be uuid: %w" , err )
}
}
2022-11-07 19:10:49 -06:00
dbAgent , err := db . InsertWorkspaceAgent ( ctx , database . InsertWorkspaceAgentParams {
2023-09-25 16:47:17 -05:00
ID : agentID ,
2025-05-13 00:01:31 +01:00
ParentID : uuid . NullUUID {},
2023-09-25 16:47:17 -05:00
CreatedAt : dbtime . Now (),
UpdatedAt : dbtime . Now (),
ResourceID : resource . ID ,
Name : prAgent . Name ,
AuthToken : authToken ,
AuthInstanceID : instanceID ,
Architecture : prAgent . Architecture ,
2023-12-11 16:10:18 +02:00
EnvironmentVariables : envJSON ,
2023-09-25 16:47:17 -05:00
Directory : prAgent . Directory ,
OperatingSystem : prAgent . OperatingSystem ,
ConnectionTimeoutSeconds : prAgent . GetConnectionTimeoutSeconds (),
TroubleshootingURL : prAgent . GetTroubleshootingUrl (),
MOTDFile : prAgent . GetMotdFile (),
DisplayApps : convertDisplayApps ( prAgent . GetDisplayApps ()),
2023-10-03 09:23:45 +01:00
InstanceMetadata : pqtype . NullRawMessage {},
ResourceMetadata : pqtype . NullRawMessage {},
2025-03-26 01:56:39 -05:00
// #nosec G115 - Order represents a display order value that's always small and fits in int32
DisplayOrder : int32 ( prAgent . Order ),
2025-05-15 15:32:52 +01:00
APIKeyScope : apiKeyScope ,
2022-11-07 19:10:49 -06:00
})
if err != nil {
return xerrors . Errorf ( "insert agent: %w" , err )
}
snapshot . WorkspaceAgents = append ( snapshot . WorkspaceAgents , telemetry . ConvertWorkspaceAgent ( dbAgent ))
2023-03-31 15:26:19 -05:00
for _ , md := range prAgent . Metadata {
p := database . InsertWorkspaceAgentMetadataParams {
WorkspaceAgentID : agentID ,
DisplayName : md . DisplayName ,
Script : md . Script ,
Key : md . Key ,
Timeout : md . Timeout ,
Interval : md . Interval ,
2025-03-26 01:56:39 -05:00
// #nosec G115 - Order represents a display order value that's always small and fits in int32
DisplayOrder : int32 ( md . Order ),
2023-03-31 15:26:19 -05:00
}
err := db . InsertWorkspaceAgentMetadata ( ctx , p )
if err != nil {
return xerrors . Errorf ( "insert agent metadata: %w, params: %+v" , err , p )
}
}
2025-02-04 18:45:33 +01:00
if prAgent . ResourcesMonitoring != nil {
if prAgent . ResourcesMonitoring . Memory != nil {
_ , err = db . InsertMemoryResourceMonitor ( ctx , database . InsertMemoryResourceMonitorParams {
2025-02-17 16:56:52 +00:00
AgentID : agentID ,
Enabled : prAgent . ResourcesMonitoring . Memory . Enabled ,
Threshold : prAgent . ResourcesMonitoring . Memory . Threshold ,
State : database . WorkspaceAgentMonitorStateOK ,
CreatedAt : dbtime . Now (),
UpdatedAt : dbtime . Now (),
DebouncedUntil : time . Time {},
2025-02-04 18:45:33 +01:00
})
if err != nil {
return xerrors . Errorf ( "failed to insert agent memory resource monitor into db: %w" , err )
}
}
for _ , volume := range prAgent . ResourcesMonitoring . Volumes {
_ , err = db . InsertVolumeResourceMonitor ( ctx , database . InsertVolumeResourceMonitorParams {
2025-02-17 16:56:52 +00:00
AgentID : agentID ,
Path : volume . Path ,
Enabled : volume . Enabled ,
Threshold : volume . Threshold ,
State : database . WorkspaceAgentMonitorStateOK ,
CreatedAt : dbtime . Now (),
UpdatedAt : dbtime . Now (),
DebouncedUntil : time . Time {},
2025-02-04 18:45:33 +01:00
})
if err != nil {
return xerrors . Errorf ( "failed to insert agent volume resource monitor into db: %w" , err )
}
}
}
2026-01-30 17:19:19 +00:00
scriptsParams := agentScriptsFromProto ( prAgent . Scripts )
2023-09-25 16:47:17 -05:00
2025-03-27 12:31:30 +02:00
// Dev Containers require a script and log/source, so we do this before
// the logs insert below.
if devcontainers := prAgent . GetDevcontainers (); len ( devcontainers ) > 0 {
var (
devcontainerIDs = make ([] uuid . UUID , 0 , len ( devcontainers ))
devcontainerNames = make ([] string , 0 , len ( devcontainers ))
devcontainerWorkspaceFolders = make ([] string , 0 , len ( devcontainers ))
devcontainerConfigPaths = make ([] string , 0 , len ( devcontainers ))
2026-01-30 17:19:19 +00:00
devcontainerSubagentIDs = make ([] uuid . UUID , 0 , len ( devcontainers ))
2025-03-27 12:31:30 +02:00
)
for _ , dc := range devcontainers {
id := uuid . New ()
2026-01-30 17:19:19 +00:00
if opts . useAgentIDsFromProto {
id , err = uuid . Parse ( dc . GetId ())
if err != nil {
return xerrors . Errorf ( "invalid devcontainer ID format; must be uuid: %w" , err )
}
}
subAgentID , err := insertDevcontainerSubagent ( ctx , db , dc , dbAgent , resource . ID , appSlugs , snapshot , opts )
if err != nil {
return xerrors . Errorf ( "insert devcontainer %q subagent: %w" , dc . GetName (), err )
}
2025-03-27 12:31:30 +02:00
devcontainerIDs = append ( devcontainerIDs , id )
2026-01-30 17:19:19 +00:00
devcontainerNames = append ( devcontainerNames , dc . GetName ())
devcontainerWorkspaceFolders = append ( devcontainerWorkspaceFolders , dc . GetWorkspaceFolder ())
devcontainerConfigPaths = append ( devcontainerConfigPaths , dc . GetConfigPath ())
devcontainerSubagentIDs = append ( devcontainerSubagentIDs , subAgentID )
2025-03-27 12:31:30 +02:00
// Add a log source and script for each devcontainer so we can
// track logs and timings for each devcontainer.
2026-01-30 17:19:19 +00:00
displayName := fmt . Sprintf ( "Dev Container (%s)" , dc . GetName ())
scriptsParams . LogSourceIDs = append ( scriptsParams . LogSourceIDs , uuid . New ())
scriptsParams . LogSourceDisplayNames = append ( scriptsParams . LogSourceDisplayNames , displayName )
scriptsParams . LogSourceIcons = append ( scriptsParams . LogSourceIcons , "/emojis/1f4e6.png" ) // Emoji package. Or perhaps /icon/container.svg?
scriptsParams . ScriptIDs = append ( scriptsParams . ScriptIDs , id ) // Re-use the devcontainer ID as the script ID for identification.
scriptsParams . ScriptDisplayNames = append ( scriptsParams . ScriptDisplayNames , displayName )
scriptsParams . ScriptLogPaths = append ( scriptsParams . ScriptLogPaths , "" )
2026-03-16 10:16:14 +02:00
scriptsParams . ScriptSources = append ( scriptsParams . ScriptSources , "" )
2026-01-30 17:19:19 +00:00
scriptsParams . ScriptCron = append ( scriptsParams . ScriptCron , "" )
scriptsParams . ScriptTimeout = append ( scriptsParams . ScriptTimeout , 0 )
scriptsParams . ScriptStartBlocksLogin = append ( scriptsParams . ScriptStartBlocksLogin , false )
2026-03-16 10:16:14 +02:00
scriptsParams . ScriptRunOnStart = append ( scriptsParams . ScriptRunOnStart , false )
2026-01-30 17:19:19 +00:00
scriptsParams . ScriptRunOnStop = append ( scriptsParams . ScriptRunOnStop , false )
2025-03-27 12:31:30 +02:00
}
_ , err = db . InsertWorkspaceAgentDevcontainers ( ctx , database . InsertWorkspaceAgentDevcontainersParams {
WorkspaceAgentID : agentID ,
CreatedAt : dbtime . Now (),
ID : devcontainerIDs ,
Name : devcontainerNames ,
WorkspaceFolder : devcontainerWorkspaceFolders ,
ConfigPath : devcontainerConfigPaths ,
2026-01-30 17:19:19 +00:00
SubagentID : devcontainerSubagentIDs ,
2025-03-27 12:31:30 +02:00
})
if err != nil {
return xerrors . Errorf ( "insert agent devcontainer: %w" , err )
}
}
2026-01-30 17:19:19 +00:00
if err := insertAgentScriptsAndLogSources ( ctx , db , agentID , scriptsParams ); err != nil {
return xerrors . Errorf ( "insert agent scripts and log sources: %w" , err )
2023-09-25 16:47:17 -05:00
}
2022-11-07 19:10:49 -06:00
for _ , app := range prAgent . Apps {
2026-01-30 17:19:19 +00:00
if err := insertAgentApp ( ctx , db , dbAgent . ID , app , appSlugs , snapshot ); err != nil {
return xerrors . Errorf ( "insert agent app: %w" , err )
2022-11-07 19:10:49 -06:00
}
}
}
2022-12-14 13:08:22 -06:00
arg := database . InsertWorkspaceResourceMetadataParams {
WorkspaceResourceID : resource . ID ,
Key : [] string {},
Value : [] string {},
Sensitive : [] bool {},
}
2022-11-07 19:10:49 -06:00
for _ , metadatum := range protoResource . Metadata {
2022-12-14 13:08:22 -06:00
if metadatum . IsNull {
continue
2022-11-07 19:10:49 -06:00
}
2022-12-14 13:08:22 -06:00
arg . Key = append ( arg . Key , metadatum . Key )
arg . Value = append ( arg . Value , metadatum . Value )
arg . Sensitive = append ( arg . Sensitive , metadatum . Sensitive )
}
_ , err = db . InsertWorkspaceResourceMetadata ( ctx , arg )
if err != nil {
return xerrors . Errorf ( "insert workspace resource metadata: %w" , err )
2022-11-07 19:10:49 -06:00
}
return nil
}
2025-09-02 09:38:43 +01:00
func WorkspaceSessionTokenName ( ownerID , workspaceID uuid . UUID ) string {
return fmt . Sprintf ( "%s_%s_session_token" , ownerID , workspaceID )
2023-05-17 23:29:22 -05:00
}
2023-08-30 14:48:35 +04:00
func ( s * server ) regenerateSessionToken ( ctx context . Context , user database . User , workspace database . Workspace ) ( string , error ) {
2025-09-02 09:38:43 +01:00
// NOTE(Cian): Once a workspace is claimed, there's no reason for the session token to be valid any longer.
// Not generating any session token at all for a system user may unintentionally break existing templates,
// which we want to avoid. If there's no session token for the workspace belonging to the prebuilds user,
// then there's nothing for us to worry about here.
// TODO(Cian): Update this to handle _all_ system users. At the time of writing, only one system user exists.
if err := deleteSessionTokenForUserAndWorkspace ( ctx , s . Database , database . PrebuildsSystemUserID , workspace . ID ); err != nil && ! errors . Is ( err , sql . ErrNoRows ) {
s . Logger . Error ( ctx , "failed to delete prebuilds session token" , slog . Error ( err ), slog . F ( "workspace_id" , workspace . ID ))
}
2023-05-17 23:29:22 -05:00
newkey , sessionToken , err := apikey . Generate ( apikey . CreateParams {
2024-01-22 11:42:55 -09:00
UserID : user . ID ,
LoginType : user . LoginType ,
2025-09-02 09:38:43 +01:00
TokenName : WorkspaceSessionTokenName ( workspace . OwnerID , workspace . ID ),
2024-09-18 21:23:42 +10:00
DefaultLifetime : s . DeploymentValues . Sessions . DefaultTokenDuration . Value (),
2024-04-10 10:34:49 -05:00
LifetimeSeconds : int64 ( s . DeploymentValues . Sessions . MaximumTokenDuration . Value (). Seconds ()),
2023-05-17 23:29:22 -05:00
})
if err != nil {
return "" , xerrors . Errorf ( "generate API key: %w" , err )
}
2023-08-30 14:48:35 +04:00
err = s . Database . InTx ( func ( tx database . Store ) error {
2023-05-17 23:29:22 -05:00
err := deleteSessionToken ( ctx , tx , workspace )
if err != nil {
return xerrors . Errorf ( "delete session token: %w" , err )
}
_ , err = tx . InsertAPIKey ( ctx , newkey )
if err != nil {
return xerrors . Errorf ( "insert API key: %w" , err )
}
return nil
}, nil )
if err != nil {
return "" , xerrors . Errorf ( "create API key: %w" , err )
}
return sessionToken , nil
}
func deleteSessionToken ( ctx context . Context , db database . Store , workspace database . Workspace ) error {
2025-09-02 09:38:43 +01:00
return deleteSessionTokenForUserAndWorkspace ( ctx , db , workspace . OwnerID , workspace . ID )
}
func deleteSessionTokenForUserAndWorkspace ( ctx context . Context , db database . Store , userID , workspaceID uuid . UUID ) error {
2023-05-17 23:29:22 -05:00
err := db . InTx ( func ( tx database . Store ) error {
key , err := tx . GetAPIKeyByName ( ctx , database . GetAPIKeyByNameParams {
2025-09-02 09:38:43 +01:00
UserID : userID ,
TokenName : WorkspaceSessionTokenName ( userID , workspaceID ),
2023-05-17 23:29:22 -05:00
})
if err == nil {
err = tx . DeleteAPIKeyByID ( ctx , key . ID )
}
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
return xerrors . Errorf ( "get api key by name: %w" , err )
}
return nil
}, nil )
if err != nil {
return xerrors . Errorf ( "in tx: %w" , err )
}
return nil
}
2026-03-06 10:51:27 -06:00
func shouldRefreshOIDCToken ( link database . UserLink ) ( bool , time . Time ) {
2026-03-03 12:13:00 -06:00
if link . OAuthRefreshToken == "" {
// We cannot refresh even if we wanted to
2026-03-06 10:51:27 -06:00
return false , link . OAuthExpiry
2026-03-03 12:13:00 -06:00
}
if link . OAuthExpiry . IsZero () {
// 0 expire means the token never expires, so we shouldn't refresh
2026-03-06 10:51:27 -06:00
return false , link . OAuthExpiry
2026-03-03 12:13:00 -06:00
}
// This handles an edge case where the token is about to expire. A workspace
// build takes a non-trivial amount of time. If the token is to expire during the
// build, then the build risks failure. To mitigate this, refresh the token
// prematurely.
//
// If an OIDC provider issues short-lived tokens less than our defined period,
// the token will always be refreshed on every workspace build.
2026-03-06 06:29:54 -06:00
//
2026-03-06 10:51:27 -06:00
// By setting the expiration backwards, we are effectively shortening the
// time a token can be alive for by 10 minutes.
// Note: This is how it is done in the oauth2 package's own token refreshing logic.
expiresAt := link . OAuthExpiry . Add ( - time . Minute * 10 )
2026-03-03 12:13:00 -06:00
// Return if the token is assumed to be expired.
2026-03-06 10:51:27 -06:00
return expiresAt . Before ( dbtime . Now ()), expiresAt
2026-03-03 12:13:00 -06:00
}
2026-03-06 10:51:27 -06:00
// ObtainOIDCAccessToken returns a valid OpenID Connect access token
2023-03-17 15:25:08 -05:00
// for the user if it's able to obtain one, otherwise it returns an empty string.
2026-03-06 10:51:27 -06:00
func ObtainOIDCAccessToken ( ctx context . Context , logger slog . Logger , db database . Store , oidcConfig promoauth . OAuth2Config , userID uuid . UUID ) ( string , error ) {
2023-03-17 15:25:08 -05:00
link , err := db . GetUserLinkByUserIDLoginType ( ctx , database . GetUserLinkByUserIDLoginTypeParams {
UserID : userID ,
LoginType : database . LoginTypeOIDC ,
})
if errors . Is ( err , sql . ErrNoRows ) {
2024-10-30 19:16:59 +00:00
return "" , nil
2023-03-17 15:25:08 -05:00
}
if err != nil {
return "" , xerrors . Errorf ( "get owner oidc link: %w" , err )
}
2026-03-06 10:51:27 -06:00
if shouldRefresh , expiresAt := shouldRefreshOIDCToken ( link ); shouldRefresh {
2023-03-17 15:25:08 -05:00
token , err := oidcConfig . TokenSource ( ctx , & oauth2 . Token {
AccessToken : link . OAuthAccessToken ,
RefreshToken : link . OAuthRefreshToken ,
2026-03-06 10:51:27 -06:00
// Use the expiresAt returned by shouldRefreshOIDCToken.
// It will force a refresh with an expired time.
Expiry : expiresAt ,
2023-03-17 15:25:08 -05:00
}). Token ()
if err != nil {
// If OIDC fails to refresh, we return an empty string and don't fail.
// There isn't a way to hard-opt in to OIDC from a template, so we don't
// want to fail builds if users haven't authenticated for a while or something.
return "" , nil
}
link . OAuthAccessToken = token . AccessToken
link . OAuthRefreshToken = token . RefreshToken
link . OAuthExpiry = token . Expiry
link , err = db . UpdateUserLink ( ctx , database . UpdateUserLinkParams {
2023-10-03 09:23:45 +01:00
UserID : userID ,
LoginType : database . LoginTypeOIDC ,
OAuthAccessToken : link . OAuthAccessToken ,
OAuthAccessTokenKeyID : sql . NullString {}, // set by dbcrypt if required
OAuthRefreshToken : link . OAuthRefreshToken ,
OAuthRefreshTokenKeyID : sql . NullString {}, // set by dbcrypt if required
OAuthExpiry : link . OAuthExpiry ,
2024-11-14 10:05:44 -06:00
Claims : link . Claims ,
2023-03-17 15:25:08 -05:00
})
if err != nil {
return "" , xerrors . Errorf ( "update user link: %w" , err )
}
2026-03-03 12:13:00 -06:00
logger . Info ( ctx , "refreshed expired OIDC token for user during workspace build" , slog . F ( "user_id" , userID ))
2023-03-17 15:25:08 -05:00
}
return link . OAuthAccessToken , nil
}
2022-11-07 19:10:49 -06:00
func convertLogLevel ( logLevel sdkproto . LogLevel ) ( database . LogLevel , error ) {
switch logLevel {
case sdkproto . LogLevel_TRACE :
return database . LogLevelTrace , nil
case sdkproto . LogLevel_DEBUG :
return database . LogLevelDebug , nil
case sdkproto . LogLevel_INFO :
return database . LogLevelInfo , nil
case sdkproto . LogLevel_WARN :
return database . LogLevelWarn , nil
case sdkproto . LogLevel_ERROR :
return database . LogLevelError , nil
default :
return database . LogLevel ( "" ), xerrors . Errorf ( "unknown log level: %d" , logLevel )
}
}
func convertLogSource ( logSource proto . LogSource ) ( database . LogSource , error ) {
switch logSource {
case proto . LogSource_PROVISIONER_DAEMON :
return database . LogSourceProvisionerDaemon , nil
case proto . LogSource_PROVISIONER :
return database . LogSourceProvisioner , nil
default :
return database . LogSource ( "" ), xerrors . Errorf ( "unknown log source: %d" , logSource )
}
}
2023-01-17 11:22:11 +01:00
func convertRichParameterValues ( workspaceBuildParameters [] database . WorkspaceBuildParameter ) [] * sdkproto . RichParameterValue {
protoParameters := make ([] * sdkproto . RichParameterValue , len ( workspaceBuildParameters ))
for i , buildParameter := range workspaceBuildParameters {
protoParameters [ i ] = & sdkproto . RichParameterValue {
Name : buildParameter . Name ,
Value : buildParameter . Value ,
}
}
return protoParameters
}
2023-02-15 18:24:15 +01:00
func convertVariableValues ( variableValues [] codersdk . VariableValue ) [] * sdkproto . VariableValue {
protoVariableValues := make ([] * sdkproto . VariableValue , len ( variableValues ))
for i , variableValue := range variableValues {
protoVariableValues [ i ] = & sdkproto . VariableValue {
2023-02-17 09:07:45 +01:00
Name : variableValue . Name ,
Value : variableValue . Value ,
Sensitive : true , // Without the template variable schema we have to assume that every variable may be sensitive.
2023-02-15 18:24:15 +01:00
}
}
return protoVariableValues
}
2022-11-07 19:10:49 -06:00
func convertWorkspaceTransition ( transition database . WorkspaceTransition ) ( sdkproto . WorkspaceTransition , error ) {
switch transition {
case database . WorkspaceTransitionStart :
return sdkproto . WorkspaceTransition_START , nil
case database . WorkspaceTransitionStop :
return sdkproto . WorkspaceTransition_STOP , nil
case database . WorkspaceTransitionDelete :
return sdkproto . WorkspaceTransition_DESTROY , nil
default :
return 0 , xerrors . Errorf ( "unrecognized transition: %q" , transition )
}
}
2022-11-22 13:22:56 -05:00
func auditActionFromTransition ( transition database . WorkspaceTransition ) database . AuditAction {
switch transition {
case database . WorkspaceTransitionStart :
return database . AuditActionStart
case database . WorkspaceTransitionStop :
return database . AuditActionStop
case database . WorkspaceTransitionDelete :
return database . AuditActionDelete
default :
return database . AuditActionWrite
}
}
2023-01-17 11:22:11 +01:00
type TemplateVersionImportJob struct {
2025-11-12 12:46:39 -06:00
// TemplateID is not guaranteed to be set. Template versions can be created
// without being associated with a template. Resulting in a template id of
// `uuid.Nil`
TemplateID uuid . NullUUID `json:"template_id"`
2023-02-15 18:24:15 +01:00
TemplateVersionID uuid . UUID `json:"template_version_id"`
UserVariableValues [] codersdk . VariableValue `json:"user_variable_values"`
2023-01-17 11:22:11 +01:00
}
2022-11-07 19:10:49 -06:00
// WorkspaceProvisionJob is the payload for the "workspace_provision" job type.
type WorkspaceProvisionJob struct {
2025-05-12 16:19:03 +02:00
WorkspaceBuildID uuid . UUID `json:"workspace_build_id"`
DryRun bool `json:"dry_run"`
LogLevel string `json:"log_level,omitempty"`
PrebuiltWorkspaceBuildStage sdkproto . PrebuiltWorkspaceBuildStage `json:"prebuilt_workspace_stage,omitempty"`
2022-11-07 19:10:49 -06:00
}
// TemplateVersionDryRunJob is the payload for the "template_version_dry_run" job type.
type TemplateVersionDryRunJob struct {
2023-01-23 15:01:22 +01:00
TemplateVersionID uuid . UUID `json:"template_version_id"`
WorkspaceName string `json:"workspace_name"`
RichParameterValues [] database . WorkspaceBuildParameter `json:"rich_parameter_values"`
2022-11-07 19:10:49 -06:00
}
2023-02-15 18:24:15 +01:00
func asVariableValues ( templateVariables [] database . TemplateVersionVariable ) [] * sdkproto . VariableValue {
var apiVariableValues [] * sdkproto . VariableValue
for _ , v := range templateVariables {
2023-02-18 18:32:09 -06:00
value := v . Value
2023-02-15 18:24:15 +01:00
if value == "" && v . DefaultValue != "" {
value = v . DefaultValue
}
if value != "" || v . Required {
apiVariableValues = append ( apiVariableValues , & sdkproto . VariableValue {
Name : v . Name ,
Value : v . Value ,
Sensitive : v . Sensitive ,
})
}
}
return apiVariableValues
}
func redactTemplateVariable ( templateVariable * sdkproto . TemplateVariable ) * sdkproto . TemplateVariable {
if templateVariable == nil {
return nil
}
maybeRedacted := & sdkproto . TemplateVariable {
Name : templateVariable . Name ,
Description : templateVariable . Description ,
Type : templateVariable . Type ,
DefaultValue : templateVariable . DefaultValue ,
Required : templateVariable . Required ,
Sensitive : templateVariable . Sensitive ,
}
if maybeRedacted . Sensitive {
maybeRedacted . DefaultValue = "*redacted*"
}
return maybeRedacted
}
2023-08-30 14:53:42 -05:00
func convertDisplayApps ( apps * sdkproto . DisplayApps ) [] database . DisplayApp {
// This shouldn't happen but let's avoid panicking. It also makes
// writing tests a bit easier.
if apps == nil {
return nil
}
dapps := make ([] database . DisplayApp , 0 , 5 )
if apps . Vscode {
dapps = append ( dapps , database . DisplayAppVscode )
}
if apps . VscodeInsiders {
dapps = append ( dapps , database . DisplayAppVscodeInsiders )
}
if apps . SshHelper {
dapps = append ( dapps , database . DisplayAppSSHHelper )
}
if apps . PortForwardingHelper {
dapps = append ( dapps , database . DisplayAppPortForwardingHelper )
}
if apps . WebTerminal {
dapps = append ( dapps , database . DisplayAppWebTerminal )
}
return dapps
}
2026-01-30 17:19:19 +00:00
// insertDevcontainerSubagent creates a workspace agent for a devcontainer's
// subagent if one is defined. It returns the subagent ID (zero UUID if no
// subagent is defined).
func insertDevcontainerSubagent (
ctx context . Context ,
db database . Store ,
dc * sdkproto . Devcontainer ,
parentAgent database . WorkspaceAgent ,
resourceID uuid . UUID ,
appSlugs map [ string ] struct {},
snapshot * telemetry . Snapshot ,
opts * insertWorkspaceResourceOptions ,
) ( uuid . UUID , error ) {
// If there are no attached resources, we don't need to pre-create the
// subagent. This preserves backwards compatibility where devcontainers
// without resources can have their agents recreated dynamically.
if len ( dc . GetApps ()) == 0 && len ( dc . GetScripts ()) == 0 && len ( dc . GetEnvs ()) == 0 {
return uuid . UUID {}, nil
}
subAgentID := uuid . New ()
if opts . useAgentIDsFromProto {
var err error
subAgentID , err = uuid . Parse ( dc . GetSubagentId ())
if err != nil {
return uuid . UUID {}, xerrors . Errorf ( "parse subagent id: %w" , err )
}
}
envJSON , err := encodeSubagentEnvs ( dc . GetEnvs ())
if err != nil {
return uuid . UUID {}, err
}
_ , err = db . InsertWorkspaceAgent ( ctx , database . InsertWorkspaceAgentParams {
ID : subAgentID ,
ParentID : uuid . NullUUID { Valid : true , UUID : parentAgent . ID },
CreatedAt : dbtime . Now (),
UpdatedAt : dbtime . Now (),
ResourceID : resourceID ,
Name : dc . GetName (),
AuthToken : uuid . New (),
2026-02-19 16:56:29 +00:00
AuthInstanceID : sql . NullString {},
2026-01-30 17:19:19 +00:00
Architecture : parentAgent . Architecture ,
EnvironmentVariables : envJSON ,
Directory : dc . GetWorkspaceFolder (),
InstanceMetadata : pqtype . NullRawMessage {},
ResourceMetadata : pqtype . NullRawMessage {},
OperatingSystem : parentAgent . OperatingSystem ,
ConnectionTimeoutSeconds : parentAgent . ConnectionTimeoutSeconds ,
TroubleshootingURL : parentAgent . TroubleshootingURL ,
MOTDFile : "" ,
DisplayApps : [] database . DisplayApp {},
DisplayOrder : 0 ,
APIKeyScope : parentAgent . APIKeyScope ,
})
if err != nil {
return uuid . UUID {}, xerrors . Errorf ( "insert subagent: %w" , err )
}
for _ , app := range dc . GetApps () {
if err := insertAgentApp ( ctx , db , subAgentID , app , appSlugs , snapshot ); err != nil {
return uuid . UUID {}, xerrors . Errorf ( "insert agent app: %w" , err )
}
}
if err := insertAgentScriptsAndLogSources ( ctx , db , subAgentID , agentScriptsFromProto ( dc . GetScripts ())); err != nil {
return uuid . UUID {}, xerrors . Errorf ( "insert agent scripts and log sources: %w" , err )
}
return subAgentID , nil
}
2026-03-18 15:43:28 +01:00
// MergeExtraEnvs applies extra environment variables to the given map,
// respecting the merge_strategy field on each env. When merge_strategy
// is empty or "replace", the value overwrites any existing entry.
// "append" and "prepend" join values with a ":" separator (PATH-style).
// "error" causes a failure if the key already exists.
func MergeExtraEnvs ( env map [ string ] string , extraEnvs [] * sdkproto . Env ) error {
for _ , e := range extraEnvs {
strategy := e . GetMergeStrategy ()
if strategy == "" {
strategy = "replace"
}
existing , exists := env [ e . GetName ()]
switch strategy {
case "error" :
if exists {
return xerrors . Errorf (
"duplicate env var %q: merge_strategy is %q but variable is already defined" ,
e . GetName (), strategy ,
)
}
env [ e . GetName ()] = e . GetValue ()
case "append" :
if exists && existing != "" {
env [ e . GetName ()] = existing + ":" + e . GetValue ()
} else {
env [ e . GetName ()] = e . GetValue ()
}
case "prepend" :
if exists && existing != "" {
env [ e . GetName ()] = e . GetValue () + ":" + existing
} else {
env [ e . GetName ()] = e . GetValue ()
}
default : // "replace"
env [ e . GetName ()] = e . GetValue ()
}
}
return nil
}
2026-01-30 17:19:19 +00:00
func encodeSubagentEnvs ( envs [] * sdkproto . Env ) ( pqtype . NullRawMessage , error ) {
if len ( envs ) == 0 {
return pqtype . NullRawMessage {}, nil
}
subAgentEnvs := make ( map [ string ] string , len ( envs ))
2026-03-18 15:43:28 +01:00
if err := MergeExtraEnvs ( subAgentEnvs , envs ); err != nil {
return pqtype . NullRawMessage {}, err
2026-01-30 17:19:19 +00:00
}
data , err := json . Marshal ( subAgentEnvs )
if err != nil {
return pqtype . NullRawMessage {}, xerrors . Errorf ( "marshal env: %w" , err )
}
return pqtype . NullRawMessage { Valid : true , RawMessage : data }, nil
}
// agentScriptsParams holds the parameters for inserting agent scripts and
// their associated log sources.
type agentScriptsParams struct {
LogSourceIDs [] uuid . UUID
LogSourceDisplayNames [] string
LogSourceIcons [] string
ScriptIDs [] uuid . UUID
ScriptDisplayNames [] string
ScriptLogPaths [] string
ScriptSources [] string
ScriptCron [] string
ScriptTimeout [] int32
ScriptStartBlocksLogin [] bool
ScriptRunOnStart [] bool
ScriptRunOnStop [] bool
}
// agentScriptsFromProto converts a slice of proto scripts into the
// agentScriptsParams struct needed for database insertion.
func agentScriptsFromProto ( scripts [] * sdkproto . Script ) agentScriptsParams {
params := agentScriptsParams {
LogSourceIDs : make ([] uuid . UUID , 0 , len ( scripts )),
LogSourceDisplayNames : make ([] string , 0 , len ( scripts )),
LogSourceIcons : make ([] string , 0 , len ( scripts )),
ScriptIDs : make ([] uuid . UUID , 0 , len ( scripts )),
ScriptDisplayNames : make ([] string , 0 , len ( scripts )),
ScriptLogPaths : make ([] string , 0 , len ( scripts )),
ScriptSources : make ([] string , 0 , len ( scripts )),
ScriptCron : make ([] string , 0 , len ( scripts )),
ScriptTimeout : make ([] int32 , 0 , len ( scripts )),
ScriptStartBlocksLogin : make ([] bool , 0 , len ( scripts )),
ScriptRunOnStart : make ([] bool , 0 , len ( scripts )),
ScriptRunOnStop : make ([] bool , 0 , len ( scripts )),
}
for _ , script := range scripts {
params . LogSourceIDs = append ( params . LogSourceIDs , uuid . New ())
params . LogSourceDisplayNames = append ( params . LogSourceDisplayNames , script . GetDisplayName ())
params . LogSourceIcons = append ( params . LogSourceIcons , script . GetIcon ())
params . ScriptIDs = append ( params . ScriptIDs , uuid . New ())
params . ScriptDisplayNames = append ( params . ScriptDisplayNames , script . GetDisplayName ())
params . ScriptLogPaths = append ( params . ScriptLogPaths , script . GetLogPath ())
params . ScriptSources = append ( params . ScriptSources , script . GetScript ())
params . ScriptCron = append ( params . ScriptCron , script . GetCron ())
params . ScriptTimeout = append ( params . ScriptTimeout , script . GetTimeoutSeconds ())
params . ScriptStartBlocksLogin = append ( params . ScriptStartBlocksLogin , script . GetStartBlocksLogin ())
params . ScriptRunOnStart = append ( params . ScriptRunOnStart , script . GetRunOnStart ())
params . ScriptRunOnStop = append ( params . ScriptRunOnStop , script . GetRunOnStop ())
}
return params
}
// insertAgentScriptsAndLogSources inserts log sources and scripts for an agent (or
// subagent). It expects the caller to have built the agentScriptsParams,
// allowing for additional entries to be appended before insertion (e.g. for
// devcontainers). Returns nil if there are no log sources to insert.
func insertAgentScriptsAndLogSources ( ctx context . Context , db database . Store , agentID uuid . UUID , params agentScriptsParams ) error {
if len ( params . LogSourceIDs ) == 0 {
return nil
}
_ , err := db . InsertWorkspaceAgentLogSources ( ctx , database . InsertWorkspaceAgentLogSourcesParams {
WorkspaceAgentID : agentID ,
ID : params . LogSourceIDs ,
CreatedAt : dbtime . Now (),
DisplayName : params . LogSourceDisplayNames ,
Icon : params . LogSourceIcons ,
})
if err != nil {
return xerrors . Errorf ( "insert log sources: %w" , err )
}
_ , err = db . InsertWorkspaceAgentScripts ( ctx , database . InsertWorkspaceAgentScriptsParams {
WorkspaceAgentID : agentID ,
LogSourceID : params . LogSourceIDs ,
ID : params . ScriptIDs ,
LogPath : params . ScriptLogPaths ,
CreatedAt : dbtime . Now (),
Script : params . ScriptSources ,
Cron : params . ScriptCron ,
TimeoutSeconds : params . ScriptTimeout ,
StartBlocksLogin : params . ScriptStartBlocksLogin ,
RunOnStart : params . ScriptRunOnStart ,
RunOnStop : params . ScriptRunOnStop ,
DisplayName : params . ScriptDisplayNames ,
})
if err != nil {
return xerrors . Errorf ( "insert scripts: %w" , err )
}
return nil
}
2026-06-11 15:02:41 -04:00
type workspaceAppRebindError struct {
slug string
appID uuid . UUID
agentID uuid . UUID
}
func ( e * workspaceAppRebindError ) Error () string {
return fmt . Sprintf ( "workspace app slug %q with ID %q is already bound to a workspace-owned agent and cannot be rebound to an agent in another workspace or to an agent without a workspace; refusing to rebind to agent ID %q" , e . slug , e . appID , e . agentID )
}
func ( s * server ) warnWorkspaceAppRebindRejected ( ctx context . Context , jobID uuid . UUID , err error ) {
slog . Helper ()
var rebindErr * workspaceAppRebindError
if ! errors . As ( err , & rebindErr ) {
return
}
s . Logger . Warn ( ctx , "workspace app rebind rejected by SQL guard" ,
slog . F ( "job_id" , jobID . String ()),
slog . F ( "app_id" , rebindErr . appID . String ()),
slog . F ( "agent_id" , rebindErr . agentID . String ()),
slog . F ( "app_slug" , rebindErr . slug ),
)
}
2026-01-30 17:19:19 +00:00
func insertAgentApp ( ctx context . Context , db database . Store , agentID uuid . UUID , app * sdkproto . App , appSlugs map [ string ] struct {}, snapshot * telemetry . Snapshot ) error {
// Similar logic is duplicated in terraform/resources.go.
slug := app . Slug
if slug == "" {
return xerrors . Errorf ( "app must have a slug or name set" )
}
// Unlike agent names, app slugs were never permitted to contain uppercase
// letters or underscores.
if ! provisioner . AppSlugRegex . MatchString ( slug ) {
return xerrors . Errorf ( "app slug %q does not match regex %q" , slug , provisioner . AppSlugRegex . String ())
}
if _ , exists := appSlugs [ slug ]; exists {
return xerrors . Errorf ( "duplicate app slug, must be unique per template: %q" , slug )
}
appSlugs [ slug ] = struct {}{}
health := database . WorkspaceAppHealthDisabled
2026-03-11 09:29:10 -07:00
healthcheck := app . GetHealthcheck ()
if healthcheck == nil {
healthcheck = & sdkproto . Healthcheck {}
2026-01-30 17:19:19 +00:00
}
2026-03-11 09:29:10 -07:00
if healthcheck . Url != "" {
2026-01-30 17:19:19 +00:00
health = database . WorkspaceAppHealthInitializing
}
sharingLevel := database . AppSharingLevelOwner
switch app . SharingLevel {
case sdkproto . AppSharingLevel_AUTHENTICATED :
sharingLevel = database . AppSharingLevelAuthenticated
case sdkproto . AppSharingLevel_PUBLIC :
sharingLevel = database . AppSharingLevelPublic
}
displayGroup := sql . NullString {
Valid : app . Group != "" ,
String : app . Group ,
}
openIn := database . WorkspaceAppOpenInSlimWindow
switch app . OpenIn {
case sdkproto . AppOpenIn_TAB :
openIn = database . WorkspaceAppOpenInTab
case sdkproto . AppOpenIn_SLIM_WINDOW :
openIn = database . WorkspaceAppOpenInSlimWindow
}
var appID string
if app . Id == "" || app . Id == uuid . Nil . String () {
appID = uuid . NewString ()
} else {
appID = app . Id
}
id , err := uuid . Parse ( appID )
if err != nil {
return xerrors . Errorf ( "parse app uuid: %w" , err )
}
// If workspace apps are "persistent", the ID will not be regenerated across workspace builds, so we have to upsert.
dbApp , err := db . UpsertWorkspaceApp ( ctx , database . UpsertWorkspaceAppParams {
ID : id ,
CreatedAt : dbtime . Now (),
AgentID : agentID ,
Slug : slug ,
DisplayName : app . DisplayName ,
Icon : app . Icon ,
Command : sql . NullString {
String : app . Command ,
Valid : app . Command != "" ,
},
Url : sql . NullString {
String : app . Url ,
Valid : app . Url != "" ,
},
External : app . External ,
Subdomain : app . Subdomain ,
SharingLevel : sharingLevel ,
2026-03-11 09:29:10 -07:00
HealthcheckUrl : healthcheck . Url ,
HealthcheckInterval : healthcheck . Interval ,
HealthcheckThreshold : healthcheck . Threshold ,
2026-01-30 17:19:19 +00:00
Health : health ,
// #nosec G115 - Order represents a display order value that's always small and fits in int32
DisplayOrder : int32 ( app . Order ),
DisplayGroup : displayGroup ,
Hidden : app . Hidden ,
OpenIn : openIn ,
Tooltip : app . Tooltip ,
})
if err != nil {
2026-06-11 15:02:41 -04:00
if errors . Is ( err , sql . ErrNoRows ) {
// The upsert's ON CONFLICT guard refused to rebind an app
// owned by a workspace to an agent outside that workspace,
// including agents from import or dry-run jobs that resolve
// to no workspace (SEC-91).
return & workspaceAppRebindError {
slug : slug ,
appID : id ,
agentID : agentID ,
}
}
2026-01-30 17:19:19 +00:00
return xerrors . Errorf ( "upsert app: %w" , err )
}
snapshot . WorkspaceApps = append ( snapshot . WorkspaceApps , telemetry . ConvertWorkspaceApp ( dbApp ))
return nil
}