insert workspace modules on provisioner job completion

coder · hugodutka · Nov 16, 2024 · Nov 6, 2024 · Nov 6, 2024 · Nov 6, 2024
commit 82c8a3c9b3e99bb376a1d132cc29a92c1ddce4fc
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
@@ -3222,6 +3222,13 @@ func (q *querier) InsertWorkspaceBuildParameters(ctx context.Context, arg databa
 	return q.db.InsertWorkspaceBuildParameters(ctx, arg)
 }
 
+func (q *querier) InsertWorkspaceModule(ctx context.Context, arg database.InsertWorkspaceModuleParams) (database.WorkspaceModule, error) {
+	if err := q.authorizeContext(ctx, policy.ActionCreate, rbac.ResourceSystem); err != nil {
+		return database.WorkspaceModule{}, err
+	}
+	return q.db.InsertWorkspaceModule(ctx, arg)
+}
+
 func (q *querier) InsertWorkspaceProxy(ctx context.Context, arg database.InsertWorkspaceProxyParams) (database.WorkspaceProxy, error) {
 	return insert(q.log, q.auth, rbac.ResourceWorkspaceProxy, q.db.InsertWorkspaceProxy)(ctx, arg)
 }

diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
@@ -8233,6 +8233,15 @@ func (q *FakeQuerier) InsertWorkspaceBuildParameters(_ context.Context, arg data
 	return nil
 }
 
+func (q *FakeQuerier) InsertWorkspaceModule(ctx context.Context, arg database.InsertWorkspaceModuleParams) (database.WorkspaceModule, error) {
+	err := validateDatabaseType(arg)
+	if err != nil {
+		return database.WorkspaceModule{}, err
+	}
+
+	panic("not implemented")
+}
+
 func (q *FakeQuerier) InsertWorkspaceProxy(_ context.Context, arg database.InsertWorkspaceProxyParams) (database.WorkspaceProxy, error) {
 	q.mutex.Lock()
 	defer q.mutex.Unlock()

diff --git a/coderd/database/dbmetrics/querymetrics.go b/coderd/database/dbmetrics/querymetrics.go
diff --git a/coderd/database/dbmock/dbmock.go b/coderd/database/dbmock/dbmock.go
diff --git a/coderd/database/querier.go b/coderd/database/querier.go
diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/queries/workspacemodules.sql b/coderd/database/queries/workspacemodules.sql
@@ -0,0 +1,5 @@
+-- name: InsertWorkspaceModule :one
+INSERT INTO
+	workspace_modules (id, job_id, transition, source, version, key, created_at)
+VALUES
+	($1, $2, $3, $4, $5, $6, $7) RETURNING *;
diff --git a/coderd/provisionerdserver/provisionerdserver.go b/coderd/provisionerdserver/provisionerdserver.go
@@ -1267,6 +1267,24 @@ func (s *server) CompleteJob(ctx context.Context, completed *proto.CompletedJob)
 				}
 			}
 		}
+		for transition, modules := range map[database.WorkspaceTransition][]*sdkproto.Module{
+			database.WorkspaceTransitionStart: jobType.TemplateImport.StartModules,
+			database.WorkspaceTransitionStop:  jobType.TemplateImport.StopModules,
+		} {
+			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))
+
+				err = InsertWorkspaceModule(ctx, s.Database, jobID, transition, module)
+				if err != nil {
+					return nil, xerrors.Errorf("insert module: %w", err)
+				}
+			}
+		}
 
 		for _, richParameter := range jobType.TemplateImport.RichParameters {
 			s.Logger.Info(ctx, "inserting template import job parameter",
@@ -1472,6 +1490,12 @@ func (s *server) CompleteJob(ctx context.Context, completed *proto.CompletedJob)
 					return xerrors.Errorf("insert provisioner job: %w", err)
 				}
 			}
