coder · spikecurtis · May 23, 2023 · May 12, 2023 · May 16, 2023 · May 16, 2023
diff --git a/cli/templatedelete_test.go b/cli/templatedelete_test.go
@@ -51,15 +51,13 @@ func TestTemplateDelete(t *testing.T) {
 
 		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
 		user := coderdtest.CreateFirstUser(t, client)
-		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
-		_ = coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
-		templates := []codersdk.Template{
-			coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID),
-			coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID),
-			coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID),
-		}
+		templates := []codersdk.Template{}
 		templateNames := []string{}
-		for _, template := range templates {
+		for i := 0; i < 3; i++ {
+			version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
+			_ = coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
+			template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+			templates = append(templates, template)
 			templateNames = append(templateNames, template.Name)
 		}
 
@@ -78,15 +76,13 @@ func TestTemplateDelete(t *testing.T) {
 
 		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
 		user := coderdtest.CreateFirstUser(t, client)
-		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
-		_ = coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
-		templates := []codersdk.Template{
-			coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID),
-			coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID),
-			coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID),
-		}
+		templates := []codersdk.Template{}
 		templateNames := []string{}
-		for _, template := range templates {
+		for i := 0; i < 3; i++ {
+			version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
+			_ = coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
+			template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+			templates = append(templates, template)
 			templateNames = append(templateNames, template.Name)
 		}
 

diff --git a/coderd/apidoc/docs.go b/coderd/apidoc/docs.go
diff --git a/coderd/apidoc/swagger.json b/coderd/apidoc/swagger.json
diff --git a/coderd/autobuild/executor/lifecycle_executor.go b/coderd/autobuild/executor/lifecycle_executor.go
@@ -2,7 +2,7 @@ package executor
 
 import (
 	"context"
-	"encoding/json"
+	"database/sql"
 	"sync/atomic"
 	"time"
 
@@ -13,8 +13,8 @@ import (
 	"cdr.dev/slog"
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbauthz"
-	"github.com/coder/coder/coderd/provisionerdserver"
 	"github.com/coder/coder/coderd/schedule"
+	"github.com/coder/coder/coderd/wsbuilder"
 )
 
 // Executor automatically starts or stops workspaces.
@@ -168,20 +168,35 @@ func (e *Executor) runOnce(t time.Time) Stats {
 					)
 					return nil
 				}
-
-				log.Info(e.ctx, "scheduling workspace transition", slog.F("transition", validTransition))
-
-				stats.Transitions[ws.ID] = validTransition
-				if err := build(e.ctx, db, ws, validTransition, priorHistory, priorJob); err != nil {
+				builder := wsbuilder.New(ws, validTransition).
+					SetLastWorkspaceBuildInTx(&priorHistory).
+					SetLastWorkspaceBuildJobInTx(&priorJob)
+
+				switch validTransition {
+				case database.WorkspaceTransitionStart:
+					builder = builder.Reason(database.BuildReasonAutostart)
+				case database.WorkspaceTransitionStop:
+					builder = builder.Reason(database.BuildReasonAutostop)
+				default:
+					log.Error(e.ctx, "unsupported transition", slog.F("transition", validTransition))
+					return nil
+				}
+				if _, _, err := builder.Build(e.ctx, db, nil); err != nil {
 					log.Error(e.ctx, "unable to transition workspace",
 						slog.F("transition", validTransition),
 						slog.Error(err),
 					)
 					return nil
 				}
+				stats.Transitions[ws.ID] = validTransition
+
+				log.Info(e.ctx, "scheduling workspace transition", slog.F("transition", validTransition))
 
 				return nil
-			}, nil)
+
+				// Run with RepeatableRead isolation so that the build process sees the same data
+				// as our calculation that determines whether an autobuild is necessary.
+			}, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
 			if err != nil {
 				log.Error(e.ctx, "workspace scheduling failed", slog.Error(err))
 			}
@@ -248,92 +263,3 @@ func getNextTransition(
 		return "", time.Time{}, xerrors.Errorf("last transition not valid for autostart or autostop")
 	}
 }
