The full end-to-end operation works

coder · kylecarbs · Feb 3, 2022 · Feb 1, 2022 · Feb 1, 2022 · Feb 1, 2022
commit e87f31db81b1f72d1550d561b68b1d1d5883be9b
diff --git a/.github/workflows/coder.yaml b/.github/workflows/coder.yaml
@@ -151,7 +151,6 @@ jobs:
       - run: go install gotest.tools/gotestsum@latest
 
       - uses: hashicorp/setup-terraform@v1
-        if: runner.os == 'Linux'
         with:
           terraform_version: 1.1.2
           terraform_wrapper: false

diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -28,6 +28,7 @@
     "coderdtest",
     "codersdk",
     "drpc",
+    "drpcconn",
     "drpcmux",
     "drpcserver",
     "goleak",
@@ -44,6 +45,8 @@
     "retrier",
     "sdkproto",
     "stretchr",
+    "tfexec",
+    "tfstate",
     "unconvert",
     "xerrors",
     "yamux"

diff --git a/coderd/cmd/root.go b/coderd/cmd/root.go
@@ -11,6 +11,7 @@ import (
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/sloghuman"
 	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/database"
 	"github.com/coder/coder/database/databasefake"
 )
 
@@ -24,6 +25,7 @@ func Root() *cobra.Command {
 			handler := coderd.New(&coderd.Options{
 				Logger:   slog.Make(sloghuman.Sink(os.Stderr)),
 				Database: databasefake.New(),
+				Pubsub:   database.NewPubsubInMemory(),
 			})
 
 			listener, err := net.Listen("tcp", address)

diff --git a/coderd/coderdtest/coderdtest.go b/coderd/coderdtest/coderdtest.go
@@ -78,13 +78,15 @@ func (s *Server) AddProvisionerd(t *testing.T) io.Closer {
 			ServeOptions: &provisionersdk.ServeOptions{
 				Listener: tfServer,
 			},
+			Logger: slogtest.Make(t, nil).Named("terraform-provisioner").Leveled(slog.LevelDebug),
 		})
 		require.NoError(t, err)
 	}()
 
 	closer := provisionerd.New(s.Client.ProvisionerDaemonClient, &provisionerd.Options{
-		Logger:       slogtest.Make(t, nil).Named("provisionerd").Leveled(slog.LevelInfo),
-		PollInterval: 50 * time.Millisecond,
+		Logger:         slogtest.Make(t, nil).Named("provisionerd").Leveled(slog.LevelInfo),
+		PollInterval:   50 * time.Millisecond,
+		UpdateInterval: 50 * time.Millisecond,
 		Provisioners: provisionerd.Provisioners{
 			string(database.ProvisionerTypeTerraform): proto.NewDRPCProvisionerClient(provisionersdk.Conn(tfClient)),
 		},
@@ -101,6 +103,7 @@ func (s *Server) AddProvisionerd(t *testing.T) io.Closer {
 func New(t *testing.T) Server {
 	// This can be hotswapped for a live database instance.
 	db := databasefake.New()
+	pubsub := database.NewPubsubInMemory()
 	if os.Getenv("DB") != "" {
 		connectionURL, close, err := postgres.Open()
 		require.NoError(t, err)
@@ -113,11 +116,15 @@ func New(t *testing.T) Server {
 		err = database.Migrate(sqlDB)
 		require.NoError(t, err)
 		db = database.New(sqlDB)
+
+		pubsub, err = database.NewPubsub(context.Background(), sqlDB, connectionURL)
+		require.NoError(t, err)
 	}
 
 	handler := coderd.New(&coderd.Options{
 		Logger:   slogtest.Make(t, nil),
 		Database: db,
+		Pubsub:   pubsub,
 	})
 	srv := httptest.NewServer(handler)
 	serverURL, err := url.Parse(srv.URL)

diff --git a/coderd/provisionerdaemons.go b/coderd/provisionerdaemons.go
@@ -33,6 +33,7 @@ func (api *api) provisionerDaemons(rw http.ResponseWriter, r *http.Request) {
 	daemons, err := api.Database.GetProvisionerDaemons(r.Context())
 	if errors.Is(err, sql.ErrNoRows) {
 		err = nil
+		daemons = []database.ProvisionerDaemon{}
 	}
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
@@ -76,9 +77,10 @@ func (api *api) provisionerDaemonsServe(rw http.ResponseWriter, r *http.Request)
 	}
 	mux := drpcmux.New()
 	err = proto.DRPCRegisterProvisionerDaemon(mux, &provisionerdServer{
-		ID:       daemon.ID,
-		Database: api.Database,
-		Pubsub:   api.Pubsub,
+		ID:           daemon.ID,
+		Database:     api.Database,
+		Pubsub:       api.Pubsub,
+		Provisioners: daemon.Provisioners,
 	})
 	if err != nil {
 		_ = conn.Close(websocket.StatusInternalError, fmt.Sprintf("drpc register provisioner daemon: %s", err))
@@ -103,9 +105,10 @@ type projectImportJob struct {
 
 // Implementation of the provisioner daemon protobuf server.
 type provisionerdServer struct {
-	ID       uuid.UUID
-	Database database.Store
-	Pubsub   database.Pubsub
+	ID           uuid.UUID
+	Provisioners []database.ProvisionerType
+	Database     database.Store
+	Pubsub       database.Pubsub
 }
 
 // AcquireJob queries the database to lock a job.
@@ -120,7 +123,7 @@ func (server *provisionerdServer) AcquireJob(ctx context.Context, _ *proto.Empty
 			UUID:  server.ID,
 			Valid: true,
 		},
-		Types: []database.ProvisionerType{database.ProvisionerTypeTerraform},
+		Types: server.Provisioners,
 	})
 	if errors.Is(err, sql.ErrNoRows) {
 		// The provisioner daemon assumes no jobs are available if

diff --git a/coderd/provisioners.go b/coderd/provisioners.go
@@ -19,6 +19,7 @@ const (
 	ProvisionerJobStatusPending   ProvisionerJobStatus = "pending"
 	ProvisionerJobStatusRunning   ProvisionerJobStatus = "running"
 	ProvisionerJobStatusSucceeded ProvisionerJobStatus = "succeeded"
+	ProvisionerJobStatusCancelled ProvisionerJobStatus = "canceled"
 	ProvisionerJobStatusFailed    ProvisionerJobStatus = "failed"
 )
 
@@ -41,6 +42,7 @@ func convertProvisionerJob(provisionerJob database.ProvisionerJob) ProvisionerJo
 		Error:       provisionerJob.Error.String,
 		Provisioner: provisionerJob.Provisioner,
 	}
+	// Applying values optional to the struct.
 	if provisionerJob.StartedAt.Valid {
 		job.StartedAt = &provisionerJob.StartedAt.Time
 	}
@@ -56,7 +58,7 @@ func convertProvisionerJob(provisionerJob database.ProvisionerJob) ProvisionerJo
 
 	switch {
 	case provisionerJob.CancelledAt.Valid:
-		job.Status = ProvisionerJobStatusFailed
+		job.Status = ProvisionerJobStatusCancelled
 	case !provisionerJob.StartedAt.Valid:
 		job.Status = ProvisionerJobStatusPending
 	case provisionerJob.CompletedAt.Valid:
@@ -68,5 +70,9 @@ func convertProvisionerJob(provisionerJob database.ProvisionerJob) ProvisionerJo
 		job.Status = ProvisionerJobStatusRunning
 	}
 
+	if job.Error != "" {
+		job.Status = ProvisionerJobStatusFailed
+	}
+
 	return job
 }
diff --git a/coderd/workspacehistory.go b/coderd/workspacehistory.go
@@ -27,6 +27,7 @@ type WorkspaceHistory struct {
 	ProjectHistoryID uuid.UUID                    `json:"project_history_id"`
 	BeforeID         uuid.UUID                    `json:"before_id"`
 	AfterID          uuid.UUID                    `json:"after_id"`
+	Name             string                       `json:"name"`
 	Transition       database.WorkspaceTransition `json:"transition"`
 	Initiator        string                       `json:"initiator"`
 	Provision        ProvisionerJob               `json:"provision"`
@@ -144,7 +145,7 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 		}
 
 		workspaceHistory, err = db.InsertWorkspaceHistory(r.Context(), database.InsertWorkspaceHistoryParams{
-			ID:               uuid.New(),
+			ID:               workspaceHistoryID,
 			CreatedAt:        database.Now(),
 			UpdatedAt:        database.Now(),
 			WorkspaceID:      workspace.ID,
@@ -242,6 +243,7 @@ func convertWorkspaceHistory(workspaceHistory database.WorkspaceHistory, provisi
 		ProjectHistoryID: workspaceHistory.ProjectHistoryID,
 		BeforeID:         workspaceHistory.BeforeID.UUID,
 		AfterID:          workspaceHistory.AfterID.UUID,
+		Name:             workspaceHistory.Name,
 		Transition:       workspaceHistory.Transition,
 		Initiator:        workspaceHistory.Initiator,
 		Provision:        convertProvisionerJob(provisionerJob),

diff --git a/coderd/workspacehistory_test.go b/coderd/workspacehistory_test.go
@@ -36,13 +36,18 @@ func TestWorkspaceHistory(t *testing.T) {
 	setupProjectHistory := func(t *testing.T, client *codersdk.Client, user coderd.CreateInitialUserRequest, project coderd.Project, files map[string]string) coderd.ProjectHistory {
 		var buffer bytes.Buffer
 		writer := tar.NewWriter(&buffer)
-		err := writer.WriteHeader(&tar.Header{
-			Name: "file",
-			Size: 1 << 10,
-		})
-		require.NoError(t, err)
-		_, err = writer.Write(make([]byte, 1<<10))
+		for path, content := range files {
+			err := writer.WriteHeader(&tar.Header{
+				Name: path,
+				Size: int64(len(content)),
+			})
+			require.NoError(t, err)
+			_, err = writer.Write([]byte(content))
+			require.NoError(t, err)
+		}
+		err := writer.Flush()
 		require.NoError(t, err)
+
 		projectHistory, err := client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
 			StorageMethod: database.ProjectStorageMethodInlineArchive,
 			StorageSource: buffer.Bytes(),
@@ -65,7 +70,9 @@ func TestWorkspaceHistory(t *testing.T) {
 		history, err := server.Client.ListWorkspaceHistory(context.Background(), "", workspace.Name)
 		require.NoError(t, err)
 		require.Len(t, history, 0)
-		projectVersion := setupProjectHistory(t, server.Client, user, project, map[string]string{})
+		projectVersion := setupProjectHistory(t, server.Client, user, project, map[string]string{
+			"example": "file",
+		})
 		_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
 			ProjectHistoryID: projectVersion.ID,
 			Transition:       database.WorkspaceTransitionCreate,
@@ -84,7 +91,9 @@ func TestWorkspaceHistory(t *testing.T) {
 		project, workspace := setupProjectAndWorkspace(t, server.Client, user)
 		_, err := server.Client.WorkspaceHistory(context.Background(), "", workspace.Name, "")
 		require.Error(t, err)
-		projectHistory := setupProjectHistory(t, server.Client, user, project, map[string]string{})
+		projectHistory := setupProjectHistory(t, server.Client, user, project, map[string]string{
+			"some": "file",
+		})
 		_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
 			ProjectHistoryID: projectHistory.ID,
 			Transition:       database.WorkspaceTransitionCreate,
@@ -100,12 +109,23 @@ func TestWorkspaceHistory(t *testing.T) {
 		_ = server.AddProvisionerd(t)
 		user := server.RandomInitialUser(t)
 		project, workspace := setupProjectAndWorkspace(t, server.Client, user)
-		projectHistory := setupProjectHistory(t, server.Client, user, project, map[string]string{})
+		projectHistory := setupProjectHistory(t, server.Client, user, project, map[string]string{
+			"main.tf": `resource "null_resource" "example" {}`,
+		})
 		_, err := server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
 			ProjectHistoryID: projectHistory.ID,
 			Transition:       database.WorkspaceTransitionCreate,
 		})
 		require.NoError(t, err)
+
+		var workspaceHistory coderd.WorkspaceHistory
+		require.Eventually(t, func() bool {
+			workspaceHistory, err = server.Client.WorkspaceHistory(context.Background(), "", workspace.Name, "")
+			require.NoError(t, err)
+			return workspaceHistory.Provision.Status.Completed()
+		}, 5*time.Second, 50*time.Millisecond)
+		require.Equal(t, "", workspaceHistory.Provision.Error)
+		require.Equal(t, coderd.ProvisionerJobStatusSucceeded, workspaceHistory.Provision.Status)
 	})
 
 	t.Run("CreateHistoryAlreadyInProgress", func(t *testing.T) {
@@ -114,7 +134,9 @@ func TestWorkspaceHistory(t *testing.T) {
 		_ = server.AddProvisionerd(t)
 		user := server.RandomInitialUser(t)
 		project, workspace := setupProjectAndWorkspace(t, server.Client, user)
-		projectHistory := setupProjectHistory(t, server.Client, user, project, map[string]string{})
+		projectHistory := setupProjectHistory(t, server.Client, user, project, map[string]string{
+			"some": "content",
+		})
 
 		_, err := server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
 			ProjectHistoryID: projectHistory.ID,

diff --git a/codersdk/projects_test.go b/codersdk/projects_test.go
@@ -71,7 +71,7 @@ func TestProjects(t *testing.T) {
 		require.NoError(t, err)
 	})
 
-	t.Run("UnauthenticatedHistorys", func(t *testing.T) {
+	t.Run("UnauthenticatedHistory", func(t *testing.T) {
 		t.Parallel()
 		server := coderdtest.New(t)
 		_, err := server.Client.ListProjectHistory(context.Background(), "org", "project")