Nov 16, 2024 · Nov 6, 2024 · Nov 6, 2024 · Nov 6, 2024 · Nov 7, 2024 · Nov 7, 2024
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
 return fetch(q.log, q.auth, q.db.GetWorkspaceByWorkspaceAppID)(ctx, workspaceAppID)
 }

 func (q *querier) GetWorkspaceModulesByJobID(ctx context.Context, jobID uuid.UUID) ([]database.WorkspaceModule, error) {
 if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceSystem); err != nil {
 return nil, err
 }
 return q.db.GetWorkspaceModulesByJobID(ctx, jobID)
 }

 func (q *querier) GetWorkspaceModulesCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceModule, error) {
 if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceSystem); err != nil {
 return nil, err
 }
 return q.db.GetWorkspaceModulesCreatedAfter(ctx, createdAt)
 }

 func (q *querier) GetWorkspaceProxies(ctx context.Context) ([]database.WorkspaceProxy, error) {
 return fetchWithPostFilter(q.auth, policy.ActionRead, func(ctx context.Context, _ interface{}) ([]database.WorkspaceProxy, error) {
 return q.db.GetWorkspaceProxies(ctx)
 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/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
 }
 check.Args(build.ID).Asserts(rbac.ResourceSystem, policy.ActionRead).Returns(rows)
 }))
 s.Run("InsertWorkspaceModule", s.Subtest(func(db database.Store, check *expects) {
 j := dbgen.ProvisionerJob(s.T(), db, nil, database.ProvisionerJob{
 Type: database.ProvisionerJobTypeWorkspaceBuild,
 })
 check.Args(database.InsertWorkspaceModuleParams{
 JobID:      j.ID,
 Transition: database.WorkspaceTransitionStart,
 }).Asserts(rbac.ResourceSystem, policy.ActionCreate)
 }))
 s.Run("GetWorkspaceModulesByJobID", s.Subtest(func(db database.Store, check *expects) {
 check.Args(uuid.New()).Asserts(rbac.ResourceSystem, policy.ActionRead)
 }))
 s.Run("GetWorkspaceModulesCreatedAfter", s.Subtest(func(db database.Store, check *expects) {
 check.Args(dbtime.Now()).Asserts(rbac.ResourceSystem, policy.ActionRead)
 }))
 }

 func (s *MethodTestSuite) TestNotifications() {
diff --git a/coderd/database/dbgen/dbgen.go b/coderd/database/dbgen/dbgen.go
 Valid:  takeFirst(orig.InstanceType.Valid, false),
 },
 DailyCost: takeFirst(orig.DailyCost, 0),
 ModulePath: sql.NullString{
 String: takeFirst(orig.ModulePath.String, ""),
 Valid:  takeFirst(orig.ModulePath.Valid, true),
 },
 })
 require.NoError(t, err, "insert resource")
 return resource
 }

 func WorkspaceModule(t testing.TB, db database.Store, orig database.WorkspaceModule) database.WorkspaceModule {
 module, err := db.InsertWorkspaceModule(genCtx, database.InsertWorkspaceModuleParams{
 ID:         takeFirst(orig.ID, uuid.New()),
 JobID:      takeFirst(orig.JobID, uuid.New()),
 Transition: takeFirst(orig.Transition, database.WorkspaceTransitionStart),
 Source:     takeFirst(orig.Source, "test-source"),
 Version:    takeFirst(orig.Version, "v1.0.0"),
 Key:        takeFirst(orig.Key, "test-key"),
 CreatedAt:  takeFirst(orig.CreatedAt, dbtime.Now()),
 })
 require.NoError(t, err, "insert workspace module")
 return module
 }

 func WorkspaceResourceMetadatums(t testing.TB, db database.Store, seed database.WorkspaceResourceMetadatum) []database.WorkspaceResourceMetadatum {
 meta, err := db.InsertWorkspaceResourceMetadata(genCtx, database.InsertWorkspaceResourceMetadataParams{
 WorkspaceResourceID: takeFirst(seed.WorkspaceResourceID, uuid.New()),
diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
 workspaceAgents:           make([]database.WorkspaceAgent, 0),
 provisionerJobLogs:        make([]database.ProvisionerJobLog, 0),
 workspaceResources:        make([]database.WorkspaceResource, 0),
 workspaceModules:          make([]database.WorkspaceModule, 0),
 workspaceResourceMetadata: make([]database.WorkspaceResourceMetadatum, 0),
 provisionerJobs:           make([]database.ProvisionerJob, 0),
 templateVersions:          make([]database.TemplateVersionTable, 0),
 workspaceBuildParameters        []database.WorkspaceBuildParameter
 workspaceResourceMetadata       []database.WorkspaceResourceMetadatum
 workspaceResources              []database.WorkspaceResource
 workspaceModules                []database.WorkspaceModule
 workspaces                      []database.WorkspaceTable
 workspaceProxies                []database.WorkspaceProxy
 customRoles                     []database.CustomRole
 return database.Workspace{}, sql.ErrNoRows
 }

 func (q *FakeQuerier) GetWorkspaceModulesByJobID(_ context.Context, jobID uuid.UUID) ([]database.WorkspaceModule, error) {
 q.mutex.RLock()
 defer q.mutex.RUnlock()

 modules := make([]database.WorkspaceModule, 0)
 for _, module := range q.workspaceModules {
 if module.JobID == jobID {
 modules = append(modules, module)
 }
 }
 return modules, nil
 }

 func (q *FakeQuerier) GetWorkspaceModulesCreatedAfter(_ context.Context, createdAt time.Time) ([]database.WorkspaceModule, error) {
 q.mutex.RLock()
 defer q.mutex.RUnlock()

 modules := make([]database.WorkspaceModule, 0)
 for _, module := range q.workspaceModules {
 if module.CreatedAt.After(createdAt) {
 modules = append(modules, module)
 }
 }
 return modules, nil
 }

 func (q *FakeQuerier) GetWorkspaceProxies(_ context.Context) ([]database.WorkspaceProxy, error) {
 q.mutex.RLock()
 defer q.mutex.RUnlock()
 return nil
 }

 func (q *FakeQuerier) InsertWorkspaceModule(_ context.Context, arg database.InsertWorkspaceModuleParams) (database.WorkspaceModule, error) {
 err := validateDatabaseType(arg)
 if err != nil {
 return database.WorkspaceModule{}, err
 }

 q.mutex.Lock()
 defer q.mutex.Unlock()

 workspaceModule := database.WorkspaceModule(arg)
 q.workspaceModules = append(q.workspaceModules, workspaceModule)
 return workspaceModule, nil
 }

 func (q *FakeQuerier) InsertWorkspaceProxy(_ context.Context, arg database.InsertWorkspaceProxyParams) (database.WorkspaceProxy, error) {
 q.mutex.Lock()
 defer q.mutex.Unlock()
 Hide:       arg.Hide,
 Icon:       arg.Icon,
 DailyCost:  arg.DailyCost,
 ModulePath: arg.ModulePath,
 }
 q.workspaceResources = append(q.workspaceResources, resource)
 return resource, nil
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/dump.sql b/coderd/database/dump.sql
diff --git a/coderd/database/foreign_key_constraint.go b/coderd/database/foreign_key_constraint.go
diff --git a/coderd/database/migrations/000276_workspace_modules.down.sql b/coderd/database/migrations/000276_workspace_modules.down.sql
 DROP TABLE workspace_modules;

 ALTER TABLE
    workspace_resources
 DROP COLUMN module_path;
diff --git a/coderd/database/migrations/000276_workspace_modules.up.sql b/coderd/database/migrations/000276_workspace_modules.up.sql
 ALTER TABLE
    workspace_resources
 ADD
    COLUMN module_path TEXT;

 CREATE TABLE workspace_modules (
    id uuid NOT NULL,
    job_id uuid NOT NULL REFERENCES provisioner_jobs (id) ON DELETE CASCADE,
    transition workspace_transition NOT NULL,
    source TEXT NOT NULL,
    version TEXT NOT NULL,
    key TEXT NOT NULL,
    created_at timestamp with time zone NOT NULL
 );

 CREATE INDEX workspace_modules_created_at_idx ON workspace_modules (created_at);
diff --git a/coderd/database/migrations/testdata/fixtures/000276_workspace_modules.up.sql b/coderd/database/migrations/testdata/fixtures/000276_workspace_modules.up.sql
 INSERT INTO
    public.workspace_modules (
        id,
        job_id,
        transition,
        source,
        version,
        key,
        created_at
    )
 VALUES
    (
        '5b1a722c-b8a0-40b0-a3a0-d8078fff9f6c',
        '424a58cb-61d6-4627-9907-613c396c4a38',
        'start',
        'test-source',
        'v1.0.0',
        'test-key',
        '2024-11-08 10:00:00+00'
    );
diff --git a/coderd/database/models.go b/coderd/database/models.go
diff --git a/coderd/database/querier.go b/coderd/database/querier.go
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2666,6 +2666,20 @@ func (q *querier) GetWorkspaceByWorkspaceAppID(ctx context.Context, workspaceApp
		return fetch(q.log, q.auth, q.db.GetWorkspaceByWorkspaceAppID)(ctx, workspaceAppID)
		}

		func (q *querier) GetWorkspaceModulesByJobID(ctx context.Context, jobID uuid.UUID) ([]database.WorkspaceModule, error) {
		if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceSystem); err != nil {
Copy link Member johnstcnNov 14, 2024• edited Loading Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. note:`rbac.ResourceSystem` is fine just for telemetry, but we'll probably want to create a separate RBAC resource in future for some of the other use-cases here. Can you create a follow-up issue for this and add a comment referencing it? hugodutka reacted with thumbs up emoji
		return nil, err
		}
		return q.db.GetWorkspaceModulesByJobID(ctx, jobID)
		}

		func (q *querier) GetWorkspaceModulesCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceModule, error) {
		if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceSystem); err != nil {
		return nil, err
		}
		return q.db.GetWorkspaceModulesCreatedAfter(ctx, createdAt)
		}

		func (q *querier) GetWorkspaceProxies(ctx context.Context) ([]database.WorkspaceProxy, error) {
		return fetchWithPostFilter(q.auth, policy.ActionRead, func(ctx context.Context, _ interface{}) ([]database.WorkspaceProxy, error) {
		return q.db.GetWorkspaceProxies(ctx)
Expand DownExpand Up		@@ -3222,6 +3236,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)
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2907,6 +2907,21 @@ func (s *MethodTestSuite) TestSystemFunctions() {
		}
		check.Args(build.ID).Asserts(rbac.ResourceSystem, policy.ActionRead).Returns(rows)
		}))
		s.Run("InsertWorkspaceModule", s.Subtest(func(db database.Store, check *expects) {
		j := dbgen.ProvisionerJob(s.T(), db, nil, database.ProvisionerJob{
		Type: database.ProvisionerJobTypeWorkspaceBuild,
		})
		check.Args(database.InsertWorkspaceModuleParams{
		JobID: j.ID,
		Transition: database.WorkspaceTransitionStart,
		}).Asserts(rbac.ResourceSystem, policy.ActionCreate)
		}))
		s.Run("GetWorkspaceModulesByJobID", s.Subtest(func(db database.Store, check *expects) {
		check.Args(uuid.New()).Asserts(rbac.ResourceSystem, policy.ActionRead)
		}))
		s.Run("GetWorkspaceModulesCreatedAfter", s.Subtest(func(db database.Store, check *expects) {
		check.Args(dbtime.Now()).Asserts(rbac.ResourceSystem, policy.ActionRead)
		}))
		}

		func (s *MethodTestSuite) TestNotifications() {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -657,11 +657,29 @@ func WorkspaceResource(t testing.TB, db database.Store, orig database.WorkspaceR
		Valid: takeFirst(orig.InstanceType.Valid, false),
		},
		DailyCost: takeFirst(orig.DailyCost, 0),
		ModulePath: sql.NullString{
		String: takeFirst(orig.ModulePath.String, ""),
		Valid: takeFirst(orig.ModulePath.Valid, true),
		},
		})
		require.NoError(t, err, "insert resource")
		return resource
		}

		func WorkspaceModule(t testing.TB, db database.Store, orig database.WorkspaceModule) database.WorkspaceModule {
		module, err := db.InsertWorkspaceModule(genCtx, database.InsertWorkspaceModuleParams{
		ID: takeFirst(orig.ID, uuid.New()),
		JobID: takeFirst(orig.JobID, uuid.New()),
		Transition: takeFirst(orig.Transition, database.WorkspaceTransitionStart),
		Source: takeFirst(orig.Source, "test-source"),
		Version: takeFirst(orig.Version, "v1.0.0"),
		Key: takeFirst(orig.Key, "test-key"),
		CreatedAt: takeFirst(orig.CreatedAt, dbtime.Now()),
		})
		require.NoError(t, err, "insert workspace module")
		return module
		}

		func WorkspaceResourceMetadatums(t testing.TB, db database.Store, seed database.WorkspaceResourceMetadatum) []database.WorkspaceResourceMetadatum {
		meta, err := db.InsertWorkspaceResourceMetadata(genCtx, database.InsertWorkspaceResourceMetadataParams{
		WorkspaceResourceID: takeFirst(seed.WorkspaceResourceID, uuid.New()),
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -73,6 +73,7 @@ func New() database.Store {
		workspaceAgents: make([]database.WorkspaceAgent, 0),
		provisionerJobLogs: make([]database.ProvisionerJobLog, 0),
		workspaceResources: make([]database.WorkspaceResource, 0),
		workspaceModules: make([]database.WorkspaceModule, 0),
		workspaceResourceMetadata: make([]database.WorkspaceResourceMetadatum, 0),
		provisionerJobs: make([]database.ProvisionerJob, 0),
		templateVersions: make([]database.TemplateVersionTable, 0),
Expand DownExpand Up		@@ -232,6 +233,7 @@ type data struct {
		workspaceBuildParameters []database.WorkspaceBuildParameter
		workspaceResourceMetadata []database.WorkspaceResourceMetadatum
		workspaceResources []database.WorkspaceResource
		workspaceModules []database.WorkspaceModule
		workspaces []database.WorkspaceTable
		workspaceProxies []database.WorkspaceProxy
		customRoles []database.CustomRole
Expand DownExpand Up		@@ -6671,6 +6673,32 @@ func (q *FakeQuerier) GetWorkspaceByWorkspaceAppID(_ context.Context, workspaceA
		return database.Workspace{}, sql.ErrNoRows
		}

		func (q *FakeQuerier) GetWorkspaceModulesByJobID(_ context.Context, jobID uuid.UUID) ([]database.WorkspaceModule, error) {
		q.mutex.RLock()
		defer q.mutex.RUnlock()

		modules := make([]database.WorkspaceModule, 0)
		for _, module := range q.workspaceModules {
		if module.JobID == jobID {
		modules = append(modules, module)
		}
		}
		return modules, nil
		}

		func (q *FakeQuerier) GetWorkspaceModulesCreatedAfter(_ context.Context, createdAt time.Time) ([]database.WorkspaceModule, error) {
		q.mutex.RLock()
		defer q.mutex.RUnlock()

		modules := make([]database.WorkspaceModule, 0)
		for _, module := range q.workspaceModules {
		if module.CreatedAt.After(createdAt) {
		modules = append(modules, module)
		}
		}
		return modules, nil
		}

		func (q *FakeQuerier) GetWorkspaceProxies(_ context.Context) ([]database.WorkspaceProxy, error) {
		q.mutex.RLock()
		defer q.mutex.RUnlock()
Expand DownExpand Up		@@ -8233,6 +8261,20 @@ func (q *FakeQuerier) InsertWorkspaceBuildParameters(_ context.Context, arg data
		return nil
		}

		func (q *FakeQuerier) InsertWorkspaceModule(_ context.Context, arg database.InsertWorkspaceModuleParams) (database.WorkspaceModule, error) {
		err := validateDatabaseType(arg)
		if err != nil {
		return database.WorkspaceModule{}, err
		}

		q.mutex.Lock()
		defer q.mutex.Unlock()

		workspaceModule := database.WorkspaceModule(arg)
		q.workspaceModules = append(q.workspaceModules, workspaceModule)
		return workspaceModule, nil
		}

		func (q *FakeQuerier) InsertWorkspaceProxy(_ context.Context, arg database.InsertWorkspaceProxyParams) (database.WorkspaceProxy, error) {
		q.mutex.Lock()
		defer q.mutex.Unlock()
Expand DownExpand Up		@@ -8283,6 +8325,7 @@ func (q *FakeQuerier) InsertWorkspaceResource(_ context.Context, arg database.In
		Hide: arg.Hide,
		Icon: arg.Icon,
		DailyCost: arg.DailyCost,
		ModulePath: arg.ModulePath,
		}
		q.workspaceResources = append(q.workspaceResources, resource)
		return resource, nil
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,5 @@
		DROP TABLE workspace_modules;

		ALTER TABLE
		workspace_resources
		DROP COLUMN module_path;
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,16 @@
		ALTER TABLE
		workspace_resources
		ADD
		COLUMN module_path TEXT;

		CREATE TABLE workspace_modules (
		id uuid NOT NULL,
		job_id uuid NOT NULL REFERENCES provisioner_jobs (id) ON DELETE CASCADE,
		transition workspace_transition NOT NULL,
		source TEXT NOT NULL,
		version TEXT NOT NULL,
		key TEXT NOT NULL,
		created_at timestamp with time zone NOT NULL
		);

		CREATE INDEX workspace_modules_created_at_idx ON workspace_modules (created_at);
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,20 @@
		INSERT INTO
		public.workspace_modules (
		id,
		job_id,
		transition,
		source,
		version,
		key,
		created_at
		)
		VALUES
		(
		'5b1a722c-b8a0-40b0-a3a0-d8078fff9f6c',
		'424a58cb-61d6-4627-9907-613c396c4a38',
		'start',
		'test-source',
		'v1.0.0',
		'test-key',
		'2024-11-08 10:00:00+00'
		);