-
-// TODO(cian): this function duplicates most of api.postWorkspaceBuilds. Refactor.
-// See: https://github.com/coder/coder/issues/1401
-func build(ctx context.Context, store database.Store, workspace database.Workspace, trans database.WorkspaceTransition, priorHistory database.WorkspaceBuild, priorJob database.ProvisionerJob) error {
-	template, err := store.GetTemplateByID(ctx, workspace.TemplateID)
-	if err != nil {
-		return xerrors.Errorf("get workspace template: %w", err)
-	}
-
-	priorBuildNumber := priorHistory.BuildNumber
-
-	// This must happen in a transaction to ensure history can be inserted, and
-	// the prior history can update it's "after" column to point at the new.
-	workspaceBuildID := uuid.New()
-	input, err := json.Marshal(provisionerdserver.WorkspaceProvisionJob{
-		WorkspaceBuildID: workspaceBuildID,
-	})
-	if err != nil {
-		return xerrors.Errorf("marshal provision job: %w", err)
-	}
-	provisionerJobID := uuid.New()
-	now := database.Now()
-
-	var buildReason database.BuildReason
-	switch trans {
-	case database.WorkspaceTransitionStart:
-		buildReason = database.BuildReasonAutostart
-	case database.WorkspaceTransitionStop:
-		buildReason = database.BuildReasonAutostop
-	default:
-		return xerrors.Errorf("Unsupported transition: %q", trans)
-	}
-
-	lastBuildParameters, err := store.GetWorkspaceBuildParameters(ctx, priorHistory.ID)
-	if err != nil {
-		return xerrors.Errorf("fetch prior workspace build parameters: %w", err)
-	}
-
-	return store.InTx(func(db database.Store) error {
-		newProvisionerJob, err := store.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:             provisionerJobID,
-			CreatedAt:      now,
-			UpdatedAt:      now,
-			InitiatorID:    workspace.OwnerID,
-			OrganizationID: template.OrganizationID,
-			Provisioner:    template.Provisioner,
-			Type:           database.ProvisionerJobTypeWorkspaceBuild,
-			StorageMethod:  priorJob.StorageMethod,
-			FileID:         priorJob.FileID,
-			Tags:           priorJob.Tags,
-			Input:          input,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert provisioner job: %w", err)
-		}
-		workspaceBuild, err := store.InsertWorkspaceBuild(ctx, database.InsertWorkspaceBuildParams{
-			ID:                workspaceBuildID,
-			CreatedAt:         now,
-			UpdatedAt:         now,
-			WorkspaceID:       workspace.ID,
-			TemplateVersionID: priorHistory.TemplateVersionID,
-			BuildNumber:       priorBuildNumber + 1,
-			ProvisionerState:  priorHistory.ProvisionerState,
-			InitiatorID:       workspace.OwnerID,
-			Transition:        trans,
-			JobID:             newProvisionerJob.ID,
-			Reason:            buildReason,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert workspace build: %w", err)
-		}
-
-		names := make([]string, 0, len(lastBuildParameters))
-		values := make([]string, 0, len(lastBuildParameters))
-		for _, param := range lastBuildParameters {
-			names = append(names, param.Name)
-			values = append(values, param.Value)
-		}
-		err = db.InsertWorkspaceBuildParameters(ctx, database.InsertWorkspaceBuildParametersParams{
-			WorkspaceBuildID: workspaceBuild.ID,
-			Name:             names,
-			Value:            values,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert workspace build parameters: %w", err)
-		}
-		return nil
-	}, nil)
-}
diff --git a/coderd/conversion/doc.go b/coderd/conversion/doc.go
@@ -0,0 +1,2 @@
+// Package conversion provides common conversion routines from database types to codersdk types
+package conversion
diff --git a/coderd/conversion/parameters.go b/coderd/conversion/parameters.go
@@ -0,0 +1,87 @@
+package conversion
+
+import (
+	"encoding/json"
+
+	"github.com/coder/coder/coderd/database"
+	"github.com/coder/coder/coderd/parameter"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/provisionersdk/proto"
+)
+
+func WorkspaceBuildParameters(params []database.WorkspaceBuildParameter) []codersdk.WorkspaceBuildParameter {
+	out := make([]codersdk.WorkspaceBuildParameter, len(params))
+	for i, p := range params {
+		out[i] = WorkspaceBuildParameter(p)
+	}
+	return out
+}
+
+func WorkspaceBuildParameter(p database.WorkspaceBuildParameter) codersdk.WorkspaceBuildParameter {
+	return codersdk.WorkspaceBuildParameter{
+		Name:  p.Name,
+		Value: p.Value,
+	}
+}
+
+func TemplateVersionParameter(param database.TemplateVersionParameter) (codersdk.TemplateVersionParameter, error) {
+	var protoOptions []*proto.RichParameterOption
+	err := json.Unmarshal(param.Options, &protoOptions)
+	if err != nil {
+		return codersdk.TemplateVersionParameter{}, err
+	}
+	options := make([]codersdk.TemplateVersionParameterOption, 0)
+	for _, option := range protoOptions {
+		options = append(options, codersdk.TemplateVersionParameterOption{
+			Name:        option.Name,
+			Description: option.Description,
+			Value:       option.Value,
+			Icon:        option.Icon,
+		})
+	}
+
+	descriptionPlaintext, err := parameter.Plaintext(param.Description)
+	if err != nil {
+		return codersdk.TemplateVersionParameter{}, err
+	}
+	return codersdk.TemplateVersionParameter{
+		Name:                 param.Name,
+		DisplayName:          param.DisplayName,
+		Description:          param.Description,
+		DescriptionPlaintext: descriptionPlaintext,
+		Type:                 param.Type,
+		Mutable:              param.Mutable,
+		DefaultValue:         param.DefaultValue,
+		Icon:                 param.Icon,
+		Options:              options,
+		ValidationRegex:      param.ValidationRegex,
+		ValidationMin:        param.ValidationMin,
+		ValidationMax:        param.ValidationMax,
+		ValidationError:      param.ValidationError,
+		ValidationMonotonic:  codersdk.ValidationMonotonicOrder(param.ValidationMonotonic),
+		Required:             param.Required,
+		LegacyVariableName:   param.LegacyVariableName,
+	}, nil
+}
+
+func Parameters(params []database.ParameterValue) []codersdk.Parameter {
+	out := make([]codersdk.Parameter, len(params))
+	for i, p := range params {
+		out[i] = Parameter(p)
+	}
+	return out
+}
+
+func Parameter(parameterValue database.ParameterValue) codersdk.Parameter {
+	return codersdk.Parameter{
+		ID:                parameterValue.ID,
+		CreatedAt:         parameterValue.CreatedAt,
+		UpdatedAt:         parameterValue.UpdatedAt,
+		Scope:             codersdk.ParameterScope(parameterValue.Scope),
+		ScopeID:           parameterValue.ScopeID,
+		Name:              parameterValue.Name,
+		SourceScheme:      codersdk.ParameterSourceScheme(parameterValue.SourceScheme),
+		DestinationScheme: codersdk.ParameterDestinationScheme(parameterValue.DestinationScheme),
+		SourceValue:       parameterValue.SourceValue,
+	}
+}
diff --git a/coderd/conversion/provisionerjob.go b/coderd/conversion/provisionerjob.go
@@ -0,0 +1,33 @@
+package conversion
+
+import (
+	"time"
+
+	"github.com/coder/coder/coderd/database"
+	"github.com/coder/coder/codersdk"
+)
+
+func ProvisionerJobStatus(provisionerJob database.ProvisionerJob) codersdk.ProvisionerJobStatus {
+	switch {
+	case provisionerJob.CanceledAt.Valid:
+		if !provisionerJob.CompletedAt.Valid {
+			return codersdk.ProvisionerJobCanceling
+		}
+		if provisionerJob.Error.String == "" {
+			return codersdk.ProvisionerJobCanceled
+		}
+		return codersdk.ProvisionerJobFailed
+	case !provisionerJob.StartedAt.Valid:
+		return codersdk.ProvisionerJobPending
+	case provisionerJob.CompletedAt.Valid:
+		if provisionerJob.Error.String == "" {
+			return codersdk.ProvisionerJobSucceeded
+		}
+		return codersdk.ProvisionerJobFailed
+	case database.Now().Sub(provisionerJob.UpdatedAt) > 30*time.Second:
+		provisionerJob.Error.String = "Worker failed to update job in time."
+		return codersdk.ProvisionerJobFailed
+	default:
+		return codersdk.ProvisionerJobRunning
+	}
+}
diff --git a/coderd/httpapi/httpapi.go b/coderd/httpapi/httpapi.go
@@ -96,12 +96,12 @@ func Is404Error(err error) bool {
 // Convenience error functions don't take contexts since their responses are
 // static, it doesn't make much sense to trace them.
 
+var ResourceNotFoundResponse = codersdk.Response{Message: "Resource not found or you do not have access to this resource"}
+
 // ResourceNotFound is intentionally vague. All 404 responses should be identical
 // to prevent leaking existence of resources.
 func ResourceNotFound(rw http.ResponseWriter) {
-	Write(context.Background(), rw, http.StatusNotFound, codersdk.Response{
-		Message: "Resource not found or you do not have access to this resource",
-	})
+	Write(context.Background(), rw, http.StatusNotFound, ResourceNotFoundResponse)
 }
 
 func Forbidden(rw http.ResponseWriter) {

diff --git a/coderd/parameters.go b/coderd/parameters.go
@@ -206,6 +206,7 @@ func convertParameterValue(parameterValue database.ParameterValue) codersdk.Para
 		Name:              parameterValue.Name,
 		SourceScheme:      codersdk.ParameterSourceScheme(parameterValue.SourceScheme),
 		DestinationScheme: codersdk.ParameterDestinationScheme(parameterValue.DestinationScheme),
+		SourceValue:       parameterValue.SourceValue,
 	}
 }
 

diff --git a/coderd/prometheusmetrics/prometheusmetrics.go b/coderd/prometheusmetrics/prometheusmetrics.go
@@ -16,7 +16,7 @@ import (
 
 	"cdr.dev/slog"
 
-	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/conversion"
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbauthz"
 	"github.com/coder/coder/tailnet"
@@ -124,7 +124,7 @@ func Workspaces(ctx context.Context, registerer prometheus.Registerer, db databa
 
 			gauge.Reset()
 			for _, job := range jobs {
-				status := coderd.ConvertProvisionerJobStatus(job)
+				status := conversion.ProvisionerJobStatus(job)
 				gauge.WithLabelValues(string(status)).Add(1)
 			}
 		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		// Package conversion provides common conversion routines from database types to codersdk types
		package conversion
spikecurtis marked this conversation as resolved. Show resolved Hide resolved