From 2affca7eded7ca19b2328bae024309de0356ebec Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 19 Nov 2026 19:03:48 +0000 Subject: [PATCH 1/3] keyspace create: add --max-rollout flag --- internal/cmd/keyspace/create.go | 9 ++++++++ internal/cmd/keyspace/create_test.go | 29 +++++++++++++++++++++++++- internal/planetscale/keyspaces.go | 1 + internal/planetscale/keyspaces_test.go | 3 +++ 4 files changed, 41 insertions(+), 1 deletion(-) diff --git a/internal/cmd/keyspace/create.go b/internal/cmd/keyspace/create.go index 255eddeff..33ea49e49 100644 --- a/internal/cmd/keyspace/create.go +++ b/internal/cmd/keyspace/create.go @@ -20,6 +20,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { shards int clusterSize string additionalReplicas int + maxRollout int wait bool } @@ -31,6 +32,13 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { ctx := cmd.Context() database, branch, keyspace := args[0], args[1], args[2] + if cmd.Flags().Changed("max-rollout") { + if flags.maxRollout < 1 || flags.maxRollout > 32 { + return errors.New("--max-rollout must be between 1 and 32") + } + createReq.MaxRollout = &flags.maxRollout + } + createReq.Organization = ch.Config.Organization createReq.Database = database createReq.Branch = branch @@ -86,6 +94,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { cmd.Flags().IntVar(&flags.shards, "shards", 1, "Number of shards in the keyspace") cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "", "cluster size for the keyspace. Use `pscale size cluster list` to get a list of valid sizes.") cmd.Flags().IntVar(&flags.additionalReplicas, "additional-replicas", 0, "number of additional replicas per shard. By default, each production cluster includes 2 replicas.") + cmd.Flags().IntVar(&flags.maxRollout, "max-rollout", 0, "Maximum number of shards to roll out changes to concurrently (1-32).") cmd.Flags().BoolVar(&flags.wait, "wait", false, "Wait until the keyspace is ready") cmd.MarkFlagRequired("cluster-size") diff --git a/internal/cmd/keyspace/create_test.go b/internal/cmd/keyspace/create_test.go index 494fb0296..ce182db4b 100644 --- a/internal/cmd/keyspace/create_test.go +++ b/internal/cmd/keyspace/create_test.go @@ -44,6 +44,8 @@ func TestKeyspace_CreateCmd(t *testing.T) { c.Assert(req.ClusterSize, qt.Equals, "PS-20") c.Assert(req.ExtraReplicas, qt.Equals, 1) c.Assert(req.Shards, qt.Equals, 2) + c.Assert(req.MaxRollout, qt.Not(qt.IsNil)) + c.Assert(*req.MaxRollout, qt.Equals, 8) return ks, nil }, @@ -62,7 +64,7 @@ func TestKeyspace_CreateCmd(t *testing.T) { } cmd := CreateCmd(ch) - cmd.SetArgs([]string{db, branch, keyspace, "--cluster-size", "PS-20", "--shards", "2", "--additional-replicas", "1"}) + cmd.SetArgs([]string{db, branch, keyspace, "--cluster-size", "PS-20", "--shards", "2", "--additional-replicas", "1", "--max-rollout", "8"}) err := cmd.Execute() c.Assert(err, qt.IsNil) c.Assert(svc.CreateFnInvoked, qt.IsTrue) @@ -149,6 +151,7 @@ func TestKeyspace_CreateCmdOnlyClusterSize(t *testing.T) { c.Assert(req.ClusterSize, qt.Equals, "PS-10") c.Assert(req.ExtraReplicas, qt.Equals, 0) c.Assert(req.Shards, qt.Equals, 1) + c.Assert(req.MaxRollout, qt.IsNil) return ks, nil }, @@ -173,3 +176,27 @@ func TestKeyspace_CreateCmdOnlyClusterSize(t *testing.T) { c.Assert(svc.CreateFnInvoked, qt.IsTrue) c.Assert(buf.String(), qt.JSONEquals, ks) } + +func TestKeyspace_CreateCmdRejectsOutOfRangeMaxRollout(t *testing.T) { + c := qt.New(t) + + format := printer.JSON + p := printer.NewPrinter(&format) + + for _, arg := range []string{"--max-rollout=0", "--max-rollout=33", "--max-rollout=-1"} { + svc := &mock.KeyspacesService{} + ch := &cmdutil.Helper{ + Printer: p, + Config: &config.Config{Organization: "planetscale"}, + Client: func() (*ps.Client, error) { + return &ps.Client{Keyspaces: svc}, nil + }, + } + + cmd := CreateCmd(ch) + cmd.SetArgs([]string{"planetscale", "main", "sharded", "--cluster-size", "PS-20", arg}) + err := cmd.Execute() + c.Assert(err, qt.ErrorMatches, ".*max-rollout must be between 1 and 32") + c.Assert(svc.CreateFnInvoked, qt.IsFalse) + } +} diff --git a/internal/planetscale/keyspaces.go b/internal/planetscale/keyspaces.go index d85d1877a..772e12a52 100644 --- a/internal/planetscale/keyspaces.go +++ b/internal/planetscale/keyspaces.go @@ -80,6 +80,7 @@ type CreateKeyspaceRequest struct { ClusterSize string `json:"cluster_size"` ExtraReplicas int `json:"extra_replicas"` Shards int `json:"shards"` + MaxRollout *int `json:"max_rollout,omitempty"` } type ExternalDatasource struct { diff --git a/internal/planetscale/keyspaces_test.go b/internal/planetscale/keyspaces_test.go index 048b3117d..ca620a7b7 100644 --- a/internal/planetscale/keyspaces_test.go +++ b/internal/planetscale/keyspaces_test.go @@ -172,6 +172,9 @@ func TestKeyspaces_Create(t *testing.T) { _, err := w.Write([]byte(out)) c.Assert(err, qt.IsNil) c.Assert(r.Method, qt.Equals, http.MethodPost) + raw, err := io.ReadAll(r.Body) + c.Assert(err, qt.IsNil) + c.Assert(strings.TrimSpace(string(raw)), qt.Equals, `{"name":"qux","cluster_size":"small","extra_replicas":3,"shards":2}`) })) client, err := NewClient(WithBaseURL(ts.URL)) From 0ec2a07e0c362c43cabc40c201a61d41483399b3 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 19 Nov 2026 21:41:38 +0000 Subject: [PATCH 2/3] keyspace create: warn when --max-rollout is not applied; share range check --- internal/cmd/keyspace/create.go | 10 +++++-- internal/cmd/keyspace/create_test.go | 35 +++++++++++++++++++++++- internal/cmd/keyspace/keyspace.go | 8 ++++++ internal/cmd/keyspace/update_settings.go | 8 ++++-- 4 files changed, 54 insertions(+), 7 deletions(-) diff --git a/internal/cmd/keyspace/create.go b/internal/cmd/keyspace/create.go index 33ea49e49..5096f3804 100644 --- a/internal/cmd/keyspace/create.go +++ b/internal/cmd/keyspace/create.go @@ -33,8 +33,8 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { database, branch, keyspace := args[0], args[1], args[2] if cmd.Flags().Changed("max-rollout") { - if flags.maxRollout < 1 || flags.maxRollout > 32 { - return errors.New("--max-rollout must be between 1 and 32") + if err := validateMaxRollout(flags.maxRollout); err != nil { + return err } createReq.MaxRollout = &flags.maxRollout } @@ -83,6 +83,10 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { end() } + if createReq.MaxRollout != nil && (k.MaxRollout == nil || *k.MaxRollout != *createReq.MaxRollout) { + fmt.Fprintf(cmd.ErrOrStderr(), "Warning: --max-rollout was not applied; set it with 'pscale keyspace update-settings %s %s %s --max-rollout %d'.\n", database, branch, keyspace, *createReq.MaxRollout) + } + if ch.Printer.Format() == printer.Human { ch.Printer.Printf("Keyspace %s was successfully created.\n", printer.BoldBlue(k.Name)) return nil @@ -94,7 +98,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { cmd.Flags().IntVar(&flags.shards, "shards", 1, "Number of shards in the keyspace") cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "", "cluster size for the keyspace. Use `pscale size cluster list` to get a list of valid sizes.") cmd.Flags().IntVar(&flags.additionalReplicas, "additional-replicas", 0, "number of additional replicas per shard. By default, each production cluster includes 2 replicas.") - cmd.Flags().IntVar(&flags.maxRollout, "max-rollout", 0, "Maximum number of shards to roll out changes to concurrently (1-32).") + cmd.Flags().IntVar(&flags.maxRollout, "max-rollout", 0, "Maximum number of shards to roll out changes to concurrently (1-32). Defaults to a value based on the shard count.") cmd.Flags().BoolVar(&flags.wait, "wait", false, "Wait until the keyspace is ready") cmd.MarkFlagRequired("cluster-size") diff --git a/internal/cmd/keyspace/create_test.go b/internal/cmd/keyspace/create_test.go index ce182db4b..699c39910 100644 --- a/internal/cmd/keyspace/create_test.go +++ b/internal/cmd/keyspace/create_test.go @@ -27,12 +27,14 @@ func TestKeyspace_CreateCmd(t *testing.T) { branch := "main" keyspace := "sharded" + maxRollout := 8 ks := &ps.Keyspace{ ID: "wantid", Name: keyspace, ClusterSize: "PS-20", Replicas: 3, Shards: 2, + MaxRollout: &maxRollout, } svc := &mock.KeyspacesService{ @@ -65,9 +67,12 @@ func TestKeyspace_CreateCmd(t *testing.T) { cmd := CreateCmd(ch) cmd.SetArgs([]string{db, branch, keyspace, "--cluster-size", "PS-20", "--shards", "2", "--additional-replicas", "1", "--max-rollout", "8"}) + var stderr bytes.Buffer + cmd.SetErr(&stderr) err := cmd.Execute() c.Assert(err, qt.IsNil) c.Assert(svc.CreateFnInvoked, qt.IsTrue) + c.Assert(stderr.String(), qt.Equals, "") c.Assert(buf.String(), qt.JSONEquals, ks) } @@ -183,7 +188,7 @@ func TestKeyspace_CreateCmdRejectsOutOfRangeMaxRollout(t *testing.T) { format := printer.JSON p := printer.NewPrinter(&format) - for _, arg := range []string{"--max-rollout=0", "--max-rollout=33", "--max-rollout=-1"} { + for _, arg := range []string{"--max-rollout=0", "--max-rollout=33"} { svc := &mock.KeyspacesService{} ch := &cmdutil.Helper{ Printer: p, @@ -200,3 +205,31 @@ func TestKeyspace_CreateCmdRejectsOutOfRangeMaxRollout(t *testing.T) { c.Assert(svc.CreateFnInvoked, qt.IsFalse) } } + +func TestKeyspace_CreateCmdWarnsWhenMaxRolloutNotApplied(t *testing.T) { + c := qt.New(t) + + format := printer.JSON + p := printer.NewPrinter(&format) + p.SetResourceOutput(&bytes.Buffer{}) + + svc := &mock.KeyspacesService{ + CreateFn: func(_ context.Context, req *ps.CreateKeyspaceRequest) (*ps.Keyspace, error) { + return &ps.Keyspace{Name: req.Name}, nil + }, + } + ch := &cmdutil.Helper{ + Printer: p, + Config: &config.Config{Organization: "planetscale"}, + Client: func() (*ps.Client, error) { + return &ps.Client{Keyspaces: svc}, nil + }, + } + + cmd := CreateCmd(ch) + cmd.SetArgs([]string{"planetscale", "main", "sharded", "--cluster-size", "PS-20", "--max-rollout", "8"}) + var stderr bytes.Buffer + cmd.SetErr(&stderr) + c.Assert(cmd.Execute(), qt.IsNil) + c.Assert(stderr.String(), qt.Contains, "--max-rollout was not applied") +} diff --git a/internal/cmd/keyspace/keyspace.go b/internal/cmd/keyspace/keyspace.go index 7ca665af9..126c4d4c1 100644 --- a/internal/cmd/keyspace/keyspace.go +++ b/internal/cmd/keyspace/keyspace.go @@ -2,6 +2,7 @@ package keyspace import ( "encoding/json" + "errors" "github.com/planetscale/cli/internal/cmdutil" ps "github.com/planetscale/cli/internal/planetscale" @@ -121,3 +122,10 @@ func (k *Keyspace) MarshalJSON() ([]byte, error) { func (k *Keyspace) MarshalCSVValue() interface{} { return []*Keyspace{k} } + +func validateMaxRollout(n int) error { + if n < 1 || n > 32 { + return errors.New("--max-rollout must be between 1 and 32") + } + return nil +} diff --git a/internal/cmd/keyspace/update_settings.go b/internal/cmd/keyspace/update_settings.go index 855be3483..7c55ae41b 100644 --- a/internal/cmd/keyspace/update_settings.go +++ b/internal/cmd/keyspace/update_settings.go @@ -81,8 +81,10 @@ func UpdateSettingsCmd(ch *cmdutil.Helper) *cobra.Command { return errors.New("--throttler-threshold must be greater than or equal to 0") } - if maxRolloutChanged && (flags.maxRollout < 1 || flags.maxRollout > 32) { - return errors.New("--max-rollout must be between 1 and 32") + if maxRolloutChanged { + if err := validateMaxRollout(flags.maxRollout); err != nil { + return err + } } if strategyChanged && !slices.Contains(diskScalingStrategies, flags.diskScalingStrategy) { @@ -212,7 +214,7 @@ func UpdateSettingsCmd(ch *cmdutil.Helper) *cobra.Command { cmd.Flags().BoolVar(&flags.vreplicationFlags.VPlayerBatching, "vreplication-batch-replication-events", false, "When enabled, sends fewer queries to MySQL to improve performance.") cmd.Flags().BoolVar(&flags.throttlerEnabled, "throttler-enabled", true, "Pause schema migrations and VReplication workflows when replication lag rises above the threshold.") cmd.Flags().Float64Var(&flags.throttlerThreshold, "throttler-threshold", 5, "Replication lag in seconds above which migrations and workflows are paused.") - cmd.Flags().IntVar(&flags.maxRollout, "max-rollout", 1, "Maximum number of shards to roll out changes to concurrently (1-32).") + cmd.Flags().IntVar(&flags.maxRollout, "max-rollout", 0, "Maximum number of shards to roll out changes to concurrently (1-32).") cmd.Flags().StringVar(&flags.diskScalingStrategy, "disk-scaling-strategy", "grow", fmt.Sprintf("The disk scaling strategy (%s). 'grow' lets dedicated disks grow automatically up to --max-storage; 'disable' turns autoscaling off; 'shrink' recreates disks at --storage and then disables autoscaling.", strings.Join(diskScalingStrategies, ", "))) cmd.Flags().StringVar(&flags.maxStorage, "max-storage", "", "The maximum size that dedicated disks may autoscale to, in bytes or with a unit such as 200GiB or 1TiB. Must be at least 12 GiB and no smaller than the current disk size. Cannot be raised above the organization default (4 TiB, or 16 TiB for managed tenancy). Read-only while PlanetScale staff have raised it above that default.") cmd.Flags().StringVar(&flags.storage, "storage", "", "The disk size to recreate disks at, in bytes or with a unit such as 200GiB or 1TiB. Must be a multiple of 1 GiB. Only accepted when the disk scaling strategy is shrink, either passed with --disk-scaling-strategy or already set on the keyspace.") From 0a714d9ba04f7a648aaa7c003c1ccb739864d024 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Fri, 20 Nov 2026 02:51:48 +0000 Subject: [PATCH 3/3] keyspace create: include --org in the max-rollout fix-up hint --- internal/cmd/keyspace/create.go | 2 +- internal/cmd/keyspace/create_test.go | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/internal/cmd/keyspace/create.go b/internal/cmd/keyspace/create.go index 5096f3804..68f891a67 100644 --- a/internal/cmd/keyspace/create.go +++ b/internal/cmd/keyspace/create.go @@ -84,7 +84,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command { } if createReq.MaxRollout != nil && (k.MaxRollout == nil || *k.MaxRollout != *createReq.MaxRollout) { - fmt.Fprintf(cmd.ErrOrStderr(), "Warning: --max-rollout was not applied; set it with 'pscale keyspace update-settings %s %s %s --max-rollout %d'.\n", database, branch, keyspace, *createReq.MaxRollout) + fmt.Fprintf(cmd.ErrOrStderr(), "Warning: --max-rollout was not applied; set it with 'pscale keyspace update-settings %s %s %s --org %s --max-rollout %d'.\n", database, branch, keyspace, ch.Config.Organization, *createReq.MaxRollout) } if ch.Printer.Format() == printer.Human { diff --git a/internal/cmd/keyspace/create_test.go b/internal/cmd/keyspace/create_test.go index 699c39910..84d0e0957 100644 --- a/internal/cmd/keyspace/create_test.go +++ b/internal/cmd/keyspace/create_test.go @@ -232,4 +232,5 @@ func TestKeyspace_CreateCmdWarnsWhenMaxRolloutNotApplied(t *testing.T) { cmd.SetErr(&stderr) c.Assert(cmd.Execute(), qt.IsNil) c.Assert(stderr.String(), qt.Contains, "--max-rollout was not applied") + c.Assert(stderr.String(), qt.Contains, "update-settings planetscale main sharded --org planetscale --max-rollout 8") }