Return jobs with WorkspaceHistory

coder · kylecarbs · Feb 3, 2022 · Feb 1, 2022 · Feb 1, 2022 · Feb 1, 2022
commit d062b5b6141ab5fbb45a0451b450a48f9e740a78
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -35,6 +35,7 @@
     "httpmw",
     "moby",
     "nhooyr",
+    "nolint",
     "nosec",
     "oneof",
     "protobuf",
@@ -43,6 +44,7 @@
     "retrier",
     "sdkproto",
     "stretchr",
+    "unconvert",
     "xerrors",
     "yamux"
   ]

diff --git a/coderd/provisionerdaemons.go b/coderd/provisionerdaemons.go
@@ -515,10 +515,6 @@ func (server *provisionerdServer) CompleteJob(ctx context.Context, completed *pr
 				ID:               workspaceHistory.ID,
 				UpdatedAt:        database.Now(),
 				ProvisionerState: jobType.WorkspaceProvision.State,
-				CompletedAt: sql.NullTime{
-					Time:  database.Now(),
-					Valid: true,
-				},
 			})
 			if err != nil {
 				return xerrors.Errorf("update workspace history: %w", err)

diff --git a/coderd/provisioners.go b/coderd/provisioners.go
@@ -0,0 +1,67 @@
+package coderd
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+
+	"github.com/coder/coder/database"
+)
+
+type ProvisionerJobStatus string
+
+const (
+	ProvisionerJobStatusPending   ProvisionerJobStatus = "pending"
+	ProvisionerJobStatusRunning   ProvisionerJobStatus = "running"
+	ProvisionerJobStatusSucceeded ProvisionerJobStatus = "succeeded"
+	ProvisionerJobStatusFailed    ProvisionerJobStatus = "failed"
+)
+
+type ProvisionerJob struct {
+	CreatedAt   time.Time                `json:"created_at"`
+	UpdatedAt   time.Time                `json:"updated_at"`
+	StartedAt   *time.Time               `json:"started_at,omitempty"`
+	CancelledAt *time.Time               `json:"canceled_at,omitempty"`
+	CompletedAt *time.Time               `json:"completed_at,omitempty"`
+	Status      ProvisionerJobStatus     `json:"status"`
+	Error       string                   `json:"error,omitempty"`
+	Provisioner database.ProvisionerType `json:"provisioner"`
+	WorkerID    *uuid.UUID               `json:"worker_id,omitempty"`
+}
+
+func convertProvisionerJob(provisionerJob database.ProvisionerJob) ProvisionerJob {
+	job := ProvisionerJob{
+		CreatedAt:   provisionerJob.CreatedAt,
+		UpdatedAt:   provisionerJob.UpdatedAt,
+		Error:       provisionerJob.Error.String,
+		Provisioner: provisionerJob.Provisioner,
+	}
+	if provisionerJob.StartedAt.Valid {
+		job.StartedAt = &provisionerJob.StartedAt.Time
+	}
+	if provisionerJob.CancelledAt.Valid {
+		job.CancelledAt = &provisionerJob.CancelledAt.Time
+	}
+	if provisionerJob.CompletedAt.Valid {
+		job.CompletedAt = &provisionerJob.CompletedAt.Time
+	}
+	if provisionerJob.WorkerID.Valid {
+		job.WorkerID = &provisionerJob.WorkerID.UUID
+	}
+
+	switch {
+	case provisionerJob.CancelledAt.Valid:
+		job.Status = ProvisionerJobStatusFailed
+	case !provisionerJob.StartedAt.Valid:
+		job.Status = ProvisionerJobStatusPending
+	case provisionerJob.CompletedAt.Valid:
+		job.Status = ProvisionerJobStatusSucceeded
+	case database.Now().Sub(provisionerJob.UpdatedAt) > 30*time.Second:
+		job.Status = ProvisionerJobStatusFailed
+		job.Error = "Worker failed to update job in time."
+	default:
+		job.Status = ProvisionerJobStatusRunning
+	}
+
+	return job
+}
diff --git a/coderd/workspacehistory.go b/coderd/workspacehistory.go
@@ -2,6 +2,7 @@ package coderd
 
 import (
 	"database/sql"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -22,13 +23,13 @@ type WorkspaceHistory struct {
 	ID               uuid.UUID                    `json:"id"`
 	CreatedAt        time.Time                    `json:"created_at"`
 	UpdatedAt        time.Time                    `json:"updated_at"`
-	CompletedAt      time.Time                    `json:"completed_at"`
 	WorkspaceID      uuid.UUID                    `json:"workspace_id"`
 	ProjectHistoryID uuid.UUID                    `json:"project_history_id"`
 	BeforeID         uuid.UUID                    `json:"before_id"`
 	AfterID          uuid.UUID                    `json:"after_id"`
 	Transition       database.WorkspaceTransition `json:"transition"`
 	Initiator        string                       `json:"initiator"`
+	Job              ProvisionerJob               `json:"job"`
 }
 
 // CreateWorkspaceHistoryRequest provides options to update the latest workspace history.
@@ -37,8 +38,6 @@ type CreateWorkspaceHistoryRequest struct {
 	Transition       database.WorkspaceTransition `json:"transition" validate:"oneof=create start stop delete,required"`
 }
 
-// Begins transitioning a workspace to new state. This queues a provision job to asynchronously
-// update the underlying infrastructure. Only one historical transition can occur at a time.
 func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Request) {
 	var createBuild CreateWorkspaceHistoryRequest
 	if !httpapi.Read(rw, r, &createBuild) {
@@ -63,16 +62,28 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 		})
 		return
 	}
