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: remove pipeline table and migrate tasks to reference plans directly (#18620)
Danny Xu34161a5dd253
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex 01cfc3c5cc..fd0a8d999a 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -12661,6 +12661,10 @@ components:- WARNING- ERROR- RUNNING+ hasRollout:+ type: boolean+ title: has_rollout+ description: Whether the plan has started the rollout.title: PlanadditionalProperties: falsebytebase.v1.Plan.ChangeDatabaseConfig:diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.goindex d67a6554f4..ba8f5b6971 100644--- a/backend/api/v1/issue_service.go+++ b/backend/api/v1/issue_service.go@@ -450,30 +450,11 @@ func (s *IssueService) createIssueDatabaseChange(ctx context.Context, project *sreturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, project.ResourceID))}planUID = &plan.UID- var rolloutUID *int- if request.Issue.Rollout != "" {- _, rolloutID, err := common.GetProjectIDRolloutID(request.Issue.Rollout)- if err != nil {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))- }- pipeline, err := s.store.GetPipeline(ctx, &store.PipelineFind{- ID: &rolloutID,- ProjectID: &project.ResourceID,- })- 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("rollout %d not found in project %s", rolloutID, project.ResourceID))- }- rolloutUID = &pipeline.ID- }issueCreateMessage := &store.IssueMessage{ProjectID: project.ResourceID,CreatorEmail: user.Email,PlanUID: planUID,- PipelineUID: rolloutUID,Title: request.Issue.Title,Status: storepb.Issue_OPEN,Type: storepb.Issue_DATABASE_CHANGE,@@ -548,7 +529,6 @@ func (s *IssueService) createIssueGrantRequest(ctx context.Context, project *stoProjectID: project.ResourceID,CreatorEmail: user.Email,PlanUID: nil,- PipelineUID: nil,Title: request.Issue.Title,Status: storepb.Issue_OPEN,Type: storepb.Issue_GRANT_REQUEST,@@ -609,30 +589,21 @@ func (s *IssueService) createIssueDatabaseDataExport(ctx context.Context, projecreturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, project.ResourceID))}planUID = &plan.UID- var rolloutUID *int+ // Rollout is now virtual and derived from Plan.if request.Issue.Rollout != "" {_, rolloutID, err := common.GetProjectIDRolloutID(request.Issue.Rollout)if err != nil {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))}- pipeline, err := s.store.GetPipeline(ctx, &store.PipelineFind{- ID: &rolloutID,- ProjectID: &project.ResourceID,- })- 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("rollout %d not found in project %s", rolloutID, project.ResourceID))+ if int64(rolloutID) != plan.UID {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("rollout ID %d does not match plan ID %d", rolloutID, plan.UID))}- rolloutUID = &pipeline.ID}issueCreateMessage := &store.IssueMessage{ProjectID: project.ResourceID,CreatorEmail: user.Email,PlanUID: planUID,- PipelineUID: rolloutUID,Title: request.Issue.Title,Status: storepb.Issue_OPEN,Type: storepb.Issue_DATABASE_EXPORT,@@ -800,10 +771,10 @@ func (s *IssueService) ApproveIssue(ctx context.Context, req *connect.Request[v1// notify pipeline rolloutif err := func() error {- if issue.PipelineUID == nil {+ if issue.PlanUID == nil {return nil}- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: issue.PipelineUID})+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: issue.PlanUID})if err != nil {return errors.Wrapf(err, "failed to list tasks")}@@ -1252,9 +1223,9 @@ func (s *IssueService) BatchUpdateIssuesStatus(ctx context.Context, req *connectissues = append(issues, issue)// Check if there is any running/pending task runs.- if issue.PipelineUID != nil {+ if issue.PlanUID != nil {taskRunStatusList := []storepb.TaskRun_Status{storepb.TaskRun_RUNNING, storepb.TaskRun_PENDING}- taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{PipelineUID: issue.PipelineUID, Status: &taskRunStatusList})+ taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{PlanUID: issue.PlanUID, Status: &taskRunStatusList})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list task runs, err: %v", err))}diff --git a/backend/api/v1/issue_service_converter.go b/backend/api/v1/issue_service_converter.goindex 318febb80a..7107e63110 100644--- a/backend/api/v1/issue_service_converter.go+++ b/backend/api/v1/issue_service_converter.go@@ -106,8 +106,9 @@ func (s *IssueService) convertToIssue(ctx context.Context, issue *store.IssueMesif issue.PlanUID != nil {issueV1.Plan = common.FormatPlan(issue.ProjectID, *issue.PlanUID)}- if issue.PipelineUID != nil {- issueV1.Rollout = common.FormatRollout(issue.ProjectID, *issue.PipelineUID)+ // Rollout uses PlanUID as ID.+ if issue.PlanUID != nil {+ issueV1.Rollout = common.FormatRollout(issue.ProjectID, int(*issue.PlanUID))}approval := issuePayload.GetApproval()@@ -191,10 +192,10 @@ func (s *IssueService) convertToIssueReleasers(ctx context.Context, issue *storeif issue.Status != storepb.Issue_OPEN {return nil, nil}- if issue.PipelineUID == nil {+ if issue.PlanUID == nil {return nil, nil}- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: issue.PipelineUID})+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: issue.PlanUID})if err != nil {return nil, errors.Wrapf(err, "failed to list issue tasks")}diff --git a/backend/api/v1/plan_service.go b/backend/api/v1/plan_service.goindex 31503570b7..62e57aed0f 100644--- a/backend/api/v1/plan_service.go+++ b/backend/api/v1/plan_service.go@@ -241,7 +241,6 @@ func (s *PlanService) CreatePlan(ctx context.Context, request *connect.Request[vplanMessage := &store.PlanMessage{ProjectID: projectID,- PipelineUID: nil,Name: req.Plan.Title,Description: req.Plan.Description,Config: convertPlan(req.Plan),@@ -353,7 +352,8 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[vplanUpdate.Deleted = &deletedcase "specs":// Block all spec changes if plan has a rollout (pipeline).- if oldPlan.PipelineUID != nil {+ // Block all spec changes if plan has a rollout (pipeline).+ if oldPlan.Config != nil && oldPlan.Config.GetHasRollout() {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot update specs for plan that has a rollout"))}@@ -860,8 +860,11 @@ func convertToPlan(ctx context.Context, s *store.Store, plan *store.PlanMessage)if issue != nil {p.Issue = common.FormatIssue(issue.ProjectID, issue.UID)}- if plan.PipelineUID != nil {- p.Rollout = common.FormatRollout(plan.ProjectID, *plan.PipelineUID)+ if plan.Config != nil {+ p.HasRollout = plan.Config.HasRollout+ }+ if p.HasRollout {+ p.Rollout = common.FormatRollout(plan.ProjectID, int(plan.UID))}planCheckRun, err := s.GetPlanCheckRun(ctx, int64(plan.UID))if err != nil {diff --git a/backend/api/v1/revision_service.go b/backend/api/v1/revision_service.goindex d5d0dbf8a9..b809035212 100644--- a/backend/api/v1/revision_service.go+++ b/backend/api/v1/revision_service.go@@ -205,7 +205,7 @@ func (s *RevisionService) createRevisions(return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("taskRun %q not found", revision.TaskRun))}if taskRun.ProjectID != projectID ||- taskRun.PipelineUID != rolloutID ||+ taskRun.PlanUID != int64(rolloutID) ||taskRun.Environment != formatEnvironmentFromStageID(stageID) ||taskRun.TaskUID != taskID {return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("taskRun %q not found", revision.TaskRun))diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.goindex aec40d1000..8c040a4f69 100644--- a/backend/api/v1/rollout_service.go+++ b/backend/api/v1/rollout_service.go@@ -73,12 +73,25 @@ func (s *RolloutService) GetRollout(ctx context.Context, req *connect.Request[v1return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", projectID))}- rollout, err := s.getRolloutWithTasks(ctx, projectID, rolloutID)+ // getRolloutWithTasks inlined+ rolloutID64 := int64(rolloutID)+ rollout, err := s.store.GetPlan(ctx, &store.FindPlanMessage{+ UID: &rolloutID64,+ ProjectID: &projectID,+ })if err != nil {- return nil, err+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))+ }+ if rollout == nil {+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))}- rolloutV1, err := convertToRollout(ctx, s.store, project, rollout)+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &rolloutID64})+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks, error: %v", err))+ }++ rolloutV1, err := convertToRollout(ctx, s.store, project, rollout, tasks)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert to rollout, error: %v", err))}@@ -112,37 +125,48 @@ func (s *RolloutService) ListRollouts(ctx context.Context, req *connect.Request[}limitPlusOne := offset.limit + 1- find := &store.PipelineFind{- ProjectID: &projectID,- Limit: &limitPlusOne,- Offset: &offset.offset,+ // ListRollouts should list Plans that have tasks (rollouts).+ // We use ListPlans but we need to filter those with tasks.+ // Previously ListPipelines did this.+ // Let's us ListPlans with has_pipeline=true (which now means has tasks).+ // But `store.PipelineFind` is still used in code?+ // Let's assume ListPipelines now returns Plan-like PipelineMessages.+ // I need to convert them to PlanMessage.++ // BUT, `ListPipelines` returns `[]*PipelineMessage`.+ // I should probably switch to `ListPlans`.++ hasRollout := true+ findPlan := &store.FindPlanMessage{+ ProjectID: &projectID,+ Limit: &limitPlusOne,+ Offset: &offset.offset,+ HasRollout: &hasRollout,}- if err := s.buildRolloutFindWithFilter(ctx, find, request.Filter); err != nil {+ if err := s.buildRolloutFindWithFilter(ctx, findPlan, request.Filter); err != nil {return nil, err}- pipelines, err := s.store.ListPipelines(ctx, find)+ plans, err := s.store.ListPlans(ctx, findPlan)if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list pipelines, error: %v", err))+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list plans, error: %v", err))}var nextPageToken string- // has more pages- if len(pipelines) == limitPlusOne {+ if len(plans) == limitPlusOne {if nextPageToken, err = offset.getNextPageToken(); err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get next page token, error: %v", err))}- pipelines = pipelines[:offset.limit]+ plans = plans[:offset.limit]}rollouts := []*v1pb.Rollout{}- for _, pipeline := range pipelines {- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &pipeline.ID})+ for _, plan := range plans {+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &plan.UID})if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks for pipeline %d, error: %v", pipeline.ID, err))+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list tasks for plan %d, error: %v", plan.UID, err))}- rolloutMessage := *pipeline- rolloutMessage.Tasks = tasks- rollout, err := convertToRollout(ctx, s.store, project, &rolloutMessage)++ rollout, err := convertToRollout(ctx, s.store, project, plan, tasks)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert to rollout, error: %v", err))}@@ -156,7 +180,7 @@ func (s *RolloutService) ListRollouts(ctx context.Context, req *connect.Request[}// buildRolloutFindWithFilter builds the filter for rollout find.-func (s *RolloutService) buildRolloutFindWithFilter(ctx context.Context, pipelineFind *store.PipelineFind, filter string) error {+func (s *RolloutService) buildRolloutFindWithFilter(ctx context.Context, planFind *store.FindPlanMessage, filter string) error {if filter == "" {return nil}@@ -166,7 +190,7 @@ func (s *RolloutService) buildRolloutFindWithFilter(ctx context.Context, pipelinreturn connect.NewError(connect.CodeInvalidArgument, err)}- pipelineFind.FilterQ = filterQ+ planFind.FilterQ = filterQreturn nil}@@ -214,24 +238,96 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request}}if request.ValidateOnly {- rolloutV1, err := convertToRollout(ctx, s.store, project, pipelineCreate)+ // Filter out tasks that already exist (same logic as CreateRolloutTasks)+ existingTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &planID})+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list existing tasks, error: %v", err))+ }++ type taskKey struct {+ instance string+ database string+ sheet string+ }++ createdTasks := map[taskKey]struct{}{}+ for _, task := range existingTasks {+ k := taskKey{+ instance: task.InstanceID,+ sheet: task.Payload.GetSheetSha256(),+ }+ if task.DatabaseName != nil {+ k.database = *task.DatabaseName+ }+ createdTasks[k] = struct{}{}+ }++ newTasks := []*store.TaskMessage{}+ for _, taskCreate := range pipelineCreate.Tasks {+ k := taskKey{+ instance: taskCreate.InstanceID,+ sheet: taskCreate.Payload.GetSheetSha256(),+ }+ if taskCreate.DatabaseName != nil {+ k.database = *taskCreate.DatabaseName+ }++ if _, ok := createdTasks[k]; ok {+ continue+ }+ newTasks = append(newTasks, taskCreate)+ }++ // Construct a dummy plan for preview.+ previewPlan := &store.PlanMessage{+ UID: planID,+ Name: plan.Name,+ Creator: user.Email,+ CreatedAt: time.Now(),+ UpdatedAt: time.Now(),+ ProjectID: project.ResourceID,+ }+ rolloutV1, err := convertToRollout(ctx, s.store, project, previewPlan, newTasks)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert to rollout, error: %v", err))}rolloutV1.Plan = request.Rollout.GetPlan()return connect.NewResponse(rolloutV1), nil}- pipelineUID, err := s.store.CreatePipelineAIO(ctx, planID, pipelineCreate, user.Email)+ _, err = s.store.CreateRolloutTasks(ctx, planID, pipelineCreate)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to create pipeline, error: %v", err))}- rollout, err := s.getRolloutWithTasks(ctx, projectID, pipelineUID)+ // Update plan to set hasRollout to true+ hasRollout := true+ if err := s.store.UpdatePlan(ctx, &store.UpdatePlanMessage{+ UID: planID,+ HasRollout: &hasRollout,+ }); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to update plan hasRollout, error: %v", err))+ }++ // getRolloutWithTasks inlined+ // re-fetch plan to get latest state (e.g. hasRollout config)+ rollout, err := s.store.GetPlan(ctx, &store.FindPlanMessage{+ UID: &planID, // planID is already int64+ ProjectID: &projectID,+ })if err != nil {- return nil, err+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))+ }+ if rollout == nil {+ // Should not happen as we just created tasks for it+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", planID, projectID))+ }++ 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))}- rolloutV1, err := convertToRollout(ctx, s.store, project, rollout)+ rolloutV1, err := convertToRollout(ctx, s.store, project, rollout, tasks)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert to rollout, error: %v", err))}@@ -271,8 +367,9 @@ func (s *RolloutService) ListTaskRuns(ctx context.Context, req *connect.Request[return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))}+ rolloutID64 := int64(rolloutID)taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{- PipelineUID: &rolloutID,+ PlanUID: &rolloutID64,Environment: maybeStageID,TaskUID: maybeTaskID,})@@ -308,9 +405,10 @@ func (s *RolloutService) GetTaskRun(ctx context.Context, req *connect.Request[v1return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))}+ pipelineID64 := int64(pipeline.ID)taskRun, err := s.store.GetTaskRunV1(ctx, &store.FindTaskRunMessage{- UID: &taskRunUID,- PipelineUID: &pipeline.ID,+ UID: &taskRunUID,+ PlanUID: &pipelineID64,})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get task run, error: %v", err))@@ -494,20 +592,23 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.Requestreturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))}- rollout, err := s.store.GetPipeline(ctx, &store.PipelineFind{- ID: &rolloutID,+ // Rollout ID is Plan ID+ rolloutID64 := int64(rolloutID)+ // Verify plan exists instead of pipeline+ 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 find rollout, error: %v", err))+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find plan for rollout, error: %v", err))}- if rollout == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %v not found", rolloutID))+ if plan == nil {+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout (plan) %v not found", rolloutID))}issueN, err := s.store.GetIssue(ctx, &store.FindIssueMessage{- PipelineID: &rolloutID,- ProjectID: &projectID,+ PlanUID: &rolloutID64,+ ProjectID: &projectID,})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue, error: %v", err))@@ -537,7 +638,7 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.Request}// Get all tasks in the same environment- stageToRunTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &rolloutID, Environment: &environmentToRun})+ stageToRunTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &rolloutID64, Environment: &environmentToRun})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list tasks, error: %v", err))}@@ -550,7 +651,7 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.Requestreturn nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))}- ok, err = s.canUserRunEnvironmentTasks(ctx, user, project, issueN, environmentToRun, rollout.Creator)+ ok, err = s.canUserRunEnvironmentTasks(ctx, user, project, issueN, environmentToRun, plan.Creator)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to check if the user can run tasks, error: %v", err))}@@ -601,7 +702,7 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.RequestType: storepb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE,Issue: webhook.NewIssue(issueN),Project: webhook.NewProject(project),- Rollout: webhook.NewRollout(rollout),+ Rollout: webhook.NewRollout(plan),TaskRunStatusUpdate: &webhook.EventTaskRunStatusUpdate{Status: storepb.TaskRun_PENDING.String(),},@@ -629,26 +730,28 @@ func (s *RolloutService) BatchSkipTasks(ctx context.Context, req *connect.Requesreturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))}- rollout, err := s.store.GetPipeline(ctx, &store.PipelineFind{- ID: &rolloutID,+ // Rollout ID is Plan ID+ 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 find rollout, error: %v", err))+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find plan for rollout, error: %v", err))}- if rollout == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %v not found", rolloutID))+ if plan == nil {+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout (plan) %v not found", rolloutID))}issueN, err := s.store.GetIssue(ctx, &store.FindIssueMessage{- PipelineID: &rolloutID,- ProjectID: &projectID,+ PlanUID: &rolloutID64,+ ProjectID: &projectID,})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue, error: %v", err))}- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &rolloutID})+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &rolloutID64})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list tasks, error: %v", err))}@@ -680,7 +783,7 @@ func (s *RolloutService) BatchSkipTasks(ctx context.Context, req *connect.Reques}for environment := range environmentSet {- ok, err = s.canUserRunEnvironmentTasks(ctx, user, project, issueN, environment, rollout.Creator)+ ok, err = s.canUserRunEnvironmentTasks(ctx, user, project, issueN, environment, plan.Creator)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to check if the user can skip tasks, error: %v", err))}@@ -703,7 +806,7 @@ func (s *RolloutService) BatchSkipTasks(ctx context.Context, req *connect.RequesComment: request.Reason,Issue: webhook.NewIssue(issueN),Project: webhook.NewProject(project),- Rollout: webhook.NewRollout(rollout),+ Rollout: webhook.NewRollout(plan),TaskRunStatusUpdate: &webhook.EventTaskRunStatusUpdate{Status: storepb.TaskRun_SKIPPED.String(),SkippedReason: request.Reason,@@ -735,20 +838,22 @@ func (s *RolloutService) BatchCancelTaskRuns(ctx context.Context, req *connect.Rreturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))}- rollout, err := s.store.GetPipeline(ctx, &store.PipelineFind{- ID: &rolloutID,+ // Rollout ID is Plan ID+ 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 find rollout, error: %v", err))+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find plan for rollout, error: %v", err))}- if rollout == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %v not found", rolloutID))+ if plan == nil {+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout (plan) %v not found", rolloutID))}issueN, err := s.store.GetIssue(ctx, &store.FindIssueMessage{- PipelineID: &rolloutID,- ProjectID: &projectID,+ PlanUID: &rolloutID64,+ ProjectID: &projectID,})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue, error: %v", err))@@ -770,7 +875,7 @@ func (s *RolloutService) BatchCancelTaskRuns(ctx context.Context, req *connect.R}environment := formatEnvironmentFromStageID(stageID)- ok, err = s.canUserCancelEnvironmentTaskRun(ctx, user, project, issueN, environment, rollout.Creator)+ ok, err = s.canUserCancelEnvironmentTaskRun(ctx, user, project, issueN, environment, plan.Creator)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to check if the user can run tasks, error: %v", err))}@@ -819,7 +924,7 @@ func (s *RolloutService) BatchCancelTaskRuns(ctx context.Context, req *connect.RActor: user,Type: storepb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE,Issue: webhook.NewIssue(issueN),- Rollout: webhook.NewRollout(rollout),+ Rollout: webhook.NewRollout(plan),Project: webhook.NewProject(project),TaskRunStatusUpdate: &webhook.EventTaskRunStatusUpdate{Status: storepb.TaskRun_CANCELED.String(),@@ -1039,26 +1144,3 @@ func (s *RolloutService) canUserRunEnvironmentTasks(ctx context.Context, user *sfunc (s *RolloutService) canUserCancelEnvironmentTaskRun(ctx context.Context, user *store.UserMessage, project *store.ProjectMessage, issue *store.IssueMessage, environment string, creator string) (bool, error) {return s.canUserRunEnvironmentTasks(ctx, user, project, issue, environment, creator)}--// getRolloutWithTasks retrieves a pipeline by ID with its tasks populated.-func (s *RolloutService) getRolloutWithTasks(ctx context.Context, projectID string, rolloutID int) (*store.PipelineMessage, error) {- pipeline, err := s.store.GetPipeline(ctx, &store.PipelineFind{- ID: &rolloutID,- ProjectID: &projectID,- })- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get pipeline, error: %v", err))- }- if pipeline == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))- }-- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &rolloutID})- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks, error: %v", err))- }-- rollout := *pipeline- rollout.Tasks = tasks- return &rollout, nil-}diff --git a/backend/api/v1/rollout_service_converter.go b/backend/api/v1/rollout_service_converter.goindex bc862a599c..d6be0643e8 100644--- a/backend/api/v1/rollout_service_converter.go+++ b/backend/api/v1/rollout_service_converter.go@@ -3,6 +3,7 @@ package v1import ("context""fmt"+ "slices""connectrpc.com/connect""github.com/pkg/errors"@@ -38,7 +39,7 @@ func convertToTaskRuns(ctx context.Context, s *store.Store, stateCfg *state.Statfunc convertToTaskRun(ctx context.Context, s *store.Store, stateCfg *state.State, taskRun *store.TaskRunMessage) (*v1pb.TaskRun, error) {stageID := common.FormatStageID(taskRun.Environment)t := &v1pb.TaskRun{- Name: common.FormatTaskRun(taskRun.ProjectID, taskRun.PipelineUID, stageID, taskRun.TaskUID, taskRun.ID),+ Name: common.FormatTaskRun(taskRun.ProjectID, int(taskRun.PlanUID), stageID, taskRun.TaskUID, taskRun.ID),Creator: common.FormatUserEmail(taskRun.CreatorEmail),CreateTime: timestamppb.New(taskRun.CreatedAt),UpdateTime: timestamppb.New(taskRun.UpdatedAt),@@ -124,18 +125,18 @@ 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, task.PipelineID)+ pipeline, err := s.GetPipelineByID(ctx, int(task.PlanID))if err != nil {- return nil, errors.Wrapf(err, "failed to get pipeline %v", task.PipelineID)+ return nil, errors.Wrapf(err, "failed to get pipeline %v", task.PlanID)}if pipeline == nil {- return nil, errors.Errorf("pipeline %d not found", task.PipelineID)+ return nil, errors.Errorf("pipeline %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, task.PipelineID, stageID, task.ID),+ Task: common.FormatTask(pipeline.ProjectID, int(task.PlanID), stageID, task.ID),},},}, nil@@ -195,9 +196,9 @@ func convertToTaskRunPriorBackupDetail(priorBackupDetail *storepb.PriorBackupDet}}-func convertToRollout(ctx context.Context, s *store.Store, project *store.ProjectMessage, rollout *store.PipelineMessage) (*v1pb.Rollout, error) {+func convertToRollout(ctx context.Context, s *store.Store, project *store.ProjectMessage, rollout *store.PlanMessage, tasks []*store.TaskMessage) (*v1pb.Rollout, error) {rolloutV1 := &v1pb.Rollout{- Name: common.FormatRollout(project.ResourceID, rollout.ID),+ Name: common.FormatRollout(project.ResourceID, int(rollout.UID)),Plan: "",Title: "",Stages: nil,@@ -214,17 +215,16 @@ func convertToRollout(ctx context.Context, s *store.Store, project *store.ProjecrolloutV1.Creator = common.FormatUserEmail(creator.Email)}- plan, err := s.GetPlan(ctx, &store.FindPlanMessage{PipelineID: &rollout.ID})+ // Rollout is Plan.+ rolloutV1.Plan = common.FormatPlan(project.ResourceID, rollout.UID)+ rolloutV1.Title = rollout.Name++ issue, err := s.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &rollout.UID})if err != nil {- return nil, errors.Wrapf(err, "failed to get plan")- }- if plan != nil {- rolloutV1.Plan = common.FormatPlan(project.ResourceID, plan.UID)- rolloutV1.Title = plan.Name+ return nil, errors.Wrapf(err, "failed to get issue by plan uid %d", rollout.UID)}-- if rollout.IssueID != nil {- rolloutV1.Issue = common.FormatIssue(project.ResourceID, *rollout.IssueID)+ if issue != nil {+ rolloutV1.Issue = common.FormatIssue(project.ResourceID, issue.UID)}// Get live environment order@@ -238,8 +238,21 @@ func convertToRollout(ctx context.Context, s *store.Store, project *store.Projec}// Group tasks by environment.+ if tasks == nil {+ var err error+ tasks, err = s.ListTasks(ctx, &store.TaskFind{PlanID: &rollout.UID})+ if err != nil {+ return nil, errors.Wrapf(err, "failed to list tasks")+ }+ }++ // Sort tasks by ID+ slices.SortFunc(tasks, func(a, b *store.TaskMessage) int {+ return a.ID - b.ID+ })+tasksByEnv := map[string][]*v1pb.Task{}- for _, task := range rollout.Tasks {+ for _, task := range tasks {rolloutTask, err := convertToTask(ctx, s, project, task)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert task"))@@ -254,7 +267,7 @@ func convertToRollout(ctx context.Context, s *store.Store, project *store.Projecif len(tasks) > 0 {stageID := common.FormatStageID(environment)stages = append(stages, &v1pb.Stage{- Name: common.FormatStage(project.ResourceID, rollout.ID, stageID),+ Name: common.FormatStage(project.ResourceID, int(rollout.UID), stageID),Id: stageID,Environment: common.FormatEnvironment(stageID),Tasks: tasks,@@ -268,7 +281,7 @@ func convertToRollout(ctx context.Context, s *store.Store, project *store.ProjecstageID := common.FormatStageID(environment)stages = append([]*v1pb.Stage{{- Name: common.FormatStage(project.ResourceID, rollout.ID, stageID),+ Name: common.FormatStage(project.ResourceID, int(rollout.UID), stageID),Id: stageID,Environment: common.FormatEnvironment(stageID),Tasks: tasks,@@ -309,7 +322,7 @@ func convertToTaskFromDatabaseCreate(ctx context.Context, s *store.Store, projec}stageID := common.FormatStageID(task.Environment)v1pbTask := &v1pb.Task{- Name: common.FormatTask(project.ResourceID, task.PipelineID, stageID, task.ID),+ Name: common.FormatTask(project.ResourceID, int(task.PlanID), stageID, task.ID),SpecId: task.Payload.GetSpecId(),Type: convertToTaskType(task),Status: convertToTaskStatus(task.LatestTaskRunStatus, task.Payload.GetSkipped()),@@ -354,7 +367,7 @@ func convertToTaskFromSchemaUpdate(project *store.ProjectMessage, task *store.TastageID := common.FormatStageID(task.Environment)v1pbTask := &v1pb.Task{- Name: common.FormatTask(project.ResourceID, task.PipelineID, stageID, task.ID),+ Name: common.FormatTask(project.ResourceID, int(task.PlanID), stageID, task.ID),SpecId: task.Payload.GetSpecId(),Type: convertToTaskType(task),Status: convertToTaskStatus(task.LatestTaskRunStatus, task.Payload.GetSkipped()),@@ -394,7 +407,7 @@ func convertToTaskFromDatabaseDataExport(project *store.ProjectMessage, task *st}stageID := common.FormatStageID(task.Environment)v1pbTask := &v1pb.Task{- Name: common.FormatTask(project.ResourceID, task.PipelineID, stageID, task.ID),+ Name: common.FormatTask(project.ResourceID, int(task.PlanID), stageID, task.ID),SpecId: task.Payload.GetSpecId(),Type: convertToTaskType(task),Status: convertToTaskStatus(task.LatestTaskRunStatus, false),diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex b9047de8fc..d2cb30658d 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -890,23 +890,24 @@ func (s *SQLService) doExportFromIssue(ctx context.Context, requestName string)}}- 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: %v", err))}- if pipeline == nil {+ if plan == nil {return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))}- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &pipeline.ID})+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &plan.UID})if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks: %v", err))}if len(tasks) == 0 {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("rollout %d has no task", pipeline.ID))+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("rollout %d has no task", plan.UID))}pendingEncrypts := []*encryptContent{}diff --git a/backend/component/webhook/event.go b/backend/component/webhook/event.goindex 8a34b66b5a..e977292045 100644--- a/backend/component/webhook/event.go+++ b/backend/component/webhook/event.go@@ -43,9 +43,9 @@ func NewProject(p *store.ProjectMessage) *Project {}}-func NewRollout(r *store.PipelineMessage) *Rollout {+func NewRollout(r *store.PlanMessage) *Rollout {return &Rollout{- UID: r.ID,+ UID: int(r.UID),}}diff --git a/backend/generated-go/store/plan.pb.go b/backend/generated-go/store/plan.pb.goindex 501dc4bc3b..366867d733 100644--- a/backend/generated-go/store/plan.pb.go+++ b/backend/generated-go/store/plan.pb.go@@ -75,8 +75,10 @@ func (PlanConfig_ChangeDatabaseConfig_Type) EnumDescriptor() ([]byte, []int) {}type PlanConfig struct {- state protoimpl.MessageState `protogen:"open.v1"`- Specs []*PlanConfig_Spec `protobuf:"bytes,1,rep,name=specs,proto3" json:"specs,omitempty"`+ state protoimpl.MessageState `protogen:"open.v1"`+ Specs []*PlanConfig_Spec `protobuf:"bytes,1,rep,name=specs,proto3" json:"specs,omitempty"`+ // Whether the plan has started the rollout.+ HasRollout bool `protobuf:"varint,2,opt,name=has_rollout,json=hasRollout,proto3" json:"has_rollout,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -118,6 +120,13 @@ func (x *PlanConfig) GetSpecs() []*PlanConfig_Spec {return nil}+func (x *PlanConfig) GetHasRollout() bool {+ if x != nil {+ return x.HasRollout+ }+ return false+}+type PlanConfig_Spec struct {state protoimpl.MessageState `protogen:"open.v1"`// A UUID4 string that uniquely identifies the Spec.@@ -515,11 +524,13 @@ var File_store_plan_proto protoreflect.FileDescriptorconst file_store_plan_proto_rawDesc = "" +"\n" +- "\x10store/plan.proto\x12\x0ebytebase.store\x1a\x1fgoogle/api/field_behavior.proto\x1a\x12store/common.proto\"\xcd\n" ++ "\x10store/plan.proto\x12\x0ebytebase.store\x1a\x1fgoogle/api/field_behavior.proto\x1a\x12store/common.proto\"\xee\n" +"\n" +"\n" +"PlanConfig\x125\n" +- "\x05specs\x18\x01 \x03(\v2\x1f.bytebase.store.PlanConfig.SpecR\x05specs\x1a\xcf\x02\n" ++ "\x05specs\x18\x01 \x03(\v2\x1f.bytebase.store.PlanConfig.SpecR\x05specs\x12\x1f\n" ++ "\vhas_rollout\x18\x02 \x01(\bR\n" ++ "hasRollout\x1a\xcf\x02\n" +"\x04Spec\x12\x0e\n" +"\x02id\x18\x05 \x01(\tR\x02id\x12g\n" +"\x16create_database_config\x18\x01 \x01(\v2/.bytebase.store.PlanConfig.CreateDatabaseConfigH\x00R\x14createDatabaseConfig\x12g\n" +diff --git a/backend/generated-go/store/plan_equal.pb.go b/backend/generated-go/store/plan_equal.pb.goindex 55a25b328c..122af6e90d 100644--- a/backend/generated-go/store/plan_equal.pb.go+++ b/backend/generated-go/store/plan_equal.pb.go@@ -146,5 +146,8 @@ func (x *PlanConfig) Equal(y *PlanConfig) bool {return false}}+ if x.HasRollout != y.HasRollout {+ return false+ }return true}diff --git a/backend/generated-go/v1/plan_service.pb.go b/backend/generated-go/v1/plan_service.pb.goindex 5ba240072d..c27c9e176f 100644--- a/backend/generated-go/v1/plan_service.pb.go+++ b/backend/generated-go/v1/plan_service.pb.go@@ -614,8 +614,10 @@ type Plan struct {// - ERROR// - RUNNINGPlanCheckRunStatusCount map[string]int32 `protobuf:"bytes,11,rep,name=plan_check_run_status_count,json=planCheckRunStatusCount,proto3" json:"plan_check_run_status_count,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache+ // Whether the plan has started the rollout.+ HasRollout bool `protobuf:"varint,12,opt,name=has_rollout,json=hasRollout,proto3" json:"has_rollout,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache}func (x *Plan) Reset() {@@ -725,6 +727,13 @@ func (x *Plan) GetPlanCheckRunStatusCount() map[string]int32 {return nil}+func (x *Plan) GetHasRollout() bool {+ if x != nil {+ return x.HasRollout+ }+ return false+}+type GetPlanCheckRunRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The name of the plan check run to retrieve.@@ -1692,7 +1701,7 @@ const file_v1_plan_service_proto_rawDesc = "" +"\x04plan\x18\x01 \x01(\v2\x11.bytebase.v1.PlanB\x03\xe0A\x02R\x04plan\x12@\n" +"\vupdate_mask\x18\x02 \x01(\v2\x1a.google.protobuf.FieldMaskB\x03\xe0A\x02R\n" +"updateMask\x12#\n" +- "\rallow_missing\x18\x03 \x01(\bR\fallowMissing\"\xae\x0e\n" ++ "\rallow_missing\x18\x03 \x01(\bR\fallowMissing\"\xd4\x0e\n" +"\x04Plan\x12\x12\n" +"\x04name\x18\x01 \x01(\tR\x04name\x12(\n" +"\x05state\x18\x02 \x01(\x0e2\x12.bytebase.v1.StateR\x05state\x12\x19\n" +@@ -1707,7 +1716,9 @@ const file_v1_plan_service_proto_rawDesc = "" +"\vupdate_time\x18\n" +" \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +"updateTime\x12q\n" +- "\x1bplan_check_run_status_count\x18\v \x03(\v2..bytebase.v1.Plan.PlanCheckRunStatusCountEntryB\x03\xe0A\x03R\x17planCheckRunStatusCount\x1a\xb4\x02\n" ++ "\x1bplan_check_run_status_count\x18\v \x03(\v2..bytebase.v1.Plan.PlanCheckRunStatusCountEntryB\x03\xe0A\x03R\x17planCheckRunStatusCount\x12$\n" ++ "\vhas_rollout\x18\f \x01(\bB\x03\xe0A\x03R\n" ++ "hasRollout\x1a\xb4\x02\n" +"\x04Spec\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12^\n" +"\x16create_database_config\x18\x02 \x01(\v2&.bytebase.v1.Plan.CreateDatabaseConfigH\x00R\x14createDatabaseConfig\x12^\n" +diff --git a/backend/generated-go/v1/plan_service_equal.pb.go b/backend/generated-go/v1/plan_service_equal.pb.goindex fe00b528ef..e4ab7739fe 100644--- a/backend/generated-go/v1/plan_service_equal.pb.go+++ b/backend/generated-go/v1/plan_service_equal.pb.go@@ -325,6 +325,9 @@ func (x *Plan) Equal(y *Plan) bool {return false}}+ if x.HasRollout != y.HasRollout {+ return false+ }return true}diff --git a/backend/migrator/migration/3.14/0010##remove_pipeline.sql b/backend/migrator/migration/3.14/0010##remove_pipeline.sqlnew file mode 100644index 0000000000..819af8743a--- /dev/null+++ b/backend/migrator/migration/3.14/0010##remove_pipeline.sql@@ -0,0 +1,65 @@+ALTER TABLE task ADD COLUMN plan_id bigint REFERENCES plan(id);++UPDATE task SET plan_id = plan.id+FROM pipeline+JOIN plan ON plan.pipeline_id = pipeline.id+WHERE task.pipeline_id = pipeline.id;++-- Remove any orphaned tasks that don't belong to a plan (i.e. not linked to a pipeline).+-- This is required to satisfy the NOT NULL constraint on plan_id.+DELETE FROM task_run WHERE task_id IN (SELECT id FROM task WHERE plan_id IS NULL);+DELETE FROM task WHERE plan_id IS NULL;++ALTER TABLE task ALTER COLUMN plan_id SET NOT NULL;++-- Backfill taskRun in changelog payload to use plan ID instead of pipeline ID+UPDATE changelog+SET payload = jsonb_set(+ payload,+ '{taskRun}',+ to_jsonb(+ replace(+ payload->>'taskRun',+ '/rollouts/' || pipeline.id || '/',+ '/rollouts/' || plan.id || '/'+ )+ )+)+FROM plan, pipeline+WHERE plan.pipeline_id = pipeline.id+AND changelog.payload->>'taskRun' LIKE '%/rollouts/' || pipeline.id || '/%';++-- Backfill taskRun in revision payload to use plan ID instead of pipeline ID+UPDATE revision+SET payload = jsonb_set(+ payload,+ '{taskRun}',+ to_jsonb(+ replace(+ payload->>'taskRun',+ '/rollouts/' || pipeline.id || '/',+ '/rollouts/' || plan.id || '/'+ )+ )+)+FROM plan, pipeline+WHERE plan.pipeline_id = pipeline.id+AND revision.payload->>'taskRun' LIKE '%/rollouts/' || pipeline.id || '/%';++DROP INDEX IF EXISTS idx_task_pipeline_id_environment;+ALTER TABLE task DROP COLUMN pipeline_id;++DROP INDEX IF EXISTS idx_plan_unique_pipeline_id;+ALTER TABLE plan DROP COLUMN pipeline_id;+DROP TABLE pipeline;++CREATE INDEX idx_task_plan_id_environment ON task(plan_id, environment);++-- Backfill hasRollout in plan config based on existing tasks+UPDATE plan+SET config = jsonb_set(COALESCE(config, '{}'::jsonb), '{hasRollout}', 'true'::jsonb)+WHERE EXISTS (+ SELECT 1+ FROM task+ WHERE task.plan_id = plan.id+);diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sqlindex fd700eaca6..83f11ba923 100644--- a/backend/migrator/migration/LATEST.sql+++ b/backend/migrator/migration/LATEST.sql@@ -191,22 +191,47 @@ CREATE INDEX idx_sheet_project ON sheet(project);ALTER SEQUENCE sheet_id_seq RESTART WITH 101;--------------------------- Pipeline related BEGIN--- pipeline table-CREATE TABLE pipeline (- id serial PRIMARY KEY,+-- plan table stores the plan for a project+CREATE TABLE plan (+ id bigserial PRIMARY KEY,+ deleted boolean NOT NULL DEFAULT FALSE,creator text NOT NULL REFERENCES principal(email) ON UPDATE CASCADE,created_at timestamptz NOT NULL DEFAULT now(),- project text NOT NULL REFERENCES project(resource_id)+ updated_at timestamptz NOT NULL DEFAULT now(),+ project text NOT NULL REFERENCES project(resource_id),+ name text NOT NULL,+ description text NOT NULL,+ -- Stored as PlanConfig (proto/store/store/plan.proto)+ config jsonb NOT NULL DEFAULT '{}'+);++CREATE INDEX idx_plan_project ON plan(project);++ALTER SEQUENCE plan_id_seq RESTART WITH 101;++CREATE TABLE plan_check_run (+ id serial PRIMARY KEY,+ created_at timestamptz NOT NULL DEFAULT now(),+ updated_at timestamptz NOT NULL DEFAULT now(),+ plan_id bigint NOT NULL REFERENCES plan(id),+ status text NOT NULL CHECK (status IN ('RUNNING', 'DONE', 'FAILED', 'CANCELED')),+ -- Stored as PlanCheckRunConfig (proto/store/store/plan_check_run.proto)+ config jsonb NOT NULL DEFAULT '{}',+ -- Stored as PlanCheckRunResult (proto/store/store/plan_check_run.proto)+ result jsonb NOT NULL DEFAULT '{}',+ payload jsonb NOT NULL DEFAULT '{}');-ALTER SEQUENCE pipeline_id_seq RESTART WITH 101;+CREATE UNIQUE INDEX idx_plan_check_run_unique_plan_id ON plan_check_run(plan_id);--- task table stores the task for the pipeline+CREATE INDEX idx_plan_check_run_active_status ON plan_check_run(status, id) WHERE status = 'RUNNING';++ALTER SEQUENCE plan_check_run_id_seq RESTART WITH 101;++-- task table stores the task for a planCREATE TABLE task (id serial PRIMARY KEY,- pipeline_id integer NOT NULL REFERENCES pipeline(id),+ plan_id bigint NOT NULL REFERENCES plan(id),instance text NOT NULL REFERENCES instance(resource_id),environment text,db_name text,@@ -215,7 +240,7 @@ CREATE TABLE task (payload jsonb NOT NULL DEFAULT '{}');-CREATE INDEX idx_task_pipeline_id_environment ON task(pipeline_id, environment);+CREATE INDEX idx_task_plan_id_environment ON task(plan_id, environment);ALTER SEQUENCE task_id_seq RESTART WITH 101;@@ -262,48 +287,6 @@ ALTER SEQUENCE task_run_log_id_seq RESTART WITH 101;-- Pipeline related END-------------------------- Plan related BEGIN-CREATE TABLE plan (- id bigserial PRIMARY KEY,- deleted boolean NOT NULL DEFAULT FALSE,- creator text NOT NULL REFERENCES principal(email) ON UPDATE CASCADE,- created_at timestamptz NOT NULL DEFAULT now(),- updated_at timestamptz NOT NULL DEFAULT now(),- project text NOT NULL REFERENCES project(resource_id),- pipeline_id integer REFERENCES pipeline(id),- name text NOT NULL,- description text NOT NULL,- -- Stored as PlanConfig (proto/store/store/plan.proto)- config jsonb NOT NULL DEFAULT '{}'-);--CREATE INDEX idx_plan_project ON plan(project);--CREATE UNIQUE INDEX idx_plan_unique_pipeline_id ON plan(pipeline_id);--ALTER SEQUENCE plan_id_seq RESTART WITH 101;--CREATE TABLE plan_check_run (- id serial PRIMARY KEY,- created_at timestamptz NOT NULL DEFAULT now(),- updated_at timestamptz NOT NULL DEFAULT now(),- plan_id bigint NOT NULL REFERENCES plan(id),- status text NOT NULL CHECK (status IN ('RUNNING', 'DONE', 'FAILED', 'CANCELED')),- -- Stored as PlanCheckRunConfig (proto/store/store/plan_check_run.proto)- config jsonb NOT NULL DEFAULT '{}',- -- Stored as PlanCheckRunResult (proto/store/store/plan_check_run.proto)- result jsonb NOT NULL DEFAULT '{}',- payload jsonb NOT NULL DEFAULT '{}'-);--CREATE UNIQUE INDEX idx_plan_check_run_unique_plan_id ON plan_check_run(plan_id);--CREATE INDEX idx_plan_check_run_active_status ON plan_check_run(status, id) WHERE status = 'RUNNING';--ALTER SEQUENCE plan_check_run_id_seq RESTART WITH 101;---- Plan related END-------------------------- issueCREATE TABLE issue (id serial PRIMARY KEY,diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.goindex 599d47134b..0bc227b822 100644--- a/backend/migrator/migrator_test.go+++ b/backend/migrator/migrator_test.go@@ -12,7 +12,7 @@ import (func TestLatestVersion(t *testing.T) {files, err := getSortedVersionedFiles()require.NoError(t, err)- require.Equal(t, semver.MustParse("3.14.9"), *files[len(files)-1].version)+ require.Equal(t, semver.MustParse("3.14.10"), *files[len(files)-1].version)}func TestVersionUnique(t *testing.T) {diff --git a/backend/runner/approval/runner.go b/backend/runner/approval/runner.goindex 9dacefac9b..dc1d824047 100644--- a/backend/runner/approval/runner.go+++ b/backend/runner/approval/runner.go@@ -221,10 +221,10 @@ func (r *Runner) findApprovalTemplateForIssue(ctx context.Context, issue *store.if payload.Approval.ApprovalTemplate != nil {return nil}- if issue.PipelineUID == nil {+ if issue.PlanUID == nil {return nil}- tasks, err := r.store.ListTasks(ctx, &store.TaskFind{PipelineID: issue.PipelineUID})+ tasks, err := r.store.ListTasks(ctx, &store.TaskFind{PlanID: issue.PlanUID})if err != nil {return errors.Wrapf(err, "failed to list tasks")}diff --git a/backend/runner/taskrun/auto_rollout_scheduler.go b/backend/runner/taskrun/auto_rollout_scheduler.goindex f599af7457..6e2fb4158e 100644--- a/backend/runner/taskrun/auto_rollout_scheduler.go+++ b/backend/runner/taskrun/auto_rollout_scheduler.go@@ -73,20 +73,20 @@ func (s *Scheduler) scheduleAutoRolloutTask(ctx context.Context, taskUID int) erreturn nil}- pipeline, err := s.store.GetPipelineByID(ctx, task.PipelineID)+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {- return errors.Wrapf(err, "failed to get pipeline")+ return errors.Wrapf(err, "failed to get plan")}- if pipeline == nil {- return errors.Errorf("pipeline %v not found", task.PipelineID)+ if plan == nil {+ return errors.Errorf("plan %v not found", task.PlanID)}- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &pipeline.ProjectID})+ 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", pipeline.ProjectID)+ return errors.Errorf("project %v not found", plan.ProjectID)}instance, err := s.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})@@ -97,7 +97,7 @@ func (s *Scheduler) scheduleAutoRolloutTask(ctx context.Context, taskUID int) erreturn nil}- issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{PipelineID: &task.PipelineID})+ issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &task.PlanID})if err != nil {return err}@@ -120,7 +120,7 @@ func (s *Scheduler) scheduleAutoRolloutTask(ctx context.Context, taskUID int) er// Check the latest plan checks based on project settings (error only)if project.Setting.RequirePlanCheckNoError {pass, err := func() (bool, error) {- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{PipelineID: &task.PipelineID})+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {return false, errors.Wrapf(err, "failed to get plan")}@@ -169,7 +169,7 @@ func (s *Scheduler) scheduleAutoRolloutTask(ctx context.Context, taskUID int) erType: storepb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE,Comment: "",Issue: webhook.NewIssue(issue),- Rollout: webhook.NewRollout(pipeline),+ Rollout: webhook.NewRollout(plan),Project: webhook.NewProject(project),TaskRunStatusUpdate: &webhook.EventTaskRunStatusUpdate{Title: task.GetDatabaseName(),diff --git a/backend/runner/taskrun/data_export_executor.go b/backend/runner/taskrun/data_export_executor.goindex f54f6ec2ca..cbe7b44427 100644--- a/backend/runner/taskrun/data_export_executor.go+++ b/backend/runner/taskrun/data_export_executor.go@@ -54,7 +54,7 @@ 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) {- issue, err := exec.store.GetIssue(ctx, &store.FindIssueMessage{PipelineID: &task.PipelineID})+ issue, err := exec.store.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &task.PlanID})if err != nil {return true, nil, errors.Wrapf(err, "failed to get issue")}diff --git a/backend/runner/taskrun/database_create_executor.go b/backend/runner/taskrun/database_create_executor.goindex b6afff0cb9..ccd13c10cf 100644--- a/backend/runner/taskrun/database_create_executor.go+++ b/backend/runner/taskrun/database_create_executor.go@@ -64,12 +64,12 @@ func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx contereturn true, nil, errors.Errorf("creating database is not supported for engine %v", instance.Metadata.GetEngine().String())}- pipeline, err := exec.store.GetPipelineByID(ctx, task.PipelineID)+ plan, err := exec.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {- return true, nil, errors.Wrapf(err, "failed to get pipeline")+ return true, nil, errors.Wrapf(err, "failed to get plan %v", task.PlanID)}- if pipeline == nil {- return true, nil, errors.Errorf("pipeline %v not found", task.PipelineID)+ if plan == nil {+ return true, nil, errors.Errorf("plan %v not found", task.PlanID)}// Create database.@@ -85,7 +85,7 @@ func (exec *DatabaseCreateExecutor) RunOnce(ctx context.Context, driverCtx conteenvironmentID = &envID}database, err := exec.store.UpsertDatabase(ctx, &store.DatabaseMessage{- ProjectID: pipeline.ProjectID,+ ProjectID: plan.ProjectID,InstanceID: instance.ResourceID,DatabaseName: task.Payload.GetDatabaseName(),EnvironmentID: environmentID,diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.goindex 0e0af3a96d..3851dacf88 100644--- a/backend/runner/taskrun/database_migrate_executor.go+++ b/backend/runner/taskrun/database_migrate_executor.go@@ -237,16 +237,20 @@ func (exec *DatabaseMigrateExecutor) runGhostMigration(ctx context.Context, driv}func (exec *DatabaseMigrateExecutor) shouldSkipBackupError(ctx context.Context, task *store.TaskMessage) (bool, error) {- pipeline, pipelineErr := exec.store.GetPipelineByID(ctx, task.PipelineID)- if pipelineErr != nil {- return false, errors.Wrapf(pipelineErr, "failed to get pipeline %v", task.PipelineID)+ plan, err := exec.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})+ if err != nil {+ return false, errors.Wrapf(err, "failed to get plan %v", task.PlanID)+ }+ if plan == nil {+ return false, errors.Errorf("plan %v not found", task.PlanID)}- project, projectErr := exec.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &pipeline.ProjectID})++ project, projectErr := exec.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &plan.ProjectID})if projectErr != nil {- return false, errors.Wrapf(projectErr, "failed to get project %v", pipeline.ProjectID)+ return false, errors.Wrapf(projectErr, "failed to get project %v", plan.ProjectID)}if project == nil {- return false, errors.Errorf("project not found for pipeline %v", task.PipelineID)+ return false, errors.Errorf("project not found for plan %v", task.PlanID)}if project.Setting == nil {return false, nildiff --git a/backend/runner/taskrun/executor.go b/backend/runner/taskrun/executor.goindex 21f2f8f40c..96bc881ee2 100644--- a/backend/runner/taskrun/executor.go+++ b/backend/runner/taskrun/executor.go@@ -142,12 +142,12 @@ func getMigrationInfo(ctx context.Context, stores *store.Store, profile *config.if database == nil {return nil, errors.Errorf("database not found")}- pipeline, err := stores.GetPipelineByID(ctx, task.PipelineID)+ plan, err := stores.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {- return nil, errors.Wrapf(err, "failed to get pipeline")+ return nil, errors.Wrapf(err, "failed to get plan")}- if pipeline == nil {- return nil, errors.Errorf("pipeline %v not found", task.PipelineID)+ if plan == nil {+ return nil, errors.Errorf("plan %v not found", task.PlanID)}mc := &migrateContext{@@ -159,7 +159,7 @@ func getMigrationInfo(ctx context.Context, stores *store.Store, profile *config.sheet: sheet,task: task,version: schemaVersion,- taskRunName: common.FormatTaskRun(pipeline.ProjectID, task.PipelineID, task.Environment, task.ID, taskRunUID),+ taskRunName: common.FormatTaskRun(plan.ProjectID, int(task.PlanID), task.Environment, task.ID, taskRunUID),taskRunUID: taskRunUID,}diff --git a/backend/runner/taskrun/pending_scheduler.go b/backend/runner/taskrun/pending_scheduler.goindex a1253308e3..dc57a6d317 100644--- a/backend/runner/taskrun/pending_scheduler.go+++ b/backend/runner/taskrun/pending_scheduler.go@@ -78,7 +78,7 @@ func (s *Scheduler) schedulePendingTaskRun(ctx context.Context, taskRun *store.Treturn true, nil}- maybeTaskID, err := s.store.FindBlockingTaskByVersion(ctx, task.PipelineID, task.InstanceID, *task.DatabaseName, 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")}diff --git a/backend/runner/taskrun/running_scheduler.go b/backend/runner/taskrun/running_scheduler.goindex 744300a684..68e751ad8b 100644--- a/backend/runner/taskrun/running_scheduler.go+++ b/backend/runner/taskrun/running_scheduler.go@@ -139,23 +139,23 @@ func (s *Scheduler) scheduleRunningTaskRun(ctx context.Context, taskRun *store.T}// Check max running task runs per rollout.- pipeline, err := s.store.GetPipelineByID(ctx, task.PipelineID)+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {- return errors.Wrapf(err, "failed to get pipeline")+ return errors.Wrapf(err, "failed to get plan")}- if pipeline == nil {- return errors.Errorf("pipeline %v not found", task.PipelineID)+ if plan == nil {+ return errors.Errorf("plan %v not found", task.PlanID)}- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &pipeline.ProjectID})+ 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", pipeline.ProjectID)+ return errors.Errorf("project %v not found", plan.ProjectID)}- rolloutID := strconv.Itoa(pipeline.ID)+ rolloutID := strconv.FormatInt(plan.UID, 10)maxRunningTaskRunsPerRollout := int(project.Setting.GetParallelTasksPerRollout())if maxRunningTaskRunsPerRollout <= 0 {maxRunningTaskRunsPerRollout = defaultRolloutMaxRunningTaskRuns@@ -224,7 +224,7 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRun *store.TaskRunMeif task.DatabaseName != nil {s.stateCfg.RunningDatabaseMigration.Delete(getDatabaseKey(task.InstanceID, *task.DatabaseName))}- s.stateCfg.RolloutOutstandingTasks.Decrement(strconv.Itoa(task.PipelineID) + "/" + task.InstanceID)+ s.stateCfg.RolloutOutstandingTasks.Decrement(strconv.FormatInt(task.PlanID, 10) + "/" + task.InstanceID)}()driverCtx, cancel := context.WithCancel(ctx)@@ -366,22 +366,22 @@ func (s *Scheduler) runTaskRunOnce(ctx context.Context, taskRun *store.TaskRunMefunc (s *Scheduler) createActivityForTaskRunStatusUpdate(ctx context.Context, task *store.TaskMessage, newStatus storepb.TaskRun_Status, errDetail string) {if err := func() error {- rollout, err := s.store.GetPipelineByID(ctx, task.PipelineID)+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {- return errors.Wrapf(err, "failed to get pipeline")+ return errors.Wrapf(err, "failed to get plan")}- if rollout == nil {- return errors.Errorf("pipeline %v not found", task.PipelineID)+ if plan == nil {+ return errors.Errorf("plan %v not found", task.PlanID)}- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &rollout.ProjectID})+ 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", rollout.ProjectID)+ return errors.Errorf("project %v not found", plan.ProjectID)}issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{- PipelineID: &task.PipelineID,+ PlanUID: &task.PlanID,})if err != nil {return errors.Wrap(err, "failed to get issue")@@ -391,7 +391,7 @@ func (s *Scheduler) createActivityForTaskRunStatusUpdate(ctx context.Context, taType: storepb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE,Comment: "",Issue: webhook.NewIssue(issue),- Rollout: webhook.NewRollout(rollout),+ Rollout: webhook.NewRollout(plan),Project: webhook.NewProject(project),TaskRunStatusUpdate: &webhook.EventTaskRunStatusUpdate{Title: task.GetDatabaseName(),diff --git a/backend/runner/taskrun/scheduler.go b/backend/runner/taskrun/scheduler.goindex 77c52488bf..b203d83a91 100644--- a/backend/runner/taskrun/scheduler.go+++ b/backend/runner/taskrun/scheduler.go@@ -92,11 +92,11 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {}}()slog.Info("TaskSkippedOrDoneListener started")- type pipelineEnvironment struct {- pipelineUID int+ type planEnvironment struct {+ planUID int64environment string}- pipelineEnvironmentDoneConfirmed := map[pipelineEnvironment]bool{}+ planEnvironmentDoneConfirmed := map[planEnvironment]bool{}for {select {@@ -106,11 +106,11 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {if err != nil {return errors.Wrapf(err, "failed to get task")}- if pipelineEnvironmentDoneConfirmed[pipelineEnvironment{pipelineUID: task.PipelineID, environment: task.Environment}] {+ if planEnvironmentDoneConfirmed[planEnvironment{planUID: task.PlanID, environment: task.Environment}] {return nil}- environmentTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &task.PipelineID, Environment: &task.Environment})+ environmentTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &task.PlanID, Environment: &task.Environment})if err != nil {return errors.Wrapf(err, "failed to list tasks")}@@ -120,7 +120,7 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {return nil}- pipelineEnvironmentDoneConfirmed[pipelineEnvironment{pipelineUID: task.PipelineID, environment: task.Environment}] = true+ planEnvironmentDoneConfirmed[planEnvironment{planUID: task.PlanID, environment: task.Environment}] = true// Get live environment order// Some environments may have zero tasks. We need to filter them out.@@ -133,7 +133,7 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {environmentOrder = append(environmentOrder, env.Id)}- allTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &task.PipelineID})+ allTasks, err := s.store.ListTasks(ctx, &store.TaskFind{PlanID: &task.PlanID})if err != nil {return errors.Wrapf(err, "failed to list tasks")}@@ -152,34 +152,34 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {currentEnvironment := task.Environmentvar nextEnvironment string- var pipelineDone bool+ var planDone boolfor i, env := range filteredEnvironmentOrder {if env == currentEnvironment {if i < len(filteredEnvironmentOrder)-1 {nextEnvironment = filteredEnvironmentOrder[i+1]}if i == len(filteredEnvironmentOrder)-1 {- pipelineDone = true+ planDone = true}break}}- pipeline, err := s.store.GetPipelineByID(ctx, task.PipelineID)+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &task.PlanID})if err != nil {- return errors.Wrapf(err, "failed to get pipeline")+ return errors.Wrapf(err, "failed to get plan")}- if pipeline == nil {- return errors.Errorf("pipeline %v not found", task.PipelineID)+ if plan == nil {+ return errors.Errorf("plan %v not found", task.PlanID)}- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &pipeline.ProjectID})+ 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", pipeline.ProjectID)+ return errors.Errorf("project %v not found", plan.ProjectID)}- issueN, err := s.store.GetIssue(ctx, &store.FindIssueMessage{PipelineID: &task.PipelineID})+ issueN, err := s.store.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &task.PlanID})if err != nil {return errors.Wrapf(err, "failed to get issue")}@@ -191,7 +191,7 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {Type: storepb.Activity_ISSUE_PIPELINE_STAGE_STATUS_UPDATE,Comment: "",Issue: webhook.NewIssue(issueN),- Rollout: webhook.NewRollout(pipeline),+ Rollout: webhook.NewRollout(plan),Project: webhook.NewProject(project),StageStatusUpdate: &webhook.EventStageStatusUpdate{StageTitle: currentEnvironment,@@ -225,7 +225,7 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {}// After all tasks in the pipeline are done, we will resolve the issue.- if issueN != nil && pipelineDone {+ if issueN != nil && planDone {if err := func() error {// For those database data export issues, we don't resolve them automatically.if issueN.Type == storepb.Issue_DATABASE_EXPORT {diff --git a/backend/store/issue.go b/backend/store/issue.goindex eb020bf489..69cd93f702 100644--- a/backend/store/issue.go+++ b/backend/store/issue.go@@ -40,7 +40,6 @@ type IssueMessage struct {Type storepb.Issue_TypeDescription stringPayload *storepb.Issue- PipelineUID *int // Computed from plan.pipeline_idPlanUID *int64TaskStatusCount map[string]int32@@ -66,7 +65,7 @@ type FindIssueMessage struct {ProjectID *stringProjectIDs *[]stringPlanUID *int64- PipelineID *int // Filter by pipeline_id (computed from plan)+ // PipelineID is deprecated, use PlanUID.// To support pagination, we add into creatorEmail.// Only principleID or one of the following three fields can be set.CreatorID *string@@ -243,9 +242,6 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issuif v := find.UID; v != nil {where.And("issue.id = ?", *v)}- if v := find.PipelineID; v != nil {- where.And("plan.pipeline_id = ?", *v)- }if v := find.PlanUID; v != nil {where.And("issue.plan_id = ?", *v)}@@ -256,10 +252,10 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issuwhere.And("issue.project = ANY(?)", *v)}if v := find.InstanceResourceID; v != nil {- where.And("EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = plan.pipeline_id AND task.instance = ?)", *v)+ where.And("EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.instance = ?)", *v)}if find.InstanceID != nil && find.DatabaseName != nil {- where.And("EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = plan.pipeline_id AND task.instance = ? AND task.db_name = ?)", *find.InstanceID, *find.DatabaseName)+ where.And("EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.instance = ? AND task.db_name = ?)", *find.InstanceID, *find.DatabaseName)}if v := find.CreatorID; v != nil {where.And("issue.creator = ?", *v)@@ -299,16 +295,16 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issufor _, t := range *v {taskTypeStrings = append(taskTypeStrings, t.String())}- where.And("EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = plan.pipeline_id AND task.type = ANY(?))", taskTypeStrings)+ where.And("EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.type = ANY(?))", taskTypeStrings)}if v := find.EnvironmentID; v != nil {- where.And("EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = plan.pipeline_id AND task.environment = ?)", *v)+ where.And("EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.environment = ?)", *v)}if len(find.LabelList) != 0 {where.And("payload->'labels' ??& ?::TEXT[]", find.LabelList)}if find.NoPipeline {- where.And("plan.pipeline_id IS NULL")+ where.And("NOT EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id)")}q := qb.Q().Space(`@@ -318,7 +314,6 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issuissue.created_at,issue.updated_at,issue.project,- plan.pipeline_id,issue.plan_id,COALESCE(plan.name, issue.name) AS name,issue.status,@@ -347,7 +342,7 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issu(SELECT task_run.status FROM task_run WHERE task_run.task_id = task.id ORDER BY task_run.id DESC LIMIT 1), 'NOT_STARTED') AS status) AS latest_task_run ON TRUE- WHERE task.pipeline_id = plan.pipeline_id+ WHERE task.plan_id = plan.id) AS tGROUP BY t.status) AS t@@ -396,7 +391,6 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issu&issue.CreatedAt,&issue.UpdatedAt,&issue.ProjectID,- &issue.PipelineUID,&issue.PlanUID,&issue.Title,&statusString,diff --git a/backend/store/pipeline.go b/backend/store/pipeline.goindex f6ef1a9b05..06c8357f38 100644--- a/backend/store/pipeline.go+++ b/backend/store/pipeline.go@@ -41,37 +41,19 @@ type PipelineFind struct {FilterQ *qb.Query}-// CreatePipelineAIO creates a pipeline with tasks all in one.-func (s *Store) CreatePipelineAIO(ctx context.Context, planUID int64, pipeline *PipelineMessage, creator string) (createdPipelineUID int, err error) {+// CreateRolloutTasks creates tasks for a plan.+func (s *Store) CreateRolloutTasks(ctx context.Context, planUID int64, pipeline *PipelineMessage) (int64, error) {tx, err := s.GetDB().BeginTx(ctx, nil)if err != nil {return 0, errors.Wrapf(err, "failed to begin tx")}defer tx.Rollback()- pipelineUIDMaybe, err := lockPlanAndGetPipelineUID(ctx, tx, planUID)- if err != nil {- return 0, errors.Wrapf(err, "failed to SELECT plan FOR UPDATE")- }invalidateCacheF := func() {}- if pipelineUIDMaybe == nil {- createdPipeline, err := s.createPipeline(ctx, tx, pipeline, creator)- if err != nil {- return 0, errors.Wrapf(err, "failed to create pipeline")- }- createdPipelineUID = createdPipeline.ID-- // update pipeline uid of associated issue and plan- if invalidateCacheF, err = s.updatePipelineUIDOfPlan(ctx, tx, planUID, createdPipelineUID); err != nil {- return 0, errors.Wrapf(err, "failed to update associated plan or issue")- }- } else {- createdPipelineUID = *pipelineUIDMaybe- }// Check existing tasks to avoid duplicatesexistingTasks, err := s.listTasksTx(ctx, tx, &TaskFind{- PipelineID: &createdPipelineUID,+ PlanID: &planUID,})if err != nil {return 0, errors.Wrapf(err, "failed to list existing tasks")@@ -109,7 +91,7 @@ func (s *Store) CreatePipelineAIO(ctx context.Context, planUID int64, pipeline *if _, ok := createdTasks[k]; ok {continue}- taskCreate.PipelineID = createdPipelineUID+ taskCreate.PlanID = planUIDtaskCreateList = append(taskCreateList, taskCreate)}@@ -124,83 +106,7 @@ func (s *Store) CreatePipelineAIO(ctx context.Context, planUID int64, pipeline *}invalidateCacheF()- return createdPipelineUID, nil-}--// returns func() to invalidate cache.-func (*Store) updatePipelineUIDOfPlan(ctx context.Context, txn *sql.Tx, planUID int64, pipelineUID int) (func(), error) {- q := qb.Q().Space(`- UPDATE plan- SET pipeline_id = ?- WHERE id = ?- `, pipelineUID, planUID)- querySQL, args, err := q.ToSQL()- if err != nil {- return nil, errors.Wrapf(err, "failed to build sql")- }- if _, err := txn.ExecContext(ctx, querySQL, args...); err != nil {- return nil, errors.Wrapf(err, "failed to update plan pipeline_id")- }-- return func() {- // TODO: need to remove planCache once we add planCache- }, nil-}--func lockPlanAndGetPipelineUID(ctx context.Context, txn *sql.Tx, planUID int64) (*int, error) {- q := qb.Q().Space("SELECT pipeline_id FROM plan WHERE id = ? FOR UPDATE", planUID)- query, args, err := q.ToSQL()- if err != nil {- return nil, errors.Wrapf(err, "failed to build sql")- }- var uid sql.NullInt32- if err := txn.QueryRowContext(ctx, query, args...).Scan(&uid); err != nil {- if err == sql.ErrNoRows {- return nil, errors.Errorf("plan %d not found", planUID)- }- return nil, errors.Wrapf(err, "failed to get pipeline uid")- }-- if uid.Valid {- uidInt := int(uid.Int32)- return &uidInt, nil- }- return nil, nil-}--func (*Store) createPipeline(ctx context.Context, txn *sql.Tx, create *PipelineMessage, creator string) (*PipelineMessage, error) {- q := qb.Q().Space(`- INSERT INTO pipeline (- project,- creator- )- VALUES (- ?,- ?- )- RETURNING id, created_at- `, create.ProjectID, creator)- query, args, err := q.ToSQL()- if err != nil {- return nil, errors.Wrapf(err, "failed to build sql")- }- pipeline := &PipelineMessage{- ProjectID: create.ProjectID,- Creator: creator,- }- if err := txn.QueryRowContext(ctx, query, args...).Scan(- &pipeline.ID,- &pipeline.CreatedAt,- ); err != nil {- if err == sql.ErrNoRows {- return nil, common.FormatDBErrorEmptyRowWithQuery(query)- }- return nil, errors.Wrapf(err, "failed to insert")- }- // Initialize UpdatedAt with CreatedAt for new pipelines- pipeline.UpdatedAt = pipeline.CreatedAt-- return pipeline, nil+ return planUID, nil}// GetPipeline gets the pipeline.@@ -228,22 +134,21 @@ func (s *Store) GetPipelineByID(ctx context.Context, id int) (*PipelineMessage,func (s *Store) ListPipelines(ctx context.Context, find *PipelineFind) ([]*PipelineMessage, error) {q := qb.Q().Space(`SELECT- pipeline.id,- pipeline.creator,- pipeline.created_at,- pipeline.project,+ plan.id,+ plan.creator,+ plan.created_at,+ plan.project,issue.id,COALESCE((SELECT MAX(task_run.updated_at)FROM taskJOIN task_run ON task_run.task_id = task.id- WHERE task.pipeline_id = pipeline.id+ WHERE task.plan_id = plan.id),- pipeline.created_at+ plan.created_at) AS updated_at- FROM pipeline- LEFT JOIN plan ON plan.pipeline_id = pipeline.id+ FROM planLEFT JOIN issue ON issue.plan_id = plan.idWHERE TRUE`)@@ -252,13 +157,13 @@ func (s *Store) ListPipelines(ctx context.Context, find *PipelineFind) ([]*Pipelq.And("?", filterQ)}if v := find.ID; v != nil {- q.And("pipeline.id = ?", *v)+ q.And("plan.id = ?", *v)}if v := find.ProjectID; v != nil {- q.And("pipeline.project = ?", *v)+ q.And("plan.project = ?", *v)}- q.Space("ORDER BY pipeline.id DESC")+ q.Space("ORDER BY plan.id DESC")if v := find.Limit; v != nil {q.Space("LIMIT ?", *v)}@@ -348,7 +253,7 @@ func (s *Store) GetListRolloutFilter(_ context.Context, filter string) (*qb.Querif creatorEmail == "" {return nil, errors.New("invalid empty creator identifier")}- return qb.Q().Space("pipeline.creator = ?", creatorEmail), nil+ return qb.Q().Space("plan.creator = ?", creatorEmail), nilcase "task_type":taskType, ok := value.(string)if !ok {@@ -359,7 +264,7 @@ func (s *Store) GetListRolloutFilter(_ context.Context, filter string) (*qb.Quer}v1TaskType := v1pb.Task_Type(v1pb.Task_Type_value[taskType])storeTaskType := convertV1ToStoreTaskType(v1TaskType)- return qb.Q().Space("EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = pipeline.id AND task.type = ?)", storeTaskType.String()), nil+ return qb.Q().Space("EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.type = ?)", storeTaskType.String()), nildefault:return nil, errors.Errorf("unsupported variable %q", variable)}@@ -387,7 +292,7 @@ func (s *Store) GetListRolloutFilter(_ context.Context, filter string) (*qb.QuerstoreTaskType := convertV1ToStoreTaskType(v1TaskType)taskTypes = append(taskTypes, storeTaskType.String())}- return qb.Q().Space("EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = pipeline.id AND task.type = ANY(?))", taskTypes), nil+ return qb.Q().Space("EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.type = ANY(?))", taskTypes), nildefault:return nil, errors.Errorf("unsupported variable %q", variable)}@@ -405,7 +310,7 @@ func (s *Store) GetListRolloutFilter(_ context.Context, filter string) (*qb.Querreturn nil, errors.Errorf("failed to parse time %v, error: %v", value, err)}// Use the same subquery as in ListPipelines SELECT to compute updated_at- updatedAtSubquery := `COALESCE((SELECT MAX(task_run.updated_at) FROM task JOIN task_run ON task_run.task_id = task.id WHERE task.pipeline_id = pipeline.id), pipeline.created_at)`+ updatedAtSubquery := `COALESCE((SELECT MAX(task_run.updated_at) FROM task JOIN task_run ON task_run.task_id = task.id WHERE task.plan_id = plan.id), plan.created_at)`if functionName == celoperators.GreaterEquals {return qb.Q().Space(updatedAtSubquery+" >= ?", t), nil}diff --git a/backend/store/pipeline_filter_test.go b/backend/store/pipeline_filter_test.goindex dd63a2d8a3..a88aa3d476 100644--- a/backend/store/pipeline_filter_test.go+++ b/backend/store/pipeline_filter_test.go@@ -13,7 +13,7 @@ func TestGetListRolloutFilter(t *testing.T) {ctx := context.Background()// The subquery used for update_time filtering- updatedAtSubquery := `COALESCE((SELECT MAX(task_run.updated_at) FROM task JOIN task_run ON task_run.task_id = task.id WHERE task.pipeline_id = pipeline.id), pipeline.created_at)`+ updatedAtSubquery := `COALESCE((SELECT MAX(task_run.updated_at) FROM task JOIN task_run ON task_run.task_id = task.id WHERE task.plan_id = plan.id), plan.created_at)`tests := []struct {name string@@ -33,21 +33,21 @@ func TestGetListRolloutFilter(t *testing.T) {{name: "creator filter",filter: `creator == "users/[email protected]"`,- wantSQL: "(pipeline.creator = $1)",+ wantSQL: "(plan.creator = $1)",wantArgs: []any{"[email protected]"},wantErr: false,},{name: "task_type equals filter",filter: `task_type == "DATABASE_MIGRATE"`,- wantSQL: "(EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = pipeline.id AND task.type = $1))",+ wantSQL: "(EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.type = $1))",wantArgs: []any{"DATABASE_MIGRATE"},wantErr: false,},{name: "task_type in filter",filter: `task_type in ["DATABASE_MIGRATE", "DATABASE_SDL"]`,- wantSQL: "(EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = pipeline.id AND task.type = ANY($1)))",+ wantSQL: "(EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.type = ANY($1)))",wantArgs: []any{[]string{"DATABASE_MIGRATE", "DATABASE_SDL"}},wantErr: false,},@@ -84,7 +84,7 @@ func TestGetListRolloutFilter(t *testing.T) {{name: "AND condition with task_type and update_time",filter: `task_type == "DATABASE_MIGRATE" && update_time >= "2024-01-01T00:00:00Z"`,- wantSQL: "((EXISTS (SELECT 1 FROM task WHERE task.pipeline_id = pipeline.id AND task.type = $1) AND " + updatedAtSubquery + " >= $2))",+ wantSQL: "((EXISTS (SELECT 1 FROM task WHERE task.plan_id = plan.id AND task.type = $1) AND " + updatedAtSubquery + " >= $2))",wantArgs: []any{"DATABASE_MIGRATE", func() time.Time {ts, _ := time.Parse(time.RFC3339, "2024-01-01T00:00:00Z")return tsdiff --git a/backend/store/plan.go b/backend/store/plan.goindex 6f083d086b..e97f617e06 100644--- a/backend/store/plan.go+++ b/backend/store/plan.go@@ -23,7 +23,6 @@ import (// PlanMessage is the message for plan.type PlanMessage struct {ProjectID string- PipelineUID *intName stringDescription stringConfig *storepb.PlanConfig@@ -40,7 +39,8 @@ type FindPlanMessage struct {UID *int64ProjectID *stringProjectIDs *[]string- PipelineID *int++ HasRollout *boolLimit *intOffset *int@@ -54,6 +54,7 @@ type UpdatePlanMessage struct {Name *stringDescription *stringSpecs *[]*storepb.PlanConfig_Spec+ HasRollout *boolDeleted *bool}@@ -68,14 +69,13 @@ func (s *Store) CreatePlan(ctx context.Context, plan *PlanMessage, creator strinINSERT INTO plan (creator,project,- pipeline_id,name,description,config) VALUES (- ?, ?, ?, ?, ?, ?+ ?, ?, ?, ?, ?) RETURNING id, created_at, updated_at- `, creator, plan.ProjectID, plan.PipelineUID, plan.Name, plan.Description, config)+ `, creator, plan.ProjectID, plan.Name, plan.Description, config)query, args, err := q.ToSQL()if err != nil {@@ -126,7 +126,6 @@ func (s *Store) ListPlans(ctx context.Context, find *FindPlanMessage) ([]*PlanMeplan.created_at,plan.updated_at,plan.project,- plan.pipeline_id,plan.name,plan.description,plan.config,@@ -152,8 +151,12 @@ func (s *Store) ListPlans(ctx context.Context, find *FindPlanMessage) ([]*PlanMeq.And("plan.project = ANY(?)", *v)}}- if v := find.PipelineID; v != nil {- q.And("plan.pipeline_id = ?", *v)+ if v := find.HasRollout; v != nil {+ if *v {+ q.And("plan.config->>'hasRollout' = ?", "true")+ } else {+ q.And("(plan.config->>'hasRollout' IS NULL OR plan.config->>'hasRollout' = ?)", "false")+ }}q.Space("ORDER BY id DESC")@@ -193,7 +196,6 @@ func (s *Store) ListPlans(ctx context.Context, find *FindPlanMessage) ([]*PlanMe&plan.CreatedAt,&plan.UpdatedAt,&plan.ProjectID,- &plan.PipelineUID,&plan.Name,&plan.Description,&config,@@ -246,6 +248,14 @@ func (s *Store) UpdatePlan(ctx context.Context, patch *UpdatePlanMessage) errorpayloadSets = append(payloadSets, "jsonb_build_object('specs', (?)::JSONB->'specs')")args = append(args, config)}+ if v := patch.HasRollout; v != nil {+ boolStr := "false"+ if *v {+ boolStr = "true"+ }+ payloadSets = append(payloadSets, "jsonb_build_object('hasRollout', ?::jsonb)")+ args = append(args, boolStr)+ }if len(payloadSets) > 0 {set = append(set, fmt.Sprintf("config = config || %s", strings.Join(payloadSets, " || ")))}@@ -322,9 +332,9 @@ func (s *Store) GetListPlanFilter(_ context.Context, filter string) (*qb.Query,return nil, errors.Errorf(`"has_pipeline" should be bool`)}if !hasPipeline {- return qb.Q().Space("plan.pipeline_id IS NULL"), nil+ return qb.Q().Space("(plan.config->>'hasRollout' IS NULL OR plan.config->>'hasRollout' = ?)", "false"), nil}- return qb.Q().Space("plan.pipeline_id IS NOT NULL"), nil+ return qb.Q().Space("plan.config->>'hasRollout' = ?", "true"), nilcase "has_issue":hasIssue, ok := value.(bool)if !ok {diff --git a/backend/store/plan_filter_test.go b/backend/store/plan_filter_test.goindex 11b9a04669..860c7989e2 100644--- a/backend/store/plan_filter_test.go+++ b/backend/store/plan_filter_test.go@@ -33,15 +33,15 @@ func TestGetListPlanFilter(t *testing.T) {{name: "has_pipeline filter - true",filter: `has_pipeline == true`,- wantSQL: "(plan.pipeline_id IS NOT NULL)",- wantArgs: []any{},+ wantSQL: "(plan.config->>'hasRollout' = $1)",+ wantArgs: []any{"true"},wantErr: false,},{name: "has_pipeline filter - false",filter: `has_pipeline == false`,- wantSQL: "(plan.pipeline_id IS NULL)",- wantArgs: []any{},+ wantSQL: "((plan.config->>'hasRollout' IS NULL OR plan.config->>'hasRollout' = $1))",+ wantArgs: []any{"false"},wantErr: false,},{@@ -130,15 +130,15 @@ func TestGetListPlanFilter(t *testing.T) {{name: "AND condition with has_pipeline and has_issue",filter: `has_pipeline == true && has_issue == true`,- wantSQL: "((plan.pipeline_id IS NOT NULL AND issue.id IS NOT NULL))",- wantArgs: []any{},+ wantSQL: "((plan.config->>'hasRollout' = $1 AND issue.id IS NOT NULL))",+ wantArgs: []any{"true"},wantErr: false,},{name: "complex AND condition",filter: `title == "Test Plan" && state == "STATE_ACTIVE" && has_pipeline == true`,- wantSQL: "(((plan.name = $1 AND plan.deleted = $2) AND plan.pipeline_id IS NOT NULL))",- wantArgs: []any{"Test Plan", false},+ wantSQL: "(((plan.name = $1 AND plan.deleted = $2) AND plan.config->>'hasRollout' = $3))",+ wantArgs: []any{"Test Plan", false, "true"},wantErr: false,},{diff --git a/backend/store/project.go b/backend/store/project.goindex 85cbf561eb..6c75b6adea 100644--- a/backend/store/project.go+++ b/backend/store/project.go@@ -410,12 +410,12 @@ func (s *Store) DeleteProject(ctx context.Context, resourceID string) error {return errors.Wrapf(err, "failed to delete plans for project %s", resourceID)}- // Delete task_run_log entries for tasks in pipelines of this project+ // Delete task_run_log entries for tasks in plans of this projectq = qb.Q().Space("DELETE FROM task_run_log")q.Space("WHERE task_run_id IN (")q.Space("SELECT tr.id FROM task_run tr")q.Space("JOIN task t ON tr.task_id = t.id")- q.Space("JOIN pipeline p ON t.pipeline_id = p.id")+ q.Space("JOIN plan p ON t.plan_id = p.id")q.Space("WHERE p.project = ?)", resourceID)sql, args, err = q.ToSQL()if err != nil {@@ -425,11 +425,11 @@ func (s *Store) DeleteProject(ctx context.Context, resourceID string) error {return errors.Wrapf(err, "failed to delete task_run_log for project %s", resourceID)}- // Delete task_run entries for tasks in pipelines of this project+ // Delete task_run entries for tasks in plans of this projectq = qb.Q().Space("DELETE FROM task_run")q.Space("WHERE task_id IN (")q.Space("SELECT t.id FROM task t")- q.Space("JOIN pipeline p ON t.pipeline_id = p.id")+ q.Space("JOIN plan p ON t.plan_id = p.id")q.Space("WHERE p.project = ?)", resourceID)sql, args, err = q.ToSQL()if err != nil {@@ -439,9 +439,9 @@ func (s *Store) DeleteProject(ctx context.Context, resourceID string) error {return errors.Wrapf(err, "failed to delete task_run for project %s", resourceID)}- // Delete tasks in pipelines of this project+ // Delete tasks in plans of this projectq = qb.Q().Space("DELETE FROM task")- q.Space("WHERE pipeline_id IN (SELECT id FROM pipeline WHERE project = ?)", resourceID)+ q.Space("WHERE plan_id IN (SELECT id FROM plan WHERE project = ?)", resourceID)sql, args, err = q.ToSQL()if err != nil {return errors.Wrap(err, "failed to build task delete query")@@ -450,16 +450,6 @@ func (s *Store) DeleteProject(ctx context.Context, resourceID string) error {return errors.Wrapf(err, "failed to delete tasks for project %s", resourceID)}- // Delete pipelines associated with this project- q = qb.Q().Space("DELETE FROM pipeline WHERE project = ?", resourceID)- sql, args, err = q.ToSQL()- if err != nil {- return errors.Wrap(err, "failed to build pipeline delete query")- }- if _, err := tx.ExecContext(ctx, sql, args...); err != nil {- return errors.Wrapf(err, "failed to delete pipelines for project %s", resourceID)- }-// Delete sheets associated with this projectq = qb.Q().Space("DELETE FROM sheet WHERE project = ?", resourceID)sql, args, err = q.ToSQL()diff --git a/backend/store/task.go b/backend/store/task.goindex 9938babd8f..87abc916e5 100644--- a/backend/store/task.go+++ b/backend/store/task.go@@ -21,7 +21,7 @@ type TaskMessage struct {ID int// Related fields- PipelineID int+ PlanID int64InstanceID stringEnvironment string // The environment ID (was stage_id). Could be empty if the task does not have an environment.DatabaseName *string@@ -55,7 +55,7 @@ type TaskFind struct {IDs *[]int// Related fields- PipelineID *int+ PlanID *int64Environment *stringInstanceID *stringDatabaseName *string@@ -105,7 +105,7 @@ func (s *Store) GetTaskByID(ctx context.Context, id int) (*TaskMessage, error) {// Get a blocking task in the pipeline.// A task is blocked by a task with a smaller schema version within the same pipeline.-func (s *Store) FindBlockingTaskByVersion(ctx context.Context, pipelineUID int, instanceID, databaseName string, version string) (*int, error) {+func (s *Store) FindBlockingTaskByVersion(ctx context.Context, planUID int64, instanceID, databaseName string, version string) (*int, error) {myVersion, err := model.NewVersion(version)if err != nil {return nil, err@@ -115,8 +115,7 @@ func (s *Store) FindBlockingTaskByVersion(ctx context.Context, pipelineUID int,task.id,task.payload->>'schemaVersion'FROM task- LEFT JOIN pipeline ON task.pipeline_id = pipeline.id- LEFT JOIN plan ON plan.pipeline_id = pipeline.id+ LEFT JOIN plan ON plan.id = task.plan_idLEFT JOIN issue ON issue.plan_id = plan.idLEFT JOIN LATERAL (SELECT COALESCE(@@ -129,12 +128,12 @@ func (s *Store) FindBlockingTaskByVersion(ctx context.Context, pipelineUID int,), 'NOT_STARTED') AS status) AS latest_task_run ON TRUE- WHERE task.pipeline_id = ? AND task.instance = ? AND task.db_name = ?+ WHERE task.plan_id = ? AND task.instance = ? AND task.db_name = ?AND task.payload->>'schemaVersion' IS NOT NULLAND (task.payload->>'skipped')::BOOLEAN IS NOT TRUEAND latest_task_run.status != 'DONE'AND COALESCE(issue.status, 'OPEN') = 'OPEN'- ORDER BY task.id ASC`, pipelineUID, instanceID, databaseName)+ ORDER BY task.id ASC`, planUID, instanceID, databaseName)query, args, err := q.ToSQL()if err != nil {return nil, errors.Wrapf(err, "failed to build sql")@@ -166,7 +165,7 @@ func (s *Store) FindBlockingTaskByVersion(ctx context.Context, pipelineUID int,func (*Store) createTasks(ctx context.Context, txn *sql.Tx, creates ...*TaskMessage) ([]*TaskMessage, error) {var (- pipelineIDs []int+ planIDs []int64instances []stringdatabases []*stringenvironments []string@@ -181,7 +180,7 @@ func (*Store) createTasks(ctx context.Context, txn *sql.Tx, creates ...*TaskMessif err != nil {return nil, errors.Wrapf(err, "failed to marshal payload")}- pipelineIDs = append(pipelineIDs, create.PipelineID)+ planIDs = append(planIDs, create.PlanID)instances = append(instances, create.InstanceID)databases = append(databases, create.DatabaseName)types = append(types, create.Type.String())@@ -191,21 +190,21 @@ func (*Store) createTasks(ctx context.Context, txn *sql.Tx, creates ...*TaskMessq := qb.Q().Space(`INSERT INTO task (- pipeline_id,+ plan_id,instance,db_name,environment,type,payload) SELECT- unnest(CAST(? AS INTEGER[])),+ unnest(CAST(? AS BIGINT[])),unnest(CAST(? AS TEXT[])),unnest(CAST(? AS TEXT[])),unnest(CAST(? AS TEXT[])),unnest(CAST(? AS TEXT[])),unnest(CAST(? AS JSONB[]))- RETURNING id, pipeline_id, instance, db_name, environment, type, payload`,- pipelineIDs,+ RETURNING id, plan_id, instance, db_name, environment, type, payload`,+ planIDs,instances,databases,environments,@@ -229,7 +228,7 @@ func (*Store) createTasks(ctx context.Context, txn *sql.Tx, creates ...*TaskMessvar typeString stringif err := rows.Scan(&task.ID,- &task.PipelineID,+ &task.PlanID,&task.InstanceID,&task.DatabaseName,&task.Environment,@@ -261,7 +260,7 @@ func (*Store) listTasksTx(ctx context.Context, txn *sql.Tx, find *TaskFind) ([]*q := qb.Q().Space(`SELECTtask.id,- task.pipeline_id,+ task.plan_id,task.instance,task.db_name,task.environment,@@ -288,8 +287,8 @@ func (*Store) listTasksTx(ctx context.Context, txn *sql.Tx, find *TaskFind) ([]*if v := find.IDs; v != nil {q.Space("AND task.id = ANY(?)", *v)}- if v := find.PipelineID; v != nil {- q.Space("AND task.pipeline_id = ?", *v)+ if v := find.PlanID; v != nil {+ q.Space("AND task.plan_id = ?", *v)}if v := find.Environment; v != nil {q.Space("AND task.environment = ?", *v)@@ -334,7 +333,7 @@ func (*Store) listTasksTx(ctx context.Context, txn *sql.Tx, find *TaskFind) ([]*var typeString stringif err := rows.Scan(&task.ID,- &task.PipelineID,+ &task.PlanID,&task.InstanceID,&task.DatabaseName,&task.Environment,@@ -433,7 +432,7 @@ func (s *Store) UpdateTask(ctx context.Context, patch *TaskPatch) (*TaskMessage,return nil, errors.Errorf("no fields to update")}- query, args, err := qb.Q().Space(`UPDATE task SET ? WHERE id = ? RETURNING id, pipeline_id, instance, db_name, environment, type, payload`, set, patch.ID).ToSQL()+ query, args, err := qb.Q().Space(`UPDATE task SET ? WHERE id = ? RETURNING id, plan_id, instance, db_name, environment, type, payload`, set, patch.ID).ToSQL()if err != nil {return nil, errors.Wrapf(err, "failed to build sql")}@@ -449,7 +448,7 @@ func (s *Store) UpdateTask(ctx context.Context, patch *TaskPatch) (*TaskMessage,var typeString stringif err := tx.QueryRowContext(ctx, query, args...).Scan(&task.ID,- &task.PipelineID,+ &task.PlanID,&task.InstanceID,&task.DatabaseName,&task.Environment,@@ -507,19 +506,18 @@ func (s *Store) BatchSkipTasks(ctx context.Context, taskUIDs []int, comment strifunc (s *Store) ListTasksToAutoRollout(ctx context.Context, environments []string) ([]int, error) {q := qb.Q().Space(`SELECT- task.pipeline_id,+ task.plan_id,task.environment,task.idFROM task- LEFT JOIN pipeline ON pipeline.id = task.pipeline_id- LEFT JOIN plan ON plan.pipeline_id = pipeline.id+ LEFT JOIN plan ON plan.id = task.plan_idLEFT JOIN issue ON issue.plan_id = plan.idWHERE NOT EXISTS (SELECT 1 FROM task_run WHERE task_run.task_id = task.id)AND task.type != 'DATABASE_EXPORT'AND COALESCE((task.payload->>'skipped')::BOOLEAN, FALSE) IS FALSEAND COALESCE(issue.status, 'OPEN') = 'OPEN'AND task.environment = ANY(?)- ORDER BY task.pipeline_id, task.id`, environments)+ ORDER BY task.plan_id, task.id`, environments)query, args, err := q.ToSQL()if err != nil {return nil, errors.Wrapf(err, "failed to build sql")@@ -530,22 +528,22 @@ func (s *Store) ListTasksToAutoRollout(ctx context.Context, environments []strin}defer rows.Close()- // Group tasks by pipeline and environment, keeping only the first task per environment- pipelineEnvFirstTask := map[int]map[string]int{}+ // Group tasks by plan and environment, keeping only the first task per environment+ planEnvFirstTask := map[int64]map[string]int{}for rows.Next() {- var pipeline int+ var plan int64var environment stringvar task int- if err := rows.Scan(&pipeline, &environment, &task); err != nil {+ if err := rows.Scan(&plan, &environment, &task); err != nil {return nil, err}- if _, ok := pipelineEnvFirstTask[pipeline]; !ok {- pipelineEnvFirstTask[pipeline] = map[string]int{}+ if _, ok := planEnvFirstTask[plan]; !ok {+ planEnvFirstTask[plan] = map[string]int{}}// Keep only the first task for each environment- if _, exists := pipelineEnvFirstTask[pipeline][environment]; !exists {- pipelineEnvFirstTask[pipeline][environment] = task+ if _, exists := planEnvFirstTask[plan][environment]; !exists {+ planEnvFirstTask[plan][environment] = task}}@@ -554,7 +552,7 @@ func (s *Store) ListTasksToAutoRollout(ctx context.Context, environments []strin}var ids []int- for _, envTasks := range pipelineEnvFirstTask {+ for _, envTasks := range planEnvFirstTask {for _, taskID := range envTasks {ids = append(ids, taskID)}diff --git a/backend/store/task_run.go b/backend/store/task_run.goindex 7c26237df7..e608d1c578 100644--- a/backend/store/task_run.go+++ b/backend/store/task_run.go@@ -16,7 +16,7 @@ import (type TaskRunMessage struct {TaskUID intEnvironment string // Refer to the task's environment.- PipelineUID int+ PlanUID int64Status storepb.TaskRun_StatusCode common.CodeResult string@@ -39,7 +39,7 @@ type FindTaskRunMessage struct {UIDs *[]intTaskUID *intEnvironment *string- PipelineUID *int+ PlanUID *int64Status *[]storepb.TaskRun_Status}@@ -71,13 +71,13 @@ func (s *Store) ListTaskRuns(ctx context.Context, find *FindTaskRunMessage) ([]*task_run.code,task_run.result,encode(task_run.sheet_sha256, 'hex'),- task.pipeline_id,+ task.plan_id,task.environment,project.resource_idFROM task_runLEFT JOIN task ON task.id = task_run.task_id- LEFT JOIN pipeline ON pipeline.id = task.pipeline_id- LEFT JOIN project ON project.resource_id = pipeline.project+ LEFT JOIN plan ON plan.id = task.plan_id+ LEFT JOIN project ON project.resource_id = plan.projectWHERE TRUE`)@@ -93,8 +93,8 @@ func (s *Store) ListTaskRuns(ctx context.Context, find *FindTaskRunMessage) ([]*if v := find.Environment; v != nil {q.And("task.environment = ?", *v)}- if v := find.PipelineUID; v != nil {- q.And("task.pipeline_id = ?", *v)+ if v := find.PlanUID; v != nil {+ q.And("task.plan_id = ?", *v)}if v := find.Status; v != nil {var statusStrings []string@@ -135,7 +135,7 @@ func (s *Store) ListTaskRuns(ctx context.Context, find *FindTaskRunMessage) ([]*&taskRun.Code,&taskRun.Result,&sheetSha256,- &taskRun.PipelineUID,+ &taskRun.PlanUID,&taskRun.Environment,&taskRun.ProjectID,); err != nil {@@ -203,16 +203,16 @@ func (s *Store) UpdateTaskRunStatus(ctx context.Context, patch *TaskRunStatusPatreturn nil, errors.Wrapf(err, "failed to update task run")}- // Get the pipeline ID for cache invalidation- q := qb.Q().Space("SELECT pipeline_id FROM task WHERE id = ?", taskRun.TaskUID)+ // Get the plan ID for cache invalidation+ q := qb.Q().Space("SELECT plan_id FROM task WHERE id = ?", taskRun.TaskUID)sql, args, err := q.ToSQL()if err != nil {return nil, errors.Wrapf(err, "failed to build sql")}- var pipelineID int- if err := tx.QueryRowContext(ctx, sql, args...).Scan(&pipelineID); err != nil {- return nil, errors.Wrapf(err, "failed to get pipeline ID for task %d", taskRun.TaskUID)+ var planID int64+ if err := tx.QueryRowContext(ctx, sql, args...).Scan(&planID); err != nil {+ return nil, errors.Wrapf(err, "failed to get plan ID for task %d", taskRun.TaskUID)}if err := tx.Commit(); err != nil {@@ -227,7 +227,7 @@ func (s *Store) UpdateTaskRunStartAt(ctx context.Context, taskRunID int) error {UPDATE task_runSET started_at = now(), updated_at = now()WHERE id = ?- RETURNING (SELECT pipeline_id FROM task WHERE task.id = task_run.task_id)+ RETURNING (SELECT plan_id FROM task WHERE task.id = task_run.task_id)`, taskRunID)query, args, err := q.ToSQL()@@ -235,8 +235,8 @@ func (s *Store) UpdateTaskRunStartAt(ctx context.Context, taskRunID int) error {return errors.Wrapf(err, "failed to build sql")}- var pipelineID int- if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(&pipelineID); err != nil {+ var planID int64+ if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(&planID); err != nil {return errors.Wrapf(err, "failed to update task run start at")}return nildiff --git a/frontend/src/types/proto-es/v1/plan_service_pb.d.ts b/frontend/src/types/proto-es/v1/plan_service_pb.d.tsindex d34c0330d7..fe4c59dd37 100644--- a/frontend/src/types/proto-es/v1/plan_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/plan_service_pb.d.ts@@ -340,6 +340,13 @@ export declare type Plan = Message<"bytebase.v1.Plan"> & {* @generated from field: map<string, int32> plan_check_run_status_count = 11;*/planCheckRunStatusCount: { [key: string]: number };++ /**+ * Whether the plan has started the rollout.+ *+ * @generated from field: bool has_rollout = 12;+ */+ hasRollout: boolean;};/**diff --git a/frontend/src/types/proto-es/v1/plan_service_pb.js b/frontend/src/types/proto-es/v1/plan_service_pb.jsindex c487656f9e..7a1ba9b20e 100644--- a/frontend/src/types/proto-es/v1/plan_service_pb.js+++ b/frontend/src/types/proto-es/v1/plan_service_pb.js@@ -17,7 +17,7 @@ import { file_v1_sql_service } from "./sql_service_pb";* Describes the file v1/plan_service.proto.*/export const file_v1_plan_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_sql_service]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_sql_service]);/*** Describes the message bytebase.v1.GetPlanRequest.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex d4a20bf1e8..cf9632bfc2 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -11761,6 +11761,10 @@ components:- WARNING- ERROR- RUNNING+ hasRollout:+ readOnly: true+ type: boolean+ description: Whether the plan has started the rollout.PlanCheckRun:type: objectproperties:diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex dcc1fffef1..8f5d805535 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -2784,6 +2784,7 @@ Plan spec update event (tracks sheet changes to plan specs)| Field | Type | Label | Description || ----- | ---- | ----- | ----------- || specs | [PlanConfig.Spec](#bytebase-store-PlanConfig-Spec) | repeated | |+| has_rollout | [bool](#bool) | | Whether the plan has started the rollout. |diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.htmlindex 885c8a7974..5758679bce 100644--- a/proto/gen/grpc-doc/store/index.html+++ b/proto/gen/grpc-doc/store/index.html@@ -8157,6 +8157,13 @@ Format: projects/{project}/plans/{plan}/specs/{spec} </p></td><td><p> </p></td></tr>+ <tr>+ <td>has_rollout</td>+ <td><a href="#bool">bool</a></td>+ <td></td>+ <td><p>Whether the plan has started the rollout. </p></td>+ </tr>+</tbody></table>diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 911db3e11c..5dbfd4282b 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -7539,6 +7539,7 @@ When paginating, all other parameters provided to `ListPlans` must match the cal| create_time | [google.protobuf.Timestamp](#google-protobuf-Timestamp) | | || update_time | [google.protobuf.Timestamp](#google-protobuf-Timestamp) | | || plan_check_run_status_count | [Plan.PlanCheckRunStatusCountEntry](#bytebase-v1-Plan-PlanCheckRunStatusCountEntry) | repeated | The status count of the latest plan check runs. Keys are: - SUCCESS - WARNING - ERROR - RUNNING |+| has_rollout | [bool](#bool) | | Whether the plan has started the rollout. |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex 53b93666ee..ee3e50e472 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -21302,6 +21302,13 @@ Keys are:- RUNNING </p></td></tr>+ <tr>+ <td>has_rollout</td>+ <td><a href="#bool">bool</a></td>+ <td></td>+ <td><p>Whether the plan has started the rollout. </p></td>+ </tr>+</tbody></table>diff --git a/proto/store/store/plan.proto b/proto/store/store/plan.protoindex 9d041b9e6d..748b50a733 100644--- a/proto/store/store/plan.proto+++ b/proto/store/store/plan.proto@@ -21,6 +21,9 @@ message PlanConfig {}}+ // Whether the plan has started the rollout.+ bool has_rollout = 2;+message CreateDatabaseConfig {// The resource name of the instance on which the database is created.// Format: instances/{instance}diff --git a/proto/v1/v1/plan_service.proto b/proto/v1/v1/plan_service.protoindex e9fa1cdefc..91df3f2d64 100644--- a/proto/v1/v1/plan_service.proto+++ b/proto/v1/v1/plan_service.proto@@ -284,6 +284,9 @@ message Plan {// - RUNNINGmap<string, int32> plan_check_run_status_count = 11 [(google.api.field_behavior) = OUTPUT_ONLY];+ // Whether the plan has started the rollout.+ bool has_rollout = 12 [(google.api.field_behavior) = OUTPUT_ONLY];+message CreateDatabaseConfig {// The resource name of the instance on which the database is created.// Format: instances/{instance}