Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

refactor: consolidate task run listing (#20659)

p0ny5ee927f6da14
diff --git a/backend/runner/taskrun/pending_scheduler.go b/backend/runner/taskrun/pending_scheduler.go
index cab9abf817..13a82603d8 100644
--- a/backend/runner/taskrun/pending_scheduler.go
+++ b/backend/runner/taskrun/pending_scheduler.go
@@ -78,7 +78,9 @@ func (s *Scheduler) schedulePendingTaskRuns(ctx context.Context) (err error) {
return nil
}
- taskRuns, err := s.store.ListTaskRunsByStatus(ctx, []storepb.TaskRun_Status{storepb.TaskRun_PENDING})
+ taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: new([]storepb.TaskRun_Status{storepb.TaskRun_PENDING}),
+ })
if err != nil {
return errors.Wrapf(err, "failed to list pending task runs")
}
@@ -224,7 +226,9 @@ type schedulingContext struct {
}
func newSchedulingContext(ctx context.Context, s *store.Store) (*schedulingContext, error) {
- activeTaskRuns, err := s.ListTaskRunsByStatus(ctx, []storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE, storepb.TaskRun_RUNNING})
+ activeTaskRuns, err := s.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: new([]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE, storepb.TaskRun_RUNNING}),
+ })
if err != nil {
return nil, errors.Wrapf(err, "failed to list active task runs")
}
diff --git a/backend/runner/taskrun/scheduler.go b/backend/runner/taskrun/scheduler.go
index 9eba119e04..3fba303876 100644
--- a/backend/runner/taskrun/scheduler.go
+++ b/backend/runner/taskrun/scheduler.go
@@ -71,7 +71,9 @@ func (s *Scheduler) Register(taskType storepb.Task_Type, executorGetter Executor
// failTaskRunsForHA fails all PENDING and AVAILABLE task runs because HA is not licensed.
func (s *Scheduler) failTaskRunsForHA(ctx context.Context, haErr error) {
- taskRuns, err := s.store.ListTaskRunsByStatus(ctx, []storepb.TaskRun_Status{storepb.TaskRun_PENDING, storepb.TaskRun_AVAILABLE})
+ taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: new([]storepb.TaskRun_Status{storepb.TaskRun_PENDING, storepb.TaskRun_AVAILABLE}),
+ })
if err != nil {
slog.Error("failed to list task runs for HA limit check", log.BBError(err))
return
diff --git a/backend/store/task_run.go b/backend/store/task_run.go
index 155d3f6702..6e1a342e16 100644
--- a/backend/store/task_run.go
+++ b/backend/store/task_run.go
@@ -39,7 +39,7 @@ type FindTaskRunMessage struct {
Workspace string
UID *int64
UIDs *[]int64
- ProjectID string
+ ProjectID string // Empty string skips filtering for cross-project queries like runners.
TaskUID *int64
Environment *string
PlanUID *int64
@@ -62,51 +62,60 @@ type TaskRunStatusPatch struct {
// ListTaskRuns lists task runs.
func (s *Store) ListTaskRuns(ctx context.Context, find *FindTaskRunMessage) ([]*TaskRunMessage, error) {
- q := qb.Q().Space(`
- SELECT
- task_run.id,
- task_run.creator,
- task_run.created_at,
- task_run.updated_at,
- task_run.task_id,
- task_run.status,
- task_run.started_at,
- task_run.run_at,
- task_run.result,
- task_run.payload,
- task.plan_id,
- task.environment,
- task_run.project
- FROM task_run
- LEFT JOIN task ON task.project = task_run.project AND task.id = task_run.task_id
- WHERE task_run.project = ?
- `, find.ProjectID)
+ if find.ProjectID == "" && (find.UID != nil || find.UIDs != nil || find.TaskUID != nil || find.Environment != nil || find.PlanUID != nil) {
+ return nil, errors.Errorf("project ID is required for scoped task run filters")
+ }
+ where := qb.Q()
+ if find.ProjectID != "" {
+ where.And("task_run.project = ?", find.ProjectID)
+ }
if find.Workspace != "" {
- q.And("task_run.project IN (SELECT resource_id FROM project WHERE workspace = ?)", find.Workspace)
+ where.And("task_run.project IN (SELECT resource_id FROM project WHERE workspace = ?)", find.Workspace)
}
-
if v := find.UID; v != nil {
- q.And("task_run.id = ?", *v)
+ where.And("task_run.id = ?", *v)
}
if v := find.UIDs; v != nil {
- q.And("task_run.id = ANY(?)", *v)
+ where.And("task_run.id = ANY(?)", *v)
}
if v := find.TaskUID; v != nil {
- q.And("task_run.task_id = ?", *v)
+ where.And("task_run.task_id = ?", *v)
}
if v := find.Environment; v != nil {
- q.And("task.environment = ?", *v)
+ where.And("task.environment = ?", *v)
}
if v := find.PlanUID; v != nil {
- q.And("task.plan_id = ?", *v)
+ where.And("task.plan_id = ?", *v)
}
if v := find.Status; v != nil {
var statusStrings []string
for _, status := range *v {
statusStrings = append(statusStrings, status.String())
}
- q.And("task_run.status = ANY(?)", statusStrings)
+ where.And("task_run.status = ANY(?)", statusStrings)
+ }
+
+ q := qb.Q().Space(`
+ SELECT
+ task_run.id,
+ task_run.creator,
+ task_run.created_at,
+ task_run.updated_at,
+ task_run.task_id,
+ task_run.status,
+ task_run.started_at,
+ task_run.run_at,
+ task_run.result,
+ task_run.payload,
+ task.plan_id,
+ task.environment,
+ task_run.project
+ FROM task_run
+ LEFT JOIN task ON task.project = task_run.project AND task.id = task_run.task_id
+ `)
+ if where.Len() > 0 {
+ q.Space("WHERE ?", where)
}
q.Space("ORDER BY task_run.id ASC")
@@ -562,91 +571,3 @@ func (s *Store) UpdateTaskRunPayload(ctx context.Context, projectID string, task
}
return nil
}
-
-// ListTaskRunsByStatus lists task runs by status across all projects.
-// This is for system schedulers that need cross-project queries.
-func (s *Store) ListTaskRunsByStatus(ctx context.Context, statuses []storepb.TaskRun_Status) ([]*TaskRunMessage, error) {
- var statusStrings []string
- for _, status := range statuses {
- statusStrings = append(statusStrings, status.String())
- }
- q := qb.Q().Space(`
- SELECT
- task_run.id,
- task_run.creator,
- task_run.created_at,
- task_run.updated_at,
- task_run.task_id,
- task_run.status,
- task_run.started_at,
- task_run.run_at,
- task_run.result,
- task_run.payload,
- task.plan_id,
- task.environment,
- task_run.project
- FROM task_run
- LEFT JOIN task ON task.project = task_run.project AND task.id = task_run.task_id
- WHERE task_run.status = ANY(?)
- ORDER BY task_run.id ASC
- `, statusStrings)
-
- query, args, err := q.ToSQL()
- if err != nil {
- return nil, errors.Wrapf(err, "failed to build sql")
- }
-
- rows, err := s.GetDB().QueryContext(ctx, query, args...)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- var taskRuns []*TaskRunMessage
- for rows.Next() {
- var taskRun TaskRunMessage
- var creatorEmail sql.NullString
- var statusString string
- var resultJSON, payloadJSON string
- if err := rows.Scan(
- &taskRun.ID,
- &creatorEmail,
- &taskRun.CreatedAt,
- &taskRun.UpdatedAt,
- &taskRun.TaskUID,
- &statusString,
- &taskRun.StartedAt,
- &taskRun.RunAt,
- &resultJSON,
- &payloadJSON,
- &taskRun.PlanUID,
- &taskRun.Environment,
- &taskRun.ProjectID,
- ); err != nil {
- return nil, err
- }
- if creatorEmail.Valid {
- taskRun.CreatorEmail = creatorEmail.String
- }
- if statusValue, ok := storepb.TaskRun_Status_value[statusString]; ok {
- taskRun.Status = storepb.TaskRun_Status(statusValue)
- } else {
- return nil, errors.Errorf("invalid task run status string: %s", statusString)
- }
- resultProto := &storepb.TaskRunResult{}
- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(resultJSON), resultProto); err != nil {
- return nil, errors.Wrapf(err, "failed to unmarshal result")
- }
- taskRun.ResultProto = resultProto
- payloadProto := &storepb.TaskRunPayload{}
- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadJSON), payloadProto); err != nil {
- return nil, errors.Wrapf(err, "failed to unmarshal payload")
- }
- taskRun.PayloadProto = payloadProto
- taskRuns = append(taskRuns, &taskRun)
- }
- if err := rows.Err(); err != nil {
- return nil, err
- }
- return taskRuns, nil
-}