+			for _, module := range jobType.WorkspaceBuild.Modules {
+				err = InsertWorkspaceModule(ctx, db, job.ID, workspaceBuild.Transition, module)
+				if err != nil {
+					return xerrors.Errorf("insert provisioner job module: %w", err)
+				}
+			}
 
 			// On start, we want to ensure that workspace agents timeout statuses
 			// are propagated. This method is simple and does not protect against
@@ -1653,6 +1677,17 @@ func (s *server) CompleteJob(ctx context.Context, completed *proto.CompletedJob)
 				return nil, xerrors.Errorf("insert resource: %w", err)
 			}
 		}
+		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),
+			)
+
+			err = InsertWorkspaceModule(ctx, s.Database, jobID, database.WorkspaceTransitionStart, module)
+			if err != nil {
+				return nil, xerrors.Errorf("insert module: %w", err)
+			}
+		}
 
 		err = s.Database.UpdateProvisionerJobWithCompleteByID(ctx, database.UpdateProvisionerJobWithCompleteByIDParams{
 			ID:        jobID,
@@ -1734,6 +1769,22 @@ func (s *server) startTrace(ctx context.Context, name string, opts ...trace.Span
 	))...)
 }
 
+func InsertWorkspaceModule(ctx context.Context, db database.Store, jobID uuid.UUID, transition database.WorkspaceTransition, protoModule *sdkproto.Module) error {
+	_, 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)
+	}
+	return nil
+}
+
 func InsertWorkspaceResource(ctx context.Context, db database.Store, jobID uuid.UUID, transition database.WorkspaceTransition, protoResource *sdkproto.Resource, snapshot *telemetry.Snapshot) error {
 	resource, err := db.InsertWorkspaceResource(ctx, database.InsertWorkspaceResourceParams{
 		ID:         uuid.New(),

diff --git a/provisioner/terraform/modules.go b/provisioner/terraform/modules.go
@@ -0,0 +1,52 @@
+package terraform
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/xerrors"
+
+	"github.com/coder/coder/v2/provisionersdk/proto"
+)
+
+type module struct {
+	Source  string `json:"Source"`
+	Version string `json:"Version"`
+	Key     string `json:"Key"`
+}
+
+type modulesFile struct {
+	Modules []*module `json:"Modules"`
+}
+
+func getModulesFilePath(workdir string) string {
+	return filepath.Join(workdir, ".terraform", "modules", "modules.json")
+}
+
+func parseModulesFile(filePath string) ([]*proto.Module, error) {
+	modules := &modulesFile{}
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, xerrors.Errorf("read modules file: %w", err)
+	}
+	if err := json.Unmarshal(data, modules); err != nil {
+		return nil, xerrors.Errorf("unmarshal modules file: %w", err)
+	}
+	protoModules := make([]*proto.Module, len(modules.Modules))
+	for i, m := range modules.Modules {
+		protoModules[i] = &proto.Module{Source: m.Source, Version: m.Version, Key: m.Key}
+	}
+	return protoModules, nil
+}
+
+// getModules returns the modules from the modules file if it exists.
+// It returns nil if the file does not exist.
+// Modules become available after terraform init.
+func getModules(workdir string) ([]*proto.Module, error) {
+	filePath := getModulesFilePath(workdir)
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		return nil, nil
+	}
+	return parseModulesFile(filePath)
+}
diff --git a/provisioner/terraform/provision.go b/provisioner/terraform/provision.go
@@ -142,6 +142,11 @@ func (s *server) Plan(
 		return provisionersdk.PlanErrorf("initialize terraform: %s", err)
 	}
 
+	modules, err := getModules(sess.WorkDirectory)
+	if err != nil {
+		return provisionersdk.PlanErrorf("get modules: %s", err)
+	}
+
 	initTimings.ingest(createInitTimingsEvent(timingInitComplete))
 
 	s.logger.Debug(ctx, "ran initialization")
@@ -167,6 +172,7 @@ func (s *server) Plan(
 	// Prepend init timings since they occur prior to plan timings.
 	// Order is irrelevant; this is merely indicative.
 	resp.Timings = append(initTimings.aggregate(), resp.Timings...)
+	resp.Modules = modules
 	return resp
 }