Skip to content

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

refactor: replace GetPipeline with GetPlan in rollout service (#18658)

Danny Xu6cbe3d69b0c8
diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.go
index bb5f10a382..96be9d0847 100644
--- a/backend/api/v1/rollout_service.go
+++ b/backend/api/v1/rollout_service.go
@@ -232,12 +232,12 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, projectID))
}
- pipelineCreate, err := GetPipelineCreate(ctx, s.store, plan.Config.GetSpecs(), project.ResourceID)
+ tasks, err := GetPipelineCreate(ctx, s.store, plan.Config.GetSpecs(), project.ResourceID)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to get pipeline create, error: %v", err))
}
if isChangeDatabasePlan(plan.Config.GetSpecs()) {
- pipelineCreate, err = getPipelineCreateToTargetStage(ctx, s.store, pipelineCreate, request.Target)
+ tasks, err = getPipelineCreateToTargetStage(ctx, s.store, tasks, request.Target)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to filter stages with stageId, error: %v", err))
}
@@ -268,7 +268,7 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request
}
newTasks := []*store.TaskMessage{}
- for _, taskCreate := range pipelineCreate.Tasks {
+ for _, taskCreate := range tasks {
k := taskKey{
instance: taskCreate.InstanceID,
sheet: taskCreate.Payload.GetSheetSha256(),
@@ -303,7 +303,7 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeInternal, err)
}
- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &planID})
+ tasks, err = s.store.ListTasks(ctx, &store.TaskFind{PlanID: &planID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks, error: %v", err))
}
@@ -337,18 +337,17 @@ func (s *RolloutService) ListTaskRuns(ctx context.Context, req *connect.Request[
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))
}
- pipeline, err := s.store.GetPipeline(ctx, &store.PipelineFind{
- ID: &rolloutID,
+ rolloutID64 := int64(rolloutID)
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
+ UID: &rolloutID64,
ProjectID: &projectID,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
}
- if pipeline == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
+ if plan == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))
}
-
- rolloutID64 := int64(rolloutID)
taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{
PlanUID: &rolloutID64,
Environment: maybeStageID,
@@ -376,16 +375,13 @@ func CreateRolloutAndPendingTasks(
issue *store.IssueMessage,
project *store.ProjectMessage,
) error {
- planID := plan.UID
-
- // Get pipeline create (tasks to create)
- pipelineCreate, err := GetPipelineCreate(ctx, s, plan.Config.GetSpecs(), project.ResourceID)
+ tasks, err := GetPipelineCreate(ctx, s, plan.Config.GetSpecs(), project.ResourceID)
if err != nil {
return errors.Wrap(err, "failed to get pipeline create for rollout creation")
}
// Create rollout tasks
- tasks, err := s.CreateRolloutTasks(ctx, planID, pipelineCreate)
+ tasks, err = s.CreateRolloutTasks(ctx, plan.UID, tasks)
if err != nil {
return errors.Wrap(err, "failed to create rollout tasks")
}
@@ -394,7 +390,7 @@ func CreateRolloutAndPendingTasks(
config := proto.CloneOf(plan.Config)
config.HasRollout = true
_, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{
- UID: planID,
+ UID: plan.UID,
Config: config,
})
if err != nil {
@@ -474,27 +470,27 @@ func (s *RolloutService) GetTaskRun(ctx context.Context, req *connect.Request[v1
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- pipeline, err := s.store.GetPipeline(ctx, &store.PipelineFind{
- ID: &rolloutID,
+ rolloutID64 := int64(rolloutID)
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
+ UID: &rolloutID64,
ProjectID: &projectID,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
}
- if pipeline == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
+ if plan == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))
}
- pipelineID64 := int64(pipeline.ID)
taskRun, err := s.store.GetTaskRunV1(ctx, &store.FindTaskRunMessage{
UID: &taskRunUID,
- PlanUID: &pipelineID64,
+ PlanUID: &rolloutID64,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get task run, error: %v", err))
}
if taskRun == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("task run %d not found in pipeline %d", taskRunUID, pipeline.ID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("task run %d not found in rollout %d", taskRunUID, rolloutID))
}
taskRunV1, err := convertToTaskRun(ctx, s.store, s.stateCfg, taskRun)
@@ -1097,7 +1093,7 @@ func isChangeDatabasePlan(specs []*storepb.PlanConfig_Spec) bool {
}
// GetPipelineCreate gets a pipeline create message from a plan.
-func GetPipelineCreate(ctx context.Context, s *store.Store, specs []*storepb.PlanConfig_Spec, projectID string) (*store.PipelineMessage, error) {
+func GetPipelineCreate(ctx context.Context, s *store.Store, specs []*storepb.PlanConfig_Spec, projectID string) ([]*store.TaskMessage, error) {
// Step 1 - transform database group specs.
// Re-evaluate database groups live to pick up newly created databases.
transformedSpecs, err := applyDatabaseGroupSpecTransformations(ctx, s, specs, projectID)
@@ -1115,20 +1111,16 @@ func GetPipelineCreate(ctx context.Context, s *store.Store, specs []*storepb.Pla
taskCreates = append(taskCreates, tcs...)
}
- return &store.PipelineMessage{
- ProjectID: projectID,
- Tasks: taskCreates,
- }, nil
+ return taskCreates, nil
}
// filter pipelineCreate.Tasks using targetEnvironmentID.
-func getPipelineCreateToTargetStage(ctx context.Context, s *store.Store, pipelineCreate *store.PipelineMessage, targetEnvironment *string) (*store.PipelineMessage, error) {
+func getPipelineCreateToTargetStage(ctx context.Context, s *store.Store, tasks []*store.TaskMessage, targetEnvironment *string) ([]*store.TaskMessage, error) {
if targetEnvironment == nil {
- return pipelineCreate, nil
+ return tasks, nil
}
if *targetEnvironment == "" {
- pipelineCreate.Tasks = nil
- return pipelineCreate, nil
+ return nil, nil
}
targetEnvironmentID, err := common.GetEnvironmentID(*targetEnvironment)
if err != nil {
@@ -1160,13 +1152,12 @@ func getPipelineCreateToTargetStage(ctx context.Context, s *store.Store, pipelin
// Filter tasks to only include those in allowed environments
filteredTasks := []*store.TaskMessage{}
- for _, task := range pipelineCreate.Tasks {
+ for _, task := range tasks {
if allowedEnvironments[task.Environment] {
filteredTasks = append(filteredTasks, task)
}
}
- pipelineCreate.Tasks = filteredTasks
- return pipelineCreate, nil
+ return filteredTasks, nil
}
func GetValidRolloutPolicyForEnvironment(ctx context.Context, stores *store.Store, environment string) (*storepb.RolloutPolicy, error) {
diff --git a/backend/api/v1/rollout_service_converter.go b/backend/api/v1/rollout_service_converter.go
index d6be0643e8..1ec1544460 100644
--- a/backend/api/v1/rollout_service_converter.go
+++ b/backend/api/v1/rollout_service_converter.go
@@ -125,18 +125,20 @@ func convertToSchedulerInfoWaitingCause(ctx context.Context, s *store.Store, c *
if task == nil {
return nil, errors.Errorf("task %v not found", taskUID)
}
- pipeline, err := s.GetPipelineByID(ctx, int(task.PlanID))
+ plan, err := s.GetPlan(ctx, &store.FindPlanMessage{
+ UID: &task.PlanID,
+ })
if err != nil {
- return nil, errors.Wrapf(err, "failed to get pipeline %v", task.PlanID)
+ return nil, errors.Wrapf(err, "failed to get plan %v", task.PlanID)
}
- if pipeline == nil {
- return nil, errors.Errorf("pipeline %d not found", task.PlanID)
+ if plan == nil {
+ return nil, errors.Errorf("plan %d not found", task.PlanID)
}
stageID := common.FormatStageID(task.Environment)
return &v1pb.TaskRun_SchedulerInfo_WaitingCause{
Cause: &v1pb.TaskRun_SchedulerInfo_WaitingCause_Task_{
Task: &v1pb.TaskRun_SchedulerInfo_WaitingCause_Task{
- Task: common.FormatTask(pipeline.ProjectID, int(task.PlanID), stageID, task.ID),
+ Task: common.FormatTask(plan.ProjectID, int(task.PlanID), stageID, task.ID),
},
},
}, nil
diff --git a/backend/runner/approval/runner.go b/backend/runner/approval/runner.go
index 042c2cd2ff..550657b64e 100644
--- a/backend/runner/approval/runner.go
+++ b/backend/runner/approval/runner.go
@@ -487,13 +487,13 @@ func (r *Runner) buildCELVariablesForDatabaseChange(ctx context.Context, issue *
}
// Build CEL variables for each task
- pipelineCreate, err := apiv1.GetPipelineCreate(ctx, r.store, plan.Config.GetSpecs(), issue.ProjectID)
+ tasks, err := apiv1.GetPipelineCreate(ctx, r.store, plan.Config.GetSpecs(), issue.ProjectID)
if err != nil {
return nil, false, errors.Wrap(err, "failed to get pipeline create")
}
var celVarsList []map[string]any
- for _, task := range pipelineCreate.Tasks {
+ for _, task := range tasks {
instance, err := r.store.GetInstance(ctx, &store.FindInstanceMessage{
ResourceID: &task.InstanceID,
})
@@ -601,13 +601,13 @@ func (r *Runner) buildCELVariablesForDataExport(ctx context.Context, issue *stor
return nil, false, errors.Errorf("plan %v not found", *issue.PlanUID)
}
- pipelineCreate, err := apiv1.GetPipelineCreate(ctx, r.store, plan.Config.GetSpecs(), issue.ProjectID)
+ tasks, err := apiv1.GetPipelineCreate(ctx, r.store, plan.Config.GetSpecs(), issue.ProjectID)
if err != nil {
return nil, false, errors.Wrap(err, "failed to get pipeline create")
}
var celVarsList []map[string]any
- for _, task := range pipelineCreate.Tasks {
+ for _, task := range tasks {
if task.Type != storepb.Task_DATABASE_EXPORT {
continue
}
diff --git a/backend/store/pipeline.go b/backend/store/pipeline.go
index 0307bc2769..cce396708d 100644
--- a/backend/store/pipeline.go
+++ b/backend/store/pipeline.go
@@ -2,7 +2,6 @@ package store
import (
"context"
- "database/sql"
"strings"
"time"
@@ -11,32 +10,13 @@ import (
celoperators "github.com/google/cel-go/common/operators"
"github.com/pkg/errors"
- "github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/qb"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
)
-// PipelineMessage is the message for pipelines.
-type PipelineMessage struct {
- ProjectID string
- Tasks []*TaskMessage
- // Output only.
- ID int
-}
-
-// PipelineFind is the API message for finding pipelines.
-type PipelineFind struct {
- ID *int
- ProjectID *string
-
- Limit *int
- Offset *int
- FilterQ *qb.Query
-}
-
// CreateRolloutTasks creates tasks for a plan.
-func (s *Store) CreateRolloutTasks(ctx context.Context, planUID int64, pipeline *PipelineMessage) ([]*TaskMessage, error) {
+func (s *Store) CreateRolloutTasks(ctx context.Context, planUID int64, tasks []*TaskMessage) ([]*TaskMessage, error) {
tx, err := s.GetDB().BeginTx(ctx, nil)
if err != nil {
return nil, errors.Wrapf(err, "failed to begin tx")
@@ -71,7 +51,7 @@ func (s *Store) CreateRolloutTasks(ctx context.Context, planUID int64, pipeline
var taskCreateList []*TaskMessage
- for _, taskCreate := range pipeline.Tasks {
+ for _, taskCreate := range tasks {
k := taskKey{
instance: taskCreate.InstanceID,
sheet: taskCreate.Payload.GetSheetSha256(),
@@ -105,93 +85,6 @@ func (s *Store) CreateRolloutTasks(ctx context.Context, planUID int64, pipeline
return []*TaskMessage{}, nil
}
-// GetPipeline gets the pipeline.
-func (s *Store) GetPipeline(ctx context.Context, find *PipelineFind) (*PipelineMessage, error) {
- pipelines, err := s.ListPipelines(ctx, find)
- if err != nil {
- return nil, err
- }
-
- if len(pipelines) == 0 {
- return nil, nil
- } else if len(pipelines) > 1 {
- return nil, &common.Error{Code: common.Conflict, Err: errors.Errorf("found %d pipelines, expect 1", len(pipelines))}
- }
- pipeline := pipelines[0]
- return pipeline, nil
-}
-
-// GetPipelineByID gets the pipeline by ID.
-func (s *Store) GetPipelineByID(ctx context.Context, id int) (*PipelineMessage, error) {
- return s.GetPipeline(ctx, &PipelineFind{ID: &id})
-}
-
-// ListPipelines lists pipelines.
-func (s *Store) ListPipelines(ctx context.Context, find *PipelineFind) ([]*PipelineMessage, error) {
- q := qb.Q().Space(`
- SELECT
- plan.id,
- plan.project
- FROM plan
- WHERE TRUE
- `)
-
- if filterQ := find.FilterQ; filterQ != nil {
- q.And("?", filterQ)
- }
- if v := find.ID; v != nil {
- q.And("plan.id = ?", *v)
- }
- if v := find.ProjectID; v != nil {
- q.And("plan.project = ?", *v)
- }
-
- q.Space("ORDER BY plan.id DESC")
- if v := find.Limit; v != nil {
- q.Space("LIMIT ?", *v)
- }
- if v := find.Offset; v != nil {
- q.Space("OFFSET ?", *v)
- }
-
- query, args, err := q.ToSQL()
- if err != nil {
- return nil, errors.Wrapf(err, "failed to build sql")
- }
-
- tx, err := s.GetDB().BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
- if err != nil {
- return nil, err
- }
- defer tx.Rollback()
-
- rows, err := tx.QueryContext(ctx, query, args...)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- var pipelines []*PipelineMessage
- for rows.Next() {
- var pipeline PipelineMessage
- if err := rows.Scan(
- &pipeline.ID,
- &pipeline.ProjectID,
- ); err != nil {
- return nil, err
- }
- pipelines = append(pipelines, &pipeline)
- }
- if err := rows.Err(); err != nil {
- return nil, err
- }
-
- if err := tx.Commit(); err != nil {
- return nil, err
- }
- return pipelines, nil
-}
-
// GetListRolloutFilter parses a CEL filter expression into a query builder query for listing rollouts.
func GetListRolloutFilter(filter string) (*qb.Query, error) {
if filter == "" {