Skip to content

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

feat: add pre-execution drift validation for stale tasks (#BYT-8875) (#19325)

boojack107e6c131081
diff --git a/backend/runner/taskrun/running_scheduler.go b/backend/runner/taskrun/running_scheduler.go
index c0481e1fe3..781bc3b833 100644
--- a/backend/runner/taskrun/running_scheduler.go
+++ b/backend/runner/taskrun/running_scheduler.go
@@ -75,6 +75,27 @@ func (s *Scheduler) executeTaskRun(ctx context.Context, taskRunUID, taskUID int)
return errors.Errorf("task %v not found", taskUID)
}
+ // Validate task freshness before execution.
+ if err := s.validateTaskFreshness(ctx, task); err != nil {
+ slog.Warn("task run blocked by drift validation",
+ slog.Int("id", task.ID),
+ slog.String("type", task.Type.String()),
+ log.BBError(err),
+ )
+ taskRunStatusPatch := &store.TaskRunStatusPatch{
+ ID: taskRunUID,
+ Updater: "",
+ Status: storepb.TaskRun_FAILED,
+ ResultProto: &storepb.TaskRunResult{
+ Detail: err.Error(),
+ },
+ }
+ if _, patchErr := s.store.UpdateTaskRunStatus(ctx, taskRunStatusPatch); patchErr != nil {
+ return errors.Wrapf(patchErr, "failed to mark task run as failed after drift detection")
+ }
+ return nil
+ }
+
executor, ok := s.executorMap[task.Type]
if !ok {
return errors.Errorf("executor not found for task type: %v", task.Type)
@@ -200,6 +221,53 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRunUID int, task *st
s.bus.PlanCompletionCheckChan <- task.PlanID
}
+// validateTaskFreshness checks for state drift between task creation and execution time.
+// Returns an error if the target database has been deleted, its project has changed,
+// or its environment has changed since the task was created.
+func (s *Scheduler) validateTaskFreshness(ctx context.Context, task *store.TaskMessage) error {
+ // DATABASE_CREATE tasks have DatabaseName = nil — the database doesn't exist yet.
+ if task.Type == storepb.Task_DATABASE_CREATE {
+ return nil
+ }
+
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &task.InstanceID,
+ DatabaseName: task.DatabaseName,
+ })
+ if err != nil {
+ return errors.Wrapf(err, "failed to get database for drift validation")
+ }
+ if database == nil {
+ return errors.Errorf("target database %q on instance %q has been deleted", task.GetDatabaseName(), task.InstanceID)
+ }
+
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})
+ if err != nil {
+ return errors.Wrapf(err, "failed to get plan for drift validation")
+ }
+ if plan == nil {
+ return errors.Errorf("plan %d not found", task.PlanID)
+ }
+
+ return checkTaskDrift(task, database, plan)
+}
+
+// checkTaskDrift performs the actual drift comparison logic.
+// Returns nil if no drift, or an error describing the drift.
+func checkTaskDrift(task *store.TaskMessage, database *store.DatabaseMessage, plan *store.PlanMessage) error {
+ // Check project drift.
+ if database.ProjectID != plan.ProjectID {
+ return errors.Errorf("target database belongs to project %q, but plan belongs to project %q", database.ProjectID, plan.ProjectID)
+ }
+
+ // Check environment drift.
+ if task.Environment != "" && database.EffectiveEnvironmentID != nil && *database.EffectiveEnvironmentID != task.Environment {
+ return errors.Errorf("target database is in environment %q, but task expected environment %q", *database.EffectiveEnvironmentID, task.Environment)
+ }
+
+ return nil
+}
+
// isSequentialTask returns whether the task should be executed sequentially.
func isSequentialTask(task *store.TaskMessage) bool {
//exhaustive:enforce
diff --git a/backend/runner/taskrun/running_scheduler_test.go b/backend/runner/taskrun/running_scheduler_test.go
new file mode 100644
index 0000000000..ac107d6fef
--- /dev/null
+++ b/backend/runner/taskrun/running_scheduler_test.go
@@ -0,0 +1,156 @@
+package taskrun
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+func TestCheckTaskDrift(t *testing.T) {
+ prodEnv := "prod"
+ stagingEnv := "staging"
+ dbName := "mydb"
+
+ tests := []struct {
+ name string
+ task *store.TaskMessage
+ database *store.DatabaseMessage
+ plan *store.PlanMessage
+ wantErr bool
+ errContains string
+ }{
+ {
+ name: "no drift",
+ task: &store.TaskMessage{
+ InstanceID: "inst-1",
+ DatabaseName: &dbName,
+ Environment: "prod",
+ Type: storepb.Task_DATABASE_MIGRATE,
+ },
+ database: &store.DatabaseMessage{
+ ProjectID: "proj-1",
+ EffectiveEnvironmentID: &prodEnv,
+ },
+ plan: &store.PlanMessage{
+ ProjectID: "proj-1",
+ },
+ wantErr: false,
+ },
+ {
+ name: "project drift",
+ task: &store.TaskMessage{
+ InstanceID: "inst-1",
+ DatabaseName: &dbName,
+ Environment: "prod",
+ Type: storepb.Task_DATABASE_MIGRATE,
+ },
+ database: &store.DatabaseMessage{
+ ProjectID: "proj-other",
+ EffectiveEnvironmentID: &prodEnv,
+ },
+ plan: &store.PlanMessage{
+ ProjectID: "proj-original",
+ },
+ wantErr: true,
+ errContains: "project",
+ },
+ {
+ name: "environment drift",
+ task: &store.TaskMessage{
+ InstanceID: "inst-1",
+ DatabaseName: &dbName,
+ Environment: "prod",
+ Type: storepb.Task_DATABASE_MIGRATE,
+ },
+ database: &store.DatabaseMessage{
+ ProjectID: "proj-1",
+ EffectiveEnvironmentID: &stagingEnv,
+ },
+ plan: &store.PlanMessage{
+ ProjectID: "proj-1",
+ },
+ wantErr: true,
+ errContains: "environment",
+ },
+ {
+ name: "project and environment drift returns project error first",
+ task: &store.TaskMessage{
+ InstanceID: "inst-1",
+ DatabaseName: &dbName,
+ Environment: "prod",
+ Type: storepb.Task_DATABASE_MIGRATE,
+ },
+ database: &store.DatabaseMessage{
+ ProjectID: "proj-other",
+ EffectiveEnvironmentID: &stagingEnv,
+ },
+ plan: &store.PlanMessage{
+ ProjectID: "proj-original",
+ },
+ wantErr: true,
+ errContains: "project",
+ },
+ {
+ name: "empty task environment skips env check",
+ task: &store.TaskMessage{
+ InstanceID: "inst-1",
+ DatabaseName: &dbName,
+ Environment: "",
+ Type: storepb.Task_DATABASE_MIGRATE,
+ },
+ database: &store.DatabaseMessage{
+ ProjectID: "proj-1",
+ EffectiveEnvironmentID: &stagingEnv,
+ },
+ plan: &store.PlanMessage{
+ ProjectID: "proj-1",
+ },
+ wantErr: false,
+ },
+ {
+ name: "nil effective environment skips env check",
+ task: &store.TaskMessage{
+ InstanceID: "inst-1",
+ DatabaseName: &dbName,
+ Environment: "prod",
+ Type: storepb.Task_DATABASE_MIGRATE,
+ },
+ database: &store.DatabaseMessage{
+ ProjectID: "proj-1",
+ EffectiveEnvironmentID: nil,
+ },
+ plan: &store.PlanMessage{
+ ProjectID: "proj-1",
+ },
+ wantErr: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ err := checkTaskDrift(tt.task, tt.database, tt.plan)
+ if tt.wantErr {
+ require.Error(t, err)
+ require.Contains(t, err.Error(), tt.errContains)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateTaskFreshness_DatabaseCreateSkipsValidation(t *testing.T) {
+ // Construct a Scheduler with nil store. If validateTaskFreshness tries to
+ // call the store for DATABASE_CREATE tasks, it will panic — proving the
+ // early return works.
+ s := &Scheduler{}
+ task := &store.TaskMessage{
+ Type: storepb.Task_DATABASE_CREATE,
+ }
+ err := s.validateTaskFreshness(context.Background(), task)
+ require.NoError(t, err)
+}