Skip to content

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

refactor: remove terminated bool from task run executors (#18757)

Danny Xud25e124c648d
diff --git a/backend/runner/taskrun/data_export_executor.go b/backend/runner/taskrun/data_export_executor.go
index a1fd7e5bd3..3d25b063b6 100644
--- a/backend/runner/taskrun/data_export_executor.go
+++ b/backend/runner/taskrun/data_export_executor.go
@@ -44,50 +44,50 @@ type DataExportExecutor struct {
}
// RunOnce will run the data export task executor once.
-func (exec *DataExportExecutor) RunOnce(ctx context.Context, _ context.Context, task *store.TaskMessage, _ int) (terminated bool, result *storepb.TaskRunResult, err error) {
+func (exec *DataExportExecutor) RunOnce(ctx context.Context, _ context.Context, task *store.TaskMessage, _ int) (*storepb.TaskRunResult, error) {
issue, err := exec.store.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &task.PlanID})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get issue")
+ return nil, errors.Wrapf(err, "failed to get issue")
}
database, err := exec.store.GetDatabase(ctx, &store.FindDatabaseMessage{InstanceID: &task.InstanceID, DatabaseName: task.DatabaseName, ShowDeleted: true})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get database")
+ return nil, errors.Wrapf(err, "failed to get database")
}
if database == nil {
- return true, nil, errors.Errorf("database not found")
+ return nil, errors.Errorf("database not found")
}
instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &database.InstanceID, ShowDeleted: true})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get instance")
+ return nil, errors.Wrapf(err, "failed to get instance")
}
if instance == nil {
- return true, nil, errors.Errorf("instance not found")
+ return nil, errors.Errorf("instance not found")
}
sheet, err := exec.store.GetSheetFull(ctx, task.Payload.GetSheetSha256())
if err != nil {
- return true, nil, err
+ return nil, err
}
if sheet == nil {
- return true, nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
+ return nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
}
statement := sheet.Statement
dataSource := apiv1.GetQueriableDataSource(instance)
creatorUser, err := exec.store.GetUserByEmail(ctx, issue.CreatorEmail)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get creator user for issue %d", issue.UID)
+ return nil, errors.Wrapf(err, "failed to get creator user for issue %d", issue.UID)
}
if creatorUser == nil {
- return true, nil, errors.Errorf("creator user not found for issue %d", issue.UID)
+ return nil, errors.Errorf("creator user not found for issue %d", issue.UID)
}
// Execute the export without masking.
// For approved DATABASE_EXPORT tasks, the approval itself authorizes access to the data.
bytes, exportErr := exec.executeExport(ctx, instance, database, dataSource, statement, task.Payload.GetFormat(), creatorUser)
if exportErr != nil {
- return true, nil, errors.Wrap(exportErr, "failed to export data")
+ return nil, errors.Wrap(exportErr, "failed to export data")
}
exportArchive, err := exec.store.CreateExportArchive(ctx, &store.ExportArchiveMessage{
@@ -97,10 +97,10 @@ func (exec *DataExportExecutor) RunOnce(ctx context.Context, _ context.Context,
},
})
if err != nil {
- return true, nil, errors.Wrap(err, "failed to create export archive")
+ return nil, errors.Wrap(err, "failed to create export archive")
}
- return true, &storepb.TaskRunResult{
+ return &storepb.TaskRunResult{
Detail: "Data export succeeded",
ExportArchiveUid: int32(exportArchive.UID),
}, nil
diff --git a/backend/runner/taskrun/database_create_executor.go b/backend/runner/taskrun/database_create_executor.go
index 51914eacee..ce33570832 100644
--- a/backend/runner/taskrun/database_create_executor.go
+++ b/backend/runner/taskrun/database_create_executor.go
@@ -34,36 +34,36 @@ type DatabaseCreateExecutor struct {
}
// RunOnce will run the database create task executor once.
-func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, _ int) (terminated bool, result *storepb.TaskRunResult, err error) {
+func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, _ int) (*storepb.TaskRunResult, error) {
sheet, err := exec.store.GetSheetFull(ctx, task.Payload.GetSheetSha256())
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get sheet: %s", task.Payload.GetSheetSha256())
+ return nil, errors.Wrapf(err, "failed to get sheet: %s", task.Payload.GetSheetSha256())
}
if sheet == nil {
- return true, nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
+ return nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
}
statement := sheet.Statement
statement = strings.TrimSpace(statement)
if statement == "" {
- return true, nil, errors.Errorf("empty create database statement")
+ return nil, errors.Errorf("empty create database statement")
}
instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})
if err != nil {
- return true, nil, err
+ return nil, err
}
if !common.EngineSupportCreateDatabase(instance.Metadata.GetEngine()) {
- return true, nil, errors.Errorf("creating database is not supported for engine %v", instance.Metadata.GetEngine().String())
+ return nil, errors.Errorf("creating database is not supported for engine %v", instance.Metadata.GetEngine().String())
}
plan, err := exec.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get plan %v", task.PlanID)
+ return nil, errors.Wrapf(err, "failed to get plan %v", task.PlanID)
}
if plan == nil {
- return true, nil, errors.Errorf("plan %v not found", task.PlanID)
+ return nil, errors.Errorf("plan %v not found", task.PlanID)
}
// Create database.
@@ -86,7 +86,7 @@ func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx conte
Metadata: &storepb.DatabaseMetadata{},
})
if err != nil {
- return true, nil, err
+ return nil, err
}
var defaultDBDriver db.Driver
@@ -97,17 +97,17 @@ func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx conte
// NOTE: we have to hack the database message.
defaultDBDriver, err = exec.dbFactory.GetAdminDatabaseDriver(ctx, instance, database, db.ConnectionContext{})
if err != nil {
- return true, nil, err
+ return nil, err
}
default:
defaultDBDriver, err = exec.dbFactory.GetAdminDatabaseDriver(ctx, instance, nil /* database */, db.ConnectionContext{})
if err != nil {
- return true, nil, err
+ return nil, err
}
}
defer defaultDBDriver.Close(ctx)
if _, err := defaultDBDriver.Execute(driverCtx, statement, db.ExecuteOptions{CreateDatabase: true}); err != nil {
- return true, nil, err
+ return nil, err
}
if err := exec.schemaSyncer.SyncDatabaseSchema(ctx, database); err != nil {
@@ -118,7 +118,7 @@ func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx conte
)
}
- return true, &storepb.TaskRunResult{
+ return &storepb.TaskRunResult{
Detail: fmt.Sprintf("Created database %q", task.Payload.GetDatabaseName()),
}, nil
}
diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.go
index 2251beb4e1..601aabd182 100644
--- a/backend/runner/taskrun/database_migrate_executor.go
+++ b/backend/runner/taskrun/database_migrate_executor.go
@@ -52,22 +52,22 @@ type DatabaseMigrateExecutor struct {
}
// RunOnce will run the database migration task executor once.
-func (exec *DatabaseMigrateExecutor) RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (bool, *storepb.TaskRunResult, error) {
+func (exec *DatabaseMigrateExecutor) RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (*storepb.TaskRunResult, error) {
// Check if this is a release-based task
if releaseName := task.Payload.GetRelease(); releaseName != "" {
// Parse release name to get project ID and release UID
_, releaseUID, err := common.GetProjectReleaseUID(releaseName)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to parse release name %q", releaseName)
+ return nil, errors.Wrapf(err, "failed to parse release name %q", releaseName)
}
// Fetch the release
release, err := exec.store.GetReleaseByUID(ctx, releaseUID)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get release %d", releaseUID)
+ return nil, errors.Wrapf(err, "failed to get release %d", releaseUID)
}
if release == nil {
- return true, nil, errors.Errorf("release %d not found", releaseUID)
+ return nil, errors.Errorf("release %d not found", releaseUID)
}
// Switch based on release type
@@ -77,7 +77,7 @@ func (exec *DatabaseMigrateExecutor) RunOnce(ctx context.Context, driverCtx cont
case storepb.SchemaChangeType_DECLARATIVE:
return exec.runDeclarativeRelease(ctx, driverCtx, task, taskRunUID, release)
default:
- return true, nil, errors.Errorf("unsupported release type %q", release.Payload.Type)
+ return nil, errors.Errorf("unsupported release type %q", release.Payload.Type)
}
}
@@ -87,13 +87,13 @@ func (exec *DatabaseMigrateExecutor) RunOnce(ctx context.Context, driverCtx cont
return exec.runMigrationWithPriorBackup(ctx, driverCtx, task, taskRunUID)
}
-func (exec *DatabaseMigrateExecutor) runMigrationWithPriorBackup(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (bool, *storepb.TaskRunResult, error) {
+func (exec *DatabaseMigrateExecutor) runMigrationWithPriorBackup(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (*storepb.TaskRunResult, error) {
sheet, err := exec.store.GetSheetFull(ctx, task.Payload.GetSheetSha256())
if err != nil {
- return true, nil, err
+ return nil, err
}
if sheet == nil {
- return true, nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
+ return nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
}
// Handle prior backup if enabled.
@@ -103,17 +103,17 @@ func (exec *DatabaseMigrateExecutor) runMigrationWithPriorBackup(ctx context.Con
if task.Payload.GetEnablePriorBackup() {
instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})
if err != nil {
- return true, nil, errors.Wrap(err, "failed to get instance")
+ return nil, errors.Wrap(err, "failed to get instance")
}
if instance == nil {
- return true, nil, errors.Errorf("instance not found for task %v", task.ID)
+ return nil, errors.Errorf("instance not found for task %v", task.ID)
}
database, err := exec.store.GetDatabase(ctx, &store.FindDatabaseMessage{InstanceID: &task.InstanceID, DatabaseName: task.DatabaseName})
if err != nil {
- return true, nil, errors.Wrap(err, "failed to get database")
+ return nil, errors.Wrap(err, "failed to get database")
}
if database == nil {
- return true, nil, errors.Errorf("database not found for task %v", task.ID)
+ return nil, errors.Errorf("database not found for task %v", task.ID)
}
exec.store.CreateTaskRunLogS(ctx, taskRunUID, time.Now(), exec.profile.DeployID, &storepb.TaskRunLog{
@@ -136,10 +136,10 @@ func (exec *DatabaseMigrateExecutor) runMigrationWithPriorBackup(ctx context.Con
// Check if we should skip backup error and continue to run migration.
skip, err := exec.shouldSkipBackupError(ctx, task)
if err != nil {
- return true, nil, errors.Errorf("failed to check skip backup error or not: %v", err)
+ return nil, errors.Errorf("failed to check skip backup error or not: %v", err)
}
if !skip {
- return true, nil, backupErr
+ return nil, backupErr
}
} else {
exec.store.CreateTaskRunLogS(ctx, taskRunUID, time.Now(), exec.profile.DeployID, &storepb.TaskRunLog{
@@ -152,37 +152,37 @@ func (exec *DatabaseMigrateExecutor) runMigrationWithPriorBackup(ctx context.Con
}
}
- terminated, result, err := runMigration(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_SCHEMA_CHANGE_TYPE_UNSPECIFIED)
+ result, err := runMigration(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_SCHEMA_CHANGE_TYPE_UNSPECIFIED)
if result != nil {
// Save prior backup detail to task run result.
result.PriorBackupDetail = priorBackupDetail
}
- return terminated, result, err
+ return result, err
}
-func (exec *DatabaseMigrateExecutor) runGhostMigration(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (bool, *storepb.TaskRunResult, error) {
+func (exec *DatabaseMigrateExecutor) runGhostMigration(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (*storepb.TaskRunResult, error) {
sheet, err := exec.store.GetSheetFull(ctx, task.Payload.GetSheetSha256())
if err != nil {
- return true, nil, err
+ return nil, err
}
if sheet == nil {
- return true, nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
+ return nil, errors.Errorf("sheet not found: %s", task.Payload.GetSheetSha256())
}
flags := task.Payload.GetFlags()
instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})
if err != nil {
- return true, nil, err
+ return nil, err
}
if instance == nil {
- return true, nil, errors.Errorf("instance %s not found", task.InstanceID)
+ return nil, errors.Errorf("instance %s not found", task.InstanceID)
}
database, err := exec.store.GetDatabase(ctx, &store.FindDatabaseMessage{InstanceID: &task.InstanceID, DatabaseName: task.DatabaseName})
if err != nil {
- return true, nil, err
+ return nil, err
}
if database == nil {
- return true, nil, errors.Errorf("database not found")
+ return nil, errors.Errorf("database not found")
}
execFunc := func(execCtx context.Context, execStatement string, driver db.Driver, _ db.ExecuteOptions) error {
@@ -262,14 +262,14 @@ func (exec *DatabaseMigrateExecutor) runGhostMigration(ctx context.Context, driv
return runMigrationWithFunc(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_SCHEMA_CHANGE_TYPE_UNSPECIFIED, execFunc)
}
-func (exec *DatabaseMigrateExecutor) runVersionedRelease(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, release *store.ReleaseMessage) (bool, *storepb.TaskRunResult, error) {
+func (exec *DatabaseMigrateExecutor) runVersionedRelease(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, release *store.ReleaseMessage) (*storepb.TaskRunResult, error) {
// Get existing revisions for this database
revisions, err := exec.store.ListRevisions(ctx, &store.FindRevisionMessage{
InstanceID: &task.InstanceID,
DatabaseName: task.DatabaseName,
})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to list revisions for database %q", *task.DatabaseName)
+ return nil, errors.Wrapf(err, "failed to list revisions for database %q", *task.DatabaseName)
}
// Build map of applied versions
@@ -293,10 +293,10 @@ func (exec *DatabaseMigrateExecutor) runVersionedRelease(ctx context.Context, dr
// Fetch and execute this file
sheet, err := exec.store.GetSheetFull(ctx, file.SheetSha256)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)
+ return nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)
}
if sheet == nil {
- return true, nil, errors.Errorf("sheet not found: %s", file.SheetSha256)
+ return nil, errors.Errorf("sheet not found: %s", file.SheetSha256)
}
slog.Info("executing release file",
@@ -314,24 +314,24 @@ func (exec *DatabaseMigrateExecutor) runVersionedRelease(ctx context.Context, dr
})
// Execute migration for this file
- _, _, err = runMigration(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, file.Version, storepb.SchemaChangeType_VERSIONED)
+ _, err = runMigration(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, file.Version, storepb.SchemaChangeType_VERSIONED)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to execute release file %s (version %s)", file.Path, file.Version)
+ return nil, errors.Wrapf(err, "failed to execute release file %s (version %s)", file.Path, file.Version)
}
}
- return true, &storepb.TaskRunResult{
+ return &storepb.TaskRunResult{
Detail: "Versioned release executed successfully",
}, nil
}
-func (exec *DatabaseMigrateExecutor) runDeclarativeRelease(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, release *store.ReleaseMessage) (bool, *storepb.TaskRunResult, error) {
+func (exec *DatabaseMigrateExecutor) runDeclarativeRelease(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, release *store.ReleaseMessage) (*storepb.TaskRunResult, error) {
// Declarative releases should have exactly one file
if len(release.Payload.Files) == 0 {
- return true, nil, errors.Errorf("no files found in declarative release")
+ return nil, errors.Errorf("no files found in declarative release")
}
if len(release.Payload.Files) > 1 {
- return true, nil, errors.Errorf("declarative release should have exactly one file, found %d", len(release.Payload.Files))
+ return nil, errors.Errorf("declarative release should have exactly one file, found %d", len(release.Payload.Files))
}
file := release.Payload.Files[0]
@@ -339,10 +339,10 @@ func (exec *DatabaseMigrateExecutor) runDeclarativeRelease(ctx context.Context,
// Fetch the schema file
sheet, err := exec.store.GetSheetFull(ctx, file.SheetSha256)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)
+ return nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)
}
if sheet == nil {
- return true, nil, errors.Errorf("sheet not found: %s", file.SheetSha256)
+ return nil, errors.Errorf("sheet not found: %s", file.SheetSha256)
}
slog.Info("executing declarative release",
@@ -362,11 +362,11 @@ func (exec *DatabaseMigrateExecutor) runDeclarativeRelease(ctx context.Context,
// Get instance and database for SDL diff
instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get instance %s", task.InstanceID)
+ return nil, errors.Wrapf(err, "failed to get instance %s", task.InstanceID)
}
database, err := exec.store.GetDatabase(ctx, &store.FindDatabaseMessage{InstanceID: &task.InstanceID, DatabaseName: task.DatabaseName})
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to get database %s", *task.DatabaseName)
+ return nil, errors.Wrapf(err, "failed to get database %s", *task.DatabaseName)
}
// Create execFunc that uses SDL diff logic (same as old SchemaDeclareExecutor)
@@ -390,12 +390,12 @@ func (exec *DatabaseMigrateExecutor) runDeclarativeRelease(ctx context.Context,
// Execute SDL migration using the diff logic
// For DECLARATIVE releases, pass empty string for version (revisions are not version-tracked)
// runMigrationWithFunc will handle version checking for DECLARATIVE releases (see executor.go:332-357)
- _, _, err = runMigrationWithFunc(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_DECLARATIVE, execFunc)
+ _, err = runMigrationWithFunc(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_DECLARATIVE, execFunc)
if err != nil {
- return true, nil, errors.Wrapf(err, "failed to execute declarative release (version %s)", file.Version)
+ return nil, errors.Wrapf(err, "failed to execute declarative release (version %s)", file.Version)
}
- return true, &storepb.TaskRunResult{
+ return &storepb.TaskRunResult{
Detail: "Declarative release executed successfully",
}, nil
}
diff --git a/backend/runner/taskrun/executor.go b/backend/runner/taskrun/executor.go
index 32f8d39187..6b9da6d658 100644
--- a/backend/runner/taskrun/executor.go
+++ b/backend/runner/taskrun/executor.go
@@ -23,22 +23,17 @@ import (
// Executor is the task executor.
type Executor interface {
- // RunOnce will be called periodically by the scheduler until terminated is true.
- //
- // NOTE
- //
- // 1. It's possible that err could be non-nil while terminated is false, which
- // usually indicates a transient error and will make scheduler retry later.
- // 2. If err is non-nil, then the detail field will be ignored since info is provided in the err.
+ // RunOnce will be called once by the scheduler to execute the task.
+ // If err is non-nil, the task will be marked as failed.
// driverCtx is used by the database driver so that we can cancel the query
- // while have the ability to cleanup migration history etc.
- RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (terminated bool, result *storepb.TaskRunResult, err error)
+ // while having the ability to cleanup migration history etc.
+ RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (result *storepb.TaskRunResult, err error)
}
type execFuncType func(context.Context, string, db.Driver, db.ExecuteOptions) error
// RunExecutorOnce wraps a TaskExecutor.RunOnce call with panic recovery.
-func RunExecutorOnce(ctx context.Context, driverCtx context.Context, exec Executor, task *store.TaskMessage, taskRunUID int) (terminated bool, result *storepb.TaskRunResult, err error) {
+func RunExecutorOnce(ctx context.Context, driverCtx context.Context, exec Executor, task *store.TaskMessage, taskRunUID int) (result *storepb.TaskRunResult, err error) {
defer func() {
if r := recover(); r != nil {
panicErr, ok := r.(error)
@@ -46,7 +41,6 @@ func RunExecutorOnce(ctx context.Context, driverCtx context.Context, exec Execut
panicErr = errors.Errorf("%v", r)
}
slog.Error("TaskExecutor PANIC RECOVER", log.BBError(panicErr), log.BBStack("panic-stack"))
- terminated = true
result = nil
err = errors.Errorf("TaskExecutor PANIC RECOVER, err: %v", panicErr)
}
@@ -95,7 +89,7 @@ func getCreateTaskRunLog(ctx context.Context, taskRunUID int, s *store.Store, pr
}
}
-func runMigration(ctx context.Context, driverCtx context.Context, store *store.Store, dbFactory *dbfactory.DBFactory, syncer *schemasync.Syncer, profile *config.Profile, task *store.TaskMessage, taskRunUID int, sheet *store.SheetMessage, schemaVersion string, releaseType storepb.SchemaChangeType) (terminated bool, result *storepb.TaskRunResult, err error) {
+func runMigration(ctx context.Context, driverCtx context.Context, store *store.Store, dbFactory *dbfactory.DBFactory, syncer *schemasync.Syncer, profile *config.Profile, task *store.TaskMessage, taskRunUID int, sheet *store.SheetMessage, schemaVersion string, releaseType storepb.SchemaChangeType) (*storepb.TaskRunResult, error) {
return runMigrationWithFunc(ctx, driverCtx, store, dbFactory, syncer, profile, task, taskRunUID, sheet, schemaVersion, releaseType, nil /* default */)
}
@@ -112,10 +106,10 @@ func runMigrationWithFunc(
schemaVersion string,
releaseType storepb.SchemaChangeType,
execFunc execFuncType,
-) (terminated bool, result *storepb.TaskRunResult, err error) {
+) (*storepb.TaskRunResult, error) {
mc, err := getMigrationInfo(ctx, store, profile, syncer, task, schemaVersion, sheet, taskRunUID, dbFactory)
if err != nil {
- return true, nil, err
+ return nil, err
}
mc.releaseType = releaseType
@@ -125,7 +119,7 @@ func runMigrationWithFunc(
skipped, err := doMigrationWithFunc(ctx, driverCtx, store, profile, sheet.Statement, mc, execFunc)
if err != nil {
- return true, nil, err
+ return nil, err
}
return postMigration(ctx, store, mc, skipped)
}
@@ -239,9 +233,9 @@ func doMigrationWithFunc(
return executeMigrationWithFunc(ctx, driverCtx, stores, mc, statement, execFunc, driver, opts)
}
-func postMigration(ctx context.Context, stores *store.Store, mc *migrateContext, skipped bool) (bool, *storepb.TaskRunResult, error) {
+func postMigration(ctx context.Context, stores *store.Store, mc *migrateContext, skipped bool) (*storepb.TaskRunResult, error) {
if skipped {
- return true, &storepb.TaskRunResult{
+ return &storepb.TaskRunResult{
Detail: fmt.Sprintf("Task skipped because version %s has been applied", mc.version),
}, nil
}
@@ -262,7 +256,7 @@ func postMigration(ctx context.Context, stores *store.Store, mc *migrateContext,
md.Drifted = false
}},
}); err != nil {
- return false, nil, errors.Wrapf(err, "failed to update database %q for instance %q", database.DatabaseName, database.InstanceID)
+ return nil, errors.Wrapf(err, "failed to update database %q for instance %q", database.DatabaseName, database.InstanceID)
}
var detail string
@@ -272,7 +266,7 @@ func postMigration(ctx context.Context, stores *store.Store, mc *migrateContext,
detail = fmt.Sprintf("Applied migration version %s to database %q.", mc.version, database.DatabaseName)
}
- return true, &storepb.TaskRunResult{
+ return &storepb.TaskRunResult{
Detail: detail,
}, nil
}
diff --git a/backend/runner/taskrun/running_scheduler.go b/backend/runner/taskrun/running_scheduler.go
index 2e15c16902..48f42eac7f 100644
--- a/backend/runner/taskrun/running_scheduler.go
+++ b/backend/runner/taskrun/running_scheduler.go
@@ -108,18 +108,9 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRunUID int, task *st
defer cancel()
s.bus.RunningTaskRunsCancelFunc.Store(taskRunUID, cancel)
- done, result, err := RunExecutorOnce(ctx, driverCtx, executor, task, taskRunUID)
+ result, err := RunExecutorOnce(ctx, driverCtx, executor, task, taskRunUID)
- switch {
- case !done && err != nil:
- slog.Debug("Encountered transient error running task, will retry",
- slog.Int("id", task.ID),
- slog.String("type", task.Type.String()),
- log.BBError(err),
- )
- return
-
- case done && err != nil && errors.Is(err, context.Canceled):
+ if err != nil && errors.Is(err, context.Canceled) {
slog.Warn("task run is canceled",
slog.Int("id", task.ID),
slog.String("type", task.Type.String()),
@@ -153,8 +144,9 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRunUID int, task *st
return
}
return
+ }
- case done && err != nil:
+ if err != nil {
slog.Warn("task run failed",
slog.Int("id", task.ID),
slog.String("type", task.Type.String()),
@@ -188,7 +180,6 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRunUID int, task *st
)
return
}
- s.createActivityForTaskRunStatusUpdate(ctx, task, storepb.TaskRun_FAILED, taskRunResult.Detail)
// Immediately try to send PIPELINE_FAILED webhook (HA-safe atomic claim)
claimed, err := s.store.ClaimPipelineFailureNotification(ctx, task.PlanID)
@@ -216,52 +207,37 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRunUID int, task *st
}
}
return
+ }
- case done && err == nil:
- resultBytes, marshalErr := protojson.Marshal(result)
- if marshalErr != nil {
- slog.Error("Failed to marshal task run result",
- slog.Int("task_id", task.ID),
- slog.String("type", task.Type.String()),
- log.BBError(marshalErr),
- )
- return
- }
- code := common.Ok
- result := string(resultBytes)
- taskRunStatusPatch := &store.TaskRunStatusPatch{
- ID: taskRunUID,
- Updater: common.SystemBotEmail,
- Status: storepb.TaskRun_DONE,
- Code: &code,
- Result: &result,
- }
- if _, err := s.store.UpdateTaskRunStatus(ctx, taskRunStatusPatch); err != nil {
- slog.Error("Failed to mark task as DONE",
- slog.Int("id", task.ID),
- log.BBError(err),
- )
- return
- }
- s.createActivityForTaskRunStatusUpdate(ctx, task, storepb.TaskRun_DONE, "")
-
- // Signal to check if plan is complete and successful (may send PIPELINE_COMPLETED)
- s.bus.PlanCompletionCheckChan <- task.PlanID
+ // Success case
+ resultBytes, marshalErr := protojson.Marshal(result)
+ if marshalErr != nil {
+ slog.Error("Failed to marshal task run result",
+ slog.Int("task_id", task.ID),
+ slog.String("type", task.Type.String()),
+ log.BBError(marshalErr),
+ )
return
- default:
- // This case should not happen in normal flow, but adding for completeness
- slog.Error("Unexpected task execution state",
+ }
+ code := common.Ok
+ resultStr := string(resultBytes)
+ taskRunStatusPatch := &store.TaskRunStatusPatch{
+ ID: taskRunUID,
+ Updater: common.SystemBotEmail,
+ Status: storepb.TaskRun_DONE,
+ Code: &code,
+ Result: &resultStr,
+ }
+ if _, err := s.store.UpdateTaskRunStatus(ctx, taskRunStatusPatch); err != nil {
+ slog.Error("Failed to mark task as DONE",
slog.Int("id", task.ID),
- slog.String("type", task.Type.String()),
- slog.Bool("done", done),
- slog.Bool("has_error", err != nil),
+ log.BBError(err),
)
return
}
-}
-func (*Scheduler) createActivityForTaskRunStatusUpdate(_ context.Context, _ *store.TaskMessage, _ storepb.TaskRun_Status, _ string) {
- // No webhook events for task run status updates
+ // Signal to check if plan is complete and successful (may send PIPELINE_COMPLETED)
+ s.bus.PlanCompletionCheckChan <- task.PlanID
}
// isSequentialTask returns whether the task should be executed sequentially.