Skip to content

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

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.yaml
index 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: Plan
additionalProperties: false
bytebase.v1.Plan.ChangeDatabaseConfig:
diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.go
index 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 *s
return 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 *sto
ProjectID: 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, projec
return 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 rollout
if 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 *connect
issues = 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.go
index 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.IssueMes
if 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 *store
if 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.go
index 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[v
planMessage := &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[v
planUpdate.Deleted = &deleted
case "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.go
index 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.go
index 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[v1
return 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, pipelin
return connect.NewError(connect.CodeInvalidArgument, err)
}
- pipelineFind.FilterQ = filterQ
+ planFind.FilterQ = filterQ
return 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[v1
return 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.Request
return 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.Request
return 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.Request
Type: 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.Reques
return 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.Reques
Comment: 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.R
return 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.R
Actor: 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 *s
func (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.go
index bc862a599c..d6be0643e8 100644
--- a/backend/api/v1/rollout_service_converter.go
+++ b/backend/api/v1/rollout_service_converter.go
@@ -3,6 +3,7 @@ package v1
import (
"context"
"fmt"
+ "slices"
"connectrpc.com/connect"
"github.com/pkg/errors"
@@ -38,7 +39,7 @@ func convertToTaskRuns(ctx context.Context, s *store.Store, stateCfg *state.Stat
func 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.Projec
rolloutV1.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.Projec
if 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.Projec
stageID := 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.Ta
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()),
@@ -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.go
index 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.go
index 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.go
index 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.UnknownFields
sizeCache 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.FileDescriptor
const 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.go
index 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.go
index 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
// - RUNNING
PlanCheckRunStatusCount 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.go
index 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.sql
new file mode 100644
index 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.sql
index 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 plan
CREATE 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
------------------------
-- issue
CREATE TABLE issue (
id serial PRIMARY KEY,
diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.go
index 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.go
index 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.go
index 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) er
return 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) er
return 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) er
Type: 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.go
index 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.go
index 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 conte
return 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 conte
environmentID = &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.go
index 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, nil
diff --git a/backend/runner/taskrun/executor.go b/backend/runner/taskrun/executor.go
index 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.go
index 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.T
return 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.go
index 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.TaskRunMe
if 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.TaskRunMe
func (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, ta
Type: 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.go
index 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 int64
environment 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.Environment
var nextEnvironment string
- var pipelineDone bool
+ var planDone bool
for 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.go
index eb020bf489..69cd93f702 100644
--- a/backend/store/issue.go
+++ b/backend/store/issue.go
@@ -40,7 +40,6 @@ type IssueMessage struct {
Type storepb.Issue_Type
Description string
Payload *storepb.Issue
- PipelineUID *int // Computed from plan.pipeline_id
PlanUID *int64
TaskStatusCount map[string]int32
@@ -66,7 +65,7 @@ type FindIssueMessage struct {
ProjectID *string
ProjectIDs *[]string
PlanUID *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) ([]*Issu
if 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) ([]*Issu
where.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) ([]*Issu
for _, 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) ([]*Issu
issue.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 t
GROUP 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.go
index 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 duplicates
existingTasks, 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 = planUID
taskCreateList = 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 task
JOIN 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 plan
LEFT JOIN issue ON issue.plan_id = plan.id
WHERE TRUE
`)
@@ -252,13 +157,13 @@ func (s *Store) ListPipelines(ctx context.Context, find *PipelineFind) ([]*Pipel
q.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.Quer
if creatorEmail == "" {
return nil, errors.New("invalid empty creator identifier")
}
- return qb.Q().Space("pipeline.creator = ?", creatorEmail), nil
+ return qb.Q().Space("plan.creator = ?", creatorEmail), nil
case "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()), nil
default:
return nil, errors.Errorf("unsupported variable %q", variable)
}
@@ -387,7 +292,7 @@ func (s *Store) GetListRolloutFilter(_ context.Context, filter string) (*qb.Quer
storeTaskType := 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), nil
default:
return nil, errors.Errorf("unsupported variable %q", variable)
}
@@ -405,7 +310,7 @@ func (s *Store) GetListRolloutFilter(_ context.Context, filter string) (*qb.Quer
return 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.go
index 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 ts
diff --git a/backend/store/plan.go b/backend/store/plan.go
index 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 *int
Name string
Description string
Config *storepb.PlanConfig
@@ -40,7 +39,8 @@ type FindPlanMessage struct {
UID *int64
ProjectID *string
ProjectIDs *[]string
- PipelineID *int
+
+ HasRollout *bool
Limit *int
Offset *int
@@ -54,6 +54,7 @@ type UpdatePlanMessage struct {
Name *string
Description *string
Specs *[]*storepb.PlanConfig_Spec
+ HasRollout *bool
Deleted *bool
}
@@ -68,14 +69,13 @@ func (s *Store) CreatePlan(ctx context.Context, plan *PlanMessage, creator strin
INSERT 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) ([]*PlanMe
plan.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) ([]*PlanMe
q.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) error
payloadSets = 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"), nil
case "has_issue":
hasIssue, ok := value.(bool)
if !ok {
diff --git a/backend/store/plan_filter_test.go b/backend/store/plan_filter_test.go
index 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.go
index 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 project
q = 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 project
q = 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 project
q = 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 project
q = 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.go
index 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 int64
InstanceID string
Environment 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 *int64
Environment *string
InstanceID *string
DatabaseName *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_id
LEFT JOIN issue ON issue.plan_id = plan.id
LEFT 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 NULL
AND (task.payload->>'skipped')::BOOLEAN IS NOT TRUE
AND 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 []int64
instances []string
databases []*string
environments []string
@@ -181,7 +180,7 @@ func (*Store) createTasks(ctx context.Context, txn *sql.Tx, creates ...*TaskMess
if 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 ...*TaskMess
q := 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 ...*TaskMess
var typeString string
if 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(`
SELECT
task.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 string
if 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 string
if 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 stri
func (s *Store) ListTasksToAutoRollout(ctx context.Context, environments []string) ([]int, error) {
q := qb.Q().Space(`
SELECT
- task.pipeline_id,
+ task.plan_id,
task.environment,
task.id
FROM 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_id
LEFT JOIN issue ON issue.plan_id = plan.id
WHERE 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 FALSE
AND 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 int64
var environment string
var 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.go
index 7c26237df7..e608d1c578 100644
--- a/backend/store/task_run.go
+++ b/backend/store/task_run.go
@@ -16,7 +16,7 @@ import (
type TaskRunMessage struct {
TaskUID int
Environment string // Refer to the task's environment.
- PipelineUID int
+ PlanUID int64
Status storepb.TaskRun_Status
Code common.Code
Result string
@@ -39,7 +39,7 @@ type FindTaskRunMessage struct {
UIDs *[]int
TaskUID *int
Environment *string
- PipelineUID *int
+ PlanUID *int64
Status *[]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_id
FROM task_run
LEFT 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.project
WHERE 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 *TaskRunStatusPat
return 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_run
SET 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 nil
diff --git a/frontend/src/types/proto-es/v1/plan_service_pb.d.ts b/frontend/src/types/proto-es/v1/plan_service_pb.d.ts
index 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.js
index 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.yaml
index 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: object
properties:
diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.md
index 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.html
index 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.md
index 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.html
index 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.proto
index 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.proto
index e9fa1cdefc..91df3f2d64 100644
--- a/proto/v1/v1/plan_service.proto
+++ b/proto/v1/v1/plan_service.proto
@@ -284,6 +284,9 @@ message Plan {
// - RUNNING
map<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}