+	project, err := api.Database.GetProjectByID(r.Context(), projectHistory.ProjectID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get project: %s", err),
+		})
+		return
+	}
 
 	// Store prior history ID if it exists to update it after we create new!
 	priorHistoryID := uuid.NullUUID{}
 	priorHistory, err := api.Database.GetWorkspaceHistoryByWorkspaceIDWithoutAfter(r.Context(), workspace.ID)
 	if err == nil {
-		if !priorHistory.CompletedAt.Valid {
-			httpapi.Write(rw, http.StatusConflict, httpapi.Response{
-				Message: "a workspace build is already active",
-			})
-			return
+		priorJob, err := api.Database.GetProvisionerJobByID(r.Context(), priorHistory.ProvisionJobID)
+		if err == nil {
+			convertedJob := convertProvisionerJob(priorJob)
+			if convertedJob.Status == ProvisionerJobStatusPending ||
+				convertedJob.Status == ProvisionerJobStatusRunning {
+				httpapi.Write(rw, http.StatusConflict, httpapi.Response{
+					Message: "a workspace build is already active",
+				})
+				return
+			}
 		}
 
 		priorHistoryID = uuid.NullUUID{
@@ -87,10 +98,34 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 		return
 	}
 
+	var provisionerJob database.ProvisionerJob
 	var workspaceHistory database.WorkspaceHistory
 	// 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.
 	err = api.Database.InTx(func(db database.Store) error {
+		// Generate the ID before-hand so the provisioner job is aware of it!
+		workspaceHistoryID := uuid.New()
+		input, err := json.Marshal(workspaceProvisionJob{
+			WorkspaceHistoryID: workspaceHistoryID,
+		})
+		if err != nil {
+			return xerrors.Errorf("marshal provision job: %w", err)
+		}
+
+		provisionerJob, err = db.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
+			ID:          uuid.New(),
+			CreatedAt:   database.Now(),
+			UpdatedAt:   database.Now(),
+			InitiatorID: user.ID,
+			Provisioner: project.Provisioner,
+			Type:        database.ProvisionerJobTypeWorkspaceProvision,
+			ProjectID:   project.ID,
+			Input:       input,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert provisioner job: %w", err)
+		}
+
 		workspaceHistory, err = db.InsertWorkspaceHistory(r.Context(), database.InsertWorkspaceHistoryParams{
 			ID:               uuid.New(),
 			CreatedAt:        database.Now(),
@@ -100,8 +135,7 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 			BeforeID:         priorHistoryID,
 			Initiator:        user.ID,
 			Transition:       createBuild.Transition,
-			// This should create a provision job once that gets implemented!
-			ProvisionJobID: uuid.New(),
+			ProvisionJobID:   provisionerJob.ID,
 		})
 		if err != nil {
 			return xerrors.Errorf("insert workspace history: %w", err)
@@ -132,7 +166,7 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 	}
 
 	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertWorkspaceHistory(workspaceHistory))
+	render.JSON(rw, r, convertWorkspaceHistory(workspaceHistory, provisionerJob))
 }
 
 // Returns all workspace history. This is not sorted. Use before/after to chronologically sort.
@@ -152,7 +186,14 @@ func (api *api) workspaceHistoryByUser(rw http.ResponseWriter, r *http.Request)
 
 	apiHistory := make([]WorkspaceHistory, 0, len(histories))
 	for _, history := range histories {
-		apiHistory = append(apiHistory, convertWorkspaceHistory(history))
+		job, err := api.Database.GetProvisionerJobByID(r.Context(), history.ProvisionJobID)
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("get provisioner job: %s", err),
+			})
+			return
+		}
+		apiHistory = append(apiHistory, convertWorkspaceHistory(history, job))
 	}
 
 	render.Status(r, http.StatusOK)
