Dec 11, 2024 · Nov 29, 2024 · Dec 3, 2024 · Dec 4, 2024 · Dec 5, 2024 · Dec 5, 2024
diff --git a/cli/testdata/coder_list_--output_json.golden b/cli/testdata/coder_list_--output_json.golden
      "deadline": "[timestamp]",
      "max_deadline": null,
      "status": "running",
      "daily_cost": 0
      "daily_cost": 0,
      "matched_provisioners": {
        "count": 0,
        "available": 0,
        "most_recently_seen": null
      }
    },
    "outdated": false,
    "name": "test-workspace",
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
 return q.db.GetDeploymentWorkspaceStats(ctx)
 }

 func (q *querier) GetEligibleProvisionerDaemonsByProvisionerJobIDs(ctx context.Context, provisionerJobIds []uuid.UUID) ([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, error) {
 return fetchWithPostFilter(q.auth, policy.ActionRead, q.db.GetEligibleProvisionerDaemonsByProvisionerJobIDs)(ctx, provisionerJobIds)
 }

 func (q *querier) GetExternalAuthLink(ctx context.Context, arg database.GetExternalAuthLinkParams) (database.ExternalAuthLink, error) {
 return fetchWithAction(q.log, q.auth, policy.ActionReadPersonal, q.db.GetExternalAuthLink)(ctx, arg)
 }
diff --git a/coderd/database/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
 s.NoError(err,"get provisioner daemon by org")
 check.Args(database.GetProvisionerDaemonsByOrganizationParams{OrganizationID:org.ID}).Asserts(d,policy.ActionRead).Returns(ds)
 }))
 s.Run("GetEligibleProvisionerDaemonsByProvisionerJobIDs",s.Subtest(func(db database.Store,check*expects) {
 org:=dbgen.Organization(s.T(),db, database.Organization{})
 tags:=database.StringMap(map[string]string{
 provisionersdk.TagScope:provisionersdk.ScopeOrganization,
 })
 j,err:=db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
 OrganizationID:org.ID,
 Type:database.ProvisionerJobTypeWorkspaceBuild,
 Tags:tags,
 Provisioner:database.ProvisionerTypeEcho,
 StorageMethod:database.ProvisionerStorageMethodFile,
 })
 s.NoError(err,"insert provisioner job")
 d,err:=db.UpsertProvisionerDaemon(context.Background(), database.UpsertProvisionerDaemonParams{
 OrganizationID:org.ID,
 Tags:tags,
 Provisioners:   []database.ProvisionerType{database.ProvisionerTypeEcho},
 })
 s.NoError(err,"insert provisioner daemon")
 ds,err:=db.GetEligibleProvisionerDaemonsByProvisionerJobIDs(context.Background(), []uuid.UUID{j.ID})
 s.NoError(err,"get provisioner daemon by org")
 check.Args(uuid.UUIDs{j.ID}).Asserts(d,policy.ActionRead).Returns(ds)
 }))
 s.Run("DeleteOldProvisionerDaemons",s.Subtest(func(db database.Store,check*expects) {
 _,err:=db.UpsertProvisionerDaemon(context.Background(), database.UpsertProvisionerDaemonParams{
 Tags:database.StringMap(map[string]string{
diff --git a/coderd/database/dbgen/dbgen.go b/coderd/database/dbgen/dbgen.go
 return groupMember
 }

 // ProvisionerDaemon creates a provisioner daemon as far as the database is concerned. It does not run a provisioner daemon.
 // If no key is provided, it will create one.
 func ProvisionerDaemon(t testing.TB, db database.Store, daemon database.ProvisionerDaemon) database.ProvisionerDaemon {
 t.Helper()

 if daemon.KeyID == uuid.Nil {
 key, err := db.InsertProvisionerKey(genCtx, database.InsertProvisionerKeyParams{
 ID:             uuid.New(),
 Name:           daemon.Name + "-key",
 OrganizationID: daemon.OrganizationID,
 HashedSecret:   []byte("secret"),
 CreatedAt:      dbtime.Now(),
 Tags:           daemon.Tags,
 })
 require.NoError(t, err)
 daemon.KeyID = key.ID
 }

 if daemon.CreatedAt.IsZero() {
 daemon.CreatedAt = dbtime.Now()
 }
 if daemon.Name == "" {
 daemon.Name = "test-daemon"
 }

 d, err := db.UpsertProvisionerDaemon(genCtx, database.UpsertProvisionerDaemonParams{
 Name:           daemon.Name,
 OrganizationID: daemon.OrganizationID,
 CreatedAt:      daemon.CreatedAt,
 Provisioners:   daemon.Provisioners,
 Tags:           daemon.Tags,
 KeyID:          daemon.KeyID,
 LastSeenAt:     daemon.LastSeenAt,
 Version:        daemon.Version,
 APIVersion:     daemon.APIVersion,
 })
 require.NoError(t, err)
 return d
 }

 // ProvisionerJob is a bit more involved to get the values such as "completedAt", "startedAt", "cancelledAt" set.  ps
 // can be set to nil if you are SURE that you don't require a provisionerdaemon to acquire the job in your test.
 func ProvisionerJob(t testing.TB, db database.Store, ps pubsub.Pubsub, orig database.ProvisionerJob) database.ProvisionerJob {
diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
 return scripts, nil
 }

 // getOwnerFromTags returns the lowercase owner from tags, matching SQL's COALESCE(tags ->> 'owner', ”)
 func getOwnerFromTags(tags map[string]string) string {
 if owner, ok := tags["owner"]; ok {
 return strings.ToLower(owner)
 }
 return ""
 }

 func (*FakeQuerier) AcquireLock(_ context.Context, _ int64) error {
 return xerrors.New("AcquireLock must only be called within a transaction")
 }
 return stat, nil
 }

 func (q *FakeQuerier) GetEligibleProvisionerDaemonsByProvisionerJobIDs(_ context.Context, provisionerJobIds []uuid.UUID) ([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, error) {
 q.mutex.RLock()
 defer q.mutex.RUnlock()

 results := make([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, 0)
 seen := make(map[string]struct{}) // Track unique combinations

 for _, jobID := range provisionerJobIds {
 var job database.ProvisionerJob
 found := false
 for _, j := range q.provisionerJobs {
 if j.ID == jobID {
 job = j
 found = true
 break
 }
 }
 if !found {
 continue
 }

 for _, daemon := range q.provisionerDaemons {
 if daemon.OrganizationID != job.OrganizationID {
 continue
 }

 if !tagsSubset(job.Tags, daemon.Tags) {
 continue
 }

 provisionerMatches := false
 for _, p := range daemon.Provisioners {
 if p == job.Provisioner {
 provisionerMatches = true
 break
 }
 }
 if !provisionerMatches {
 continue
 }

 key := jobID.String() + "-" + daemon.ID.String()
 if _, exists := seen[key]; exists {
 continue
 }
 seen[key] = struct{}{}

 results = append(results, database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow{
 JobID:             jobID,
 ProvisionerDaemon: daemon,
 })
 }
 }

 return results, nil
 }

 func (q *FakeQuerier) GetExternalAuthLink(_ context.Context, arg database.GetExternalAuthLinkParams) (database.ExternalAuthLink, error) {
 if err := validateDatabaseType(arg); err != nil {
 return database.ExternalAuthLink{}, err
 }

 func (q *FakeQuerier) UpsertProvisionerDaemon(_ context.Context, arg database.UpsertProvisionerDaemonParams) (database.ProvisionerDaemon, error) {
 err := validateDatabaseType(arg)
 if err != nil {
 if err := validateDatabaseType(arg); err != nil {
 return database.ProvisionerDaemon{}, err
 }

 q.mutex.Lock()
 defer q.mutex.Unlock()
 for _, d := range q.provisionerDaemons {
 if d.Name == arg.Name {
 if d.Tags[provisionersdk.TagScope] == provisionersdk.ScopeOrganization && arg.Tags[provisionersdk.TagOwner] != "" {
 continue
 }
 if d.Tags[provisionersdk.TagScope] == provisionersdk.ScopeUser && arg.Tags[provisionersdk.TagOwner] != d.Tags[provisionersdk.TagOwner] {
 continue
 }

 // Look for existing daemon using the same composite key as SQL
 for i, d := range q.provisionerDaemons {
 if d.OrganizationID == arg.OrganizationID &&
 d.Name == arg.Name &&
 getOwnerFromTags(d.Tags) == getOwnerFromTags(arg.Tags) {
 d.Provisioners = arg.Provisioners
 d.Tags = maps.Clone(arg.Tags)
 d.Version = arg.Version
 d.LastSeenAt = arg.LastSeenAt
 d.Version = arg.Version
 d.APIVersion = arg.APIVersion
 d.OrganizationID = arg.OrganizationID
 d.KeyID = arg.KeyID
 q.provisionerDaemons[i] = d
 return d, nil
 }
 }
 Name:           arg.Name,
 Provisioners:   arg.Provisioners,
 Tags:           maps.Clone(arg.Tags),
 ReplicaID:      uuid.NullUUID{},
 LastSeenAt:     arg.LastSeenAt,
 Version:        arg.Version,
 APIVersion:     arg.APIVersion,
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/modelmethods.go b/coderd/database/modelmethods.go
 InOrg(p.OrganizationID)
 }

 func (p GetEligibleProvisionerDaemonsByProvisionerJobIDsRow) RBACObject() rbac.Object {
 return p.ProvisionerDaemon.RBACObject()
 }

 func (p ProvisionerKey) RBACObject() rbac.Object {
 return rbac.ResourceProvisionerKeys.
 WithID(p.ID).
diff --git a/coderd/database/querier.go b/coderd/database/querier.go
Original file line number	Diff line number	Diff line change
Expand Up		@@ -50,7 +50,12 @@
		"deadline": "[timestamp]",
		"max_deadline": null,
		"status": "running",
		"daily_cost": 0
		"daily_cost": 0,
		"matched_provisioners": {
		"count": 0,
		"available": 0,
		"most_recently_seen": null
		}
		},
		"outdated": false,
		"name": "test-workspace",
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1568,6 +1568,10 @@ func (q *querier) GetDeploymentWorkspaceStats(ctx context.Context) (database.Get
		return q.db.GetDeploymentWorkspaceStats(ctx)
		}

		func (q *querier) GetEligibleProvisionerDaemonsByProvisionerJobIDs(ctx context.Context, provisionerJobIds []uuid.UUID) ([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, error) {
		return fetchWithPostFilter(q.auth, policy.ActionRead, q.db.GetEligibleProvisionerDaemonsByProvisionerJobIDs)(ctx, provisionerJobIds)
		}

		func (q *querier) GetExternalAuthLink(ctx context.Context, arg database.GetExternalAuthLinkParams) (database.ExternalAuthLink, error) {
		return fetchWithAction(q.log, q.auth, policy.ActionReadPersonal, q.db.GetExternalAuthLink)(ctx, arg)
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2119,6 +2119,29 @@ func (s *MethodTestSuite) TestExtraMethods() {
		s.NoError(err,"get provisioner daemon by org")
		check.Args(database.GetProvisionerDaemonsByOrganizationParams{OrganizationID:org.ID}).Asserts(d,policy.ActionRead).Returns(ds)
		}))
		s.Run("GetEligibleProvisionerDaemonsByProvisionerJobIDs",s.Subtest(func(db database.Store,check*expects) {
		org:=dbgen.Organization(s.T(),db, database.Organization{})
		tags:=database.StringMap(map[string]string{
		provisionersdk.TagScope:provisionersdk.ScopeOrganization,
		})
		j,err:=db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
		OrganizationID:org.ID,
		Type:database.ProvisionerJobTypeWorkspaceBuild,
		Tags:tags,
		Provisioner:database.ProvisionerTypeEcho,
		StorageMethod:database.ProvisionerStorageMethodFile,
		})
		s.NoError(err,"insert provisioner job")
		d,err:=db.UpsertProvisionerDaemon(context.Background(), database.UpsertProvisionerDaemonParams{
		OrganizationID:org.ID,
		Tags:tags,
		Provisioners: []database.ProvisionerType{database.ProvisionerTypeEcho},
		})
		s.NoError(err,"insert provisioner daemon")
		ds,err:=db.GetEligibleProvisionerDaemonsByProvisionerJobIDs(context.Background(), []uuid.UUID{j.ID})
		s.NoError(err,"get provisioner daemon by org")
		check.Args(uuid.UUIDs{j.ID}).Asserts(d,policy.ActionRead).Returns(ds)
		}))
		s.Run("DeleteOldProvisionerDaemons",s.Subtest(func(db database.Store,check*expects) {
		_,err:=db.UpsertProvisionerDaemon(context.Background(), database.UpsertProvisionerDaemonParams{
		Tags:database.StringMap(map[string]string{
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -503,6 +503,46 @@ func GroupMember(t testing.TB, db database.Store, member database.GroupMemberTab
		return groupMember
		}

		// ProvisionerDaemon creates a provisioner daemon as far as the database is concerned. It does not run a provisioner daemon.
		// If no key is provided, it will create one.
		func ProvisionerDaemon(t testing.TB, db database.Store, daemon database.ProvisionerDaemon) database.ProvisionerDaemon {
		t.Helper()

		if daemon.KeyID == uuid.Nil {
		key, err := db.InsertProvisionerKey(genCtx, database.InsertProvisionerKeyParams{
		ID: uuid.New(),
		Name: daemon.Name + "-key",
		OrganizationID: daemon.OrganizationID,
		HashedSecret: []byte("secret"),
		CreatedAt: dbtime.Now(),
		Tags: daemon.Tags,
		})
		require.NoError(t, err)
		daemon.KeyID = key.ID
		}

		if daemon.CreatedAt.IsZero() {
		daemon.CreatedAt = dbtime.Now()
		}
		if daemon.Name == "" {
		daemon.Name = "test-daemon"
		}

		d, err := db.UpsertProvisionerDaemon(genCtx, database.UpsertProvisionerDaemonParams{
		Name: daemon.Name,
		OrganizationID: daemon.OrganizationID,
		CreatedAt: daemon.CreatedAt,
		Provisioners: daemon.Provisioners,
		Tags: daemon.Tags,
		KeyID: daemon.KeyID,
		LastSeenAt: daemon.LastSeenAt,
		Version: daemon.Version,
		APIVersion: daemon.APIVersion,
		})
		require.NoError(t, err)
		return d
		}

		// ProvisionerJob is a bit more involved to get the values such as "completedAt", "startedAt", "cancelledAt" set. ps
		// can be set to nil if you are SURE that you don't require a provisionerdaemon to acquire the job in your test.
		func ProvisionerJob(t testing.TB, db database.Store, ps pubsub.Pubsub, orig database.ProvisionerJob) database.ProvisionerJob {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1120,6 +1120,14 @@ func (q *FakeQuerier) getWorkspaceAgentScriptsByAgentIDsNoLock(ids []uuid.UUID)
		return scripts, nil
		}

		// getOwnerFromTags returns the lowercase owner from tags, matching SQL's COALESCE(tags ->> 'owner', ”)
		func getOwnerFromTags(tags map[string]string) string {
		if owner, ok := tags["owner"]; ok {
		return strings.ToLower(owner)
		}
		return ""
		}

		func (*FakeQuerier) AcquireLock(_ context.Context, _ int64) error {
		return xerrors.New("AcquireLock must only be called within a transaction")
		}
Expand DownExpand Up		@@ -2773,6 +2781,63 @@ func (q *FakeQuerier) GetDeploymentWorkspaceStats(ctx context.Context) (database
		return stat, nil
		}

		func (q *FakeQuerier) GetEligibleProvisionerDaemonsByProvisionerJobIDs(_ context.Context, provisionerJobIds []uuid.UUID) ([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, error) {
		q.mutex.RLock()
		defer q.mutex.RUnlock()

		results := make([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, 0)
		seen := make(map[string]struct{}) // Track unique combinations

		for _, jobID := range provisionerJobIds {
		var job database.ProvisionerJob
		found := false
		for _, j := range q.provisionerJobs {
		if j.ID == jobID {
		job = j
		found = true
		break
		}
		}
		if !found {
		continue
		}

		for _, daemon := range q.provisionerDaemons {
		if daemon.OrganizationID != job.OrganizationID {
		continue
		}

		if !tagsSubset(job.Tags, daemon.Tags) {
		continue
		}

		provisionerMatches := false
		for _, p := range daemon.Provisioners {
		if p == job.Provisioner {
		provisionerMatches = true
		break
		}
		}
		if !provisionerMatches {
		continue
		}

		key := jobID.String() + "-" + daemon.ID.String()
		if _, exists := seen[key]; exists {
		continue
		}
		seen[key] = struct{}{}

		results = append(results, database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow{
		JobID: jobID,
		ProvisionerDaemon: daemon,
		})
		}
		}

		return results, nil
		}

		func (q *FakeQuerier) GetExternalAuthLink(_ context.Context, arg database.GetExternalAuthLinkParams) (database.ExternalAuthLink, error) {
		if err := validateDatabaseType(arg); err != nil {
		return database.ExternalAuthLink{}, err
Expand DownExpand Up		@@ -10344,25 +10409,26 @@ func (q *FakeQuerier) UpsertOAuthSigningKey(_ context.Context, value string) err
		}

		func (q *FakeQuerier) UpsertProvisionerDaemon(_ context.Context, arg database.UpsertProvisionerDaemonParams) (database.ProvisionerDaemon, error) {
		err := validateDatabaseType(arg)
		if err != nil {
		if err := validateDatabaseType(arg); err != nil {
		return database.ProvisionerDaemon{}, err
		}

		q.mutex.Lock()
		defer q.mutex.Unlock()
		for _, d := range q.provisionerDaemons {
		if d.Name == arg.Name {
		if d.Tags[provisionersdk.TagScope] == provisionersdk.ScopeOrganization && arg.Tags[provisionersdk.TagOwner] != "" {
		continue
		}
		if d.Tags[provisionersdk.TagScope] == provisionersdk.ScopeUser && arg.Tags[provisionersdk.TagOwner] != d.Tags[provisionersdk.TagOwner] {
		continue
		}

		// Look for existing daemon using the same composite key as SQL
		for i, d := range q.provisionerDaemons {
		if d.OrganizationID == arg.OrganizationID &&
		d.Name == arg.Name &&
		getOwnerFromTags(d.Tags) == getOwnerFromTags(arg.Tags) {
		d.Provisioners = arg.Provisioners
		d.Tags = maps.Clone(arg.Tags)
		d.Version = arg.Version
		d.LastSeenAt = arg.LastSeenAt
		d.Version = arg.Version
		d.APIVersion = arg.APIVersion
		d.OrganizationID = arg.OrganizationID
		d.KeyID = arg.KeyID
		q.provisionerDaemons[i] = d
		return d, nil
		}
		}
Expand All		@@ -10372,7 +10438,6 @@ func (q *FakeQuerier) UpsertProvisionerDaemon(_ context.Context, arg database.Up
		Name: arg.Name,
		Provisioners: arg.Provisioners,
		Tags: maps.Clone(arg.Tags),
		ReplicaID: uuid.NullUUID{},
		LastSeenAt: arg.LastSeenAt,
		Version: arg.Version,
		APIVersion: arg.APIVersion,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -269,6 +269,10 @@ func (p ProvisionerDaemon) RBACObject() rbac.Object {
		InOrg(p.OrganizationID)
		}

		func (p GetEligibleProvisionerDaemonsByProvisionerJobIDsRow) RBACObject() rbac.Object {
		return p.ProvisionerDaemon.RBACObject()
		}

		func (p ProvisionerKey) RBACObject() rbac.Object {
		return rbac.ResourceProvisionerKeys.
		WithID(p.ID).
Expand Down