Skip to content

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

refactor: add AVAILABLE status to task scheduler for HA preparation (#18697)

p0ny714640c51676
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yaml
index d60efcf557..f8d98777cc 100644
--- a/backend/api/mcp/gen/openapi.yaml
+++ b/backend/api/mcp/gen/openapi.yaml
@@ -16185,6 +16185,7 @@ components:
- DONE
- FAILED
- CANCELED
+ - AVAILABLE
bytebase.v1.TaskRunLog:
type: object
properties:
diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.go
index 038d81e73e..e9976b1dcf 100644
--- a/backend/api/v1/rollout_service.go
+++ b/backend/api/v1/rollout_service.go
@@ -922,9 +922,10 @@ func (s *RolloutService) BatchCancelTaskRuns(ctx context.Context, req *connect.R
for _, taskRun := range taskRuns {
switch taskRun.Status {
case storepb.TaskRun_PENDING:
+ case storepb.TaskRun_AVAILABLE:
case storepb.TaskRun_RUNNING:
default:
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("taskRun %v is not pending or running", taskRun.ID))
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("taskRun %v is not pending, available or running", taskRun.ID))
}
}
diff --git a/backend/component/state/state.go b/backend/component/state/state.go
index 2b4f5b1ace..d11dd6e9e3 100644
--- a/backend/component/state/state.go
+++ b/backend/component/state/state.go
@@ -19,17 +19,11 @@ type State struct {
RunningTaskRuns sync.Map // map[taskRunID]bool
// RunningTaskRunsCancelFunc is the cancelFunc of running taskruns.
RunningTaskRunsCancelFunc sync.Map // map[taskRunID]context.CancelFunc
- // RunningDatabaseMigration is the taskUID of the running migration on the database.
- RunningDatabaseMigration sync.Map // map[databaseKey]taskUID
// RunningPlanChecks is the set of running plan checks.
RunningPlanChecks sync.Map
// RunningPlanCheckRunsCancelFunc is the cancelFunc of running plan checks.
RunningPlanCheckRunsCancelFunc sync.Map // map[planCheckRunUID]context.CancelFunc
- // InstanceOutstandingConnections is the maximum number of connections per instance.
- InstanceOutstandingConnections *resourceLimiter
- // RolloutOutstandingTasks is the maximum number of tasks per rollout.
- RolloutOutstandingTasks *resourceLimiter
// TaskSkippedOrDoneChan is the channel for notifying the task is skipped or done.
TaskSkippedOrDoneChan chan int
@@ -45,39 +39,9 @@ type State struct {
func New() (*State, error) {
return &State{
- InstanceOutstandingConnections: &resourceLimiter{connections: map[string]int{}},
- RolloutOutstandingTasks: &resourceLimiter{connections: map[string]int{}},
- TaskSkippedOrDoneChan: make(chan int, 1000),
- PlanCheckTickleChan: make(chan int, 1000),
- TaskRunTickleChan: make(chan int, 1000),
- RolloutCreationChan: make(chan int64, 100),
+ TaskSkippedOrDoneChan: make(chan int, 1000),
+ PlanCheckTickleChan: make(chan int, 1000),
+ TaskRunTickleChan: make(chan int, 1000),
+ RolloutCreationChan: make(chan int64, 100),
}, nil
}
-
-type resourceLimiter struct {
- sync.Mutex
- connections map[string]int
-}
-
-// limit <= 0 means no limit.
-func (c *resourceLimiter) Increment(key string, limit int) bool {
- c.Lock()
- defer c.Unlock()
- if limit <= 0 {
- // No limit.
- // Increment anyway to balance the decrement.
- c.connections[key]++
- return false
- }
- if c.connections[key] >= limit {
- return true
- }
- c.connections[key]++
- return false
-}
-
-func (c *resourceLimiter) Decrement(key string) {
- c.Lock()
- defer c.Unlock()
- c.connections[key]--
-}
diff --git a/backend/generated-go/store/task_run.pb.go b/backend/generated-go/store/task_run.pb.go
index b1d738ee63..c97b07df3c 100644
--- a/backend/generated-go/store/task_run.pb.go
+++ b/backend/generated-go/store/task_run.pb.go
@@ -41,6 +41,8 @@ const (
TaskRun_NOT_STARTED TaskRun_Status = 6
// Task run was skipped and will not execute.
TaskRun_SKIPPED TaskRun_Status = 7
+ // Task run is ready for immediate execution.
+ TaskRun_AVAILABLE TaskRun_Status = 8
)
// Enum value maps for TaskRun_Status.
@@ -54,6 +56,7 @@ var (
5: "CANCELED",
6: "NOT_STARTED",
7: "SKIPPED",
+ 8: "AVAILABLE",
}
TaskRun_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
@@ -64,6 +67,7 @@ var (
"CANCELED": 5,
"NOT_STARTED": 6,
"SKIPPED": 7,
+ "AVAILABLE": 8,
}
)
@@ -577,8 +581,8 @@ var File_store_task_run_proto protoreflect.FileDescriptor
const file_store_task_run_proto_rawDesc = "" +
"\n" +
- "\x14store/task_run.proto\x12\x0ebytebase.store\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x12store/common.proto\"\x87\x01\n" +
- "\aTaskRun\"|\n" +
+ "\x14store/task_run.proto\x12\x0ebytebase.store\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x12store/common.proto\"\x97\x01\n" +
+ "\aTaskRun\"\x8b\x01\n" +
"\x06Status\x12\x16\n" +
"\x12STATUS_UNSPECIFIED\x10\x00\x12\v\n" +
"\aPENDING\x10\x01\x12\v\n" +
@@ -588,7 +592,8 @@ const file_store_task_run_proto_rawDesc = "" +
"\x06FAILED\x10\x04\x12\f\n" +
"\bCANCELED\x10\x05\x12\x0f\n" +
"\vNOT_STARTED\x10\x06\x12\v\n" +
- "\aSKIPPED\x10\a\"\xde\x02\n" +
+ "\aSKIPPED\x10\a\x12\r\n" +
+ "\tAVAILABLE\x10\b\"\xde\x02\n" +
"\rTaskRunResult\x12\x16\n" +
"\x06detail\x18\x01 \x01(\tR\x06detail\x12\x18\n" +
"\aversion\x18\x02 \x01(\tR\aversion\x12?\n" +
diff --git a/backend/generated-go/v1/rollout_service.pb.go b/backend/generated-go/v1/rollout_service.pb.go
index 68c3bb5870..ea59f298b7 100644
--- a/backend/generated-go/v1/rollout_service.pb.go
+++ b/backend/generated-go/v1/rollout_service.pb.go
@@ -179,6 +179,8 @@ const (
TaskRun_FAILED TaskRun_Status = 4
// Task run execution was canceled by a user.
TaskRun_CANCELED TaskRun_Status = 5
+ // Task run is ready for immediate execution.
+ TaskRun_AVAILABLE TaskRun_Status = 6
)
// Enum value maps for TaskRun_Status.
@@ -190,6 +192,7 @@ var (
3: "DONE",
4: "FAILED",
5: "CANCELED",
+ 6: "AVAILABLE",
}
TaskRun_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
@@ -198,6 +201,7 @@ var (
"DONE": 3,
"FAILED": 4,
"CANCELED": 5,
+ "AVAILABLE": 6,
}
)
@@ -3645,7 +3649,7 @@ const file_v1_rollout_service_proto_rawDesc = "" +
"\x11bytebase.com/Task\x12Cprojects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}B\t\n" +
"\apayloadB\x0e\n" +
"\f_update_timeB\v\n" +
- "\t_run_time\"\x8c\x0f\n" +
+ "\t_run_time\"\x9b\x0f\n" +
"\aTaskRun\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
"\acreator\x18\x02 \x01(\tR\acreator\x12@\n" +
@@ -3686,7 +3690,7 @@ const file_v1_rollout_service_proto_rawDesc = "" +
"\x14parallel_tasks_limit\x18\x03 \x01(\bH\x00R\x12parallelTasksLimit\x1a\x1a\n" +
"\x04Task\x12\x12\n" +
"\x04task\x18\x01 \x01(\tR\x04taskB\a\n" +
- "\x05cause\"^\n" +
+ "\x05cause\"m\n" +
"\x06Status\x12\x16\n" +
"\x12STATUS_UNSPECIFIED\x10\x00\x12\v\n" +
"\aPENDING\x10\x01\x12\v\n" +
@@ -3694,7 +3698,8 @@ const file_v1_rollout_service_proto_rawDesc = "" +
"\x04DONE\x10\x03\x12\n" +
"\n" +
"\x06FAILED\x10\x04\x12\f\n" +
- "\bCANCELED\x10\x05\"U\n" +
+ "\bCANCELED\x10\x05\x12\r\n" +
+ "\tAVAILABLE\x10\x06\"U\n" +
"\x13ExportArchiveStatus\x12%\n" +
"!EXPORT_ARCHIVE_STATUS_UNSPECIFIED\x10\x00\x12\t\n" +
"\x05READY\x10\x01\x12\f\n" +
diff --git a/backend/migrator/migration/3.14/0015##task_run_available_status.sql b/backend/migrator/migration/3.14/0015##task_run_available_status.sql
new file mode 100644
index 0000000000..c8d9358bc7
--- /dev/null
+++ b/backend/migrator/migration/3.14/0015##task_run_available_status.sql
@@ -0,0 +1,9 @@
+-- Add AVAILABLE status to task_run CHECK constraint
+ALTER TABLE task_run DROP CONSTRAINT task_run_status_check;
+ALTER TABLE task_run ADD CONSTRAINT task_run_status_check
+ CHECK (status IN ('PENDING', 'AVAILABLE', 'RUNNING', 'DONE', 'FAILED', 'CANCELED'));
+
+-- Update partial index to include AVAILABLE
+DROP INDEX idx_task_run_active_status_id;
+CREATE INDEX idx_task_run_active_status_id ON task_run(status, id)
+ WHERE status IN ('PENDING', 'AVAILABLE', 'RUNNING');
diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sql
index 72eafde90b..905d6a99ba 100644
--- a/backend/migrator/migration/LATEST.sql
+++ b/backend/migrator/migration/LATEST.sql
@@ -254,7 +254,7 @@ CREATE TABLE task_run (
task_id integer NOT NULL REFERENCES task(id),
sheet_sha256 bytea REFERENCES sheet_blob(sha256),
attempt integer NOT NULL,
- status text NOT NULL CHECK (status IN ('PENDING', 'RUNNING', 'DONE', 'FAILED', 'CANCELED')),
+ status text NOT NULL CHECK (status IN ('PENDING', 'AVAILABLE', 'RUNNING', 'DONE', 'FAILED', 'CANCELED')),
started_at timestamptz NULL,
run_at timestamptz,
code integer NOT NULL DEFAULT 0,
@@ -270,7 +270,7 @@ CREATE UNIQUE INDEX uk_task_run_task_id_attempt ON task_run (task_id, attempt);
-- Partial index for active task runs. Most task runs are in terminal states (DONE, FAILED, CANCELED)
-- that never change. Queries frequently filter for active statuses (PENDING, RUNNING), so a partial
-- index is more efficient than a full index on status - smaller size, faster maintenance, better cache efficiency.
-CREATE INDEX idx_task_run_active_status_id ON task_run(status, id) WHERE status IN ('PENDING', 'RUNNING');
+CREATE INDEX idx_task_run_active_status_id ON task_run(status, id) WHERE status IN ('PENDING', 'AVAILABLE', 'RUNNING');
ALTER SEQUENCE task_run_id_seq RESTART WITH 101;
diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.go
index 22ca5000cd..4c70b914bb 100644
--- a/backend/migrator/migrator_test.go
+++ b/backend/migrator/migrator_test.go
@@ -12,8 +12,8 @@ import (
func TestLatestVersion(t *testing.T) {
files, err := getSortedVersionedFiles()
require.NoError(t, err)
- require.Equal(t, semver.MustParse("3.14.14"), *files[len(files)-1].version)
- require.Equal(t, "migration/3.14/0014##clean_deprecated_webhook_activities.sql", files[len(files)-1].path)
+ require.Equal(t, semver.MustParse("3.14.15"), *files[len(files)-1].version)
+ require.Equal(t, "migration/3.14/0015##task_run_available_status.sql", files[len(files)-1].path)
}
func TestVersionUnique(t *testing.T) {
diff --git a/backend/runner/taskrun/pending_scheduler.go b/backend/runner/taskrun/pending_scheduler.go
index dc57a6d317..53f2c2aab6 100644
--- a/backend/runner/taskrun/pending_scheduler.go
+++ b/backend/runner/taskrun/pending_scheduler.go
@@ -16,6 +16,88 @@ import (
"github.com/bytebase/bytebase/backend/store"
)
+// checkDatabaseMutualExclusion checks if there's already an AVAILABLE or RUNNING task on the database.
+// Returns true if the task can proceed (no conflict), false otherwise.
+func (s *Scheduler) checkDatabaseMutualExclusion(ctx context.Context, task *store.TaskMessage, availableDBs map[string]bool) (bool, *int, error) {
+ if task.DatabaseName == nil {
+ return true, nil, nil
+ }
+ if !isSequentialTask(task) {
+ return true, nil, nil
+ }
+
+ databaseKey := getDatabaseKey(task.InstanceID, *task.DatabaseName)
+
+ // Check in-memory tracking first (tasks promoted this round)
+ if availableDBs[databaseKey] {
+ return false, nil, nil
+ }
+
+ // Check database for AVAILABLE or RUNNING tasks on the same database
+ activeTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE, storepb.TaskRun_RUNNING},
+ })
+ if err != nil {
+ return false, nil, errors.Wrapf(err, "failed to list active task runs")
+ }
+
+ for _, tr := range activeTaskRuns {
+ activeTask, err := s.store.GetTaskByID(ctx, tr.TaskUID)
+ if err != nil {
+ return false, nil, errors.Wrapf(err, "failed to get task")
+ }
+ if activeTask.DatabaseName == nil {
+ continue
+ }
+ if !isSequentialTask(activeTask) {
+ continue
+ }
+ if getDatabaseKey(activeTask.InstanceID, *activeTask.DatabaseName) == databaseKey {
+ return false, &activeTask.ID, nil
+ }
+ }
+
+ return true, nil, nil
+}
+
+// checkParallelLimit checks if promoting this task would exceed the parallel task limit.
+// Returns true if the task can proceed, false otherwise.
+func (s *Scheduler) checkParallelLimit(ctx context.Context, task *store.TaskMessage, rolloutCounts map[int64]int) (bool, error) {
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get plan")
+ }
+ if plan == nil {
+ return false, errors.Errorf("plan %v not found", task.PlanID)
+ }
+
+ project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &plan.ProjectID})
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get project")
+ }
+ if project == nil {
+ return false, errors.Errorf("project %v not found", plan.ProjectID)
+ }
+
+ maxParallel := int(project.Setting.GetParallelTasksPerRollout())
+ if maxParallel <= 0 {
+ // No limit
+ return true, nil
+ }
+
+ // Count current AVAILABLE + RUNNING for this rollout
+ activeTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ PlanUID: &task.PlanID,
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE, storepb.TaskRun_RUNNING},
+ })
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to list active task runs")
+ }
+
+ currentCount := len(activeTaskRuns) + rolloutCounts[task.PlanID]
+ return currentCount < maxParallel, nil
+}
+
// runPendingTaskRunsScheduler runs in a separate goroutine to schedule pending task runs.
func (s *Scheduler) runPendingTaskRunsScheduler(ctx context.Context, wg *sync.WaitGroup) {
ticker := time.NewTicker(taskSchedulerInterval)
@@ -45,71 +127,112 @@ func (s *Scheduler) schedulePendingTaskRuns(ctx context.Context) error {
if err != nil {
return errors.Wrapf(err, "failed to list pending tasks")
}
+
+ // Track what we've promoted this round to avoid over-committing
+ availableDBs := map[string]bool{} // database key -> has AVAILABLE this round
+ rolloutCounts := map[int64]int{} // plan_id -> count promoted this round
+
for _, taskRun := range taskRuns {
- if err := s.schedulePendingTaskRun(ctx, taskRun); err != nil {
+ promoted, err := s.schedulePendingTaskRun(ctx, taskRun, availableDBs, rolloutCounts)
+ if err != nil {
slog.Error("failed to schedule pending task run", log.BBError(err))
+ continue
+ }
+ if promoted {
+ task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
+ if err != nil {
+ slog.Error("failed to get task after promotion", log.BBError(err))
+ continue
+ }
+ if task.DatabaseName != nil && isSequentialTask(task) {
+ availableDBs[getDatabaseKey(task.InstanceID, *task.DatabaseName)] = true
+ }
+ rolloutCounts[task.PlanID]++
}
}
return nil
}
-func (s *Scheduler) schedulePendingTaskRun(ctx context.Context, taskRun *store.TaskRunMessage) error {
- // here, we move pending taskruns to running taskruns which means they are ready to be executed.
- // pending taskruns remain pending if
- // 1. taskRun.RunAt not met.
- // 2. for versioned tasks, there are other versioned tasks on the same database with
- // a smaller version not finished yet. we need to wait for those first.
+func (s *Scheduler) schedulePendingTaskRun(ctx context.Context, taskRun *store.TaskRunMessage, availableDBs map[string]bool, rolloutCounts map[int64]int) (bool, error) {
task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
if err != nil {
- return errors.Wrapf(err, "failed to get task")
+ return false, errors.Wrapf(err, "failed to get task")
}
+
+ // Check 1: RunAt time
if taskRun.RunAt != nil && time.Now().Before(*taskRun.RunAt) {
- return nil
+ return false, nil
}
- doSchedule, err := func() (bool, error) {
- if task.DatabaseName == nil {
- return true, nil
- }
-
+ // Check 2: Version ordering (blocking tasks with smaller versions)
+ if task.DatabaseName != nil {
schemaVersion := task.Payload.GetSchemaVersion()
- if schemaVersion == "" {
- return true, nil
+ if schemaVersion != "" {
+ maybeTaskID, err := s.store.FindBlockingTaskByVersion(ctx, task.PlanID, task.InstanceID, *task.DatabaseName, schemaVersion)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to find blocking versioned tasks")
+ }
+ if maybeTaskID != nil {
+ s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
+ ReportTime: timestamppb.Now(),
+ WaitingCause: &storepb.SchedulerInfo_WaitingCause{
+ Cause: &storepb.SchedulerInfo_WaitingCause_TaskUid{
+ TaskUid: int32(*maybeTaskID),
+ },
+ },
+ })
+ return false, nil
+ }
}
+ }
- maybeTaskID, err := s.store.FindBlockingTaskByVersion(ctx, task.PlanID, task.InstanceID, *task.DatabaseName, schemaVersion)
- if err != nil {
- return false, errors.Wrapf(err, "failed to find blocking versioned tasks")
- }
- if maybeTaskID != nil {
+ // Check 3: Database mutual exclusion (for sequential tasks)
+ canProceed, blockingTaskID, err := s.checkDatabaseMutualExclusion(ctx, task, availableDBs)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to check database mutual exclusion")
+ }
+ if !canProceed {
+ if blockingTaskID != nil {
s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
ReportTime: timestamppb.Now(),
WaitingCause: &storepb.SchedulerInfo_WaitingCause{
Cause: &storepb.SchedulerInfo_WaitingCause_TaskUid{
- TaskUid: int32(*maybeTaskID),
+ TaskUid: int32(*blockingTaskID),
},
},
})
- return false, nil
}
- s.stateCfg.TaskRunSchedulerInfo.Delete(taskRun.ID)
- return true, nil
- }()
+ return false, nil
+ }
+
+ // Check 4: Parallel task limit per rollout
+ withinLimit, err := s.checkParallelLimit(ctx, task, rolloutCounts)
if err != nil {
- return errors.Wrapf(err, "failed to check blocking versioned tasks")
+ return false, errors.Wrapf(err, "failed to check parallel limit")
}
- if !doSchedule {
- return nil
+ if !withinLimit {
+ s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
+ ReportTime: timestamppb.Now(),
+ WaitingCause: &storepb.SchedulerInfo_WaitingCause{
+ Cause: &storepb.SchedulerInfo_WaitingCause_ParallelTasksLimit{
+ ParallelTasksLimit: true,
+ },
+ },
+ })
+ return false, nil
}
+ // All checks passed - promote to AVAILABLE
+ s.stateCfg.TaskRunSchedulerInfo.Delete(taskRun.ID)
if _, err := s.store.UpdateTaskRunStatus(ctx, &store.TaskRunStatusPatch{
ID: taskRun.ID,
Updater: common.SystemBotEmail,
- Status: storepb.TaskRun_RUNNING,
+ Status: storepb.TaskRun_AVAILABLE,
}); err != nil {
- return errors.Wrapf(err, "failed to update task run status to running")
+ return false, errors.Wrapf(err, "failed to update task run status to available")
}
+
s.store.CreateTaskRunLogS(ctx, taskRun.ID, time.Now(), s.profile.DeployID, &storepb.TaskRunLog{
Type: storepb.TaskRunLog_TASK_RUN_STATUS_UPDATE,
TaskRunStatusUpdate: &storepb.TaskRunLog_TaskRunStatusUpdate{
@@ -117,13 +240,11 @@ func (s *Scheduler) schedulePendingTaskRun(ctx context.Context, taskRun *store.T
},
})
- // Tickle the running scheduler to immediately pick up this newly RUNNING task
- // This prevents delays when user clicks "Run stage" in the UI
+ // Tickle the running scheduler
select {
case s.stateCfg.TaskRunTickleChan <- 0:
default:
- // Channel is full, running scheduler will pick it up on next tick
}
- return nil
+ return true, nil
}
diff --git a/backend/runner/taskrun/running_scheduler.go b/backend/runner/taskrun/running_scheduler.go
index 43ebd5799a..a8f3354f3d 100644
--- a/backend/runner/taskrun/running_scheduler.go
+++ b/backend/runner/taskrun/running_scheduler.go
@@ -4,13 +4,11 @@ import (
"context"
"fmt"
"log/slog"
- "strconv"
"sync"
"time"
"github.com/pkg/errors"
"google.golang.org/protobuf/encoding/protojson"
- "google.golang.org/protobuf/types/known/timestamppb"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
@@ -47,84 +45,63 @@ func (s *Scheduler) runRunningTaskRunsScheduler(ctx context.Context, wg *sync.Wa
}
func (s *Scheduler) scheduleRunningTaskRuns(ctx context.Context) error {
- taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
- Status: &[]storepb.TaskRun_Status{storepb.TaskRun_RUNNING},
+ // Query AVAILABLE tasks (ready for execution)
+ availableTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE},
})
if err != nil {
- return errors.Wrapf(err, "failed to list pending tasks")
+ return errors.Wrapf(err, "failed to list available task runs")
}
- // Find the minimum task ID for each database.
- // We only run the first (i.e. which has the minimum task ID) task for each database.
- // 1. For ddl tasks, we run them one by one to get a sane schema dump and thus diff.
- // 2. For versioned tasks, this is our last resort to determine the order for tasks with the same version. We don't want to run them in parallel.
- // 2.1. Rollout 1 tasks will be run before rollout 2 tasks. Where, rollout 1 tasks are created before rollout 2 tasks.
- minTaskIDForDatabase := map[string]int{}
- for _, taskRun := range taskRuns {
- task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
- if err != nil {
- slog.Error("failed to get task", slog.Int("task id", taskRun.TaskUID), log.BBError(err))
- continue
- }
- if task.DatabaseName == nil {
- continue
+ for _, taskRun := range availableTaskRuns {
+ if err := s.claimAndExecuteTaskRun(ctx, taskRun); err != nil {
+ slog.Error("failed to claim and execute task run", log.BBError(err))
}
+ }
- databaseKey := getDatabaseKey(task.InstanceID, *task.DatabaseName)
- if isSequentialTask(task) {
- if _, ok := minTaskIDForDatabase[databaseKey]; !ok {
- minTaskIDForDatabase[databaseKey] = task.ID
- } else if minTaskIDForDatabase[databaseKey] > task.ID {
- minTaskIDForDatabase[databaseKey] = task.ID
- }
- }
+ // Also re-execute orphaned RUNNING tasks (for restart recovery)
+ runningTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_RUNNING},
+ })
+ if err != nil {
+ return errors.Wrapf(err, "failed to list running task runs")
}
- for _, taskRun := range taskRuns {
- if err := s.scheduleRunningTaskRun(ctx, taskRun, minTaskIDForDatabase); err != nil {
- slog.Error("failed to schedule running task run", log.BBError(err))
+ for _, taskRun := range runningTaskRuns {
+ // Skip if already executing in this instance
+ if _, ok := s.stateCfg.RunningTaskRuns.Load(taskRun.ID); ok {
+ continue
+ }
+ // Re-execute orphaned RUNNING task
+ if err := s.executeTaskRun(ctx, taskRun); err != nil {
+ slog.Error("failed to re-execute orphaned task run", log.BBError(err))
}
}
return nil
}
-func (s *Scheduler) scheduleRunningTaskRun(ctx context.Context, taskRun *store.TaskRunMessage, minTaskIDForDatabase map[string]int) error {
- // Skip the task run if it is already executing.
- if _, ok := s.stateCfg.RunningTaskRuns.Load(taskRun.ID); ok {
+// claimAndExecuteTaskRun attempts to atomically claim an AVAILABLE task and execute it.
+func (s *Scheduler) claimAndExecuteTaskRun(ctx context.Context, taskRun *store.TaskRunMessage) error {
+ // Optimistic locking: attempt to claim by updating AVAILABLE -> RUNNING
+ claimed, err := s.store.ClaimAvailableTaskRun(ctx, taskRun.ID)
+ if err != nil {
+ return errors.Wrapf(err, "failed to claim task run")
+ }
+ if !claimed {
+ // Another instance claimed it
return nil
}
+
+ return s.executeTaskRun(ctx, taskRun)
+}
+
+// executeTaskRun executes a task run that is already in RUNNING status.
+func (s *Scheduler) executeTaskRun(ctx context.Context, taskRun *store.TaskRunMessage) error {
task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
if err != nil {
return errors.Wrapf(err, "failed to get task")
}
- if task.DatabaseName != nil && isSequentialTask(task) {
- // Skip the task run if there is an ongoing migration on the database.
- if taskUIDAny, ok := s.stateCfg.RunningDatabaseMigration.Load(getDatabaseKey(task.InstanceID, *task.DatabaseName)); ok {
- if taskUID, ok := taskUIDAny.(int); ok {
- s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
- ReportTime: timestamppb.Now(),
- WaitingCause: &storepb.SchedulerInfo_WaitingCause{
- Cause: &storepb.SchedulerInfo_WaitingCause_TaskUid{
- TaskUid: int32(taskUID),
- },
- },
- })
- }
- return nil
- }
- if taskUID := minTaskIDForDatabase[getDatabaseKey(task.InstanceID, *task.DatabaseName)]; taskUID != task.ID {
- s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
- ReportTime: timestamppb.Now(),
- WaitingCause: &storepb.SchedulerInfo_WaitingCause{
- Cause: &storepb.SchedulerInfo_WaitingCause_TaskUid{
- TaskUid: int32(taskUID),
- },
- },
- })
- return nil
- }
- }
instance, err := s.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})
if err != nil {
@@ -136,66 +113,19 @@ func (s *Scheduler) scheduleRunningTaskRun(ctx context.Context, taskRun *store.T
if instance.Deleted {
return errors.Errorf("instance %v is deleted", task.InstanceID)
}
+
executor, ok := s.executorMap[task.Type]
if !ok {
return errors.Errorf("executor not found for task type: %v", task.Type)
}
- // Check max running task runs per rollout.
- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})
- if err != nil {
- return errors.Wrapf(err, "failed to get plan")
- }
- if plan == nil {
- return errors.Errorf("plan %v not found", task.PlanID)
- }
-
- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &plan.ProjectID})
- if err != nil {
- return errors.Wrapf(err, "failed to get project")
- }
- if project == nil {
- return errors.Errorf("project %v not found", plan.ProjectID)
- }
-
- planID := strconv.FormatInt(plan.UID, 10)
- maxRunningTaskRunsPerRollout := int(project.Setting.GetParallelTasksPerRollout())
- if maxRunningTaskRunsPerRollout <= 0 {
- maxRunningTaskRunsPerRollout = defaultRolloutMaxRunningTaskRuns
- }
- if s.stateCfg.RolloutOutstandingTasks.Increment(planID+"/"+task.InstanceID, maxRunningTaskRunsPerRollout) {
- s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
- ReportTime: timestamppb.Now(),
- WaitingCause: &storepb.SchedulerInfo_WaitingCause{
- Cause: &storepb.SchedulerInfo_WaitingCause_ParallelTasksLimit{
- ParallelTasksLimit: true,
- },
- },
- })
- return nil
- }
-
- // decrement the connection count if we return below.
- revertRolloutConnectionsIncrement := true
- defer func() {
- if revertRolloutConnectionsIncrement {
- s.stateCfg.RolloutOutstandingTasks.Decrement(planID + "/" + task.InstanceID)
- }
- }()
-
- // Set taskrun StartAt when it's about to run.
- // So that the waiting time is not taken into account of the actual execution time.
+ // Update started_at
if err := s.store.UpdateTaskRunStartAt(ctx, taskRun.ID); err != nil {
return errors.Wrapf(err, "failed to update task run start at")
}
- // We MUST NOT return early below this line.
- // If we do want to return early, we must revert related states.
- s.stateCfg.TaskRunSchedulerInfo.Delete(taskRun.ID)
+ // Register as running
s.stateCfg.RunningTaskRuns.Store(taskRun.ID, true)
- if task.DatabaseName != nil {
- s.stateCfg.RunningDatabaseMigration.Store(getDatabaseKey(task.InstanceID, *task.DatabaseName), task.ID)
- }
s.store.CreateTaskRunLogS(ctx, taskRun.ID, time.Now(), s.profile.DeployID, &storepb.TaskRunLog{
Type: storepb.TaskRunLog_TASK_RUN_STATUS_UPDATE,
@@ -204,9 +134,6 @@ func (s *Scheduler) scheduleRunningTaskRun(ctx context.Context, taskRun *store.T
},
})
- // We are sure that we will run the task.
- // The executor will decrement them.
- revertRolloutConnectionsIncrement = false
go s.runTaskRunOnce(ctx, taskRun, task, executor)
return nil
}
@@ -222,12 +149,7 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRun *store.TaskRunMe
}
}()
defer func() {
- // We don't need to do s.stateCfg.RunningTaskRuns.Delete(taskRun.ID) to avoid race condition.
s.stateCfg.RunningTaskRunsCancelFunc.Delete(taskRun.ID)
- if task.DatabaseName != nil {
- s.stateCfg.RunningDatabaseMigration.Delete(getDatabaseKey(task.InstanceID, *task.DatabaseName))
- }
- s.stateCfg.RolloutOutstandingTasks.Decrement(strconv.FormatInt(task.PlanID, 10) + "/" + task.InstanceID)
}()
driverCtx, cancel := context.WithCancel(ctx)
diff --git a/backend/runner/taskrun/scheduler.go b/backend/runner/taskrun/scheduler.go
index 1cf6fef4fc..90d4049f1a 100644
--- a/backend/runner/taskrun/scheduler.go
+++ b/backend/runner/taskrun/scheduler.go
@@ -20,10 +20,6 @@ const (
taskSchedulerInterval = 5 * time.Second
)
-// defaultRolloutMaxRunningTaskRuns is the maximum number of running tasks per rollout.
-// No limit by default.
-const defaultRolloutMaxRunningTaskRuns = 0
-
// Scheduler is the scheduler for task run.
type Scheduler struct {
store *store.Store
diff --git a/backend/store/task_run.go b/backend/store/task_run.go
index e608d1c578..1967da416e 100644
--- a/backend/store/task_run.go
+++ b/backend/store/task_run.go
@@ -221,6 +221,33 @@ func (s *Store) UpdateTaskRunStatus(ctx context.Context, patch *TaskRunStatusPat
return taskRun, nil
}
+// ClaimAvailableTaskRun attempts to atomically claim an AVAILABLE task run by updating it to RUNNING.
+// Returns true if the claim succeeded, false if another process claimed it first.
+func (s *Store) ClaimAvailableTaskRun(ctx context.Context, taskRunID int) (bool, error) {
+ q := qb.Q().Space(`
+ UPDATE task_run
+ SET status = ?, updated_at = now()
+ WHERE id = ? AND status = ?
+ `, storepb.TaskRun_RUNNING.String(), taskRunID, storepb.TaskRun_AVAILABLE.String())
+
+ query, args, err := q.ToSQL()
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to build sql")
+ }
+
+ result, err := s.GetDB().ExecContext(ctx, query, args...)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to claim task run")
+ }
+
+ rowsAffected, err := result.RowsAffected()
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get rows affected")
+ }
+
+ return rowsAffected == 1, nil
+}
+
func (s *Store) UpdateTaskRunStartAt(ctx context.Context, taskRunID int) error {
// Get the pipeline ID for cache invalidation
q := qb.Q().Space(`
@@ -297,11 +324,11 @@ func (s *Store) CreatePendingTaskRuns(ctx context.Context, creator string, creat
WHERE NOT EXISTS (
SELECT 1 FROM task_run
WHERE task_run.task_id = tasks.task_id
- AND task_run.status IN (?, ?, ?)
+ AND task_run.status IN (?, ?, ?, ?)
)
ON CONFLICT (task_id, attempt) DO NOTHING
`, creator, storepb.TaskRun_PENDING.String(), taskUIDs, sheetSha256s, runAts,
- storepb.TaskRun_PENDING.String(), storepb.TaskRun_RUNNING.String(), storepb.TaskRun_DONE.String())
+ storepb.TaskRun_PENDING.String(), storepb.TaskRun_AVAILABLE.String(), storepb.TaskRun_RUNNING.String(), storepb.TaskRun_DONE.String())
query, args, err := q.ToSQL()
if err != nil {
diff --git a/docs/plans/2025-12-30-task-scheduler-available-status-design.md b/docs/plans/2025-12-30-task-scheduler-available-status-design.md
new file mode 100644
index 0000000000..b7611c40f6
--- /dev/null
+++ b/docs/plans/2025-12-30-task-scheduler-available-status-design.md
@@ -0,0 +1,224 @@
+# Task Scheduler AVAILABLE Status Refactoring
+
+## Overview
+
+Refactor the task scheduler to introduce a dedicated `AVAILABLE` status between `PENDING` and `RUNNING`. This separates "ready to execute" from "actively executing", preparing the foundation for High Availability (HA) scheduler instances.
+
+## Status Model
+
+### New Status Flow
+
+```
+PENDING → AVAILABLE → RUNNING → DONE/FAILED/CANCELED
+```
+
+### Status Definitions
+
+| Status | Meaning |
+|--------|---------|
+| PENDING | Waiting for constraints: RunAt time, version ordering, database locks, parallel limits |
+| AVAILABLE | All constraints satisfied, ready for immediate execution by any scheduler instance |
+| RUNNING | Actively executing |
+| DONE/FAILED/CANCELED | Terminal states |
+
+### Transition Rules
+
+- `PENDING → AVAILABLE`: pending_scheduler promotes when ALL gating checks pass
+- `AVAILABLE → RUNNING`: running_scheduler atomically claims via optimistic locking
+- `RUNNING → terminal`: running_scheduler updates after execution completes
+
+## Scheduler Architecture
+
+### pending_scheduler.go (Enhanced)
+
+Responsibility: PENDING → AVAILABLE transitions with all gating logic.
+
+```
+Every 5 seconds:
+1. Query task_runs WHERE status = 'PENDING'
+2. Track in-memory for this round:
+ - availableDBs: databases already promoted this round
+ - rolloutCounts: tasks promoted per rollout this round
+3. For each pending task:
+ a. Check RunAt time
+ b. Check version ordering (no smaller versions pending/available/running on same DB)
+ c. Check database mutual exclusion (sequential tasks only):
+ - Skip if availableDBs[database_id] is set
+ - Query: no RUNNING or AVAILABLE on same database
+ d. Check parallel limit:
+ - currentCount = COUNT(*) WHERE rollout_id = ? AND status IN ('RUNNING', 'AVAILABLE')
+ - Skip if currentCount + rolloutCounts[rollout_id] >= limit
+ e. If all pass:
+ - UPDATE status = 'AVAILABLE'
+ - availableDBs[database_id] = true
+ - rolloutCounts[rollout_id]++
+```
+
+### running_scheduler.go (Simplified)
+
+Responsibility: Claim AVAILABLE tasks and execute. No gating logic.
+
+```
+Every 5 seconds (or when tickled):
+1. Query task_runs WHERE status = 'AVAILABLE'
+2. For each available task:
+ a. Attempt atomic claim:
+ UPDATE task_run SET status = 'RUNNING', started_at = NOW()
+ WHERE id = ? AND status = 'AVAILABLE'
+ b. If claim succeeds (rows affected = 1):
+ - Spawn goroutine to execute task
+ c. If claim fails (rows affected = 0):
+ - Another instance claimed it, skip
+3. Re-execute orphaned RUNNING tasks on startup (maintains current behavior)
+```
+
+### Key Simplification
+
+running_scheduler no longer maintains:
+- `RunningDatabaseMigration` map
+- Database mutual exclusion checks
+- Parallel limit checks
+- Version ordering checks
+
+All gating logic is centralized in pending_scheduler.
+
+## Gating Logic Details
+
+### Checks Performed (PENDING → AVAILABLE)
+
+1. **RunAt time**: `task_run.run_at <= NOW()`
+2. **Version ordering**: No blocking tasks with smaller versions on same database in PENDING/AVAILABLE/RUNNING
+3. **Database mutual exclusion** (for sequential task types DDL/SDL):
+ - No RUNNING or AVAILABLE tasks on same database
+ - Plus in-memory tracking within the loop
+4. **Parallel task limit per rollout**:
+ - `COUNT(*) WHERE rollout_id = ? AND status IN ('RUNNING', 'AVAILABLE') < limit`
+ - Plus in-memory tracking within the loop
+
+### In-Memory Loop Tracking
+
+Within a single pending_scheduler iteration, track locally:
+
+```go
+availableDBs := map[int]bool{} // database_id -> has AVAILABLE this round
+rolloutCounts := map[int]int{} // rollout_id -> count promoted this round
+```
+
+This prevents marking multiple tasks AVAILABLE for the same database or exceeding rollout limits within one loop.
+
+### Future HA Consideration
+
+For HA with multiple scheduler instances, atomic check-and-update may be needed:
+
+```sql
+UPDATE task_run
+SET status = 'AVAILABLE'
+WHERE id = ?
+ AND status = 'PENDING'
+ AND (SELECT COUNT(*) FROM task_run
+ WHERE rollout_id = ? AND status IN ('RUNNING', 'AVAILABLE')) < ?
+```
+
+This is future work; current implementation assumes single pending_scheduler instance.
+
+## Database Schema Changes
+
+### Migration
+
+```sql
+-- Add AVAILABLE to CHECK constraint
+ALTER TABLE task_run
+DROP CONSTRAINT task_run_status_check,
+ADD CONSTRAINT task_run_status_check
+CHECK (status IN ('PENDING', 'AVAILABLE', 'RUNNING', 'DONE', 'FAILED', 'CANCELED'));
+
+-- Update partial index for active statuses
+DROP INDEX idx_task_run_active_status_id;
+CREATE INDEX idx_task_run_active_status_id ON task_run (status, id)
+WHERE status IN ('PENDING', 'AVAILABLE', 'RUNNING');
+```
+
+### Proto Changes
+
+`proto/store/task_run.proto`:
+
+```proto
+enum Status {
+ STATUS_UNSPECIFIED = 0;
+ PENDING = 1;
+ RUNNING = 2;
+ DONE = 3;
+ FAILED = 4;
+ CANCELED = 5;
+ NOT_STARTED = 6;
+ SKIPPED = 7;
+ AVAILABLE = 8; // NEW: Ready for immediate execution
+}
+```
+
+## Frontend Changes
+
+### Status Classification
+
+`frontend/src/components/RolloutV1/components/utils/taskStatus.ts`:
+
+```typescript
+const ACTIONABLE_STATUSES = [
+ "NOT_STARTED", "PENDING", "AVAILABLE", "RUNNING", "FAILED", "CANCELED"
+];
+
+const TERMINAL_STATUSES = ["DONE", "SKIPPED"];
+```
+
+### Visual Representation
+
+- AVAILABLE gets distinct color/icon (ready indicator)
+- Status display order: NOT_STARTED → PENDING → AVAILABLE → RUNNING → terminal
+
+### Locale Strings
+
+Add translations for "Available" status in `frontend/src/locales/`.
+
+### SchedulerInfo Display
+
+- Only show waiting causes for PENDING tasks
+- AVAILABLE tasks have no waiting info (they're ready)
+
+## Implementation Plan
+
+### Files to Modify
+
+| File | Changes |
+|------|---------|
+| `proto/store/task_run.proto` | Add `AVAILABLE = 8` to Status enum |
+| `backend/migrator/migration/XXX/` | New migration for schema changes |
+| `backend/migrator/migration/LATEST.sql` | Update CHECK constraint and index |
+| `backend/runner/taskrun/pending_scheduler.go` | Add all gating logic, promote to AVAILABLE |
+| `backend/runner/taskrun/running_scheduler.go` | Simplify to: claim AVAILABLE → execute |
+| `backend/store/task_run.go` | Add AVAILABLE constant, update queries |
+| `frontend/src/components/RolloutV1/.../taskStatus.ts` | Add AVAILABLE to actionable statuses |
+| `frontend/src/locales/*.json` | Add "available" translation |
+| Frontend status display components | Add AVAILABLE visual styling |
+
+### Implementation Order
+
+1. Proto + generate
+2. Database migration
+3. Store layer updates
+4. pending_scheduler (add gating, PENDING → AVAILABLE)
+5. running_scheduler (simplify to claim + execute)
+6. Frontend status handling
+7. Testing
+
+### Compatibility
+
+No breaking changes. Existing PENDING/RUNNING tasks continue to work. New tasks will use the AVAILABLE intermediate state.
+
+## HA Preparation
+
+This refactoring prepares for HA by:
+
+1. **Clear state separation**: AVAILABLE = ready, RUNNING = executing
+2. **Optimistic locking**: Multiple running_scheduler instances can safely compete for AVAILABLE tasks
+3. **Database as source of truth**: No in-memory state coordination needed between instances
+4. **Future lease-based claiming**: Status model supports adding claimed_by/expiry fields later
diff --git a/docs/plans/2025-12-30-task-scheduler-available-status.md b/docs/plans/2025-12-30-task-scheduler-available-status.md
new file mode 100644
index 0000000000..aad57cfc0a
--- /dev/null
+++ b/docs/plans/2025-12-30-task-scheduler-available-status.md
@@ -0,0 +1,829 @@
+# Task Scheduler AVAILABLE Status Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Add AVAILABLE status to task runs, separating "ready to execute" from "actively executing" to prepare for HA.
+
+**Architecture:** PENDING → AVAILABLE → RUNNING flow. pending_scheduler handles all gating (RunAt, version ordering, database locks, parallel limits) and promotes to AVAILABLE. running_scheduler simply claims AVAILABLE tasks and executes.
+
+**Tech Stack:** Go, PostgreSQL, Protocol Buffers, TypeScript/Vue
+
+---
+
+## Task 1: Add AVAILABLE to Proto
+
+**Files:**
+- Modify: `proto/store/store/task_run.proto:13-29`
+
+**Step 1: Add AVAILABLE enum value**
+
+In `proto/store/store/task_run.proto`, add AVAILABLE after SKIPPED:
+
+```proto
+ enum Status {
+ STATUS_UNSPECIFIED = 0;
+ // Task run is queued and waiting to execute.
+ PENDING = 1;
+ // Task run is currently executing.
+ RUNNING = 2;
+ // Task run completed successfully.
+ DONE = 3;
+ // Task run encountered an error and failed.
+ FAILED = 4;
+ // Task run was canceled by user or system.
+ CANCELED = 5;
+ // Task run has not started yet.
+ NOT_STARTED = 6;
+ // Task run was skipped and will not execute.
+ SKIPPED = 7;
+ // Task run is ready for immediate execution.
+ AVAILABLE = 8;
+ }
+```
+
+**Step 2: Generate proto files**
+
+Run:
+```bash
+cd proto && buf generate
+```
+
+Expected: New generated files in `backend/generated-go/` and `frontend/src/types/proto-es/`
+
+**Step 3: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "proto: add AVAILABLE status to TaskRun"
+```
+
+---
+
+## Task 2: Database Migration
+
+**Files:**
+- Create: `backend/migrator/migration/3.14/0014##task_run_available_status.sql`
+- Modify: `backend/migrator/migration/LATEST.sql:257,273`
+- Modify: `backend/migrator/migrator_test.go` (update TestLatestVersion)
+
+**Step 1: Create migration file**
+
+Create `backend/migrator/migration/3.14/0014##task_run_available_status.sql`:
+
+```sql
+-- Add AVAILABLE status to task_run CHECK constraint
+ALTER TABLE task_run DROP CONSTRAINT task_run_status_check;
+ALTER TABLE task_run ADD CONSTRAINT task_run_status_check
+ CHECK (status IN ('PENDING', 'AVAILABLE', 'RUNNING', 'DONE', 'FAILED', 'CANCELED'));
+
+-- Update partial index to include AVAILABLE
+DROP INDEX idx_task_run_active_status_id;
+CREATE INDEX idx_task_run_active_status_id ON task_run(status, id)
+ WHERE status IN ('PENDING', 'AVAILABLE', 'RUNNING');
+```
+
+**Step 2: Update LATEST.sql**
+
+In `backend/migrator/migration/LATEST.sql`, line 257, change:
+
+```sql
+status text NOT NULL CHECK (status IN ('PENDING', 'AVAILABLE', 'RUNNING', 'DONE', 'FAILED', 'CANCELED')),
+```
+
+And line 273, change:
+
+```sql
+CREATE INDEX idx_task_run_active_status_id ON task_run(status, id) WHERE status IN ('PENDING', 'AVAILABLE', 'RUNNING');
+```
+
+**Step 3: Update migrator test**
+
+In `backend/migrator/migrator_test.go`, update TestLatestVersion to expect:
+- Version: `3.14.14`
+- Path: `migration/3.14/0014##task_run_available_status.sql`
+
+**Step 4: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "migration: add AVAILABLE status to task_run"
+```
+
+---
+
+## Task 3: Update Store Layer
+
+**Files:**
+- Modify: `backend/store/task_run.go:297-304`
+
+**Step 1: Update CreatePendingTaskRuns to check AVAILABLE**
+
+In `backend/store/task_run.go`, the `CreatePendingTaskRuns` function checks for existing active task runs. Update line 303-304 to include AVAILABLE:
+
+```go
+ storepb.TaskRun_PENDING.String(), storepb.TaskRun_AVAILABLE.String(), storepb.TaskRun_RUNNING.String(), storepb.TaskRun_DONE.String())
+```
+
+**Step 2: Run tests**
+
+```bash
+go test -v -count=1 github.com/bytebase/bytebase/backend/store -run ^TestTaskRun
+```
+
+**Step 3: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "store: include AVAILABLE in active task run check"
+```
+
+---
+
+## Task 4: Update FindBlockingTaskByVersion
+
+**Files:**
+- Modify: `backend/store/task.go:107-160`
+
+**Step 1: Update query to check for AVAILABLE status**
+
+The `FindBlockingTaskByVersion` function checks if there are blocking tasks. It currently considers any task whose latest status is not DONE as blocking. This is correct - AVAILABLE tasks should also block.
+
+No change needed - the query already blocks on anything that's not DONE.
+
+**Step 2: Verify logic**
+
+Run:
+```bash
+go build ./backend/...
+```
+
+---
+
+## Task 5: Refactor pending_scheduler - Add Gating Logic
+
+**Files:**
+- Modify: `backend/runner/taskrun/pending_scheduler.go`
+
+**Step 1: Add helper function for database mutual exclusion check**
+
+Add after line 16:
+
+```go
+// checkDatabaseMutualExclusion checks if there's already an AVAILABLE or RUNNING task on the database.
+// Returns true if the task can proceed (no conflict), false otherwise.
+func (s *Scheduler) checkDatabaseMutualExclusion(ctx context.Context, task *store.TaskMessage, availableDBs map[string]bool) (bool, *int, error) {
+ if task.DatabaseName == nil {
+ return true, nil, nil
+ }
+ if !isSequentialTask(task) {
+ return true, nil, nil
+ }
+
+ databaseKey := getDatabaseKey(task.InstanceID, *task.DatabaseName)
+
+ // Check in-memory tracking first (tasks promoted this round)
+ if availableDBs[databaseKey] {
+ return false, nil, nil
+ }
+
+ // Check database for AVAILABLE or RUNNING tasks on the same database
+ activeTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE, storepb.TaskRun_RUNNING},
+ })
+ if err != nil {
+ return false, nil, errors.Wrapf(err, "failed to list active task runs")
+ }
+
+ for _, tr := range activeTaskRuns {
+ activeTask, err := s.store.GetTaskByID(ctx, tr.TaskUID)
+ if err != nil {
+ return false, nil, errors.Wrapf(err, "failed to get task")
+ }
+ if activeTask.DatabaseName == nil {
+ continue
+ }
+ if !isSequentialTask(activeTask) {
+ continue
+ }
+ if getDatabaseKey(activeTask.InstanceID, *activeTask.DatabaseName) == databaseKey {
+ return false, &activeTask.ID, nil
+ }
+ }
+
+ return true, nil, nil
+}
+```
+
+**Step 2: Add helper function for parallel limit check**
+
+Add after the previous function:
+
+```go
+// checkParallelLimit checks if promoting this task would exceed the parallel task limit.
+// Returns true if the task can proceed, false otherwise.
+func (s *Scheduler) checkParallelLimit(ctx context.Context, task *store.TaskMessage, rolloutCounts map[int64]int) (bool, error) {
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get plan")
+ }
+ if plan == nil {
+ return false, errors.Errorf("plan %v not found", task.PlanID)
+ }
+
+ project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &plan.ProjectID})
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get project")
+ }
+ if project == nil {
+ return false, errors.Errorf("project %v not found", plan.ProjectID)
+ }
+
+ maxParallel := int(project.Setting.GetParallelTasksPerRollout())
+ if maxParallel <= 0 {
+ // No limit
+ return true, nil
+ }
+
+ // Count current AVAILABLE + RUNNING for this rollout
+ activeTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ PlanUID: &task.PlanID,
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE, storepb.TaskRun_RUNNING},
+ })
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to list active task runs")
+ }
+
+ currentCount := len(activeTaskRuns) + rolloutCounts[task.PlanID]
+ return currentCount < maxParallel, nil
+}
+```
+
+**Step 3: Rewrite schedulePendingTaskRuns with in-memory tracking**
+
+Replace the `schedulePendingTaskRuns` function (lines 41-55):
+
+```go
+func (s *Scheduler) schedulePendingTaskRuns(ctx context.Context) error {
+ taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_PENDING},
+ })
+ if err != nil {
+ return errors.Wrapf(err, "failed to list pending tasks")
+ }
+
+ // Track what we've promoted this round to avoid over-committing
+ availableDBs := map[string]bool{} // database key -> has AVAILABLE this round
+ rolloutCounts := map[int64]int{} // plan_id -> count promoted this round
+
+ for _, taskRun := range taskRuns {
+ promoted, err := s.schedulePendingTaskRun(ctx, taskRun, availableDBs, rolloutCounts)
+ if err != nil {
+ slog.Error("failed to schedule pending task run", log.BBError(err))
+ continue
+ }
+ if promoted {
+ task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
+ if err != nil {
+ slog.Error("failed to get task after promotion", log.BBError(err))
+ continue
+ }
+ if task.DatabaseName != nil && isSequentialTask(task) {
+ availableDBs[getDatabaseKey(task.InstanceID, *task.DatabaseName)] = true
+ }
+ rolloutCounts[task.PlanID]++
+ }
+ }
+
+ return nil
+}
+```
+
+**Step 4: Rewrite schedulePendingTaskRun with all gating logic**
+
+Replace the `schedulePendingTaskRun` function (lines 57-129):
+
+```go
+func (s *Scheduler) schedulePendingTaskRun(ctx context.Context, taskRun *store.TaskRunMessage, availableDBs map[string]bool, rolloutCounts map[int64]int) (bool, error) {
+ task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get task")
+ }
+
+ // Check 1: RunAt time
+ if taskRun.RunAt != nil && time.Now().Before(*taskRun.RunAt) {
+ return false, nil
+ }
+
+ // Check 2: Version ordering (blocking tasks with smaller versions)
+ if task.DatabaseName != nil {
+ schemaVersion := task.Payload.GetSchemaVersion()
+ if schemaVersion != "" {
+ maybeTaskID, err := s.store.FindBlockingTaskByVersion(ctx, task.PlanID, task.InstanceID, *task.DatabaseName, schemaVersion)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to find blocking versioned tasks")
+ }
+ if maybeTaskID != nil {
+ s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
+ ReportTime: timestamppb.Now(),
+ WaitingCause: &storepb.SchedulerInfo_WaitingCause{
+ Cause: &storepb.SchedulerInfo_WaitingCause_TaskUid{
+ TaskUid: int32(*maybeTaskID),
+ },
+ },
+ })
+ return false, nil
+ }
+ }
+ }
+
+ // Check 3: Database mutual exclusion (for sequential tasks)
+ canProceed, blockingTaskID, err := s.checkDatabaseMutualExclusion(ctx, task, availableDBs)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to check database mutual exclusion")
+ }
+ if !canProceed {
+ if blockingTaskID != nil {
+ s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
+ ReportTime: timestamppb.Now(),
+ WaitingCause: &storepb.SchedulerInfo_WaitingCause{
+ Cause: &storepb.SchedulerInfo_WaitingCause_TaskUid{
+ TaskUid: int32(*blockingTaskID),
+ },
+ },
+ })
+ }
+ return false, nil
+ }
+
+ // Check 4: Parallel task limit per rollout
+ withinLimit, err := s.checkParallelLimit(ctx, task, rolloutCounts)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to check parallel limit")
+ }
+ if !withinLimit {
+ s.stateCfg.TaskRunSchedulerInfo.Store(taskRun.ID, &storepb.SchedulerInfo{
+ ReportTime: timestamppb.Now(),
+ WaitingCause: &storepb.SchedulerInfo_WaitingCause{
+ Cause: &storepb.SchedulerInfo_WaitingCause_ParallelTasksLimit{
+ ParallelTasksLimit: true,
+ },
+ },
+ })
+ return false, nil
+ }
+
+ // All checks passed - promote to AVAILABLE
+ s.stateCfg.TaskRunSchedulerInfo.Delete(taskRun.ID)
+ if _, err := s.store.UpdateTaskRunStatus(ctx, &store.TaskRunStatusPatch{
+ ID: taskRun.ID,
+ Updater: common.SystemBotEmail,
+ Status: storepb.TaskRun_AVAILABLE,
+ }); err != nil {
+ return false, errors.Wrapf(err, "failed to update task run status to available")
+ }
+
+ s.store.CreateTaskRunLogS(ctx, taskRun.ID, time.Now(), s.profile.DeployID, &storepb.TaskRunLog{
+ Type: storepb.TaskRunLog_TASK_RUN_STATUS_UPDATE,
+ TaskRunStatusUpdate: &storepb.TaskRunLog_TaskRunStatusUpdate{
+ Status: storepb.TaskRunLog_TaskRunStatusUpdate_RUNNING_WAITING,
+ },
+ })
+
+ // Tickle the running scheduler
+ select {
+ case s.stateCfg.TaskRunTickleChan <- 0:
+ default:
+ }
+
+ return true, nil
+}
+```
+
+**Step 5: Add import for isSequentialTask**
+
+The `isSequentialTask` function is in `running_scheduler.go`. Move it to a shared location or add the import. Since it's in the same package, no import needed.
+
+**Step 6: Build and verify**
+
+```bash
+go build ./backend/runner/taskrun/...
+```
+
+**Step 7: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "pending_scheduler: add all gating logic for PENDING->AVAILABLE"
+```
+
+---
+
+## Task 6: Simplify running_scheduler
+
+**Files:**
+- Modify: `backend/runner/taskrun/running_scheduler.go`
+
+**Step 1: Rewrite scheduleRunningTaskRuns to query AVAILABLE**
+
+Replace `scheduleRunningTaskRuns` function (lines 49-90):
+
+```go
+func (s *Scheduler) scheduleRunningTaskRuns(ctx context.Context) error {
+ // Query AVAILABLE tasks (ready for execution)
+ availableTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_AVAILABLE},
+ })
+ if err != nil {
+ return errors.Wrapf(err, "failed to list available task runs")
+ }
+
+ for _, taskRun := range availableTaskRuns {
+ if err := s.claimAndExecuteTaskRun(ctx, taskRun); err != nil {
+ slog.Error("failed to claim and execute task run", log.BBError(err))
+ }
+ }
+
+ // Also re-execute orphaned RUNNING tasks (for restart recovery)
+ runningTaskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
+ Status: &[]storepb.TaskRun_Status{storepb.TaskRun_RUNNING},
+ })
+ if err != nil {
+ return errors.Wrapf(err, "failed to list running task runs")
+ }
+
+ for _, taskRun := range runningTaskRuns {
+ // Skip if already executing in this instance
+ if _, ok := s.stateCfg.RunningTaskRuns.Load(taskRun.ID); ok {
+ continue
+ }
+ // Re-execute orphaned RUNNING task
+ if err := s.executeTaskRun(ctx, taskRun); err != nil {
+ slog.Error("failed to re-execute orphaned task run", log.BBError(err))
+ }
+ }
+
+ return nil
+}
+```
+
+**Step 2: Add claimAndExecuteTaskRun function**
+
+Add new function after scheduleRunningTaskRuns:
+
+```go
+// claimAndExecuteTaskRun attempts to atomically claim an AVAILABLE task and execute it.
+func (s *Scheduler) claimAndExecuteTaskRun(ctx context.Context, taskRun *store.TaskRunMessage) error {
+ // Optimistic locking: attempt to claim by updating AVAILABLE -> RUNNING
+ claimed, err := s.store.ClaimAvailableTaskRun(ctx, taskRun.ID)
+ if err != nil {
+ return errors.Wrapf(err, "failed to claim task run")
+ }
+ if !claimed {
+ // Another instance claimed it
+ return nil
+ }
+
+ return s.executeTaskRun(ctx, taskRun)
+}
+
+// executeTaskRun executes a task run that is already in RUNNING status.
+func (s *Scheduler) executeTaskRun(ctx context.Context, taskRun *store.TaskRunMessage) error {
+ task, err := s.store.GetTaskByID(ctx, taskRun.TaskUID)
+ if err != nil {
+ return errors.Wrapf(err, "failed to get task")
+ }
+
+ instance, err := s.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})
+ if err != nil {
+ return errors.Wrapf(err, "failed to get instance")
+ }
+ if instance.Deleted {
+ return errors.Errorf("instance %v is deleted", task.InstanceID)
+ }
+
+ executor, ok := s.executorMap[task.Type]
+ if !ok {
+ return errors.Errorf("executor not found for task type: %v", task.Type)
+ }
+
+ // Update started_at
+ if err := s.store.UpdateTaskRunStartAt(ctx, taskRun.ID); err != nil {
+ return errors.Wrapf(err, "failed to update task run start at")
+ }
+
+ // Register as running
+ s.stateCfg.RunningTaskRuns.Store(taskRun.ID, true)
+
+ s.store.CreateTaskRunLogS(ctx, taskRun.ID, time.Now(), s.profile.DeployID, &storepb.TaskRunLog{
+ Type: storepb.TaskRunLog_TASK_RUN_STATUS_UPDATE,
+ TaskRunStatusUpdate: &storepb.TaskRunLog_TaskRunStatusUpdate{
+ Status: storepb.TaskRunLog_TaskRunStatusUpdate_RUNNING_RUNNING,
+ },
+ })
+
+ go s.runTaskRunOnce(ctx, taskRun, task, executor)
+ return nil
+}
+```
+
+**Step 3: Remove old scheduleRunningTaskRun function**
+
+Delete the old `scheduleRunningTaskRun` function (lines 92-209) - it's replaced by the simplified logic above.
+
+**Step 4: Update runTaskRunOnce to remove in-memory state tracking**
+
+In `runTaskRunOnce` function, remove the database migration tracking since it's no longer needed. Update the defer block (lines 221-228):
+
+```go
+ defer func() {
+ s.stateCfg.RunningTaskRunsCancelFunc.Delete(taskRun.ID)
+ }()
+```
+
+Remove references to:
+- `s.stateCfg.RunningDatabaseMigration`
+- `s.stateCfg.RolloutOutstandingTasks`
+
+**Step 5: Build and verify**
+
+```bash
+go build ./backend/runner/taskrun/...
+```
+
+**Step 6: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "running_scheduler: simplify to claim AVAILABLE and execute"
+```
+
+---
+
+## Task 7: Add ClaimAvailableTaskRun to Store
+
+**Files:**
+- Modify: `backend/store/task_run.go`
+
+**Step 1: Add ClaimAvailableTaskRun function**
+
+Add after `UpdateTaskRunStatus`:
+
+```go
+// ClaimAvailableTaskRun attempts to atomically claim an AVAILABLE task run by updating it to RUNNING.
+// Returns true if the claim succeeded, false if another process claimed it first.
+func (s *Store) ClaimAvailableTaskRun(ctx context.Context, taskRunID int) (bool, error) {
+ q := qb.Q().Space(`
+ UPDATE task_run
+ SET status = ?, updated_at = now()
+ WHERE id = ? AND status = ?
+ `, storepb.TaskRun_RUNNING.String(), taskRunID, storepb.TaskRun_AVAILABLE.String())
+
+ query, args, err := q.ToSQL()
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to build sql")
+ }
+
+ result, err := s.GetDB().ExecContext(ctx, query, args...)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to claim task run")
+ }
+
+ rowsAffected, err := result.RowsAffected()
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get rows affected")
+ }
+
+ return rowsAffected == 1, nil
+}
+```
+
+**Step 2: Build and verify**
+
+```bash
+go build ./backend/store/...
+```
+
+**Step 3: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "store: add ClaimAvailableTaskRun for optimistic locking"
+```
+
+---
+
+## Task 8: Remove Unused State Fields
+
+**Files:**
+- Modify: `backend/component/state/state.go`
+
+**Step 1: Remove RunningDatabaseMigration field**
+
+This field is no longer needed since gating is done in pending_scheduler via DB queries. Remove line 22-23:
+
+```go
+ // RunningDatabaseMigration is the taskUID of the running migration on the database.
+ RunningDatabaseMigration sync.Map // map[databaseKey]taskUID
+```
+
+**Step 2: Remove RolloutOutstandingTasks field**
+
+This is no longer needed. Remove lines 31-32:
+
+```go
+ // RolloutOutstandingTasks is the maximum number of tasks per rollout.
+ RolloutOutstandingTasks *resourceLimiter
+```
+
+Also update the `New()` function to remove initialization.
+
+**Step 3: Build and verify all usages are removed**
+
+```bash
+go build ./backend/...
+```
+
+**Step 4: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "state: remove unused RunningDatabaseMigration and RolloutOutstandingTasks"
+```
+
+---
+
+## Task 9: Update BatchCancelTaskRuns
+
+**Files:**
+- Modify: `backend/store/task_run.go:369-389`
+
+**Step 1: Update to also cancel AVAILABLE tasks**
+
+The batch cancel should work for AVAILABLE tasks too. No change needed - it updates by ID regardless of status.
+
+**Step 2: Verify the rollout service uses correct statuses**
+
+Check `backend/api/v1/rollout_service.go` for any status checks that need AVAILABLE added.
+
+---
+
+## Task 10: Frontend - Add AVAILABLE Status
+
+**Files:**
+- Modify: `frontend/src/components/RolloutV1/constants/task.ts`
+- Modify: `frontend/src/components/Plan/constants/task.ts`
+- Modify: `frontend/src/components/RolloutV1/components/utils/taskStatus.ts`
+
+**Step 1: Update TASK_STATUS_FILTERS in RolloutV1**
+
+In `frontend/src/components/RolloutV1/constants/task.ts`:
+
+```typescript
+import { Task_Status } from "@/types/proto-es/v1/rollout_service_pb";
+
+export const TASK_STATUS_FILTERS: Task_Status[] = [
+ Task_Status.RUNNING,
+ Task_Status.AVAILABLE,
+ Task_Status.FAILED,
+ Task_Status.PENDING,
+ Task_Status.NOT_STARTED,
+ Task_Status.CANCELED,
+ Task_Status.DONE,
+ Task_Status.SKIPPED,
+];
+```
+
+**Step 2: Update TASK_STATUS_FILTERS in Plan**
+
+In `frontend/src/components/Plan/constants/task.ts`:
+
+```typescript
+import { Task_Status } from "@/types/proto-es/v1/rollout_service_pb";
+
+export const TASK_STATUS_FILTERS: Task_Status[] = [
+ Task_Status.RUNNING,
+ Task_Status.AVAILABLE,
+ Task_Status.FAILED,
+ Task_Status.PENDING,
+ Task_Status.NOT_STARTED,
+ Task_Status.CANCELED,
+ Task_Status.DONE,
+ Task_Status.SKIPPED,
+];
+```
+
+**Step 3: Update taskStatus.ts**
+
+In `frontend/src/components/RolloutV1/components/utils/taskStatus.ts`, add AVAILABLE to ACTIONABLE_STATUSES:
+
+```typescript
+const ACTIONABLE_STATUSES = new Set<Task_Status>([
+ Task_Status.NOT_STARTED,
+ Task_Status.PENDING,
+ Task_Status.AVAILABLE,
+ Task_Status.RUNNING,
+ Task_Status.FAILED,
+ Task_Status.CANCELED,
+]);
+```
+
+**Step 4: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "frontend: add AVAILABLE status to task filters"
+```
+
+---
+
+## Task 11: Frontend - Add Locale Strings
+
+**Files:**
+- Modify: `frontend/src/locales/en-US.json`
+- Modify: `frontend/src/locales/zh-CN.json`
+- Modify: `frontend/src/locales/ja-JP.json`
+- Modify: `frontend/src/locales/es-ES.json`
+
+**Step 1: Add translations**
+
+Find the task status section in each locale file and add AVAILABLE translation.
+
+For `en-US.json`:
+```json
+"available": "Available"
+```
+
+For `zh-CN.json`:
+```json
+"available": "就绪"
+```
+
+**Step 2: Commit**
+
+```bash
+but commit task-scheduler-available-status -m "i18n: add AVAILABLE status translations"
+```
+
+---
+
+## Task 12: Lint and Test
+
+**Step 1: Run Go linter**
+
+```bash
+golangci-lint run --allow-parallel-runners
+```
+
+Fix any issues. Run repeatedly until clean.
+
+**Step 2: Run frontend checks**
+
+```bash
+pnpm --dir frontend type-check
+pnpm --dir frontend biome:check
+```
+
+**Step 3: Run backend build**
+
+```bash
+go build -ldflags "-w -s" -p=16 -o ./bytebase-build/bytebase ./backend/bin/server/main.go
+```
+
+**Step 4: Commit any fixes**
+
+```bash
+but commit task-scheduler-available-status -m "chore: fix lint issues"
+```
+
+---
+
+## Task 13: Final Review and Push
+
+**Step 1: Review all changes**
+
+```bash
+but status
+git diff main...HEAD
+```
+
+**Step 2: Push branch**
+
+```bash
+but push task-scheduler-available-status
+```
+
+**Step 3: Create PR**
+
+```bash
+gh pr create --base main --head task-scheduler-available-status \
+ --title "refactor: add AVAILABLE status to task scheduler" \
+ --body "$(cat <<'EOF'
+## Summary
+- Add AVAILABLE status between PENDING and RUNNING for task runs
+- Centralize all gating logic in pending_scheduler (RunAt, version ordering, database locks, parallel limits)
+- Simplify running_scheduler to just claim AVAILABLE tasks and execute
+- Prepare foundation for HA with optimistic locking
+
+## Test plan
+- [ ] Verify PENDING tasks transition to AVAILABLE when all constraints are met
+- [ ] Verify AVAILABLE tasks are claimed and executed
+- [ ] Verify database mutual exclusion works (only one DDL/SDL per database)
+- [ ] Verify parallel limit is respected
+- [ ] Verify frontend shows AVAILABLE status correctly
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+EOF
+)"
+```
diff --git a/frontend/src/locales/en-US.json b/frontend/src/locales/en-US.json
index 2359d0d4e5..dd9d43c2a8 100644
--- a/frontend/src/locales/en-US.json
+++ b/frontend/src/locales/en-US.json
@@ -283,6 +283,7 @@
"view-change": "View change",
"status": {
"running": "Running",
+ "available": "Available",
"failed": "Failed",
"canceled": "Canceled",
"skipped": "Skipped",
diff --git a/frontend/src/locales/es-ES.json b/frontend/src/locales/es-ES.json
index bdf41662f0..54857c0c70 100644
--- a/frontend/src/locales/es-ES.json
+++ b/frontend/src/locales/es-ES.json
@@ -283,6 +283,7 @@
"view-change": "Ver cambio",
"status": {
"running": "Ejecutándose",
+ "available": "Disponible",
"failed": "Fallido",
"canceled": "Cancelado",
"skipped": "Omitido",
diff --git a/frontend/src/locales/ja-JP.json b/frontend/src/locales/ja-JP.json
index aa5bc5a284..a803093f41 100644
--- a/frontend/src/locales/ja-JP.json
+++ b/frontend/src/locales/ja-JP.json
@@ -283,6 +283,7 @@
"view-change": "変更を表示する",
"status": {
"running": "ランニング",
+ "available": "利用可能",
"failed": "失敗",
"canceled": "キャンセル",
"skipped": "スキップ",
diff --git a/frontend/src/locales/vi-VN.json b/frontend/src/locales/vi-VN.json
index 9464b25ba4..8c1cdc4ee9 100644
--- a/frontend/src/locales/vi-VN.json
+++ b/frontend/src/locales/vi-VN.json
@@ -283,6 +283,7 @@
"view-change": "Xem thay đổi",
"status": {
"running": "Đang chạy",
+ "available": "Có sẵn",
"failed": "Thất bại",
"canceled": "Đã hủy",
"skipped": "Đã bỏ qua",
diff --git a/frontend/src/locales/zh-CN.json b/frontend/src/locales/zh-CN.json
index 1ebd542ca3..5f978f8d28 100644
--- a/frontend/src/locales/zh-CN.json
+++ b/frontend/src/locales/zh-CN.json
@@ -283,6 +283,7 @@
"view-change": "查看变更",
"status": {
"running": "运行中",
+ "available": "就绪",
"failed": "失败",
"canceled": "取消",
"skipped": "已跳过",
diff --git a/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts b/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts
index 153a1a5b6a..01e9c67faa 100644
--- a/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts
+++ b/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts
@@ -1131,6 +1131,13 @@ export enum TaskRun_Status {
* @generated from enum value: CANCELED = 5;
*/
CANCELED = 5,
+
+ /**
+ * Task run is ready for immediate execution.
+ *
+ * @generated from enum value: AVAILABLE = 6;
+ */
+ AVAILABLE = 6,
}
/**
diff --git a/frontend/src/types/proto-es/v1/rollout_service_pb.js b/frontend/src/types/proto-es/v1/rollout_service_pb.js
index 95d4a9592d..c168c699be 100644
--- a/frontend/src/types/proto-es/v1/rollout_service_pb.js
+++ b/frontend/src/types/proto-es/v1/rollout_service_pb.js
@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";
* Describes the file v1/rollout_service.proto.
*/
export const file_v1_rollout_service = /*@__PURE__*/
- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);
+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);
/**
* Describes the message bytebase.v1.BatchRunTasksRequest.
diff --git a/frontend/src/utils/v1/issue/rollout.ts b/frontend/src/utils/v1/issue/rollout.ts
index 7b4024ac9e..0f77845b17 100644
--- a/frontend/src/utils/v1/issue/rollout.ts
+++ b/frontend/src/utils/v1/issue/rollout.ts
@@ -236,6 +236,8 @@ export const stringifyTaskStatus = (
return t("task.status.canceled");
case Task_Status.SKIPPED:
return t("task.status.skipped");
+ case TaskRun_Status.AVAILABLE:
+ return t("task.status.available");
default:
return Task_Status[status] || String(status);
}
diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yaml
index bd71f0fa03..b18783488c 100644
--- a/proto/gen/grpc-doc/openapi.yaml
+++ b/proto/gen/grpc-doc/openapi.yaml
@@ -14267,6 +14267,7 @@ components:
- DONE
- FAILED
- CANCELED
+ - AVAILABLE
type: string
description: The current execution status of the task run.
format: enum
diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.md
index 18bb972127..0c16bc6641 100644
--- a/proto/gen/grpc-doc/store/README.md
+++ b/proto/gen/grpc-doc/store/README.md
@@ -4881,6 +4881,7 @@ Status represents the current execution state of a task run.
| CANCELED | 5 | Task run was canceled by user or system. |
| NOT_STARTED | 6 | Task run has not started yet. |
| SKIPPED | 7 | Task run was skipped and will not execute. |
+| AVAILABLE | 8 | Task run is ready for immediate execution. |
diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.html
index 238dc42c08..66cdde1604 100644
--- a/proto/gen/grpc-doc/store/index.html
+++ b/proto/gen/grpc-doc/store/index.html
@@ -13226,6 +13226,12 @@ Format: instances/{instance}/databases/{database}/changelogs/{changelog} </p></t
<td><p>Task run was skipped and will not execute.</p></td>
</tr>
+ <tr>
+ <td>AVAILABLE</td>
+ <td>8</td>
+ <td><p>Task run is ready for immediate execution.</p></td>
+ </tr>
+
</tbody>
</table>
diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.md
index 79dd90f267..c999f13004 100644
--- a/proto/gen/grpc-doc/v1/README.md
+++ b/proto/gen/grpc-doc/v1/README.md
@@ -10128,6 +10128,7 @@ PostgreSQL session information read from `pg_stat_activity`.
| DONE | 3 | Task run completed successfully. |
| FAILED | 4 | Task run execution failed with errors. |
| CANCELED | 5 | Task run execution was canceled by a user. |
+| AVAILABLE | 6 | Task run is ready for immediate execution. |
diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.html
index cac7ba18a8..5eea7bb6ac 100644
--- a/proto/gen/grpc-doc/v1/index.html
+++ b/proto/gen/grpc-doc/v1/index.html
@@ -28341,6 +28341,12 @@ Use payload DatabaseUpdate.</p></td>
<td><p>Task run execution was canceled by a user.</p></td>
</tr>
+ <tr>
+ <td>AVAILABLE</td>
+ <td>6</td>
+ <td><p>Task run is ready for immediate execution.</p></td>
+ </tr>
+
</tbody>
</table>
diff --git a/proto/store/store/task_run.proto b/proto/store/store/task_run.proto
index 1b083dd6ef..d575895571 100644
--- a/proto/store/store/task_run.proto
+++ b/proto/store/store/task_run.proto
@@ -26,6 +26,8 @@ message TaskRun {
NOT_STARTED = 6;
// Task run was skipped and will not execute.
SKIPPED = 7;
+ // Task run is ready for immediate execution.
+ AVAILABLE = 8;
}
}
diff --git a/proto/v1/v1/rollout_service.proto b/proto/v1/v1/rollout_service.proto
index b3843abdaa..155faa294c 100644
--- a/proto/v1/v1/rollout_service.proto
+++ b/proto/v1/v1/rollout_service.proto
@@ -470,6 +470,8 @@ message TaskRun {
FAILED = 4;
// Task run execution was canceled by a user.
CANCELED = 5;
+ // Task run is ready for immediate execution.
+ AVAILABLE = 6;
}
// The current execution status of the task run.
Status status = 5;