Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.yamlindex 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+ - AVAILABLEbytebase.v1.TaskRunLog:type: objectproperties:diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.goindex 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.Rfor _, 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.goindex 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.goindex 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.FileDescriptorconst 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.goindex 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.sqlnew file mode 100644index 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.sqlindex 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.goindex 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.goindex 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 timeif 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 schedulerselect {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.goindex 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 itreturn 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.Tif 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_atif 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 runnings.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 = falsego 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.goindex 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.Storediff --git a/backend/store/task_run.go b/backend/store/task_run.goindex 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 *TaskRunStatusPatreturn 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 invalidationq := qb.Q().Space(`@@ -297,11 +324,11 @@ func (s *Store) CreatePendingTaskRuns(ctx context.Context, creator string, creatWHERE NOT EXISTS (SELECT 1 FROM task_runWHERE 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.mdnew file mode 100644index 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 laterdiff --git a/docs/plans/2025-12-30-task-scheduler-available-status.md b/docs/plans/2025-12-30-task-scheduler-available-status.mdnew file mode 100644index 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.tsindex 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.jsindex 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("Chh2MS9yb2xsb3V0X3NlcnZpY2UucHJvdG8SC2J5dGViYXNlLnYxIpEBChRCYXRjaFJ1blRhc2tzUmVxdWVzdBIqCgZwYXJlbnQYASABKAlCGuBBAvpBFAoSYnl0ZWJhc2UuY29tL1N0YWdlEg0KBXRhc2tzGAIgAygJEjEKCHJ1bl90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgAiAEBQgsKCV9ydW5fdGltZSIXChVCYXRjaFJ1blRhc2tzUmVzcG9uc2UibAoVQmF0Y2hTa2lwVGFza3NSZXF1ZXN0EioKBnBhcmVudBgBIAEoCUIa4EEC+kEUChJieXRlYmFzZS5jb20vU3RhZ2USDQoFdGFza3MYAiADKAkSGAoGcmVhc29uGAMgASgJQgi6SAVyAxjoByIYChZCYXRjaFNraXBUYXNrc1Jlc3BvbnNlIloKGkJhdGNoQ2FuY2VsVGFza1J1bnNSZXF1ZXN0EikKBnBhcmVudBgBIAEoCUIZ4EEC+kETChFieXRlYmFzZS5jb20vVGFzaxIRCgl0YXNrX3J1bnMYAiADKAkiHQobQmF0Y2hDYW5jZWxUYXNrUnVuc1Jlc3BvbnNlIj8KEUdldFJvbGxvdXRSZXF1ZXN0EioKBG5hbWUYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1JvbGxvdXQiegoTTGlzdFJvbGxvdXRzUmVxdWVzdBIsCgZwYXJlbnQYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1Byb2plY3QSEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmlsdGVyGAQgASgJIlcKFExpc3RSb2xsb3V0c1Jlc3BvbnNlEiYKCHJvbGxvdXRzGAEgAygLMhQuYnl0ZWJhc2UudjEuUm9sbG91dBIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkiYQoUQ3JlYXRlUm9sbG91dFJlcXVlc3QSKQoGcGFyZW50GAEgASgJQhngQQL6QRMKEWJ5dGViYXNlLmNvbS9QbGFuEhMKBnRhcmdldBgDIAEoCUgAiAEBQgkKB190YXJnZXQiQAoTTGlzdFRhc2tSdW5zUmVxdWVzdBIpCgZwYXJlbnQYASABKAlCGeBBAvpBEwoRYnl0ZWJhc2UuY29tL1Rhc2siPwoUTGlzdFRhc2tSdW5zUmVzcG9uc2USJwoJdGFza19ydW5zGAEgAygLMhQuYnl0ZWJhc2UudjEuVGFza1J1biI/ChFHZXRUYXNrUnVuUmVxdWVzdBIqCgRuYW1lGAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9UYXNrUnVuIkQKFEdldFRhc2tSdW5Mb2dSZXF1ZXN0EiwKBnBhcmVudBgBIAEoCUIc4EEC+kEWChRieXRlYmFzZS5jb20vVGFza1J1biKEAgoHUm9sbG91dBIMCgRuYW1lGAEgASgJEhIKBXRpdGxlGAMgASgJQgPgQQMSJwoGc3RhZ2VzGAQgAygLMhIuYnl0ZWJhc2UudjEuU3RhZ2VCA+BBAxI0CgtjcmVhdGVfdGltZRgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAzpC6kE/ChRieXRlYmFzZS5jb20vUm9sbG91dBIncHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0Iq4BCgVTdGFnZRIMCgRuYW1lGAEgASgJEg8KAmlkGAIgASgJQgPgQQMSEwoLZW52aXJvbm1lbnQYAyABKAkSIAoFdGFza3MYBCADKAsyES5ieXRlYmFzZS52MS5UYXNrOk/qQUwKEmJ5dGViYXNlLmNvbS9TdGFnZRI2cHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0L3N0YWdlcy97c3RhZ2V9IuAJCgRUYXNrEgwKBG5hbWUYASABKAkSDwoHc3BlY19pZBgCIAEoCRIoCgZzdGF0dXMYAyABKA4yGC5ieXRlYmFzZS52MS5UYXNrLlN0YXR1cxIWCg5za2lwcGVkX3JlYXNvbhgEIAEoCRIkCgR0eXBlGAUgASgOMhYuYnl0ZWJhc2UudjEuVGFzay5UeXBlEg4KBnRhcmdldBgGIAEoCRI7Cg9kYXRhYmFzZV9jcmVhdGUYByABKAsyIC5ieXRlYmFzZS52MS5UYXNrLkRhdGFiYXNlQ3JlYXRlSAASOwoPZGF0YWJhc2VfdXBkYXRlGAggASgLMiAuYnl0ZWJhc2UudjEuVGFzay5EYXRhYmFzZVVwZGF0ZUgAEkQKFGRhdGFiYXNlX2RhdGFfZXhwb3J0GAkgASgLMiQuYnl0ZWJhc2UudjEuVGFzay5EYXRhYmFzZURhdGFFeHBvcnRIABI5Cgt1cGRhdGVfdGltZRgKIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBA0gBiAEBEjYKCHJ1bl90aW1lGAsgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDSAKIAQEakAEKDkRhdGFiYXNlQ3JlYXRlEg8KB3Byb2plY3QYASABKAkSEAoIZGF0YWJhc2UYAiABKAkSDQoFdGFibGUYAyABKAkSDQoFc2hlZXQYBCABKAkSFQoNY2hhcmFjdGVyX3NldBgFIAEoCRIRCgljb2xsYXRpb24YBiABKAkSEwoLZW52aXJvbm1lbnQYByABKAkadgoORGF0YWJhc2VVcGRhdGUSDQoFc2hlZXQYASABKAkSFgoOc2NoZW1hX3ZlcnNpb24YAiABKAkSPQoUZGF0YWJhc2VfY2hhbmdlX3R5cGUYAyABKA4yHy5ieXRlYmFzZS52MS5EYXRhYmFzZUNoYW5nZVR5cGUaggEKEkRhdGFiYXNlRGF0YUV4cG9ydBIOCgZ0YXJnZXQYASABKAkSDQoFc2hlZXQYAiABKAkSKQoGZm9ybWF0GAMgASgOMhkuYnl0ZWJhc2UudjEuRXhwb3J0Rm9ybWF0EhUKCHBhc3N3b3JkGAQgASgJSACIAQFCCwoJX3Bhc3N3b3JkInwKBlN0YXR1cxIWChJTVEFUVVNfVU5TUEVDSUZJRUQQABIPCgtOT1RfU1RBUlRFRBABEgsKB1BFTkRJTkcQAhILCgdSVU5OSU5HEAMSCAoERE9ORRAEEgoKBkZBSUxFRBAFEgwKCENBTkNFTEVEEAYSCwoHU0tJUFBFRBAHInsKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgsKB0dFTkVSQUwQARITCg9EQVRBQkFTRV9DUkVBVEUQAhIUChBEQVRBQkFTRV9NSUdSQVRFEAMSEwoPREFUQUJBU0VfRVhQT1JUEAQSEAoMREFUQUJBU0VfU0RMEAU6W+pBWAoRYnl0ZWJhc2UuY29tL1Rhc2sSQ3Byb2plY3RzL3twcm9qZWN0fS9wbGFucy97cGxhbn0vcm9sbG91dC9zdGFnZXMve3N0YWdlfS90YXNrcy97dGFza31CCQoHcGF5bG9hZEIOCgxfdXBkYXRlX3RpbWVCCwoJX3J1bl90aW1lIsgMCgdUYXNrUnVuEgwKBG5hbWUYASABKAkSDwoHY3JlYXRvchgCIAEoCRI0CgtjcmVhdGVfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxIrCgZzdGF0dXMYBSABKA4yGy5ieXRlYmFzZS52MS5UYXNrUnVuLlN0YXR1cxIOCgZkZXRhaWwYBiABKAkSFgoJY2hhbmdlbG9nGAcgASgJQgPgQQMSFgoOc2NoZW1hX3ZlcnNpb24YCCABKAkSMwoKc3RhcnRfdGltZRgJIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxJHChVleHBvcnRfYXJjaGl2ZV9zdGF0dXMYCiABKA4yKC5ieXRlYmFzZS52MS5UYXNrUnVuLkV4cG9ydEFyY2hpdmVTdGF0dXMSQwoTcHJpb3JfYmFja3VwX2RldGFpbBgLIAEoCzImLmJ5dGViYXNlLnYxLlRhc2tSdW4uUHJpb3JCYWNrdXBEZXRhaWwSPwoOc2NoZWR1bGVyX2luZm8YDCABKAsyIi5ieXRlYmFzZS52MS5UYXNrUnVuLlNjaGVkdWxlckluZm9CA+BBAxISCgVzaGVldBgNIAEoCUID4EEDEjYKCHJ1bl90aW1lGA4gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDSACIAQEagAMKEVByaW9yQmFja3VwRGV0YWlsEjoKBWl0ZW1zGAEgAygLMisuYnl0ZWJhc2UudjEuVGFza1J1bi5QcmlvckJhY2t1cERldGFpbC5JdGVtGq4CCgRJdGVtEkcKDHNvdXJjZV90YWJsZRgBIAEoCzIxLmJ5dGViYXNlLnYxLlRhc2tSdW4uUHJpb3JCYWNrdXBEZXRhaWwuSXRlbS5UYWJsZRJHCgx0YXJnZXRfdGFibGUYAiABKAsyMS5ieXRlYmFzZS52MS5UYXNrUnVuLlByaW9yQmFja3VwRGV0YWlsLkl0ZW0uVGFibGUSLQoOc3RhcnRfcG9zaXRpb24YAyABKAsyFS5ieXRlYmFzZS52MS5Qb3NpdGlvbhIrCgxlbmRfcG9zaXRpb24YBCABKAsyFS5ieXRlYmFzZS52MS5Qb3NpdGlvbho4CgVUYWJsZRIQCghkYXRhYmFzZRgBIAEoCRIOCgZzY2hlbWEYAiABKAkSDQoFdGFibGUYAyABKAkaugIKDVNjaGVkdWxlckluZm8SLwoLcmVwb3J0X3RpbWUYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkYKDXdhaXRpbmdfY2F1c2UYAiABKAsyLy5ieXRlYmFzZS52MS5UYXNrUnVuLlNjaGVkdWxlckluZm8uV2FpdGluZ0NhdXNlGq8BCgxXYWl0aW5nQ2F1c2USGgoQY29ubmVjdGlvbl9saW1pdBgBIAEoCEgAEkQKBHRhc2sYAiABKAsyNC5ieXRlYmFzZS52MS5UYXNrUnVuLlNjaGVkdWxlckluZm8uV2FpdGluZ0NhdXNlLlRhc2tIABIeChRwYXJhbGxlbF90YXNrc19saW1pdBgDIAEoCEgAGhQKBFRhc2sSDAoEdGFzaxgBIAEoCUIHCgVjYXVzZSJeCgZTdGF0dXMSFgoSU1RBVFVTX1VOU1BFQ0lGSUVEEAASCwoHUEVORElORxABEgsKB1JVTk5JTkcQAhIICgRET05FEAMSCgoGRkFJTEVEEAQSDAoIQ0FOQ0VMRUQQBSJVChNFeHBvcnRBcmNoaXZlU3RhdHVzEiUKIUVYUE9SVF9BUkNISVZFX1NUQVRVU19VTlNQRUNJRklFRBAAEgkKBVJFQURZEAESDAoIRVhQT1JURUQQAjpx6kFuChRieXRlYmFzZS5jb20vVGFza1J1bhJWcHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0L3N0YWdlcy97c3RhZ2V9L3Rhc2tzL3t0YXNrfS90YXNrUnVucy97dGFza1J1bn1CCwoJX3J1bl90aW1lIsMBCgpUYXNrUnVuTG9nEgwKBG5hbWUYASABKAkSLQoHZW50cmllcxgCIAMoCzIcLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeTp46kF1ChdieXRlYmFzZS5jb20vVGFza1J1bkxvZxJacHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0L3N0YWdlcy97c3RhZ2V9L3Rhc2tzL3t0YXNrfS90YXNrUnVucy97dGFza1J1bn0vbG9nIokRCg9UYXNrUnVuTG9nRW50cnkSLwoEdHlwZRgBIAEoDjIhLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5UeXBlEiwKCGxvZ190aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIRCglkZXBsb3lfaWQYAyABKAkSPAoLc2NoZW1hX2R1bXAYBCABKAsyJy5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuU2NoZW1hRHVtcBJECg9jb21tYW5kX2V4ZWN1dGUYBSABKAsyKy5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuQ29tbWFuZEV4ZWN1dGUSQAoNZGF0YWJhc2Vfc3luYxgGIAEoCzIpLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5EYXRhYmFzZVN5bmMSUAoWdGFza19ydW5fc3RhdHVzX3VwZGF0ZRgHIAEoCzIwLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5UYXNrUnVuU3RhdHVzVXBkYXRlEkwKE3RyYW5zYWN0aW9uX2NvbnRyb2wYCCABKAsyLy5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuVHJhbnNhY3Rpb25Db250cm9sEj4KDHByaW9yX2JhY2t1cBgJIAEoCzIoLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5QcmlvckJhY2t1cBI6CgpyZXRyeV9pbmZvGAogASgLMiYuYnl0ZWJhc2UudjEuVGFza1J1bkxvZ0VudHJ5LlJldHJ5SW5mbxI+Cgxjb21wdXRlX2RpZmYYCyABKAsyKC5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuQ29tcHV0ZURpZmYaeQoKU2NoZW1hRHVtcBIuCgpzdGFydF90aW1lGAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIsCghlbmRfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASDQoFZXJyb3IYAyABKAkaxgIKDkNvbW1hbmRFeGVjdXRlEiwKCGxvZ190aW1lGAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIhCgVyYW5nZRgCIAEoCzISLmJ5dGViYXNlLnYxLlJhbmdlEhEKCXN0YXRlbWVudBgEIAEoCRJNCghyZXNwb25zZRgDIAEoCzI7LmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5Db21tYW5kRXhlY3V0ZS5Db21tYW5kUmVzcG9uc2UagAEKD0NvbW1hbmRSZXNwb25zZRIsCghsb2dfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASDQoFZXJyb3IYAiABKAkSFQoNYWZmZWN0ZWRfcm93cxgDIAEoAxIZChFhbGxfYWZmZWN0ZWRfcm93cxgEIAMoAxp7CgxEYXRhYmFzZVN5bmMSLgoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLAoIZW5kX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEg0KBWVycm9yGAMgASgJGqoBChNUYXNrUnVuU3RhdHVzVXBkYXRlEkcKBnN0YXR1cxgBIAEoDjI3LmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5UYXNrUnVuU3RhdHVzVXBkYXRlLlN0YXR1cyJKCgZTdGF0dXMSFgoSU1RBVFVTX1VOU1BFQ0lGSUVEEAASEwoPUlVOTklOR19XQUlUSU5HEAESEwoPUlVOTklOR19SVU5OSU5HEAIaqgEKElRyYW5zYWN0aW9uQ29udHJvbBJCCgR0eXBlGAEgASgOMjQuYnl0ZWJhc2UudjEuVGFza1J1bkxvZ0VudHJ5LlRyYW5zYWN0aW9uQ29udHJvbC5UeXBlEg0KBWVycm9yGAIgASgJIkEKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgkKBUJFR0lOEAESCgoGQ09NTUlUEAISDAoIUk9MTEJBQ0sQAxq/AQoLUHJpb3JCYWNrdXASLgoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLAoIZW5kX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkMKE3ByaW9yX2JhY2t1cF9kZXRhaWwYAyABKAsyJi5ieXRlYmFzZS52MS5UYXNrUnVuLlByaW9yQmFja3VwRGV0YWlsEg0KBWVycm9yGAQgASgJGkgKCVJldHJ5SW5mbxINCgVlcnJvchgBIAEoCRITCgtyZXRyeV9jb3VudBgCIAEoBRIXCg9tYXhpbXVtX3JldHJpZXMYAyABKAUaegoLQ29tcHV0ZURpZmYSLgoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLAoIZW5kX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEg0KBWVycm9yGAMgASgJIr4BCgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABIPCgtTQ0hFTUFfRFVNUBABEhMKD0NPTU1BTkRfRVhFQ1VURRACEhEKDURBVEFCQVNFX1NZTkMQAxIaChZUQVNLX1JVTl9TVEFUVVNfVVBEQVRFEAQSFwoTVFJBTlNBQ1RJT05fQ09OVFJPTBAFEhAKDFBSSU9SX0JBQ0tVUBAGEg4KClJFVFJZX0lORk8QBxIQCgxDT01QVVRFX0RJRkYQCCJIChhHZXRUYXNrUnVuU2Vzc2lvblJlcXVlc3QSLAoGcGFyZW50GAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9UYXNrUnVuIusHCg5UYXNrUnVuU2Vzc2lvbhIMCgRuYW1lGAEgASgJEjgKCHBvc3RncmVzGAIgASgLMiQuYnl0ZWJhc2UudjEuVGFza1J1blNlc3Npb24uUG9zdGdyZXNIABqCBgoIUG9zdGdyZXMSPQoHc2Vzc2lvbhgBIAEoCzIsLmJ5dGViYXNlLnYxLlRhc2tSdW5TZXNzaW9uLlBvc3RncmVzLlNlc3Npb24SRwoRYmxvY2tpbmdfc2Vzc2lvbnMYAiADKAsyLC5ieXRlYmFzZS52MS5UYXNrUnVuU2Vzc2lvbi5Qb3N0Z3Jlcy5TZXNzaW9uEkYKEGJsb2NrZWRfc2Vzc2lvbnMYAyADKAsyLC5ieXRlYmFzZS52MS5UYXNrUnVuU2Vzc2lvbi5Qb3N0Z3Jlcy5TZXNzaW9uGqUECgdTZXNzaW9uEgsKA3BpZBgBIAEoCRIXCg9ibG9ja2VkX2J5X3BpZHMYAiADKAkSDQoFcXVlcnkYAyABKAkSEgoFc3RhdGUYBCABKAlIAIgBARIcCg93YWl0X2V2ZW50X3R5cGUYBSABKAlIAYgBARIXCgp3YWl0X2V2ZW50GAYgASgJSAKIAQESFAoHZGF0bmFtZRgHIAEoCUgDiAEBEhQKB3VzZW5hbWUYCCABKAlIBIgBARIYChBhcHBsaWNhdGlvbl9uYW1lGAkgASgJEhgKC2NsaWVudF9hZGRyGAogASgJSAWIAQESGAoLY2xpZW50X3BvcnQYCyABKAlIBogBARIxCg1iYWNrZW5kX3N0YXJ0GAwgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIzCgp4YWN0X3N0YXJ0GA0gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgHiAEBEjQKC3F1ZXJ5X3N0YXJ0GA4gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgIiAEBQggKBl9zdGF0ZUISChBfd2FpdF9ldmVudF90eXBlQg0KC193YWl0X2V2ZW50QgoKCF9kYXRuYW1lQgoKCF91c2VuYW1lQg4KDF9jbGllbnRfYWRkckIOCgxfY2xpZW50X3BvcnRCDQoLX3hhY3Rfc3RhcnRCDgoMX3F1ZXJ5X3N0YXJ0OoAB6kF9ChtieXRlYmFzZS5jb20vVGFza1J1blNlc3Npb24SXnByb2plY3RzL3twcm9qZWN0fS9wbGFucy97cGxhbn0vcm9sbG91dC9zdGFnZXMve3N0YWdlfS90YXNrcy97dGFza30vdGFza1J1bnMve3Rhc2tSdW59L3Nlc3Npb25CCQoHc2Vzc2lvbiJLCh1QcmV2aWV3VGFza1J1blJvbGxiYWNrUmVxdWVzdBIqCgRuYW1lGAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9UYXNrUnVuIjMKHlByZXZpZXdUYXNrUnVuUm9sbGJhY2tSZXNwb25zZRIRCglzdGF0ZW1lbnQYASABKAkyoRAKDlJvbGxvdXRTZXJ2aWNlEo8BCgpHZXRSb2xsb3V0Eh4uYnl0ZWJhc2UudjEuR2V0Um9sbG91dFJlcXVlc3QaFC5ieXRlYmFzZS52MS5Sb2xsb3V0IkvaQQRuYW1liuowD2JiLnJvbGxvdXRzLmdldJDqMAGC0+STAicSJS92MS97bmFtZT1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dH0SngEKDExpc3RSb2xsb3V0cxIgLmJ5dGViYXNlLnYxLkxpc3RSb2xsb3V0c1JlcXVlc3QaIS5ieXRlYmFzZS52MS5MaXN0Um9sbG91dHNSZXNwb25zZSJJ2kEGcGFyZW50iuowEGJiLnJvbGxvdXRzLmxpc3SQ6jABgtPkkwIiEiAvdjEve3BhcmVudD1wcm9qZWN0cy8qfS9yb2xsb3V0cxKjAQoNQ3JlYXRlUm9sbG91dBIhLmJ5dGViYXNlLnYxLkNyZWF0ZVJvbGxvdXRSZXF1ZXN0GhQuYnl0ZWJhc2UudjEuUm9sbG91dCJZ2kEGcGFyZW50iuowEmJiLnJvbGxvdXRzLmNyZWF0ZZDqMAGY6jABgtPkkwIsOgEqIicvdjEve3BhcmVudD1wcm9qZWN0cy8qL3BsYW5zLyp9L3JvbGxvdXQSvwEKDExpc3RUYXNrUnVucxIgLmJ5dGViYXNlLnYxLkxpc3RUYXNrUnVuc1JlcXVlc3QaIS5ieXRlYmFzZS52MS5MaXN0VGFza1J1bnNSZXNwb25zZSJq2kEGcGFyZW50iuowEGJiLnRhc2tSdW5zLmxpc3SQ6jABgtPkkwJDEkEvdjEve3BhcmVudD1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dC9zdGFnZXMvKi90YXNrcy8qfS90YXNrUnVucxKsAQoKR2V0VGFza1J1bhIeLmJ5dGViYXNlLnYxLkdldFRhc2tSdW5SZXF1ZXN0GhQuYnl0ZWJhc2UudjEuVGFza1J1biJo2kEEbmFtZYrqMBBiYi50YXNrUnVucy5saXN0kOowAYLT5JMCQxJBL3YxL3tuYW1lPXByb2plY3RzLyovcGxhbnMvKi9yb2xsb3V0L3N0YWdlcy8qL3Rhc2tzLyovdGFza1J1bnMvKn0SvQEKDUdldFRhc2tSdW5Mb2cSIS5ieXRlYmFzZS52MS5HZXRUYXNrUnVuTG9nUmVxdWVzdBoXLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2cicNpBBnBhcmVudIrqMBBiYi50YXNrUnVucy5saXN0kOowAYLT5JMCSRJHL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9wbGFucy8qL3JvbGxvdXQvc3RhZ2VzLyovdGFza3MvKi90YXNrUnVucy8qfS9sb2cSzQEKEUdldFRhc2tSdW5TZXNzaW9uEiUuYnl0ZWJhc2UudjEuR2V0VGFza1J1blNlc3Npb25SZXF1ZXN0GhsuYnl0ZWJhc2UudjEuVGFza1J1blNlc3Npb24idNpBBnBhcmVudIrqMBBiYi50YXNrUnVucy5saXN0kOowAYLT5JMCTRJLL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9wbGFucy8qL3JvbGxvdXQvc3RhZ2VzLyovdGFza3MvKi90YXNrUnVucy8qfS9zZXNzaW9uErMBCg1CYXRjaFJ1blRhc2tzEiEuYnl0ZWJhc2UudjEuQmF0Y2hSdW5UYXNrc1JlcXVlc3QaIi5ieXRlYmFzZS52MS5CYXRjaFJ1blRhc2tzUmVzcG9uc2UiW9pBBnBhcmVudJDqMAKY6jABgtPkkwJEOgEqIj8vdjEve3BhcmVudD1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dC9zdGFnZXMvKn0vdGFza3M6YmF0Y2hSdW4StwEKDkJhdGNoU2tpcFRhc2tzEiIuYnl0ZWJhc2UudjEuQmF0Y2hTa2lwVGFza3NSZXF1ZXN0GiMuYnl0ZWJhc2UudjEuQmF0Y2hTa2lwVGFza3NSZXNwb25zZSJc2kEGcGFyZW50kOowApjqMAGC0+STAkU6ASoiQC92MS97cGFyZW50PXByb2plY3RzLyovcGxhbnMvKi9yb2xsb3V0L3N0YWdlcy8qfS90YXNrczpiYXRjaFNraXAS0wEKE0JhdGNoQ2FuY2VsVGFza1J1bnMSJy5ieXRlYmFzZS52MS5CYXRjaENhbmNlbFRhc2tSdW5zUmVxdWVzdBooLmJ5dGViYXNlLnYxLkJhdGNoQ2FuY2VsVGFza1J1bnNSZXNwb25zZSJp2kEGcGFyZW50kOowApjqMAGC0+STAlI6ASoiTS92MS97cGFyZW50PXByb2plY3RzLyovcGxhbnMvKi9yb2xsb3V0L3N0YWdlcy8qL3Rhc2tzLyp9L3Rhc2tSdW5zOmJhdGNoQ2FuY2VsEu4BChZQcmV2aWV3VGFza1J1blJvbGxiYWNrEiouYnl0ZWJhc2UudjEuUHJldmlld1Rhc2tSdW5Sb2xsYmFja1JlcXVlc3QaKy5ieXRlYmFzZS52MS5QcmV2aWV3VGFza1J1blJvbGxiYWNrUmVzcG9uc2Uie9pBBG5hbWWK6jAQYmIudGFza1J1bnMubGlzdJDqMAGC0+STAlY6ASoiUS92MS97bmFtZT1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dC9zdGFnZXMvKi90YXNrcy8qL3Rhc2tSdW5zLyp9OnByZXZpZXdSb2xsYmFja0KpAQoPY29tLmJ5dGViYXNlLnYxQhNSb2xsb3V0U2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [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("Chh2MS9yb2xsb3V0X3NlcnZpY2UucHJvdG8SC2J5dGViYXNlLnYxIpEBChRCYXRjaFJ1blRhc2tzUmVxdWVzdBIqCgZwYXJlbnQYASABKAlCGuBBAvpBFAoSYnl0ZWJhc2UuY29tL1N0YWdlEg0KBXRhc2tzGAIgAygJEjEKCHJ1bl90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgAiAEBQgsKCV9ydW5fdGltZSIXChVCYXRjaFJ1blRhc2tzUmVzcG9uc2UibAoVQmF0Y2hTa2lwVGFza3NSZXF1ZXN0EioKBnBhcmVudBgBIAEoCUIa4EEC+kEUChJieXRlYmFzZS5jb20vU3RhZ2USDQoFdGFza3MYAiADKAkSGAoGcmVhc29uGAMgASgJQgi6SAVyAxjoByIYChZCYXRjaFNraXBUYXNrc1Jlc3BvbnNlIloKGkJhdGNoQ2FuY2VsVGFza1J1bnNSZXF1ZXN0EikKBnBhcmVudBgBIAEoCUIZ4EEC+kETChFieXRlYmFzZS5jb20vVGFzaxIRCgl0YXNrX3J1bnMYAiADKAkiHQobQmF0Y2hDYW5jZWxUYXNrUnVuc1Jlc3BvbnNlIj8KEUdldFJvbGxvdXRSZXF1ZXN0EioKBG5hbWUYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1JvbGxvdXQiegoTTGlzdFJvbGxvdXRzUmVxdWVzdBIsCgZwYXJlbnQYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1Byb2plY3QSEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmlsdGVyGAQgASgJIlcKFExpc3RSb2xsb3V0c1Jlc3BvbnNlEiYKCHJvbGxvdXRzGAEgAygLMhQuYnl0ZWJhc2UudjEuUm9sbG91dBIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkiYQoUQ3JlYXRlUm9sbG91dFJlcXVlc3QSKQoGcGFyZW50GAEgASgJQhngQQL6QRMKEWJ5dGViYXNlLmNvbS9QbGFuEhMKBnRhcmdldBgDIAEoCUgAiAEBQgkKB190YXJnZXQiQAoTTGlzdFRhc2tSdW5zUmVxdWVzdBIpCgZwYXJlbnQYASABKAlCGeBBAvpBEwoRYnl0ZWJhc2UuY29tL1Rhc2siPwoUTGlzdFRhc2tSdW5zUmVzcG9uc2USJwoJdGFza19ydW5zGAEgAygLMhQuYnl0ZWJhc2UudjEuVGFza1J1biI/ChFHZXRUYXNrUnVuUmVxdWVzdBIqCgRuYW1lGAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9UYXNrUnVuIkQKFEdldFRhc2tSdW5Mb2dSZXF1ZXN0EiwKBnBhcmVudBgBIAEoCUIc4EEC+kEWChRieXRlYmFzZS5jb20vVGFza1J1biKEAgoHUm9sbG91dBIMCgRuYW1lGAEgASgJEhIKBXRpdGxlGAMgASgJQgPgQQMSJwoGc3RhZ2VzGAQgAygLMhIuYnl0ZWJhc2UudjEuU3RhZ2VCA+BBAxI0CgtjcmVhdGVfdGltZRgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAzpC6kE/ChRieXRlYmFzZS5jb20vUm9sbG91dBIncHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0Iq4BCgVTdGFnZRIMCgRuYW1lGAEgASgJEg8KAmlkGAIgASgJQgPgQQMSEwoLZW52aXJvbm1lbnQYAyABKAkSIAoFdGFza3MYBCADKAsyES5ieXRlYmFzZS52MS5UYXNrOk/qQUwKEmJ5dGViYXNlLmNvbS9TdGFnZRI2cHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0L3N0YWdlcy97c3RhZ2V9IuAJCgRUYXNrEgwKBG5hbWUYASABKAkSDwoHc3BlY19pZBgCIAEoCRIoCgZzdGF0dXMYAyABKA4yGC5ieXRlYmFzZS52MS5UYXNrLlN0YXR1cxIWCg5za2lwcGVkX3JlYXNvbhgEIAEoCRIkCgR0eXBlGAUgASgOMhYuYnl0ZWJhc2UudjEuVGFzay5UeXBlEg4KBnRhcmdldBgGIAEoCRI7Cg9kYXRhYmFzZV9jcmVhdGUYByABKAsyIC5ieXRlYmFzZS52MS5UYXNrLkRhdGFiYXNlQ3JlYXRlSAASOwoPZGF0YWJhc2VfdXBkYXRlGAggASgLMiAuYnl0ZWJhc2UudjEuVGFzay5EYXRhYmFzZVVwZGF0ZUgAEkQKFGRhdGFiYXNlX2RhdGFfZXhwb3J0GAkgASgLMiQuYnl0ZWJhc2UudjEuVGFzay5EYXRhYmFzZURhdGFFeHBvcnRIABI5Cgt1cGRhdGVfdGltZRgKIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBA0gBiAEBEjYKCHJ1bl90aW1lGAsgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDSAKIAQEakAEKDkRhdGFiYXNlQ3JlYXRlEg8KB3Byb2plY3QYASABKAkSEAoIZGF0YWJhc2UYAiABKAkSDQoFdGFibGUYAyABKAkSDQoFc2hlZXQYBCABKAkSFQoNY2hhcmFjdGVyX3NldBgFIAEoCRIRCgljb2xsYXRpb24YBiABKAkSEwoLZW52aXJvbm1lbnQYByABKAkadgoORGF0YWJhc2VVcGRhdGUSDQoFc2hlZXQYASABKAkSFgoOc2NoZW1hX3ZlcnNpb24YAiABKAkSPQoUZGF0YWJhc2VfY2hhbmdlX3R5cGUYAyABKA4yHy5ieXRlYmFzZS52MS5EYXRhYmFzZUNoYW5nZVR5cGUaggEKEkRhdGFiYXNlRGF0YUV4cG9ydBIOCgZ0YXJnZXQYASABKAkSDQoFc2hlZXQYAiABKAkSKQoGZm9ybWF0GAMgASgOMhkuYnl0ZWJhc2UudjEuRXhwb3J0Rm9ybWF0EhUKCHBhc3N3b3JkGAQgASgJSACIAQFCCwoJX3Bhc3N3b3JkInwKBlN0YXR1cxIWChJTVEFUVVNfVU5TUEVDSUZJRUQQABIPCgtOT1RfU1RBUlRFRBABEgsKB1BFTkRJTkcQAhILCgdSVU5OSU5HEAMSCAoERE9ORRAEEgoKBkZBSUxFRBAFEgwKCENBTkNFTEVEEAYSCwoHU0tJUFBFRBAHInsKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgsKB0dFTkVSQUwQARITCg9EQVRBQkFTRV9DUkVBVEUQAhIUChBEQVRBQkFTRV9NSUdSQVRFEAMSEwoPREFUQUJBU0VfRVhQT1JUEAQSEAoMREFUQUJBU0VfU0RMEAU6W+pBWAoRYnl0ZWJhc2UuY29tL1Rhc2sSQ3Byb2plY3RzL3twcm9qZWN0fS9wbGFucy97cGxhbn0vcm9sbG91dC9zdGFnZXMve3N0YWdlfS90YXNrcy97dGFza31CCQoHcGF5bG9hZEIOCgxfdXBkYXRlX3RpbWVCCwoJX3J1bl90aW1lItcMCgdUYXNrUnVuEgwKBG5hbWUYASABKAkSDwoHY3JlYXRvchgCIAEoCRI0CgtjcmVhdGVfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxIrCgZzdGF0dXMYBSABKA4yGy5ieXRlYmFzZS52MS5UYXNrUnVuLlN0YXR1cxIOCgZkZXRhaWwYBiABKAkSFgoJY2hhbmdlbG9nGAcgASgJQgPgQQMSFgoOc2NoZW1hX3ZlcnNpb24YCCABKAkSMwoKc3RhcnRfdGltZRgJIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxJHChVleHBvcnRfYXJjaGl2ZV9zdGF0dXMYCiABKA4yKC5ieXRlYmFzZS52MS5UYXNrUnVuLkV4cG9ydEFyY2hpdmVTdGF0dXMSQwoTcHJpb3JfYmFja3VwX2RldGFpbBgLIAEoCzImLmJ5dGViYXNlLnYxLlRhc2tSdW4uUHJpb3JCYWNrdXBEZXRhaWwSPwoOc2NoZWR1bGVyX2luZm8YDCABKAsyIi5ieXRlYmFzZS52MS5UYXNrUnVuLlNjaGVkdWxlckluZm9CA+BBAxISCgVzaGVldBgNIAEoCUID4EEDEjYKCHJ1bl90aW1lGA4gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDSACIAQEagAMKEVByaW9yQmFja3VwRGV0YWlsEjoKBWl0ZW1zGAEgAygLMisuYnl0ZWJhc2UudjEuVGFza1J1bi5QcmlvckJhY2t1cERldGFpbC5JdGVtGq4CCgRJdGVtEkcKDHNvdXJjZV90YWJsZRgBIAEoCzIxLmJ5dGViYXNlLnYxLlRhc2tSdW4uUHJpb3JCYWNrdXBEZXRhaWwuSXRlbS5UYWJsZRJHCgx0YXJnZXRfdGFibGUYAiABKAsyMS5ieXRlYmFzZS52MS5UYXNrUnVuLlByaW9yQmFja3VwRGV0YWlsLkl0ZW0uVGFibGUSLQoOc3RhcnRfcG9zaXRpb24YAyABKAsyFS5ieXRlYmFzZS52MS5Qb3NpdGlvbhIrCgxlbmRfcG9zaXRpb24YBCABKAsyFS5ieXRlYmFzZS52MS5Qb3NpdGlvbho4CgVUYWJsZRIQCghkYXRhYmFzZRgBIAEoCRIOCgZzY2hlbWEYAiABKAkSDQoFdGFibGUYAyABKAkaugIKDVNjaGVkdWxlckluZm8SLwoLcmVwb3J0X3RpbWUYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkYKDXdhaXRpbmdfY2F1c2UYAiABKAsyLy5ieXRlYmFzZS52MS5UYXNrUnVuLlNjaGVkdWxlckluZm8uV2FpdGluZ0NhdXNlGq8BCgxXYWl0aW5nQ2F1c2USGgoQY29ubmVjdGlvbl9saW1pdBgBIAEoCEgAEkQKBHRhc2sYAiABKAsyNC5ieXRlYmFzZS52MS5UYXNrUnVuLlNjaGVkdWxlckluZm8uV2FpdGluZ0NhdXNlLlRhc2tIABIeChRwYXJhbGxlbF90YXNrc19saW1pdBgDIAEoCEgAGhQKBFRhc2sSDAoEdGFzaxgBIAEoCUIHCgVjYXVzZSJtCgZTdGF0dXMSFgoSU1RBVFVTX1VOU1BFQ0lGSUVEEAASCwoHUEVORElORxABEgsKB1JVTk5JTkcQAhIICgRET05FEAMSCgoGRkFJTEVEEAQSDAoIQ0FOQ0VMRUQQBRINCglBVkFJTEFCTEUQBiJVChNFeHBvcnRBcmNoaXZlU3RhdHVzEiUKIUVYUE9SVF9BUkNISVZFX1NUQVRVU19VTlNQRUNJRklFRBAAEgkKBVJFQURZEAESDAoIRVhQT1JURUQQAjpx6kFuChRieXRlYmFzZS5jb20vVGFza1J1bhJWcHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0L3N0YWdlcy97c3RhZ2V9L3Rhc2tzL3t0YXNrfS90YXNrUnVucy97dGFza1J1bn1CCwoJX3J1bl90aW1lIsMBCgpUYXNrUnVuTG9nEgwKBG5hbWUYASABKAkSLQoHZW50cmllcxgCIAMoCzIcLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeTp46kF1ChdieXRlYmFzZS5jb20vVGFza1J1bkxvZxJacHJvamVjdHMve3Byb2plY3R9L3BsYW5zL3twbGFufS9yb2xsb3V0L3N0YWdlcy97c3RhZ2V9L3Rhc2tzL3t0YXNrfS90YXNrUnVucy97dGFza1J1bn0vbG9nIokRCg9UYXNrUnVuTG9nRW50cnkSLwoEdHlwZRgBIAEoDjIhLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5UeXBlEiwKCGxvZ190aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIRCglkZXBsb3lfaWQYAyABKAkSPAoLc2NoZW1hX2R1bXAYBCABKAsyJy5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuU2NoZW1hRHVtcBJECg9jb21tYW5kX2V4ZWN1dGUYBSABKAsyKy5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuQ29tbWFuZEV4ZWN1dGUSQAoNZGF0YWJhc2Vfc3luYxgGIAEoCzIpLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5EYXRhYmFzZVN5bmMSUAoWdGFza19ydW5fc3RhdHVzX3VwZGF0ZRgHIAEoCzIwLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5UYXNrUnVuU3RhdHVzVXBkYXRlEkwKE3RyYW5zYWN0aW9uX2NvbnRyb2wYCCABKAsyLy5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuVHJhbnNhY3Rpb25Db250cm9sEj4KDHByaW9yX2JhY2t1cBgJIAEoCzIoLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5QcmlvckJhY2t1cBI6CgpyZXRyeV9pbmZvGAogASgLMiYuYnl0ZWJhc2UudjEuVGFza1J1bkxvZ0VudHJ5LlJldHJ5SW5mbxI+Cgxjb21wdXRlX2RpZmYYCyABKAsyKC5ieXRlYmFzZS52MS5UYXNrUnVuTG9nRW50cnkuQ29tcHV0ZURpZmYaeQoKU2NoZW1hRHVtcBIuCgpzdGFydF90aW1lGAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIsCghlbmRfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASDQoFZXJyb3IYAyABKAkaxgIKDkNvbW1hbmRFeGVjdXRlEiwKCGxvZ190aW1lGAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIhCgVyYW5nZRgCIAEoCzISLmJ5dGViYXNlLnYxLlJhbmdlEhEKCXN0YXRlbWVudBgEIAEoCRJNCghyZXNwb25zZRgDIAEoCzI7LmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5Db21tYW5kRXhlY3V0ZS5Db21tYW5kUmVzcG9uc2UagAEKD0NvbW1hbmRSZXNwb25zZRIsCghsb2dfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASDQoFZXJyb3IYAiABKAkSFQoNYWZmZWN0ZWRfcm93cxgDIAEoAxIZChFhbGxfYWZmZWN0ZWRfcm93cxgEIAMoAxp7CgxEYXRhYmFzZVN5bmMSLgoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLAoIZW5kX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEg0KBWVycm9yGAMgASgJGqoBChNUYXNrUnVuU3RhdHVzVXBkYXRlEkcKBnN0YXR1cxgBIAEoDjI3LmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2dFbnRyeS5UYXNrUnVuU3RhdHVzVXBkYXRlLlN0YXR1cyJKCgZTdGF0dXMSFgoSU1RBVFVTX1VOU1BFQ0lGSUVEEAASEwoPUlVOTklOR19XQUlUSU5HEAESEwoPUlVOTklOR19SVU5OSU5HEAIaqgEKElRyYW5zYWN0aW9uQ29udHJvbBJCCgR0eXBlGAEgASgOMjQuYnl0ZWJhc2UudjEuVGFza1J1bkxvZ0VudHJ5LlRyYW5zYWN0aW9uQ29udHJvbC5UeXBlEg0KBWVycm9yGAIgASgJIkEKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgkKBUJFR0lOEAESCgoGQ09NTUlUEAISDAoIUk9MTEJBQ0sQAxq/AQoLUHJpb3JCYWNrdXASLgoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLAoIZW5kX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkMKE3ByaW9yX2JhY2t1cF9kZXRhaWwYAyABKAsyJi5ieXRlYmFzZS52MS5UYXNrUnVuLlByaW9yQmFja3VwRGV0YWlsEg0KBWVycm9yGAQgASgJGkgKCVJldHJ5SW5mbxINCgVlcnJvchgBIAEoCRITCgtyZXRyeV9jb3VudBgCIAEoBRIXCg9tYXhpbXVtX3JldHJpZXMYAyABKAUaegoLQ29tcHV0ZURpZmYSLgoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASLAoIZW5kX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEg0KBWVycm9yGAMgASgJIr4BCgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABIPCgtTQ0hFTUFfRFVNUBABEhMKD0NPTU1BTkRfRVhFQ1VURRACEhEKDURBVEFCQVNFX1NZTkMQAxIaChZUQVNLX1JVTl9TVEFUVVNfVVBEQVRFEAQSFwoTVFJBTlNBQ1RJT05fQ09OVFJPTBAFEhAKDFBSSU9SX0JBQ0tVUBAGEg4KClJFVFJZX0lORk8QBxIQCgxDT01QVVRFX0RJRkYQCCJIChhHZXRUYXNrUnVuU2Vzc2lvblJlcXVlc3QSLAoGcGFyZW50GAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9UYXNrUnVuIusHCg5UYXNrUnVuU2Vzc2lvbhIMCgRuYW1lGAEgASgJEjgKCHBvc3RncmVzGAIgASgLMiQuYnl0ZWJhc2UudjEuVGFza1J1blNlc3Npb24uUG9zdGdyZXNIABqCBgoIUG9zdGdyZXMSPQoHc2Vzc2lvbhgBIAEoCzIsLmJ5dGViYXNlLnYxLlRhc2tSdW5TZXNzaW9uLlBvc3RncmVzLlNlc3Npb24SRwoRYmxvY2tpbmdfc2Vzc2lvbnMYAiADKAsyLC5ieXRlYmFzZS52MS5UYXNrUnVuU2Vzc2lvbi5Qb3N0Z3Jlcy5TZXNzaW9uEkYKEGJsb2NrZWRfc2Vzc2lvbnMYAyADKAsyLC5ieXRlYmFzZS52MS5UYXNrUnVuU2Vzc2lvbi5Qb3N0Z3Jlcy5TZXNzaW9uGqUECgdTZXNzaW9uEgsKA3BpZBgBIAEoCRIXCg9ibG9ja2VkX2J5X3BpZHMYAiADKAkSDQoFcXVlcnkYAyABKAkSEgoFc3RhdGUYBCABKAlIAIgBARIcCg93YWl0X2V2ZW50X3R5cGUYBSABKAlIAYgBARIXCgp3YWl0X2V2ZW50GAYgASgJSAKIAQESFAoHZGF0bmFtZRgHIAEoCUgDiAEBEhQKB3VzZW5hbWUYCCABKAlIBIgBARIYChBhcHBsaWNhdGlvbl9uYW1lGAkgASgJEhgKC2NsaWVudF9hZGRyGAogASgJSAWIAQESGAoLY2xpZW50X3BvcnQYCyABKAlIBogBARIxCg1iYWNrZW5kX3N0YXJ0GAwgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIzCgp4YWN0X3N0YXJ0GA0gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgHiAEBEjQKC3F1ZXJ5X3N0YXJ0GA4gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgIiAEBQggKBl9zdGF0ZUISChBfd2FpdF9ldmVudF90eXBlQg0KC193YWl0X2V2ZW50QgoKCF9kYXRuYW1lQgoKCF91c2VuYW1lQg4KDF9jbGllbnRfYWRkckIOCgxfY2xpZW50X3BvcnRCDQoLX3hhY3Rfc3RhcnRCDgoMX3F1ZXJ5X3N0YXJ0OoAB6kF9ChtieXRlYmFzZS5jb20vVGFza1J1blNlc3Npb24SXnByb2plY3RzL3twcm9qZWN0fS9wbGFucy97cGxhbn0vcm9sbG91dC9zdGFnZXMve3N0YWdlfS90YXNrcy97dGFza30vdGFza1J1bnMve3Rhc2tSdW59L3Nlc3Npb25CCQoHc2Vzc2lvbiJLCh1QcmV2aWV3VGFza1J1blJvbGxiYWNrUmVxdWVzdBIqCgRuYW1lGAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9UYXNrUnVuIjMKHlByZXZpZXdUYXNrUnVuUm9sbGJhY2tSZXNwb25zZRIRCglzdGF0ZW1lbnQYASABKAkyoRAKDlJvbGxvdXRTZXJ2aWNlEo8BCgpHZXRSb2xsb3V0Eh4uYnl0ZWJhc2UudjEuR2V0Um9sbG91dFJlcXVlc3QaFC5ieXRlYmFzZS52MS5Sb2xsb3V0IkvaQQRuYW1liuowD2JiLnJvbGxvdXRzLmdldJDqMAGC0+STAicSJS92MS97bmFtZT1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dH0SngEKDExpc3RSb2xsb3V0cxIgLmJ5dGViYXNlLnYxLkxpc3RSb2xsb3V0c1JlcXVlc3QaIS5ieXRlYmFzZS52MS5MaXN0Um9sbG91dHNSZXNwb25zZSJJ2kEGcGFyZW50iuowEGJiLnJvbGxvdXRzLmxpc3SQ6jABgtPkkwIiEiAvdjEve3BhcmVudD1wcm9qZWN0cy8qfS9yb2xsb3V0cxKjAQoNQ3JlYXRlUm9sbG91dBIhLmJ5dGViYXNlLnYxLkNyZWF0ZVJvbGxvdXRSZXF1ZXN0GhQuYnl0ZWJhc2UudjEuUm9sbG91dCJZ2kEGcGFyZW50iuowEmJiLnJvbGxvdXRzLmNyZWF0ZZDqMAGY6jABgtPkkwIsOgEqIicvdjEve3BhcmVudD1wcm9qZWN0cy8qL3BsYW5zLyp9L3JvbGxvdXQSvwEKDExpc3RUYXNrUnVucxIgLmJ5dGViYXNlLnYxLkxpc3RUYXNrUnVuc1JlcXVlc3QaIS5ieXRlYmFzZS52MS5MaXN0VGFza1J1bnNSZXNwb25zZSJq2kEGcGFyZW50iuowEGJiLnRhc2tSdW5zLmxpc3SQ6jABgtPkkwJDEkEvdjEve3BhcmVudD1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dC9zdGFnZXMvKi90YXNrcy8qfS90YXNrUnVucxKsAQoKR2V0VGFza1J1bhIeLmJ5dGViYXNlLnYxLkdldFRhc2tSdW5SZXF1ZXN0GhQuYnl0ZWJhc2UudjEuVGFza1J1biJo2kEEbmFtZYrqMBBiYi50YXNrUnVucy5saXN0kOowAYLT5JMCQxJBL3YxL3tuYW1lPXByb2plY3RzLyovcGxhbnMvKi9yb2xsb3V0L3N0YWdlcy8qL3Rhc2tzLyovdGFza1J1bnMvKn0SvQEKDUdldFRhc2tSdW5Mb2cSIS5ieXRlYmFzZS52MS5HZXRUYXNrUnVuTG9nUmVxdWVzdBoXLmJ5dGViYXNlLnYxLlRhc2tSdW5Mb2cicNpBBnBhcmVudIrqMBBiYi50YXNrUnVucy5saXN0kOowAYLT5JMCSRJHL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9wbGFucy8qL3JvbGxvdXQvc3RhZ2VzLyovdGFza3MvKi90YXNrUnVucy8qfS9sb2cSzQEKEUdldFRhc2tSdW5TZXNzaW9uEiUuYnl0ZWJhc2UudjEuR2V0VGFza1J1blNlc3Npb25SZXF1ZXN0GhsuYnl0ZWJhc2UudjEuVGFza1J1blNlc3Npb24idNpBBnBhcmVudIrqMBBiYi50YXNrUnVucy5saXN0kOowAYLT5JMCTRJLL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9wbGFucy8qL3JvbGxvdXQvc3RhZ2VzLyovdGFza3MvKi90YXNrUnVucy8qfS9zZXNzaW9uErMBCg1CYXRjaFJ1blRhc2tzEiEuYnl0ZWJhc2UudjEuQmF0Y2hSdW5UYXNrc1JlcXVlc3QaIi5ieXRlYmFzZS52MS5CYXRjaFJ1blRhc2tzUmVzcG9uc2UiW9pBBnBhcmVudJDqMAKY6jABgtPkkwJEOgEqIj8vdjEve3BhcmVudD1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dC9zdGFnZXMvKn0vdGFza3M6YmF0Y2hSdW4StwEKDkJhdGNoU2tpcFRhc2tzEiIuYnl0ZWJhc2UudjEuQmF0Y2hTa2lwVGFza3NSZXF1ZXN0GiMuYnl0ZWJhc2UudjEuQmF0Y2hTa2lwVGFza3NSZXNwb25zZSJc2kEGcGFyZW50kOowApjqMAGC0+STAkU6ASoiQC92MS97cGFyZW50PXByb2plY3RzLyovcGxhbnMvKi9yb2xsb3V0L3N0YWdlcy8qfS90YXNrczpiYXRjaFNraXAS0wEKE0JhdGNoQ2FuY2VsVGFza1J1bnMSJy5ieXRlYmFzZS52MS5CYXRjaENhbmNlbFRhc2tSdW5zUmVxdWVzdBooLmJ5dGViYXNlLnYxLkJhdGNoQ2FuY2VsVGFza1J1bnNSZXNwb25zZSJp2kEGcGFyZW50kOowApjqMAGC0+STAlI6ASoiTS92MS97cGFyZW50PXByb2plY3RzLyovcGxhbnMvKi9yb2xsb3V0L3N0YWdlcy8qL3Rhc2tzLyp9L3Rhc2tSdW5zOmJhdGNoQ2FuY2VsEu4BChZQcmV2aWV3VGFza1J1blJvbGxiYWNrEiouYnl0ZWJhc2UudjEuUHJldmlld1Rhc2tSdW5Sb2xsYmFja1JlcXVlc3QaKy5ieXRlYmFzZS52MS5QcmV2aWV3VGFza1J1blJvbGxiYWNrUmVzcG9uc2Uie9pBBG5hbWWK6jAQYmIudGFza1J1bnMubGlzdJDqMAGC0+STAlY6ASoiUS92MS97bmFtZT1wcm9qZWN0cy8qL3BsYW5zLyovcm9sbG91dC9zdGFnZXMvKi90YXNrcy8qL3Rhc2tSdW5zLyp9OnByZXZpZXdSb2xsYmFja0KpAQoPY29tLmJ5dGViYXNlLnYxQhNSb2xsb3V0U2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [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.tsindex 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.yamlindex 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+ - AVAILABLEtype: stringdescription: The current execution status of the task run.format: enumdiff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex 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.htmlindex 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.mdindex 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.htmlindex 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.protoindex 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.protoindex 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;