@@ -176,9 +217,33 @@ func (api *api) latestWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Req
 		})
 		return
 	}
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), history.ProvisionJobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
 
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertWorkspaceHistory(history))
+	render.JSON(rw, r, convertWorkspaceHistory(history, job))
+}
+
+// Converts the internal history representation to a public external-facing model.
+func convertWorkspaceHistory(workspaceHistory database.WorkspaceHistory, provisionerJob database.ProvisionerJob) WorkspaceHistory {
+	//nolint:unconvert
+	return WorkspaceHistory(WorkspaceHistory{
+		ID:               workspaceHistory.ID,
+		CreatedAt:        workspaceHistory.CreatedAt,
+		UpdatedAt:        workspaceHistory.UpdatedAt,
+		WorkspaceID:      workspaceHistory.WorkspaceID,
+		ProjectHistoryID: workspaceHistory.ProjectHistoryID,
+		BeforeID:         workspaceHistory.BeforeID.UUID,
+		AfterID:          workspaceHistory.AfterID.UUID,
+		Transition:       workspaceHistory.Transition,
+		Initiator:        workspaceHistory.Initiator,
+		Job:              convertProvisionerJob(provisionerJob),
+	})
 }
 
 func workspaceHistoryLogsChannel(workspaceHistoryID uuid.UUID) string {

diff --git a/coderd/workspaces.go b/coderd/workspaces.go
@@ -149,20 +149,3 @@ func (*api) workspaceByUser(rw http.ResponseWriter, r *http.Request) {
 func convertWorkspace(workspace database.Workspace) Workspace {
 	return Workspace(workspace)
 }
-
-// Converts the internal history representation to a public external-facing model.
-func convertWorkspaceHistory(workspaceHistory database.WorkspaceHistory) WorkspaceHistory {
-	//nolint:unconvert
-	return WorkspaceHistory(WorkspaceHistory{
-		ID:               workspaceHistory.ID,
-		CreatedAt:        workspaceHistory.CreatedAt,
-		UpdatedAt:        workspaceHistory.UpdatedAt,
-		CompletedAt:      workspaceHistory.CompletedAt.Time,
-		WorkspaceID:      workspaceHistory.WorkspaceID,
-		ProjectHistoryID: workspaceHistory.ProjectHistoryID,
-		BeforeID:         workspaceHistory.BeforeID.UUID,
-		AfterID:          workspaceHistory.AfterID.UUID,
-		Transition:       workspaceHistory.Transition,
-		Initiator:        workspaceHistory.Initiator,
-	})
-}
diff --git a/database/databasefake/databasefake.go b/database/databasefake/databasefake.go
@@ -764,7 +764,6 @@ func (q *fakeQuerier) UpdateWorkspaceHistoryByID(_ context.Context, arg database
 			continue
 		}
 		workspaceHistory.UpdatedAt = arg.UpdatedAt
-		workspaceHistory.CompletedAt = arg.CompletedAt
 		workspaceHistory.AfterID = arg.AfterID
 		workspaceHistory.ProvisionerState = arg.ProvisionerState
 		q.workspaceHistory[index] = workspaceHistory

diff --git a/database/dump.sql b/database/dump.sql
diff --git a/database/migrations/000003_workspaces.up.sql b/database/migrations/000003_workspaces.up.sql
@@ -20,7 +20,6 @@ CREATE TABLE workspace_history (
     id uuid NOT NULL UNIQUE,
     created_at timestamptz NOT NULL,
     updated_at timestamptz NOT NULL,
-    completed_at timestamptz,
     workspace_id uuid NOT NULL REFERENCES workspace (id) ON DELETE CASCADE,
     project_history_id uuid NOT NULL REFERENCES project_history (id) ON DELETE CASCADE,
     name varchar(64) NOT NULL,

diff --git a/database/models.go b/database/models.go
diff --git a/database/query.sql b/database/query.sql
@@ -619,8 +619,7 @@ UPDATE
   workspace_history
 SET
   updated_at = $2,
-  completed_at = $3,
-  after_id = $4,
-  provisioner_state = $5
+  after_id = $3,
+  provisioner_state = $4
 WHERE
   id = $1;