Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: simplify rollout target logic and remove ValidateOnly (#18661)
Danny Xua147e2e0d67a
diff --git a/action/command/rollout.go b/action/command/rollout.goindex f296c4982a..ced62ba9cb 100644--- a/action/command/rollout.go+++ b/action/command/rollout.go@@ -134,47 +134,26 @@ func runRollout(w *world.World) func(command *cobra.Command, _ []string) error {}func runAndWaitForRollout(ctx context.Context, w *world.World, client *Client, planName string) error {- // preview rollout with all pending stages- rolloutPreview, err := client.CreateRollout(ctx, &v1pb.CreateRolloutRequest{+ // create rollout with all stages created+ rollout, err := client.CreateRollout(ctx, &v1pb.CreateRolloutRequest{Parent: w.Project,Rollout: &v1pb.Rollout{Plan: planName,},- Target: nil, // all stages- ValidateOnly: true,+ Target: nil, // all stages})if err != nil {return errors.Wrapf(err, "failed to create rollout")}+ w.OutputMap.Rollout = rollout.Name+ w.Rollout = rollout- pendingStages := []string{}- for _, stage := range rolloutPreview.Stages {- pendingStages = append(pendingStages, stage.Environment)- }- w.PendingStages = pendingStages-- // create rollout with no stages to obtain the rollout name- emptyTarget := ""- rolloutEmpty, err := client.CreateRollout(ctx, &v1pb.CreateRolloutRequest{- Parent: w.Project,- Rollout: &v1pb.Rollout{- Plan: planName,- },- Target: &emptyTarget, // zero stage- ValidateOnly: false,- })- if err != nil {- return errors.Wrapf(err, "failed to preview rollout")- }- w.OutputMap.Rollout = rolloutEmpty.Name- w.Rollout = rolloutEmpty+ w.Logger.Info("rollout created", "url", fmt.Sprintf("%s/%s", client.url, rollout.Name))- w.Logger.Info("rollout created", "url", fmt.Sprintf("%s/%s", client.url, rolloutEmpty.Name))-- return waitForRollout(ctx, w, client, pendingStages, rolloutEmpty.Name)+ return waitForRollout(ctx, w, client, rollout.Name)}-func waitForRollout(ctx context.Context, w *world.World, client *Client, pendingStages []string, rolloutName string) error {+func waitForRollout(ctx context.Context, w *world.World, client *Client, rolloutName string) error {if w.TargetStage == "" {w.Logger.Info("target stage is not specified, exiting...")return nil@@ -185,32 +164,7 @@ func waitForRollout(ctx context.Context, w *world.World, client *Client, pendingreturn}w.Logger.Info("context cancelled, canceling the rollout")- // cancel rollout- if err := func() error {- taskRuns, err := client.ListAllTaskRuns(context.Background(), rolloutName)- if err != nil {- return errors.Wrapf(err, "failed to list task runs")- }- taskRunsToCancelByStage := map[string][]string{}- for _, taskRun := range taskRuns.TaskRuns {- if taskRun.Status == v1pb.TaskRun_RUNNING || taskRun.Status == v1pb.TaskRun_PENDING {- stage := strings.Split(taskRun.Name, "/tasks")[0]- taskRunsToCancelByStage[stage] = append(taskRunsToCancelByStage[stage], taskRun.Name)- }- }- var errs error- for stage, taskRuns := range taskRunsToCancelByStage {- _, err := client.BatchCancelTaskRuns(context.Background(), &v1pb.BatchCancelTaskRunsRequest{- Parent: stage + "/tasks/-",- TaskRuns: taskRuns,- })- if err != nil {- err = errors.Wrapf(err, "failed to cancel task runs for stage %v", stage)- errs = multierr.Append(errs, err)- }- }- return errs- }(); err != nil {+ if err := cancelRollout(context.Background(), client, rolloutName); err != nil {w.Logger.Error("failed to cancel rollout", "error", err)}}()@@ -228,9 +182,8 @@ func waitForRollout(ctx context.Context, w *world.World, client *Client, pendingreturn}}- }),- "pendingStages", pendingStages)- if len(pendingStages) == 0 && len(rollout.Stages) == 0 {+ }))+ if len(rollout.Stages) == 0 {w.Logger.Info("no stages in the rollout. exiting...")return nil}@@ -242,131 +195,116 @@ func waitForRollout(ctx context.Context, w *world.World, client *Client, pendingbreak}}- for _, stage := range pendingStages {- if stage == w.TargetStage {- targetStageFound = true- break- }- }if !targetStageFound {w.Logger.Info("the target stage is not found in the rollout. exiting...", "targetStage", w.TargetStage)return nil}- // To make it more robust,- // - remove pending stage that already in the rollout stage and call CreateRollout with latest rollout stage once so no new tasks will be missed- if len(rollout.Stages) > 0 {- latestStage := rollout.Stages[len(rollout.Stages)-1].Environment- index := slices.Index(pendingStages, latestStage)- if index != -1 {- w.Logger.Info("removing pending stage that already in the rollout stage", "latestStage", latestStage)- pendingStages = pendingStages[index+1:]- _, err := client.CreateRollout(ctx, &v1pb.CreateRolloutRequest{- Parent: w.Project,- Rollout: &v1pb.Rollout{- Plan: rollout.GetPlan(),- },- Target: &latestStage,- })+ for i := range rollout.Stages {+ // Polling loop for the current stage+ for {+ if ctx.Err() != nil {+ return errors.Wrapf(ctx.Err(), "context cancelled")+ }+ // get rollout to refresh status+ rollout, err := client.GetRollout(ctx, rolloutName)if err != nil {- return errors.Wrapf(err, "failed to create rollout")+ return errors.Wrapf(err, "failed to get rollout")}- }- }+ w.Rollout = rollout+ if i >= len(rollout.Stages) {+ return errors.Errorf("rollout stage index out of bounds")+ }+ stage := rollout.Stages[i]- i := 0- for {- if ctx.Err() != nil {- return errors.Wrapf(ctx.Err(), "context cancelled")- }- // get rollout- rollout, err := client.GetRollout(ctx, rolloutName)- if err != nil {- return errors.Wrapf(err, "failed to get rollout")- }- if i >= len(rollout.GetStages()) {- if len(pendingStages) == 0 {- return errors.Errorf("rollout has no more stages")+ // check stage tasks+ done := true+ var foundFailed, foundCanceled bool+ var notStartedTasks []string+ for _, task := range stage.GetTasks() {+ switch task.Status {+ case v1pb.Task_STATUS_UNSPECIFIED:+ done = false+ case v1pb.Task_NOT_STARTED:+ notStartedTasks = append(notStartedTasks, task.Name)+ done = false+ case v1pb.Task_PENDING:+ done = false+ case v1pb.Task_RUNNING:+ done = false+ case v1pb.Task_FAILED:+ foundFailed = true+ done = false+ case v1pb.Task_CANCELED:+ foundCanceled = true+ done = false+ case v1pb.Task_DONE:+ case v1pb.Task_SKIPPED:+ default:+ // Treat unknown task status as not done to be safe+ done = false+ }}- // create a new target- target := pendingStages[0]- pendingStages = pendingStages[1:]- rolloutAdvanced, err := client.CreateRollout(ctx, &v1pb.CreateRolloutRequest{- Parent: w.Project,- Rollout: &v1pb.Rollout{- Plan: rollout.GetPlan(),- },- Target: &target,- })- if err != nil {- return errors.Wrapf(err, "failed to create rollout")+ if foundFailed {+ return errors.Errorf("found failed tasks. view on Bytebase")}- rollout = rolloutAdvanced- }- w.Rollout = rollout- if i >= len(rollout.GetStages()) {- return errors.Errorf("rollout has no more stages")- }- // check stage tasks- stage := rollout.Stages[i]- done := true- var foundFailed, foundCanceled bool- var notStartedTasks []string- for _, task := range stage.GetTasks() {- switch task.Status {- case v1pb.Task_STATUS_UNSPECIFIED:- done = false- case v1pb.Task_NOT_STARTED:- notStartedTasks = append(notStartedTasks, task.Name)- done = false- case v1pb.Task_PENDING:- done = false- case v1pb.Task_RUNNING:- done = false- case v1pb.Task_FAILED:- foundFailed = true- done = false- case v1pb.Task_CANCELED:- foundCanceled = true- done = false- case v1pb.Task_DONE:- case v1pb.Task_SKIPPED:- default:- // Treat unknown task status as not done to be safe- done = false+ if foundCanceled {+ return errors.Errorf("found canceled tasks. view on Bytebase")}- }- if foundFailed {- return errors.Errorf("found failed tasks. view on Bytebase")- }- if foundCanceled {- return errors.Errorf("found canceled tasks. view on Bytebase")- }- if done {- w.Logger.Info("stage completed", "stage", stage.Environment)- if w.TargetStage == stage.Environment {++ if done {+ w.Logger.Info("stage completed", "stage", stage.Environment)+ if w.TargetStage == stage.Environment {+ return nil+ }+ // Break inner loop to proceed to next stagebreak}- i++- continue- }- // run stage tasks- if len(notStartedTasks) > 0 {- w.Logger.Info("running stage tasks", "stage", stage.Environment, "taskCount", len(notStartedTasks))- if _, err := client.BatchRunTasks(ctx, &v1pb.BatchRunTasksRequest{- Parent: stage.Name,- Tasks: notStartedTasks,- }); err != nil {- return errors.Wrapf(err, "failed to batch create tasks")+ // run stage tasks+ if len(notStartedTasks) > 0 {+ w.Logger.Info("running stage tasks", "stage", stage.Environment, "taskCount", len(notStartedTasks))+ if _, err := client.BatchRunTasks(ctx, &v1pb.BatchRunTasksRequest{+ Parent: stage.Name,+ Tasks: notStartedTasks,+ }); err != nil {+ return errors.Wrapf(err, "failed to batch create tasks")+ }}+ time.Sleep(5 * time.Second)}- time.Sleep(5 * time.Second)}+return nil}+func cancelRollout(ctx context.Context, client *Client, rolloutName string) error {+ taskRuns, err := client.ListAllTaskRuns(ctx, rolloutName)+ if err != nil {+ return errors.Wrapf(err, "failed to list task runs")+ }+ taskRunsToCancelByStage := map[string][]string{}+ for _, taskRun := range taskRuns.TaskRuns {+ if taskRun.Status == v1pb.TaskRun_RUNNING || taskRun.Status == v1pb.TaskRun_PENDING {+ stage := strings.Split(taskRun.Name, "/tasks")[0]+ taskRunsToCancelByStage[stage] = append(taskRunsToCancelByStage[stage], taskRun.Name)+ }+ }+ var errs error+ for stage, taskRuns := range taskRunsToCancelByStage {+ _, err := client.BatchCancelTaskRuns(ctx, &v1pb.BatchCancelTaskRunsRequest{+ Parent: stage + "/tasks/-",+ TaskRuns: taskRuns,+ })+ if err != nil {+ err = errors.Wrapf(err, "failed to cancel task runs for stage %v", stage)+ errs = multierr.Append(errs, err)+ }+ }+ return errs+}+func getVCSSource(w *world.World) *v1pb.Release_VCSSource {switch w.Platform {case world.GitHub:diff --git a/action/github/summary.go b/action/github/summary.goindex 5510dbc748..86635cbaf6 100644--- a/action/github/summary.go+++ b/action/github/summary.go@@ -27,42 +27,19 @@ func BuildSummaryMarkdown(w *world.World) string {func buildOutputStagesMarkdown(w *world.World, sb *strings.Builder) {if w.IsRollout && w.Rollout != nil {- pendingStages := w.PendingStagesrollout := w.Rollout- // build a table of stage and status in GitHub flavored markdown.- // The stages come from the aggregated result of pendingStages and rollout.Stages.- // pendingStages are the stages to be rolled out at the beginning of the execution,- // they may or may not have been executed (depending on the targetStage input).- // rollout.Stages are the stages that have been executed, and the stage status is- // an aggregated status from stage tasks.-- // Combine stages from rollout.Stages and pendingStages, deduplicating- allStages := []string{}- seenStages := make(map[string]bool)-- // First add all stages from rollout.Stages- for _, stage := range rollout.Stages {- if !seenStages[stage.Environment] {- allStages = append(allStages, stage.Environment)- seenStages[stage.Environment] = true- }- }-- // Then append pendingStages that aren't already in the list- for _, stage := range pendingStages {- if !seenStages[stage] {- allStages = append(allStages, stage)- seenStages[stage] = true- }- }- // Check if there are any stages to display- if len(allStages) == 0 {+ if len(rollout.Stages) == 0 {sb.WriteString("\n### Rollout Stages\n\n")sb.WriteString("_No stages to display. The rollout may not have any stages._\n\n")return}+ allStages := []string{}+ for _, stage := range rollout.Stages {+ allStages = append(allStages, stage.Environment)+ }+// Create a map of stage environment to Stage object for quick lookupstageMap := make(map[string]*v1pb.Stage)for _, stage := range rollout.Stages {diff --git a/action/world/world.go b/action/world/world.goindex 9f34dd697f..1639a61a55 100644--- a/action/world/world.go+++ b/action/world/world.go@@ -51,8 +51,7 @@ type World struct {Rollout string `json:"rollout,omitempty"`CheckResults *v1pb.CheckReleaseResponse `json:"checkResults,omitempty"`}- PendingStages []string- Rollout *v1pb.Rollout+ Rollout *v1pb.Rollout}func NewWorld() *World {diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex 6eb229701c..e83137cdd5 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -8210,17 +8210,11 @@ components:type: stringtitle: targetdescription: |-- Create the rollout and the stages up to the target stage.+ Create the rollout only for the specified target.Format: environments/{environment}If unspecified, all stages are created.If set to "", no stages are created.nullable: true- validateOnly:- type: boolean- title: validate_only- description: |-- If set, validate the request and preview the rollout, but- do not actually create it.title: CreateRolloutRequestadditionalProperties: falsebytebase.v1.CreateSheetRequest:diff --git a/backend/api/v1/common_test.go b/backend/api/v1/common_test.goindex 4c0fa55ce8..30a7c01146 100644--- a/backend/api/v1/common_test.go+++ b/backend/api/v1/common_test.go@@ -198,15 +198,6 @@ func TestIsValidateOnlyRequest(t *testing.T) {},want: true,},- {- name: "CreateRolloutRequest with validate_only=false",- request: &v1pb.CreateRolloutRequest{- Parent: "projects/test",- Rollout: &v1pb.Rollout{},- ValidateOnly: false,- },- want: false,- },}for _, test := range tests {diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.goindex 789dd241a6..57c66d46fa 100644--- a/backend/api/v1/rollout_service.go+++ b/backend/api/v1/rollout_service.go@@ -193,10 +193,6 @@ func buildRolloutFindWithFilter(planFind *store.FindPlanMessage, filter string)// CreateRollout creates a rollout from plan.func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request[v1pb.CreateRolloutRequest]) (*connect.Response[v1pb.Rollout], error) {request := req.Msg- user, ok := GetUserFromContext(ctx)- if !ok {- return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))- }projectID, err := common.GetProjectID(request.Parent)if err != nil {return nil, connect.NewError(connect.CodeInvalidArgument, err)@@ -228,69 +224,13 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Requestreturn nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to get pipeline create, error: %v", err))}if isChangeDatabasePlan(plan.Config.GetSpecs()) {- tasks, err = getPipelineCreateToTargetStage(ctx, s.store, tasks, request.Target)+ tasks, err = filterTasksByStage(tasks, request.Target)if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to filter stages with stageId, error: %v", err))+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to filter tasks with stage id, error: %v", err))}}- if request.ValidateOnly {- // Filter out tasks that already exist (same logic as CreateTasks)- 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 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- }- if err := CreateRolloutAndPendingTasks(ctx, s.store, s.webhookManager, plan, nil, project); err != nil {+ if err := CreateRolloutAndPendingTasks(ctx, s.store, s.webhookManager, plan, nil, project, tasks); err != nil {return nil, connect.NewError(connect.CodeInternal, err)}@@ -365,10 +305,14 @@ func CreateRolloutAndPendingTasks(plan *store.PlanMessage,issue *store.IssueMessage,project *store.ProjectMessage,+ tasks []*store.TaskMessage,) error {- tasks, err := GetPipelineCreate(ctx, s, plan.Config.GetSpecs(), project.ResourceID)- if err != nil {- return errors.Wrap(err, "failed to get pipeline create for rollout creation")+ var err error+ if tasks == nil {+ tasks, err = GetPipelineCreate(ctx, s, plan.Config.GetSpecs(), project.ResourceID)+ if err != nil {+ return errors.Wrap(err, "failed to get pipeline create for rollout creation")+ }}// Create rollout tasks@@ -1106,7 +1050,7 @@ func GetPipelineCreate(ctx context.Context, s *store.Store, specs []*storepb.Pla}// filter pipelineCreate.Tasks using targetEnvironmentID.-func getPipelineCreateToTargetStage(ctx context.Context, s *store.Store, tasks []*store.TaskMessage, targetEnvironment *string) ([]*store.TaskMessage, error) {+func filterTasksByStage(tasks []*store.TaskMessage, targetEnvironment *string) ([]*store.TaskMessage, error) {if targetEnvironment == nil {return tasks, nil}@@ -1118,33 +1062,10 @@ func getPipelineCreateToTargetStage(ctx context.Context, s *store.Store, tasks [return nil, errors.Wrapf(err, "failed to get environment id from %q", *targetEnvironment)}- // Get live environment order- environments, err := s.GetEnvironment(ctx)- if err != nil {- return nil, errors.Wrap(err, "failed to get environments")- }- var environmentOrder []string- for _, env := range environments.GetEnvironments() {- environmentOrder = append(environmentOrder, env.Id)- }-- // Build a set of allowed environments up to and including the target- allowedEnvironments := make(map[string]bool)- for _, environmentID := range environmentOrder {- allowedEnvironments[environmentID] = true- if environmentID == targetEnvironmentID {- break- }- }-- if !allowedEnvironments[targetEnvironmentID] {- return nil, errors.Errorf("environment %q not found", targetEnvironmentID)- }-// Filter tasks to only include those in allowed environmentsfilteredTasks := []*store.TaskMessage{}for _, task := range tasks {- if allowedEnvironments[task.Environment] {+ if task.Environment == targetEnvironmentID {filteredTasks = append(filteredTasks, task)}}diff --git a/backend/generated-go/v1/rollout_service.pb.go b/backend/generated-go/v1/rollout_service.pb.goindex 78d2a925c6..1f334997b4 100644--- a/backend/generated-go/v1/rollout_service.pb.go+++ b/backend/generated-go/v1/rollout_service.pb.go@@ -962,14 +962,11 @@ type CreateRolloutRequest struct {Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`// The rollout to create.Rollout *Rollout `protobuf:"bytes,2,opt,name=rollout,proto3" json:"rollout,omitempty"`- // Create the rollout and the stages up to the target stage.+ // Create the rollout only for the specified target.// Format: environments/{environment}// If unspecified, all stages are created.// If set to "", no stages are created.- Target *string `protobuf:"bytes,3,opt,name=target,proto3,oneof" json:"target,omitempty"`- // If set, validate the request and preview the rollout, but- // do not actually create it.- ValidateOnly bool `protobuf:"varint,4,opt,name=validate_only,json=validateOnly,proto3" json:"validate_only,omitempty"`+ Target *string `protobuf:"bytes,3,opt,name=target,proto3,oneof" json:"target,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -1025,13 +1022,6 @@ func (x *CreateRolloutRequest) GetTarget() string {return ""}-func (x *CreateRolloutRequest) GetValidateOnly() bool {- if x != nil {- return x.ValidateOnly- }- return false-}-type ListTaskRunsRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The parent, which owns this collection of plans.@@ -3612,13 +3602,12 @@ const file_v1_rollout_service_proto_rawDesc = "" +"\x06filter\x18\x04 \x01(\tR\x06filter\"p\n" +"\x14ListRolloutsResponse\x120\n" +"\brollouts\x18\x01 \x03(\v2\x14.bytebase.v1.RolloutR\brollouts\x12&\n" +- "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xce\x01\n" ++ "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xa9\x01\n" +"\x14CreateRolloutRequest\x124\n" +"\x06parent\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +"\x14bytebase.com/ProjectR\x06parent\x123\n" +"\arollout\x18\x02 \x01(\v2\x14.bytebase.v1.RolloutB\x03\xe0A\x02R\arollout\x12\x1b\n" +- "\x06target\x18\x03 \x01(\tH\x00R\x06target\x88\x01\x01\x12#\n" +- "\rvalidate_only\x18\x04 \x01(\bR\fvalidateOnlyB\t\n" ++ "\x06target\x18\x03 \x01(\tH\x00R\x06target\x88\x01\x01B\t\n" +"\a_target\"H\n" +"\x13ListTaskRunsRequest\x121\n" +"\x06parent\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +diff --git a/backend/generated-go/v1/rollout_service_equal.pb.go b/backend/generated-go/v1/rollout_service_equal.pb.goindex d54c433626..5d4cfc308f 100644--- a/backend/generated-go/v1/rollout_service_equal.pb.go+++ b/backend/generated-go/v1/rollout_service_equal.pb.go@@ -174,9 +174,6 @@ func (x *CreateRolloutRequest) Equal(y *CreateRolloutRequest) bool {if p, q := x.Target, y.Target; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {return false}- if x.ValidateOnly != y.ValidateOnly {- return false- }return true}diff --git a/backend/runner/taskrun/rollout_creator.go b/backend/runner/taskrun/rollout_creator.goindex 95dd8e87aa..fe639332b3 100644--- a/backend/runner/taskrun/rollout_creator.go+++ b/backend/runner/taskrun/rollout_creator.go@@ -141,7 +141,7 @@ func (rc *RolloutCreator) tryCreateRollout(ctx context.Context, planID int64) {slog.Info("auto-creating rollout", slog.Int("plan_id", int(planID)))// Create rollout and pending tasks- if err := apiv1.CreateRolloutAndPendingTasks(ctx, rc.store, rc.webhookManager, plan, issue, project); err != nil {+ if err := apiv1.CreateRolloutAndPendingTasks(ctx, rc.store, rc.webhookManager, plan, issue, project, nil); err != nil {slog.Error("failed to create rollout and pending tasks",slog.Int("plan_id", int(planID)),log.BBError(err))diff --git a/backend/tests/gitops_test.go b/backend/tests/gitops_test.goindex 551ad94b4d..04fd0e760b 100644--- a/backend/tests/gitops_test.go+++ b/backend/tests/gitops_test.go@@ -318,19 +318,6 @@ func TestGitOpsRollout(t *testing.T) {a.NoError(err)a.NotNil(rolloutResp2)a.Equal(rollout.Name, rolloutResp2.Msg.Name)-- // Call CreateRollout with ValidateOnly on the finished plan.- // the rollout should contain zero stages.- rolloutResp3, err := ctl.rolloutServiceClient.CreateRollout(ctx, connect.NewRequest(&v1pb.CreateRolloutRequest{- Parent: project.Name,- Rollout: &v1pb.Rollout{- Plan: plan.Name,- },- ValidateOnly: true,- }))- a.NoError(err)- a.NotNil(rolloutResp3)- a.Empty(rolloutResp3.Msg.Stages)}// TestGitOpsRolloutMultiTarget tests a more complex GitOps scenario:@@ -594,19 +581,6 @@ func TestGitOpsRolloutMultiTarget(t *testing.T) {a.NoError(err)a.NotNil(rolloutResp2)a.Equal(rollout.Name, rolloutResp2.Msg.Name)-- // Call CreateRollout with ValidateOnly on the finished plan.- // the rollout should contain zero stages.- rolloutResp3, err := ctl.rolloutServiceClient.CreateRollout(ctx, connect.NewRequest(&v1pb.CreateRolloutRequest{- Parent: project.Name,- Rollout: &v1pb.Rollout{- Plan: plan.Name,- },- ValidateOnly: true,- }))- a.NoError(err)- a.NotNil(rolloutResp3)- a.Empty(rolloutResp3.Msg.Stages)}// TestGitOpsCheckAppliedButChanged tests that CheckRelease detects files that have been applied but with different content.diff --git a/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts b/frontend/src/types/proto-es/v1/rollout_service_pb.d.tsindex 806f7710b0..a29d592bf0 100644--- a/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/rollout_service_pb.d.ts@@ -268,7 +268,7 @@ export declare type CreateRolloutRequest = Message<"bytebase.v1.CreateRolloutReqrollout?: Rollout;/**- * Create the rollout and the stages up to the target stage.+ * Create the rollout only for the specified target.* Format: environments/{environment}* If unspecified, all stages are created.* If set to "", no stages are created.@@ -276,14 +276,6 @@ export declare type CreateRolloutRequest = Message<"bytebase.v1.CreateRolloutReq* @generated from field: optional string target = 3;*/target?: string;-- /**- * If set, validate the request and preview the rollout, but- * do not actually create it.- *- * @generated from field: bool validate_only = 4;- */- validateOnly: boolean;};/**diff --git a/frontend/src/types/proto-es/v1/rollout_service_pb.js b/frontend/src/types/proto-es/v1/rollout_service_pb.jsindex 0294fdcd48..e8110d920d 100644--- a/frontend/src/types/proto-es/v1/rollout_service_pb.js+++ b/frontend/src/types/proto-es/v1/rollout_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";* Describes the file v1/rollout_service.proto.*/export const file_v1_rollout_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_timestamp, file_v1_annotation, file_v1_common]);+ 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_timestamp, file_v1_annotation, file_v1_common]);/*** Describes the message bytebase.v1.BatchRunTasksRequest.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex 931c9457e7..b948c27feb 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -5362,19 +5362,12 @@ paths:- name: targetin: querydescription: |-- Create the rollout and the stages up to the target stage.+ Create the rollout only for the specified target.Format: environments/{environment}If unspecified, all stages are created.If set to "", no stages are created.schema:type: string- - name: validateOnly- in: query- description: |-- If set, validate the request and preview the rollout, but- do not actually create it.- schema:- type: booleanrequestBody:content:application/json:diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 01e8dbab5d..81fe7f88c0 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -9442,8 +9442,7 @@ RoleService manages workspace roles and permissions.| ----- | ---- | ----- | ----------- || parent | [string](#string) | | The parent project where this rollout will be created. Format: projects/{project} || rollout | [Rollout](#bytebase-v1-Rollout) | | The rollout to create. |-| target | [string](#string) | optional | Create the rollout and the stages up to the target stage. Format: environments/{environment} If unspecified, all stages are created. If set to "", no stages are created. |-| validate_only | [bool](#bool) | | If set, validate the request and preview the rollout, but do not actually create it. |+| target | [string](#string) | optional | Create the rollout only for the specified target. Format: environments/{environment} If unspecified, all stages are created. If set to "", no stages are created. |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex 5d7169d2db..c777c54bca 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -26621,20 +26621,12 @@ Format: projects/{project} </p></td><td>target</td><td><a href="#string">string</a></td><td>optional</td>- <td><p>Create the rollout and the stages up to the target stage.+ <td><p>Create the rollout only for the specified target.Format: environments/{environment}If unspecified, all stages are created.If set to "", no stages are created. </p></td></tr>- <tr>- <td>validate_only</td>- <td><a href="#bool">bool</a></td>- <td></td>- <td><p>If set, validate the request and preview the rollout, but-do not actually create it. </p></td>- </tr>-</tbody></table>diff --git a/proto/v1/v1/rollout_service.proto b/proto/v1/v1/rollout_service.protoindex b4b10f183e..1965af60fc 100644--- a/proto/v1/v1/rollout_service.proto+++ b/proto/v1/v1/rollout_service.proto@@ -246,15 +246,11 @@ message CreateRolloutRequest {// The rollout to create.Rollout rollout = 2 [(google.api.field_behavior) = REQUIRED];- // Create the rollout and the stages up to the target stage.+ // Create the rollout only for the specified target.// Format: environments/{environment}// If unspecified, all stages are created.// If set to "", no stages are created.optional string target = 3;-- // If set, validate the request and preview the rollout, but- // do not actually create it.- bool validate_only = 4;}message ListTaskRunsRequest {