diff --git a/Cargo.lock b/Cargo.lock index 7afdbdb31a6f1..ac85ccf14a80f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5777,6 +5777,7 @@ dependencies = [ "mz-cloud-provider", "mz-cloud-resources", "mz-cluster-client", + "mz-cluster-controller", "mz-compute-client", "mz-compute-types", "mz-controller", @@ -6306,6 +6307,19 @@ dependencies = [ "uuid", ] +[[package]] +name = "mz-cluster-controller" +version = "0.0.0" +dependencies = [ + "async-trait", + "mz-compute-types", + "mz-controller-types", + "mz-ore", + "mz-repr", + "timely", + "tokio", +] + [[package]] name = "mz-clusterd" version = "26.30.0-dev.0" diff --git a/Cargo.toml b/Cargo.toml index 9d22db9e04424..83ed79a6b4c19 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,6 +24,7 @@ members = [ "src/cloud-resources", "src/cluster", "src/cluster-client", + "src/cluster-controller", "src/clusterd", "src/compute", "src/compute-client", @@ -153,6 +154,7 @@ default-members = [ "src/cloud-resources", "src/cluster", "src/cluster-client", + "src/cluster-controller", "src/clusterd", "src/compute", "src/compute-client", diff --git a/doc/developer/design/20260522_cluster_autoscaling.md b/doc/developer/design/20260522_cluster_autoscaling.md index 7cd64c07daa47..9530fc48737c9 100644 --- a/doc/developer/design/20260522_cluster_autoscaling.md +++ b/doc/developer/design/20260522_cluster_autoscaling.md @@ -55,7 +55,7 @@ Beneath both capabilities is a shared architectural problem: today, cluster sche ### Summary -We introduce a **cluster controller** as a dedicated task inside `environmentd`. It is the single decision-maker for the replica set of every cluster. It operates as a reconciler: it reads desired cluster state from the durable catalog, observes the actual replica set and live status signals, computes a desired replica set per cluster by combining a set of **strategies**, and emits catalog-change commands to the Coordinator via a message channel. The Coordinator remains the sole writer of catalog state. +We introduce a **cluster controller** as a dedicated task inside `environmentd`. It is the single decision-maker for the replica set of every user managed cluster (system and builtin clusters keep their bootstrap-owned replicas). It operates as a reconciler: it reads desired cluster state from the durable catalog, observes the actual replica set and live status signals, computes a desired replica set per cluster by combining a set of **strategies**, and emits catalog-change commands to the Coordinator via a message channel. The Coordinator remains the sole writer of catalog state. ALTER CLUSTER operations are reshaped so that the user's intent is written durably and immediately to the catalog — as an in-flight target record, leaving the cluster's realized config in place until the controller cuts over; the controller then reconciles from that intent. Graceful reconfiguration becomes a strategy within the controller framework, as does hydration burst. The existing `ON REFRESH` scheduling is lifted into the framework. @@ -70,9 +70,9 @@ Initial strategies. The implicit baseline is always present; the rest engage per - **Implicit baseline.** Desires the replicas implied by the realized config, `replication_factor` replicas at `cluster.size`, with the configured AZ and other cluster shape. It is what lets the policy strategies be purely additive: it holds the steady set, so they only ever add to it. -- **Graceful reconfiguration.** Engaged when `ALTER` writes a durable `reconfiguration` record. This desires `replication_factor` replicas — the target's, since an `ALTER` can change it — at the record's `target` **config shape** (target size, logging, and availability-zone list). When `update_state` observes the target replicas present and hydrated, it updates the cluster configuration (`cluster.size := target`, ...) and clears the `reconfiguration` record. `update_state` also reads the `deadline` and `on_timeout`. Success takes precedence: a tick that sees the target replicas hydrated cuts over even if the deadline has passed. Otherwise, once `now > deadline` with the target not fully hydrated, `update_state` applies `on_timeout` — the default `ROLLBACK` stops contributing this reconfiguration's target replicas and keeps the record as a tombstone, so the strategy stays a no-op until another `ALTER`; `COMMIT` instead cuts over to the still-unhydrated target. Cut-over keys on **hydration** — today's graceful-reconfiguration signal — not a stronger caught-up check: hydration already guarantees correct answers, so a caught-up check would only avoid a brief post-cut-over latency bump, a possible later refinement. One consequence worth noting: an OOM- or crash-looping target replica never hydrates, so it can never cut over — the deadline fires and the default `on_timeout` reverts. No special OOM-loop detection needed. +- **Graceful reconfiguration.** Engaged when `ALTER` writes a durable `reconfiguration` record. This desires `replication_factor` replicas — the target's, since an `ALTER` can change it — at the record's `target` **config shape** (target size, logging, and availability-zone list). When `update_state` observes the target replicas present and hydrated, it updates the cluster configuration (`cluster.size := target`, ...) and clears the `reconfiguration` record. `update_state` also reads the `deadline` and `on_timeout`. Success takes precedence: a tick that sees the target replicas hydrated cuts over even if the deadline has passed. Otherwise, once `now > deadline` with the target not fully hydrated, `update_state` applies `on_timeout` — the default `ROLLBACK` clears the record without touching the realized config and stops contributing the target replicas, so the cluster reverts to the pre-reconfiguration set and the strategy disengages; `COMMIT` instead cuts over to the still-unhydrated target. Cut-over keys on **hydration** — today's graceful-reconfiguration signal — not a stronger caught-up check: hydration already guarantees correct answers, so a caught-up check would only avoid a brief post-cut-over latency bump, a possible later refinement. One consequence worth noting: an OOM- or crash-looping target replica never hydrates, so it can never cut over — the deadline fires and the default `on_timeout` reverts. No special OOM-loop detection needed. -- **Hydration burst.** When the cluster's `AUTO SCALING STRATEGY` sets `ON HYDRATION (HYDRATION SIZE = ...)`, the cluster is On (`replication_factor > 0`), and no realized-config replica has all current objects hydrated, `update_state` writes a `burst` record (its size and linger duration). When that record is present this desires one extra replica at `HYDRATION SIZE`. When `update_state` notices that at least one steady-state replica is hydrated, it records that timestamp. Once time has passed that timestamp plus linger duration it removes the burst record. Additionally, when there is a burst record and we recorded successful hydration of the steady-state replicas, but the steady-state replicas become un-hydrated again, we reset burst state so that the linger duration can restart after the next successful hydration. Finally, `update_state` clears the `burst` record — regardless of linger — whenever a burst is no longer warranted by current config: the `AUTO SCALING STRATEGY` was removed or its `HYDRATION SIZE` changed, or the cluster was turned off (`replication_factor = 0`). Because `desired_replicas` keys the burst replica purely on the record's presence, this cleanup is what stops a stale record from pinning a burst replica on a cluster that is off or no longer configured for burst; on a `HYDRATION SIZE` change a fresh record is written at the new size on a later tick if a burst is still warranted. +- **Hydration burst.** When the cluster's `AUTO SCALING STRATEGY` sets `ON HYDRATION (HYDRATION SIZE = ...)`, the cluster is On (`replication_factor > 0`), and there exists an object on the cluster that no realized-config replica has hydrated (zero objects warrant no burst, vacuously — a brand-new cluster does not burst at creation), `update_state` writes a `burst` record (its size and linger duration). When that record is present this desires one extra replica at `HYDRATION SIZE`. When `update_state` notices that at least one steady-state replica is hydrated, it records that timestamp. Once time has passed that timestamp plus linger duration it removes the burst record. Additionally, when there is a burst record and we recorded successful hydration of the steady-state replicas, but the steady-state replicas become un-hydrated again, we reset burst state so that the linger duration can restart after the next successful hydration. Finally, `update_state` clears the `burst` record — regardless of linger — whenever a burst is no longer warranted by current config: the `AUTO SCALING STRATEGY` was removed or its `HYDRATION SIZE` changed, or the cluster was turned off (`replication_factor = 0`). Because `desired_replicas` keys the burst replica purely on the record's presence, this cleanup is what stops a stale record from pinning a burst replica on a cluster that is off or no longer configured for burst; on a `HYDRATION SIZE` change a fresh record is written at the new size on a later tick if a burst is still warranted. - **`ON REFRESH` scheduling.** Contributes one replica at `cluster.size` while the cluster is inside a refresh window and nothing otherwise, based on REFRESH MV write frontiers and the configured hydration-time estimate. A scheduled cluster's `replication_factor` is normalized to `0`, so the implicit baseline desires no replicas and `ON REFRESH` is the sole contributor of replicas. It does not apply to MANUAL clusters. @@ -80,7 +80,7 @@ Both functions of every strategy are pure: same inputs, same output, no side eff #### Combining strategy outputs -Each strategy's `desired_replicas` contribution is a **multiset of replica slots keyed by config shape** — a count per shape, not a set: the implicit baseline alone wants `replication_factor` slots at one shape. Strategies name no replicas; they describe shapes and counts, and the controller assigns concrete names as it fills slots, so two strategies can never contend over a replica *name*. Contributions combine **per shape, taking the max count across strategies**, so a slot survives as long as *any* strategy desires it and overlapping requests for the same shape don't double it. Strategies are purely additive, so they cannot contradict one another. The controller diffs the combined desired set against the actual replica set and emits the gap: a create for a slot the desired set calls for but actual lacks, a drop for a replica whose shape no strategy still desires. This composes the strategies with no state-machine interaction between them. The controller retains each strategy's individual contribution, not just the merged set, so it can attribute every command it emits: a create records which strategies desired the replica ("required by graceful reconfiguration and hydration burst"), a drop records that none did. These attributions are the reasons carried on the audit events. +Each strategy's `desired_replicas` contribution is a **multiset of replica slots keyed by config shape** — a count per shape, not a set: the implicit baseline alone wants `replication_factor` slots at one shape. Strategies name no replicas; they describe shapes and counts, and the controller assigns concrete names as it fills slots, so two strategies can never contend over a replica *name*. Contributions combine **per shape, taking the max count across strategies**, so a slot survives as long as *any* strategy desires it and overlapping requests for the same shape don't double it. Strategies are purely additive, so they cannot contradict one another. The controller diffs the combined desired set against the actual replica set and emits the gap: a create for a slot the desired set calls for but actual lacks, a drop for a replica whose shape no strategy still desires. This composes the strategies with no state-machine interaction between them. The controller retains each strategy's individual contribution, not just the merged set, so it can attribute every create it emits: a create records which strategies desired the replica ("required by graceful reconfiguration and hydration burst"), and those attributions are the reasons carried on the create audit events; an on-refresh create additionally carries the window decision behind it (which REFRESH MVs needed a refresh or compaction time, and the hydration-time estimate) as the event's `scheduling_policies` detail, just as the legacy scheduler recorded. A drop happens exactly when no strategy desires the replica, so it carries no strategy attribution and no decision detail; every controller drop is audited with the uniform `retired` reason — the cluster's configuration no longer calls for the replica. ### The cluster controller @@ -158,7 +158,7 @@ An `ALTER CLUSTER SET (...)` that changes a replica's **config shape** — `SIZE - `WAIT UNTIL READY (TIMEOUT '', ON TIMEOUT COMMIT|ROLLBACK)` — the hydration-aware form. `TIMEOUT` is added to the transaction timestamp and written as the `reconfiguration` record's `deadline`; `ON TIMEOUT` is written as its `on_timeout`. The controller cuts over once the target replicas hydrate; only if the deadline passes un-hydrated does it apply `on_timeout`. - `WAIT FOR ''` — retained as sugar for `WAIT UNTIL READY (TIMEOUT '', ON TIMEOUT COMMIT)`. Its legacy contract was "wait the fixed duration, then cut over regardless of hydration"; a change from the legacy behavior is that the controller cuts over the instant the target hydrates, so we drop the "wait the *full* duration even when ready early" property, which carries no value in a background model. The blind cut-over-at-the-deadline it implied is exactly `ON TIMEOUT COMMIT`. A `WAIT FOR '0s'` (equivalently `TIMEOUT '0s'` with `ON TIMEOUT COMMIT`) thus requests an immediate cut-over: the deadline is already past, so the controller commits on its first pass without ever provisioning overlap replicas — the non-graceful, drop-and-recreate resize, now an explicit opt-in rather than the no-`WAIT` default. -`ON TIMEOUT` defaults to **`ROLLBACK`** when omitted — the safe, conservative choice that never surprises a user with downtime by cutting over to a not-yet-hydrated target. This is a change from today's implicit `COMMIT` default, applied uniformly (the foreground wait shim picks it up too). Omitting `WITH (WAIT ...)` entirely on a reconfiguring `ALTER` falls back to the `default_cluster_reconfiguration_timeout` dyncfg for the deadline (so a transition is never unbounded) and the default `ROLLBACK` action. The session-side wait shim does not run a timer of its own; it watches the durable outcome and returns when the controller resolves — a completed cut-over or a rolled-back tombstone — so the in-session UX of "ALTER returns or errors within the timeout" is preserved without the shim and controller ever disagreeing. There is no shim-side timeout at all: the controller resolves the reconfiguration by its deadline, and the shim simply waits for that. +`ON TIMEOUT` defaults to **`ROLLBACK`** when omitted — the safe, conservative choice that never surprises a user with downtime by cutting over to a not-yet-hydrated target. This is a change from today's implicit `COMMIT` default, applied uniformly (the foreground wait shim picks it up too). Omitting `WITH (WAIT ...)` entirely on a reconfiguring `ALTER` falls back to the `default_cluster_reconfiguration_timeout` dyncfg for the deadline (so a transition is never unbounded) and the default `ROLLBACK` action. The session-side wait shim does not run a timer of its own; it watches the durable outcome and returns when the controller resolves — the record clearing, with success or rollback read off whether the realized config reached the target — so the in-session UX of "ALTER returns or errors within the timeout" is preserved without the shim and controller ever disagreeing. There is no shim-side timeout at all: the controller resolves the reconfiguration by its deadline, and the shim simply waits for that. **New cluster option: `AUTO SCALING STRATEGY = (...)`.** Available at `CREATE CLUSTER` and `ALTER CLUSTER ... SET (...)`. The value is a paren-enclosed list mixing strategy specs (currently only `ON HYDRATION (HYDRATION SIZE = '...', LINGER DURATION = '...')`, where `LINGER DURATION` is optional — the dyncfg default applies when it is omitted). The whole block is set or replaced atomically; specifying an empty list — or `ALTER CLUSTER ... RESET (AUTO SCALING STRATEGY)` — disables auto-scaling for the cluster. Fine-grained ALTERs that change one sub-parameter are out of scope for v1. @@ -174,25 +174,25 @@ We may add explicit `ALTER CLUSTER ... CANCEL ALTER` (or equivalent) syntax late Two distinct surfaces, mirroring the controller's separation of "current state" from "history": -- **Current state — introspection view.** A new builtin view (working name: `mz_internal.mz_cluster_reconfigurations`, naming TBD) reports, per cluster: realized vs. target config shape (size, logging, availability zones) and replication factor, presence of an in-flight reconfiguration, the active deadline (when set), currently-running burst replicas. The *target* is the `reconfiguration` record's target whenever a `reconfiguration` record is present (including a timed-out tombstone), otherwise `cluster.size` itself. During a graceful reconfiguration the two differ; at cut-over `cluster.size` advances to the target and they coincide again. A timed-out reconfiguration shows as a tombstoned record (deadline in the past) with `cluster.size` still at the realized value, and the abandoned target visible in the record. +- **Current state — two introspection relations.** The realized config lives in `mz_clusters`; the in-flight delta is split across two builtin relations keyed on `cluster_id`, each carrying its structural payload as JSON so the schema is stable as strategies grow: + - `mz_internal.mz_cluster_reconfigurations` — one row per in-flight graceful reconfiguration: its `deadline`, `on_timeout` action, and `target` config shape. A timed-out reconfiguration clears its record and drops out of the relation; the abandoned target lives only in the audit log. + - `mz_internal.mz_cluster_auto_scaling_strategies` — one row per cluster with an `AUTO SCALING STRATEGY` configured or an autoscaling action running: the configured policy and the in-flight runtime state (the active burst, when one is up). -- **`SHOW CLUSTERS` surfaces in-flight reconfigurations.** Today's `SHOW CLUSTERS` is implemented as SQL over `mz_clusters` and related views; we extend that SQL to join with the new introspection view so a user sees, per cluster, both the current size (the realized `cluster.size`) and the target size (the `reconfiguration` record's target, when one is in flight), plus an indication of whether a reconfiguration is in flight. The exact column set is left to implementation, but the design requires that a single `SHOW CLUSTERS` answers the questions "what did I ask for", "what's actually there now", and "is something in progress, done, or timed out" without requiring the user to know about the introspection view. +- **`SHOW CLUSTERS` surfaces in-flight activity.** We extend its SQL to add one column reporting any in-flight reconfiguration or burst, drawn from the two relations above, so a single `SHOW CLUSTERS` answers "is something in progress" without the user needing to know about them. -- **History — audit log.** Audit events come from three places: the `ALTER` that writes or overwrites a `reconfiguration` record (a graceful reconfiguration *started*, or *cancelled* via ALTER-back), the durable transitions `update_state` commits within a tick (cut-over, timeout-fired, and burst *started* — burst is controller-initiated, so `update_state` writes its record), and the create/drop commands the controller derives from the `desired_replicas` diff. `desired_replicas` itself records nothing directly — it touches the log only through the replica-lifecycle commands its output induces. Extend the existing `SchedulingDecisionsWithReasonsV2` event family (or add closely-related event variants) to cover: - - Graceful reconfiguration: started, replica created, replica dropped, finalized, cancelled, timeout fired (for stuck reconfigurations). +- **History — audit log.** Audit events come from three places: the `ALTER` that writes or overwrites a `reconfiguration` record (a graceful reconfiguration *started*, or *cancelled* via ALTER-back), the durable transitions `update_state` commits within a tick (cut-over, timed-out, and burst *started* — burst is controller-initiated, so `update_state` writes its record), and the create/drop commands the controller derives from the `desired_replicas` diff. `desired_replicas` itself records nothing directly — it touches the log only through the replica-lifecycle commands its output induces. Extend the existing `SchedulingDecisionsWithReasonsV2` event family (or add closely-related event variants) to cover: + - Graceful reconfiguration: started, replica created, replica dropped, finalized, cancelled, timed-out. - Hydration burst: started, replica created, replica dropped. -All audit entries record the cluster, and identifiers of the replicas involved. Reconfiguration start and timeout-fired events also record the active deadline so an operator can correlate "timeout fired" with the originating `ALTER`. +All audit entries record the cluster, and identifiers of the replicas involved. Every reconfiguration lifecycle event records the active deadline so an operator can correlate it with the originating `ALTER`. ### Failure handling and safety rails - **Stuck reconfiguration.** The `reconfiguration` record's `deadline` and `on_timeout` come from the `ALTER`'s `WITH (WAIT ...)` (or the `default_cluster_reconfiguration_timeout` dyncfg + default `ROLLBACK` when no `WAIT` is given). *Success precedence* always applies first: if the target replicas all hydrate at or before the deadline, the controller cuts over normally regardless of `on_timeout`. When `now` exceeds the deadline with the target **not** fully hydrated, the controller applies `on_timeout`: - - **`ROLLBACK` (the default).** The controller **drops all of this reconfiguration's target replicas — including any that did hydrate — reverting to the pre-reconfiguration replica set.** Dropping the whole target set, not just the un-hydrated ones, is deliberate: `replication_factor > 1` is a high-availability requirement, and a partial cutover (some target-size replicas, the rest still old) would satisfy it at no single size — so the cluster stays fully on the old set, which does meet HA at the realized size, until the new set can hydrate completely. The `reconfiguration` record is **retained with the past deadline as a tombstone**: it surfaces the abandoned target in `SHOW CLUSTERS` and the introspection view, and its past deadline keeps the strategy backed off (suppresses re-adding the target replicas), so this is a stable state, not a retry loop. It persists until the user issues another `ALTER` — back to the realized size (overwrite-and-converge, which just confirms the current state and clears the record), forward to a new one, or a re-issue to grant a fresh deadline. + - **`ROLLBACK` (the default).** The controller **drops all of this reconfiguration's target replicas — including any that did hydrate — reverting to the pre-reconfiguration replica set.** Dropping the whole target set, not just the un-hydrated ones, is deliberate: `replication_factor > 1` is a high-availability requirement, and a partial cutover (some target-size replicas, the rest still old) would satisfy it at no single size — so the cluster stays fully on the old set, which does meet HA at the realized size, until the new set can hydrate completely. The controller **clears the `reconfiguration` record durably, leaving the realized config untouched**: with the record gone the strategy disengages entirely, so this is a stable state, not a retry loop. The clear-without-cut-over is what the `timed-out` audit event classifies, so the timeout firing is in the history exactly once — and the audit event is the timeout's only papertrail. - **`COMMIT`.** The controller advances the realized `cluster.size` to the target and clears the record even though the target replicas are not all hydrated — the explicit "I'd rather take the new shape now than keep waiting" choice, accepting that queries may be served from a not-yet-hydrated replica until it catches up. - An audit event records the timeout and the action taken. - - **Hysteresis.** The only bit of light hysteresis we have is the linger duration on burst clusters. This makes it so we don't rapidly thrash when a user is slowly creating new objects. We deliberately don't add more elaborate schemes and cooldowns that prevent firing up a burst replica. The initial user-facing goal is: there should be a burst replica when steady-state replicas are not hydrated, and it's okay to have a burst replica around for quite a while because it might be the only thing that makes it so we can continue serving requests. Which latter means we don't want to have a timeout/ttl on how long a burst replica can be up. Two consequences fall out of having no TTL and re-arming on un-hydration, both accepted: if the steady-state replicas can never hydrate at `cluster.size` (e.g. a dataflow that only fits at the burst size), the burst replica stays up indefinitely and the cluster runs permanently oversized, visible only through billing and the audit log; and a cluster with steady object churn keeps re-arming the linger and so keeps a burst replica alive. - **Break-glass dyncfg.** A dedicated flag disables the hydration-burst strategy environment-wide without disabling graceful reconfiguration or `ON REFRESH`. Operations can flip this if burst behavior misfires. @@ -209,7 +209,7 @@ Keys TBD. The dyncfgs in play: background-reconfiguration gate, default timeout Because all relevant state is durable, restart behavior is trivial: -- On controller startup, it reads the catalog and live status signals, computes desired replica sets, diffs against actual, and emits whatever decisions are needed. A reconfiguration mid-flight at the moment of restart resumes from wherever the durable state landed — the `reconfiguration` record (target + deadline) is durable, so the controller knows both what it was converging on and by when: if the new replicas were already created and partially hydrated, it waits for them; if they had hydrated and the cut-over had already committed, there is no record and `cluster.size` is already the new size, so the controller sees a settled cluster and does nothing; if the timeout had already fired, the tombstoned record keeps the strategy parked until another `ALTER`. +- On controller startup, it reads the catalog and live status signals, computes desired replica sets, diffs against actual, and emits whatever decisions are needed. A reconfiguration mid-flight at the moment of restart resumes from wherever the durable state landed — the `reconfiguration` record (target + deadline) is durable, so the controller knows both what it was converging on and by when: if the new replicas were already created and partially hydrated, it waits for them; if they had hydrated and the cut-over had already committed, there is no record and `cluster.size` is already the new size, so the controller sees a settled cluster and does nothing; if the timeout had already fired, the record is gone and the controller sees a settled cluster at the pre-reconfiguration shape, so it does nothing. - No bootstrap cleanup of "pending" replicas is needed (there are no pending-flagged replicas; the diff drives convergence). ### Migration @@ -228,7 +228,7 @@ The following behaviors fall out of the design rather than being its headline ou - **Background `ALTER CLUSTER` returns immediately** after writing the in-flight `reconfiguration` record to the catalog. The actual replica transition happens asynchronously and is observable via the new introspection view. Note a deliberate difference from how some other async DDL reads back: the cluster's realized config (`cluster.size`, `SHOW CREATE CLUSTER`, `mz_clusters.size`) keeps showing the **pre-reconfiguration** config until the controller cuts over; the realized config is the committed steady-state config, not a target, and the pending target is surfaced separately (the introspection view, `SHOW CLUSTERS`). - **A plain `ALTER CLUSTER SET (SIZE = ...)` (no `WITH (WAIT ...)`) is now graceful and non-disruptive by default.** Today a bare config-shape `ALTER` without `WITH (WAIT ...)` tears the cluster's replicas down and recreates them at the new shape, so the cluster is unavailable while the new replicas rehydrate. The new model runs the graceful overlap path instead — old replicas keep serving until the new ones hydrate and cut over — at the cost of the transient double billing noted above. This flip should be called out in release notes. A user who wants the old immediate behavior — cut over at once and accept the rehydration gap, avoiding the overlap cost — can request it explicitly with `WITH (WAIT FOR '0s')` (equivalently `WAIT UNTIL READY (TIMEOUT '0s', ON TIMEOUT COMMIT)`): the deadline is already in the past, so the controller commits the cut-over on its first pass without provisioning overlap replicas. - **`SHOW CLUSTERS` gains in-flight visibility.** The command is extended to surface both the current size (the realized `cluster.size`) and the target size (the in-flight `reconfiguration` record, when one is pending), plus an indication of whether a reconfiguration is in progress. This is a change from today's behavior, where `SHOW CLUSTERS` shows only the old size until the graceful reconfiguration finalizes and there is no in-band way to ask "is a reconfig in flight". See [Observability](#observability). -- **`WITH (WAIT ...)` is now durable, and the implicit `ON TIMEOUT` default flips from `COMMIT` to `ROLLBACK`.** Today's `WAIT UNTIL READY (TIMEOUT ...)` was session-bound: closing the session aborted the reconfiguration. In the new model the deadline and the `ON TIMEOUT` action are written to the catalog as the `reconfiguration` record's `deadline` and `on_timeout`; closing the session no longer aborts anything, and the controller enforces both regardless of session lifetime. The session-side wait shim reflects the controller's durable outcome rather than running its own timer, so the in-session UX of "ALTER returns or errors within the timeout" is unchanged. Two changes worth release-noting: (1) the implicit `ON TIMEOUT` default is now **`ROLLBACK`** rather than `COMMIT` — a timed-out reconfiguration with no explicit action reverts to the pre-reconfiguration shape instead of cutting over to a possibly-unhydrated target; this is the safe default that never silently induces downtime, and it applies to the foreground path too. (2) On a `ROLLBACK` expiry the controller drops all of this reconfiguration's target replicas (including any that already hydrated); the cluster keeps running at its pre-reconfiguration size (the realized `cluster.size`, which never moved) with the abandoned target retained in the tombstoned record. `SHOW CLUSTERS` shows the current/target split and a timed-out indicator, and the user re-issues `ALTER` to retry or change course. Completion (or timeout) is read from the introspection view (or the absence of a pending record), not assumed from the `SIZE` the `ALTER` requested. +- **`WITH (WAIT ...)` is now durable, and the implicit `ON TIMEOUT` default flips from `COMMIT` to `ROLLBACK`.** Today's `WAIT UNTIL READY (TIMEOUT ...)` was session-bound: closing the session aborted the reconfiguration. In the new model the deadline and the `ON TIMEOUT` action are written to the catalog as the `reconfiguration` record's `deadline` and `on_timeout`; closing the session no longer aborts anything, and the controller enforces both regardless of session lifetime. The session-side wait shim reflects the controller's durable outcome rather than running its own timer, so the in-session UX of "ALTER returns or errors within the timeout" is unchanged. Two changes worth release-noting: (1) the implicit `ON TIMEOUT` default is now **`ROLLBACK`** rather than `COMMIT` — a timed-out reconfiguration with no explicit action reverts to the pre-reconfiguration shape instead of cutting over to a possibly-unhydrated target; this is the safe default that never silently induces downtime, and it applies to the foreground path too. (2) On a `ROLLBACK` expiry the cluster keeps running at its pre-reconfiguration size (the realized `cluster.size`, which never moved); the timeout is recorded in the audit log, and the user re-issues `ALTER` to retry or change course. ## Alternatives Considered diff --git a/doc/developer/design/20260522_cluster_autoscaling_plan.md b/doc/developer/design/20260522_cluster_autoscaling_plan.md new file mode 100644 index 0000000000000..18f2d751673f2 --- /dev/null +++ b/doc/developer/design/20260522_cluster_autoscaling_plan.md @@ -0,0 +1,1669 @@ +# Cluster Autoscaling — Implementation Plan & Progress Tracker + +Companion to the design doc: [`20260522_cluster_autoscaling.md`](./20260522_cluster_autoscaling.md). +That doc is the source of truth for **what** and **why**; this doc is the source of truth +for **how we land it** — the PR sequence, per-PR scope, gating, and live progress. + +> **Status:** Not started. The design (the in-flight target lives in a durable +> `reconfiguration` record; `cluster.size` stays the realized fact) is settled; no controller +> code exists in the tree yet. Build from PR 1. + +--- + +## Working on this plan (operating protocol for implementation sessions) + +**To start a session, the user says something like:** + +> "Please work on the next step of `@doc/developer/design/20260522_cluster_autoscaling_plan.md`." + +**An implementation session then does, in order:** + +1. **Read the design doc** [`20260522_cluster_autoscaling.md`](./20260522_cluster_autoscaling.md) in full, then this plan. +2. **Work from current code, not assumptions.** Skim the *Codebase anchors* below and + re-verify the file:line references you'll touch before relying on them — they drift. +3. **Pick the current PR**: the first PR below whose status is not `✅ Merged`. If a PR is + `🚧 In progress`, continue its unchecked checklist items. Do not start a later PR before + an earlier one is merged unless the user says so (the stack is ordered by dependency). +4. **Confirm the open decisions** for that PR (each PR lists the decisions it must resolve). + If a decision is genuinely the user's to make and isn't already settled here or in the + design doc, ask before building. Otherwise pick the recommended option and note it. +5. **Implement**, following the working agreement below. +6. **Update this file**: tick the checklist items you finished, update the PR status line, + and append a dated note to the Progress Log at the bottom. Keep the tracker honest — + if something was authored-but-not-run, say so. + +**Working agreement:** + +- **Match the codebase.** Read the neighbouring code before writing; mirror its idioms, + comment density, and naming. Honour root `CLAUDE.md` (workspace deps, `cargo update` + discipline, license sync) and the `mz-*` skills. +- **Cheap checks before claiming success:** `cargo fmt` and `cargo check -p ` for the + crates you touched. The optimized build is heavy — do **not** block on a full release + build locally; rely on `cargo check` locally and **author** the boundary tests for CI. +- **Test the boundaries, user-visible behavior first.** The boundary that matters most is what + a user observes: assert it with sqllogictest / testdrive (`ALTER` returns, `SHOW CLUSTERS` + shows target vs current, cut-over, timeout tombstone, burst appears/tears down, rejected + options error) and survival across restart/upgrade with platform-checks. The other boundary + is the `ClusterControllerCtx` interface — exercise the controller against a fake impl. Add + unit tests for the pure reconcile kernel only for tricky, high-value cases (multiset union, + convergence, timeout precedence) — **not** exhaustive per-function suites. +- **Keep each PR green and behaviour-preserving** — every PR (1–6) lands dark; only the final + cleanup PR (7) changes defaults and removes code. + Everything new lands **dark** behind the feature gate; existing tests must still pass with + the gate at its default. +- **Pure strategies behind a clean interface.** Strategy logic is pure + (`fn(config, status, now) -> output`, no I/O) in `mz-cluster-controller`; the controller pulls + inputs through the `ClusterControllerCtx` trait and applies outputs through it. Spend design + effort on that interface — it is the boundary that matters. +- **Migrations:** follow the catalog-migration recipe (see Anchors). Bump `CATALOG_VERSION`, + snapshot the proto, add the `vN_to_vN+1.rs` module, generate encodings. One migration PR + at a time; never regenerate `Cargo.lock` wholesale. +- **Commits/PRs:** only when the user asks. Use the project's commit conventions. +- **Changes that belong to an earlier PR.** While implementing PR N you may discover a change that + logically belongs in an earlier PR's commit (M < N) — a durable field that should have been added + in PR 1, a wrong conversion in PR 2's scaffolding, a missing test. **Do not fold it silently into + the PR N commit.** Make it a **separate commit placed before** your PR N change, with a message + that names the PR it really belongs to (e.g. `fixup! `, or a subject like + `PR 1: ` so `git rebase --autosquash` / a later manual squash can land it). This keeps the + out-of-scope fix **visible and reviewable on its own** now, and lets us later squash it into the + PR-M commit it was meant to be in from the start. The PR N commit then stays focused on PR N's + scope. Note any such commit in the Progress Log so the eventual squash isn't forgotten. + +**Status legend:** `⬜ Not started` · `🚧 In progress` · `👀 In review` · `✅ Merged` + +--- + +## Context: starting point + +- There is no `mz-cluster-controller` crate, no controller module in the adapter, and none of + the autoscaling dyncfgs yet — we build from scratch, starting at PR 1. +- The model is **realized-fact** (per the design doc): `ALTER` writes a durable + `reconfiguration` record (target + deadline) and returns; `cluster.size` only advances at the + controller's cut-over. The records and their migration land in PR 1. + +--- + +## Architecture at a glance + +**Crate layout (target):** + +- `src/cluster-controller/` (`mz-cluster-controller`) — **pure** framework: the strategy + trait, the reconcile kernel (union desired contributions → diff vs actual → decisions), + the strategy implementations, and their unit tests. Minimal deps (ids, repr, controller + types for shapes); **no** adapter/catalog-writer deps. +- `src/adapter/src/coord/cluster_controller.rs` — the **driver/glue**: implements + `ClusterControllerCtx` over the catalog + live controller signals (the controller pulls), and + applies the emitted `Decision`s as catalog transactions under a compare-and-append guard. + +**The reconcile tick (per the design):** two phases separated by a barrier — +(1) run every strategy's `update_state`, transact the durable writes (cut-overs, record +writes/clears) and **await** confirmation; (2) run every strategy's `desired_replicas`, +union the contributions (implicit baseline included), diff against actual replicas, emit the +creates/drops that close the gap. Commands name **explicit replicas**; re-emission is +harmless (create-existing / drop-gone are no-ops). + +**The boundary — a clean, agnostic pull-interface (the most important thing to get right).** +The controller depends on one narrow trait (working name `ClusterControllerCtx`) and *pulls* +what it needs through it; the environment never guesses and pushes a snapshot. The trait is +**strategy-agnostic** — primitive signals in, primitive catalog mutations out — and carries +**no per-strategy state or vocabulary**: + +- reads: a consistent durable view of cluster + replica state; "are these collections on this + cluster hydrated on these replicas?"; collection write frontiers; a read timestamp; `now`. +- writes: "apply this catalog batch under a compare-and-append guard." + +This keeps the abstraction **zero-cost / pay-for-what-you-use**: a tick fetches only the +signals it actually examines (no eager all-clusters-all-replicas snapshot), and the controller +drives what is fetched. The controller crate knows nothing about the Coordinator; the +Coordinator implements the trait. That single seam is what makes the controller testable (drive +it against a fake impl) and extractable later (swap the impl for one backed by builtin-relation +subscriptions) without touching controller code. + +Keep two boundaries distinct: + +- **controller ↔ environment** = the `ClusterControllerCtx` trait (above). Design and test *here*. +- **controller ↔ strategy** = the pure strategy functions `update_state` / `desired_replicas` + over `(config, observed status, now)`. The controller assembles each strategy's inputs by + pulling through the ctx; strategies never touch the ctx. + +**Compare-and-append guard.** The Coordinator stays the sole catalog writer. Each applied batch +carries the controller's view of the durable cluster state it was derived from (config + +`reconfiguration` + `burst`); the Coordinator applies it only if that state still holds, so a +user `ALTER` that lands mid-tick rejects the stale batch and the controller recomputes next tick. + +**Gating model (how we land 7 PRs without changing prod behaviour until ready):** + +- `enable_cluster_controller` (master gate, default **false**). When false the controller + task is inert and **all legacy paths run** (3-stage graceful machine + `cluster_scheduling.rs`). + When true the controller owns the managed-cluster replica set and legacy paths are bypassed. +- Because the controller — when on — must own **baseline + graceful + on-refresh** coherently + (two writers of the replica set is not allowed), strategies land **dark** across PRs 2–6 (the + gate stays false in prod; tests force it true to exercise each strategy in isolation). When the + gate is on, the legacy entry points (graceful stage machine, `cluster_scheduling.rs` tick) + no-op, so flipping it is a clean switch. +- **Turning it on is operational, not a code change.** Once the whole feature (incl. burst) is in + `main` dark, we enable the gates at runtime via LaunchDarkly, roll out, and **bake in prod**. + The legacy paths stay in the binary so rollback is a flag flip. Only **after** a successful bake + does a final code PR (PR 7) flip the dyncfg defaults to true and delete the legacy paths (and + only then is it safe to drop `pending`). We never enable *and* remove-the-fallback in one step. +- This is intentional: we trade "incremental prod enablement per strategy" (two coexisting + replica-set writers) for "incremental, independently-reviewable PRs behind one gate, a runtime + flip we can roll back, and a cleanup that lands only once prod is happy." + +**Dyncfgs (final set; add as the relevant PR lands):** + +| Key | Type | Default | Introduced | Purpose | +|---|---|---|---|---| +| `enable_cluster_controller` | bool | false | PR 2 | Master gate: controller owns the replica set; legacy paths bypassed. | +| `cluster_controller_tick_interval` | Duration | (≈ today's scheduling interval) | PR 2 | Reconcile cadence (replaces `cluster_check_scheduling_policies_interval`). | +| `enable_background_alter_cluster` | bool | false | PR 3 | When true `ALTER` returns immediately; when false the session wait-shim blocks (foreground UX) over the same durable mechanism. | +| `default_cluster_reconfiguration_timeout` | Duration | (system default) | PR 3 | Deadline written when an `ALTER` omits `WITH (WAIT ...)`. | +| `enable_auto_scaling_strategy` | bool | false | PR 6 | Gates `AUTO SCALING STRATEGY` SQL acceptance. | +| `enable_hydration_burst` | bool | true (at GA) | PR 6 | Break-glass: set false to disable the burst strategy env-wide without touching graceful/on-refresh. | + +Defaults stay as above (the off ones off) in code until **PR 7**; enabling in prod is a runtime +LaunchDarkly flip, not a default change. + +--- + +## Cross-cutting decisions to confirm + +These shape multiple PRs. A recommendation is given for each; confirm with the user before +building where the choice is genuinely theirs. + +1. **The `ClusterControllerCtx` interface + execution placement.** The controller pulls signals + through the agnostic trait (see *The boundary* above) and never receives a pushed snapshot. + *Open within that:* where the trait impl runs. The signals live on coordinator-owned + compute/storage controllers reachable only from its loop, so the impl either (a) runs the + controller as a **separate task** whose ctx calls marshal to the Coordinator over a channel + (use **batch** pull methods to bound round-trips), or (b) drives the controller from a tick + **on the coordinator loop** with the ctx as direct calls (truly zero-cost, but occupies the + loop for the tick). The trait makes this reversible. *Recommend* (a) to honour the design's + separate-task intent; pick in PR 2. Either way, controller code is written only against the trait. +2. **Compare-and-append mechanism.** *Recommend:* the apply path re-reads each target cluster's + durable config + records and rejects the batch if it differs from the controller's carried + view (`expected`), then the controller recomputes next tick. Could be a new `Op` precondition + or a check in `apply_cluster_decisions`. Resolve in PR 2. +3. **Where the new records live.** *Recommend:* add `auto_scaling_strategy`, `reconfiguration`, + `burst` to durable `ClusterVariantManaged` (managed-only; cut-over already rewrites this struct + via `Op::UpdateClusterConfig`). Resolve in PR 1. +4. **`ReconfigurationState.target` shape.** *Recommend:* a struct carrying `size`, + `replication_factor`, `availability_zones`, `logging` (the full config-shape the cluster is + moving to, so a combined size+rf+AZ change is one record). Resolve in PR 1. +5. **Burst-replica identity — not needed.** A burst replica is just a replica; the union/diff + reconciler handles it without any tag or label. A replica survives iff *some* strategy desires + a slot of its shape this tick, and the controller drops to the desired count by shape, picking + any excess replica — it never needs to know "which one was the burst replica." Abandoned + re-target replicas are dropped only when no strategy desires their shape (so if burst still + wants that shape, the replica is simply reused — fine). Audit attribution ("which strategies + desired this create") is computed per-tick from the current desired set, not stored. So **no + durable marker** is needed; this drops out of PR 1 and PR 6. +6. **Naming.** Design Open Question 7. *Recommend:* "cluster controller" / `mz-cluster-controller` + (matches the design's lean). Alternatives: `ClusterReconciler`, `ClusterScheduler`. +7. **Timing of the non-inert changes** (`pending: bool` removal; durable `replication_factor`→0 + for scheduled clusters). Neither can ride PR 1: removing `pending` breaks the legacy stage + machine, and normalizing rf while the legacy scheduler still toggles it would just be undone. + *Recommend:* PR 1 holds only **additive, inert** durable changes; the controller normalizes + scheduled-cluster rf at runtime when enabled (PR 5 — self-healing, no migration); and the + `pending` drop rides the **final cleanup PR (7)**, after legacy removal. + +--- + +## Codebase anchors + +Verified against the tree on 2026-06-01 unless marked *(approx)*. **Re-verify line numbers +before relying** — they drift. + +**Durable catalog state & migrations** +- Durable cluster config: `src/catalog/src/durable/objects.rs` — `ClusterConfig` (335), `ClusterVariant` (341), `ClusterVariantManaged` (347–354). +- Durable replica location: same file — `ReplicaLocation::Managed { size, availability_zone: Option, internal, billed_as, pending }` (470–483). `availability_zone` is the single user-pin; the **provisioned AZ list** must be added here. +- In-memory mirrors: `src/catalog/src/memory/objects.rs` — `ClusterConfig` (≈3253), `ClusterVariantManaged` (≈3286). *(approx)* +- Proto: `src/catalog-protos/src/objects.rs` — `ManagedCluster`, `ManagedLocation`, `ClusterSchedule` *(approx)*; `.proto` sources under `src/catalog-protos/protos/`. +- Version: `src/catalog-protos/src/lib.rs` — `CATALOG_VERSION = 85`, `MIN_CATALOG_VERSION = 74`. **Next migration is v85→v86.** +- Migration framework: `src/catalog/src/durable/upgrade.rs` (recipe in the module header, `run_upgrade` dispatch, `MigrationAction`); per-version modules `src/catalog/src/durable/upgrade/vN_to_vN+1.rs` (latest `v84_to_v85.rs`); encodings under `.../upgrade/snapshots/`. Generate with `cargo test -p mz-catalog --lib durable::upgrade::tests::generate_missing_encodings -- --ignored`. + +**Graceful reconfiguration (legacy, to be bypassed then removed)** +- `src/adapter/src/coord/sequencer/inner/cluster.rs`: `PENDING_REPLICA_SUFFIX` (50); 3-stage machine — Stage 1 create (≈148+, pending replicas at ≈1129), Stage 2 `check_if_pending_replicas_hydrated_stage` (≈488), Stage 3 `finalize_alter_cluster_stage` (≈362, strip suffix at 441); `AlterClusterWhilePendingReplicas` raised at ≈1063. +- `src/adapter/src/coord.rs`: `enum ClusterStage` (818) with `WaitForHydrated`/`Finalize` structs (≈825–846); `ConnMeta.pending_cluster_alters` (≈1226). *(approx)* +- Plan/AST: `AlterClusterPlan`, `AlterClusterPlanStrategy` (None/For/UntilReady), `OnTimeoutAction` in `src/sql/src/plan.rs` *(approx)*; cluster options AST `ClusterOptionName` in `src/sql-parser/src/ast/defs/statement.rs` *(approx)*; planning in `src/sql/src/plan/statement/ddl.rs` (`plan_create_cluster*`, `plan_alter_cluster`) *(approx)*; gate `ENABLE_ZERO_DOWNTIME_CLUSTER_RECONFIGURATION`. + +**Scheduling (legacy, to be ported then removed)** +- `src/adapter/src/coord/cluster_scheduling.rs`: `check_scheduling_policies` / `check_refresh_policy`, `SchedulingDecision::Refresh(RefreshDecision)`, `handle_scheduling_decisions` (rf toggled 0↔1; swallows `AlterClusterWhilePendingReplicas`). *(approx)* +- `src/adapter/src/coord.rs`: `Message::CheckSchedulingPolicies` (414), `Message::SchedulingDecisions` (420), `check_cluster_scheduling_policies_interval` (1966; tick 3683; init 4734). + +**Hydration / frontier signals (controller inputs)** +- Compute: `ComputeController::collections_hydrated_for_replicas(&self, instance_id, replicas, exclude) -> oneshot::Receiver` — `src/compute-client/src/controller.rs` (≈421). Takes `&self`. +- Storage: `StorageController::collections_hydrated_on_replicas(&self, replicas, cluster_id, exclude) -> Result` — `src/storage-client/src/controller.rs` (≈334). Takes `&self`. +- Frontiers: `collection_frontiers(&self, ...)` on both controllers. The legacy wait stage calls these at `cluster.rs` ≈548–558. +- Controllers are owned by `Coordinator.controller: mz_controller::Controller` (`src/controller/src/lib.rs` ≈148). Reachable from the coordinator loop only — so the `ClusterControllerCtx` impl backs the hydration/frontier reads from there (decision 1). + +**Coordinator wiring & dyncfgs** +- Main loop `serve` + biased `select!`: `src/adapter/src/coord.rs` (≈3483+); `internal_cmd_tx: mpsc::UnboundedSender` (≈1848). Background-task pattern: `mz_ore::task::spawn`, clone `internal_cmd_tx`, send a `Message` (see storage-usage collection in `message_handler.rs`). Oneshot request/response: `Command { tx: oneshot::Sender<_> }` in `src/adapter/src/command.rs`. +- Catalog ops: `Op` enum + `transact(...)` in `src/adapter/src/catalog/transact.rs` (`Op::UpdateClusterConfig` ≈220; `ReplicaCreateDropReason` ≈311; `into_audit_log` ≈322). +- Dyncfg: define in `src/adapter-types/src/dyncfgs.rs` (`Config::new(name, default, desc)`), register in `all_dyncfgs()`, read via `KEY.get(self.catalog().system_config().dyncfgs())`. + +**Builtins / observability / audit** +- Builtin defs: `src/catalog/src/builtin/mz_catalog.rs` (`MZ_CLUSTERS` ≈1804, `MZ_CLUSTER_REPLICAS` ≈1976) and `src/catalog/src/builtin/mz_internal.rs` (`MZ_SHOW_CLUSTERS` ≈4806 — this is what `SHOW CLUSTERS` selects from). `SHOW CLUSTERS` SQL template: `src/sql/src/plan/statement/show.rs` `show_clusters` (≈755). *(approx)* +- Builtin tables are catalog-populated (rows written where catalog state is reflected to builtin tables); builtin views are pure SQL. New builtins need no migration; **changing** an existing builtin needs a step in `src/adapter/src/catalog/open/builtin_schema_migration.rs`. Builtin dependency ordering in `BUILTINS_STATIC` is enforced by a test. +- Audit: `src/audit-log/src/lib.rs` — `VersionedEvent`, `EventDetails`, `CreateClusterReplicaV4` (≈559), `DropClusterReplicaV3` (≈460), `SchedulingDecisionsWithReasonsV2` (≈626). New reason variants are added to `CreateOrDropClusterReplicaReasonV1` + `ReplicaCreateDropReason`. + +--- + +## PR sequence overview + +| PR | Title | Maps to user's bucket | Gate state | Catalog migration | +|---|---|---|---|---| +| **1** | Durable state model + migration (additive, inert) | durable state | n/a (dark by being unused) | v85→v86 (additive) | +| **2** | Controller scaffolding + baseline strategy + coordinator wiring + CaA | controller scaffolding | adds `enable_cluster_controller` (off) | none | +| **3** | Graceful reconfiguration strategy + `ALTER` reshape + wait-shim + hydration input | move graceful over | dark behind master gate | none | +| **4** | Observability: introspection view + `SHOW CLUSTERS` + reconfig audit | (supports graceful) | dark (no records until enabled) | none | +| **5** | `ON REFRESH` scheduling as a strategy | move scheduling over | dark behind master gate | none | +| **6** | Hydration burst: `AUTO SCALING STRATEGY` SQL + burst strategy + break-glass (last **feature** PR) | add burst (last) | adds `enable_auto_scaling_strategy` / `enable_hydration_burst` (off) | none | +| — | **Operational rollout** (not a PR): enable the gates at runtime via LaunchDarkly; bake in prod | turn it on | runtime flip — legacy stays as fallback | none | +| **7** | Flip dyncfg defaults to true + remove legacy paths (only after prod bake) | the cleanup | defaults → on | drop `pending` | +| **8** | Showcase follow-ups: `retired` drop reason, rollback-at-deadline record clear + `timed-out` audit event, burst arming on object existence | polish from live testing | dark behind master gate | none | +| **9** | Restore the on-refresh `scheduling_policies` audit detail on creates | audit fidelity | dark behind master gate | none | + +Splitting/merging notes: PR 3 is the largest and may split into **3a** (strategy + hydration +input + record handling, controller side) and **3b** (`ALTER` SQL reshape + wait-shim + audit +reason). PR 4 may merge into PR 3 if you want graceful + its observability in one review. PR 6 +may split into **6a** (SQL surface + validations) and **6b** (burst strategy + observability). + +--- + +## PR 1 — Durable state model + migration + +**Status:** 👀 In review + +**Goal.** Add every *additive, behaviourally-inert* durable field the controller will need, +with one catalog migration (v85→v86) defaulting them for existing clusters. No reads of the +new fields yet → no behaviour change. + +**Scope (in).** +- New durable + in-memory + proto types and their conversions: + - `AutoScalingStrategy { on_hydration: Option }> }` — extensible (a struct/list so future strategies slot in). User-configured *policy*. + - `ReconfigurationState { target: ReconfigurationTarget, deadline: mz_repr::Timestamp, on_timeout: OnTimeoutAction }`, where `ReconfigurationTarget { size, replication_factor, availability_zones, logging }` (decision 4) and `on_timeout` is the `COMMIT`/`ROLLBACK` action applied if the deadline passes un-hydrated (default `ROLLBACK`). *(The `on_timeout` field was added after PR 1's initial commit, in the PR 3 design refinement; it lands as a `fixup!` against PR 1's catalog commit — v86 is unshipped, so the proto is revised in place — per the fixup-commit convention.)* + - `BurstState { burst_size: String, linger_duration: Duration, steady_hydrated_at: Option }`. + - Add the three as `Option<...>` fields on `ClusterVariantManaged` (decision 3), `None` by default. +- **Provisioned AZ list on managed replicas:** collapse durable `ReplicaLocation::Managed`'s single `availability_zone` user-pin into an `availability_zones: Vec` recording the zones the replica was provisioned under — a managed cluster's `AVAILABILITY ZONES` pool, or an unmanaged replica's pin as a zero-/one-element list. Backfill existing managed replicas from their cluster's current `availability_zones` and unmanaged-cluster replicas from their pin. (Needed so the controller can tell realized- from target-shape replicas by config shape, including AZ divergence.) With the durable field now storing the list unconditionally, the in-memory `ManagedReplicaAvailabilityZones` enum is collapsed in the same change to a bare `Vec` (empty = no constraint), so the in-memory to durable `From` becomes a passthrough. +- Migration `v85_to_v86.rs`: snapshot proto, bump `CATALOG_VERSION`, default new fields to `None`/empty, backfill the AZ list, generate encodings. Thread the new fields through all `From`/`RustType` conversions and any exhaustive matches. + +**Scope (out).** No reads of the new fields. **Not** here: `replication_factor` normalization +and `pending` removal (decision 7 → PR 7). No SQL surface for `AUTO SCALING STRATEGY` (PR 6). +No builtin/`mz_clusters` exposure (PR 4). + +**Verification.** `cargo fmt`; `cargo check -p mz-catalog -p mz-catalog-protos -p mz-adapter`; +catalog upgrade unit tests + `generate_missing_encodings`; confirm the round-trip +(`from_proto(to_proto(x)) == x`) holds for migrated rows. + +**Acceptance criteria.** Builds; all existing tests pass; a catalog opened at v85 upgrades to +v86 with new fields defaulted and managed replicas' AZ lists backfilled; no behaviour change. + +**Checklist.** +- [x] Decide records placement (3 — on durable `ClusterVariantManaged`), target shape (4 — `ReconfigurationTarget { size, replication_factor, availability_zones, logging }`). +- [x] Add types (durable, memory, proto) + conversions for `AutoScalingStrategy`/`OnHydration`, `ReconfigurationState`/`ReconfigurationTarget`, `BurstState`. +- [x] Collapse durable `ReplicaLocation::Managed` `availability_zone` into `availability_zones: Vec` and the in-memory `ManagedReplicaAvailabilityZones` enum into a bare `Vec` (empty = no constraint). Update all construction and conversion sites. The in-memory to durable `From` is a passthrough. Concretize re-derives the managed pool from the cluster on create and reshape, keeps the durable provisioned list on rebuild, and reads the list as the pin for unmanaged clusters. +- [x] Write `v85_to_v86.rs`; bump `CATALOG_VERSION` to 86; snapshot proto (`objects_v86.rs` + hashes); backfill AZ list; generate encodings (`objects_v86.txt`). +- [x] `cargo fmt` + `cargo check -p mz-catalog -p mz-catalog-protos -p mz-adapter` clean; catalog-protos snapshot tests + catalog durable/upgrade tests pass (incl. four new migration tests and `proptest_state_update_kind_roundtrip`). +- [x] Update this tracker (status + Progress Log). + +--- + +## PR 2 — Controller scaffolding + baseline strategy + coordinator wiring + +**Status:** 👀 In review + +**Goal.** Stand up the controller end-to-end with **only the implicit baseline strategy**, so +the loop runs but is a no-op for steady-state clusters. Establish the task boundary, the +input/decision types, the compare-and-append apply path, and the master gate — all dark. + +**Scope (in).** +- New crate `mz-cluster-controller` (`src/cluster-controller/`): add to workspace, `deny.toml`/`about.toml` if new licenses. + - **`ClusterControllerCtx` trait** — the agnostic pull/apply interface (reads: durable cluster+replica view, hydration of collections on replicas, frontiers, read-ts, `now`; write: apply a CaA-guarded batch). This is the PR's centerpiece — design it carefully. Baseline needs only the durable view, so the hydration/frontier methods exist but go unused until PR 3. + - Pure strategy trait: `update_state(config, status, now) -> Vec` and `desired_replicas(config, status, now) -> Vec`. + - Reconcile kernel: pull current state via the ctx → run strategies → union desired contributions (baseline included) → match-by-shape against actual → emit `Decision::{CreateReplica { name, config, reasons }, DropReplica { id, reasons }, UpdateClusterState { expected, writes }}` → apply via the ctx. Attribution (which strategies desired a create) is computed here, per tick. + - **Implicit baseline strategy:** desires `replication_factor` replicas at `cluster.size` with the cluster's shape. Baseline-only ⇒ desired == realized ⇒ no decisions in steady state. +- Adapter driver `src/adapter/src/coord/cluster_controller.rs`: + - Implement `ClusterControllerCtx` on the Coordinator side; drive the controller per decision 1 (separate task with batched marshaling, or on-loop tick) at `cluster_controller_tick_interval`. + - The ctx apply method transacts `update_state` writes (await), then create/drop, under the **compare-and-append guard** (decision 2) — reject + recompute next tick on mismatch. + - Master gate `enable_cluster_controller` (off): when off, the controller is inert; legacy paths untouched. + +**Scope (out).** No hydration input yet (baseline doesn't need it; PR 3). No graceful/on-refresh/burst +strategies. No legacy removal. No SQL changes. + +**Verification.** `cargo fmt`; `cargo check -p mz-cluster-controller -p mz-adapter -p mz-adapter-types`. +Boundary tests: drive the controller against a **fake `ClusterControllerCtx`** to assert the +reconcile loop is a no-op for a steady cluster and that a CaA conflict is rejected and recovered. +User-visible: an integration test that force-enables the gate and asserts a steady managed cluster +sees **zero** controller-initiated replica changes. A couple of kernel unit tests for the multiset +union/diff only. + +**Acceptance criteria.** With the gate off, behaviour is identical to today. With the gate forced +on in a test, the controller reconciles a steady managed cluster to a no-op and a CaA conflict is +rejected and recovered on the next tick. + +**Checklist.** +- [x] Resolve decisions 1, 2, 6. (1 — separate task; the `CoordCtx` marshals each batched pull/apply to the coordinator over `internal_cmd_tx` + oneshot. 2 — each `UpdateClusterState` carries an `ExpectedClusterState`; the apply path re-reads each cluster and rejects the whole batch on mismatch. 6 — `mz-cluster-controller` / "cluster controller".) +- [x] Create `mz-cluster-controller` crate (workspace + default-members; no new third-party deps so `deny.toml`/`about.toml` unchanged); the `ClusterControllerCtx` trait, pure `Strategy` trait, `Decision`, reconcile kernel (multiset union = max-per-shape, match-by-shape diff, attribution). +- [x] Implement baseline strategy (`replication_factor` replicas at the realized shape). +- [x] Adapter driver `coord/cluster_controller.rs`: implement `ClusterControllerCtx` on the Coordinator (`observe_cluster_state` read; `apply_cluster_decisions` builds `Op::UpdateClusterConfig` + `Op::CreateClusterReplica` + `Op::DropObjects`); drive the controller as a separate task; CaA-guarded apply. +- [x] Add `enable_cluster_controller` (off) + `cluster_controller_tick_interval` dyncfgs (registered in `all_dyncfgs`). +- [x] Boundary tests against a fake ctx (steady no-op, under/over-provision, wrong-shape, union max-not-sum, distinct-shape attribution, CaA-reject + recover) + gate-on testdrive no-op test (`test/testdrive/cluster-controller.td`, authored for CI). +- [x] `cargo fmt`/`check`/`clippy` clean on `mz-cluster-controller`/`mz-adapter`/`mz-adapter-types`; controller unit tests pass; update tracker. + +--- + +## PR 3 — Graceful reconfiguration strategy + `ALTER` reshape + wait-shim + +**Status:** 👀 In review — implementation + review landed (commits `8022d9a`, `d7d0254`); the +2026-06-02 design refinement (durable, controller-honored `ON TIMEOUT`, default `ROLLBACK`) is now +implemented (the three reopened checklist items below are done). + +**Goal.** Move graceful (zero-downtime) reconfiguration into the controller as a strategy, +driven by the durable `reconfiguration` record, with hydration-aware cut-over and timeout — +all dark behind the master gate; legacy 3-stage machine still runs when the gate is off. + +**Scope (in).** +- **Implement the hydration/frontier ctx methods** (first hydration-dependent strategy): back `ClusterControllerCtx`'s hydration query with `collections_hydrated_for_replicas` / `collections_hydrated_on_replicas` (and frontiers as needed), pulled on demand — the controller asks only about the replicas a tick examines. This is the seam stubbed in PR 2. +- `GracefulReconfigurationStrategy` (pure): + - Engaged when `reconfiguration` record is present. + - `desired_replicas`: `target.replication_factor` replicas at `target` shape (size + logging + AZ list). + - `update_state`: target replicas present **and** hydrated → cut over (`cluster.size := target.{size,...}`, clear record); success precedence holds even past the deadline. Otherwise once `now > deadline` and not yet hydrated, apply the record's `on_timeout`: **`ROLLBACK`** (default) → drop the whole target set, **retain record as tombstone**, stop contributing (parked); **`COMMIT`** → advance `cluster.size` to the target and clear the record anyway. Emit an audit event recording the action. + - Diff on size + logging + **AZ list** (now diffable thanks to PR 1) + count. +- **`ALTER CLUSTER` reshape (gated):** when the master gate is on and the change is a config-shape change (size/logging/AZ), write the `reconfiguration` record (target + deadline + on_timeout) in one txn and return; leave realized config. Once a record is present, further `ALTER`s **fold into it** (overwrite target + deadline + on_timeout). Non-shape changes (rf-only, workload_class) with no record in flight update realized config directly (as today). Deadline + on-timeout come from the **existing** `WITH (WAIT ...)` surface (kept verbatim — no new token): `WAIT UNTIL READY (TIMEOUT '', ON TIMEOUT COMMIT|ROLLBACK)` → `deadline = txn_ts + timeout`, `on_timeout` as given; `WAIT FOR ''` ≡ `UNTIL READY (TIMEOUT '', ON TIMEOUT COMMIT)`; omitting `WAIT` → `default_cluster_reconfiguration_timeout` + default `ROLLBACK`. **Flip the planner's implicit `ON TIMEOUT` default `COMMIT`→`ROLLBACK` globally** (`OnTimeoutAction::default()`), which also changes the legacy foreground default — the safe, no-surprise-downtime default. **Keep the legacy 3-stage path for gate-off** (don't delete yet — PR 7). +- **Wait-shim:** `enable_background_alter_cluster` off (or foreground UX during rollout) → the session polls the durable `reconfiguration` record (cleared = done; `now > deadline` = timed out) up to its own wait. On → `ALTER` returns immediately. (Polls the record directly so this PR doesn't depend on PR 4's view. Session disconnect no longer aborts the reconfiguration.) +- **Audit:** `ReplicaCreateDropReason::GracefulReconfiguration` → new `CreateOrDropClusterReplicaReasonV1::Reconfiguration`, carried on the controller's create/drop events. + +**Scope (out).** No on-refresh/burst. No legacy removal. Rich observability (`SHOW CLUSTERS`, +introspection view) is PR 4. + +**Verification.** User-visible first (sqllogictest/testdrive, gate forced on): background `ALTER` +returns immediately / foreground shim waits; replicas transition and cut-over advances `cluster.size`; +`SHOW`/introspection reflect target then realized; timeout leaves a tombstoned record and the +realized set. Platform-check: a mid-flight reconfiguration survives an `environmentd` restart. +Targeted kernel unit tests only for the tricky cases (timeout-vs-hydrated precedence, +refold/ALTER-back, AZ-only vs size+AZ). + +**Acceptance criteria.** With the gate off, legacy graceful reconfiguration is unchanged. With the +gate forced on, a background `ALTER` returns immediately, the controller converges/cuts over, +timeouts park as tombstones, and the flow survives restart. + +**Checklist.** +- [x] Implement the hydration method of `ClusterControllerCtx` (pulled on demand). Reshaped the speculative PR-2 stub `collections_hydrated_on_replicas(cluster, replicas, collections) -> bool` into `hydrated_replicas(cluster, replicas) -> BTreeSet` (per-replica "all current collections hydrated"), backed by `collections_hydrated_for_replicas`/`collections_hydrated_on_replicas` with an empty exclude set. (Frontier/read-ts reads still land with their first consumer, PR 5.) +- [x] Implement `GracefulReconfigurationStrategy` (pure); targeted kernel tests for the tricky cases (timeout-vs-hydrated precedence, partial-hydration, AZ-only shape change, full overlap→cut-over, ALTER-back no-churn). +- [x] Reshape `ALTER CLUSTER` (gated): write/fold `reconfiguration` record; keep legacy path for gate-off; timeout/deadline resolution + dyncfg default. +- [x] Wait-shim polling the record; `enable_background_alter_cluster` dyncfg. +- [x] Audit reason variant (`Reconfiguration`) on create (graceful-desired); old-set drops at cut-over are `Manual` (none-desired), with richer drop-lifecycle attribution deferred to PR 4. +- [x] Integration test authored (`cluster-controller.td`, gate + background forced on); platform-check **deferred** (see Progress Log). +- [x] `cargo fmt`/`check`/`clippy` clean; update tracker. + +Reopened by the 2026-06-02 design refinement (the durable `on_timeout` knob): +- [x] Add `on_timeout: OnTimeoutAction` to durable `ReconfigurationState` — landed as a `fixup!` against PR 1's catalog commit (v86 unshipped → proto revised in place: `ReconfigurationState` field + mirrored `OnTimeoutAction` proto enum + `RustType` conversion; durable/memory mirrors threaded; `OnTimeoutAction` gained serde/ordering derives, shared by both layers like `ClusterSchedule`; v86 encoding snapshot regenerated). Per the fixup-commit convention. +- [x] Honor `on_timeout` in `GracefulReconfigurationStrategy::update_state` (`ROLLBACK` = drop target set + tombstone; `COMMIT` = cut over un-hydrated and clear); kernel tests for `COMMIT`-on-timeout vs `ROLLBACK`-on-timeout (and an overlap-before-deadline parity case). Audit: the action is recorded through the existing reason-carrying create/drop + cut-over ops; the dedicated deadline-carrying *timeout-fired* lifecycle event stays with PR 4's reconfiguration audit lifecycle (see Deferred). +- [x] Flipped planner `OnTimeoutAction::default()` `COMMIT`→`ROLLBACK` (global; also changes the legacy foreground default, which reads the same `default()`); threaded `on_timeout` from the `WITH (WAIT ...)` plan into the written record (a fold overwrites it with the latest `ALTER`'s); `WAIT FOR` desugars to `ON TIMEOUT COMMIT`; no `WAIT` → default `ROLLBACK`. Extended `cluster-controller.td` (gate + background on) to assert the omitted-`ON TIMEOUT` default and both explicit actions drive a record under the gate (authored for CI). + +**Deferred (with reasons).** +- **No new `WITH (TIMEOUT = ...)` token (settled — *not* deferred).** Earlier the implementation deferred a new top-level token to PR 6; per the 2026-06-02 design refinement we keep the existing `WITH (WAIT ...)` surface **permanently** as the only spelling — it already expresses both the deadline (`TIMEOUT`) and the on-timeout action (`ON TIMEOUT`), so a second token would only fragment it. The timeout value already flows from the `WAIT` plumbing; no parser work remains. See the design doc's *Per-`ALTER` timeout* section. +- **Restart-survival platform-check.** The controller is dark by default; a platform-check would have to `ALTER SYSTEM SET enable_cluster_controller = true` env-wide, which would change behavior for **every other check** in the shared suite (the controller would own all replica sets) while the feature is dark. Survival across restart is guaranteed by construction (the `reconfiguration` record is durable catalog state) and is exercised by the controller tests + the slt; a dedicated restart test belongs with the rollout enablement, not the dark suite. +- **Dedicated *timeout-fired* audit event (with the active deadline).** The on-timeout action is already attributable through the existing reason-carrying ops (a `COMMIT` cut-over via `Op::UpdateClusterConfig`; a `ROLLBACK` drop via `Op::DropObjects`, none-desired). A distinct cluster-level *timeout-fired* event recording the action and the active deadline is part of PR 4's reconfiguration audit *lifecycle* (started / finalized / cancelled / timeout-fired), which owns the audit-event surface; adding it here would duplicate that work and split the event family across two PRs. +- **Deterministic ROLLBACK-vs-COMMIT-at-timeout slt.** A timeout-park requires a target that does **not** hydrate before its deadline, but an empty slt cluster hydrates promptly (success precedence then cuts over regardless of the action). The action's behavior *at* a timeout is asserted deterministically in the controller kernel tests (`graceful_commit_on_timeout_cuts_over_unhydrated`, `graceful_timeout_parks_and_drops_target`), where hydration does not race the deadline; the slt asserts only that the three spellings (omitted/`ROLLBACK`/`COMMIT`, plus `WAIT FOR`) are accepted under the gate and drive a record. + +> **Superseded:** the implementation's "`ON TIMEOUT COMMIT` collapsed into the tombstone-revert model" +> deferral no longer holds — `on_timeout` is now an honored durable knob (the three reopened +> checklist items above), with the default flipped to `ROLLBACK`. `COMMIT` is no longer silently +> treated as `ROLLBACK`. + +--- + +## PR 4 — Observability: introspection view + `SHOW CLUSTERS` + audit + +**Status:** 👀 In review — implementation + review follow-up landed on `cluster-autoscaling`. +Introspection table + `SHOW CLUSTERS` extension + reconfiguration audit lifecycle, all dark +(records stay `None` until the controller is enabled). The review follow-up adds the `cancelled` +lifecycle transition (ALTER-back to the realized shape), corrects the `finalized`-vs-`timed-out` +classification (a `ROLLBACK` record only ever clears on a hydrated success, so it is never +mislabeled `timed-out`; the residual `COMMIT`-late-success imprecision is documented), fixes the +`belongs_to_cluster` ontology cardinality to one-to-one, regenerates the unshipped-`v86` proto +snapshot so the new audit variant round-trips, and updates the `canary-clusters.td` `SHOW CLUSTERS` +row for the new columns. The `ROLLBACK`-timeout audit event remains deferred with a reason (see +Deferred); the other lifecycle transitions are covered. A later follow-up (2026-06-03, same +branch) reworked the introspection relation from the imperatively-packed `BuiltinTable` into a +`BuiltinMaterializedView` over `mz_internal.mz_catalog_raw` (plus a `mz_catalog_server` index), +following the move off imperative builtin-table packing for catalog-derived relations — schema, +ontology, and dark behavior unchanged. See the Progress Log. + +**Goal.** Make in-flight reconfigurations observable in SQL, so background `ALTER` (PR 3) is +usable and validatable. + +**Scope (in).** +- Surface the durable `reconfiguration` record to SQL: catalog-populate a new builtin **table** + (working name `mz_internal.mz_cluster_reconfigurations`) with realized vs. target shape, + replication factor, in-flight flag, active deadline, and (placeholder columns for) burst — fed + from the new durable fields where `mz_clusters` rows are built. Add a user-facing **view** if a + friendlier shape is wanted. +- Extend `MZ_SHOW_CLUSTERS` view SQL to join the new relation so `SHOW CLUSTERS` answers + "what did I ask for / what's there now / in progress, done, or timed out" — including the + current (realized) size and the target size when a reconfiguration is in flight. +- Round out reconfiguration audit lifecycle (started / replica created / replica dropped / + finalized / cancelled / timeout-fired) using the reason-carrying events; record the active + deadline on start/timeout events. + +**Scope (out).** Burst columns are placeholders here; populated in PR 6. + +**Verification.** Testdrive: query the view and `SHOW CLUSTERS` before/during/after a forced-on +reconfiguration and at timeout; assert audit-log rows. Builtin-migration test green (new builtins +need no migration; ordering test passes). + +**Acceptance criteria.** During a (forced-on) background reconfiguration, the view and +`SHOW CLUSTERS` show current vs. target and an in-flight/timed-out indicator; audit log captures +the lifecycle. + +**Checklist.** +- [x] Add the introspection relation; derive it from the durable records. (`mz_internal.mz_cluster_reconfigurations`: realized vs. target size/rf/AZ list, in-flight flag, active deadline, placeholder `burst_size`. New builtin → no migration. No separate user view added — the relation is the introspection surface and `SHOW CLUSTERS` is the friendly shape. **Reworked 2026-06-03** from an imperatively-packed `BuiltinTable` into a `BuiltinMaterializedView` over `mz_internal.mz_catalog_raw` (with a companion `mz_catalog_server` index), matching the convention of moving catalog-derived relations off imperative builtin-table packing onto views over the raw catalog — schema/ontology unchanged, dark behavior preserved. See the Progress Log. **Redesigned 2026-06-12** into two sparse, JSON-forward relations (a row only while active): `mz_cluster_reconfigurations` keeps its name/OID/index but is reshaped to `cluster_id`, `deadline`, `on_timeout`, and a `jsonb` `target`, dropping the realized-mirror columns (`mz_clusters` already holds the realized config); the new `mz_cluster_auto_scaling_strategies` carries the configured policy and in-flight `state` as JSON. JSON keeps the schema stable as strategies grow.) +- [x] Extend `MZ_SHOW_CLUSTERS` SQL; keep `show.rs` template pointing at the view. (LEFT JOINs the new table to add `current_size`, `target_size`, `reconfiguration_in_flight`; `show.rs` projects the new columns. The view stays **non-temporal** — the indexed `mz_show_clusters` cannot use `mz_now()`, so the timed-out-vs-in-progress split is read from `mz_cluster_reconfigurations.reconfiguration_deadline`, not computed in the view. **Redesigned 2026-06-12**: the four added columns collapse to a single nullable `activity` column summarizing any in-flight reconfiguration or burst, `NULL` when steady; still non-temporal.) +- [x] Reconfiguration audit lifecycle events (with deadline on start/timeout/cancel). (New `EventDetails::AlterClusterReconfigurationV1` with a `started`/`finalized`/`timed-out`/`cancelled` transition + target size/rf + optional deadline; proto variant added in place to the unshipped v86 (`objects.rs` + `objects_v86.rs`, hashes regenerated, `v86` snapshot regenerated) with `RustType` conversions. Emitted from the `Op::UpdateClusterConfig` durable transition, classified purely from the before/after `reconfiguration` record + the realized shape + the write timestamp vs. the deadline — covers record-write/re-target (`started`, with deadline), re-target *back* to the realized shape (`cancelled`, with deadline), success cut-over (`finalized`), and `COMMIT`-on-timeout cut-over (`timed-out`, with deadline). A `ROLLBACK` record only ever clears on a hydrated success (rollback never clears on a timeout), so it is classified `finalized` regardless of the deadline; only a `COMMIT` clear past the deadline is `timed-out`. The deadline is a heuristic under `COMMIT`: a hydrated-late `COMMIT` success is indistinguishable from a timeout-committed un-hydrated target at the agnostic apply site and surfaces as `timed-out` (documented on the event variants and asserted in the unit test). Replica create/drop attribution (`Reconfiguration`) already lands from PR 3. The `ROLLBACK`-timeout event is deferred, see below.) +- [x] Testdrive + audit assertions. (Authored for CI: `cluster-controller.td` gains an observability section asserting the introspection table + `SHOW CLUSTERS` shape on a steady and a reconfigured cluster, the audit lifecycle rows for a success (`started`+deadline, `finalized`) and for an ALTER-back cancel (`started`, `cancelled`, `finalized`); `show_clusters.slt` asserts the new gate-off columns are benign; `canary-clusters.td` updated for the new `SHOW CLUSTERS` columns. A `classify_reconfiguration_transition` unit test in `mz-adapter` covers started/finalized/timed-out/cancelled/re-target/no-op deterministically, including the `ROLLBACK`-late-success and the documented `COMMIT`-late-success imprecision.) +- [x] `cargo fmt`/`check` clean; update tracker. + +**Deferred (with reasons).** +- **`ROLLBACK`-timeout audit event.** The lifecycle events are emitted by classifying the durable + `reconfiguration` before/after at the single `Op::UpdateClusterConfig` write site. A `ROLLBACK` + timeout performs **no config write** — the strategy's `update_state` returns + `StateWrite::default()`, the record is retained as a tombstone unchanged, and only the in-flight + target replicas are dropped (none-desired). With no config transition to hang the event off, a + dedicated `timed-out (rollback)` event would need either a fire-once signal threaded through the + controller `StateWrite` seam (widening the agnostic interface with audit-only vocabulary) or a + durable tombstone-stamp on the record (a PR-1 schema change). Both are larger than PR 4's + observability scope. The rollback is already observable: the tombstoned record (past deadline, + `reconfiguration_in_flight = true`) surfaces in `mz_cluster_reconfigurations` and `SHOW CLUSTERS`, + and the target-set drops carry the none-desired reason. Lands with the burst lifecycle (PR 6) or + a focused follow-up once the seam shape for it is settled. **→ Closed by PR 8b**, which makes the + rollback a durable config write after all: the strategy clears the record at the deadline (no + tombstone retained), and the clear-without-cut-over classifies `timed-out`. +- **Live `mz_now()`-based timed-out indicator in `SHOW CLUSTERS`.** The `mz_show_clusters` view is + indexed in `mz_catalog_server`, and an index cannot be built over a relation that uses `mz_now()`, + so the view exposes only a boolean `reconfiguration_in_flight`. The deadline needed to split + in-progress from timed-out lives on `mz_cluster_reconfigurations.reconfiguration_deadline`; a user + compares it to `mz_now()` there. Surfacing a derived status in `SHOW CLUSTERS` would require + dropping the index or a non-indexed companion view; not pursued in this PR. +- **Autogenerated catalog-doc / index-accounting snapshots.** The slt snapshots that enumerate every + builtin and the catalog-server index dependency columns (`autogenerated/mz_internal.slt`, + `mz_catalog_server_index_accounting.slt`, `information_schema_tables.slt`, `oid.slt`, `catalog.td`) + were hand-updated to include the new table/columns and the bumped table count, matching the + generators' format; they are authoritative only after the live-server regen steps in CI confirm + byte-equality. Not runnable locally without a full environmentd. + +--- + +## PR 5 — `ON REFRESH` scheduling as a strategy + +**Status:** 👀 In review — implementation landed on `cluster-autoscaling`. `OnRefreshStrategy` +ported into the controller (pure), the refresh-window ctx pull (read-ts / frontiers / +compaction estimate) backed in the adapter driver, scheduled-cluster `replication_factor` +normalized to `0` at runtime, and the legacy `cluster_scheduling.rs` tick gated off when the +controller owns the replica set — all dark behind the master gate. A later follow-up +(2026-06-03, same branch) restored the on-refresh MV write frontier to a full-fidelity +`timely` `Antichain` at the `ClusterControllerCtx` seam (matching the legacy +refresh policy's `less_than` / `as_option` comparisons), reverting an earlier +`Option` upper-bound collapse — behavior-identical for single-input MVs, dark +preserved. See the Progress Log. + +**Goal.** Port the existing `ON REFRESH` policy into the controller as `OnRefreshStrategy`, so +the framework owns all three existing behaviours — still dark; legacy `cluster_scheduling.rs` +runs when the gate is off. + +**Scope (in).** +- `OnRefreshStrategy` (pure): contributes one replica at `cluster.size` while the cluster is + inside a refresh window, nothing otherwise — from REFRESH MV write frontiers + the configured + hydration-time estimate + current read timestamp. Does not apply to MANUAL clusters. Pull the + read-ts / frontiers via `ClusterControllerCtx` on demand (the same signals `check_refresh_policy` + reads today), not a pushed snapshot. +- Model: a scheduled cluster's `replication_factor` is the controller's domain; the baseline + desires nothing and `OnRefreshStrategy` is the sole contributor. So enabling-by-flag is safe + regardless of the stored rf: the strategy's `update_state` **normalizes scheduled-cluster rf to + 0 at runtime** (self-healing — no migration, and it makes `mz_clusters.replication_factor` read 0). +- Keep legacy `cluster_scheduling.rs` for gate-off (removed in PR 7). + +**Scope (out).** No legacy removal (PR 7). No rf migration — rf is normalized by the controller at runtime. + +**Verification.** User-visible first (gate forced on): a scheduled cluster turns on inside its +refresh window and off outside, matching today's behaviour. A few kernel unit tests for the +window decision (in/out-of-window; frontier vs. estimate) where they're cheap. + +**Acceptance criteria.** With the gate off, scheduling is unchanged. With the gate forced on, an +`ON REFRESH` cluster's replica lifecycle matches today's behaviour, driven by the strategy. + +**Checklist.** +- [x] Implement `OnRefreshStrategy` (pure); targeted parity unit tests for the window decision. +- [x] Normalize scheduled-cluster `replication_factor` to 0 via `update_state` (so flag-enablement needs no migration). +- [x] Back the read-ts / frontier ctx methods used by the refresh strategy. +- [x] Integration test (gate forced on) for window on/off (`cluster-controller.td`, authored for CI). +- [x] `cargo fmt`/`check` clean; update tracker. + +**Deferred (with reasons).** +- **Rich `ClusterScheduling` audit attribution on on-refresh creates/drops.** The legacy + scheduler attaches a `SchedulingDecisionsWithReasonsV2` (objects needing refresh / compaction, + hydration-time estimate) to each scheduling-driven replica create/drop, computed where the + decision is made. The controller attributes commands only by strategy *name* (`on-refresh`), + not by that rich per-decision detail, and the audit reason `ReplicaCreateDropReason::ClusterScheduling` + requires a non-empty `Vec` (its `into_element()` panics on empty). Rather + than fabricate or recompute that detail at the agnostic apply site, on-refresh creates/drops + carry the interim `Manual` tag (as the baseline does). The controller is dark, so the tag is + immaterial until the gate is enabled; richer reconfiguration/scheduling drop-lifecycle audit + attribution is the audit-surface work owned by the observability PRs (cf. PR 4's deferred + drop-lifecycle attribution). +- **Restart-survival / live window integration beyond the slt.** As with PR 3, a platform-check + that flips `enable_cluster_controller` env-wide would change behavior for every other check in + the shared dark suite. The on/off window behavior is asserted deterministically in the kernel + parity tests and the gate-on `cluster-controller.td`; a dedicated restart/upgrade test belongs + with the rollout enablement, not the dark suite. + +--- + +## PR 6 — Hydration burst (last feature PR; lands dark) + +**Status:** 👀 In review — implementation landed on `cluster-autoscaling`. The +`AUTO SCALING STRATEGY = (ON HYDRATION (...))` SQL surface (AST + parser + planner + +`SHOW CREATE CLUSTER` + the item-parsing `enable_auto_scaling_strategy` gate), the pure +`HydrationBurstStrategy`, the `enable_hydration_burst` break-glass + `default_hydration_burst_linger` +dyncfgs, the validations (HYDRATION SIZE == SIZE; AUTO SCALING + ON REFRESH), and burst +observability/audit (the `HydrationBurst` create/drop reason + a `ClusterHydrationBurstV1` +started/finished lifecycle event; the PR-4 `mz_cluster_reconfigurations.burst_size` column already +reads the record) — all dark behind the gates. Authored-for-CI: parser testdata, the burst section of +`cluster-controller.td`. See the Progress Log. + +**Goal.** Add the new `ON HYDRATION` burst capability: the SQL surface, the strategy, the +break-glass flag, validations, and burst observability/audit. This completes the feature; like +PRs 2–5 it lands **behind gates, defaults off** — no production behaviour change. After it merges, +the whole feature is in `main` and ready to be turned on at runtime (see *Operational rollout*). + +**Scope (in).** +- **SQL surface:** `AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '...', LINGER DURATION = '...'))` + at `CREATE CLUSTER` and `ALTER CLUSTER ... SET (...)`. AST (`ClusterOptionName::AutoScalingStrategy` + + nested option parsing), parser, planner → the `auto_scaling_strategy` durable field (PR 1). + Whole block set/replaced atomically; omitted/empty disables. `SHOW CREATE CLUSTER` renders it. + Gated by `enable_auto_scaling_strategy`. +- **Validations (parse/plan):** reject `HYDRATION SIZE == cluster SIZE`; reject + `AUTO SCALING STRATEGY` combined with `SCHEDULE = ('on-refresh', ...)`. +- `HydrationBurstStrategy` (pure): when `on_hydration` set, cluster on (rf > 0), and no + realized-config replica has all current objects hydrated → write `burst` record (size, linger). + Desires one extra replica at `HYDRATION SIZE` while the record is present. `update_state`: + record the timestamp when a steady replica first hydrates; once `now > that + linger` clear the + `burst` record (teardown). Re-arm (reset the timestamp) if steady replicas go un-hydrated again. + No TTL on the burst replica (accepted: permanent oversize if steady can never hydrate). Burst is + **not** suppressed during a reconfiguration (coexists). The burst replica is an ordinary replica — + the union/diff reconciler creates and tears it down by shape+count; no tag or special identity + (decision 5). +- **Break-glass** `enable_hydration_burst` (default true at GA; false disables the strategy + env-wide, leaving graceful/on-refresh untouched). +- **Observability/audit:** populate the burst columns in the PR 4 view; `SHOW CLUSTERS` burst + indication; audit events for burst started / replica created / replica dropped. + +**Scope (out).** Multiple burst replicas; `AUTO SCALING STRATEGY` + `ON REFRESH` (both rejected, +per design). Turning the feature on (rollout) and removing legacy paths (PR 7) come later. + +**Verification.** User-visible first (gates + `enable_auto_scaling_strategy` forced on in tests): a +burst replica appears while steady is un-hydrated and tears down after its linger; the break-glass +flag disables it; rejected combinations error at plan time; `SHOW CLUSTERS`/introspection show the +burst. Platform-check for burst surviving restart. A few kernel unit tests for arm/linger/re-arm/teardown. + +**Acceptance criteria.** With the gates forced on, a user can set `AUTO SCALING STRATEGY (ON HYDRATION (...))`; +a burst replica spins up when warranted and tears down after linger with no user action; the +break-glass flag disables it; rejected combinations error. With the gates off (default), nothing changes. + +**Checklist.** +- [x] SQL: AST + parser + planner for `AUTO SCALING STRATEGY`/`ON HYDRATION`; `SHOW CREATE CLUSTER`; `enable_auto_scaling_strategy` gate. (New `ClusterOptionName::AutoScalingStrategy` + `WithOptionValue::ClusterAutoScalingStrategyOptionValue` (`{ on_hydration: Option }`); `AUTO`/`SCALING`/`LINGER`/`DURATION` keywords; `parse_cluster_option_auto_scaling_strategy`; threaded through `ClusterOptionExtracted` → `CreateClusterManagedPlan.auto_scaling_strategy` / `PlanClusterOption.auto_scaling_strategy` (`Set(None)` = disable) → durable `ClusterVariantManaged.auto_scaling_strategy`. `unplan_auto_scaling_strategy` + `Cluster::try_to_plan` surface it for `SHOW CREATE CLUSTER` (round-trip-checked by `plan_create_cluster`). Gate is a `feature_flags!` flag (item-parsing), **not** a dyncfg — a stored `CREATE CLUSTER` re-parses at rehydration where dyncfgs aren't consulted (design *Feature gate*).) +- [x] Validations: HYDRATION SIZE == SIZE; AUTO SCALING + ON REFRESH. (Both at plan time, on `CREATE` and `ALTER`. The `ALTER` check (`validate_auto_scaling_strategy`) runs against the cluster's *effective* config — the values the `ALTER` sets, else its current ones (`cluster.auto_scaling_strategy()`/`managed_size()`/`schedule()`) — regardless of whether the `ALTER` touches the strategy option, so the invariants cannot be established by changing the *other* side (e.g. `ALTER ... SET (SIZE = )` or `... SET (SCHEDULE = ON REFRESH)` on a cluster that already carries a strategy). Rejected for unmanaged clusters in planner and adapter.) +- [x] `HydrationBurstStrategy` (pure); targeted kernel tests (arm/linger/re-arm/teardown). (Engaged on `ON HYDRATION` + break-glass on + cluster On; `update_state` cleanup/arm/linger/teardown/re-arm; `desired_replicas` keys one replica at `HYDRATION SIZE` on the record's presence. 16 kernel tests + a FakeCtx seam test (create-then-teardown).) +- [x] `enable_hydration_burst` break-glass dyncfg. (Default **true** at GA; plus `default_hydration_burst_linger` for an omitted `LINGER DURATION`. Both pulled into `ClusterState` as config signals — excluded from the CaA witness.) +- [x] Burst observability columns + audit events. (`mz_cluster_reconfigurations.burst_size` already reads the record (PR 4); `mz_internal.mz_show_clusters` (and the `SHOW CLUSTERS` projection in `show.rs`) gained a `burst_size` column joined from it, so a single `SHOW CLUSTERS` answers "is a burst running" — NULL when none. New `ReplicaCreateDropReason::HydrationBurst` → `CreateOrDropClusterReplicaReasonV1::HydrationBurst` (proto variant added in place to unshipped v86) on burst create/drop; new `EventDetails::ClusterHydrationBurstV1` started/finished lifecycle classified at the `Op::UpdateClusterConfig` write site (alongside the reconfiguration lifecycle), proto + `RustType` added in place to v86, hashes regenerated.) +- [x] Integration tests (burst lifecycle, break-glass, rejections). (`cluster-controller.td` burst section: SQL acceptance + `SHOW CREATE` round-trip + RESET + rejections (HYDRATION SIZE == SIZE, + ON REFRESH, gate-off) — authored for CI. The deterministic burst-replica lifecycle is in the kernel + FakeCtx tests, since an empty slt cluster hydrates promptly and races the linger.) +- [x] `cargo fmt`/`check` clean; update tracker. + +**Deferred (with reasons).** +- **Restart-survival platform-check for burst.** As with PR 3/PR 5, a platform-check that flips + `enable_cluster_controller` (and `enable_auto_scaling_strategy`) env-wide would change behavior for + every other check in the shared dark suite (the controller would own all replica sets). Burst + survival across restart is guaranteed by construction (the `burst` record is durable catalog state) + and exercised by the controller kernel + FakeCtx seam tests; a dedicated restart test belongs with + the rollout enablement, not the dark suite. +- **Rich `SchedulingDecisions`-style audit detail on burst create/drop.** Burst create/drop carry the + `HydrationBurst` reason (a clean attribution); they do not carry a rich per-decision detail blob. + None is defined for burst (unlike the legacy `SchedulingDecisionsWithReasonsV2` for on-refresh), so + there is nothing to fabricate — the `ClusterHydrationBurstV1` started/finished lifecycle event plus + the reason-tagged replica events cover the burst lifecycle. +- **Live-server regen of autogenerated catalog/keyword snapshots.** The parser testdata and the burst + `cluster-controller.td` section are authored to match the generators' format but were not run + against a booted `environmentd` (operating rules say not to block on the optimized build). The + `enable_auto_scaling_strategy` flag is intentionally **not** added to the mzcompose default + feature-flag list — adding it would enable the SQL surface env-wide for every mzcompose test, which + contradicts landing dark. + +--- + +## Operational rollout — between PR 6 and PR 7 (not a code change) + +With the whole feature in `main` behind gates defaulting **off**, enabling it is an **operational** +step, not a PR: flip the dyncfgs on at runtime via LaunchDarkly — `enable_cluster_controller`, then +`enable_background_alter_cluster`, then `enable_auto_scaling_strategy` (leave `enable_hydration_burst` +at its default). Roll out staging → a few prod environments → fleet, watching the introspection +view, audit log, and replica metrics. The legacy paths stay in the binary the whole time, so +rollback is a flag flip. **Let it bake in prod until we're confident.** Only then does PR 7 land. + +Notes: +- The gates are independent, so enablement can be staged (master / graceful + on-refresh first, + burst later) at the operator's discretion. +- `replication_factor` for scheduled clusters is normalized by the controller at runtime (PR 5), + so flag-enablement is safe with no migration. +- Rollback (flag → off) is cleanest when no controller-driven reconfiguration or burst is in flight. + +--- + +## PR 7 — Flip defaults to true & remove legacy paths (only after prod has baked) + +**Status:** ⬜ Not started — **do not start until the runtime-enabled feature has baked +successfully in prod for the agreed period.** + +**Goal.** Make the controller the permanent owner in code and delete the now-unused legacy +machinery. This is irreversible (it removes the fallback), so it follows a successful prod bake — +not just local parity. + +**Scope (in).** +- Flip the dyncfg **defaults** to match the baked-in prod state: `enable_cluster_controller` → true, + `enable_background_alter_cluster` → true, `enable_auto_scaling_strategy` → true + (`enable_hydration_burst` already defaults true). +- **Remove legacy code:** the 3-stage graceful machine (`WaitForHydrated`/`Finalize`/pending + creation + `-pending` suffix + `pending_cluster_alters`), `cluster_scheduling.rs` policy + + `Message::CheckSchedulingPolicies`/`SchedulingDecisions` + the scheduling interval, and the + now-obsolete `AlterClusterWhilePendingReplicas` reject. The wait-shim becomes the only foreground path. +- **Migration (drop `pending`):** remove `pending: bool` from durable `ReplicaLocation::Managed` + (proto change + migration) — safe now that the legacy stage machine that used it is gone. + (Scheduled-cluster `replication_factor` was already normalized to 0 by the controller at runtime + in PR 5; add a tidy-up data migration only if any non-zero values remain.) +- Update/remove tests pinned to legacy behaviour (`enable_cluster_controller=false` pins, removed + legacy workflows). + +**Scope (out).** Nothing new — this is pure cleanup. + +**Verification.** Full relevant suite green with the new defaults (sqllogictest cluster suites, +testdrive, platform-checks for restart/upgrade). Upgrade test for the `pending`-drop migration. +Confirm `mz_clusters.replication_factor` reads 0 for scheduled clusters while a replica runs +(`mz_cluster_replicas` is authoritative). + +**Acceptance criteria.** Defaults are on; legacy paths are gone; `pending` dropped; full suite green. +Because the fallback is removed, this is gated on a successful prod bake, not on local parity alone. + +**Checklist.** +- [ ] Confirm prod ran the runtime-enabled feature successfully for the agreed bake period. +- [ ] Flip dyncfg defaults (`enable_cluster_controller`, `enable_background_alter_cluster`, `enable_auto_scaling_strategy`) to true. +- [ ] Remove legacy graceful machine + scheduling policy + obsolete reject/messages/interval. +- [ ] Migration: drop `pending` (+ tidy rf only if needed). +- [ ] Update/remove tests pinned to legacy behaviour. +- [ ] Full suite green (CI); upgrade + platform checks. +- [ ] Update tracker. + +--- + +## PR 8 — Showcase follow-ups: drop attribution, rollback observability, burst arming + +**Status:** 👀 In review — complete. 8a, 8b, and 8c landed (implement/review/revise cycles; +each verified with an end-to-end `cluster-controller.td` run against a live server — +105/105 after 8a, 131/131 for the full file after 8b's re-cut and 8c), and the full +showcase replay (`pm-showcase-replay.sh`, fresh `--reset` environment on the optimized PR 8 +build) confirmed all three rough edges gone: the cut-over drop reads `retired`, the rollback +history gains its `timed-out` event, and the burst audit shows a single `started`/`finished` +pair (no at-creation burst). The replay ran against 8b's original durable-stamp form; after +the re-cut to the record-clear design the rollback flow (`started → timed-out`, deadline on +every transition, the cluster settled afterwards) was re-verified via the live slt run +rather than a fresh full replay. The showcase report's rough-edges section was updated to +record the fixes. + +Three independent fixes that fell out of live end-to-end testing for the PM showcase +(`pm-showcase-cluster-controller.md`, "Known rough edges"). Each is small, lands as its own +commit, and touches only unreleased surfaces (no migration; the v86 amendments follow the +in-place recipe PR 4 already used). Workshopped decisions are recorded inline — they are +settled, not open. + +**Goal.** Make the audit log tell the truth about controller-driven replica lifecycle, make a +`ROLLBACK`-at-deadline observable in history (closing PR 4's deferred item), and stop bursting +on clusters with nothing to hydrate. + +### 8a — `retired` drop reason (no smarts) + +A drop happens exactly when no strategy desires the replica, so the diff has no strategy name +to attribute and today maps the empty set to `manual` — misleading next to creates that carry +`reconfiguration`/`hydration-burst`. Decision: **no attribution smarts**; one new reason. + +- New `CreateOrDropClusterReplicaReasonV1::Retired` (kebab-case `retired`): "the cluster's + configuration no longer calls for this replica". **Every controller-emitted drop** carries it — + cut-over retiring the old set, rollback/cancel retiring the target set, burst teardown, + refresh-window close, and an rf-decrease retiring the surplus (a deliberate semantic shift: + that drop reads `retired`, not `manual`, even though the config change was user-initiated). +- Creates keep per-strategy attribution; **on-refresh creates are restored to `schedule`** + (the strategy name is already in the create's attribution list — a one-line mapping change). + The legacy `scheduling_policies` detail blob stays gone; only the reason word returns. + *(Superseded for creates by PR 9: the blob returns on on-refresh creates. Drops keep no + blob — that side of this decision stands.)* +- User-issued `DROP CLUSTER REPLICA` (unmanaged clusters) keeps `manual` — that path is + untouched. +- Update the `reason_from_strategies` doc comment (the on-refresh caveat dissolves) and the + design doc's attribution language where it implies drops carry strategy reasons. + +Checklist: +- [x] `Retired` audit variant; drop mapping → `retired`, create mapping restores `schedule`. + (`Retired(Empty)` mirrored into the unshipped v86 protos per the `HydrationBurst` recipe, + hashes regenerated. Drops bypass `reason_from_strategies` entirely — the now-create-only + mapping gained `on-refresh → OnRefresh`, a new detail-less adapter variant converting to + `(Schedule, None)`; `ClusterScheduling`'s non-empty-blob contract stays intact for the + legacy scheduler. `Decision::DropReplica.reasons` removed — always empty by construction.) +- [x] Test expectations: `cluster-controller.td`, `materialized_views.slt`, + `materialized-view-refresh-options.td` (creates `manual`→`schedule` on scheduled + clusters; drops →`retired`); kernel/adapter unit tests. + (`singlereplica_audit_log.slt`'s `manual` drop is a user `DROP CLUSTER REPLICA` on an + unmanaged cluster — correctly untouched.) +- [x] `cargo fmt`/`check` clean; tracker + progress log. + +### 8b — Rollback-at-deadline: clear the record, audit `timed-out` + +Closes PR 4's deferred **`ROLLBACK`-timeout audit event**. Today a rollback past the deadline +performs no durable write — the strategy just stops desiring the target replicas and the +record lingers as a tombstone — so there is no transition to classify and the audit trail +ends at `started`. + +Decision: the rollback becomes a durable config write, but the *cheap* one — the strategy +**clears the record** at the deadline (realized config untouched), the same finalizing move +every other settled outcome already makes. The audit event is the timeout's papertrail; no +tombstone is retained and no schema change is needed (the durable-stamp option named in PR 4 +was implemented first and then rejected as over-engineered: a stamped tombstone in durable +state duplicated what the audit history already records, and dragged a `state` column plus +re-open semantics behind it). + +- Strategy: on a tick with `now > deadline`, target un-hydrated, and `on_timeout == Rollback`, + `update_state` returns a record-clear write (success precedence unchanged: the hydrated + check comes first). `desired_replicas` keeps the `now > deadline` predicate so the target + set is retired even on a tick whose clear could not land (witness rejection). +- **Event vocabulary re-carve** (all unreleased): `finalized` = the realized config cut over + (hydrated success under either action, *or* a forced `COMMIT` past the deadline); + `timed-out` = the rollback clear (emitted exactly once because the clear is durable). The + classifier tells the two clears apart by whether the same write advanced the realized shape + to the cleared record's target. `finalized` now always carries the record's deadline so a + reader can tell a late/forced cut-over from an in-time one — this dissolves PR 4's + documented `COMMIT`-late-success imprecision. +- Introspection: none. A rolled-back cluster reads settled in + `mz_cluster_reconfigurations`/`SHOW CLUSTERS` (record gone, target back to mirroring the + realized shape); the abandoned target survives only in the `timed-out` event. PR 4's + "tombstone visible in the view" framing is superseded. +- Wait-shim: a cleared record is no longer conclusively success, so the shim carries the + `ALTER`'s target and, on clear, reports success iff the realized config reached it — + `AlterClusterTimeout` otherwise. This replaces the deadline+grace heuristic as the shim's + settled-outcome signal (the grace re-poll stays, but only to bound the wait when the record + cannot move, e.g. the controller is disabled). + +Checklist: +- [x] Strategy clear-on-timeout; kernel unit tests (clear without cut-over, no target desired + past the deadline, seam test asserts the clear + revert + second-tick no-op). +- [x] Classifier re-carve + unit tests; `ReconfigurationLifecycleV1` docstrings updated. + (`(Some, None)` classifies by realized-vs-target: advanced → `finalized`, short → + `timed-out`, both carrying the cleared record's deadline. The cancel-converge clear + reads `finalized` (its target equals the realized shape). Accepted marginal mislabel: + a rollback whose target equals the realized shape would read `finalized`, but such a + target cuts over as trivially satisfied unless the realized set itself sits un-hydrated + past the whole deadline. The classifier's unused `now` parameter is gone.) +- [x] Wait-shim success-vs-rollback off the realized config; stale stamp-era comments gone. +- [x] `cluster-controller.td` timeout-rollback flow asserts the settled view + the ordered + audit history (`TIMEOUT '0s'` rolls back before any replica can hydrate; in-flight + asserted by freezing the controller via the master gate); cloudtest slow-hydration + rollback asserts settled view + `timed-out` event. +- [x] `cargo fmt`/`check` clean; tick the PR 4 deferred item; tracker + progress log. + +### 8c — Burst arming: existential object semantics + +Burst currently arms whenever no steady replica reports fully-hydrated — which is also true +when the replica simply doesn't exist yet or hasn't registered, so a brand-new empty cluster +bursts for boot-time + linger. Decision: the arm condition is the design doc's own quantifier. + +- Semantics: **burst is warranted iff there exists an object on the cluster that no + steady-state replica has hydrated.** Zero objects ⇒ the set is empty ⇒ never warranted — + the empty-cluster case falls out vacuously, no special-casing. +- Implementation sketch: the ctx supplies whether the cluster has any hydratable objects + (from the catalog's bound objects, filtered to dataflow-backed items — same source the + refresh-window pull reads); a config-style signal excluded from the CaA witness like + `burst_enabled`. The burst strategy arms only when it holds and the steady set is + un-hydrated. Exact signal shape (field on `ClusterState` vs. on-demand ctx pull) is the + implementer's call — match the existing ctx idiom. Teardown paths unchanged: if all objects + are dropped mid-burst, the steady set reads vacuously hydrated and the linger clears the + record. +- A crashed/restarting steady replica on a cluster *with* objects still bursts — correct and + desirable. + +Checklist: +- [x] Object-existence signal through the ctx; burst arm condition updated. + (On-demand `has_hydratable_objects` pull, answered from the cluster's `bound_objects` + filtered to dataflow-backed items — webhook sources excluded; a documented catalog-level + approximation whose mismatches self-heal through the linger path. Excluded from the CaA + witness like the other live signals. The pull doubles as a probe gate: an object-less + cluster skips the per-replica hydration probe entirely.) +- [x] Kernel unit tests: empty cluster never arms; arms when the first object lands; + crashed-replica-with-objects still arms. + (Seam tests hold the signal beside the states in the `FakeCtx` so the `enrich_hydration` + pull is load-bearing — deleting the pull demonstrably fails them.) +- [x] `cluster-controller.td`: strategy-carrying cluster with no objects shows no burst + record/replica across ticks. + (Deterministic precisely because of the gate; verified to fail against a pre-8c binary + and pass — 134/134 — against the 8c build.) +- [x] `cargo fmt`/`check` clean; tracker + progress log. + (Noted follow-up, out of scope here: `kick_cluster_controller` does not fire on item + creates/drops, so arming after the first object lands waits up to one tick interval — + consider kicking on item ops whose `item.cluster_id()` is `Some`.) + +**Verification (all three).** Author slt/unit coverage per fix (CI-run); locally `cargo fmt` + +`cargo check` + kernel/adapter unit tests per the working agreement. Final pass: re-run the +showcase replay (`pm-showcase-replay.sh`) against a fresh environment and confirm the three +"known rough edges" are gone (drops read `retired`, the rollback flow emits `timed-out` and +shows `state = 'rolled-back'`, no burst on the freshly-created empty cluster). + +--- + +## PR 9 — Restore the on-refresh `scheduling_policies` audit detail on creates + +**Status:** 👀 In review — spec'd and workshopped 2026-06-10; implemented the same day on the +user's go-ahead. Independent of 8b/8c (it touches the audit mapping and kernel decision types +8a settled, not the rollback or burst surfaces). Folded with 8a into per-mainline-PR `fixup!` +commits (see the Progress Log): PR 8/9 are not standalone PRs but amendments to the mainline +stack. + +PR 8a restored the `schedule` reason *word* on on-refresh creates but recorded the +per-decision `scheduling_policies` detail blob as gone. Revisited with the user: the blob is +the audit log's only answer to "why did this cluster turn on" — which REFRESH MVs were behind +(`objects_needing_refresh`), which were still inside their post-refresh Persist-compaction +window (`objects_needing_compaction`), and the `hydration_time_estimate` the window was +widened by — and it turns out to be cheap to restore with full fidelity: every signal it +needs is already in the tick's `RefreshWindowInputs`, and the audit format still carries the +optional field. Settled decisions: + +- **Creates only.** Drops stay uniformly `retired` with no blob — 8a's no-attribution design + stands. A drop happens exactly when no strategy desires the replica, so there is no + decision to record; the legacy "off" blob (`decision: off` + empty lists) does not come + back. Structurally enforced: only `Decision::CreateReplica` carries the payload, the + payload has no on/off field, and the adapter conversion hardcodes `decision: "on"`. +- **No audit-format change.** `CreateClusterReplicaV4.scheduling_policies` is already + `Option` (serde-skipped when `None`); this PR stops + passing `None` on the controller path. No audit version bump, no catalog migration; dark + behind the master gate like PR 5/8. +- **The kernel stays audit-agnostic.** `mz-cluster-controller` grows no `mz-audit-log` + dependency: the strategy emits a plain decision struct (`GlobalId`s + `Duration`s) and the + adapter owns the conversion to the audit type — the same split the legacy path uses, whose + `RefreshDecision` → V2-blob conversion also lives adapter-side. + +Design, in data-flow order: + +- **MV identity into the inputs.** `RefreshMvInfo` (ctx.rs) gains `id: GlobalId` — the MV's + writes-GlobalId, the identity the legacy blob recorded. The coord pull + (`refresh_window_inputs`) already has `mv.global_id_writes()` in hand and currently drops + it. +- **The strategy computes lists, not booleans.** `OnRefreshStrategy::cluster_on` becomes a + window-decision function returning + + ```rust + pub struct RefreshWindowDecision { + pub objects_needing_refresh: Vec, + pub objects_needing_compaction: Vec, + pub hydration_time_estimate: Duration, + } + ``` + + by turning the two `.any()`s into `filter`s — the same computation the legacy + `check_refresh_policy` does. The window is open iff either list is non-empty, so the legacy + soft-assert ("`on` should have an explanation") holds by construction. Type lives next to + `OnRefreshStrategy` (naming/placement is the implementer's call within the ctx idiom). +- **Payload through the kernel.** `DesiredReplica` gains + `audit_detail: Option`; only the on-refresh strategy sets `Some`. + The union merge in `reconcile_replicas` combines per-shape details with `Option::or` (at + most one strategy produces `Some` today; the rule is documented, not load-bearing) and + `Decision::CreateReplica` carries the merged field. Multiple creates of one shape in a tick + share the same decision, as legacy events did. Drops gain nothing. +- **Adapter mapping.** `ReplicaCreateDropReason::OnRefresh` gains the payload + (`OnRefresh(Option)`); `reason_from_strategies` keeps the + graceful > burst > on-refresh precedence and attaches the create's detail only when + on-refresh wins — so the blob appears **iff** the audited reason is `schedule`, the same + invariant legacy events had (a shape desired by both graceful and on-refresh audits + `reconfiguration`, no blob — consistent, since the blob explains a `schedule` decision). + `into_audit_log` converts ids to strings and the estimate to an interval string + (`Interval::from_duration` + `strconv::format_interval`, as the legacy conversion does), + with `decision` hardcoded `On`. The legacy `ClusterScheduling` variant and its conversion + are untouched (they die with PR 7). +- **Fidelity.** The blob is computed from the same tick's `RefreshWindowInputs` the create + decision keys on — the same fidelity as the legacy path, where the deciding task carried + its decision into the `ALTER`. A mid-window re-create (e.g. replacing a lost replica) + carries the lists as of its own tick, which is the honest reading. + +Comment trail to update (the places that currently say the detail is gone): the `OnRefresh` +variant rustdoc and `into_audit_log` notes (catalog/transact.rs), the +`reason_from_strategies` rustdoc (coord/cluster_controller.rs), the +`test_replica_create_drop_reason_into_audit_log` comment, the slt comments in +`cluster-controller.td` / `materialized_views.slt`, the design doc's attribution sentence +(§"strategies are purely additive…", which describes creates as carrying only strategy +names), and 8a's settled-decision bullet (amended in place, pointing here). + +Checklist: +- [x] `RefreshMvInfo.id`; `RefreshWindowDecision` + strategy refactor; kernel unit tests + (refresh-due, compaction-window, both-empty ⇒ window closed; lists match + expectations). (`RefreshWindowDecision` lives in `ctx.rs` next to + `RefreshWindowInputs` — `Decision::CreateReplica` carries it, and placing it + strategy-side would invert the ctx ← strategy module layering.) +- [x] `DesiredReplica.audit_detail` + merge rule + `Decision::CreateReplica` plumbing; + kernel unit tests (on-refresh create carries the detail; burst/`extra` creates carry + `None`; shared-shape merge keeps the detail). +- [x] `OnRefresh(Option)` + conversion in `into_audit_log`; adapter + unit test updated (`Some` ⇒ blob with stringified ids + formatted interval, `None` ⇒ + no blob; `Retired` unchanged). +- [x] slt (authored for CI): `cluster-controller.td`'s scheduled-cluster create asserts the + blob (decision `on`, estimate, non-empty `objects_needing_refresh`); drop stays + `retired` + no blob. `materialized_views.slt` restores the pre-branch blob-content + assertions on creates (the `uXXX` normalization), including the compaction-driven + `c_schedule_6` case; drops stay `retired`/null. (`materialized-view-refresh-options.td` + asserts only reason words — unchanged.) +- [x] Comment trail above; `cargo fmt`/`check` clean; tracker + progress log. + +--- + +## Progress log + +Append dated entries as work lands. Newest first. + +- _2026-06-10_ — **PR 8 verification pass complete.** Rebuilt optimized binaries and re-ran + the full PM-showcase replay (`pm-showcase-replay.sh`) on a fresh `--reset` environment: + all three rough edges confirmed gone (cut-over drop audited `retired`; the rollback + timeout in the audit history with its deadline; exactly one burst `started`/`finished` + pair — no at-creation burst). The replay ran against 8b's original durable-stamp form; + after the re-cut the rollback flow (`started → timed-out`, cluster settled afterwards) + was re-verified via the live 131/131 `cluster-controller.td` run, not a fresh full + replay. The showcase report's "Known rough edges" section now records the fixes and what + a current build prints where its transcripts predate them. PR 8 status → in review, + complete. + +- _2026-06-10_ — **PR 8c landed** (implement → adversarial review → revise, separate agents; + the implementation session was cut off twice by an agent session limit and completed by a + continuation agent). Burst arming is existential: an on-demand `has_hydratable_objects` ctx + pull (from `bound_objects`, dataflow-backed items only) gates the arm branch, so an + object-less cluster never bursts — and skips the per-replica hydration probe entirely. + Review verdict: APPROVE; the one substantive minor (the `FakeCtx` pre-populated the new + signal, so seam tests couldn't catch a broken pull) was fixed in the revise pass by holding + the signal beside the states — deleting the pull now demonstrably fails the seam tests. + Verification note for the record: the first live slt run of the new regression section + FAILED — because the runner binary was stale (the rebuild had been OOM-killed and a `tail` + pipe masked the exit code), i.e. the section correctly caught pre-8c behavior; after a real + rebuild the full file passes (131/131 after the 8b re-cut reshaped the file). Noted follow-ups: kick the controller on item ops + (arming currently waits up to one tick after the first object lands); the burst-arming + outage mode is only covered by seam tests, the slt asserts the negative case. +- _2026-06-10_ — **PR 8b landed, then simplified.** First implemented as a durable + `rolled_back_at` stamp (tombstone retained, view `state` column, v86 amended); on review we + judged that over-engineered — the audit event is papertrail enough — and re-cut it: the + strategy now **clears the record** at the deadline under `ROLLBACK` (realized config + untouched), the classifier tells the two clears apart by whether the realized shape advanced + to the cleared record's target (`finalized` vs `timed-out`, both carrying the deadline), and + the wait-shim carries the `ALTER`'s target to tell success from rollback when the record + clears. No schema change, no tombstone, no `state` column; a rolled-back cluster reads + settled everywhere except the audit history. Closes PR 4's deferred ROLLBACK-timeout item + and still dissolves the documented COMMIT-late-success imprecision. `cargo fmt`/`check`, + kernel and classifier unit tests clean; the reworked timeout-rollback slt flow verified + live on the full PR 8 stack (131/131). +- _2026-06-10_ — **PR 9 implemented; PR 8a + PR 9 dissolved into mainline `fixup!` commits.** + The on-refresh `scheduling_policies` detail is restored on creates with full fidelity: + `RefreshMvInfo.id` (the coord pull already had `global_id_writes()` in hand), + `RefreshWindowDecision` computed by the strategy (the two `.any()`s became `filter`s, so an + open window names the MVs that explain it), `DesiredReplica.audit_detail` → + `Decision::CreateReplica.audit_detail` through the kernel union (first-`Some`-wins merge per + shape), and `ReplicaCreateDropReason::OnRefresh(Option)` converted + adapter-side in `into_audit_log` (ids stringified, estimate as interval string, decision + hardcoded `on`). Drops stay uniformly `retired`, no blob. Kernel/adapter unit tests + + `cluster-controller.td`/`materialized_views.slt` blob assertions authored for CI; `cargo + fmt`/`check`/unit tests clean locally. Since PR 8/9 amend behavior the mainline PRs + introduce, the 8a commit and this work were then split into `fixup!` commits against their + mainline targets (`retired` drops → PR 2 scaffold commit; on-refresh `schedule` reason + + blob → PR 5 on-refresh commit; migrated-legacy-test expectations → the CI-enablement + commit) for `git rebase --autosquash`, per the fixup-commit convention. +- _2026-06-10_ — **PR 9 planned** (spec only; implementation paused for a user go-ahead). + Revisited 8a's "detail blob stays gone" call: the create-side `scheduling_policies` blob is + the only audit record of *why* a scheduled cluster turned on, and it is cheap to restore + with full fidelity — every signal is already in the tick's `RefreshWindowInputs`, and + `CreateClusterReplicaV4` still carries the optional field, so there is no format change. + Settled with the user: restore the blob **on creates only**; drops stay uniformly + `retired` with no off-blob, preserving 8a's no-attribution design. Plumbing: MV ids into + `RefreshMvInfo`, the strategy's `.any()`s become list-building `filter`s emitting a + kernel-side `RefreshWindowDecision`, the payload rides `DesiredReplica` → + `Decision::CreateReplica` → `ReplicaCreateDropReason::OnRefresh`, and the adapter converts + to the audit type (kernel stays free of `mz-audit-log`). + +- _2026-06-10_ — **PR 8a landed** (implement → adversarial review → revise, run as separate + agents). Drops are audited `retired` via a single uniform mapping at the apply site (no + record-context smarts, per the settled decision); on-refresh creates read `schedule` again + through a new detail-less `ReplicaCreateDropReason::OnRefresh` (the legacy + `ClusterScheduling` variant and its non-empty `scheduling_policies` contract are untouched); + `Decision::DropReplica.reasons` deleted (always empty by construction). Review verdict + APPROVE with minors (test informativeness, comment dedup, rustdoc length) — applied in the + revise pass. The reviewer built the slt runner and ran `cluster-controller.td` against a + live server: 105/105. Known residue: the committed PM showcase report still shows `manual` + drops in its transcripts; it gets refreshed by the full replay re-run after 8c. + +- _2026-06-10_ — **PR 8 planned** (this section). Live end-to-end testing for the PM showcase + (`pm-showcase-cluster-controller.md`, run with all gates on against a local environmentd) + surfaced three rough edges: (1) every controller-emitted replica *drop* is audited + `manual` (drops carry no strategy attribution by construction — empty reasons map to + `Manual`); (2) a `ROLLBACK`-at-deadline leaves no audit trace (no durable write happens, so + the PR 4 classifier has nothing to classify — the known deferred item); (3) a burst replica + is provisioned at cluster creation before any object exists (the replica-centric + `steady_hydrated` check reads an absent/unregistered replica as un-hydrated). Workshopped + with the user and settled as PR 8a/8b/8c: drops uniformly `retired` (no attribution smarts; + on-refresh creates restored to `schedule`, detail blob stays gone), a durable + `rolled_back_at` stamp + event re-carve (`finalized` = cut over with deadline carried, + `timed-out` = parked) + a `state` column on the introspection view, and burst arming on the + existential object condition (zero objects ⇒ vacuously no burst). + +- _2026-06-03_ — **PR 6 review follow-up** (fixup on `cluster-autoscaling`, separate commit on PR 6). + Addressed the adversarial review of the implementation commit: + (1) **ALTER-side validation gaps (two majors).** The `HYDRATION SIZE == SIZE` and + `AUTO SCALING + non-MANUAL SCHEDULE` rejections only fired when the `ALTER` itself set + `AUTO SCALING STRATEGY`, so the prohibited states could be reached by `ALTER`ing the *other* side + (e.g. `SET (SIZE = )` or `SET (SCHEDULE = ON REFRESH)` on a cluster that + already carries a strategy). Split `plan_auto_scaling_strategy` into a pure AST→plan conversion plus + a new `validate_auto_scaling_strategy(strategy, effective_size, schedule_non_manual)`, and call the + validator in `plan_alter_cluster` against the cluster's *effective* config regardless of which + options the `ALTER` touches. Added a `CatalogCluster::auto_scaling_strategy()` accessor (the planner + needs the cluster's current strategy to compute the effective value). Fixed the + `plan_auto_scaling_strategy` doc comment, which had claimed a "re-validated against the realized + config" path that did not exist. Kept the single validation in the planner (the design's parse/plan + rejection point) rather than duplicating it in the adapter sequencer — every `ALTER` flows through + the planner, so the plan reaching the sequencer is already validated; a second `coord_bail!` would + fork the invariant. + (2) **SHOW CLUSTERS burst indication (major; design Scope-in).** Added a `burst_size` column to + `mz_internal.mz_show_clusters` (joined from `mz_cluster_reconfigurations`, which already projects it) + and to the `SHOW CLUSTERS` projection in `show.rs` — NULL when no burst is in flight. Updated the + `mz_catalog_server_index_accounting.slt` column list; no migration (builtin view, recreated from its + definition). + (3) **Burst audit-classification test (major; false confidence).** Added + `test_classify_burst_transition` mirroring the PR-4 reconfiguration sibling: Started on write, + Finished on clear, Started on a `burst_size` re-arm, and crucially **None** on a same-size record + change (the `steady_hydrated_at` stamp) and `None`/`None`. + (4) **Witness coverage for `auto_scaling_policy` (minor).** Added a `concurrent_policy_alter` hook to + the `FakeCtx` and two seam tests (`burst_policy_alter_rejects_in_flight_decision` + a non-vacuous + unchanged-policy dual) so removing `auto_scaling_policy` from the CaA witness would now fail a test. + (5) **Kernel no-panic hardening (minor).** The burst teardown guard used `step_forward_by` (panics on + overflow) on a `duration_to_ts` result that may saturate to `Timestamp::MAX`; switched to + `try_step_forward_by(...).unwrap_or(Timestamp::MAX)`, reading a saturated linger as never-elapsed + (hold the burst), consistent with `duration_to_ts`'s degrade-to-keep-on intent. **Not** applied to + the on-refresh `read_ts.step_forward_by` at `strategy.rs`: it must mirror the legacy + `check_refresh_policy` (which uses the same panicking call) for frontier fidelity, and its inputs + (a bounded read timestamp, a planning-capped hydration estimate) do not share the burst case's + unbounded-dyncfg reachability. + (6) **Parser duplicate rejection (nit).** `AUTO SCALING STRATEGY = (ON HYDRATION (...), ON HYDRATION + (...))` silently kept the last entry; now errors "ON HYDRATION specified more than once". Kept the + comma-separated loop (the design's extensible sub-policy list) and rejects only a repeated keyword. + Added a parser testdata case (rewritten via `REWRITE=1`) and `cluster-controller.td` cases for the + ALTER-other-side rejections + the `SHOW CLUSTERS` burst column. Cheap checks: `cargo +nightly fmt` + clean; `cargo +nightly check` clean on `mz-sql-parser`/`mz-sql`/`mz-catalog`/`mz-cluster-controller`/ + `mz-adapter`; `bin/lint-cargo` clean; `cargo +nightly clippy -p mz-cluster-controller` clean in the + touched files. Tests: `mz-cluster-controller` (51, +2 witness), `mz-sql-parser` datadriven, + `mz-adapter` `catalog::transact` (4, +1 burst classify), `mz-catalog` `builtin::` (7) + + `durable::upgrade` (146). Did **not** run the slt/testdrive suites (the new slt cases are + authored-for-CI) or the optimized build. +- _2026-06-03_ — **PR 6 implemented** (hydration burst — the last feature PR; all dark behind gates + defaulting to the no-burst state). **SQL surface:** new `AUTO SCALING STRATEGY = (ON HYDRATION + (HYDRATION SIZE = '...', LINGER DURATION = '...'))` cluster option, available at `CREATE CLUSTER` + and `ALTER CLUSTER SET/RESET`. Added `ClusterOptionName::AutoScalingStrategy`, a dedicated + `WithOptionValue::ClusterAutoScalingStrategyOptionValue(ClusterAutoScalingStrategyOptionValue { on_hydration: + Option }> })` AST + node (mirroring `ClusterScheduleOptionValue`), the `AUTO`/`SCALING`/`LINGER`/`DURATION` keywords, + and `parse_cluster_option_auto_scaling_strategy` (an empty `()` disables). Threaded through + `ClusterOptionExtracted` → `CreateClusterManagedPlan.auto_scaling_strategy` and + `PlanClusterOption.auto_scaling_strategy` (`Set(Some)`/`Set(None)`-on-empty/`Reset`-on-RESET) → the + durable `ClusterVariantManaged.auto_scaling_strategy` (PR 1 field) on both the create and alter + sequencer paths; `plan_auto_scaling_strategy`/`unplan_auto_scaling_strategy` + `Cluster::try_to_plan` + render it for `SHOW CREATE CLUSTER` (the planner's create-roundtrip asserts the unplan/parse/plan + equality). **Gate:** SQL acceptance is the `enable_auto_scaling_strategy` **`feature_flags!`** flag + (`enable_for_item_parsing: true`, default off) — *not* a dyncfg, because a stored `CREATE CLUSTER` + re-parses at catalog rehydration where dyncfgs aren't consulted (design *Feature gate*). The plan's + dyncfg table listed it as a dyncfg; the design is authoritative — recorded here. **Validations + (plan time):** reject `HYDRATION SIZE == cluster SIZE` (a no-op burst) and `AUTO SCALING STRATEGY` + with a non-MANUAL `SCHEDULE` (both on `CREATE` and `ALTER`, the latter against the effective + size/schedule); reject the option for unmanaged clusters in both the planner and the adapter. + **Strategy:** new pure `HydrationBurstStrategy` in `mz-cluster-controller`, registered in + `ClusterController::new()`. Engaged when the cluster carries `ON HYDRATION`, the break-glass flag is + on, and the cluster is On (`rf > 0`). `update_state` runs the lifecycle in precedence order: + cleanup (clear the record when burst is no longer warranted — policy removed, `HYDRATION SIZE` + changed so the record's size is stale, cluster off, or break-glass off — regardless of linger), arm + (write a record while the steady set is un-hydrated), then linger/teardown/re-arm (stamp + `steady_hydrated_at` on first steady hydration, clear once `now > stamp + linger`, reset the stamp + if the steady set un-hydrates again). `desired_replicas` keys one extra replica at `HYDRATION SIZE` + purely on the record's presence. No TTL (accepted permanent oversize), coexists with a + reconfiguration. **Seam:** added `AutoScalingPolicy`/`OnHydrationPolicy` controller mirrors (kept + out of the SQL dep like `ClusterSchedule`/`OnTimeout`), an `auto_scaling_policy` field on + `ClusterState` *and* `ExpectedClusterState` (so a concurrent `ALTER` of the policy rejects an + in-flight burst decision via CaA), and `burst_enabled` + `default_burst_linger` config signals on + `ClusterState` (excluded from the witness). `enrich_hydration` now also probes a cluster when a + burst is in flight or warranted, not only during a reconfiguration. **Adapter driver:** + `observe_cluster_state` threads the policy + reads `ENABLE_HYDRATION_BURST` / + `DEFAULT_HYDRATION_BURST_LINGER`; `cluster_state_matches` compares the policy; + `reason_from_strategies` maps a burst-desired create to the new `HydrationBurst` reason. **Dyncfgs:** + `enable_hydration_burst` (break-glass, default **true** at GA) and `default_hydration_burst_linger` + (default 0). **Audit:** new `ReplicaCreateDropReason::HydrationBurst` → + `CreateOrDropClusterReplicaReasonV1::HydrationBurst` on burst create/drop; new + `EventDetails::ClusterHydrationBurstV1` started/finished cluster lifecycle, classified from the + `burst` before/after at the single `Op::UpdateClusterConfig` write site (next to the reconfiguration + lifecycle). Both proto variants were added **in place** to the unshipped v86 + (`objects.rs` + `objects_v86.rs`, `objects_hashes.json` regenerated to + `78a3650e8eec5a81c02e459eef26f7f7`) with `RustType` conversions in `catalog-protos/audit_log.rs`; + the audit reason/event are not part of the durable `StateUpdateKind` snapshot, so `objects_v86.txt` + needed no regen. The PR-4 `mz_cluster_reconfigurations.burst_size` column already reads the record, + so the introspection surface needs no schema change. **Tests:** 16 new burst kernel tests + 1 + FakeCtx seam test in `mz-cluster-controller` (49 total, all pass); parser testdata for the new + option (5 cases + the two updated keyword-list error messages, rewritten via `REWRITE=1`); a burst + section in `cluster-controller.td` (acceptance, `SHOW CREATE` round-trip via `create_sql LIKE`, + RESET, and the three rejections incl. gate-off) authored for CI. **Cheap checks:** `cargo +nightly + fmt`; `cargo +nightly check` clean on every touched crate (`mz-sql-parser`, `mz-sql`, `mz-catalog`, + `mz-catalog-protos`, `mz-audit-log`, `mz-adapter`, `mz-adapter-types`, `mz-cluster-controller`); + `cargo +nightly clippy` clean on `mz-cluster-controller`/`mz-adapter-types`; `bin/lint-cargo` clean; + `Cargo.lock` unchanged (no new third-party deps). Tests run: `mz-cluster-controller` (49), + `mz-sql-parser` datadriven, `mz-sql-lexer`, `mz-audit-log`, `mz-catalog` `builtin::` (7) + + `durable::upgrade` (146, incl. proto-serialization stability), `mz-adapter` `catalog::transact` (3, + incl. the reconfiguration classify test), `mz-catalog-protos` (proto roundtrip). The local + toolchain is stable 1.95 but the workspace pins `rust-version = 1.96`, so all builds used + `cargo +nightly` (1.98) with `OPENSSL_DIR` pointed at the vendored openssl build. Did **not** run the + slt/testdrive suites or the optimized build. **Deferred (see the PR-6 section):** a restart-survival + platform-check (would flip the gates env-wide in the shared dark suite); rich + `SchedulingDecisions`-style audit detail on burst (none defined; the lifecycle event + reason cover + it); and a live-server regen of the autogenerated snapshots. `enable_auto_scaling_strategy` is + deliberately **not** added to the mzcompose default feature-flag list (that would enable the surface + env-wide, contradicting dark). + +- _2026-06-03_ — **PR 5 follow-up review: frontier-comment precision** (fixup on + `cluster-autoscaling`, separate commit on PR 5). Tightened two doc/test comments from the + frontier-fidelity restoration so they describe what the code proves rather than overstating it. + The added kernel test (`on_refresh_empty_frontier_needs_no_refresh`) only feeds the empty/sealed + frontier `[]`, where the `Antichain` and the prior `Option` model agree, so its comment no longer + claims antichain-specific discrimination; it now states it guards the empty-frontier arm and notes + a multi-element frontier is not reachable for a single-input total-order MV. The `RefreshMvInfo` + doc comment no longer implies a frontier always has a single upper bound: it describes `as_option` + reading the lone element and falling back to the schedule's last refresh on `[]`, mirroring the + legacy policy. (`Antichain::as_option` for a `TotalOrder` element asserts at most one element, so + the multi-element case is not a producible runtime input here — a single-input MV's frontier holds + at most one element.) Comment-only, no behavior change. **Ran:** `cargo fmt`; + `cargo check -p mz-cluster-controller -p mz-adapter`; `cargo test -p mz-cluster-controller` + (33 pass); `bin/lint-cargo` (clean). + +- _2026-06-03_ — **PR 5 follow-up: full-fidelity MV write frontier at the seam** (fixup on + `cluster-autoscaling`, separate commit on PR 5). The on-refresh strategy had collapsed each + REFRESH MV's storage write frontier to an `Option` (the antichain's single upper + bound via `as_option().copied()`) at the `ClusterControllerCtx` seam. Restored it to the real + `timely` `Antichain` the storage controller reports, so the seam carries the same + abstraction as the legacy `check_refresh_policy` and the window decision is correct regardless + of element count (`as_option()` returns `None` for *both* the empty/sealed frontier and a + multi-element one — the `Option` collapse conflated the two). **Changes:** added the `timely` + workspace dep to `mz-cluster-controller` (`timely.workspace = true`; already in the build graph + via `mz-repr`, so `Cargo.lock` gained only the dependency edge, no version bumps); `ctx::RefreshMvInfo.write_frontier` + is now `Antichain`; `OnRefreshStrategy::cluster_on` compares with + `write_frontier.less_than(&read_ts_adjusted)` (needs-refresh) and + `write_frontier.as_option()` (needs-compaction prev-refresh), byte-for-byte the legacy + semantics; the adapter driver `Coordinator::refresh_window_inputs` passes the owned `Antichain` + from `collection_frontiers` straight through (no `as_option()`); kernel tests build the field + with `Antichain::from_elem(ts)` / `Antichain::new()` and keep their existing expected outcomes. + Added one kernel test (`on_refresh_empty_frontier_needs_no_refresh`) asserting the empty/sealed + frontier reads as not-needing-refresh via `less_than`, the parity case the `Antichain` model + carries directly. Dark and behavior-preserving: for a single-input MV the frontier has at most + one element, so `less_than`/`as_option` agree with the prior `Option` model — every existing + test passes unchanged. **Ran:** `cargo fmt`; `cargo check -p mz-cluster-controller -p mz-adapter`; + `cargo clippy -p mz-cluster-controller`; `cargo test -p mz-cluster-controller` (33 pass); + `bin/lint-cargo` (clean — the new workspace dep passes). Did not run the optimized build or the + slt suite. + +- _2026-06-03_ — **PR 5 review follow-up** (same branch, separate commit on PR 5). Addressed the + review's two minors/nits. **Schedule witness now tested at the seam:** the `FakeCtx` gained an + opt-in `witness_check` that performs the real per-decision compare-and-append (re-reading each + decision's `expected` against stored durable state, mirroring the adapter's + `cluster_state_matches`), plus a `concurrent_schedule_alter` hook that splices an + `ALTER ... SET (SCHEDULE = ...)` in between the controller's read and its append. Two new tests: + `on_refresh_schedule_alter_rejects_in_flight_decision` (a concurrent flip to `MANUAL`, changing + *only* the `schedule` field, rejects the in-flight on-refresh drop — so removing `schedule` from + `ExpectedClusterState` now fails a test) and its non-vacuous dual + `on_refresh_unchanged_schedule_passes_witness`. The legacy "all policies decided" **restart latch** + is deliberately omitted, not deferred: it compensates for the legacy scheduler gathering policy + decisions asynchronously, whereas the controller derives a complete decision from durable + + storage state each tick — so the half-populated-decision-map failure mode it guards cannot occur. + Rationale documented on `OnRefreshStrategy`. + **Conversion divergence** (saturating `Duration → Timestamp` vs the legacy panic) centralized in + a `duration_to_ts` helper using the existing `TryFrom` and documented as deliberate (a + pure kernel must not panic on input). **Comment chronology** trimmed where it did not explain + current behavior (`ClusterController::new` doc, the legacy gating doc, and the on-refresh audit + caveat no longer name future PRs). `cargo fmt`/`check`/`clippy` clean on + `mz-cluster-controller`/`mz-adapter`; `mz-cluster-controller` tests 32 pass. + +- _2026-06-03_ — **PR 5 implemented** (`ON REFRESH` scheduling as a controller strategy, all dark + behind the master gate). **Strategy:** new pure `OnRefreshStrategy` in `mz-cluster-controller` — + engaged for non-MANUAL clusters; `desired_replicas` contributes one replica at the realized + shape while the cluster is inside a refresh window and nothing otherwise, with the window + decision (needs-refresh OR needs-compaction) ported verbatim from the legacy + `check_refresh_policy` (write_frontier < read_ts + hydration_time_estimate; prev_refresh + + compaction_estimate > read_ts). `update_state` normalizes a scheduled cluster's realized + `replication_factor` to `0` at runtime (self-healing — no migration; makes + `mz_clusters.replication_factor` read 0, with `mz_cluster_replicas` authoritative), writing only + when it is actually non-zero so steady ticks stay no-ops. The implicit `BaselineStrategy` now + contributes nothing on a scheduled cluster (the on-refresh strategy is the sole contributor + there), so the two views agree even on the first pre-normalization tick. Registered in + `ClusterController::new()` alongside the baseline and graceful strategies. **Seam:** modeled the + refresh-window signals purely as a new `RefreshWindowInputs { read_ts, compaction_estimate, + refresh_mvs: Vec, refresh_schedule }> }` on + `ClusterState`, plus a `schedule: ClusterSchedule` mirror (kept out of the SQL-layer dep by a + controller-local enum, like `OnTimeout`). The MV write frontier is carried as the antichain's + `as_option()` upper bound — exact for a single-input total-order collection — which keeps the + pure crate free of a direct `timely` dep while preserving the exact `less_than` / `as_option` + semantics the legacy logic relies on. New ctx method `refresh_window_inputs(cluster_id) -> + Option`, pulled on demand the same pay-for-what-you-use way as + `hydrated_replicas`: the controller's `enrich_refresh_window` probes a cluster only when it is + scheduled, so a MANUAL cluster is never probed. Added `schedule` to the CaA witness + (`ExpectedClusterState`) so a concurrent `ALTER ... SET (SCHEDULE = ...)` flipping which strategy + owns the replica set rejects an in-flight on-refresh decision. **Adapter driver:** the new + `Coordinator::refresh_window_inputs` backs the pull against the same signals + `check_refresh_policy` reads — the local oracle read ts (`get_local_read_ts`), the system + `cluster_refresh_mv_compaction_estimate`, and each bound REFRESH MV's + `collection_frontiers().as_option()` + `refresh_schedule`; `observe_cluster_state` threads the + schedule via `schedule_to_controller`. On-refresh creates/drops carry the interim `Manual` reason + (the rich `ClusterScheduling` attribution is deferred, see below). **Legacy gating:** + `check_scheduling_policies` and `handle_scheduling_decisions` now no-op when + `enable_cluster_controller` is on (two writers of a scheduled cluster's replica set is not + allowed), mirroring how PR 3 gated the graceful 3-stage machine; the legacy path stays for + gate-off and is removed in PR 7. **Tests:** 10 new on-refresh tests in `mz-cluster-controller` + (30 total, all pass) — baseline-holds-nothing-on-scheduled, rf-normalization (+ no-op when + already 0 / MANUAL), in-window-desires-one, caught-up-at-read-ts-is-off, + hydration-estimate-opens-window-early, compaction-window-keeps-on, and two end-to-end + FakeCtx-driven seam tests (creates in window / drops out of window, with rf normalized to 0). + `cluster-controller.td` (gate + fast tick forced on) gained an ON REFRESH section asserting a + scheduled cluster reads rf=0 with no replica when no REFRESH MV is bound, brings up exactly one + replica at the cluster size once a `REFRESH EVERY` MV (large HYDRATION TIME ESTIMATE for a + deterministic always-open window) is bound, and that a MANUAL cluster is untouched — authored for + CI, not run locally. **Cheap checks:** `cargo fmt` + `cargo check`/`clippy` clean on + `mz-cluster-controller`/`mz-adapter`; `bin/lint-cargo` clean; `Cargo.lock` unchanged (no new + deps). Did **not** run the slt suite, platform-checks, or the full optimized build. **Deferred + (see the PR-5 section):** the rich `ClusterScheduling` per-decision audit attribution (the + controller attributes by strategy name, not the legacy `SchedulingDecisionsWithReasonsV2` + detail; `into_element()` panics on empty, so an empty-vec interim is unsafe — on-refresh + create/drop carries `Manual`); and a restart-survival platform-check (would flip the master gate + env-wide in the shared dark suite). + +- _2026-06-03_ — **PR 4 follow-up: reconfiguration relation reworked into a materialized view** + (fixup against PR 4's observability commit, same branch). The team has moved away from + imperatively-populated builtin relations for catalog-derived data; PR 4 had introduced + `mz_internal.mz_cluster_reconfigurations` as a catalog-populated `BuiltinTable` packed in + `pack_cluster_update`. It is now a `BuiltinMaterializedView` over the builtin source + `mz_internal.mz_catalog_raw`, mirroring `MZ_CLUSTER_WORKLOAD_CLASSES` (its companion + `MZ_CLUSTER_RECONFIGURATIONS_IND` in `mz_catalog_server` is mirrored too). The MV reads the + managed variant straight from the durable `Cluster` record: realized config from + `data->'value'->'config'->'variant'->'Managed'` (`size`, `replication_factor`, + `availability_zones`), the in-flight target from `…->'Managed'->'reconfiguration'->'target'`, + the deadline from `…->'reconfiguration'->'deadline'`, and `burst_size` from + `…->'Managed'->'burst'`. Externally-tagged variant ⇒ `->'Managed' IS NOT NULL` selects only + managed clusters; an absent `Option` serializes to JSON `null`, so in-flight presence is + `reconfiguration != 'null'`. `target_*` COALESCE onto the realized config when no record is in + flight, so with the controller dark the row is identical to what the table produced + (current==target, not-in-flight, NULL deadline/burst). AZ pools are rebuilt as ordered + `text list`s via `jsonb_array_elements_text(...) AS az WITH ORDINALITY` + `list_agg(az.value + ORDER BY az.ordinality)` (`jsonb_array_elements_text` is a `CallTable` table func, so the + non-legacy `WITH ORDINALITY` path applies), with an unpinned pool COALESCEd to the empty list. + The output `RelationDesc` (columns/types/nullability/key), `column_comments`, and the + one-to-one `belongs_to_cluster` ontology are byte-for-byte unchanged, so `mz_show_clusters` + (LEFT JOIN, indexed) and `show.rs` are untouched. Removed the imperative path + (`pack_cluster_reconfiguration_row` + its `pack_cluster_update` call site and the now-unused + `MZ_CLUSTER_RECONFIGURATIONS` / `ClusterVariantManaged` imports in + `builtin_table_updates.rs`); rewired `BUILTINS_STATIC` (Table → MaterializedView, plus the + Index registered next to `MZ_CLUSTERS_IND`); renamed the OID + `TABLE_MZ_CLUSTER_RECONFIGURATIONS_OID` → `MV_MZ_CLUSTER_RECONFIGURATIONS_OID` (value 17088 + kept) and added `INDEX_MZ_CLUSTER_RECONFIGURATIONS_IND_OID = 17089`. **No + `builtin_schema_migration` entry** — the relation is unshipped (introduced on this branch in + PR 4, never in a released version), so it is defined correctly in place, not migrated; the + migration machinery is only for version upgrades of already-shipped persisted builtins. + **Cheap checks run:** `cargo fmt`; `cargo check -p mz-catalog -p mz-adapter -p + mz-pgrepr-consts` clean; `bin/lint-cargo` clean; `mz-catalog` `builtin::tests` green (incl. + `test_builtins_static_dependency_order`, `test_ontology_consistency`, + `test_mz_sources_fingerprint_changes_with_new_builtin_source`). **Authored for CI (not run — + needs environmentd):** hand-updated the catalog snapshots — `information_schema_tables.slt` + (BASE TABLE → MATERIALIZED VIEW), `catalog.td` (moved to the materialized-views section, table + count 54→53, index count 267→268), `oid.slt` (added the index OID row), and a new index row in + `mz_catalog_server_index_accounting.slt` (its per-column block + the `mz_show_clusters` column + dependencies are unchanged because the schema is identical; the `sNNN` global-IDs across that + file shift and are authoritative only after CI live-server `--rewrite-results`). The dark + behavior assertions in `cluster-controller.td` / `show_clusters.slt` / `canary-clusters.td` + need no edits — the MV yields the same rows. Did **not** run the slt/testdrive suites or a full + optimized build. + +- _2026-06-03_ — **PR 4 follow-up review addressed** (fixup on `cluster-autoscaling`). Adversarial + review of the Table → MaterializedView conversion returned **approve, no must-fix**. Re-verified + the high-risk dimensions against the live tree: the JSON paths match the catalog-protos + serialization (`StateUpdateKind` internally tagged on `kind`; `ClusterVariant` externally tagged + ⇒ `…->'variant'->'Managed'`; `ManagedCluster` / `ReconfigurationState` / `ReconfigurationTarget` / + `BurstState` field names all match), `jsonb_array_elements_text` yields a text column named + `value` so the `list_agg(... ORDER BY ordinality)` rebuilds a `text list`, and the per-column + block in `autogenerated/mz_internal.slt` needs no edit (schema identical; indexes do not appear + in its `objects` listing). The two review findings are **deferred, not fixed**, with reasoning: + (1) the `sNNN` system-item global IDs in `mz_catalog_server_index_accounting.slt` shift because + registering the new index in `BUILTINS_STATIC` bumps every item allocated after it (e.g. + `mz_recent_storage_usage` s806→s807) and the new index's relation reference is a placeholder — + these IDs are positional and authoritative only after CI live-server `--rewrite-results`; a + partial hand-edit cannot make the file self-consistent (the relation's true global ID is not + knowable without booting `environmentd`, which the operating rules say not to block on), so the + whole file is left for CI regen. (2) the sibling template's companion index + `MZ_CLUSTER_WORKLOAD_CLASSES_IND` is defined but unregistered in `BUILTINS_STATIC` (inert) — a + pre-existing condition out of scope for this correction; whether to register it (and add it to + the index-accounting snapshot) is tracked separately. + +- _2026-06-03_ — **PR 4 implemented** (observability: introspection table + `SHOW CLUSTERS` + + reconfiguration audit lifecycle, all dark). **Introspection table:** new catalog-populated builtin + `mz_internal.mz_cluster_reconfigurations` (OID 17088), one row per managed cluster, packed in + `pack_cluster_update` from the realized config plus the durable `reconfiguration`/`burst` records — + `current_*` (size / rf / AZ list), `target_*` (the record's target when in flight, else the realized + config), `reconfiguration_in_flight`, `reconfiguration_deadline` (`mz_timestamp`, NULL when none), + and a placeholder `burst_size` for PR 6. New builtin → **no migration**; with the controller dark + the records stay `None`, so `current == target` and nothing is in flight. **`SHOW CLUSTERS`:** + `mz_show_clusters` now LEFT JOINs the new table and exposes `current_size`, `target_size`, + `reconfiguration_in_flight`; `show.rs` projects them. The view is **indexed**, so it stays + non-temporal (no `mz_now()`); the timed-out-vs-in-progress split is read from the table's deadline. + **Audit lifecycle:** new `mz_audit_log::EventDetails::AlterClusterReconfigurationV1` + (`started`/`finalized`/`timed-out` transition + target size/rf + optional deadline), with the proto + variant added in place to the unshipped v86 (`objects.rs` + `objects_v86.rs`, both + `objects_hashes.json` entries regenerated to `11a6859ce52f01809ed4a317ec1735aa`) and `RustType` + conversions in `catalog-protos/audit_log.rs`. Emitted from the `Op::UpdateClusterConfig` durable + write site via `Catalog::classify_reconfiguration_transition`, classified purely from the + before/after `reconfiguration` record and the write timestamp vs. the deadline: record write / + re-target → `started` (with deadline), success cut-over → `finalized`, `COMMIT`-on-timeout cut-over + → `timed-out` (with deadline). The replica create/drop attribution (`Reconfiguration`) already lands + from PR 3. Dark by construction — a record only ever moves under the master gate. **Tests:** + `cluster-controller.td` gained an observability section (steady-state introspection row = + current==target/not-in-flight, `SHOW CLUSTERS` new columns, post-reconfiguration current==target, + and the `started`+deadline / `finalized` audit rows) and `show_clusters.slt` asserts the new + gate-off columns are benign (current==target, NULL for unmanaged) — both authored for CI. A + `classify_reconfiguration_transition` unit test (`mz-adapter`) covers started/finalized/timed-out/ + re-target/no-op deterministically and passes. Updated the hand-maintained catalog snapshots for the + new table/columns + bumped system-table count (`autogenerated/mz_internal.slt` query block + the + DISTINCT-object list, `mz_catalog_server_index_accounting.slt` column blocks, + `information_schema_tables.slt`, `oid.slt`, `catalog.td`) and added the `mz_cluster_reconfigurations` + doc block to `doc/.../system-catalog/mz_internal.md`. **Cheap checks:** `cargo fmt` + `cargo + check`/`clippy` clean on `mz-adapter`/`mz-catalog`/`mz-catalog-protos`/`mz-audit-log`/`mz-sql`/ + `mz-pgrepr-consts`; `bin/lint-cargo` clean; `Cargo.lock` unchanged (no new deps); catalog + `test_proto_serialization_stability`, `durable::upgrade::tests`, and `builtin::` (incl. + `test_builtins_static_dependency_order`, `test_ontology_consistency`) green; catalog-protos + + audit-log unit tests green. Did **not** run the slt/testdrive suites or the live-server catalog-doc + regen (needs a full environmentd). **Deferred (see the PR-4 section):** the dedicated + `ROLLBACK`-timeout audit event (no config write to hang it off; needs a seam signal or a durable + tombstone-stamp — larger than PR 4's scope; the rollback is already visible via the tombstoned + record + none-desired drops); a live `mz_now()` timed-out indicator in `SHOW CLUSTERS` (the view is + indexed); and the live-server regen of the autogenerated catalog snapshots (hand-updated here to + match the generators). + +- _2026-06-02_ — **PR 3 review follow-up (on-timeout knob; fixup commit, same branch)** — addresses + the adversarial review of the durable, controller-honored `ON TIMEOUT` work. **Doc correctness + (major):** rewrote the stale `**Timeout action.**` paragraph on `reshape_alter_cluster_managed`, + which still claimed `COMMIT` was "collapsed into the tombstone-revert model". It now states the + current contract — the record carries `on_timeout` (default `ROLLBACK`) and the controller applies + it at the deadline only if the target has not hydrated (`ROLLBACK` drops the target set + retains the + tombstone, `COMMIT` cuts the realized config over to the un-hydrated target and clears the record; + success always takes precedence). **Seam coverage (minor):** added two `FakeCtx`-driven controller + tests that force `now` past the deadline with an un-hydrated target and drive `reconcile` end-to-end: + `graceful_rollback_at_timeout_drops_target_through_seam` (the in-flight target replica is dropped via + `apply`, the realized set reverts, the record is retained as a tombstone, second tick is a no-op) and + `graceful_commit_at_timeout_cuts_over_through_seam` (phase 1 advances `size` to the target and clears + the record, phase 2 drops the old replica, second tick converges). 21 controller tests total, all + pass. **Fold note (nit):** sharpened the `reshape_alter_cluster_managed` comment to state explicitly + that — unlike the target, which folds per-dimension — the deadline and `on_timeout` are resolved + fresh and replaced wholesale by the latest `ALTER`'s `WAIT` clause. **Cheap checks:** `cargo + fmt --check` + `cargo check`/`clippy` clean on `mz-cluster-controller` and `mz-adapter`; `Cargo.lock` + unchanged. No scope change; stays dark behind the master gate. +- _2026-06-02_ — **PR 3 completed: durable, controller-honored `ON TIMEOUT` (default `ROLLBACK`)** + — the three reopened checklist items, in two commits on `cluster-autoscaling`. **(1) PR-1 + `fixup!` commit** (against the v85→v86 catalog commit): `on_timeout: OnTimeoutAction` added to + the durable `ReconfigurationState`. v86 is unshipped, so the proto is revised in place — + `ReconfigurationState` gains the field and a mirrored `OnTimeoutAction` proto enum + (`objects.rs` + the `objects_v86.rs` snapshot, both hashes updated in `objects_hashes.json`), + with the `RustType` conversion alongside the other autoscaling types in catalog-protos + `serialization.rs`. The durable serialization, the in-memory mirror and its `From` conversions, + and the adapter↔controller record conversions all thread the field; `mz_sql::plan::OnTimeoutAction` + gained `Copy`/serde/ordering derives so both the durable and memory layers can reference it without + conversion, like `ClusterSchedule`. The v86 encoding snapshot (`objects_v86.txt`) was regenerated + (decoding the old snapshot into the new struct fails on the missing field — expected for an + unshipped version). The implicit default stays `COMMIT` in this commit (behavior-preserving). **(2) + PR-3 commit:** `GracefulReconfigurationStrategy::update_state` now honors `on_timeout` — past the + deadline un-hydrated, `Rollback` parks (drops the target set, tombstones the record; the existing + behavior) and `Commit` cuts over the un-hydrated target and clears the record; `desired_replicas` + keeps the target desired under `Commit` (it becomes the realized set at cut-over) and drops it under + `Rollback`. Success precedence is unchanged (a hydrated target cuts over regardless of the action). + The controller carries its own `OnTimeout` enum (no `mz_sql` dep in the pure crate); the adapter + driver maps `OnTimeoutAction`↔`OnTimeout`. The planner's `OnTimeoutAction::default()` flipped + `COMMIT`→`ROLLBACK` globally (also the legacy foreground default, which reads the same `default()` — + no test relied on the implicit default, all `WAIT UNTIL READY` tests pass `ON TIMEOUT` explicitly). + The reshape threads the action from the `WITH (WAIT ...)` plan into the record (`WAIT FOR` → + `COMMIT`; no `WAIT` → default `ROLLBACK`; a fold overwrites it with the latest `ALTER`'s). + **Tests:** two new graceful kernel tests (`graceful_commit_on_timeout_cuts_over_unhydrated`, + `graceful_rollback_on_timeout_before_deadline_still_overlaps`; 19 controller tests total, all pass) + plus the existing `graceful_timeout_parks_and_drops_target` as the `ROLLBACK`-at-timeout case; + `cluster-controller.td` extended with an `ON TIMEOUT` section (omitted default + both explicit + actions + `WAIT FOR`, authored for CI). **Cheap checks:** `cargo fmt` + `cargo check`/`clippy` clean + on `mz-cluster-controller`/`mz-adapter`/`mz-sql`/`mz-catalog`/`mz-catalog-protos`; `bin/lint-cargo` + clean; `Cargo.lock` unchanged; the catalog `durable::` suite (163 passed) and the adapter cluster + fold unit tests pass. Did **not** run the slt suite or the full optimized build. **Deferred (see the + PR-3 section):** the dedicated deadline-carrying *timeout-fired* audit event (PR 4's reconfiguration + audit lifecycle owns the event family); the action is already attributable through the existing + reason-carrying ops. A deterministic ROLLBACK-vs-COMMIT-*at-timeout* slt is not feasible (an empty + slt cluster hydrates before any deadline) — that behavior is covered by the kernel tests. + **Fixup note:** the `on_timeout` durable field is a `fixup!` against the PR-1 catalog commit and + should be squashed into it when PR 1 is finalized. + +- _2026-06-02_ — **PR 3 design refinement (docs only): keep the existing `WITH (WAIT ...)` syntax; + `ON TIMEOUT` becomes a durable, controller-honored knob defaulting to `ROLLBACK`.** Settled the two + timeout-related PR-3 review items in the design rather than carrying them as deferrals. + (1) **No new token:** we do *not* add a top-level `WITH (TIMEOUT = ...)`; the existing + `WITH (WAIT FOR '')` / `WITH (WAIT UNTIL READY (TIMEOUT '', ON TIMEOUT COMMIT|ROLLBACK))` + surface is the permanent spelling, with `WAIT FOR` defined as sugar for + `UNTIL READY (TIMEOUT '', ON TIMEOUT COMMIT)` (it loses only the now-meaningless "wait the full + duration even when ready early" property). (2) **Honor `on_timeout`:** instead of always reverting, + the controller now applies the action — added as a durable field on `ReconfigurationState`, written + by the reshape from the `WITH (WAIT ...)` plan, and applied in `update_state` (`ROLLBACK` = drop the + whole target set + tombstone; `COMMIT` = cut over un-hydrated and clear), with an audit event for the + action taken. Success precedence is unchanged. (3) **Default flip:** the implicit `ON TIMEOUT` default + goes `COMMIT`→`ROLLBACK` **globally** (planner `OnTimeoutAction::default()`) — a deliberate + safe-default change that also affects the **legacy foreground path** (chosen so the same syntax never + means different things across the gate, and so a timeout never silently induces downtime by cutting + over to an unhydrated target). Design doc updated (*Per-`ALTER` timeout*, *Stuck reconfiguration*, + *Notable user-facing changes*, success criteria, dyncfgs). PR 3 reopened to 🚧; remaining code work + (durable field as a PR-1 `fixup!`, strategy honoring + audit, the default flip + `on_timeout` + threading) is tracked in the PR 3 checklist. **No code in this entry — docs only.** + +- _2026-06-02_ — **PR 3 review follow-up** (fixup commit, same branch; addresses the adversarial + review). **Fold correctness:** a fold of an `ALTER` issued while a `reconfiguration` is in flight + no longer reverts dimensions the `ALTER` did not mention. `reshape_alter_cluster_managed` now + overlays the new `ALTER` onto the **in-flight target** — a dimension left `Unchanged` keeps the + in-flight target's value rather than the realized (pre-reconfiguration) value `new_config` carried — + via the new pure helper `fold_reconfiguration_target` (unit-tested: no-record passthrough, rf-only + keeps the in-flight shape, all-set overwrite, all-unchanged ALTER-back). Previously an rf-only or + workload_class-only `ALTER` mid-flight silently discarded the in-flight size/AZ/logging. **Wait-shim + vs. success-precedence:** the foreground shim no longer reports a spurious timeout on a + reconfiguration the controller is about to (or just did) complete. Past the deadline with the record + still present it grants **one grace re-poll** (`past_deadline_grace_used`) before erroring, so the + controller's success-precedence cut-over (hydrated-past-deadline still cuts over) can clear the + record first; the strategy's tombstone is stable, so a record still present after the grace re-poll + is a genuine timeout. **`ON TIMEOUT COMMIT`:** documented as intentionally collapsed into the + tombstone-revert (`ROLLBACK`) model on `reshape_alter_cluster_managed` and the Deferred list — + committing a not-fully-hydrated target would break the HA guarantee the overlap exists for. **slt:** + the second graceful `ALTER` is now a genuine reshape to a third size (was an identical no-op that + early-returned before the reshape branch, proving nothing about record-clearing). **Hydration probe:** + documented why `Coordinator::hydrated_replicas` must probe per-replica (the compute/storage APIs + collapse a replica list to a single "hydrated on any" bool, so a batched call would lose the + per-replica granularity the cut-over needs); phase-2 already reuses the phase-1 hydration when phase + 1 wrote nothing. Dropped a redundant `.clone()` on the `Copy` `cluster_alter_check_ready_interval()`. + Cheap checks re-run: `cargo fmt --check` + `cargo check`/`clippy` clean on `mz-cluster-controller` + and `mz-adapter`; new fold unit tests + the 17 controller tests pass. +- _2026-06-02_ — **PR 3 implemented** (graceful reconfiguration strategy + `ALTER` reshape + + wait-shim, all dark behind the master gate). **Strategy:** new pure `GracefulReconfigurationStrategy` + in `mz-cluster-controller` — engaged whenever the durable `reconfiguration` record is present; + `desired_replicas` contributes `target.replication_factor` replicas at the target shape (size + + logging + AZ list, all diffable thanks to PR 1) on top of the baseline's realized set (the + hydrate-overlap), and stops contributing them on timeout (`now > deadline` && target not fully + hydrated → park, the controller drops the in-flight target set, the record is retained as a + tombstone); `update_state` cuts over (`cluster.{size,rf,az,logging} := target`, clears the record) + once the target replicas are **all** present and hydrated — success takes precedence over the + deadline. Registered in `ClusterController::new()` alongside the baseline. **Hydration seam:** the + PR-2 stub `collections_hydrated_on_replicas(cluster, replicas, collections) -> bool` (whose + `collections` include-list the underlying controller APIs cannot express) was reshaped into + `hydrated_replicas(cluster, replicas) -> BTreeSet` — "of these replicas, which have all + current non-transient collections on the cluster hydrated". The controller pulls it + **on demand**: `enrich_hydration` probes a cluster's replicas only while a `reconfiguration` is in + flight (steady clusters are never probed), and threads the result into the new live-signal field + `ClusterState::hydrated_replicas` (excluded from the CaA `expected` witness — it is a signal, not + durable state). The adapter driver backs it per-replica against + `ComputeController::collections_hydrated_for_replicas` + `StorageController::collections_hydrated_on_replicas` + with an empty exclude set (a replica counts as hydrated iff both report it). **`ALTER` reshape:** + when `enable_cluster_controller` is on and a managed→managed `ALTER` touches a replica's config + shape (SIZE / logging / AVAILABILITY ZONES) — or any `ALTER` while a record is already in flight — + it is routed to `reshape_alter_cluster_managed`, which writes/folds the `reconfiguration` record + (full target shape + deadline) onto the **realized** config in one txn (only `workload_class`, which + needs no overlap, is applied immediately) and leaves the realized shape in place; the legacy + 3-stage machine still runs for gate-off and for non-shape changes (rf-only, workload_class) with no + record in flight. Deadline = `now + timeout`, timeout from the existing `WITH (WAIT ...)` strategy + or the new `default_cluster_reconfiguration_timeout` dyncfg. **Wait-shim:** new + `ClusterStage::AwaitReconfiguration` polls the durable record at `cluster_alter_check_ready_interval` + — cleared = done, past-deadline tombstone = `AlterClusterTimeout`; with the new + `enable_background_alter_cluster` dyncfg on, `ALTER` returns immediately instead. Session disconnect + no longer aborts the reconfiguration (the record is durable; the controller carries on). **Audit:** + new `ReplicaCreateDropReason::GracefulReconfiguration` → `CreateOrDropClusterReplicaReasonV1::Reconfiguration` + (rust enum + `objects.rs`/`objects_v86.rs` proto enum revised in place since v86 is unshipped, hashes + updated, `RustType` conversion threaded); the controller maps graceful-desired creates to it via + per-decision strategy attribution. Added dyncfgs `enable_background_alter_cluster` (false) and + `default_cluster_reconfiguration_timeout` (24h), registered in `all_dyncfgs`. **Tests:** 8 new + graceful kernel/flow tests (17 total in `mz-cluster-controller`, all pass) covering in-flight desire, + cut-over on full hydration, partial-hydration no-cutover, timeout-vs-hydrated precedence, timeout + park+drop, AZ-only shape change, full overlap→cut-over→old-set-drop with attribution, and ALTER-back + no-churn; the fake ctx now drives hydration. Extended `cluster-controller.td` (gate + background + forced on) to assert a background `ALTER SIZE` cuts the realized `mz_clusters.size` over and settles + the replica set — authored for CI, not run locally. **Cheap checks:** `cargo fmt` + `cargo + check`/`clippy` clean on `mz-cluster-controller`/`mz-adapter`/`mz-adapter-types`/`mz-catalog-protos`/ + `mz-audit-log`/`mz-catalog`; `bin/lint-cargo` clean; `mz-catalog-protos` snapshot + `mz-catalog` + `durable::` suite (163 passed) green; `Cargo.lock` unchanged (no new deps). Did **not** run the slt + suite, platform-checks, or the full optimized build. **Deferred (see PR-3 section):** the bare + `WITH (TIMEOUT = ...)` parser token (timeout sourced from the existing `WAIT` plumbing instead) and + the restart-survival platform-check (would flip the master gate env-wide in the shared dark suite). + Old-set drops at cut-over carry `Manual` (none-desired); richer reconfiguration drop-lifecycle audit + attribution lands in PR 4. +- _2026-06-02_ — **PR 2 implemented** (controller scaffolding + baseline strategy + coordinator + wiring, all dark). New pure crate `mz-cluster-controller` (deps: `mz-controller-types`, + `mz-compute-types`, `mz-repr`, `mz-ore`, `async-trait`; no adapter/catalog dep, no new + third-party license). It defines the **`ClusterControllerCtx`** seam (batched pulls: + `managed_cluster_ids`, `cluster_states` with latched `now`, `collections_hydrated_on_replicas` + stubbed for PR 3; one CaA-guarded `apply`), the pure **`Strategy`** trait + (`update_state`/`desired_replicas`), the **`BaselineStrategy`** (desires `replication_factor` + replicas at the realized shape), and the **reconcile kernel**: phase 1 unions every strategy's + `update_state` into one `UpdateClusterState` per cluster and applies under CaA (rejected clusters + are skipped this tick); phase 2 re-reads, unions `desired_replicas` (multiset union = max per + shape, not sum), matches by `ReplicaShape` against actual, and emits creates (fresh names that + avoid in-use `rNN`) / drops with strategy attribution (phase 2 reuses the phase-1 read when no + state was written). **Compare-and-append:** every decision — the `UpdateClusterState` writes and + the create/drop batch alike — carries the `ExpectedClusterState` it was diffed against + (`ClusterState::expected()`); the apply path re-reads each cluster's durable config + records and + rejects the whole batch on any mismatch, so a stale create/drop can never reshape the replica set + against a config a concurrent `ALTER` established (recomputed next tick). Decision 1 = **separate + task**: the adapter driver `coord/cluster_controller.rs` runs the controller on its own + `mz_ore::task::spawn`, and its `CoordCtx` marshals each ctx call to the coordinator loop via + `Message::ClusterControllerRequest(..)` + oneshot; on a held guard it builds + `Op::UpdateClusterConfig` (cut-over/record-write from the `StateWrite` deltas), + `Op::CreateClusterReplica` (reusing `concretize_replica_location`), and `Op::DropObjects`, + transacted via `catalog_transact`. Added dyncfgs `enable_cluster_controller` (default **false**) + and `cluster_controller_tick_interval` (5s), both re-read each tick — a gate flip needs no restart + and the cadence is a live operational knob; with the gate off, reads return no clusters and + applies reject, keeping the controller fully inert and all legacy paths unchanged. Create/drop + audit currently uses `ReplicaCreateDropReason::Manual` as an interim tag — PR 3 introduces the + controller-specific, attribution-carrying reason (the controller is dark, so the tag is immaterial + until then). The frontier/read-ts ctx reads land with their first consumer (PR 3/5), not as + speculative stubs (their shape depends on that consumer and would pull an unused frontier dep into + the pure crate). Tests: 9 boundary/kernel tests against a fake ctx (steady no-op, + under/over-provision, wrong-shape drop+create, union max-not-sum, distinct-shape attribution, CaA + reject-and-recover against a state a concurrent `ALTER` changed, and a direct phase-2 create/drop + guard test) all pass; an slt (`cluster-controller.td`, gate forced on) drives the interval to + 5ms, waits across hundreds of ticks, and asserts a steady managed cluster's replica ids+names are + unchanged — not satisfiable by gate-off behaviour that never runs the loop; authored for CI, not + run locally. Cheap checks: `cargo fmt` + `cargo check`/`cargo clippy` clean on + `mz-cluster-controller`/`mz-adapter`/`mz-adapter-types`; `bin/lint-cargo` clean; `Cargo.lock` + gained only the new-crate entry (no version bumps). Did **not** run the full optimized build, the + slt suite, or generate `doc/developer/generated/` crate docs (regen deferred, as in PR 1). +- _2026-06-01_ — **PR 1 AZ modeling reworked.** Reworked the durable availability-zone change + rather than carrying forward the two-field shape from the entries below. + The managed `ReplicaLocation`'s single `availability_zone` user-pin is **collapsed** into one + `availability_zones: Vec` (the zones the replica was provisioned under, a managed cluster's + `AVAILABILITY ZONES` pool, or an unmanaged replica's pin as a 0/1-element list), replacing the + separate `provisioned_availability_zones` field. The two were mutually exclusive (concretize even + errored if both were set) and both collapse to a list at the orchestrator, so the split was + redundant. v86 is unshipped, so it is revised in place: one migration, the collapsed shape. With the + durable field now storing the list unconditionally, the in-memory `ManagedReplicaAvailabilityZones` + enum is also collapsed to a bare `Vec` (empty = no constraint), so the in-memory to durable + `From` is a passthrough and the orchestrator maps an empty list to no-constraint. Concretize stays + behaviour-preserving (re-derives the managed pool from the cluster on create and reshape, keeps the + durable provisioned list on rebuild, reads the list as the pin for unmanaged), so PR 1 stays dark. + Per decision, the stable public `mz_cluster_replicas.availability_zone` column is left unchanged + (still the unmanaged replica's single pin, now derived from the list + the cluster's managed-ness); + the `guswynn` TODO is replaced with a comment recording the future plural-`text list` rename and its + consumers (console types, dbt macros, docs, slt). Cheap checks: `cargo fmt` + `cargo check + -p mz-controller -p mz-catalog -p mz-catalog-protos -p mz-adapter` clean; full `durable::` suite + (163 passed, incl. `test_proto_serialization_stability`, `proptest_state_update_kind_roundtrip`, + v85↔v86 json-compat round-trips, migration tests); `objects_v86.txt` regenerated. +- _2026-06-01_ — **PR 1 boundary refactor.** Removed the deviation that the in-memory + `ClusterVariantManaged` embedded durable-only autoscaling types (which forced serde derives on + those durable types, unlike every other durable type). Re-homed each type per the existing + convention, by kind: (1) the *user-configured policy* `AutoScalingStrategy`/`OnHydration` moved to + `mz_sql::plan` and is now referenced by **both** layers with no conversion, exactly like + `ClusterSchedule` (its `RustType` impls live in `mz-catalog-protos`'s `serialization.rs` + alongside `ClusterSchedule`'s, per Rust's orphan rules); (2) the *in-flight runtime* records + `ReconfigurationState`/`ReconfigurationTarget`/`BurstState` stay durable-only and lose their serde + derives, with new in-memory mirror types in `memory::objects` carrying serde and `From` conversions + in both directions, mirroring the `optimizer_feature_overrides` pattern (runtime controller state + does not belong in the SQL planning crate, and `mz-cluster-controller` does not exist until PR 2). + Purely a relocation of Rust type definitions/derives and conversion plumbing: the proto message + types, `objects_v86.rs`/`objects_v86.txt`/`objects_hashes.json`, and the v85→v86 migration are + untouched, so the on-disk encoding and migration semantics are unchanged and PR 1 stays dark (no + new field is read). Cheap checks: `cargo fmt --check` + `cargo check` + `cargo clippy` on + `mz-sql`/`mz-catalog`/`mz-catalog-protos`/`mz-adapter` clean; `mz-catalog-protos` snapshot tests + and the full `mz-catalog durable::` suite (163 passed, incl. `test_proto_serialization_stability`, + `proptest_state_update_kind_roundtrip`, the json-compat round-trips, and the v85→v86 migration + tests) pass. +- _2026-06-01_ — **PR 1 review follow-up.** Addressed the review of the implementation commit: + (1) clarified the contract of `provisioned_availability_zones` and made the two write paths + agree — it is now the cluster-imposed AZ pool on both, so `FromReplica` (a non-managed cluster's + managed location) contributes only the single `availability_zone` user-pin and an empty list, + matching the migration's empty backfill for unmanaged-cluster replicas; (2) rewrote `v85_to_v86.rs` + to use `JsonCompatible::convert` for unchanged sub-structures (per the directory convention), + reconstructing only the managed `Cluster` variant and managed `ReplicaLocation`, and to skip + byte-identical unmanaged records rather than emit no-op retract+add pairs; (3) added a `nota bene` + documenting why the durable autoscaling types carry serde derives (the in-memory mirror backing + `dump()` requires them) — the review's suggestion to drop them was declined because removing them + breaks compilation. Cheap checks: `cargo fmt --check` + `cargo check -p mz-catalog + -p mz-catalog-protos -p mz-adapter` clean; full `durable::` test suite (163 passed, incl. the 18 + new generated json-compat round-trip proptests and `test_proto_serialization_stability`) and the + catalog-protos snapshot tests pass. +- _2026-06-01_ — **PR 1 implemented** (durable state model + migration v85→v86, additive/inert). + Added durable + in-memory + proto types `AutoScalingStrategy`/`OnHydration`, + `ReconfigurationState`/`ReconfigurationTarget`, `BurstState` as `Option` fields on + `ClusterVariantManaged` (decision 3), with target shape `{ size, replication_factor, + availability_zones, logging }` (decision 4). Added `provisioned_availability_zones: Vec` + to durable `ReplicaLocation::Managed`; new managed replicas derive it from + `ManagedReplicaAvailabilityZones` in the controller→durable `From`, and the migration backfills + existing managed replicas from their cluster's `availability_zones`. Bumped `CATALOG_VERSION` to 86, + snapshotted `objects_v86.rs` (+ `objects_hashes.json`), wrote `v85_to_v86.rs` (rewrites every + managed `Cluster`/`ClusterReplica` record), and generated `objects_v86.txt`. No new fields are read + yet → no behaviour change; the `pending` drop and rf-normalization stay deferred to later PRs + (decision 7). Cheap checks: `cargo fmt` clean; `cargo check -p mz-catalog -p mz-catalog-protos + -p mz-adapter` clean. Tests run: catalog-protos snapshot assertions + all 144 catalog durable tests + (incl. four new migration unit tests and the proto round-trip proptest). Did **not** run the full + optimized/release build or `cargo test` over the whole workspace. +- _2026-06-01_ — Reordered the rollout: burst is the last *feature* PR (PR 6), so all of PRs 1–6 + land **dark**. Enabling is an operational LaunchDarkly flip + prod bake (not a code change); + the final PR 7 (flip defaults to true + remove legacy paths + drop `pending`) lands **only after** + the bake — we never enable and remove-the-fallback in one step. Scheduled-cluster rf is normalized + by the controller at runtime, so no rf migration. +- _2026-06-01_ — Plan created against the realized-fact design (no implementation in the tree + yet; PR 1 is next). The controller↔coordinator boundary is an agnostic **pull** interface + (`ClusterControllerCtx`), not a coordinator-pushed snapshot; testing focuses on user-visible + behavior + the interface seam with minimal kernel unit tests; burst replicas are ordinary + replicas in the reconciler (no tag/marker). diff --git a/doc/user/content/reference/system-catalog/mz_internal.md b/doc/user/content/reference/system-catalog/mz_internal.md index 82fb9be822879..2512118020803 100644 --- a/doc/user/content/reference/system-catalog/mz_internal.md +++ b/doc/user/content/reference/system-catalog/mz_internal.md @@ -165,6 +165,34 @@ The `mz_cluster_schedules` table shows the `SCHEDULE` option specified for each | `type` | [`text`] | `on-refresh`, or `manual`. Default: `manual` | | `refresh_hydration_time_estimate` | [`interval`] | The interval given in the `HYDRATION TIME ESTIMATE` option. | +## `mz_cluster_reconfigurations` + +The `mz_cluster_reconfigurations` table shows the in-flight graceful reconfiguration of each managed +cluster that has one. A row is present only while a background `ALTER CLUSTER` is converging on a +new configuration; the realized (current) shape is in +[`mz_clusters`](../mz_catalog/#mz_clusters). + + +| Field | Type | Meaning | +|----------------|------------------|----------------------------------------------------------------| +| `cluster_id` | [`text`] | The ID of the cluster. Corresponds to [`mz_clusters.id`](../mz_catalog/#mz_clusters). | +| `deadline` | [`mz_timestamp`] | The deadline by which the reconfiguration must complete; after it passes the `on_timeout` action applies. Compare against `mz_now()` to distinguish an in-progress reconfiguration from one past its deadline. | +| `on_timeout` | [`text`] | The action applied if `deadline` passes before the target hydrates: `commit` (cut over to the not-yet-hydrated target) or `rollback` (revert to the pre-reconfiguration shape). | +| `target` | [`jsonb`] | The config shape the cluster is reconfiguring to, as JSON: `size`, `replication_factor`, `availability_zones`, and `logging`. The realized (current) shape is in `mz_clusters`. | + +## `mz_cluster_auto_scaling_strategies` + +The `mz_cluster_auto_scaling_strategies` table shows the configured `AUTO SCALING STRATEGY` of each +managed cluster that has one, together with any in-flight autoscaling state. A row is present while +a strategy is configured or an autoscaling action is running. + + +| Field | Type | Meaning | +|----------------|-----------|----------------------------------------------------------------| +| `cluster_id` | [`text`] | The ID of the cluster. Corresponds to [`mz_clusters.id`](../mz_catalog/#mz_clusters). | +| `strategy` | [`jsonb`] | **Unstable** The configured autoscaling policy, as JSON. Currently an `on_hydration` sub-policy carrying its `hydration_size` and optional `linger_duration`. | +| `state` | [`jsonb`] | **Unstable** The in-flight autoscaling runtime state, as JSON keyed by strategy, or `NULL` when nothing is running. Currently a `burst` key carrying the active hydration burst: its `burst_size`, `linger_duration`, and `steady_hydrated_at`. | + ## `mz_cluster_replica_metrics` The `mz_cluster_replica_metrics` view gives the last known CPU and RAM utilization statistics diff --git a/misc/python/materialize/mzcompose/__init__.py b/misc/python/materialize/mzcompose/__init__.py index 8751214bee185..0ec27c7b86189 100644 --- a/misc/python/materialize/mzcompose/__init__.py +++ b/misc/python/materialize/mzcompose/__init__.py @@ -96,6 +96,16 @@ def get_minimal_system_parameters( "enable_refresh_every_mvs": "true", "enable_replacement_materialized_views": "true", "enable_cluster_schedule_refresh": "true", + # The cluster controller and background ALTER CLUSTER land dark in + # production (the dyncfg defaults stay false); force them on for the test + # harness so CI exercises the controller owning the managed-cluster + # replica set. The real production default flip is a separate rollout. + "enable_cluster_controller": ( + "true" if version >= MzVersion.parse_mz("v26.29.0-dev") else "false" + ), + "enable_background_alter_cluster": ( + "true" if version >= MzVersion.parse_mz("v26.29.0-dev") else "false" + ), "enable_s3_tables_region_check": "false", "enable_statement_lifecycle_logging": "true", "enable_storage_introspection_logs": "true", @@ -673,6 +683,10 @@ def get_default_system_parameters( "enable_mcp_developer_query_tool", "mcp_max_response_size", "user_id_pool_batch_size", + "cluster_controller_tick_interval", + "default_cluster_reconfiguration_timeout", + "enable_hydration_burst", + "default_hydration_burst_linger", ] diff --git a/misc/python/materialize/parallel_workload/action.py b/misc/python/materialize/parallel_workload/action.py index 8991a1b1a5110..2dfe65fe91419 100644 --- a/misc/python/materialize/parallel_workload/action.py +++ b/misc/python/materialize/parallel_workload/action.py @@ -1864,6 +1864,12 @@ def __init__( "oidc_group_role_sync_strict", "console_oidc_client_id", "console_oidc_scopes", + "enable_cluster_controller", + "cluster_controller_tick_interval", + "enable_background_alter_cluster", + "default_cluster_reconfiguration_timeout", + "enable_hydration_burst", + "default_hydration_burst_linger", ] def run(self, exe: Executor) -> bool: diff --git a/pm-showcase-cluster-controller.md b/pm-showcase-cluster-controller.md new file mode 100644 index 0000000000000..e43dbc94543ae --- /dev/null +++ b/pm-showcase-cluster-controller.md @@ -0,0 +1,607 @@ +# Cluster controller: graceful reconfiguration, burst autoscaling, and full visibility + +This document showcases the new cluster-management capabilities for product. +Every SQL statement and result below was captured verbatim from a locally +running Materialize built from this branch — nothing is mocked or +hand-written. Two cosmetic notes: + +- Local development builds use replica sizes spelled `scale=1,workers=2`; in + cloud these read `100cc`, `200cc`, etc. Read `scale=1,workers=1` as "small" + and `scale=1,workers=8` as "8x larger". +- To make transitions observable on a demo timescale, the demo clusters carry + a deliberately expensive index that takes ~50 seconds to hydrate on a + 1-worker replica — a stand-in for real-world dataflows that take minutes to + hours. Setup statements are in Appendix B. + +## TL;DR — what's new for users + +- **Resizing a cluster is now zero-downtime and runs in the background.** + `ALTER CLUSTER ... SET (SIZE = ...)` returns in milliseconds. Materialize + provisions the new replicas alongside the old ones, waits until they have + fully hydrated, and only then cuts over and retires the old ones. The + cluster answers queries throughout. The operation is durable: it survives + session disconnects and a full `environmentd` restart. +- **Clusters can autoscale for hydration.** A new cluster option, + `AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = ...))`, makes + Materialize temporarily run one extra, larger replica whenever the cluster + has objects that are not yet hydrated. The burst replica serves results + long before the steady replica is ready, then tears itself down. +- **You can always see what's happening.** `SHOW CLUSTERS` now answers "what + did I ask for, what is actually running, is something in progress" in one + command; a new view `mz_internal.mz_cluster_reconfigurations` carries the + detail; every transition lands in the audit log with a reason. + +--- + +## Scenario 1: resizing a cluster with zero downtime + +`prod_analytics` is a cluster at size `scale=1,workers=1` serving two +indexes: a cheap one (`order_totals_idx`) and the expensive +`event_fingerprint_idx` described above. + +### The resize returns immediately + +``` +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=2'); +Time: 104.202 ms +``` + +That's it — no session to babysit. The reconfiguration now runs in the +background. + +### Watching it happen + +`SHOW CLUSTERS` immediately shows the current and the target shape, the +in-flight flag, and the overlapping replica sets: + +``` +SHOW CLUSTERS WHERE name = 'prod_analytics'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +----------------+------------------------------------------------+-------------------+-------------------+---------------------------+------------+--------- + prod_analytics | r1 (scale=1,workers=1), r2 (scale=1,workers=2) | scale=1,workers=1 | scale=1,workers=2 | t | | +(1 row) +``` + +The new introspection view adds the enforcement deadline. This `ALTER` gave +no explicit timeout, so the system default of 1 day applies — a transition is +never unbounded: + +``` +SELECT c.name, r.current_size, r.target_size, + r.reconfiguration_in_flight AS in_flight, + to_timestamp(r.reconfiguration_deadline::text::numeric / 1000) AS deadline +FROM mz_internal.mz_cluster_reconfigurations r +JOIN mz_clusters c ON c.id = r.cluster_id +WHERE c.name = 'prod_analytics'; + name | current_size | target_size | in_flight | deadline +----------------+-------------------+-------------------+-----------+---------------------------- + prod_analytics | scale=1,workers=1 | scale=1,workers=2 | t | 2026-06-11 23:58:22.012+00 +(1 row) +``` + +### No downtime + +Mid-reconfiguration — while the new replica is still hydrating — queries +against both indexes answer in milliseconds, served by the old replica: + +``` +SELECT total FROM order_totals WHERE id = 42; + total +------- + 100 +(1 row) +Time: 11.176 ms + +SELECT fp FROM event_fingerprint; + fp +---------------------------------- + ffffebfcda3c1606012f242a4104711e +(1 row) +Time: 19.350 ms +``` + +Note that `mz_clusters.size` still reports `scale=1,workers=1`: the catalog +reports the *realized* configuration — what is actually serving — and the +pending target is surfaced separately. Some 40 seconds later the new replica +has hydrated, the controller cuts over, and everything reads the new size: + +``` +SHOW CLUSTERS WHERE name = 'prod_analytics'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +----------------+------------------------+-------------------+-------------------+---------------------------+------------+--------- + prod_analytics | r2 (scale=1,workers=2) | scale=1,workers=2 | scale=1,workers=2 | f | | +(1 row) +``` + +### A full audit trail + +Both the cluster-level transitions and every replica the controller touched +are recorded in `mz_audit_events`. Replica creates carry the strategy that +provisioned them as their reason; a replica the cluster's configuration no +longer calls for is dropped with reason `retired`: + +``` +SELECT details->>'transition' AS transition, + details->>'target_size' AS target_size, occurred_at +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'prod_analytics' + AND details->>'transition' IS NOT NULL +ORDER BY id; + transition | target_size | occurred_at +------------+-------------------+---------------------------- + started | scale=1,workers=2 | 2026-06-10 23:58:22.013+00 + finalized | scale=1,workers=2 | 2026-06-10 23:59:05.21+00 +(2 rows) + +SELECT event_type, details->>'replica_name' AS replica, + details->>'logical_size' AS size, details->>'reason' AS reason +FROM mz_catalog.mz_audit_events +WHERE object_type = 'cluster-replica' + AND details->>'cluster_name' = 'prod_analytics' +ORDER BY id; + event_type | replica | size | reason +------------+---------+-------------------+----------------- + create | r1 | scale=1,workers=1 | manual + create | r2 | scale=1,workers=2 | reconfiguration + drop | r1 | | retired +(3 rows) +``` + +### Changing your mind: cancellation + +Re-issuing `ALTER CLUSTER` while a reconfiguration is in flight simply +re-targets it; issuing it with the *current* size cancels. Here we start a +move to `workers=4`, then cancel it — the in-flight replica is dropped and +the audit log records the change of heart: + +``` +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=4'); +SHOW CLUSTERS WHERE name = 'prod_analytics'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +----------------+------------------------------------------------+-------------------+-------------------+---------------------------+------------+--------- + prod_analytics | r2 (scale=1,workers=2), r3 (scale=1,workers=4) | scale=1,workers=2 | scale=1,workers=4 | t | | +(1 row) + +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=2'); +-- a few seconds later: +SHOW CLUSTERS WHERE name = 'prod_analytics'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +----------------+------------------------+-------------------+-------------------+---------------------------+------------+--------- + prod_analytics | r2 (scale=1,workers=2) | scale=1,workers=2 | scale=1,workers=2 | f | | +(1 row) + + transition | target_size +------------+------------------- + started | scale=1,workers=2 + finalized | scale=1,workers=2 + started | scale=1,workers=4 + cancelled | scale=1,workers=2 + finalized | scale=1,workers=2 +(5 rows) +``` + +### Bounding a reconfiguration: timeouts that survive disconnects + +`WITH (WAIT UNTIL READY (TIMEOUT ..., ON TIMEOUT ...))` bounds an individual +reconfiguration. The deadline is stored in the catalog and enforced by the +system, not by the user's session — closing the laptop no longer aborts +anything. The default action, `ROLLBACK`, is the safe one: if the target +can't hydrate in time, the cluster stays on its current shape and keeps +serving. + +Here we try to *downsize* to a shape that cannot hydrate within a 10-second +deadline. While the clock runs, both replica sets are up: + +``` +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=1') + WITH (WAIT UNTIL READY (TIMEOUT '10s', ON TIMEOUT 'ROLLBACK')); + +SHOW CLUSTER REPLICAS WHERE cluster = 'prod_analytics'; + cluster | replica | size | ready | comment +----------------+---------+-------------------+-------+--------- + prod_analytics | r2 | scale=1,workers=2 | t | + prod_analytics | r3 | scale=1,workers=1 | f | +(2 rows) +``` + +At the deadline the controller rolls back on its own: the not-yet-hydrated +target replica is dropped, the realized configuration is untouched, and the +cluster reads settled again — never having stopped serving: + +``` +-- 15 seconds later: +SHOW CLUSTERS WHERE name = 'prod_analytics'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +----------------+------------------------+-------------------+-------------------+---------------------------+------------+--------- + prod_analytics | r2 (scale=1,workers=2) | scale=1,workers=2 | scale=1,workers=2 | f | | +(1 row) + +SELECT total FROM order_totals WHERE id = 42; + total +------- + 100 +(1 row) +``` + +The abandoned target isn't lost: the timeout is recorded as a durable +`timed-out` transition in the audit log, carrying the deadline and the target +that didn't make it. (`finalized` events carry the deadline too, so a late or +forced cut-over is distinguishable from an in-time one.) + +``` +SELECT details->>'transition' AS transition, + details->>'target_size' AS target_size, + to_timestamp((details->>'deadline')::numeric / 1000) AS deadline +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'prod_analytics' + AND details->>'transition' IS NOT NULL +ORDER BY id DESC LIMIT 2; + transition | target_size | deadline +------------+-------------------+--------------------------- + timed-out | scale=1,workers=1 | 2026-06-10 23:59:23.09+00 + started | scale=1,workers=1 | 2026-06-10 23:59:23.09+00 +(2 rows) +``` + +### Surviving a restart + +The user's intent is durable, so a reconfiguration continues across a full +`environmentd` restart. We start one (back down to `workers=1`), then kill +`environmentd` mid-flight and restart it. Immediately after the restart: + +``` +SHOW CLUSTERS WHERE name = 'prod_analytics'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +----------------+------------------------------------------------+-------------------+-------------------+---------------------------+------------+--------- + prod_analytics | r2 (scale=1,workers=2), r3 (scale=1,workers=1) | scale=1,workers=2 | scale=1,workers=1 | t | | +(1 row) +``` + +— still in flight, same target, and it completes on its own. The audit trail +shows one continuous operation spanning the crash (`started` at 23:59:29, +kill at ~23:59:37, `finalized` at 00:00:43): + +``` + transition | target_size | occurred_at +------------+-------------------+---------------------------- + finalized | scale=1,workers=1 | 2026-06-11 00:00:43.893+00 + started | scale=1,workers=1 | 2026-06-10 23:59:29.301+00 +(2 rows) +``` + +--- + +## Scenario 2: burst autoscaling for hydration + +A new cluster option declares the policy once; the system manages the burst +lifecycle from then on, with no user action: + +``` +CREATE CLUSTER fast_start ( + SIZE = 'scale=1,workers=1', + AUTO SCALING STRATEGY = (ON HYDRATION ( + HYDRATION SIZE = 'scale=1,workers=8', + LINGER DURATION = '15s')) +); + +SHOW CREATE CLUSTER fast_start; + fast_start | CREATE CLUSTER "fast_start" (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=8', LINGER DURATION = INTERVAL '00:00:15')), ..., REPLICATION FACTOR = 1, SIZE = 'scale=1,workers=1', SCHEDULE = MANUAL) +``` + +The policy is armed existentially: a burst runs only while some object on the +cluster is not yet hydrated. The freshly created cluster has no objects, so +nothing bursts — just the steady replica: + +``` +SHOW CLUSTERS WHERE name = 'fast_start'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +------------+------------------------+-------------------+-------------------+---------------------------+------------+--------- + fast_start | r1 (scale=1,workers=1) | scale=1,workers=1 | scale=1,workers=1 | f | | +(1 row) +``` + +### Burst fires when there is hydration work + +We attach an expensive index (~50s to hydrate at the cluster's steady size). +Within a tick, the controller runs an extra replica at the configured +`HYDRATION SIZE` — 8x the steady size — visible both in the replica list and +in the `burst_size` column: + +``` +CREATE INDEX pageview_fingerprint_idx IN CLUSTER fast_start ON pageview_fingerprint (fp); + +-- 4 seconds after attaching the index: +SHOW CLUSTERS WHERE name = 'fast_start'; + name | replicas | current_size | target_size | reconfiguration_in_flight | burst_size | comment +------------+------------------------------------------------+-------------------+-------------------+---------------------------+-------------------+--------- + fast_start | r1 (scale=1,workers=1), r2 (scale=1,workers=8) | scale=1,workers=1 | scale=1,workers=1 | f | scale=1,workers=8 | +(1 row) +``` + +### The payoff: results long before the steady replica is ready + +Half a minute in, the burst replica has fully hydrated the index while the +steady replica is still computing (it hasn't even reported hydration state +for the index yet) — and the cluster is already answering in milliseconds: + +``` +SELECT i.name AS index, cr.name AS replica, cr.size, h.hydrated +FROM mz_internal.mz_hydration_statuses h +JOIN mz_indexes i ON i.id = h.object_id +JOIN mz_cluster_replicas cr ON cr.id = h.replica_id +JOIN mz_clusters c ON c.id = cr.cluster_id +WHERE c.name = 'fast_start' AND i.name = 'pageview_fingerprint_idx' +ORDER BY cr.name; + index | replica | size | hydrated +--------------------------+---------+-------------------+---------- + pageview_fingerprint_idx | r2 | scale=1,workers=8 | t +(1 row) + +SELECT fp FROM pageview_fingerprint; + fp +---------------------------------- + ffffebfcda3c1606012f242a4104711e +(1 row) +Time: 15.738 ms +``` + +Without the burst, this query would have waited ~50 seconds for the steady +replica. + +### Burst tears itself down + +Once the steady replica hydrates, the burst replica lingers for the +configured `LINGER DURATION` (a guard against thrash while a user is actively +creating objects), then disappears on its own: + +``` +SHOW CLUSTER REPLICAS WHERE cluster = 'fast_start'; + cluster | replica | size | ready | comment +------------+---------+-------------------+-------+--------- + fast_start | r1 | scale=1,workers=1 | t | +(1 row) +``` + +The full lifecycle is in the audit log — burst transitions at the cluster +level, the replica creates with reason `hydration-burst`, and the teardown +drops with reason `retired`: + +``` + transition | burst_size | occurred_at +------------+-------------------+---------------------------- + started | scale=1,workers=8 | 2026-06-11 00:01:00.728+00 + finished | scale=1,workers=8 | 2026-06-11 00:02:17.058+00 +(2 rows) + + event_type | replica | size | reason +------------+---------+-------------------+----------------- + create | r1 | scale=1,workers=1 | manual + create | r2 | scale=1,workers=8 | hydration-burst + drop | r2 | | retired +(3 rows) +``` + +### Managing the policy, and guardrails + +The policy round-trips through `SHOW CREATE CLUSTER`, is removed with +`ALTER ... RESET`, and re-added or changed with `ALTER ... SET` (shown live +in the run; output as in the creation snippet above). Nonsensical +configurations are rejected up front: + +``` +CREATE CLUSTER bad_burst ( + SIZE = 'scale=1,workers=2', + AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=2')) +); +ERROR: HYDRATION SIZE must differ from the cluster SIZE ('scale=1,workers=2'); a burst replica at the same size would not accelerate hydration + +CREATE CLUSTER bad_burst ( + SIZE = 'scale=1,workers=1', + SCHEDULE = ON REFRESH, + AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=2')) +); +ERROR: AUTO SCALING STRATEGY cannot be combined with a SCHEDULE other than MANUAL +``` + +--- + +## Observability reference + +| Surface | What it answers | +|---|---| +| `SHOW CLUSTERS` | Per cluster: `current_size`, `target_size`, `reconfiguration_in_flight`, `burst_size`, plus the replica list. "What did I ask for / what's running / is something happening" in one command. | +| `mz_internal.mz_cluster_reconfigurations` | The detail: current vs. target size, replication factor, availability zones; in-flight flag; enforcement deadline; active burst size. | +| `mz_internal.mz_hydration_statuses` | Per replica, per object: hydrated or not — the signal the controller acts on. | +| `mz_catalog.mz_audit_events` | History. Reconfiguration transitions: `started` / `finalized` / `timed-out` / `cancelled`. Burst transitions: `started` / `finished`. Replica creates carry the responsible strategy as their reason (`reconfiguration`, `hydration-burst`, `schedule` — the latter with the full `scheduling_policies` decision detail); replicas the configuration no longer calls for are dropped with reason `retired`. | + +--- + +## Side-effect changes users will notice + +These fall out of the new model rather than being headline features; they +belong in release notes and docs. + +1. **A bare `ALTER CLUSTER SET (SIZE = ...)` is now graceful by default.** + Previously it dropped and recreated the replicas immediately, leaving the + cluster unavailable until the new replicas rehydrated. Now the + zero-downtime overlap path runs by default — at the cost of transiently + paying for both replica sets. The old immediate behavior is an explicit + opt-in, `WITH (WAIT FOR '0s')` — the deadline is already past, so the + controller cuts over at once without provisioning overlap replicas: + + ``` + ALTER CLUSTER batch_jobs SET (SIZE = 'scale=1,workers=2') WITH (WAIT FOR '0s'); + + -- 3 seconds later: replaced in place, no overlap window + SHOW CLUSTER REPLICAS WHERE cluster = 'batch_jobs'; + cluster | replica | size | ready | comment + ------------+---------+-------------------+-------+--------- + batch_jobs | r2 | scale=1,workers=2 | t | + (1 row) + ``` + +2. **The implicit `ON TIMEOUT` default flips from `COMMIT` to `ROLLBACK`.** A + timed-out reconfiguration now reverts to the old shape instead of cutting + over to a possibly-unhydrated target. Safe by default: a timeout never + silently induces downtime. + +3. **`WITH (WAIT ...)` is durable; disconnects no longer abort.** Previously + the session carried the reconfiguration, so a network blip or a closed SQL + tool aborted it. Now the target, deadline, and timeout action live in the + catalog and the controller enforces them regardless of session lifetime + (Scenario 1 demonstrates surviving a full restart). + +4. **`SHOW CLUSTERS` changed shape.** The `size` column is now + `current_size`, and `target_size`, `reconfiguration_in_flight`, and + `burst_size` are new (see any `SHOW CLUSTERS` output above). Anyone + parsing `SHOW CLUSTERS` output must adapt. + +5. **Scheduled (`SCHEDULE = ON REFRESH`) clusters now report + `replication_factor = 0`.** The controller owns their replica set; a + replica exists only inside refresh windows, and `mz_cluster_replicas` is + the authoritative view of what is running. The feature itself behaves as + before — it is now one strategy inside the controller framework rather + than a separate mechanism: + + ``` + CREATE CLUSTER nightly ( + SIZE = 'scale=1,workers=1', + SCHEDULE = ON REFRESH (HYDRATION TIME ESTIMATE = '60 seconds') + ); + + SELECT name, replication_factor FROM mz_clusters WHERE name = 'nightly'; + name | replication_factor + ---------+-------------------- + nightly | 0 + (1 row) + + -- after creating a REFRESH EVERY materialized view on it, a replica runs + -- inside the refresh window, while replication_factor still reads 0: + SHOW CLUSTER REPLICAS WHERE cluster = 'nightly'; + cluster | replica | size | ready | comment + ---------+---------+-------------------+-------+--------- + nightly | r1 | scale=1,workers=1 | t | + (1 row) + ``` + + The on-window replica create is attributed `schedule` in the audit log and + carries the full scheduling decision — which materialized views needed a + refresh, which were still inside their post-refresh compaction window, and + the hydration-time estimate the window was widened by: + + ``` + SELECT event_type, details->>'replica_name' AS replica, + details->>'reason' AS reason, + jsonb_pretty(details->'scheduling_policies') AS scheduling_policies + FROM mz_catalog.mz_audit_events + WHERE object_type = 'cluster-replica' AND details->>'cluster_name' = 'nightly' + ORDER BY id; + event_type | replica | reason | scheduling_policies + ------------+---------+----------+-------------------------------------------- + create | r1 | schedule | { + + | | | "on_refresh": { + + | | | "decision": "on", + + | | | "hydration_time_estimate": "00:01:00",+ + | | | "objects_needing_compaction": [], + + | | | "objects_needing_refresh": [ + + | | | "u516" + + | | | ] + + | | | } + + | | | } + (1 row) + ``` + +6. **Replica names churn on resize.** A graceful resize creates fresh + replicas (`r1` → `r2` in Scenario 1); names are not preserved, and the + `-pending` replicas of the old mechanism are gone. Tooling should + key on the cluster, not on replica names. + +7. **`mz_clusters.size` / `SHOW CREATE CLUSTER` lag the request.** During a + reconfiguration they keep reporting the pre-change (realized) + configuration until cut-over; the pending target is in `SHOW CLUSTERS` / + the introspection view. Reading back the size right after `ALTER` no + longer shows the requested value. + +8. **Audit log shape changes.** Replica creates gain new reasons + (`reconfiguration`, `hydration-burst`); on-refresh creates keep reason + `schedule` and the `scheduling_policies` decision detail (shown in 5. + above). Every replica the controller retires — cut-over, cancellation, + burst teardown, refresh-window close — is dropped with the new reason + `retired`, where the legacy paths wrote `manual`. One deliberate nuance: a + replication-factor *decrease* also drops the surplus replica as `retired`, + even though the config change itself was user-initiated. New cluster-level + transition events exist (see the observability table). The legacy + scheduled-cluster "off" event with its `decision: off` detail blob is gone; + the window closing is the `retired` drop itself. + +9. **Billing.** Overlap replicas during a resize and burst replicas are + ordinary replicas and are billed as such: a resize transiently bills both + sets, a burst bills the `HYDRATION SIZE` replica while it runs. Not a new + rule, but these replicas now appear without a user creating them + explicitly. + +--- + +## Appendix A: rollout gating + +The work ships dark behind independent gates, so each piece can be rolled out +(and disabled) separately: + +| Setting | Default | Gates | +|---|---|---| +| `enable_cluster_controller` | `false` | Master switch: the controller owns managed-cluster replica sets; legacy paths bypassed. | +| `enable_background_alter_cluster` | `false` | Off: `ALTER` blocks the session until the reconfiguration resolves (same durable mechanism underneath — disconnecting still doesn't abort). On: `ALTER` returns immediately. | +| `enable_auto_scaling_strategy` | `false` | SQL acceptance of `AUTO SCALING STRATEGY` (catalog-safe feature flag). | +| `enable_hydration_burst` | `true` | Break-glass: disables only the burst strategy, environment-wide; graceful reconfiguration and `ON REFRESH` untouched. | +| `enable_zero_downtime_cluster_reconfiguration` | `false` | Pre-existing flag for the `WITH (WAIT ...)` SQL surface. | +| `default_cluster_reconfiguration_timeout` | 1 day | Deadline written when an `ALTER` gives no explicit timeout — no transition is ever unbounded. | +| `default_hydration_burst_linger` | `0s` | Linger used when a strategy omits `LINGER DURATION`. | +| `cluster_controller_tick_interval` | `5s` | Controller reconcile cadence. | + +## Appendix B: demo environment setup + +Local environment: `bin/environmentd --reset -- --unsafe-mode`, a debug +development build (`--unsafe-mode` only for `mz_unsafe.mz_sleep` used as a +wait between captures). Flags, as `mz_system` (the replay script additionally +enables `unsafe_enable_unsafe_functions` and the `REFRESH EVERY` / +`SCHEDULE = ON REFRESH` feature flags): + +```sql +ALTER SYSTEM SET enable_cluster_controller = true; +ALTER SYSTEM SET enable_zero_downtime_cluster_reconfiguration = true; +ALTER SYSTEM SET enable_background_alter_cluster = true; +ALTER SYSTEM SET enable_auto_scaling_strategy = true; +ALTER SYSTEM SET cluster_controller_tick_interval = '1s'; -- default 5s; snappier demo +``` + +Scenario 1 objects. `event_fingerprint_idx` is the deliberately expensive +index: an md5 over ~10 kB per row, 320k rows, ~50s to hydrate on one worker +of the debug build (an optimized build chews through roughly 6x as many rows +in the same time — scale the row count accordingly). The data is loaded in +eight separate inserts so the work spreads across the workers of a larger +replica (which is what makes the 8-worker burst replica in Scenario 2 hydrate +~8x faster): + +```sql +CREATE CLUSTER prod_analytics (SIZE = 'scale=1,workers=1'); +CREATE TABLE orders (id int, amount numeric); +INSERT INTO orders SELECT generate_series(1, 1000), 100; +CREATE TABLE events (x int); +INSERT INTO events SELECT generate_series(1, 40000); +-- ... seven more 40k-row inserts ... +SET cluster = prod_analytics; +CREATE VIEW order_totals AS SELECT id, sum(amount) AS total FROM orders GROUP BY id; +CREATE INDEX order_totals_idx ON order_totals (id); +CREATE VIEW event_fingerprint AS + SELECT max(md5(repeat(x::text, 2000))) AS fp FROM events; +CREATE INDEX event_fingerprint_idx ON event_fingerprint (fp); +``` + +Scenario 2 uses an identical fingerprint view (`pageview_fingerprint` over a +freshly loaded `pageviews` table) indexed `IN CLUSTER fast_start`. + +The complete capture script (every statement, wait, and kill in order) is +`pm-showcase-replay.sh` next to this document; running it against a fresh +environment regenerates every transcript quoted above. diff --git a/pm-showcase-replay.sh b/pm-showcase-replay.sh new file mode 100644 index 0000000000000..ee8573dc6b728 --- /dev/null +++ b/pm-showcase-replay.sh @@ -0,0 +1,345 @@ +#!/usr/bin/env bash +# Copyright Materialize, Inc. and contributors. All rights reserved. +# +# Use of this software is governed by the Business Source License +# included in the LICENSE file at the root of this repository. +# +# As of the Change Date specified in that file, in accordance with +# the Business Source License, use of this software will be governed +# by the Apache License, Version 2.0. + +# Clean end-to-end replay of the cluster-controller demo. Produces verbatim +# transcripts in /tmp/demo/clean/. Assumes environmentd is NOT running. +set -euo pipefail + +OUT=/tmp/demo/clean +mkdir -p "$OUT" +rm -f "$OUT"/*.txt + +PSQL_USER="psql -p 6875 -h localhost -U materialize -X -q -P pager=off" +PSQL_SYS="psql -p 6877 -h localhost -U mz_system -X -q -P pager=off" + +log() { echo "[replay $(date +%H:%M:%S)] $*"; } + +# Run SQL with statement echo, capture to transcript file. +cap() { # cap (sql on stdin) + $PSQL_USER -e materialize 2>&1 | grep -vE "NOTICE: (connected|cluster replica)|^ (Environment ID|Region|User|Cluster|Database|Schema|Session UUID)|^Issue a SQL|View documentation|Join our Slack|^ *$" > "$OUT/$1" +} + +sql() { $PSQL_USER -t -A -c "$1" materialize 2>/dev/null; } + +wait_ready() { + until $PSQL_USER -t -A -c 'SELECT 1' materialize >/dev/null 2>&1; do sleep 2; done +} + +poll() { # poll + local desc=$1 q=$2 want=$3 deadline=$(( $(date +%s) + $4 )) + until [ "$(sql "$q")" = "$want" ]; do + if [ "$(date +%s)" -gt "$deadline" ]; then echo "TIMEOUT waiting for: $desc"; exit 1; fi + sleep 2 + done + log "reached: $desc" +} + +############################################################################ +log "starting environmentd with --reset" +(cd /home/ubuntu/materialize && nohup bin/environmentd --reset -- --unsafe-mode > /tmp/demo/environmentd-clean.log 2>&1 &) +wait_ready +log "environmentd up" + +############################################################################ +log "applying system flags" +$PSQL_SYS materialize <<'EOF' >/dev/null 2>&1 +ALTER SYSTEM SET enable_cluster_controller = true; +ALTER SYSTEM SET enable_zero_downtime_cluster_reconfiguration = true; +ALTER SYSTEM SET enable_background_alter_cluster = true; +ALTER SYSTEM SET enable_auto_scaling_strategy = true; +ALTER SYSTEM SET cluster_controller_tick_interval = '1s'; +ALTER SYSTEM SET unsafe_enable_unsafe_functions = true; +ALTER SYSTEM SET enable_cluster_schedule_refresh = true; +ALTER SYSTEM SET enable_refresh_every_mvs = true; +EOF + +############################################################################ +log "scenario 1 setup (slow-hydrating index, ~55s initial hydration)" +cap 01-setup.txt <<'EOF' +CREATE CLUSTER prod_analytics (SIZE = 'scale=1,workers=1'); +CREATE TABLE orders (id int, amount numeric); +INSERT INTO orders SELECT generate_series(1, 1000), 100; +CREATE TABLE events (x int); +INSERT INTO events SELECT generate_series(1, 40000); +INSERT INTO events SELECT generate_series(40001, 80000); +INSERT INTO events SELECT generate_series(80001, 120000); +INSERT INTO events SELECT generate_series(120001, 160000); +INSERT INTO events SELECT generate_series(160001, 200000); +INSERT INTO events SELECT generate_series(200001, 240000); +INSERT INTO events SELECT generate_series(240001, 280000); +INSERT INTO events SELECT generate_series(280001, 320000); +SET cluster = prod_analytics; +CREATE VIEW order_totals AS SELECT id, sum(amount) AS total FROM orders GROUP BY id; +CREATE INDEX order_totals_idx ON order_totals (id); +CREATE VIEW event_fingerprint AS + SELECT max(md5(repeat(x::text, 2000))) AS fp FROM events; +CREATE INDEX event_fingerprint_idx ON event_fingerprint (fp); +EOF +# Block until the heavy index is hydrated (peek waits for it). +$PSQL_USER -c "SET cluster = prod_analytics" -c "SELECT fp FROM event_fingerprint" materialize >/dev/null 2>&1 +log "initial hydration done" + +############################################################################ +log "S1a: background ALTER + mid-flight introspection" +cap 02-reconfig-midflight.txt <<'EOF' +SET cluster = prod_analytics; +\timing on +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=2'); +\timing off +SHOW CLUSTERS WHERE name = 'prod_analytics'; +SELECT c.name, r.current_size, r.target_size, + r.reconfiguration_in_flight AS in_flight, + to_timestamp(r.reconfiguration_deadline::text::numeric / 1000) AS deadline +FROM mz_internal.mz_cluster_reconfigurations r +JOIN mz_clusters c ON c.id = r.cluster_id +WHERE c.name = 'prod_analytics'; +SHOW CLUSTER REPLICAS WHERE cluster = 'prod_analytics'; +\timing on +SELECT total FROM order_totals WHERE id = 42; +SELECT fp FROM event_fingerprint; +\timing off +SELECT size FROM mz_clusters WHERE name = 'prod_analytics'; +EOF + +poll "S1 cut-over" "SELECT reconfiguration_in_flight FROM mz_internal.mz_cluster_reconfigurations r JOIN mz_clusters c ON c.id = r.cluster_id WHERE c.name = 'prod_analytics'" "f" 180 + +log "S1b: settled state + audit trail" +cap 03-reconfig-settled.txt <<'EOF' +SHOW CLUSTERS WHERE name = 'prod_analytics'; +SHOW CLUSTER REPLICAS WHERE cluster = 'prod_analytics'; +SELECT size FROM mz_clusters WHERE name = 'prod_analytics'; +SELECT details->>'transition' AS transition, + details->>'target_size' AS target_size, occurred_at +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'prod_analytics' + AND details->>'transition' IS NOT NULL +ORDER BY id; +SELECT event_type, details->>'replica_name' AS replica, + details->>'logical_size' AS size, details->>'reason' AS reason +FROM mz_catalog.mz_audit_events +WHERE object_type = 'cluster-replica' + AND details->>'cluster_name' = 'prod_analytics' +ORDER BY id; +EOF + +############################################################################ +log "S1c: ALTER-back cancellation" +cap 04-cancel.txt <<'EOF' +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=4'); +SHOW CLUSTERS WHERE name = 'prod_analytics'; +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=2'); +SELECT mz_unsafe.mz_sleep(5); +SHOW CLUSTERS WHERE name = 'prod_analytics'; +SELECT details->>'transition' AS transition, details->>'target_size' AS target_size +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'prod_analytics' + AND details->>'transition' IS NOT NULL +ORDER BY id; +EOF + +############################################################################ +log "S1d: timeout + ON TIMEOUT ROLLBACK" +cap 05-timeout-rollback.txt <<'EOF' +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=1') + WITH (WAIT UNTIL READY (TIMEOUT '10s', ON TIMEOUT 'ROLLBACK')); +SHOW CLUSTER REPLICAS WHERE cluster = 'prod_analytics'; +SELECT mz_unsafe.mz_sleep(15); +SHOW CLUSTERS WHERE name = 'prod_analytics'; +SELECT c.name, r.current_size, r.target_size, + r.reconfiguration_in_flight AS in_flight +FROM mz_internal.mz_cluster_reconfigurations r +JOIN mz_clusters c ON c.id = r.cluster_id +WHERE c.name = 'prod_analytics'; +SHOW CLUSTER REPLICAS WHERE cluster = 'prod_analytics'; +SELECT total FROM order_totals WHERE id = 42; +SELECT details->>'transition' AS transition, + details->>'target_size' AS target_size, + to_timestamp((details->>'deadline')::numeric / 1000) AS deadline +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'prod_analytics' + AND details->>'transition' IS NOT NULL +ORDER BY id DESC LIMIT 2; +EOF + +############################################################################ +log "S1f: restart survival — start reconfiguration" +cap 07-restart-part1.txt <<'EOF' +ALTER CLUSTER prod_analytics SET (SIZE = 'scale=1,workers=1'); +SELECT mz_unsafe.mz_sleep(8); +SHOW CLUSTERS WHERE name = 'prod_analytics'; +EOF + +log "killing environmentd mid-reconfiguration" +pgrep -af 'clusterd|environmentd' | grep -vE 'grep|pgrep|replay' | awk '{print $1}' | xargs -r kill -9 || true +sleep 2 +(cd /home/ubuntu/materialize && nohup bin/environmentd -- --unsafe-mode > /tmp/demo/environmentd-clean-restart.log 2>&1 &) +wait_ready +log "environmentd back up" + +cap 08-restart-part2.txt <<'EOF' +SHOW CLUSTERS WHERE name = 'prod_analytics'; +EOF + +poll "post-restart cut-over" "SELECT reconfiguration_in_flight FROM mz_internal.mz_cluster_reconfigurations r JOIN mz_clusters c ON c.id = r.cluster_id WHERE c.name = 'prod_analytics'" "f" 300 + +cap 09-restart-settled.txt <<'EOF' +SHOW CLUSTERS WHERE name = 'prod_analytics'; +SELECT details->>'transition' AS transition, + details->>'target_size' AS target_size, occurred_at +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'prod_analytics' + AND details->>'transition' IS NOT NULL +ORDER BY id DESC LIMIT 2; +EOF + +############################################################################ +log "S2: burst cluster creation" +cap 10-burst-create.txt <<'EOF' +CREATE CLUSTER fast_start ( + SIZE = 'scale=1,workers=1', + AUTO SCALING STRATEGY = (ON HYDRATION ( + HYDRATION SIZE = 'scale=1,workers=8', + LINGER DURATION = '15s')) +); +SHOW CREATE CLUSTER fast_start; +EOF + +# Burst arming is existential: a cluster with no objects must not burst. +cap 11-burst-steady.txt <<'EOF' +SELECT mz_unsafe.mz_sleep(5); +SHOW CLUSTERS WHERE name = 'fast_start'; +SHOW CLUSTER REPLICAS WHERE cluster = 'fast_start'; +EOF + +log "S2: load fresh data for the burst demo (uncaptured prep)" +$PSQL_USER materialize >/dev/null 2>&1 <<'EOF' +CREATE TABLE pageviews (x int); +INSERT INTO pageviews SELECT generate_series(1, 40000); +INSERT INTO pageviews SELECT generate_series(40001, 80000); +INSERT INTO pageviews SELECT generate_series(80001, 120000); +INSERT INTO pageviews SELECT generate_series(120001, 160000); +INSERT INTO pageviews SELECT generate_series(160001, 200000); +INSERT INTO pageviews SELECT generate_series(200001, 240000); +INSERT INTO pageviews SELECT generate_series(240001, 280000); +INSERT INTO pageviews SELECT generate_series(280001, 320000); +CREATE VIEW pageview_fingerprint AS + SELECT max(md5(repeat(x::text, 2000))) AS fp FROM pageviews; +EOF + +log "S2: attach heavy index, burst fires" +cap 12-burst-fires.txt <<'EOF' +CREATE INDEX pageview_fingerprint_idx IN CLUSTER fast_start ON pageview_fingerprint (fp); +SELECT mz_unsafe.mz_sleep(4); +SHOW CLUSTERS WHERE name = 'fast_start'; +SHOW CLUSTER REPLICAS WHERE cluster = 'fast_start'; +EOF + +# Catch the moment the burst replica has hydrated the index while the steady +# replica is still computing. +poll "burst hydrated, steady not" " +SELECT coalesce(bool_or(h.hydrated) FILTER (WHERE cr.size = 'scale=1,workers=8'), false) + AND NOT coalesce(bool_or(h.hydrated) FILTER (WHERE cr.size = 'scale=1,workers=1'), false) +FROM mz_internal.mz_hydration_statuses h +JOIN mz_indexes i ON i.id = h.object_id +JOIN mz_cluster_replicas cr ON cr.id = h.replica_id +JOIN mz_clusters c ON c.id = cr.cluster_id +WHERE c.name = 'fast_start' AND i.name = 'pageview_fingerprint_idx'" "t" 120 + +log "S2: burst serving while steady hydrates" +cap 13-burst-serving.txt <<'EOF' +SELECT i.name AS index, cr.name AS replica, cr.size, h.hydrated +FROM mz_internal.mz_hydration_statuses h +JOIN mz_indexes i ON i.id = h.object_id +JOIN mz_cluster_replicas cr ON cr.id = h.replica_id +JOIN mz_clusters c ON c.id = cr.cluster_id +WHERE c.name = 'fast_start' AND i.name = 'pageview_fingerprint_idx' +ORDER BY cr.name; +SET cluster = fast_start; +\timing on +SELECT fp FROM pageview_fingerprint; +\timing off +EOF + +poll "burst teardown" "SELECT coalesce(burst_size, 'none') FROM mz_internal.mz_cluster_reconfigurations r JOIN mz_clusters c ON c.id = r.cluster_id WHERE c.name = 'fast_start'" "none" 240 + +log "S2: teardown state + audit" +cap 14-burst-teardown.txt <<'EOF' +SHOW CLUSTER REPLICAS WHERE cluster = 'fast_start'; +SHOW CLUSTERS WHERE name = 'fast_start'; +SELECT details->>'transition' AS transition, + details->>'burst_size' AS burst_size, occurred_at +FROM mz_catalog.mz_audit_events +WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'fast_start' + AND details->>'transition' IS NOT NULL +ORDER BY id; +SELECT event_type, details->>'replica_name' AS replica, + details->>'logical_size' AS size, details->>'reason' AS reason +FROM mz_catalog.mz_audit_events +WHERE object_type = 'cluster-replica' AND details->>'cluster_name' = 'fast_start' +ORDER BY id; +EOF + +log "S2: guardrails + policy management" +cap 15-burst-guardrails.txt <<'EOF' +CREATE CLUSTER bad_burst ( + SIZE = 'scale=1,workers=2', + AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=2')) +); +CREATE CLUSTER bad_burst ( + SIZE = 'scale=1,workers=1', + SCHEDULE = ON REFRESH, + AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=2')) +); +ALTER CLUSTER fast_start RESET (AUTO SCALING STRATEGY); +SHOW CREATE CLUSTER fast_start; +ALTER CLUSTER fast_start SET (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=4'))); +SHOW CREATE CLUSTER fast_start; +EOF + +############################################################################ +log "S3: ON REFRESH scheduling" +cap 16-on-refresh.txt <<'EOF' +CREATE CLUSTER nightly ( + SIZE = 'scale=1,workers=1', + SCHEDULE = ON REFRESH (HYDRATION TIME ESTIMATE = '60 seconds') +); +SELECT name, replication_factor FROM mz_clusters WHERE name = 'nightly'; +SHOW CLUSTER REPLICAS WHERE cluster = 'nightly'; +CREATE MATERIALIZED VIEW order_summary IN CLUSTER nightly + WITH (REFRESH EVERY '1 minute') + AS SELECT count(*) AS n, sum(amount) AS volume FROM orders; +SELECT mz_unsafe.mz_sleep(4); +SELECT name, replication_factor FROM mz_clusters WHERE name = 'nightly'; +SHOW CLUSTER REPLICAS WHERE cluster = 'nightly'; +SELECT n, volume FROM order_summary; +SELECT event_type, details->>'replica_name' AS replica, + details->>'reason' AS reason, + jsonb_pretty(details->'scheduling_policies') AS scheduling_policies +FROM mz_catalog.mz_audit_events +WHERE object_type = 'cluster-replica' AND details->>'cluster_name' = 'nightly' +ORDER BY id; +EOF + +log "S3: WAIT FOR '0s' opt-out + full SHOW CLUSTERS" +cap 17-wait-for-0s.txt <<'EOF' +CREATE CLUSTER batch_jobs (SIZE = 'scale=1,workers=1'); +SELECT mz_unsafe.mz_sleep(2); +ALTER CLUSTER batch_jobs SET (SIZE = 'scale=1,workers=2') WITH (WAIT FOR '0s'); +SELECT mz_unsafe.mz_sleep(3); +SHOW CLUSTER REPLICAS WHERE cluster = 'batch_jobs'; +SHOW CLUSTERS; +EOF + +log "replay complete; transcripts in $OUT" diff --git a/src/adapter-types/src/dyncfgs.rs b/src/adapter-types/src/dyncfgs.rs index 5d71f21c4258e..08b95f6e88d47 100644 --- a/src/adapter-types/src/dyncfgs.rs +++ b/src/adapter-types/src/dyncfgs.rs @@ -267,10 +267,79 @@ pub const CATALOG_INFO_METRICS_RECONCILE_INTERVAL: Config = Config::ne "How frequently to reconcile the catalog `*_info` metrics with the catalog. A zero duration disables reconciliation.", ); +/// Master gate for the cluster controller. When on, the controller owns the +/// managed-cluster replica set and the legacy paths (the graceful 3-stage +/// machine and `cluster_scheduling.rs`) are bypassed. The replica set cannot +/// have two writers, so this is a clean switch, not a per-strategy toggle. +pub const ENABLE_CLUSTER_CONTROLLER: Config = Config::new( + "enable_cluster_controller", + false, + "Whether the cluster controller owns the managed-cluster replica set. When false, the legacy scheduling and graceful-reconfiguration paths run instead.", +); + +/// Cadence of the cluster controller's reconcile tick. +/// +/// Replaces `cluster_check_scheduling_policies_interval` once the controller is +/// the sole owner; while the controller is dark both intervals exist. +pub const CLUSTER_CONTROLLER_TICK_INTERVAL: Config = Config::new( + "cluster_controller_tick_interval", + Duration::from_secs(5), + "How often the cluster controller runs a reconcile tick.", +); + +/// Whether a config-shape `ALTER CLUSTER` returns immediately, with the +/// controller converging in the background, or blocks the session on a +/// wait-shim until the reconfiguration completes or its deadline passes. +/// +/// Only consulted while [`ENABLE_CLUSTER_CONTROLLER`] is on, when the +/// controller owns the reconfiguration. +pub const ENABLE_BACKGROUND_ALTER_CLUSTER: Config = Config::new( + "enable_background_alter_cluster", + false, + "Whether a config-shape ALTER CLUSTER returns immediately (true) or the session blocks on a wait-shim over the durable reconfiguration record (false).", +); + +/// The reconfiguration deadline written when a config-shape `ALTER CLUSTER` +/// omits `WITH (TIMEOUT = ...)`. What happens when the deadline passes +/// un-hydrated is the record's `on_timeout` action. +pub const DEFAULT_CLUSTER_RECONFIGURATION_TIMEOUT: Config = Config::new( + "default_cluster_reconfiguration_timeout", + Duration::from_secs(60 * 60 * 24), + "The reconfiguration deadline written when a config-shape ALTER CLUSTER omits WITH (TIMEOUT = ...).", +); + +/// Break-glass for the hydration-burst strategy: when off the controller never +/// runs a burst replica; graceful reconfiguration and `ON REFRESH` scheduling +/// are unaffected. +/// +/// Only consulted while [`ENABLE_CLUSTER_CONTROLLER`] is on. A cluster can only +/// carry an `AUTO SCALING STRATEGY` while its SQL acceptance feature flag is +/// on, so this is the second of the two gates burst sits behind. +pub const ENABLE_HYDRATION_BURST: Config = Config::new( + "enable_hydration_burst", + true, + "Whether the cluster controller's hydration-burst strategy may run a burst replica (break-glass; leaves graceful reconfiguration and ON REFRESH untouched).", +); + +/// The burst-replica linger duration written into a new `burst` record when the +/// cluster's `AUTO SCALING STRATEGY` omits `LINGER DURATION`. The burst replica +/// stays up this long after the steady-state replicas first hydrate. +pub const DEFAULT_HYDRATION_BURST_LINGER: Config = Config::new( + "default_hydration_burst_linger", + Duration::from_secs(0), + "The burst-replica linger duration written when an AUTO SCALING STRATEGY omits LINGER DURATION.", +); + /// Adds the full set of all adapter `Config`s. pub fn all_dyncfgs(configs: ConfigSet) -> ConfigSet { configs .add(&ALLOW_USER_SESSIONS) + .add(&ENABLE_CLUSTER_CONTROLLER) + .add(&CLUSTER_CONTROLLER_TICK_INTERVAL) + .add(&ENABLE_BACKGROUND_ALTER_CLUSTER) + .add(&DEFAULT_CLUSTER_RECONFIGURATION_TIMEOUT) + .add(&ENABLE_HYDRATION_BURST) + .add(&DEFAULT_HYDRATION_BURST_LINGER) .add(&WITH_0DT_DEPLOYMENT_MAX_WAIT) .add(&WITH_0DT_DEPLOYMENT_DDL_CHECK_INTERVAL) .add(&ENABLE_0DT_DEPLOYMENT_PANIC_AFTER_TIMEOUT) diff --git a/src/adapter/Cargo.toml b/src/adapter/Cargo.toml index 74da334662554..76b1c2b2a4b17 100644 --- a/src/adapter/Cargo.toml +++ b/src/adapter/Cargo.toml @@ -42,6 +42,7 @@ mz-catalog = { path = "../catalog" } mz-cloud-provider = { path = "../cloud-provider", default-features = false } mz-cloud-resources = { path = "../cloud-resources" } mz-cluster-client = { path = "../cluster-client" } +mz-cluster-controller = { path = "../cluster-controller" } mz-compute-client = { path = "../compute-client" } mz-compute-types = { path = "../compute-types" } mz-controller = { path = "../controller" } diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index e1f9ff79f5da0..a764124e90be6 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -653,7 +653,6 @@ impl CatalogState { .clusters_by_id .get(&cluster_replica.cluster_id) .expect("catalog out of sync"); - let azs = cluster.availability_zones(); // Mirror the cluster-side soft signal: if a managed replica's size // is no longer in the in-memory size map, skip in-memory @@ -679,8 +678,13 @@ impl CatalogState { } } + // Pass no availability-zone override: a rebuild from the durable record + // keeps the AZ list the replica was provisioned under, which may differ + // from the cluster's current pool while a graceful reconfiguration is in + // flight — the cluster controller tells realized- from target-shape + // replicas by exactly this list. let location = self - .concretize_replica_location(cluster_replica.config.location, &vec![], azs, true) + .concretize_replica_location(cluster_replica.config.location, &vec![], None, true) .expect("catalog in unexpected state"); let cluster = self .clusters_by_id diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index 4107e26c9b97d..ac83b41ea66b6 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -985,6 +985,9 @@ fn add_new_remove_old_builtin_clusters_migration( logging: default_logging_config(), optimizer_feature_overrides: Default::default(), schedule: Default::default(), + auto_scaling_strategy: None, + reconfiguration: None, + burst: None, }), workload_class: None, }, @@ -1320,7 +1323,7 @@ pub(crate) fn builtin_cluster_replica_config( ) -> mz_catalog::durable::ReplicaConfig { mz_catalog::durable::ReplicaConfig { location: mz_catalog::durable::ReplicaLocation::Managed { - availability_zone: None, + availability_zones: Vec::new(), billed_as: None, pending: false, internal: false, diff --git a/src/adapter/src/catalog/state.rs b/src/adapter/src/catalog/state.rs index 348d16e3d8cbc..7d9517fcc5621 100644 --- a/src/adapter/src/catalog/state.rs +++ b/src/adapter/src/catalog/state.rs @@ -36,8 +36,7 @@ use mz_catalog::memory::objects::{ TableDataSource, Type, View, }; use mz_controller::clusters::{ - ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaAllocation, ReplicaLocation, - UnmanagedReplicaLocation, + ManagedReplicaLocation, ReplicaAllocation, ReplicaLocation, UnmanagedReplicaLocation, }; use mz_controller_types::{ClusterId, ReplicaId}; use mz_expr::{CollectionPlan, OptimizedMirRelationExpr}; @@ -2401,17 +2400,16 @@ impl CatalogState { } mz_catalog::durable::ReplicaLocation::Managed { size, - availability_zone, + // The AZ list the replica was provisioned under: provisioning + // paths pass the cluster's pool as `allowed_availability_zones` + // to stamp it, while rebuilds from durable state pass `None` to + // keep it. For an unmanaged cluster's replica it is the single + // user-pinned AZ. + availability_zones, billed_as, internal, pending, } => { - if allowed_availability_zones.is_some() && availability_zone.is_some() { - let message = "tried concretize managed replica with specific availability zones and availability zone"; - return Err(Error { - kind: ErrorKind::Internal(message.to_string()), - }); - } self.ensure_valid_replica_size(allowed_sizes, &size, allow_disabled)?; let cluster_replica_sizes = &self.cluster_replica_sizes; @@ -2421,13 +2419,9 @@ impl CatalogState { .get(&size) .expect("catalog out of sync") .clone(), - availability_zones: match (availability_zone, allowed_availability_zones) { - (Some(az), _) => ManagedReplicaAvailabilityZones::FromReplica(Some(az)), - (None, Some([])) => ManagedReplicaAvailabilityZones::FromCluster(None), - (None, Some(azs)) => { - ManagedReplicaAvailabilityZones::FromCluster(Some(azs.to_vec())) - } - (None, None) => ManagedReplicaAvailabilityZones::FromReplica(None), + availability_zones: match allowed_availability_zones { + Some(azs) => azs.to_vec(), + None => availability_zones, }, size, billed_as, diff --git a/src/adapter/src/catalog/transact.rs b/src/adapter/src/catalog/transact.rs index dca35a4362589..5336acd05106a 100644 --- a/src/adapter/src/catalog/transact.rs +++ b/src/adapter/src/catalog/transact.rs @@ -22,8 +22,10 @@ use mz_adapter_types::dyncfgs::{ WITH_0DT_DEPLOYMENT_MAX_WAIT, }; use mz_audit_log::{ - CreateOrDropClusterReplicaReasonV1, EventDetails, EventType, IdFullNameV1, IdNameV1, - ObjectType, SchedulingDecisionsWithReasonsV2, VersionedEvent, + AlterClusterReconfigurationV1, ClusterHydrationBurstV1, CreateOrDropClusterReplicaReasonV1, + EventDetails, EventType, HydrationBurstLifecycleV1, IdFullNameV1, IdNameV1, ObjectType, + ReconfigurationLifecycleV1, RefreshDecisionWithReasonV2, SchedulingDecisionV1, + SchedulingDecisionsWithReasonsV2, VersionedEvent, }; use mz_catalog::SYSTEM_CONN_ID; use mz_catalog::builtin::BuiltinLog; @@ -31,14 +33,17 @@ use mz_catalog::durable::{NetworkPolicy, Snapshot, Transaction}; use mz_catalog::expr_cache::LocalExpressions; use mz_catalog::memory::error::{AmbiguousRename, Error, ErrorKind}; use mz_catalog::memory::objects::{ - CatalogEntry, CatalogItem, ClusterConfig, DataSourceDesc, DefaultPrivileges, SourceReferences, - StateDiff, StateUpdate, StateUpdateKind, TemporaryItem, + BurstState, CatalogEntry, CatalogItem, ClusterConfig, ClusterVariant, DataSourceDesc, + DefaultPrivileges, ReconfigurationState, ReconfigurationTarget, SourceReferences, StateDiff, + StateUpdate, StateUpdateKind, TemporaryItem, }; +use mz_cluster_controller::ctx::RefreshWindowDecision; use mz_controller::clusters::{ManagedReplicaLocation, ReplicaConfig, ReplicaLocation}; use mz_controller_types::{ClusterId, ReplicaId}; use mz_ore::collections::HashSet; use mz_ore::instrument; use mz_persist_types::ShardId; +use mz_repr::adt::interval::Interval; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem, PrivilegeMap, merge_mz_acl_items}; use mz_repr::network_policy_id::NetworkPolicyId; use mz_repr::optimize::OptimizerFeatures; @@ -317,6 +322,24 @@ pub enum ReplicaCreateDropReason { /// The automated cluster scheduling initiated the replica create or drop, e.g., a /// materialized view is needing a refresh on a SCHEDULE ON REFRESH cluster. ClusterScheduling(Vec), + /// The cluster controller's graceful-reconfiguration strategy created the replica while + /// converging a cluster onto an in-flight `reconfiguration` target (a background + /// `ALTER CLUSTER`). + GracefulReconfiguration, + /// The cluster controller's hydration-burst strategy created the transient burst replica + /// it runs while a cluster's objects are not yet hydrated. + HydrationBurst, + /// The cluster controller's on-refresh strategy created the replica for a refresh window on + /// a `SCHEDULE = ON REFRESH` cluster. Audited as the `schedule` reason, carrying the tick's + /// window decision (which MVs needed a refresh or compaction time, and the hydration-time + /// estimate) as the `scheduling_policies` detail — the same detail the legacy scheduler's + /// [`ReplicaCreateDropReason::ClusterScheduling`] records. The controller always supplies + /// the decision; a `None` still audits `schedule`, just without the blob. + OnRefresh(Option), + /// The cluster controller dropped the replica because the cluster's configuration no longer + /// calls for it — the uniform reason on every controller-emitted drop (e.g. a + /// replication-factor decrease). + Retired, } impl ReplicaCreateDropReason { @@ -326,19 +349,59 @@ impl ReplicaCreateDropReason { CreateOrDropClusterReplicaReasonV1, Option, ) { - let (reason, scheduling_policies) = match self { + match self { ReplicaCreateDropReason::Manual => (CreateOrDropClusterReplicaReasonV1::Manual, None), ReplicaCreateDropReason::ClusterScheduling(scheduling_decisions) => ( CreateOrDropClusterReplicaReasonV1::Schedule, - Some(scheduling_decisions), + Some(SchedulingDecision::reasons_to_audit_log_reasons( + &scheduling_decisions, + )), ), - }; - ( - reason, - scheduling_policies - .as_ref() - .map(SchedulingDecision::reasons_to_audit_log_reasons), - ) + ReplicaCreateDropReason::GracefulReconfiguration => { + (CreateOrDropClusterReplicaReasonV1::Reconfiguration, None) + } + ReplicaCreateDropReason::HydrationBurst => { + (CreateOrDropClusterReplicaReasonV1::HydrationBurst, None) + } + ReplicaCreateDropReason::OnRefresh(decision) => ( + CreateOrDropClusterReplicaReasonV1::Schedule, + decision.map(refresh_window_decision_to_audit_log), + ), + ReplicaCreateDropReason::Retired => (CreateOrDropClusterReplicaReasonV1::Retired, None), + } + } +} + +/// Convert the controller's on-refresh window decision into the audit log's +/// `scheduling_policies` detail, the same shape the legacy scheduler records: +/// ids as strings and the hydration-time estimate as an interval string. +fn refresh_window_decision_to_audit_log( + decision: RefreshWindowDecision, +) -> SchedulingDecisionsWithReasonsV2 { + let mut hydration_time_estimate_str = String::new(); + strconv::format_interval( + &mut hydration_time_estimate_str, + Interval::from_duration(&decision.hydration_time_estimate) + .expect("the estimate originated as a planned Interval"), + ); + SchedulingDecisionsWithReasonsV2 { + on_refresh: RefreshDecisionWithReasonV2 { + // The controller produces a create — and so this detail — only for + // an open window; there is no "off" decision to record (a + // window-close is a `retired` drop with no detail). + decision: SchedulingDecisionV1::On, + objects_needing_refresh: decision + .objects_needing_refresh + .iter() + .map(|id| id.to_string()) + .collect(), + objects_needing_compaction: decision + .objects_needing_compaction + .iter() + .map(|id| id.to_string()) + .collect(), + hydration_time_estimate: hydration_time_estimate_str, + }, } } @@ -369,6 +432,147 @@ impl Catalog { !item.is_temporary() } + /// Classify the background-reconfiguration lifecycle transition an + /// [`Op::UpdateClusterConfig`] represents, comparing the cluster's + /// `reconfiguration` record before (`old`) and after (`new`) the change. + /// Returns `None` when the record is unchanged (no lifecycle transition). + /// + /// Only the controller clears a record (an `ALTER` always writes one, never + /// clears one), and it does so in exactly two ways: a cut-over, which + /// advances the realized config to the target in the same write + /// (`finalized` — a hydrated success, or a forced `COMMIT` past the + /// deadline; the event carries the cleared record's deadline so a reader + /// can tell the two apart against the event's occurrence time), and a + /// `ROLLBACK` timeout, which clears the record with the realized config + /// untouched (`timed-out`). Whether the realized config advanced to the + /// cleared record's target is therefore what classifies a clear; both + /// clears are durable, so neither event can re-fire. + fn classify_reconfiguration_transition( + old: &ClusterConfig, + new: &ClusterConfig, + cluster_id: ClusterId, + cluster_name: &str, + ) -> Option { + let reconfiguration = |config: &ClusterConfig| -> Option { + match &config.variant { + ClusterVariant::Managed(managed) => managed.reconfiguration.clone(), + ClusterVariant::Unmanaged => None, + } + }; + // The new config's realized shape, used to recognize an ALTER-back + // cancel (a re-target whose target equals the still-realized shape) + // and to classify a clear (did the realized config advance to the + // cleared record's target?). + let new_realized = match &new.variant { + ClusterVariant::Managed(managed) => Some(managed.clone()), + ClusterVariant::Unmanaged => None, + }; + let realized_matches_target = |target: &ReconfigurationTarget| { + new_realized.as_ref().is_some_and(|realized| { + realized.size == target.size + && realized.replication_factor == target.replication_factor + && realized.availability_zones == target.availability_zones + && realized.logging == target.logging + }) + }; + let old = reconfiguration(old); + let new = reconfiguration(new); + + let event = + |transition, record: &ReconfigurationState, deadline| AlterClusterReconfigurationV1 { + cluster_id: cluster_id.to_string(), + cluster_name: cluster_name.to_string(), + transition, + target_size: record.target.size.clone(), + target_replication_factor: record.target.replication_factor, + deadline, + }; + + match (old, new) { + (None, Some(record)) => Some(event( + ReconfigurationLifecycleV1::Started, + &record, + Some(record.deadline.into()), + )), + (Some(old), Some(new)) if old != new => { + // A re-target back to the still-realized shape is a cancel (the + // controller will just drop the in-flight target replicas); any + // other re-target starts converging onto a new target. + let is_cancel = new_realized.as_ref().map(|r| r.size.as_str()) + == Some(new.target.size.as_str()); + let transition = if is_cancel { + ReconfigurationLifecycleV1::Cancelled + } else { + ReconfigurationLifecycleV1::Started + }; + Some(event(transition, &new, Some(new.deadline.into()))) + } + // A clear: a cut-over (the same write advanced the realized config + // to the target) finalizes; a clear that left the realized config + // short of the target is the `ROLLBACK` timeout firing. The one + // shape this cannot tell apart is a rollback whose target equals + // the realized config: it would read as a finalize. That needs the + // already-running realized set to sit un-hydrated past the whole + // deadline — the controller otherwise cuts such a target over as + // trivially satisfied — so we accept the marginal mislabel. + (Some(old), None) => { + let transition = if realized_matches_target(&old.target) { + ReconfigurationLifecycleV1::Finalized + } else { + ReconfigurationLifecycleV1::TimedOut + }; + Some(event(transition, &old, Some(old.deadline.into()))) + } + (None, None) | (Some(_), Some(_)) => None, + } + } + + /// Classify the hydration-burst lifecycle transition an [`Op::UpdateClusterConfig`] + /// represents, comparing the cluster's `burst` record before and after. + /// + /// A burst is controller-initiated, so its record is written and cleared by the + /// controller's `update_state` rather than by an `ALTER`. A record written → + /// `started`; cleared → `finished`. A record whose `burst_size` changes (a + /// re-armed burst at a new size, after a `HYDRATION SIZE` change) is reported as + /// a fresh `started`. Returns `None` when the record is unchanged. + /// + /// Dark by construction: a `burst` record only ever moves when the cluster + /// controller is enabled. + fn classify_burst_transition( + old: &ClusterConfig, + new: &ClusterConfig, + cluster_id: ClusterId, + cluster_name: &str, + ) -> Option { + let burst = |config: &ClusterConfig| -> Option { + match &config.variant { + ClusterVariant::Managed(managed) => managed.burst.clone(), + ClusterVariant::Unmanaged => None, + } + }; + let old = burst(old); + let new = burst(new); + + let event = |transition, record: &BurstState| ClusterHydrationBurstV1 { + cluster_id: cluster_id.to_string(), + cluster_name: cluster_name.to_string(), + transition, + burst_size: record.burst_size.clone(), + }; + + match (old, new) { + (None, Some(record)) => Some(event(HydrationBurstLifecycleV1::Started, &record)), + (Some(old), None) => Some(event(HydrationBurstLifecycleV1::Finished, &old)), + // A re-arm at a new size (a `HYDRATION SIZE` change) restarts the burst. + // A same-size record change (e.g. the `steady_hydrated_at` stamp) is not + // a lifecycle transition. + (Some(old), Some(new)) if old.burst_size != new.burst_size => { + Some(event(HydrationBurstLifecycleV1::Started, &new)) + } + (None, None) | (Some(_), Some(_)) => None, + } + } + /// Gets [`CatalogItemId`]s of temporary items to be created, checks for name collisions /// within a connection id. fn temporary_ids( @@ -2545,6 +2749,16 @@ impl Catalog { } Op::UpdateClusterConfig { id, name, config } => { let mut cluster = state.get_cluster(id).clone(); + // Classify any background-reconfiguration lifecycle transition + // this config change represents (record written/re-targeted, or + // cut over) before we overwrite the old config. Emitted in + // addition to the generic `IdNameV1` alter event. This is dark by + // construction: a `reconfiguration` record only ever moves when + // the cluster controller is enabled. + let reconfiguration_event = + Self::classify_reconfiguration_transition(&cluster.config, &config, id, &name); + let burst_event = + Self::classify_burst_transition(&cluster.config, &config, id, &name); cluster.config = config; tx.update_cluster(id, cluster.into())?; info!("update cluster {}", name); @@ -2562,6 +2776,32 @@ impl Catalog { name, }), )?; + + if let Some(details) = reconfiguration_event { + CatalogState::add_to_audit_log( + &state.system_configuration, + oracle_write_ts, + session, + tx, + audit_events, + EventType::Alter, + ObjectType::Cluster, + EventDetails::AlterClusterReconfigurationV1(details), + )?; + } + + if let Some(details) = burst_event { + CatalogState::add_to_audit_log( + &state.system_configuration, + oracle_write_ts, + session, + tx, + audit_events, + EventType::Alter, + ObjectType::Cluster, + EventDetails::ClusterHydrationBurstV1(details), + )?; + } } Op::UpdateClusterReplicaConfig { replica_id, @@ -3087,6 +3327,291 @@ mod tests { use crate::catalog::{Catalog, Op}; use crate::session::DEFAULT_DATABASE_NAME; + #[mz_ore::test] + fn test_classify_reconfiguration_transition() { + use mz_audit_log::ReconfigurationLifecycleV1; + use mz_catalog::memory::objects::{ + ClusterConfig, ClusterVariant, ClusterVariantManaged, ReconfigurationState, + ReconfigurationTarget, + }; + use mz_controller::clusters::ReplicaLogging; + use mz_controller_types::ClusterId; + use mz_repr::Timestamp; + use mz_repr::optimize::OptimizerFeatureOverrides; + + let cluster_id = ClusterId::user(1).expect("valid id"); + let logging = ReplicaLogging { + log_logging: false, + interval: None, + }; + // The realized shape of the modeled cluster before any cut-over; an + // ALTER-back cancel re-targets a record at this same size. + let realized_size = "small"; + // A config with the realized shape at (`size`, `rf`) and the given + // record: a clear that advanced the realized shape to the cleared + // record's target is a cut-over, one that left it behind is a rollback. + let managed_at = + |size: &str, rf: u32, reconfiguration: Option| ClusterConfig { + variant: ClusterVariant::Managed(ClusterVariantManaged { + size: size.into(), + availability_zones: Vec::new(), + logging: logging.clone(), + replication_factor: rf, + optimizer_feature_overrides: OptimizerFeatureOverrides::default(), + schedule: Default::default(), + auto_scaling_strategy: None, + reconfiguration, + burst: None, + }), + workload_class: None, + }; + let managed = |reconfiguration: Option| { + managed_at(realized_size, 1, reconfiguration) + }; + let record = |size: &str, deadline: u64, on_timeout: mz_sql::plan::OnTimeoutAction| { + ReconfigurationState { + target: ReconfigurationTarget { + size: size.into(), + replication_factor: 2, + availability_zones: Vec::new(), + logging: logging.clone(), + }, + deadline: Timestamp::from(deadline), + on_timeout, + } + }; + use mz_sql::plan::OnTimeoutAction::{Commit, Rollback}; + let classify = |old: &ClusterConfig, new: &ClusterConfig| { + Catalog::classify_reconfiguration_transition(old, new, cluster_id, "c") + }; + + // none -> some: started, carrying the record's deadline. + let started = classify( + &managed(None), + &managed(Some(record("large", 200, Rollback))), + ) + .expect("a written record is a started transition"); + assert_eq!(started.transition, ReconfigurationLifecycleV1::Started); + assert_eq!(started.deadline, Some(200)); + assert_eq!(started.target_size, "large"); + assert_eq!(started.target_replication_factor, 2); + + // A cut-over clear: the same write advanced the realized shape to the + // cleared record's target — finalized, carrying the cleared record's + // deadline (a reader tells an in-time from a late cut-over by comparing + // the carried deadline to the event's occurrence time). + let finalized = classify( + &managed(Some(record("large", 200, Rollback))), + &managed_at("large", 2, None), + ) + .expect("a cut-over clear is a finalize"); + assert_eq!(finalized.transition, ReconfigurationLifecycleV1::Finalized); + assert_eq!(finalized.deadline, Some(200)); + + // A cut-over clear under COMMIT (a forced cut-over past the deadline + // ends up here too): still finalized, deadline kept. + let commit_finalized = classify( + &managed(Some(record("large", 50, Commit))), + &managed_at("large", 2, None), + ) + .expect("clearing a commit record is a finalize"); + assert_eq!( + commit_finalized.transition, + ReconfigurationLifecycleV1::Finalized + ); + assert_eq!(commit_finalized.deadline, Some(50)); + + // A rollback clear: the record is gone but the realized shape stayed + // behind — the rollback timeout fired. Carries the cleared record's + // deadline and target so the abandoned shape survives in the history. + let timed_out = classify( + &managed(Some(record("large", 50, Rollback))), + &managed(None), + ) + .expect("a clear short of the target is a timed-out transition"); + assert_eq!(timed_out.transition, ReconfigurationLifecycleV1::TimedOut); + assert_eq!(timed_out.deadline, Some(50)); + assert_eq!(timed_out.target_size, "large"); + assert_eq!(timed_out.target_replication_factor, 2); + + // The cancel-converge clear: a cancel record (target == realized shape, + // rf included) confirms the current state, so its clear leaves the + // realized config in place *and* matching the target — a finalize. + let cancel_record = ReconfigurationState { + target: ReconfigurationTarget { + size: realized_size.into(), + replication_factor: 1, + availability_zones: Vec::new(), + logging: logging.clone(), + }, + deadline: Timestamp::from(300u64), + on_timeout: Rollback, + }; + let cancel_clear = classify(&managed(Some(cancel_record)), &managed(None)) + .expect("clearing a cancel record is a finalize"); + assert_eq!( + cancel_clear.transition, + ReconfigurationLifecycleV1::Finalized + ); + assert_eq!(cancel_clear.deadline, Some(300)); + + // some -> some re-targeting to a *new* shape: started, carrying the new + // deadline. + let retarget = classify( + &managed(Some(record("large", 200, Rollback))), + &managed(Some(record("xlarge", 300, Rollback))), + ) + .expect("a re-target is a started transition"); + assert_eq!(retarget.transition, ReconfigurationLifecycleV1::Started); + assert_eq!(retarget.deadline, Some(300)); + assert_eq!(retarget.target_size, "xlarge"); + + // some -> some re-targeting *back* to the realized shape: a cancel, + // carrying the cancel record's deadline. + let cancelled = classify( + &managed(Some(record("large", 200, Rollback))), + &managed(Some(record(realized_size, 300, Rollback))), + ) + .expect("an ALTER-back to the realized shape is a cancel transition"); + assert_eq!(cancelled.transition, ReconfigurationLifecycleV1::Cancelled); + assert_eq!(cancelled.deadline, Some(300)); + assert_eq!(cancelled.target_size, realized_size); + + // No transition: identical record, or no record on either side. + assert!( + classify( + &managed(Some(record("large", 200, Rollback))), + &managed(Some(record("large", 200, Rollback))), + ) + .is_none() + ); + assert!(classify(&managed(None), &managed(None)).is_none()); + } + + #[mz_ore::test] + fn test_classify_burst_transition() { + use mz_audit_log::HydrationBurstLifecycleV1; + use mz_catalog::memory::objects::{ + BurstState, ClusterConfig, ClusterVariant, ClusterVariantManaged, + }; + use mz_controller::clusters::ReplicaLogging; + use mz_controller_types::ClusterId; + use mz_repr::Timestamp; + use mz_repr::optimize::OptimizerFeatureOverrides; + use std::time::Duration; + + let cluster_id = ClusterId::user(1).expect("valid id"); + let logging = ReplicaLogging { + log_logging: false, + interval: None, + }; + let managed = |burst: Option| ClusterConfig { + variant: ClusterVariant::Managed(ClusterVariantManaged { + size: "small".into(), + availability_zones: Vec::new(), + logging: logging.clone(), + replication_factor: 1, + optimizer_feature_overrides: OptimizerFeatureOverrides::default(), + schedule: Default::default(), + auto_scaling_strategy: None, + reconfiguration: None, + burst, + }), + workload_class: None, + }; + // A burst record at the given size, before the steady set has hydrated. + let record = |size: &str| BurstState { + burst_size: size.into(), + linger_duration: Duration::from_secs(60), + steady_hydrated_at: None, + }; + let classify = |old: &ClusterConfig, new: &ClusterConfig| { + Catalog::classify_burst_transition(old, new, cluster_id, "c") + }; + + // none -> some: the burst started, carrying the record's size. + let started = classify(&managed(None), &managed(Some(record("large")))) + .expect("a written burst record is a started transition"); + assert_eq!(started.transition, HydrationBurstLifecycleV1::Started); + assert_eq!(started.burst_size, "large"); + + // some -> none: the burst finished (the linger elapsed, record cleared). + let finished = classify(&managed(Some(record("large"))), &managed(None)) + .expect("clearing a burst record is a finished transition"); + assert_eq!(finished.transition, HydrationBurstLifecycleV1::Finished); + assert_eq!(finished.burst_size, "large"); + + // some -> some at a *new* size (a re-arm after a HYDRATION SIZE change): + // reported as a fresh started, carrying the new size. + let rearmed = classify( + &managed(Some(record("large"))), + &managed(Some(record("xlarge"))), + ) + .expect("a burst re-arm at a new size is a started transition"); + assert_eq!(rearmed.transition, HydrationBurstLifecycleV1::Started); + assert_eq!(rearmed.burst_size, "xlarge"); + + // some -> some at the *same* size: not a lifecycle transition. This is the + // load-bearing case: the controller stamps `steady_hydrated_at` (the linger + // clock) on an existing record without changing its size, and that in-place + // update must not emit a spurious burst event. + let stamped = BurstState { + steady_hydrated_at: Some(Timestamp::from(42u64)), + ..record("large") + }; + assert!( + classify(&managed(Some(record("large"))), &managed(Some(stamped))).is_none(), + "stamping steady_hydrated_at on a same-size record is not a transition" + ); + + // No record on either side is not a transition. + assert!(classify(&managed(None), &managed(None)).is_none()); + } + + #[mz_ore::test] + fn test_replica_create_drop_reason_into_audit_log() { + use std::time::Duration; + + use mz_audit_log::{CreateOrDropClusterReplicaReasonV1, SchedulingDecisionV1}; + use mz_cluster_controller::ctx::RefreshWindowDecision; + use mz_repr::GlobalId; + + use crate::catalog::ReplicaCreateDropReason; + + // `OnRefresh` shares the `schedule` audit word with the legacy + // `ClusterScheduling` variant and converts the controller's window + // decision into the same `scheduling_policies` detail blob: ids as + // strings, the hydration-time estimate as an interval string, and the + // decision hardcoded `on` (the controller produces a create — and so + // this detail — only for an open window). + let (reason, scheduling_policies) = + ReplicaCreateDropReason::OnRefresh(Some(RefreshWindowDecision { + objects_needing_refresh: vec![GlobalId::User(1)], + objects_needing_compaction: vec![GlobalId::User(2), GlobalId::User(3)], + hydration_time_estimate: Duration::from_secs(995), + })) + .into_audit_log(); + assert_eq!(reason, CreateOrDropClusterReplicaReasonV1::Schedule); + let blob = scheduling_policies.expect("on-refresh create carries the detail"); + assert_eq!(blob.on_refresh.decision, SchedulingDecisionV1::On); + assert_eq!(blob.on_refresh.objects_needing_refresh, vec!["u1"]); + assert_eq!(blob.on_refresh.objects_needing_compaction, vec!["u2", "u3"]); + assert_eq!(blob.on_refresh.hydration_time_estimate, "00:16:35"); + + // A detail-less on-refresh create still reads `schedule`, just without + // the blob. + let (reason, scheduling_policies) = + ReplicaCreateDropReason::OnRefresh(None).into_audit_log(); + assert_eq!(reason, CreateOrDropClusterReplicaReasonV1::Schedule); + assert!(scheduling_policies.is_none()); + + // `Retired` is the uniform word for every controller drop, with no + // blob. + let (reason, scheduling_policies) = ReplicaCreateDropReason::Retired.into_audit_log(); + assert_eq!(reason, CreateOrDropClusterReplicaReasonV1::Retired); + assert!(scheduling_policies.is_none()); + } + #[mz_ore::test] fn test_update_privilege_owners() { let old_owner = RoleId::User(1); diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index 6b8e525215d66..1b242f3d64c10 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -102,7 +102,8 @@ use mz_catalog::durable::{AuditLogIterator, OpenableDurableCatalogState}; use mz_catalog::expr_cache::{GlobalExpressions, LocalExpressions}; use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, ClusterReplicaProcessStatus, ClusterVariantManaged, Connection, - DataSourceDesc, StateDiff, StateUpdate, StateUpdateKind, Table, TableDataSource, + DataSourceDesc, ReconfigurationTarget, StateDiff, StateUpdate, StateUpdateKind, Table, + TableDataSource, }; use mz_cloud_resources::{CloudResourceController, VpcEndpointConfig, VpcEndpointEvent}; use mz_compute_client::as_of_selection; @@ -172,7 +173,7 @@ use thiserror::Error; use timely::progress::{Antichain, Timestamp as _}; use tokio::runtime::Handle as TokioHandle; use tokio::select; -use tokio::sync::{OwnedMutexGuard, mpsc, oneshot, watch}; +use tokio::sync::{Notify, OwnedMutexGuard, mpsc, oneshot, watch}; use tokio::time::{Interval, MissedTickBehavior}; use tracing::{Instrument, Level, Span, debug, info, info_span, span, warn}; use tracing_opentelemetry::OpenTelemetrySpanExt; @@ -211,6 +212,7 @@ use crate::{AdapterNotice, ReadHolds, flags}; pub(crate) mod appends; pub(crate) mod catalog_serving; +pub(crate) mod cluster_controller; pub(crate) mod cluster_scheduling; pub(crate) mod consistency; pub(crate) mod id_bundle; @@ -419,6 +421,11 @@ pub enum Message { /// A cluster will be On if and only if there is at least one On decision for it. /// Scheduling decisions for clusters that have `SCHEDULE = MANUAL` are ignored. SchedulingDecisions(Vec<(&'static str, Vec<(ClusterId, SchedulingDecision)>)>), + + /// One pull/apply call from the cluster controller task, to be answered from + /// the catalog and live controller signals on this loop. See + /// [`cluster_controller`]. + ClusterControllerRequest(cluster_controller::ClusterControllerRequest), } impl Message { @@ -514,6 +521,7 @@ impl Message { Message::PrivateLinkVpcEndpointEvents(_) => "private_link_vpc_endpoint_events", Message::CheckSchedulingPolicies => "check_scheduling_policies", Message::SchedulingDecisions { .. } => "scheduling_decision", + Message::ClusterControllerRequest(_) => "cluster_controller_request", Message::DeferredStatementReady => "deferred_statement_ready", } } @@ -820,6 +828,11 @@ pub enum ClusterStage { Alter(AlterCluster), WaitForHydrated(AlterClusterWaitForHydrated), Finalize(AlterClusterFinalize), + /// The foreground wait-shim over a controller-driven background + /// reconfiguration: poll the durable `reconfiguration` record until it + /// clears, then report success or timeout depending on whether the realized + /// config reached the target. + AwaitReconfiguration(AlterClusterAwaitReconfiguration), } #[derive(Debug)] @@ -846,6 +859,19 @@ pub struct AlterClusterFinalize { workload_class: Option, } +#[derive(Debug)] +pub struct AlterClusterAwaitReconfiguration { + validity: PlanValidity, + cluster_id: ClusterId, + /// The target shape the awaited `ALTER` wrote. When the record clears, the + /// realized config matching this is what distinguishes a cut-over (success) + /// from a rollback clear (timeout); see `await_reconfiguration_stage`. + target: ReconfigurationTarget, + /// Whether the shim has already granted the one post-deadline grace + /// re-poll; see `await_reconfiguration_stage`. + past_deadline_grace_used: bool, +} + #[derive(Debug)] pub enum ExplainContext { /// The ordinary, non-explain variant of the statement. @@ -1849,6 +1875,10 @@ pub struct Coordinator { internal_cmd_tx: mpsc::UnboundedSender, /// Notification that triggers a group commit. group_commit_tx: appends::GroupCommitNotifier, + /// Kicks the cluster controller task to reconcile immediately instead of + /// waiting out its tick interval. Notified after catalog transactions that + /// change durable cluster state. + cluster_controller_kick: Arc, /// Channel for strict serializable reads ready to commit. strict_serializable_reads_tx: mpsc::UnboundedSender<(ConnectionId, PendingReadTxn)>, @@ -3559,6 +3589,7 @@ impl Coordinator { self.spawn_privatelink_vpc_endpoints_watch_task(); self.spawn_statement_logging_task(); self.spawn_catalog_info_metrics_task(); + self.spawn_cluster_controller_task(); flags::tracing_config(self.catalog.system_config()).apply(&self.tracing_handle); // Report if the handling of a single message takes longer than this threshold. @@ -4594,10 +4625,31 @@ pub fn serve( let clusters_caught_up_check = clusters_caught_up_trigger.map(|trigger| { let mut exclude_collections: BTreeSet = - new_builtin_collections.into_iter().collect(); + new_builtin_collections.iter().copied().collect(); - // Migrated MVs can't make progress in read-only mode. Exclude them and all their - // transitive dependents. + // A collection that can't advance its write frontier in read-only mode also + // stalls everything that transitively reads from it, so those dependents must be + // excluded from the caught-up check as well. Two kinds of source can't advance + // while read-only: + // + // * Migrated MVs: their dataflows don't write in read-only mode. + // * New builtin MVs: their freshly-created shard has no writer until this + // deployment promotes, so the leader never advances it on our behalf. + // + // New builtin collections are themselves excluded above, but their dependents are + // not, so also seed the walk from new builtin MVs. This only bites when an + // already-existing, hydration-gating builtin (e.g. an indexed builtin view) is + // pointed at a new builtin MV in the same release. + // + // Excluding the dependents is intended steady-state behavior, with a known + // tradeoff: an excluded dependent is not guaranteed caught up at promotion, so a + // hydration-gating dependent (e.g. an indexed builtin view) can still be hydrating + // right after we cut over to read-write — a brief blip of unavailability for that + // view. We accept it because these builtin MVs are small: once we cut over the new + // MV gets a writer and the dependent hydrates quickly, so the blip is short and + // self-resolving. Staging the rollout — shipping a new builtin MV one release + // before anything depends on it, so the upgrade base already writes its shard — + // would avoid even the blip, but we prefer the exclusion as the simpler behavior. // // TODO: Consider sending `allow_writes` for the dataflows of migrated MVs, which // would allow them to make progress even in read-only mode. This doesn't @@ -4605,12 +4657,15 @@ pub fn serve( // than v26.17, since before that version the catalog shard's frontier wasn't // kept up-to-date with the current time. So this workaround has to remain in // place upgrades from a version less than v26.17 are no longer supported. + let new_builtin_mvs = new_builtin_collections.iter().filter_map(|global_id| { + let entry = catalog.state().try_get_entry_by_global_id(global_id)?; + entry.is_materialized_view().then(|| entry.id()) + }); let mut todo: Vec<_> = migrated_storage_collections_0dt .iter() - .filter(|id| { - catalog.state().get_entry(id).is_materialized_view() - }) .copied() + .filter(|id| catalog.state().get_entry(id).is_materialized_view()) + .chain(new_builtin_mvs) .collect(); while let Some(item_id) = todo.pop() { let entry = catalog.state().get_entry(&item_id); @@ -4707,6 +4762,7 @@ pub fn serve( catalog, internal_cmd_tx, group_commit_tx, + cluster_controller_kick: Arc::new(Notify::new()), strict_serializable_reads_tx, global_timelines: timestamp_oracles, transient_id_gen: Arc::new(TransientIdGen::new()), diff --git a/src/adapter/src/coord/cluster_controller.rs b/src/adapter/src/coord/cluster_controller.rs new file mode 100644 index 0000000000000..9aa0fad9721fb --- /dev/null +++ b/src/adapter/src/coord/cluster_controller.rs @@ -0,0 +1,1080 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +//! Driver and glue for the [`mz_cluster_controller`] reconciler. +//! +//! The controller crate is pure: it knows nothing about the Coordinator. This +//! module is the half of the [`ClusterControllerCtx`] seam that does: it runs +//! the controller as a **separate task** and implements the ctx by marshaling +//! each pull/apply to the Coordinator over the internal command channel, because +//! the catalog and the live compute/storage signals are reachable only from the +//! coordinator loop. The two whole-tick reads are batched; the per-cluster live +//! signals are pulled on demand, so a tick's round-trips scale with the number of +//! managed clusters that need a live signal, not with a constant. +//! +//! Everything here is gated by [`ENABLE_CLUSTER_CONTROLLER`] (default off). With +//! the gate off the task does not tick, so the legacy scheduling and graceful +//! paths remain the sole writers of the replica set. With the gate on the +//! controller owns the *user* managed-cluster replica set; the legacy entry +//! points no-op. (System/builtin clusters are never controller-owned — the +//! catalog's bootstrap migration owns their replicas.) + +use std::collections::BTreeSet; +use std::sync::Arc; +use std::time::Duration; + +use mz_adapter_types::dyncfgs::{ + CLUSTER_CONTROLLER_TICK_INTERVAL, DEFAULT_HYDRATION_BURST_LINGER, ENABLE_CLUSTER_CONTROLLER, + ENABLE_HYDRATION_BURST, +}; +use mz_catalog::memory::objects::{ClusterConfig, ClusterVariant, ClusterVariantManaged}; +use mz_cluster_controller::ClusterController; +use mz_cluster_controller::ctx::{ + ApplyOutcome, AutoScalingPolicy, ClusterControllerCtx, ClusterSchedule, ClusterState, Decision, + ExpectedClusterState, ObservedReplica, OnHydrationPolicy, OnTimeout, ReconfigurationRecord, + ReconfigurationTarget, RefreshMvInfo, RefreshWindowDecision, RefreshWindowInputs, ReplicaShape, + StateWrite, +}; +use mz_cluster_controller::strategy::{ + GRACEFUL_RECONFIGURATION_STRATEGY_NAME, HYDRATION_BURST_STRATEGY_NAME, ON_REFRESH_STRATEGY_NAME, +}; +use mz_compute_types::config::ComputeReplicaConfig; +use mz_controller_types::{ClusterId, ReplicaId}; +use mz_ore::task::spawn; +use mz_repr::Timestamp; +use tokio::sync::{mpsc, oneshot}; +use tracing::{debug, warn}; + +use crate::catalog::{DropObjectInfo, Op, ReplicaCreateDropReason}; +use crate::coord::{Coordinator, Message}; +use crate::error::AdapterError; + +/// A request the controller task marshals to the Coordinator to satisfy one +/// [`ClusterControllerCtx`] call. Each variant carries a oneshot for the reply. +/// +/// `ManagedClusterIds` and `ClusterStates` are the per-tick batched reads (`now` +/// is folded into `ClusterStates`'s reply); the hydration, hydratable-objects, +/// and refresh-window reads are the per-cluster live signals a strategy pulls on +/// demand. +#[derive(Debug)] +pub enum ClusterControllerRequest { + /// The ids of all *user* managed clusters the controller owns this tick. + /// System/builtin clusters are excluded — their replica set is owned by the + /// catalog's bootstrap migration, not the controller. + ManagedClusterIds { tx: oneshot::Sender> }, + /// A consistent durable view of the given clusters and their replicas, plus + /// the current time. + ClusterStates { + clusters: Vec, + tx: oneshot::Sender<(Vec, Timestamp)>, + }, + /// Of `replicas` on `cluster`, which have all current collections hydrated. + HydratedReplicas { + cluster_id: ClusterId, + replicas: Vec, + tx: oneshot::Sender>, + }, + /// Whether the cluster has any hydratable (dataflow-backed) objects bound to + /// it. + HasHydratableObjects { + cluster_id: ClusterId, + tx: oneshot::Sender, + }, + /// The refresh-window live signals for one scheduled cluster (read ts, + /// compaction estimate, bound REFRESH MVs). `None` for a cluster that is not + /// scheduled `ON REFRESH`. + RefreshWindowInputs { + cluster_id: ClusterId, + tx: oneshot::Sender>, + }, + /// Apply a tick's batch of decisions under their compare-and-append guards. + Apply { + decisions: Vec, + tx: oneshot::Sender, + }, + /// The current configured reconcile cadence. Read once per tick so a runtime + /// change to `cluster_controller_tick_interval` takes effect without a + /// restart. + TickInterval { tx: oneshot::Sender }, +} + +/// The controller-task side of the seam: a [`ClusterControllerCtx`] that +/// marshals every call to the Coordinator over `internal_cmd_tx`. +struct CoordCtx { + internal_cmd_tx: mpsc::UnboundedSender, + /// Latched `now` from the most recent batched read, returned by + /// [`ClusterControllerCtx::now`] so a strategy and the kernel see a single + /// consistent time per phase. + now: Timestamp, +} + +impl CoordCtx { + /// Send a request and await its reply. Returns `None` if the Coordinator has + /// gone away (shutdown), which the caller treats as "nothing to do". + async fn request( + &self, + make: impl FnOnce(oneshot::Sender) -> ClusterControllerRequest, + ) -> Option { + let (tx, rx) = oneshot::channel(); + if self + .internal_cmd_tx + .send(Message::ClusterControllerRequest(make(tx))) + .is_err() + { + return None; + } + rx.await.ok() + } +} + +#[async_trait::async_trait] +impl ClusterControllerCtx for CoordCtx { + fn now(&self) -> Timestamp { + self.now + } + + async fn managed_cluster_ids(&mut self) -> Vec { + self.request(|tx| ClusterControllerRequest::ManagedClusterIds { tx }) + .await + .unwrap_or_default() + } + + async fn cluster_states(&mut self, clusters: &[ClusterId]) -> Vec { + let clusters = clusters.to_vec(); + match self + .request(|tx| ClusterControllerRequest::ClusterStates { clusters, tx }) + .await + { + Some((states, now)) => { + self.now = now; + states + } + None => Vec::new(), + } + } + + async fn hydrated_replicas( + &mut self, + cluster_id: ClusterId, + replicas: &[ReplicaId], + ) -> BTreeSet { + let replicas = replicas.to_vec(); + self.request(|tx| ClusterControllerRequest::HydratedReplicas { + cluster_id, + replicas, + tx, + }) + .await + .unwrap_or_default() + } + + async fn has_hydratable_objects(&mut self, cluster_id: ClusterId) -> bool { + self.request(|tx| ClusterControllerRequest::HasHydratableObjects { cluster_id, tx }) + .await + // A lost reply means shutdown; "no objects" arms nothing, which is + // the safe answer. + .unwrap_or(false) + } + + async fn refresh_window_inputs( + &mut self, + cluster_id: ClusterId, + ) -> Option { + self.request(|tx| ClusterControllerRequest::RefreshWindowInputs { cluster_id, tx }) + .await + .flatten() + } + + async fn apply(&mut self, decisions: Vec) -> ApplyOutcome { + self.request(|tx| ClusterControllerRequest::Apply { decisions, tx }) + .await + // A lost reply means shutdown; treat as rejected so we make no + // further claims about the catalog state. + .unwrap_or(ApplyOutcome::Rejected) + } +} + +impl Coordinator { + /// Spawn the cluster controller task. + /// + /// The task ticks at [`CLUSTER_CONTROLLER_TICK_INTERVAL`] and reconciles when + /// [`ENABLE_CLUSTER_CONTROLLER`] is on; while the gate is off it ticks but + /// each tick is an early no-op. Both the gate and the interval are re-read + /// each tick (the interval via a [`ClusterControllerRequest::TickInterval`] + /// round-trip), so a runtime change to either takes effect without a restart. + /// It owns the controller and a [`CoordCtx`] that marshals back to this + /// Coordinator. + /// + /// The interval is the fallback cadence: `cluster_controller_kick` cuts the + /// sleep short after a catalog transaction changes durable cluster state. A + /// kick only wakes the task — the tick still pulls fresh state through the + /// coordinator loop — and the controller's own applies re-kick at the cost + /// of one no-op tick. + pub(crate) fn spawn_cluster_controller_task(&self) { + let internal_cmd_tx = self.internal_cmd_tx.clone(); + let kick = Arc::clone(&self.cluster_controller_kick); + + spawn(|| "cluster_controller", async move { + let controller = ClusterController::new(); + let mut ctx = CoordCtx { + internal_cmd_tx, + now: Timestamp::MIN, + }; + + loop { + // Re-read the cadence each tick so a runtime change takes effect. + // A lost reply means the Coordinator is gone; stop ticking. + let Some(interval) = ctx + .request(|tx| ClusterControllerRequest::TickInterval { tx }) + .await + else { + break; + }; + tokio::select! { + _ = tokio::time::sleep(interval.max(Duration::from_millis(1))) => {} + _ = kick.notified() => {} + } + + if ctx.internal_cmd_tx.is_closed() { + // Coordinator gone; stop ticking. + break; + } + controller.reconcile(&mut ctx).await; + } + }); + } + + /// Handle one [`ClusterControllerRequest`] on the coordinator loop. + /// + /// The controller is inactive when the gate is off, or while the deployment + /// is in read-only mode (a 0dt upgrade, where it must not write the catalog). + /// When inactive, reads report no managed clusters (so the controller finds + /// nothing to reconcile) and applies are rejected: the task still wakes each + /// tick and sends one `ManagedClusterIds` request, but that request + /// early-returns here and no catalog state is read or written, so the legacy + /// paths remain the sole writers of the replica set. The task keeps ticking, + /// so the controller reactivates on its own once the deployment promotes out + /// of read-only mode. + #[mz_ore::instrument(level = "debug")] + pub(crate) async fn handle_cluster_controller_request( + &mut self, + request: ClusterControllerRequest, + ) { + let active = ENABLE_CLUSTER_CONTROLLER.get(self.catalog().system_config().dyncfgs()) + && !self.controller.read_only(); + + match request { + ClusterControllerRequest::ManagedClusterIds { tx } => { + let ids = if active { + self.catalog() + .clusters() + // Only *user* managed clusters. System/builtin clusters + // (mz_system, mz_catalog_server, …) are also managed, but + // their replica set is owned by the bootstrap migration + // (`add_new_remove_old_builtin_cluster_replicas_migration`), + // which holds exactly the `BUILTIN_CLUSTER_REPLICAS`-defined + // replicas regardless of the cluster's `replication_factor`. + // Letting the controller own them too would make two writers + // of one replica set: the baseline would, for example, add a + // replica to reach a builtin cluster's `replication_factor`, + // which the bootstrap migration then tears down on the next + // open. The legacy scheduler likewise only ever acted on user + // clusters. + .filter(|c| c.is_managed() && c.id.is_user()) + .map(|c| c.id) + .collect() + } else { + Vec::new() + }; + let _ = tx.send(ids); + } + ClusterControllerRequest::ClusterStates { clusters, tx } => { + let now = Timestamp::from(self.now()); + // Only ever asked about clusters the controller is reconciling + // this tick, which the inactive `ManagedClusterIds` gate above + // makes empty — so no guard is needed here. + let states: Vec<_> = clusters + .into_iter() + .filter_map(|id| self.observe_cluster_state(id)) + .collect(); + let _ = tx.send((states, now)); + } + ClusterControllerRequest::HydratedReplicas { + cluster_id, + replicas, + tx, + } => { + let hydrated = self.hydrated_replicas(cluster_id, replicas).await; + let _ = tx.send(hydrated); + } + ClusterControllerRequest::HasHydratableObjects { cluster_id, tx } => { + let _ = tx.send(self.cluster_has_hydratable_objects(cluster_id)); + } + ClusterControllerRequest::RefreshWindowInputs { cluster_id, tx } => { + let inputs = self.refresh_window_inputs(cluster_id).await; + let _ = tx.send(inputs); + } + ClusterControllerRequest::Apply { decisions, tx } => { + let outcome = if active { + self.apply_cluster_decisions(decisions).await + } else { + ApplyOutcome::Rejected + }; + let _ = tx.send(outcome); + } + ClusterControllerRequest::TickInterval { tx } => { + let interval = + CLUSTER_CONTROLLER_TICK_INTERVAL.get(self.catalog().system_config().dyncfgs()); + let _ = tx.send(interval); + } + } + } + + /// Build the controller's view of one managed cluster from the catalog. + /// Returns `None` for a missing or unmanaged cluster. + fn observe_cluster_state(&self, cluster_id: ClusterId) -> Option { + let cluster = self.catalog().try_get_cluster(cluster_id)?; + let ClusterVariant::Managed(managed) = &cluster.config.variant else { + return None; + }; + let ClusterVariantManaged { + size, + availability_zones, + logging, + replication_factor, + optimizer_feature_overrides: _, + schedule, + auto_scaling_strategy, + reconfiguration, + burst, + } = managed; + + let mut replicas = Vec::new(); + let mut reserved_replica_names = Vec::new(); + for replica in cluster.replicas() { + // INTERNAL / BILLED AS replicas are manually managed and live outside + // the controller's replication-factor domain: a user can attach one to + // any managed cluster, and the legacy scheduler and reconfiguration + // paths never create or drop them. Keep them out of the observed set so + // the controller neither counts one toward a desired shape (letting it + // stand in for a managed replica) nor drops it as excess — but reserve + // their names so a controller-created replica cannot collide with one + // that happens to use an `rN` name. + let shape = if replica.config.location.internal() + || replica.config.location.billed_as().is_some() + { + None + } else { + replica_shape(&replica.config) + }; + match shape { + Some(shape) => replicas.push(ObservedReplica { + replica_id: replica.replica_id, + name: replica.name.clone(), + shape, + }), + None => reserved_replica_names.push(replica.name.clone()), + } + } + + let dyncfgs = self.catalog().system_config().dyncfgs(); + let burst_enabled = ENABLE_HYDRATION_BURST.get(dyncfgs); + let default_burst_linger = DEFAULT_HYDRATION_BURST_LINGER.get(dyncfgs); + + Some(ClusterState { + cluster_id, + size: size.clone(), + replication_factor: *replication_factor, + availability_zones: availability_zones.clone(), + logging: logging.clone(), + schedule: schedule_to_controller(schedule), + auto_scaling_policy: auto_scaling_strategy + .as_ref() + .map(auto_scaling_policy_to_controller), + reconfiguration: reconfiguration.as_ref().map(reconfiguration_to_controller), + burst: burst.as_ref().map(burst_to_controller), + burst_enabled, + default_burst_linger, + replicas, + reserved_replica_names, + // Live signals the controller pulls separately (via `hydrated_replicas` + // / `refresh_window_inputs` / `has_hydratable_objects`) only when a + // strategy needs them. + hydrated_replicas: BTreeSet::new(), + refresh_window: None, + has_hydratable_objects: false, + }) + } + + /// Whether the cluster has any hydratable objects bound to it, backing the + /// controller's [`ClusterControllerCtx::has_hydratable_objects`] pull (see + /// the trait method for the approximation contract and why mismatches with + /// the hydration check are self-healing). + /// + /// Counts the dataflow-backed items among the cluster's `bound_objects`: + /// indexes, materialized views, sinks, and ingestion sources. A webhook + /// source is bound to its cluster but runs no dataflow on any replica, so + /// it is nothing a burst could accelerate. + fn cluster_has_hydratable_objects(&self, cluster_id: ClusterId) -> bool { + use mz_catalog::memory::objects::{CatalogItem, DataSourceDesc}; + + let Some(cluster) = self.catalog().try_get_cluster(cluster_id) else { + return false; + }; + cluster + .bound_objects + .iter() + .any(|id| match self.catalog().get_entry(id).item() { + CatalogItem::Index(_) | CatalogItem::MaterializedView(_) | CatalogItem::Sink(_) => { + true + } + CatalogItem::Source(source) => matches!( + source.data_source, + DataSourceDesc::Ingestion { .. } | DataSourceDesc::OldSyntaxIngestion { .. } + ), + _ => false, + }) + } + + /// Of `replicas` on `cluster_id`, which have *all* current (non-transient) + /// collections on the cluster hydrated on that replica. + /// + /// Backs the controller's [`ClusterControllerCtx::hydrated_replicas`] pull + /// against the live compute and storage controller signals — the same signals + /// the legacy graceful wait stage reads. A replica counts as hydrated only if + /// both its compute and storage collections are hydrated on it. A replica the + /// controllers do not recognize (e.g. just dropped) is treated as not + /// hydrated. + /// + /// The probe is per-replica by necessity, not for lack of a batched API: both + /// `collections_hydrated_for_replicas` and `collections_hydrated_on_replicas` + /// take a replica list but collapse it to a single "hydrated on **any** of + /// these" bool. We need per-replica answers, so each replica is asked about on + /// its own; passing them all at once would lose the per-replica granularity the + /// graceful strategy's all-target-replicas cut-over requires. + async fn hydrated_replicas( + &self, + cluster_id: ClusterId, + replicas: Vec, + ) -> BTreeSet { + use mz_catalog::memory::objects::CatalogItem; + + let mut hydrated = BTreeSet::new(); + for replica_id in replicas { + // A materialized view pinned to a *different* replica (via + // `IN CLUSTER ... REPLICA`) is only ever installed on that replica, + // so this replica can never report it hydrated. Exclude such + // collections from this replica's hydration check; otherwise a + // graceful reconfiguration's cut-over to a fresh replica set would + // wait forever for the new replicas to hydrate an MV bound to a + // replica being replaced, then roll back at the deadline (leaving the + // old replica — and the targeted MV — in place). Indexes cannot be + // replica-pinned, so MVs are the only case. + let exclude: BTreeSet = self + .catalog() + .try_get_cluster(cluster_id) + .into_iter() + .flat_map(|cluster| cluster.bound_objects.iter()) + .filter_map(|id| match self.catalog().get_entry(id).item() { + CatalogItem::MaterializedView(mv) + if mv.target_replica.is_some_and(|target| target != replica_id) => + { + Some(mv.global_id_writes()) + } + _ => None, + }) + .collect(); + let compute_fut = match self.controller.compute.collections_hydrated_for_replicas( + cluster_id, + vec![replica_id], + exclude.clone(), + ) { + Ok(fut) => fut, + // The replica is not known to the compute controller; not hydrated. + Err(_) => continue, + }; + let storage_hydrated = match self.controller.storage.collections_hydrated_on_replicas( + Some(vec![replica_id]), + &cluster_id, + &exclude, + ) { + Ok(hydrated) => hydrated, + Err(_) => continue, + }; + let compute_hydrated = match compute_fut.await { + Ok(hydrated) => hydrated, + Err(_) => continue, + }; + if compute_hydrated && storage_hydrated { + hydrated.insert(replica_id); + } + } + hydrated + } + + /// The refresh-window live signals for one scheduled cluster, or `None` if the + /// cluster is missing, unmanaged, or not scheduled `ON REFRESH`. + /// + /// Backs the controller's [`ClusterControllerCtx::refresh_window_inputs`] + /// pull against the same signals the legacy `check_refresh_policy` reads: the + /// local oracle read timestamp, the system compaction estimate, and each bound + /// REFRESH materialized view's storage write frontier and refresh schedule. The + /// pure on-refresh strategy takes the window decision from these. + /// + /// The MV write frontier is carried through with full fidelity as the + /// `Antichain` the storage controller reports, matching the legacy refresh + /// policy; the on-refresh strategy compares against it directly. + async fn refresh_window_inputs(&self, cluster_id: ClusterId) -> Option { + use mz_catalog::memory::objects::CatalogItem; + + let cluster = self.catalog().try_get_cluster(cluster_id)?; + let ClusterVariant::Managed(managed) = &cluster.config.variant else { + return None; + }; + if !matches!( + managed.schedule, + mz_sql::plan::ClusterSchedule::Refresh { .. } + ) { + return None; + } + + let refresh_mvs = cluster + .bound_objects + .iter() + .filter_map(|id| { + let CatalogItem::MaterializedView(mv) = self.catalog().get_entry(id).item() else { + return None; + }; + let refresh_schedule = mv.refresh_schedule.clone()?; + // The storage controller knows about every MV in the catalog. The + // write frontier is passed through with full fidelity as the + // `Antichain` reported here. + let (_since, write_frontier) = self + .controller + .storage + .collection_frontiers(mv.global_id_writes()) + .expect("storage controller knows about catalog MVs"); + Some(RefreshMvInfo { + id: mv.global_id_writes(), + write_frontier, + refresh_schedule, + }) + }) + .collect(); + + let compaction_estimate = self + .catalog() + .system_config() + .cluster_refresh_mv_compaction_estimate(); + let read_ts = self.get_local_read_ts().await; + + Some(RefreshWindowInputs { + read_ts, + compaction_estimate, + refresh_mvs, + }) + } + + /// Apply one batch of decisions. + /// + /// The kernel calls this once per tick phase: a phase-1 batch is all + /// `UpdateClusterState`, a phase-2 batch is all create/drop. Either batch may + /// in principle be mixed; this handles both. + /// + /// Every decision — create, drop, or state write — carries the durable state + /// it was derived from; the **compare-and-append guard** re-reads each target + /// cluster and rejects the *whole* batch if any state has since diverged + /// (e.g. a user `ALTER` landed mid-tick), so a stale create or drop can never + /// reshape the replica set against the config the `ALTER` has since + /// established (in particular, a stale drop cannot retire a replica the + /// `ALTER` has just made desired). On rejection nothing is applied and the + /// controller recomputes next tick. When the guards hold, the batch's ops are + /// transacted together, so they commit atomically. + async fn apply_cluster_decisions(&mut self, decisions: Vec) -> ApplyOutcome { + // Phase 0: compare-and-append guard. Every decision carries the durable + // state it was derived from; if any target cluster has since diverged the + // whole batch is stale. All decisions for a cluster in one tick's batch + // carry the same `expected` (derived from the single state we read for it), + // so we check each cluster only once. + let mut checked = BTreeSet::new(); + for decision in &decisions { + let (cluster_id, expected) = match decision { + Decision::CreateReplica { + cluster_id, + expected, + .. + } + | Decision::DropReplica { + cluster_id, + expected, + .. + } + | Decision::UpdateClusterState { + cluster_id, + expected, + .. + } => (*cluster_id, expected), + }; + if !checked.insert(cluster_id) { + continue; + } + if !self.cluster_state_matches(cluster_id, expected) { + return ApplyOutcome::Rejected; + } + } + + let mut ops = Vec::new(); + let mut drops = Vec::new(); + for decision in decisions { + match decision { + Decision::UpdateClusterState { + cluster_id, write, .. + } => match self.build_update_cluster_config_op(cluster_id, &write) { + Some(op) => ops.push(op), + None => { + // The cluster vanished between the guard and here; the + // batch is no longer coherent. + return ApplyOutcome::Rejected; + } + }, + Decision::CreateReplica { + cluster_id, + name, + shape, + reasons, + audit_detail, + .. + } => { + let reason = reason_from_strategies(&reasons, audit_detail); + match self.build_create_replica_op(cluster_id, name, &shape, reason) { + Ok(Some(op)) => ops.push(op), + Ok(None) => return ApplyOutcome::Rejected, + Err(err) => { + warn!(%cluster_id, "cluster controller could not build replica create: {err}"); + return ApplyOutcome::Rejected; + } + } + } + Decision::DropReplica { + cluster_id, + replica_id, + .. + } => { + drops.push(DropObjectInfo::ClusterReplica(( + cluster_id, + replica_id, + ReplicaCreateDropReason::Retired, + ))); + } + } + } + if !drops.is_empty() { + ops.push(Op::DropObjects(drops)); + } + + if ops.is_empty() { + return ApplyOutcome::Applied; + } + + match self.catalog_transact(None, ops).await { + Ok(()) => ApplyOutcome::Applied, + Err(AdapterError::ReadOnly) => { + // The controller is quiesced while read-only (see + // `handle_cluster_controller_request`), so this is normally + // unreachable; if reached it's expected and not actionable, not + // a failure to surface. + debug!("cluster controller apply skipped in read-only mode"); + ApplyOutcome::Rejected + } + Err(err) => { + warn!("cluster controller apply failed: {err}"); + ApplyOutcome::Rejected + } + } + } + + /// Build an [`Op::UpdateClusterConfig`] that applies `write`'s deltas to the + /// cluster's current in-memory config, or `None` if the cluster is gone or + /// unmanaged. The write was guard-checked against the same state, so this is + /// the realized cut-over / record write. + fn build_update_cluster_config_op( + &self, + cluster_id: ClusterId, + write: &StateWrite, + ) -> Option { + let cluster = self.catalog().try_get_cluster(cluster_id)?; + let mut config = cluster.config.clone(); + let ClusterConfig { + variant: ClusterVariant::Managed(managed), + .. + } = &mut config + else { + return None; + }; + // Exhaustive destructure of the source (no `..`): a field added to + // `StateWrite` is a compile error here until it's overlaid onto the + // managed config. We cannot destructure `managed` itself — it carries + // fields the controller does not model (`workload_class`, + // `optimizer_feature_overrides`) that this overlay must leave untouched. + let StateWrite { + new_size, + new_replication_factor, + new_availability_zones, + new_logging, + reconfiguration, + burst, + } = write; + if let Some(size) = new_size { + managed.size = size.clone(); + } + if let Some(rf) = new_replication_factor { + managed.replication_factor = *rf; + } + if let Some(azs) = new_availability_zones { + managed.availability_zones = azs.clone(); + } + if let Some(logging) = new_logging { + managed.logging = logging.clone(); + } + if let Some(reconfiguration) = reconfiguration { + managed.reconfiguration = reconfiguration + .as_ref() + .map(reconfiguration_from_controller); + } + if let Some(burst) = burst { + managed.burst = burst.as_ref().map(burst_from_controller); + } + Some(Op::UpdateClusterConfig { + id: cluster_id, + name: cluster.name.clone(), + config, + }) + } + + /// Build an [`Op::CreateClusterReplica`] for a desired replica `shape` on + /// `cluster_id`, attributed to `reason`. Returns `Ok(None)` if the cluster is + /// gone or unmanaged. + fn build_create_replica_op( + &self, + cluster_id: ClusterId, + name: String, + shape: &ReplicaShape, + reason: ReplicaCreateDropReason, + ) -> Result, mz_catalog::memory::error::Error> { + let Some(cluster) = self.catalog().try_get_cluster(cluster_id) else { + return Ok(None); + }; + if !cluster.is_managed() { + return Ok(None); + } + let owner_id = cluster.owner_id; + + let location = mz_catalog::durable::ReplicaLocation::Managed { + // Concretized from the cluster config below; left empty here. + availability_zones: Vec::new(), + billed_as: None, + internal: false, + size: shape.size.clone(), + pending: false, + }; + let azs: Option<&[String]> = if shape.availability_zones.is_empty() { + None + } else { + Some(&shape.availability_zones) + }; + let location = self.catalog().concretize_replica_location( + location, + &self + .catalog() + .get_role_allowed_cluster_sizes(&Some(owner_id)), + azs, + false, + )?; + + let config = mz_controller::clusters::ReplicaConfig { + location, + compute: ComputeReplicaConfig { + logging: shape.logging.clone(), + }, + }; + + Ok(Some(Op::CreateClusterReplica { + cluster_id, + name, + config, + owner_id, + reason, + })) + } + + /// Whether `cluster_id`'s current durable state still matches `expected`, the + /// compare-and-append witness a [`Decision`] was derived from. + fn cluster_state_matches( + &self, + cluster_id: ClusterId, + expected: &ExpectedClusterState, + ) -> bool { + // Re-derive the witness through the same `observe_cluster_state` -> + // `expected()` path the decision was built from and compare, rather than + // matching field by field. Going through one path keeps the witness from + // silently drifting out of sync with what `ExpectedClusterState` carries: + // a field added there is compared here automatically. + self.observe_cluster_state(cluster_id) + .map(|state| state.expected()) + .as_ref() + == Some(expected) + } +} + +/// Map a create decision's strategy-attribution to the audit reason carried on +/// the create event. Graceful wins over burst when both desired a shape (their +/// shapes differ in practice, so this is a stable tie-break); on-refresh maps to +/// the `schedule` reason, carrying the create's window decision as the +/// `scheduling_policies` detail; a baseline-held replica is `Manual`, the tag +/// for replicas the user's own config calls for. +/// +/// The detail is attached only when on-refresh wins the precedence, so the blob +/// appears iff the audited reason is `schedule` — the same invariant the legacy +/// scheduler's events had. (A shape desired by both graceful and on-refresh +/// audits `reconfiguration` with no blob: consistent, since the blob explains a +/// `schedule` decision.) +/// +/// Drops never come through here: a drop happens exactly when no strategy +/// desires the replica, so it carries no attribution and is uniformly audited +/// [`ReplicaCreateDropReason::Retired`]. +fn reason_from_strategies( + reasons: &[&'static str], + audit_detail: Option, +) -> ReplicaCreateDropReason { + if reasons.contains(&GRACEFUL_RECONFIGURATION_STRATEGY_NAME) { + ReplicaCreateDropReason::GracefulReconfiguration + } else if reasons.contains(&HYDRATION_BURST_STRATEGY_NAME) { + ReplicaCreateDropReason::HydrationBurst + } else if reasons.contains(&ON_REFRESH_STRATEGY_NAME) { + ReplicaCreateDropReason::OnRefresh(audit_detail) + } else { + ReplicaCreateDropReason::Manual + } +} + +/// Map an in-memory replica config to a [`ReplicaShape`], or `None` for an +/// unmanaged replica (which the controller does not own). +fn replica_shape(config: &mz_controller::clusters::ReplicaConfig) -> Option { + use mz_controller::clusters::ReplicaLocation; + let ReplicaLocation::Managed(managed) = &config.location else { + return None; + }; + Some(ReplicaShape { + size: managed.size.clone(), + availability_zones: managed.availability_zones.clone(), + logging: config.compute.logging.clone(), + }) +} + +fn reconfiguration_to_controller( + record: &mz_catalog::memory::objects::ReconfigurationState, +) -> ReconfigurationRecord { + // Destructure the source (no `..`): a field added to the memory type is a + // compile error here until it's carried across. The target is the same. + let mz_catalog::memory::objects::ReconfigurationState { + target, + deadline, + on_timeout, + } = record; + let mz_catalog::memory::objects::ReconfigurationTarget { + size, + replication_factor, + availability_zones, + logging, + } = target; + ReconfigurationRecord { + target: ReconfigurationTarget { + size: size.clone(), + replication_factor: *replication_factor, + availability_zones: availability_zones.clone(), + logging: logging.clone(), + }, + deadline: *deadline, + on_timeout: on_timeout_to_controller(*on_timeout), + } +} + +fn schedule_to_controller(schedule: &mz_sql::plan::ClusterSchedule) -> ClusterSchedule { + match schedule { + mz_sql::plan::ClusterSchedule::Manual => ClusterSchedule::Manual, + mz_sql::plan::ClusterSchedule::Refresh { + hydration_time_estimate, + } => ClusterSchedule::Refresh { + hydration_time_estimate: *hydration_time_estimate, + }, + } +} + +fn on_timeout_to_controller(action: mz_sql::plan::OnTimeoutAction) -> OnTimeout { + match action { + mz_sql::plan::OnTimeoutAction::Commit => OnTimeout::Commit, + mz_sql::plan::OnTimeoutAction::Rollback => OnTimeout::Rollback, + } +} + +fn on_timeout_from_controller(action: OnTimeout) -> mz_sql::plan::OnTimeoutAction { + match action { + OnTimeout::Commit => mz_sql::plan::OnTimeoutAction::Commit, + OnTimeout::Rollback => mz_sql::plan::OnTimeoutAction::Rollback, + } +} + +fn auto_scaling_policy_to_controller( + strategy: &mz_sql::plan::AutoScalingStrategy, +) -> AutoScalingPolicy { + // Destructure the source (no `..`): a field added to either plan type is a + // compile error here until it's carried across. + let mz_sql::plan::AutoScalingStrategy { on_hydration } = strategy; + AutoScalingPolicy { + on_hydration: on_hydration.as_ref().map(|on_hydration| { + let mz_sql::plan::OnHydration { + hydration_size, + linger_duration, + } = on_hydration; + OnHydrationPolicy { + hydration_size: hydration_size.clone(), + linger_duration: *linger_duration, + } + }), + } +} + +fn burst_to_controller( + record: &mz_catalog::memory::objects::BurstState, +) -> mz_cluster_controller::ctx::BurstRecord { + // Destructure the source (no `..`): a field added to the memory type is a + // compile error here until it's carried across. + let mz_catalog::memory::objects::BurstState { + burst_size, + linger_duration, + steady_hydrated_at, + } = record; + mz_cluster_controller::ctx::BurstRecord { + burst_size: burst_size.clone(), + linger_duration: *linger_duration, + steady_hydrated_at: *steady_hydrated_at, + } +} + +fn reconfiguration_from_controller( + record: &ReconfigurationRecord, +) -> mz_catalog::memory::objects::ReconfigurationState { + // Destructure the source (no `..`): a field added to the controller type is a + // compile error here until it's carried across. The target is the same. + let ReconfigurationRecord { + target, + deadline, + on_timeout, + } = record; + let ReconfigurationTarget { + size, + replication_factor, + availability_zones, + logging, + } = target; + mz_catalog::memory::objects::ReconfigurationState { + target: mz_catalog::memory::objects::ReconfigurationTarget { + size: size.clone(), + replication_factor: *replication_factor, + availability_zones: availability_zones.clone(), + logging: logging.clone(), + }, + deadline: *deadline, + on_timeout: on_timeout_from_controller(*on_timeout), + } +} + +fn burst_from_controller( + record: &mz_cluster_controller::ctx::BurstRecord, +) -> mz_catalog::memory::objects::BurstState { + // Destructure the source (no `..`): a field added to the controller type is a + // compile error here until it's carried across. + let mz_cluster_controller::ctx::BurstRecord { + burst_size, + linger_duration, + steady_hydrated_at, + } = record; + mz_catalog::memory::objects::BurstState { + burst_size: burst_size.clone(), + linger_duration: *linger_duration, + steady_hydrated_at: *steady_hydrated_at, + } +} + +#[cfg(test)] +mod tests { + use mz_cluster_controller::strategy::BASELINE_STRATEGY_NAME; + + use super::*; + + #[mz_ore::test] + fn test_reason_from_strategies() { + use ReplicaCreateDropReason as Reason; + + let detail = || { + Some(RefreshWindowDecision { + objects_needing_refresh: Vec::new(), + objects_needing_compaction: Vec::new(), + hydration_time_estimate: Duration::ZERO, + }) + }; + + // Each strategy maps to its own reason; the baseline (or no + // attribution) is `Manual`. + assert!(matches!( + reason_from_strategies(&[BASELINE_STRATEGY_NAME], None), + Reason::Manual + )); + assert!(matches!(reason_from_strategies(&[], None), Reason::Manual)); + assert!(matches!( + reason_from_strategies(&[GRACEFUL_RECONFIGURATION_STRATEGY_NAME], None), + Reason::GracefulReconfiguration + )); + assert!(matches!( + reason_from_strategies(&[HYDRATION_BURST_STRATEGY_NAME], None), + Reason::HydrationBurst + )); + // The on-refresh reason carries the create's window decision through to + // the audit detail. + assert!(matches!( + reason_from_strategies(&[ON_REFRESH_STRATEGY_NAME], detail()), + Reason::OnRefresh(Some(_)) + )); + + // Graceful wins the tie-break when several strategies desired the + // shape, and any strategy attribution beats the baseline's `Manual`. + // The window decision is attached only when on-refresh wins, so the + // `scheduling_policies` blob appears iff the audited reason is + // `schedule`. + assert!(matches!( + reason_from_strategies( + &[ + BASELINE_STRATEGY_NAME, + HYDRATION_BURST_STRATEGY_NAME, + ON_REFRESH_STRATEGY_NAME, + GRACEFUL_RECONFIGURATION_STRATEGY_NAME, + ], + detail(), + ), + Reason::GracefulReconfiguration + )); + assert!(matches!( + reason_from_strategies( + &[BASELINE_STRATEGY_NAME, ON_REFRESH_STRATEGY_NAME], + detail() + ), + Reason::OnRefresh(Some(_)) + )); + } +} diff --git a/src/adapter/src/coord/cluster_scheduling.rs b/src/adapter/src/coord/cluster_scheduling.rs index ae607520a094a..1ad1211d492b6 100644 --- a/src/adapter/src/coord/cluster_scheduling.rs +++ b/src/adapter/src/coord/cluster_scheduling.rs @@ -8,6 +8,7 @@ // by the Apache License, Version 2.0. use itertools::Itertools; +use mz_adapter_types::dyncfgs::ENABLE_CLUSTER_CONTROLLER; use mz_audit_log::SchedulingDecisionsWithReasonsV2; use mz_catalog::memory::objects::{CatalogItem, ClusterVariant, ClusterVariantManaged}; use mz_controller_types::ClusterId; @@ -109,7 +110,17 @@ impl SchedulingDecision { impl Coordinator { #[mz_ore::instrument(level = "debug")] /// Call each scheduling policy. + /// + /// No-ops when the cluster controller owns the replica set + /// ([`ENABLE_CLUSTER_CONTROLLER`]): the controller's `OnRefreshStrategy` is + /// then the sole authority over scheduled clusters, so the legacy policy must + /// not also toggle their replication factor (two writers of the replica set is + /// not allowed). The legacy path remains in place to drive scheduling while the + /// gate is off. pub(crate) async fn check_scheduling_policies(&self) { + if ENABLE_CLUSTER_CONTROLLER.get(self.catalog().system_config().dyncfgs()) { + return; + } // (So far, we have only this one policy.) self.check_refresh_policy(); } @@ -282,6 +293,14 @@ impl Coordinator { &mut self, decisions: Vec<(&'static str, Vec<(ClusterId, SchedulingDecision)>)>, ) { + // When the cluster controller owns the replica set it is the sole writer + // for scheduled clusters; drop any legacy decisions still in flight from a + // background task spawned before the gate flipped on, so the two never + // contend. (`check_scheduling_policies` already stops spawning new ones.) + if ENABLE_CLUSTER_CONTROLLER.get(self.catalog().system_config().dyncfgs()) { + return; + } + let start_time = Instant::now(); // 1. Add the received decisions to `cluster_scheduling_decisions`. diff --git a/src/adapter/src/coord/ddl.rs b/src/adapter/src/coord/ddl.rs index 45701353404d4..efebb2218a85c 100644 --- a/src/adapter/src/coord/ddl.rs +++ b/src/adapter/src/coord/ddl.rs @@ -335,9 +335,18 @@ impl Coordinator { let mut update_cluster_scheduling_config = false; let mut update_http_config = false; let mut update_advance_timelines_interval = false; + // Whether to kick the cluster controller to reconcile immediately: set + // for ops that change durable cluster state or system configuration. + let mut kick_cluster_controller = false; for op in &ops { match op { + catalog::Op::UpdateClusterConfig { .. } + | catalog::Op::UpdateClusterReplicaConfig { .. } + | catalog::Op::RenameCluster { .. } + | catalog::Op::RenameClusterReplica { .. } => { + kick_cluster_controller = true; + } catalog::Op::DropObjects(drop_object_infos) => { for drop_object_info in drop_object_infos { match &drop_object_info { @@ -347,6 +356,7 @@ impl Coordinator { } catalog::DropObjectInfo::Cluster(id) => { clusters_to_drop.push(*id); + kick_cluster_controller = true; } catalog::DropObjectInfo::ClusterReplica(( cluster_id, @@ -355,6 +365,7 @@ impl Coordinator { )) => { // Drop the cluster replica itself. cluster_replicas_to_drop.push((*cluster_id, *replica_id)); + kick_cluster_controller = true; } _ => (), } @@ -389,6 +400,9 @@ impl Coordinator { update_cluster_scheduling_config |= vars::is_cluster_scheduling_var(name); update_http_config |= vars::is_http_config_var(name); update_advance_timelines_interval |= name == DEFAULT_TIMESTAMP_INTERVAL.name(); + // The controller's gates and knobs live in the system + // configuration. + kick_cluster_controller = true; } catalog::Op::ResetAllSystemConfiguration => { // Assume they all need to be updated. @@ -405,6 +419,7 @@ impl Coordinator { update_metrics_config = true; update_http_config = true; update_advance_timelines_interval = true; + kick_cluster_controller = true; } catalog::Op::RenameItem { id, .. } => { let item = self.catalog().get_entry(id); @@ -436,6 +451,7 @@ impl Coordinator { } catalog::Op::CreateCluster { id, .. } => { clusters_to_create.push(*id); + kick_cluster_controller = true; } catalog::Op::CreateClusterReplica { cluster_id, @@ -448,6 +464,7 @@ impl Coordinator { name.clone(), config.location.num_processes(), )); + kick_cluster_controller = true; } _ => (), } @@ -561,6 +578,9 @@ impl Coordinator { self.advance_timelines_interval = tokio::time::interval(new_interval); } } + if kick_cluster_controller { + self.cluster_controller_kick.notify_one(); + } } .instrument(info_span!("coord::catalog_transact_with::finalize")) .await; diff --git a/src/adapter/src/coord/info_metrics.rs b/src/adapter/src/coord/info_metrics.rs index 7fb817effaa76..08e7201ceb7f5 100644 --- a/src/adapter/src/coord/info_metrics.rs +++ b/src/adapter/src/coord/info_metrics.rs @@ -322,8 +322,7 @@ mod tests { }; use mz_compute_types::config::ComputeReplicaConfig; use mz_controller::clusters::{ - ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaAllocation, ReplicaConfig, - UnmanagedReplicaLocation, + ManagedReplicaLocation, ReplicaAllocation, ReplicaConfig, UnmanagedReplicaLocation, }; use mz_controller_types::{ClusterId, ReplicaId}; use mz_repr::adt::mz_acl_item::PrivilegeMap; @@ -448,6 +447,9 @@ mod tests { replication_factor: 1, optimizer_feature_overrides: Default::default(), schedule: Default::default(), + auto_scaling_strategy: None, + reconfiguration: None, + burst: None, }), workload_class: None, } @@ -656,7 +658,7 @@ mod tests { size: "scale=2,workers=4".to_string(), internal: false, billed_as: None, - availability_zones: ManagedReplicaAvailabilityZones::FromReplica(None), + availability_zones: Vec::new(), pending: false, }), compute: ComputeReplicaConfig { diff --git a/src/adapter/src/coord/message_handler.rs b/src/adapter/src/coord/message_handler.rs index 9248b3452b3f3..d341c9a8687f9 100644 --- a/src/adapter/src/coord/message_handler.rs +++ b/src/adapter/src/coord/message_handler.rs @@ -212,6 +212,11 @@ impl Coordinator { .boxed_local() .await; } + Message::ClusterControllerRequest(request) => { + self.handle_cluster_controller_request(request) + .boxed_local() + .await; + } Message::DeferredStatementReady => { self.handle_deferred_statement().boxed_local().await; } diff --git a/src/adapter/src/coord/sequencer/inner/cluster.rs b/src/adapter/src/coord/sequencer/inner/cluster.rs index 5c06794cbd209..b2a6595a97865 100644 --- a/src/adapter/src/coord/sequencer/inner/cluster.rs +++ b/src/adapter/src/coord/sequencer/inner/cluster.rs @@ -14,12 +14,12 @@ use itertools::Itertools; use maplit::btreeset; use mz_catalog::builtin::BUILTINS; use mz_catalog::memory::objects::{ - ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, + ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, ReconfigurationState, + ReconfigurationTarget, }; use mz_compute_types::config::ComputeReplicaConfig; use mz_controller::clusters::{ - ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaConfig, ReplicaLocation, - ReplicaLogging, + ManagedReplicaLocation, ReplicaConfig, ReplicaLocation, ReplicaLogging, }; use mz_controller_types::{ClusterId, DEFAULT_REPLICA_LOGGING_INTERVAL}; use mz_ore::cast::CastFrom; @@ -38,12 +38,18 @@ use mz_sql::session::metadata::SessionMetadata; use mz_sql::session::vars::{MAX_REPLICAS_PER_CLUSTER, SystemVars, Var}; use tracing::{Instrument, Span, debug}; +use mz_adapter_types::dyncfgs::{ + DEFAULT_CLUSTER_RECONFIGURATION_TIMEOUT, ENABLE_BACKGROUND_ALTER_CLUSTER, + ENABLE_CLUSTER_CONTROLLER, +}; + use super::return_if_err; use crate::AdapterError::AlterClusterWhilePendingReplicas; use crate::catalog::{self, Op, ReplicaCreateDropReason}; use crate::coord::{ - AlterCluster, AlterClusterFinalize, AlterClusterWaitForHydrated, ClusterStage, Coordinator, - Message, PlanValidity, StageResult, Staged, + AlterCluster, AlterClusterAwaitReconfiguration, AlterClusterFinalize, + AlterClusterWaitForHydrated, ClusterStage, Coordinator, Message, PlanValidity, StageResult, + Staged, }; use crate::{AdapterError, ExecuteContext, ExecuteResponse, session::Session}; @@ -57,6 +63,7 @@ impl Staged for ClusterStage { Self::Alter(stage) => &mut stage.validity, Self::WaitForHydrated(stage) => &mut stage.validity, Self::Finalize(stage) => &mut stage.validity, + Self::AwaitReconfiguration(stage) => &mut stage.validity, } } @@ -102,6 +109,12 @@ impl Staged for ClusterStage { ) .await } + Self::AwaitReconfiguration(stage) => coord.await_reconfiguration_stage( + stage.validity, + stage.cluster_id, + stage.target, + stage.past_deadline_grace_used, + ), } } @@ -184,6 +197,9 @@ impl Coordinator { replication_factor: 1, optimizer_feature_overrides: Default::default(), schedule: Default::default(), + auto_scaling_strategy: None, + reconfiguration: None, + burst: None, }); } } @@ -196,6 +212,9 @@ impl Coordinator { replication_factor, optimizer_feature_overrides: _, schedule, + auto_scaling_strategy, + reconfiguration: _, + burst: _, }) => { match &options.size { Set(s) => size.clone_from(s), @@ -234,6 +253,12 @@ impl Coordinator { Reset => *schedule = Default::default(), Unchanged => {} } + match &options.auto_scaling_strategy { + Set(new_strategy) => auto_scaling_strategy.clone_from(new_strategy), + // The default is autoscaling disabled. + Reset => *auto_scaling_strategy = None, + Unchanged => {} + } if !matches!(options.replicas, Unchanged) { coord_bail!("Cannot change REPLICAS of managed clusters"); } @@ -254,6 +279,9 @@ impl Coordinator { if !matches!(options.replication_factor, Unchanged) { coord_bail!("Cannot change REPLICATION FACTOR of unmanaged clusters"); } + if !matches!(options.auto_scaling_strategy, Unchanged) { + coord_bail!("Cannot change AUTO SCALING STRATEGY of unmanaged clusters"); + } } } @@ -263,12 +291,56 @@ impl Coordinator { Unchanged => {} } - if new_config == config { + // A no-op `ALTER` short-circuits — but only when no reconfiguration is in + // flight. When the controller owns an in-flight reconfiguration, an `ALTER` + // that leaves the realized config unchanged is not a no-op: it re-targets + // (folds onto) the in-flight record. This is how an `ALTER` back to the + // realized shape cancels an in-flight reconfiguration — so it must reach the + // reshape path below rather than early-returning here. (`config` carries the + // in-flight record, so `new_config == config` holds for such an `ALTER`.) + // The controller owns only *user* managed clusters (see `ManagedClusterIds` + // in cluster_controller.rs and `controller_owns` in the managed-to-managed + // path below). A system/builtin cluster is never converged by the + // controller, so it must not be reshaped into a durable reconfiguration + // record nobody would cut over — it takes the direct realized-config path + // below, exactly as it does with the controller off. + let cluster_controller_owns = ENABLE_CLUSTER_CONTROLLER + .get(self.catalog().system_config().dyncfgs()) + && cluster_id.is_user(); + let reconfiguration_in_flight = matches!( + &config.variant, + Managed(managed) if managed.reconfiguration.is_some() + ); + if new_config == config && !(cluster_controller_owns && reconfiguration_in_flight) { return Ok(StageResult::Response(ExecuteResponse::AlteredObject( ObjectType::Cluster, ))); } + // When the cluster controller owns the replica set, a config-shape change + // (or any change while a reconfiguration is already in flight) is reshaped + // into a durable `reconfiguration` record rather than driven by the legacy + // 3-stage machine; the controller converges on it. Non-shape changes with + // no record in flight fall through to the realized-config update below. + if cluster_controller_owns { + if let (Managed(old_managed), Managed(new_managed)) = + (&config.variant, &new_config.variant) + { + if self.reconfiguration_needs_record(old_managed, new_managed) { + return self + .reshape_alter_cluster_managed( + session, + cluster_id, + new_config.clone(), + options, + strategy, + validity, + ) + .await; + } + } + } + match (&config.variant, &new_config.variant) { (Managed(_), Managed(new_config_managed)) => { let alter_followup = self @@ -359,6 +431,295 @@ impl Coordinator { ))) } + /// Whether a managed→managed `ALTER` must be reshaped into a durable + /// `reconfiguration` record (controller-driven) rather than applied to the + /// realized config directly. + /// + /// True when the change touches a replica's **config shape** (`SIZE`, logging, + /// or `AVAILABILITY ZONES`) — which needs a hydrate-overlap — or when a + /// reconfiguration is already in flight, in which case every further `ALTER` + /// folds into the existing record (re-targets it and refreshes its deadline) + /// rather than racing a direct config write against the in-flight transition. + /// + /// The fold is an **overlay on the in-flight target, not the realized config**: + /// a dimension the `ALTER` set replaces the record's target for that dimension, + /// a dimension left unset keeps the in-flight target's value (see + /// [`Coordinator::reshape_alter_cluster_managed`]). This is why a record in + /// flight forces the record path even for a change that, against the realized + /// config alone, would look like a no-shape (e.g. rf-only) update: applying it + /// to the realized config would discard the in-flight target. + fn reconfiguration_needs_record( + &self, + old: &ClusterVariantManaged, + new: &ClusterVariantManaged, + ) -> bool { + old.reconfiguration.is_some() + || new.size != old.size + || new.logging != old.logging + || new.availability_zones != old.availability_zones + } + + /// Reshape a managed→managed `ALTER` into a durable `reconfiguration` record. + /// + /// Writes (or folds into) the `reconfiguration` record carrying the full target + /// config shape and a deadline, leaving the realized config in place (only + /// `workload_class`, which needs no hydrate-overlap, is applied immediately). + /// The controller converges the replica set onto the target and cuts the + /// realized config over at hydration. + /// + /// **Fold semantics.** When a record is already in flight, the target is an + /// overlay on the *in-flight target*, not the realized config: a dimension the + /// `ALTER` set (`options.*` is `Set`/`Reset`) takes the new value, a dimension + /// left `Unchanged` keeps the in-flight target's value. `new_config` was built + /// against the realized config, which still holds the pre-reconfiguration shape + /// (the realized config is advanced only at cut-over), so seeding `Unchanged` + /// dimensions from it would silently revert the in-flight transition along any + /// dimension this `ALTER` did not mention. With no record in flight there is + /// nothing to fold and the target is exactly `new_config`'s shape. + /// + /// **Timeout action.** The record carries an `on_timeout` action (resolved + /// from `WITH (WAIT ...)`, defaulting to `ROLLBACK`), which the controller + /// applies at the deadline only if the target has not hydrated: `ROLLBACK` + /// drops the whole in-flight target set and retains the record as a tombstone + /// (the realized config never advanced, so the cluster keeps its old shape); + /// `COMMIT` cuts the realized config over to the not-fully-hydrated target and + /// clears the record. Success always takes precedence — a target that hydrates + /// before the deadline cuts over regardless of the action. + /// + /// With `enable_background_alter_cluster` on, the statement returns + /// immediately. With it off, the session blocks on a wait-shim + /// ([`ClusterStage::AwaitReconfiguration`]) that polls the record until it + /// clears (success) or its deadline passes (timeout), preserving today's + /// foreground UX over the same durable mechanism. + async fn reshape_alter_cluster_managed( + &mut self, + session: &Session, + cluster_id: ClusterId, + new_config: ClusterConfig, + options: &PlanClusterOption, + strategy: &AlterClusterPlanStrategy, + validity: PlanValidity, + ) -> Result>, AdapterError> { + use mz_sql::plan::AlterOptionParameter::Unchanged; + + let ClusterVariant::Managed(new_managed) = &new_config.variant else { + return Err(AdapterError::Internal( + "reshape_alter_cluster_managed requires a managed target config".into(), + )); + }; + + // Fold onto the in-flight target when one exists: `new_config` carries the + // realized value for any dimension the `ALTER` left `Unchanged`, but the + // realized config is the pre-reconfiguration shape, so we instead carry the + // in-flight target's value for those dimensions. Only dimensions the `ALTER` + // explicitly set diverge from the in-flight target. + let cluster = self.catalog.get_cluster(cluster_id); + let in_flight = match &cluster.config.variant { + ClusterVariant::Managed(managed) => managed.reconfiguration.clone(), + ClusterVariant::Unmanaged => None, + }; + let new_target = ReconfigurationTarget { + size: new_managed.size.clone(), + replication_factor: new_managed.replication_factor, + availability_zones: new_managed.availability_zones.clone(), + logging: new_managed.logging.clone(), + }; + let unchanged = ReconfigurationDimensionsUnchanged { + size: matches!(options.size, Unchanged), + replication_factor: matches!(options.replication_factor, Unchanged), + availability_zones: matches!(options.availability_zones, Unchanged), + // Logging is driven by two options; "unchanged" only if neither was set. + logging: matches!(options.introspection_debugging, Unchanged) + && matches!(options.introspection_interval, Unchanged), + }; + let target = fold_reconfiguration_target( + in_flight.as_ref().map(|r| &r.target), + new_target, + unchanged, + ); + + // Validate the target up front, so a bad reshape errors at `ALTER` time + // rather than silently parking an unconvergeable record. + let role_id = session.role_metadata().current_role; + self.catalog.ensure_valid_replica_size( + &self + .catalog() + .get_role_allowed_cluster_sizes(&Some(role_id)), + &target.size, + false, + )?; + self.ensure_valid_azs(target.availability_zones.iter())?; + + // Resolve the deadline and the on-timeout action from the existing + // `WITH (WAIT ...)` surface; both are written relative to the current time + // so they survive session disconnect and restart. Unlike the target — which + // folds per-dimension onto the in-flight one — the deadline and `on_timeout` + // are replaced wholesale by the latest `ALTER`'s `WAIT` clause (they are + // resolved fresh here, not merged), so re-issuing an `ALTER` with a + // different `ON TIMEOUT` overwrites the prior action. + // - no `WAIT` -> the system-default timeout and the implicit + // `on_timeout` default (`ROLLBACK`). + // - `WAIT FOR` -> sugar for `ON TIMEOUT COMMIT` (cut over at the + // deadline regardless of hydration). + // - `WAIT UNTIL READY -> the explicit `TIMEOUT` / `ON TIMEOUT`. + let (timeout, on_timeout) = match strategy { + AlterClusterPlanStrategy::None => ( + DEFAULT_CLUSTER_RECONFIGURATION_TIMEOUT + .get(self.catalog().system_config().dyncfgs()), + OnTimeoutAction::default(), + ), + AlterClusterPlanStrategy::For(timeout) => (*timeout, OnTimeoutAction::Commit), + AlterClusterPlanStrategy::UntilReady { + timeout, + on_timeout, + } => (*timeout, *on_timeout), + }; + let deadline = self.now() + u64::try_from(timeout.as_millis()).unwrap_or(u64::MAX); + let record = ReconfigurationState { + target: target.clone(), + deadline: deadline.into(), + on_timeout, + }; + + // Write the record onto the *realized* config (which is left otherwise + // untouched), folding over any existing record. `workload_class` needs no + // overlap, so it is applied immediately. + let cluster = self.catalog.get_cluster(cluster_id); + let cluster_name = cluster.name().to_string(); + let mut realized = cluster.config.clone(); + let ClusterVariant::Managed(realized_managed) = &mut realized.variant else { + return Err(AdapterError::Internal( + "reshape_alter_cluster_managed requires a managed realized config".into(), + )); + }; + realized_managed.reconfiguration = Some(record); + realized.workload_class = new_config.workload_class.clone(); + + self.catalog_transact( + Some(session), + vec![Op::UpdateClusterConfig { + id: cluster_id, + name: cluster_name, + config: realized, + }], + ) + .await?; + + let background = + ENABLE_BACKGROUND_ALTER_CLUSTER.get(self.catalog().system_config().dyncfgs()); + if background { + return Ok(StageResult::Response(ExecuteResponse::AlteredObject( + ObjectType::Cluster, + ))); + } + + // Foreground wait-shim: poll the durable record until it clears or times + // out. The reconfiguration continues in the background regardless of the + // session, so a disconnect during the wait no longer aborts it. + Ok(StageResult::Immediate(Box::new( + ClusterStage::AwaitReconfiguration(AlterClusterAwaitReconfiguration { + validity, + cluster_id, + target, + past_deadline_grace_used: false, + }), + ))) + } + + /// One step of the foreground wait-shim: read the durable `reconfiguration` + /// record and either complete, error on timeout, or re-poll after the + /// configured interval. + /// + /// The record clearing ends the wait, but is not by itself success: the + /// controller also clears the record on a `ROLLBACK` timeout, leaving the + /// realized config untouched. The realized config having reached `target` + /// is what distinguishes the two. A record whose deadline has passed is a + /// candidate timeout, not a conclusive one, so we grant one post-deadline + /// grace re-poll before erroring. The reconfiguration itself is durable and + /// continues (or has already settled) independently of this session. + fn await_reconfiguration_stage( + &self, + validity: PlanValidity, + cluster_id: ClusterId, + target: ReconfigurationTarget, + past_deadline_grace_used: bool, + ) -> Result>, AdapterError> { + let Some(cluster) = self.catalog().try_get_cluster(cluster_id) else { + // The cluster was dropped out from under the reconfiguration; nothing + // to wait on. + return Ok(StageResult::Response(ExecuteResponse::AlteredObject( + ObjectType::Cluster, + ))); + }; + let record = match &cluster.config.variant { + ClusterVariant::Managed(managed) => managed.reconfiguration.clone(), + ClusterVariant::Unmanaged => None, + }; + + match record { + None => { + // Cleared. A cut-over advanced the realized config to the + // target: success. A clear that left the realized config short + // of the target is a `ROLLBACK` timeout — or our record was + // overwritten by a concurrent `ALTER` and settled elsewhere, in + // which case this session's requested shape equally did not + // take effect. + let realized_matches_target = match &cluster.config.variant { + ClusterVariant::Managed(managed) => { + managed.size == target.size + && managed.replication_factor == target.replication_factor + && managed.availability_zones == target.availability_zones + && managed.logging == target.logging + } + ClusterVariant::Unmanaged => false, + }; + if realized_matches_target { + Ok(StageResult::Response(ExecuteResponse::AlteredObject( + ObjectType::Cluster, + ))) + } else { + Err(AdapterError::AlterClusterTimeout) + } + } + Some(record) => { + let past_deadline = mz_repr::Timestamp::from(self.now()) > record.deadline; + if past_deadline && past_deadline_grace_used { + // The record is still present after the grace re-poll: stop + // waiting and surface a timeout. This only bounds the wait + // to one poll interval past the deadline; it says nothing + // about how the reconfiguration settles (a `COMMIT` record + // stays present until the imminent cut-over clears it, a + // `ROLLBACK` clear may simply not have landed yet). + return Err(AdapterError::AlterClusterTimeout); + } + // Past the deadline for the first time, re-poll once more so the + // controller's success-precedence cut-over can clear the record; + // before the deadline this flag stays unset. + let past_deadline_grace_used = past_deadline_grace_used || past_deadline; + let poll_duration = self + .catalog + .system_config() + .cluster_alter_check_ready_interval(); + let span = Span::current(); + Ok(StageResult::Handle(mz_ore::task::spawn( + || "Await Cluster Reconfiguration", + async move { + tokio::time::sleep(poll_duration).await; + Ok(Box::new(ClusterStage::AwaitReconfiguration( + AlterClusterAwaitReconfiguration { + validity, + cluster_id, + target, + past_deadline_grace_used, + }, + ))) + } + .instrument(span), + ))) + } + } + } + async fn finalize_alter_cluster_stage( &mut self, session: &Session, @@ -627,6 +988,9 @@ impl Coordinator { replication_factor: plan.replication_factor, optimizer_feature_overrides: plan.optimizer_feature_overrides.clone(), schedule: plan.schedule.clone(), + auto_scaling_strategy: plan.auto_scaling_strategy.clone(), + reconfiguration: None, + burst: None, }) } CreateClusterVariant::Unmanaged(_) => ClusterVariant::Unmanaged, @@ -666,6 +1030,7 @@ impl Coordinator { size, optimizer_feature_overrides: _, schedule: _, + auto_scaling_strategy: _, }: CreateClusterManagedPlan, cluster_id: ClusterId, mut ops: Vec, @@ -733,7 +1098,9 @@ impl Coordinator { reason: ReplicaCreateDropReason, ) -> Result<(), AdapterError> { let location = mz_catalog::durable::ReplicaLocation::Managed { - availability_zone: None, + // Concretized below from the cluster config; this intermediate value + // is discarded, so the list is left empty here. + availability_zones: Vec::new(), billed_as: None, internal: false, size: size.clone(), @@ -855,7 +1222,9 @@ impl Coordinator { } let location = mz_catalog::durable::ReplicaLocation::Managed { - availability_zone, + // The user-pinned `AVAILABILITY ZONE`, if any, as a zero- + // or one-element list. + availability_zones: availability_zone.into_iter().collect(), billed_as, internal, size: size.clone(), @@ -939,7 +1308,9 @@ impl Coordinator { None => None, }; let location = mz_catalog::durable::ReplicaLocation::Managed { - availability_zone, + // The user-pinned `AVAILABILITY ZONE`, if any, as a zero- or + // one-element list. + availability_zones: availability_zone.into_iter().collect(), billed_as, internal, size, @@ -1040,6 +1411,9 @@ impl Coordinator { replication_factor, optimizer_feature_overrides: _, schedule: _, + auto_scaling_strategy: _, + reconfiguration: _, + burst: _, }) = &cluster.config.variant else { panic!("expected existing managed cluster config"); @@ -1051,6 +1425,9 @@ impl Coordinator { logging: new_logging, optimizer_feature_overrides: _, schedule: _, + auto_scaling_strategy: _, + reconfiguration: _, + burst: _, }) = &new_config.variant else { panic!("expected new managed cluster config"); @@ -1093,7 +1470,26 @@ impl Coordinator { } } - if new_size != size + // When the controller owns the managed replica set (master gate on, user + // cluster), a non-record change reaching this path is replication-factor + // only: config-shape changes (size/logging/AZ) are reshaped into a durable + // reconfiguration record before they get here. The controller reconciles + // the replica set to the realized config's new count on its next tick, so + // we update only the realized config and emit no create/drop here. Doing + // both would fight the controller: it derives replica names from the + // observed set, so an adapter create by canonical `rN` would risk + // colliding with a controller-chosen name and an adapter drop by canonical + // `rN` would miss a churned one. With the gate off (or a system cluster, + // which the controller never owns) the legacy path below still does the + // create/drop directly. + let controller_owns = ENABLE_CLUSTER_CONTROLLER + .get(self.catalog().system_config().dyncfgs()) + && cluster_id.is_user(); + + if controller_owns { + // Defer all replica create/drop to the controller; only the realized + // config update below is applied here. + } else if new_size != size || new_availability_zones != availability_zones || new_logging != logging { @@ -1218,6 +1614,9 @@ impl Coordinator { logging: _, optimizer_feature_overrides: _, schedule: _, + auto_scaling_strategy: _, + reconfiguration: _, + burst: _, }) = &mut new_config.variant else { panic!("expected new managed cluster config"); @@ -1258,9 +1657,10 @@ impl Coordinator { ReplicaLocation::Managed(location) => { sizes.insert(location.size.clone()); - if let ManagedReplicaAvailabilityZones::FromReplica(Some(az)) = - &location.availability_zones - { + // An unmanaged cluster's replica carries its single + // user-pinned AZ (if any) as the sole entry; every pin must + // fall within the managed cluster's `AVAILABILITY ZONES`. + for az in &location.availability_zones { if !new_availability_zones.contains(az) { coord_bail!( "unmanaged replica has availability zone {az} which is not \ @@ -1476,6 +1876,58 @@ fn managed_cluster_replica_name(index: u32) -> String { format!("r{}", index + 1) } +/// Which reconfiguration-target dimensions an `ALTER` left unset (`Unchanged`). +/// Drives [`fold_reconfiguration_target`]. +struct ReconfigurationDimensionsUnchanged { + size: bool, + replication_factor: bool, + availability_zones: bool, + logging: bool, +} + +/// Fold a new `ALTER` onto an in-flight reconfiguration target. +/// +/// `new_target` was built against the *realized* config, so any dimension the +/// `ALTER` left `Unchanged` carries the realized (pre-reconfiguration) value. When +/// a reconfiguration is in flight (`in_flight` is `Some`), the realized config is +/// the pre-reconfiguration shape, so for each `Unchanged` dimension we instead +/// keep the in-flight target's value — only dimensions the `ALTER` explicitly set +/// re-target. With nothing in flight (`in_flight` is `None`) the target is exactly +/// `new_target`. This is what keeps an `ALTER` that touches one dimension (e.g. +/// rf-only) from silently reverting the in-flight transition along every dimension +/// it did not mention. +fn fold_reconfiguration_target( + in_flight: Option<&ReconfigurationTarget>, + new_target: ReconfigurationTarget, + unchanged: ReconfigurationDimensionsUnchanged, +) -> ReconfigurationTarget { + let Some(prev) = in_flight else { + return new_target; + }; + ReconfigurationTarget { + size: if unchanged.size { + prev.size.clone() + } else { + new_target.size + }, + replication_factor: if unchanged.replication_factor { + prev.replication_factor + } else { + new_target.replication_factor + }, + availability_zones: if unchanged.availability_zones { + prev.availability_zones.clone() + } else { + new_target.availability_zones + }, + logging: if unchanged.logging { + prev.logging.clone() + } else { + new_target.logging + }, + } +} + /// The type of finalization needed after an /// operation such as alter_cluster_managed_to_managed. #[derive(PartialEq)] @@ -1484,3 +1936,90 @@ pub(crate) enum NeedsFinalization { Yes, No, } + +#[cfg(test)] +mod tests { + use mz_controller::clusters::ReplicaLogging; + use mz_controller_types::DEFAULT_REPLICA_LOGGING_INTERVAL; + + use super::*; + + fn target(size: &str, rf: u32, azs: &[&str], log_logging: bool) -> ReconfigurationTarget { + ReconfigurationTarget { + size: size.to_string(), + replication_factor: rf, + availability_zones: azs.iter().map(|s| s.to_string()).collect(), + logging: ReplicaLogging { + log_logging, + interval: Some(DEFAULT_REPLICA_LOGGING_INTERVAL), + }, + } + } + + fn all_changed() -> ReconfigurationDimensionsUnchanged { + ReconfigurationDimensionsUnchanged { + size: false, + replication_factor: false, + availability_zones: false, + logging: false, + } + } + + fn all_unchanged() -> ReconfigurationDimensionsUnchanged { + ReconfigurationDimensionsUnchanged { + size: true, + replication_factor: true, + availability_zones: true, + logging: true, + } + } + + #[mz_ore::test] + fn fold_with_no_record_takes_new_target() { + // No reconfiguration in flight: the target is exactly the new one. + let new = target("200cc", 3, &["az1"], true); + let folded = fold_reconfiguration_target(None, new.clone(), all_changed()); + assert_eq!(folded, new); + } + + #[mz_ore::test] + fn fold_rf_only_keeps_in_flight_shape() { + // A 200cc size change is in flight; a later rf-only ALTER must NOT revert + // the in-flight size/AZ/logging back to the realized (100cc) values that + // `new_target` carries for the dimensions the ALTER left unchanged. + let in_flight = target("200cc", 1, &["az2"], true); + // new_target reflects realized 100cc/az1 for every dimension but rf, which + // the ALTER set to 5. + let new = target("100cc", 5, &["az1"], false); + let unchanged = ReconfigurationDimensionsUnchanged { + size: true, + replication_factor: false, + availability_zones: true, + logging: true, + }; + let folded = fold_reconfiguration_target(Some(&in_flight), new, unchanged); + // The in-flight size/AZ/logging survive; only rf is re-targeted. + assert_eq!(folded, target("200cc", 5, &["az2"], true)); + } + + #[mz_ore::test] + fn fold_with_all_set_overwrites_every_dimension() { + // Every dimension explicitly set: the fold takes all of new_target. + let in_flight = target("200cc", 1, &["az2"], true); + let new = target("400cc", 9, &["az9"], false); + let folded = fold_reconfiguration_target(Some(&in_flight), new.clone(), all_changed()); + assert_eq!(folded, new); + } + + #[mz_ore::test] + fn fold_all_unchanged_is_alter_back_to_in_flight() { + // An ALTER that sets nothing while a record is in flight (e.g. only + // workload_class, handled elsewhere) folds to the in-flight target + // unchanged — a no-op re-target, not a revert to realized. + let in_flight = target("200cc", 2, &["az2"], true); + let realized_shaped = target("100cc", 1, &["az1"], false); + let folded = + fold_reconfiguration_target(Some(&in_flight), realized_shaped, all_unchanged()); + assert_eq!(folded, in_flight); + } +} diff --git a/src/audit-log/src/lib.rs b/src/audit-log/src/lib.rs index 2ec7ac2e8d6a7..95425dfbbfba9 100644 --- a/src/audit-log/src/lib.rs +++ b/src/audit-log/src/lib.rs @@ -225,6 +225,8 @@ pub enum EventDetails { IdFullNameV1(IdFullNameV1), RenameClusterV1(RenameClusterV1), RenameClusterReplicaV1(RenameClusterReplicaV1), + AlterClusterReconfigurationV1(AlterClusterReconfigurationV1), + ClusterHydrationBurstV1(ClusterHydrationBurstV1), RenameItemV1(RenameItemV1), IdNameV1(IdNameV1), SchemaV1(SchemaV1), @@ -329,6 +331,82 @@ pub struct IdNameV1 { pub name: String, } +/// A transition in the lifecycle of a background cluster reconfiguration (a +/// `reconfiguration` record on a managed cluster), recorded so an operator can +/// trace a background `ALTER CLUSTER` from start to its resolution. +/// +/// The replica creates and drops the reconfiguration induces are recorded +/// separately, carrying [`CreateOrDropClusterReplicaReasonV1::Reconfiguration`]; +/// this event family records the cluster-level transitions those replica +/// lifecycle events hang off of. +#[derive( + Clone, + Debug, + Serialize, + Deserialize, + PartialOrd, + PartialEq, + Eq, + Ord, + Hash, + Arbitrary +)] +#[serde(rename_all = "kebab-case")] +pub enum ReconfigurationLifecycleV1 { + /// A reconfiguration record was written or re-targeted: the cluster is now + /// converging onto a new target shape. + Started, + /// The realized config cut over to the target and the record was cleared: + /// a hydrated success under either `ON TIMEOUT` action — including one that + /// hydrated after the deadline, since success takes precedence — or a + /// forced `ON TIMEOUT COMMIT` cut-over of a not-yet-hydrated target past + /// the deadline. The event carries the record's deadline; comparing it to + /// the event's occurrence time tells an in-time cut-over from a late or + /// forced one. + Finalized, + /// The deadline fired with the target not hydrated under `ON TIMEOUT + /// ROLLBACK`: the record was cleared with the realized config untouched and + /// the target replicas dropped, reverting to the pre-reconfiguration set. + /// Emitted exactly once per timeout — the clear is durable, so the + /// transition cannot re-fire. This event is the timeout's papertrail; the + /// record (and with it the abandoned target) is gone from the catalog. + TimedOut, + /// An in-flight reconfiguration was cancelled by re-targeting the record + /// back to the cluster's still-realized shape (the ALTER-back cancel path); + /// the controller drops the in-flight target replicas and clears the record. + Cancelled, +} + +/// A cluster-level transition in a background reconfiguration's lifecycle. +/// +/// `deadline` is the reconfiguration's active deadline as a millisecond +/// `mz_timestamp`, recorded on every transition so an operator can correlate +/// the transition with the originating `ALTER`: on `started` and `cancelled` +/// the written/re-targeted record's deadline, on `timed-out` and `finalized` +/// the just-cleared record's — on `finalized`, comparing it to the event's +/// occurrence time distinguishes an in-time cut-over from a late or forced +/// (`ON TIMEOUT COMMIT`) one. +#[derive( + Clone, + Debug, + Serialize, + Deserialize, + PartialOrd, + PartialEq, + Eq, + Ord, + Hash, + Arbitrary +)] +pub struct AlterClusterReconfigurationV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: ReconfigurationLifecycleV1, + pub target_size: String, + pub target_replication_factor: u32, + pub deadline: Option, +} + #[derive( Clone, Debug, @@ -347,6 +425,56 @@ pub struct CreateRoleV1 { pub auto_provision_source: Option, } +/// A transition in the lifecycle of a hydration burst (a `burst` record on a +/// managed cluster), recorded so an operator can trace a controller-initiated +/// burst from start to teardown. +/// +/// The burst replica's create and drop are recorded separately, carrying +/// [`CreateOrDropClusterReplicaReasonV1::HydrationBurst`]; this event family +/// records the cluster-level transitions those replica lifecycle events hang off. +#[derive( + Clone, + Debug, + Serialize, + Deserialize, + PartialOrd, + PartialEq, + Eq, + Ord, + Hash, + Arbitrary +)] +#[serde(rename_all = "kebab-case")] +pub enum HydrationBurstLifecycleV1 { + /// A `burst` record was written: the controller is now running a burst + /// replica to accelerate hydration. + Started, + /// The `burst` record was cleared: the burst replica is torn down (its linger + /// elapsed after the steady set hydrated, or the burst is no longer warranted). + Finished, +} + +/// A cluster-level transition in a hydration burst's lifecycle. +#[derive( + Clone, + Debug, + Serialize, + Deserialize, + PartialOrd, + PartialEq, + Eq, + Ord, + Hash, + Arbitrary +)] +pub struct ClusterHydrationBurstV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: HydrationBurstLifecycleV1, + /// The size of the burst replica the record runs. + pub burst_size: String, +} + #[derive( Clone, Debug, @@ -586,6 +714,19 @@ pub enum CreateOrDropClusterReplicaReasonV1 { Manual, Schedule, System, + /// The cluster controller's graceful-reconfiguration strategy created the + /// replica while converging a cluster onto an in-flight `reconfiguration` + /// target (a background `ALTER CLUSTER`). + Reconfiguration, + /// The cluster controller's hydration-burst strategy created the + /// transient burst replica it runs while a cluster's objects are not yet + /// hydrated. + HydrationBurst, + /// The cluster controller dropped the replica because the cluster's + /// configuration no longer calls for it. NOTE: a replication-factor + /// decrease drop reads `retired` even though the config change itself was + /// user-initiated. + Retired, } /// The reason for the automated cluster scheduling to turn a cluster On or Off. Each existing @@ -1200,6 +1341,12 @@ impl EventDetails { EventDetails::RenameClusterReplicaV1(v) => { serde_json::to_value(v).expect("must serialize") } + EventDetails::AlterClusterReconfigurationV1(v) => { + serde_json::to_value(v).expect("must serialize") + } + EventDetails::ClusterHydrationBurstV1(v) => { + serde_json::to_value(v).expect("must serialize") + } EventDetails::RenameItemV1(v) => serde_json::to_value(v).expect("must serialize"), EventDetails::IdNameV1(v) => serde_json::to_value(v).expect("must serialize"), EventDetails::SchemaV1(v) => serde_json::to_value(v).expect("must serialize"), diff --git a/src/catalog-protos/objects_hashes.json b/src/catalog-protos/objects_hashes.json index ad588612bb0c8..8bc1f7a53ec5d 100644 --- a/src/catalog-protos/objects_hashes.json +++ b/src/catalog-protos/objects_hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.rs", - "md5": "e80f862e380a58535975f052a9ace35f" + "md5": "5ab4dfdd35a5a26cb0529e8e806914c9" }, { "name": "objects_v74.rs", @@ -50,5 +50,9 @@ { "name": "objects_v85.rs", "md5": "e80f862e380a58535975f052a9ace35f" + }, + { + "name": "objects_v86.rs", + "md5": "5ab4dfdd35a5a26cb0529e8e806914c9" } ] diff --git a/src/catalog-protos/src/audit_log.rs b/src/catalog-protos/src/audit_log.rs index 3bd9ec356c969..a3889efaadefd 100644 --- a/src/catalog-protos/src/audit_log.rs +++ b/src/catalog-protos/src/audit_log.rs @@ -14,17 +14,19 @@ //! because of Rust's orphan rules. use mz_audit_log::{ - AlterAddColumnV1, AlterApplyReplacementV1, AlterDefaultPrivilegeV1, AlterRetainHistoryV1, - AlterSetClusterV1, AlterSourceSinkV1, AlterSourceTimestampIntervalV1, CreateClusterReplicaV1, + AlterAddColumnV1, AlterApplyReplacementV1, AlterClusterReconfigurationV1, + AlterDefaultPrivilegeV1, AlterRetainHistoryV1, AlterSetClusterV1, AlterSourceSinkV1, + AlterSourceTimestampIntervalV1, ClusterHydrationBurstV1, CreateClusterReplicaV1, CreateClusterReplicaV2, CreateClusterReplicaV3, CreateClusterReplicaV4, CreateIndexV1, CreateMaterializedViewV1, CreateOrDropClusterReplicaReasonV1, CreateRoleV1, CreateSourceSinkV1, CreateSourceSinkV2, CreateSourceSinkV3, CreateSourceSinkV4, DropClusterReplicaV1, DropClusterReplicaV2, DropClusterReplicaV3, EventDetails, EventType, EventV1, FromPreviousIdV1, - FullNameV1, GrantRoleV1, GrantRoleV2, IdFullNameV1, IdNameV1, RefreshDecisionWithReasonV1, - RefreshDecisionWithReasonV2, RenameClusterReplicaV1, RenameClusterV1, RenameItemV1, - RenameSchemaV1, RevokeRoleV1, RevokeRoleV2, RotateKeysV1, SchedulingDecisionV1, - SchedulingDecisionsWithReasonsV1, SchedulingDecisionsWithReasonsV2, SchemaV1, SchemaV2, SetV1, - ToNewIdV1, UpdateItemV1, UpdateOwnerV1, UpdatePrivilegeV1, VersionedEvent, + FullNameV1, GrantRoleV1, GrantRoleV2, HydrationBurstLifecycleV1, IdFullNameV1, IdNameV1, + ReconfigurationLifecycleV1, RefreshDecisionWithReasonV1, RefreshDecisionWithReasonV2, + RenameClusterReplicaV1, RenameClusterV1, RenameItemV1, RenameSchemaV1, RevokeRoleV1, + RevokeRoleV2, RotateKeysV1, SchedulingDecisionV1, SchedulingDecisionsWithReasonsV1, + SchedulingDecisionsWithReasonsV2, SchemaV1, SchemaV2, SetV1, ToNewIdV1, UpdateItemV1, + UpdateOwnerV1, UpdatePrivilegeV1, VersionedEvent, }; use mz_proto::{ProtoType, RustType, TryFromProtoError}; @@ -308,6 +310,108 @@ impl RustType } } +impl RustType + for ReconfigurationLifecycleV1 +{ + fn into_proto(&self) -> crate::objects::audit_log_event_v1::ReconfigurationLifecycleV1 { + use crate::objects::audit_log_event_v1::reconfiguration_lifecycle_v1::Transition; + let transition = match self { + ReconfigurationLifecycleV1::Started => Transition::Started(Empty {}), + ReconfigurationLifecycleV1::Finalized => Transition::Finalized(Empty {}), + ReconfigurationLifecycleV1::TimedOut => Transition::TimedOut(Empty {}), + ReconfigurationLifecycleV1::Cancelled => Transition::Cancelled(Empty {}), + }; + crate::objects::audit_log_event_v1::ReconfigurationLifecycleV1 { transition } + } + + fn from_proto( + proto: crate::objects::audit_log_event_v1::ReconfigurationLifecycleV1, + ) -> Result { + use crate::objects::audit_log_event_v1::reconfiguration_lifecycle_v1::Transition; + Ok(match proto.transition { + Transition::Started(_) => ReconfigurationLifecycleV1::Started, + Transition::Finalized(_) => ReconfigurationLifecycleV1::Finalized, + Transition::TimedOut(_) => ReconfigurationLifecycleV1::TimedOut, + Transition::Cancelled(_) => ReconfigurationLifecycleV1::Cancelled, + }) + } +} + +impl RustType + for AlterClusterReconfigurationV1 +{ + fn into_proto(&self) -> crate::objects::audit_log_event_v1::AlterClusterReconfigurationV1 { + crate::objects::audit_log_event_v1::AlterClusterReconfigurationV1 { + cluster_id: self.cluster_id.to_string(), + cluster_name: self.cluster_name.to_string(), + transition: self.transition.into_proto(), + target_size: self.target_size.to_string(), + target_replication_factor: self.target_replication_factor, + deadline: self.deadline, + } + } + + fn from_proto( + proto: crate::objects::audit_log_event_v1::AlterClusterReconfigurationV1, + ) -> Result { + Ok(AlterClusterReconfigurationV1 { + cluster_id: proto.cluster_id, + cluster_name: proto.cluster_name, + transition: proto.transition.into_rust()?, + target_size: proto.target_size, + target_replication_factor: proto.target_replication_factor, + deadline: proto.deadline, + }) + } +} + +impl RustType + for HydrationBurstLifecycleV1 +{ + fn into_proto(&self) -> crate::objects::audit_log_event_v1::HydrationBurstLifecycleV1 { + use crate::objects::audit_log_event_v1::hydration_burst_lifecycle_v1::Transition; + let transition = match self { + HydrationBurstLifecycleV1::Started => Transition::Started(Empty {}), + HydrationBurstLifecycleV1::Finished => Transition::Finished(Empty {}), + }; + crate::objects::audit_log_event_v1::HydrationBurstLifecycleV1 { transition } + } + + fn from_proto( + proto: crate::objects::audit_log_event_v1::HydrationBurstLifecycleV1, + ) -> Result { + use crate::objects::audit_log_event_v1::hydration_burst_lifecycle_v1::Transition; + Ok(match proto.transition { + Transition::Started(_) => HydrationBurstLifecycleV1::Started, + Transition::Finished(_) => HydrationBurstLifecycleV1::Finished, + }) + } +} + +impl RustType + for ClusterHydrationBurstV1 +{ + fn into_proto(&self) -> crate::objects::audit_log_event_v1::ClusterHydrationBurstV1 { + crate::objects::audit_log_event_v1::ClusterHydrationBurstV1 { + cluster_id: self.cluster_id.to_string(), + cluster_name: self.cluster_name.to_string(), + transition: self.transition.into_proto(), + burst_size: self.burst_size.to_string(), + } + } + + fn from_proto( + proto: crate::objects::audit_log_event_v1::ClusterHydrationBurstV1, + ) -> Result { + Ok(ClusterHydrationBurstV1 { + cluster_id: proto.cluster_id, + cluster_name: proto.cluster_name, + transition: proto.transition.into_rust()?, + burst_size: proto.burst_size, + }) + } +} + impl RustType for DropClusterReplicaV1 { fn into_proto(&self) -> crate::objects::audit_log_event_v1::DropClusterReplicaV1 { crate::objects::audit_log_event_v1::DropClusterReplicaV1 { @@ -578,22 +682,42 @@ impl RustType { + use crate::objects::audit_log_event_v1 as ev; + ev::CreateOrDropClusterReplicaReasonV1 { + reason: ev::CreateOrDropClusterReplicaReasonV1Reason::Reconfiguration(Empty {}), + } + } + CreateOrDropClusterReplicaReasonV1::HydrationBurst => { + use crate::objects::audit_log_event_v1 as ev; + ev::CreateOrDropClusterReplicaReasonV1 { + reason: ev::CreateOrDropClusterReplicaReasonV1Reason::HydrationBurst(Empty {}), + } + } + CreateOrDropClusterReplicaReasonV1::Retired => { + use crate::objects::audit_log_event_v1 as ev; + ev::CreateOrDropClusterReplicaReasonV1 { + reason: ev::CreateOrDropClusterReplicaReasonV1Reason::Retired(Empty {}), + } + } } } fn from_proto( proto: crate::objects::audit_log_event_v1::CreateOrDropClusterReplicaReasonV1, ) -> Result { + use crate::objects::audit_log_event_v1::CreateOrDropClusterReplicaReasonV1Reason as Reason; match proto.reason { - crate::objects::audit_log_event_v1::CreateOrDropClusterReplicaReasonV1Reason::Manual( - Empty {}, - ) => Ok(CreateOrDropClusterReplicaReasonV1::Manual), - crate::objects::audit_log_event_v1::CreateOrDropClusterReplicaReasonV1Reason::Schedule( - Empty {}, - ) => Ok(CreateOrDropClusterReplicaReasonV1::Schedule), - crate::objects::audit_log_event_v1::CreateOrDropClusterReplicaReasonV1Reason::System( - Empty {}, - ) => Ok(CreateOrDropClusterReplicaReasonV1::System), + Reason::Manual(Empty {}) => Ok(CreateOrDropClusterReplicaReasonV1::Manual), + Reason::Schedule(Empty {}) => Ok(CreateOrDropClusterReplicaReasonV1::Schedule), + Reason::System(Empty {}) => Ok(CreateOrDropClusterReplicaReasonV1::System), + Reason::Reconfiguration(Empty {}) => { + Ok(CreateOrDropClusterReplicaReasonV1::Reconfiguration) + } + Reason::HydrationBurst(Empty {}) => { + Ok(CreateOrDropClusterReplicaReasonV1::HydrationBurst) + } + Reason::Retired(Empty {}) => Ok(CreateOrDropClusterReplicaReasonV1::Retired), } } } @@ -1390,6 +1514,12 @@ impl RustType for EventDetails { EventDetails::AlterSourceTimestampIntervalV1(details) => { AlterSourceTimestampIntervalV1(details.into_proto()) } + EventDetails::AlterClusterReconfigurationV1(details) => { + AlterClusterReconfigurationV1(details.into_proto()) + } + EventDetails::ClusterHydrationBurstV1(details) => { + ClusterHydrationBurstV1(details.into_proto()) + } EventDetails::ToNewIdV1(details) => ToNewIdV1(details.into_proto()), EventDetails::FromPreviousIdV1(details) => FromPreviousIdV1(details.into_proto()), EventDetails::SetV1(details) => SetV1(details.into_proto()), @@ -1480,6 +1610,12 @@ impl RustType for EventDetails { AlterSourceTimestampIntervalV1(details) => Ok( EventDetails::AlterSourceTimestampIntervalV1(details.into_rust()?), ), + AlterClusterReconfigurationV1(details) => Ok( + EventDetails::AlterClusterReconfigurationV1(details.into_rust()?), + ), + ClusterHydrationBurstV1(details) => { + Ok(EventDetails::ClusterHydrationBurstV1(details.into_rust()?)) + } } } } diff --git a/src/catalog-protos/src/lib.rs b/src/catalog-protos/src/lib.rs index b5e5b23d0b53f..8f0e7d7f308ed 100644 --- a/src/catalog-protos/src/lib.rs +++ b/src/catalog-protos/src/lib.rs @@ -23,6 +23,7 @@ pub mod objects_v82; pub mod objects_v83; pub mod objects_v84; pub mod objects_v85; +pub mod objects_v86; pub mod serialization; /// The current version of the `Catalog`. @@ -30,7 +31,7 @@ pub mod serialization; /// We will initialize new `Catalog`s with this version, and migrate existing `Catalog`s to this /// version. Whenever the `Catalog` changes, e.g. the types we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 85; +pub const CATALOG_VERSION: u64 = 86; /// The minimum `Catalog` version number that we support migrating from. /// diff --git a/src/catalog-protos/src/objects.rs b/src/catalog-protos/src/objects.rs index 247b6ac26acbc..f9c8bf64610bd 100644 --- a/src/catalog-protos/src/objects.rs +++ b/src/catalog-protos/src/objects.rs @@ -899,6 +899,86 @@ pub struct ManagedCluster { pub logging: ReplicaLogging, pub optimizer_feature_overrides: Vec, pub schedule: ClusterSchedule, + /// User-configured autoscaling policy, distinct from the in-flight runtime + /// records below. + pub auto_scaling_strategy: Option, + /// In-flight graceful reconfiguration the controller is converging on. + pub reconfiguration: Option, + /// In-flight hydration burst the controller is running. + pub burst: Option, +} + +/// The user-configured autoscaling policy of a managed cluster. +/// +/// Extensible: future strategies are added as additional optional sub-policies. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AutoScalingStrategy { + pub on_hydration: Option, +} + +/// The `ON HYDRATION` autoscaling sub-policy. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct OnHydration { + pub hydration_size: String, + pub linger_duration: Option, +} + +/// An in-flight graceful reconfiguration: the config shape the cluster is +/// moving to plus the deadline by which it must complete. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReconfigurationState { + pub target: ReconfigurationTarget, + /// Deadline as an `mz_repr::Timestamp`. + pub deadline: u64, + /// What to do if the deadline passes before the target hydrates. + pub on_timeout: OnTimeoutAction, +} + +/// The action a graceful reconfiguration applies if its deadline passes before +/// the target replicas hydrate. Mirrors `mz_sql::plan::OnTimeoutAction`. +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum OnTimeoutAction { + /// Cut over to the (not-yet-hydrated) target anyway and clear the record. + Commit, + /// Drop the target replica set, reverting to the pre-reconfiguration shape, + /// and retain the record as a tombstone. + Rollback, +} + +/// The full config shape a reconfiguration is moving the cluster to, so a +/// combined size + replication-factor + availability-zone change is one record. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReconfigurationTarget { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, +} + +/// An active hydration burst. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct BurstState { + pub burst_size: String, + pub linger_duration: Duration, + /// When the steady-state replicas were first observed hydrated, as an + /// `mz_repr::Timestamp`. Absent until that observation. + pub steady_hydrated_at: Option, } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] @@ -919,7 +999,16 @@ pub struct UnmanagedLocation { #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] pub struct ManagedLocation { pub size: String, - pub availability_zone: Option, + /// The availability zones the replica was provisioned under. + /// + /// For a replica of a managed cluster this is the cluster's + /// `AVAILABILITY ZONES` pool at provision time; the cluster controller + /// compares it against a cluster's target `availability_zones` to tell + /// realized- from target-shape replicas (including an `AVAILABILITY ZONES` + /// divergence). For a replica of an unmanaged cluster it is the user-pinned + /// `AVAILABILITY ZONE`, as a zero- or one-element list. Empty when no zones + /// constrain placement. + pub availability_zones: Vec, pub internal: bool, pub billed_as: Option, pub pending: bool, @@ -1228,6 +1317,62 @@ pub mod audit_log_event_v1 { pub new_name: String, } + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterClusterReconfigurationV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: ReconfigurationLifecycleV1, + pub target_size: String, + pub target_replication_factor: u32, + pub deadline: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ReconfigurationLifecycleV1 { + pub transition: reconfiguration_lifecycle_v1::Transition, + } + + pub mod reconfiguration_lifecycle_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Transition { + Started(Empty), + Finalized(Empty), + TimedOut(Empty), + Cancelled(Empty), + } + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ClusterHydrationBurstV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: HydrationBurstLifecycleV1, + pub burst_size: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct HydrationBurstLifecycleV1 { + pub transition: hydration_burst_lifecycle_v1::Transition, + } + + pub mod hydration_burst_lifecycle_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Transition { + Started(Empty), + Finished(Empty), + } + } + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] pub struct RenameItemV1 { @@ -1356,6 +1501,9 @@ pub mod audit_log_event_v1 { Manual(Empty), Schedule(Empty), System(Empty), + Reconfiguration(Empty), + HydrationBurst(Empty), + Retired(Empty), } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] @@ -1727,6 +1875,8 @@ pub mod audit_log_event_v1 { CreateRoleV1(CreateRoleV1), AlterAddColumnV1(AlterAddColumnV1), AlterSourceTimestampIntervalV1(AlterSourceTimestampIntervalV1), + AlterClusterReconfigurationV1(AlterClusterReconfigurationV1), + ClusterHydrationBurstV1(ClusterHydrationBurstV1), } } diff --git a/src/catalog-protos/src/objects_v86.rs b/src/catalog-protos/src/objects_v86.rs new file mode 100644 index 0000000000000..f9c8bf64610bd --- /dev/null +++ b/src/catalog-protos/src/objects_v86.rs @@ -0,0 +1,2163 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +#[cfg(any(test, feature = "proptest"))] +use proptest_derive::Arbitrary; +use serde::{Deserialize, Serialize}; +use serde_repr::{Deserialize_repr, Serialize_repr}; + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ConfigKey { + pub key: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ConfigValue { + pub value: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SettingKey { + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SettingValue { + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IdAllocKey { + pub name: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IdAllocValue { + pub next_id: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct GidMappingKey { + pub schema_name: String, + pub object_type: CatalogItemType, + pub object_name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct GidMappingValue { + pub catalog_id: SystemCatalogItemId, + pub global_id: SystemGlobalId, + pub fingerprint: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterKey { + pub id: ClusterId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterValue { + pub name: String, + pub owner_id: RoleId, + pub privileges: Vec, + pub config: ClusterConfig, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterIntrospectionSourceIndexKey { + pub cluster_id: ClusterId, + pub name: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterIntrospectionSourceIndexValue { + pub catalog_id: IntrospectionSourceIndexCatalogItemId, + pub global_id: IntrospectionSourceIndexGlobalId, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplicaKey { + pub id: ReplicaId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplicaValue { + pub cluster_id: ClusterId, + pub name: String, + pub config: ReplicaConfig, + pub owner_id: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DatabaseKey { + pub id: DatabaseId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DatabaseValue { + pub name: String, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SchemaKey { + pub id: SchemaId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SchemaValue { + pub database_id: Option, + pub name: String, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ItemKey { + pub gid: CatalogItemId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ItemValue { + pub schema_id: SchemaId, + pub name: String, + pub definition: CatalogItem, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, + pub global_id: GlobalId, + pub extra_versions: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ItemVersion { + pub global_id: GlobalId, + pub version: Version, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleKey { + pub id: RoleId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleValue { + pub name: String, + pub attributes: RoleAttributes, + pub membership: RoleMembership, + pub vars: RoleVars, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAuthKey { + pub id: RoleId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAuthValue { + pub password_hash: Option, + pub updated_at: EpochMillis, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicyKey { + pub id: NetworkPolicyId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicyValue { + pub name: String, + pub rules: Vec, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ServerConfigurationKey { + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ServerConfigurationValue { + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AuditLogKey { + pub event: AuditLogEvent, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum AuditLogEvent { + V1(AuditLogEventV1), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct CommentKey { + pub object: CommentObject, + pub sub_component: Option, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CommentObject { + Table(CatalogItemId), + View(CatalogItemId), + MaterializedView(CatalogItemId), + Source(CatalogItemId), + Sink(CatalogItemId), + Index(CatalogItemId), + Func(CatalogItemId), + Connection(CatalogItemId), + Type(CatalogItemId), + Secret(CatalogItemId), + Role(RoleId), + Database(DatabaseId), + Schema(ResolvedSchema), + Cluster(ClusterId), + ClusterReplica(ClusterReplicaId), + NetworkPolicy(NetworkPolicyId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CommentSubComponent { + ColumnPos(u64), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct CommentValue { + pub comment: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReferencesKey { + pub source: CatalogItemId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReferencesValue { + pub references: Vec, + pub updated_at: EpochMillis, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReference { + pub name: String, + pub namespace: Option, + pub columns: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StorageCollectionMetadataKey { + pub id: GlobalId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StorageCollectionMetadataValue { + pub shard: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct UnfinalizedShardKey { + pub shard: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct TxnWalShardValue { + pub shard: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Empty {} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StringWrapper { + pub inner: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Duration { + pub secs: u64, + pub nanos: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct EpochMillis { + pub millis: u64, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Version { + pub value: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CatalogItem { + V1(CatalogItemV1), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct CatalogItemV1 { + pub create_sql: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CatalogItemId { + System(u64), + User(u64), + Transient(u64), + IntrospectionSourceIndex(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemCatalogItemId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IntrospectionSourceIndexCatalogItemId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum GlobalId { + System(u64), + User(u64), + Transient(u64), + Explain, + IntrospectionSourceIndex(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemGlobalId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IntrospectionSourceIndexGlobalId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ClusterId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum DatabaseId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ResolvedDatabaseSpecifier { + Ambient, + Id(DatabaseId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum SchemaId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum SchemaSpecifier { + Temporary, + Id(SchemaId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ResolvedSchema { + pub database: ResolvedDatabaseSpecifier, + pub schema: SchemaSpecifier, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ReplicaId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplicaId { + pub cluster_id: ClusterId, + pub replica_id: ReplicaId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum NetworkPolicyId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaLogging { + pub log_logging: bool, + pub interval: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct OptimizerFeatureOverride { + pub name: String, + pub value: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterScheduleRefreshOptions { + pub rehydration_time_estimate: Duration, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ClusterSchedule { + Manual, + Refresh(ClusterScheduleRefreshOptions), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterConfig { + pub workload_class: Option, + pub variant: ClusterVariant, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ClusterVariant { + Unmanaged, + Managed(ManagedCluster), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ManagedCluster { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, + pub optimizer_feature_overrides: Vec, + pub schedule: ClusterSchedule, + /// User-configured autoscaling policy, distinct from the in-flight runtime + /// records below. + pub auto_scaling_strategy: Option, + /// In-flight graceful reconfiguration the controller is converging on. + pub reconfiguration: Option, + /// In-flight hydration burst the controller is running. + pub burst: Option, +} + +/// The user-configured autoscaling policy of a managed cluster. +/// +/// Extensible: future strategies are added as additional optional sub-policies. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AutoScalingStrategy { + pub on_hydration: Option, +} + +/// The `ON HYDRATION` autoscaling sub-policy. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct OnHydration { + pub hydration_size: String, + pub linger_duration: Option, +} + +/// An in-flight graceful reconfiguration: the config shape the cluster is +/// moving to plus the deadline by which it must complete. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReconfigurationState { + pub target: ReconfigurationTarget, + /// Deadline as an `mz_repr::Timestamp`. + pub deadline: u64, + /// What to do if the deadline passes before the target hydrates. + pub on_timeout: OnTimeoutAction, +} + +/// The action a graceful reconfiguration applies if its deadline passes before +/// the target replicas hydrate. Mirrors `mz_sql::plan::OnTimeoutAction`. +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum OnTimeoutAction { + /// Cut over to the (not-yet-hydrated) target anyway and clear the record. + Commit, + /// Drop the target replica set, reverting to the pre-reconfiguration shape, + /// and retain the record as a tombstone. + Rollback, +} + +/// The full config shape a reconfiguration is moving the cluster to, so a +/// combined size + replication-factor + availability-zone change is one record. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReconfigurationTarget { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, +} + +/// An active hydration burst. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct BurstState { + pub burst_size: String, + pub linger_duration: Duration, + /// When the steady-state replicas were first observed hydrated, as an + /// `mz_repr::Timestamp`. Absent until that observation. + pub steady_hydrated_at: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaConfig { + pub logging: ReplicaLogging, + pub location: ReplicaLocation, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct UnmanagedLocation { + pub storagectl_addrs: Vec, + pub computectl_addrs: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ManagedLocation { + pub size: String, + /// The availability zones the replica was provisioned under. + /// + /// For a replica of a managed cluster this is the cluster's + /// `AVAILABILITY ZONES` pool at provision time; the cluster controller + /// compares it against a cluster's target `availability_zones` to tell + /// realized- from target-shape replicas (including an `AVAILABILITY ZONES` + /// divergence). For a replica of an unmanaged cluster it is the user-pinned + /// `AVAILABILITY ZONE`, as a zero- or one-element list. Empty when no zones + /// constrain placement. + pub availability_zones: Vec, + pub internal: bool, + pub billed_as: Option, + pub pending: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ReplicaLocation { + Unmanaged(UnmanagedLocation), + Managed(ManagedLocation), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum RoleId { + System(u64), + User(u64), + Public, + Predefined(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum AutoProvisionSource { + Oidc = 0, + Frontegg = 1, + None = 2, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAttributes { + pub inherit: bool, + pub superuser: Option, + pub login: Option, + pub auto_provision_source: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleMembership { + pub map: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleMembershipEntry { + pub key: RoleId, + pub value: RoleId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleVars { + pub entries: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleVarsEntry { + pub key: String, + pub val: RoleVar, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum RoleVar { + Flat(String), + SqlSet(Vec), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicyRule { + pub name: String, + pub address: String, + pub action: NetworkPolicyRuleAction, + pub direction: NetworkPolicyRuleDirection, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum NetworkPolicyRuleAction { + Allow, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum NetworkPolicyRuleDirection { + Ingress, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AclMode { + pub bitflags: u64, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct MzAclItem { + pub grantee: RoleId, + pub grantor: RoleId, + pub acl_mode: AclMode, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DefaultPrivilegesKey { + pub role_id: RoleId, + pub database_id: Option, + pub schema_id: Option, + pub object_type: ObjectType, + pub grantee: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DefaultPrivilegesValue { + pub privileges: AclMode, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemPrivilegesKey { + pub grantee: RoleId, + pub grantor: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemPrivilegesValue { + pub acl_mode: AclMode, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AuditLogEventV1 { + pub id: u64, + pub event_type: audit_log_event_v1::EventType, + pub object_type: audit_log_event_v1::ObjectType, + pub user: Option, + pub occurred_at: EpochMillis, + pub details: audit_log_event_v1::Details, +} + +pub mod audit_log_event_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct IdFullNameV1 { + pub id: String, + pub name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct FullNameV1 { + pub database: String, + pub schema: String, + pub item: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct IdNameV1 { + pub id: String, + pub name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameClusterV1 { + pub id: String, + pub old_name: String, + pub new_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameClusterReplicaV1 { + pub cluster_id: String, + pub replica_id: String, + pub old_name: String, + pub new_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterClusterReconfigurationV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: ReconfigurationLifecycleV1, + pub target_size: String, + pub target_replication_factor: u32, + pub deadline: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ReconfigurationLifecycleV1 { + pub transition: reconfiguration_lifecycle_v1::Transition, + } + + pub mod reconfiguration_lifecycle_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Transition { + Started(Empty), + Finalized(Empty), + TimedOut(Empty), + Cancelled(Empty), + } + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ClusterHydrationBurstV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: HydrationBurstLifecycleV1, + pub burst_size: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct HydrationBurstLifecycleV1 { + pub transition: hydration_burst_lifecycle_v1::Transition, + } + + pub mod hydration_burst_lifecycle_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Transition { + Started(Empty), + Finished(Empty), + } + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameItemV1 { + pub id: String, + pub old_name: FullNameV1, + pub new_name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV1 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub disk: bool, + pub billed_as: Option, + pub internal: bool, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV2 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub disk: bool, + pub billed_as: Option, + pub internal: bool, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV3 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub disk: bool, + pub billed_as: Option, + pub internal: bool, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV4 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub billed_as: Option, + pub internal: bool, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct DropClusterReplicaV1 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct DropClusterReplicaV2 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct DropClusterReplicaV3 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateOrDropClusterReplicaReasonV1 { + pub reason: CreateOrDropClusterReplicaReasonV1Reason, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum CreateOrDropClusterReplicaReasonV1Reason { + Manual(Empty), + Schedule(Empty), + System(Empty), + Reconfiguration(Empty), + HydrationBurst(Empty), + Retired(Empty), + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchedulingDecisionsWithReasonsV1 { + pub on_refresh: RefreshDecisionWithReasonV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchedulingDecisionsWithReasonsV2 { + pub on_refresh: RefreshDecisionWithReasonV2, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum RefreshDecision { + On(Empty), + Off(Empty), + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RefreshDecisionWithReasonV1 { + pub objects_needing_refresh: Vec, + pub rehydration_time_estimate: String, + pub decision: RefreshDecision, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RefreshDecisionWithReasonV2 { + pub objects_needing_refresh: Vec, + pub objects_needing_compaction: Vec, + pub rehydration_time_estimate: String, + pub decision: RefreshDecision, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV1 { + pub id: String, + pub name: FullNameV1, + pub size: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV2 { + pub id: String, + pub name: FullNameV1, + pub size: Option, + pub external_type: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV3 { + pub id: String, + pub name: FullNameV1, + pub external_type: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV4 { + pub id: String, + pub cluster_id: Option, + pub name: FullNameV1, + pub external_type: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateIndexV1 { + pub id: String, + pub cluster_id: String, + pub name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateMaterializedViewV1 { + pub id: String, + pub cluster_id: String, + pub name: FullNameV1, + pub replacement_target_id: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterApplyReplacementV1 { + pub target: IdFullNameV1, + pub replacement: IdFullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterSourceSinkV1 { + pub id: String, + pub name: FullNameV1, + pub old_size: Option, + pub new_size: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterSetClusterV1 { + pub id: String, + pub name: FullNameV1, + pub old_cluster_id: String, + pub new_cluster_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct GrantRoleV1 { + pub role_id: String, + pub member_id: String, + pub grantor_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct GrantRoleV2 { + pub role_id: String, + pub member_id: String, + pub grantor_id: String, + pub executed_by: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RevokeRoleV1 { + pub role_id: String, + pub member_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RevokeRoleV2 { + pub role_id: String, + pub member_id: String, + pub grantor_id: String, + pub executed_by: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct UpdatePrivilegeV1 { + pub object_id: String, + pub grantee_id: String, + pub grantor_id: String, + pub privileges: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterDefaultPrivilegeV1 { + pub role_id: String, + pub database_id: Option, + pub schema_id: Option, + pub grantee_id: String, + pub privileges: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct UpdateOwnerV1 { + pub object_id: String, + pub old_owner_id: String, + pub new_owner_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchemaV1 { + pub id: String, + pub name: String, + pub database_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchemaV2 { + pub id: String, + pub name: String, + pub database_name: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameSchemaV1 { + pub id: String, + pub database_name: Option, + pub old_name: String, + pub new_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct UpdateItemV1 { + pub id: String, + pub name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterRetainHistoryV1 { + pub id: String, + pub old_history: Option, + pub new_history: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterAddColumnV1 { + pub id: String, + pub column: String, + pub column_type: String, + pub nullable: bool, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterSourceTimestampIntervalV1 { + pub id: String, + pub old_interval: Option, + pub new_interval: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ToNewIdV1 { + pub id: String, + pub new_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct FromPreviousIdV1 { + pub id: String, + pub previous_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SetV1 { + pub name: String, + pub value: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RotateKeysV1 { + pub id: String, + pub name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateRoleV1 { + pub id: String, + pub name: String, + pub auto_provision_source: Option, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + #[repr(u8)] + pub enum EventType { + Unknown = 0, + Create = 1, + Drop = 2, + Alter = 3, + Grant = 4, + Revoke = 5, + Comment = 6, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + #[repr(u8)] + pub enum ObjectType { + Unknown = 0, + Cluster = 1, + ClusterReplica = 2, + Connection = 3, + Database = 4, + Func = 5, + Index = 6, + MaterializedView = 7, + Role = 8, + Secret = 9, + Schema = 10, + Sink = 11, + Source = 12, + Table = 13, + Type = 14, + View = 15, + System = 16, + ContinualTask = 17, + NetworkPolicy = 18, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Details { + CreateClusterReplicaV1(CreateClusterReplicaV1), + CreateClusterReplicaV2(CreateClusterReplicaV2), + CreateClusterReplicaV3(CreateClusterReplicaV3), + CreateClusterReplicaV4(CreateClusterReplicaV4), + DropClusterReplicaV1(DropClusterReplicaV1), + DropClusterReplicaV2(DropClusterReplicaV2), + DropClusterReplicaV3(DropClusterReplicaV3), + CreateSourceSinkV1(CreateSourceSinkV1), + CreateSourceSinkV2(CreateSourceSinkV2), + AlterSourceSinkV1(AlterSourceSinkV1), + AlterSetClusterV1(AlterSetClusterV1), + GrantRoleV1(GrantRoleV1), + GrantRoleV2(GrantRoleV2), + RevokeRoleV1(RevokeRoleV1), + RevokeRoleV2(RevokeRoleV2), + UpdatePrivilegeV1(UpdatePrivilegeV1), + AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1), + UpdateOwnerV1(UpdateOwnerV1), + IdFullNameV1(IdFullNameV1), + RenameClusterV1(RenameClusterV1), + RenameClusterReplicaV1(RenameClusterReplicaV1), + RenameItemV1(RenameItemV1), + IdNameV1(IdNameV1), + SchemaV1(SchemaV1), + SchemaV2(SchemaV2), + RenameSchemaV1(RenameSchemaV1), + UpdateItemV1(UpdateItemV1), + CreateSourceSinkV3(CreateSourceSinkV3), + AlterRetainHistoryV1(AlterRetainHistoryV1), + ToNewIdV1(ToNewIdV1), + FromPreviousIdV1(FromPreviousIdV1), + SetV1(SetV1), + ResetAllV1(Empty), + RotateKeysV1(RotateKeysV1), + CreateSourceSinkV4(CreateSourceSinkV4), + CreateIndexV1(CreateIndexV1), + CreateMaterializedViewV1(CreateMaterializedViewV1), + AlterApplyReplacementV1(AlterApplyReplacementV1), + CreateRoleV1(CreateRoleV1), + AlterAddColumnV1(AlterAddColumnV1), + AlterSourceTimestampIntervalV1(AlterSourceTimestampIntervalV1), + AlterClusterReconfigurationV1(AlterClusterReconfigurationV1), + ClusterHydrationBurstV1(ClusterHydrationBurstV1), + } +} + +/// The contents of a single state update. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +// Serialize the top-level enum in the persist-backed catalog as internally tagged to set up +// persist pushdown statistics for success. +#[serde(tag = "kind")] +pub enum StateUpdateKind { + AuditLog(AuditLog), + Cluster(Cluster), + ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex), + ClusterReplica(ClusterReplica), + Comment(Comment), + Config(Config), + Database(Database), + DefaultPrivileges(DefaultPrivileges), + FenceToken(FenceToken), + GidMapping(GidMapping), + IdAlloc(IdAlloc), + Item(Item), + NetworkPolicy(NetworkPolicy), + Role(Role), + RoleAuth(RoleAuth), + Schema(Schema), + ServerConfiguration(ServerConfiguration), + Setting(Setting), + SourceReferences(SourceReferences), + StorageCollectionMetadata(StorageCollectionMetadata), + SystemPrivileges(SystemPrivileges), + TxnWalShard(TxnWalShard), + UnfinalizedShard(UnfinalizedShard), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AuditLog { + pub key: AuditLogKey, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Cluster { + pub key: ClusterKey, + pub value: ClusterValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplica { + pub key: ClusterReplicaKey, + pub value: ClusterReplicaValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Comment { + pub key: CommentKey, + pub value: CommentValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Config { + pub key: ConfigKey, + pub value: ConfigValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Database { + pub key: DatabaseKey, + pub value: DatabaseValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DefaultPrivileges { + pub key: DefaultPrivilegesKey, + pub value: DefaultPrivilegesValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct FenceToken { + pub deploy_generation: u64, + pub epoch: i64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IdAlloc { + pub key: IdAllocKey, + pub value: IdAllocValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterIntrospectionSourceIndex { + pub key: ClusterIntrospectionSourceIndexKey, + pub value: ClusterIntrospectionSourceIndexValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Item { + pub key: ItemKey, + pub value: ItemValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Role { + pub key: RoleKey, + pub value: RoleValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAuth { + pub key: RoleAuthKey, + pub value: RoleAuthValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicy { + pub key: NetworkPolicyKey, + pub value: NetworkPolicyValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Schema { + pub key: SchemaKey, + pub value: SchemaValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Setting { + pub key: SettingKey, + pub value: SettingValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ServerConfiguration { + pub key: ServerConfigurationKey, + pub value: ServerConfigurationValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReferences { + pub key: SourceReferencesKey, + pub value: SourceReferencesValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct GidMapping { + pub key: GidMappingKey, + pub value: GidMappingValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemPrivileges { + pub key: SystemPrivilegesKey, + pub value: SystemPrivilegesValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StorageCollectionMetadata { + pub key: StorageCollectionMetadataKey, + pub value: StorageCollectionMetadataValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct UnfinalizedShard { + pub key: UnfinalizedShardKey, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct TxnWalShard { + pub value: TxnWalShardValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +#[repr(u8)] +pub enum CatalogItemType { + Unknown = 0, + Table = 1, + Source = 2, + Sink = 3, + View = 4, + MaterializedView = 5, + Index = 6, + Type = 7, + Func = 8, + Secret = 9, + Connection = 10, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +#[repr(u8)] +pub enum ObjectType { + Unknown = 0, + Table = 1, + View = 2, + MaterializedView = 3, + Source = 4, + Sink = 5, + Index = 6, + Type = 7, + Role = 8, + Cluster = 9, + ClusterReplica = 10, + Secret = 11, + Connection = 12, + Database = 13, + Schema = 14, + Func = 15, + NetworkPolicy = 17, +} diff --git a/src/catalog-protos/src/serialization.rs b/src/catalog-protos/src/serialization.rs index 9fdbc75346027..14379bdebf1e2 100644 --- a/src/catalog-protos/src/serialization.rs +++ b/src/catalog-protos/src/serialization.rs @@ -29,8 +29,8 @@ use mz_sql::names::{ CommentObjectId, DatabaseId, ResolvedDatabaseSpecifier, SchemaId, SchemaSpecifier, }; use mz_sql::plan::{ - ClusterSchedule, NetworkPolicyRule, NetworkPolicyRuleAction, NetworkPolicyRuleDirection, - PolicyAddress, + AutoScalingStrategy, ClusterSchedule, NetworkPolicyRule, NetworkPolicyRuleAction, + NetworkPolicyRuleDirection, OnHydration, OnTimeoutAction, PolicyAddress, }; use mz_sql::session::vars::OwnedVarInput; use mz_storage_types::instances::StorageInstanceId; @@ -666,6 +666,52 @@ impl RustType for ClusterSchedule { } } +impl RustType for AutoScalingStrategy { + fn into_proto(&self) -> crate::objects::AutoScalingStrategy { + crate::objects::AutoScalingStrategy { + on_hydration: self.on_hydration.into_proto(), + } + } + + fn from_proto(proto: crate::objects::AutoScalingStrategy) -> Result { + Ok(Self { + on_hydration: proto.on_hydration.into_rust()?, + }) + } +} + +impl RustType for OnHydration { + fn into_proto(&self) -> crate::objects::OnHydration { + crate::objects::OnHydration { + hydration_size: self.hydration_size.clone(), + linger_duration: self.linger_duration.into_proto(), + } + } + + fn from_proto(proto: crate::objects::OnHydration) -> Result { + Ok(Self { + hydration_size: proto.hydration_size, + linger_duration: proto.linger_duration.into_rust()?, + }) + } +} + +impl RustType for OnTimeoutAction { + fn into_proto(&self) -> crate::objects::OnTimeoutAction { + match self { + OnTimeoutAction::Commit => crate::objects::OnTimeoutAction::Commit, + OnTimeoutAction::Rollback => crate::objects::OnTimeoutAction::Rollback, + } + } + + fn from_proto(proto: crate::objects::OnTimeoutAction) -> Result { + Ok(match proto { + crate::objects::OnTimeoutAction::Commit => OnTimeoutAction::Commit, + crate::objects::OnTimeoutAction::Rollback => OnTimeoutAction::Rollback, + }) + } +} + impl RustType for ComputeReplicaLogging { fn into_proto(&self) -> crate::objects::ReplicaLogging { crate::objects::ReplicaLogging { diff --git a/src/catalog/src/builtin.rs b/src/catalog/src/builtin.rs index f7c8c113c6ef5..3c05269cbd7d0 100644 --- a/src/catalog/src/builtin.rs +++ b/src/catalog/src/builtin.rs @@ -1169,6 +1169,8 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::MaterializedView(&MZ_CLUSTERS), Builtin::MaterializedView(&MZ_CLUSTER_WORKLOAD_CLASSES), Builtin::MaterializedView(&MZ_CLUSTER_SCHEDULES), + Builtin::MaterializedView(&MZ_CLUSTER_RECONFIGURATIONS), + Builtin::MaterializedView(&MZ_CLUSTER_AUTO_SCALING_STRATEGIES), Builtin::MaterializedView(&MZ_SECRETS), Builtin::MaterializedView(&MZ_CONNECTIONS), Builtin::Table(&MZ_SSH_TUNNEL_CONNECTIONS), @@ -1428,6 +1430,8 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::Index(&MZ_SHOW_SECRETS_IND), Builtin::Index(&MZ_SHOW_ROLES_IND), Builtin::Index(&MZ_CLUSTERS_IND), + Builtin::Index(&MZ_CLUSTER_RECONFIGURATIONS_IND), + Builtin::Index(&MZ_CLUSTER_AUTO_SCALING_STRATEGIES_IND), Builtin::Index(&MZ_INDEXES_IND), Builtin::Index(&MZ_ROLES_IND), Builtin::Index(&MZ_SOURCES_IND), diff --git a/src/catalog/src/builtin/mz_internal.rs b/src/catalog/src/builtin/mz_internal.rs index ca8169d0ec256..a3f3e7d3ed04f 100644 --- a/src/catalog/src/builtin/mz_internal.rs +++ b/src/catalog/src/builtin/mz_internal.rs @@ -695,6 +695,185 @@ WHERE } }); +pub static MZ_CLUSTER_RECONFIGURATIONS: LazyLock = LazyLock::new(|| { + BuiltinMaterializedView { + name: "mz_cluster_reconfigurations", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::MV_MZ_CLUSTER_RECONFIGURATIONS_OID, + desc: RelationDesc::builder() + .with_column("cluster_id", SqlScalarType::String.nullable(false)) + .with_column("deadline", SqlScalarType::MzTimestamp.nullable(false)) + .with_column("on_timeout", SqlScalarType::String.nullable(false)) + .with_column("target", SqlScalarType::Jsonb.nullable(false)) + .with_key(vec![0]) + .finish(), + column_comments: BTreeMap::from_iter([ + ( + "cluster_id", + "The ID of the cluster. Corresponds to `mz_clusters.id`.", + ), + ( + "deadline", + "The deadline by which the reconfiguration must complete; after it passes the `on_timeout` action applies. Compare against `mz_now()` to distinguish an in-progress reconfiguration from one past its deadline.", + ), + ( + "on_timeout", + "The action applied if `deadline` passes before the target hydrates: `commit` (cut over to the not-yet-hydrated target) or `rollback` (revert to the pre-reconfiguration shape).", + ), + ( + "target", + "The config shape the cluster is reconfiguring to, as JSON: `size`, `replication_factor`, `availability_zones`, and `logging`. The realized (current) shape is in `mz_clusters`.", + ), + ]), + // One row per managed cluster with an in-flight graceful reconfiguration. + // The durable `reconfiguration` record is present only while the (gated, + // default-off) controller is converging on a new shape, and an absent + // `Option` serializes to a JSON `null`, so we key row presence on + // `!= 'null'`. We carry only the in-flight delta here; the realized + // (current) shape stays in `mz_clusters`. The deadline is the `u64` + // `mz_repr::Timestamp` cast to `mz_timestamp`; `on_timeout` is lowercased + // from the proto enum (`Commit`/`Rollback`) to match the SQL keywords. + sql: " +IN CLUSTER mz_catalog_server +WITH ( + ASSERT NOT NULL cluster_id, + ASSERT NOT NULL deadline, + ASSERT NOT NULL on_timeout, + ASSERT NOT NULL target +) AS +WITH + managed AS ( + SELECT + mz_internal.parse_catalog_id(data->'key'->'id') AS cluster_id, + data->'value'->'config'->'variant'->'Managed'->'reconfiguration' AS reconfiguration + FROM mz_internal.mz_catalog_raw + WHERE + data->>'kind' = 'Cluster' AND + data->'value'->'config'->'variant'->'Managed' IS NOT NULL + ) +SELECT + m.cluster_id, + (m.reconfiguration->>'deadline')::mz_timestamp AS deadline, + lower(m.reconfiguration->>'on_timeout') AS on_timeout, + m.reconfiguration->'target' AS target +FROM managed m +WHERE m.reconfiguration != 'null'", + is_retained_metrics_object: false, + access: vec![PUBLIC_SELECT], + ontology: Some(Ontology { + entity_name: "cluster_reconfiguration", + description: "In-flight graceful cluster reconfiguration", + links: &const { + [OntologyLink { + // At most one in-flight reconfiguration per cluster (unique + // key on `cluster_id`), so the FK is one-to-one. + name: "belongs_to_cluster", + target: "cluster", + properties: LinkProperties::fk("cluster_id", "id", Cardinality::OneToOne), + }] + }, + column_semantic_types: &[("cluster_id", SemanticType::ClusterId)], + }), + } +}); + +pub const MZ_CLUSTER_RECONFIGURATIONS_IND: BuiltinIndex = BuiltinIndex { + name: "mz_cluster_reconfigurations_ind", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::INDEX_MZ_CLUSTER_RECONFIGURATIONS_IND_OID, + sql: "IN CLUSTER mz_catalog_server +ON mz_internal.mz_cluster_reconfigurations (cluster_id)", + is_retained_metrics_object: false, +}; + +pub static MZ_CLUSTER_AUTO_SCALING_STRATEGIES: LazyLock = LazyLock::new( + || { + BuiltinMaterializedView { + name: "mz_cluster_auto_scaling_strategies", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::MV_MZ_CLUSTER_AUTO_SCALING_STRATEGIES_OID, + desc: RelationDesc::builder() + .with_column("cluster_id", SqlScalarType::String.nullable(false)) + .with_column("strategy", SqlScalarType::Jsonb.nullable(false)) + .with_column("state", SqlScalarType::Jsonb.nullable(true)) + .with_key(vec![0]) + .finish(), + column_comments: BTreeMap::from_iter([ + ( + "cluster_id", + "The ID of the cluster. Corresponds to `mz_clusters.id`.", + ), + ( + "strategy", + "**Unstable** The configured autoscaling policy, as JSON. Currently an `on_hydration` sub-policy carrying its `hydration_size` and optional `linger_duration`.", + ), + ( + "state", + "**Unstable** The in-flight autoscaling runtime state, as JSON keyed by strategy, or `NULL` when nothing is running. Currently a `burst` key carrying the active hydration burst: its `burst_size`, `linger_duration`, and `steady_hydrated_at`.", + ), + ]), + // One row per managed cluster that has an `AUTO SCALING STRATEGY` + // configured (the durable `auto_scaling_strategy` policy) or an + // in-flight autoscaling action (the durable `burst` record). These + // are two separate fields: a burst can briefly outlive a just-removed + // policy, so we admit a row when either is present. An absent + // `Option` serializes to a JSON `null`, so presence is `!= 'null'`. + // `state` keys the runtime by strategy (`{"burst": ...}`) so adding a + // future strategy's state is another key, not a schema change. The + // burst strategy is gated and default-off, so for an ordinary cluster + // `state` is `NULL`. + sql: " +IN CLUSTER mz_catalog_server +WITH ( + ASSERT NOT NULL cluster_id, + ASSERT NOT NULL strategy +) AS +WITH + managed AS ( + SELECT + mz_internal.parse_catalog_id(data->'key'->'id') AS cluster_id, + data->'value'->'config'->'variant'->'Managed'->'auto_scaling_strategy' AS strategy, + data->'value'->'config'->'variant'->'Managed'->'burst' AS burst + FROM mz_internal.mz_catalog_raw + WHERE + data->>'kind' = 'Cluster' AND + data->'value'->'config'->'variant'->'Managed' IS NOT NULL + ) +SELECT + m.cluster_id, + COALESCE(m.strategy, 'null'::jsonb) AS strategy, + CASE WHEN m.burst != 'null' THEN jsonb_build_object('burst', m.burst) END AS state +FROM managed m +WHERE m.strategy != 'null' OR m.burst != 'null'", + is_retained_metrics_object: false, + access: vec![PUBLIC_SELECT], + ontology: Some(Ontology { + entity_name: "cluster_auto_scaling_strategy", + description: "Configured cluster autoscaling strategy and in-flight state", + links: &const { + [OntologyLink { + // At most one row per managed cluster (unique key on + // `cluster_id`), so the FK is one-to-one. + name: "belongs_to_cluster", + target: "cluster", + properties: LinkProperties::fk("cluster_id", "id", Cardinality::OneToOne), + }] + }, + column_semantic_types: &[("cluster_id", SemanticType::ClusterId)], + }), + } + }, +); + +pub const MZ_CLUSTER_AUTO_SCALING_STRATEGIES_IND: BuiltinIndex = BuiltinIndex { + name: "mz_cluster_auto_scaling_strategies_ind", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::INDEX_MZ_CLUSTER_AUTO_SCALING_STRATEGIES_IND_OID, + sql: "IN CLUSTER mz_catalog_server +ON mz_internal.mz_cluster_auto_scaling_strategies (cluster_id)", + is_retained_metrics_object: false, +}; + pub static MZ_INTERNAL_CLUSTER_REPLICAS: LazyLock = LazyLock::new(|| BuiltinMaterializedView { name: "mz_internal_cluster_replicas", @@ -4915,9 +5094,19 @@ pub static MZ_SHOW_CLUSTERS: LazyLock = LazyLock::new(|| { desc: RelationDesc::builder() .with_column("name", SqlScalarType::String.nullable(false)) .with_column("replicas", SqlScalarType::String.nullable(true)) + // A short summary of any in-flight reconfiguration and/or hydration + // burst. `NULL` when the cluster is steady. The realized size is already + // in `replicas`; the full detail is in `mz_cluster_reconfigurations` and + // `mz_cluster_auto_scaling_strategies`. + .with_column("activity", SqlScalarType::String.nullable(true)) .with_column("comment", SqlScalarType::String.nullable(false)) .finish(), column_comments: BTreeMap::new(), + // `activity` is a one-line, human-readable summary built from the two base + // builtins: the in-flight reconfiguration target and the active burst size, + // joined with `;` when both are happening. Both relations are sparse (a row + // only while active), so a matched LEFT JOIN means the activity is live — + // no `mz_now()` needed, keeping this indexed view non-temporal. sql: " WITH clusters AS ( SELECT @@ -4934,9 +5123,24 @@ pub static MZ_SHOW_CLUSTERS: LazyLock = LazyLock::new(|| { FROM mz_internal.mz_comments WHERE object_type = 'cluster' AND object_sub_id IS NULL ) - SELECT name, replicas, COALESCE(comment, '') as comment + SELECT + name, + replicas, + CASE + WHEN recon.cluster_id IS NOT NULL AND ass.state IS NOT NULL + THEN 'reconfiguring to ' || (recon.target->>'size') + || '; hydration burst at ' || (ass.state->'burst'->>'burst_size') + WHEN recon.cluster_id IS NOT NULL + THEN 'reconfiguring to ' || (recon.target->>'size') + WHEN ass.state IS NOT NULL + THEN 'hydration burst at ' || (ass.state->'burst'->>'burst_size') + ELSE NULL + END AS activity, + COALESCE(comment, '') as comment FROM clusters - LEFT JOIN comments ON clusters.id = comments.id", + LEFT JOIN comments ON clusters.id = comments.id + LEFT JOIN mz_internal.mz_cluster_reconfigurations recon ON clusters.id = recon.cluster_id + LEFT JOIN mz_internal.mz_cluster_auto_scaling_strategies ass ON clusters.id = ass.cluster_id", access: vec![PUBLIC_SELECT], ontology: None, } diff --git a/src/catalog/src/durable.rs b/src/catalog/src/durable.rs index fac877b89a297..cebe3aa719bec 100644 --- a/src/catalog/src/durable.rs +++ b/src/catalog/src/durable.rs @@ -35,11 +35,11 @@ pub use crate::durable::objects::Snapshot; pub use crate::durable::objects::state_update::StateUpdate; use crate::durable::objects::state_update::{StateUpdateKindJson, TryIntoStateUpdateKind}; pub use crate::durable::objects::{ - Cluster, ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, Comment, - Database, DefaultPrivilege, IntrospectionSourceIndex, Item, NetworkPolicy, ReplicaConfig, - ReplicaLocation, Role, RoleAuth, Schema, SourceReference, SourceReferences, - StorageCollectionMetadata, SystemConfiguration, SystemObjectDescription, SystemObjectMapping, - UnfinalizedShard, + BurstState, Cluster, ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, + Comment, Database, DefaultPrivilege, IntrospectionSourceIndex, Item, NetworkPolicy, + ReconfigurationState, ReconfigurationTarget, ReplicaConfig, ReplicaLocation, Role, RoleAuth, + Schema, SourceReference, SourceReferences, StorageCollectionMetadata, SystemConfiguration, + SystemObjectDescription, SystemObjectMapping, UnfinalizedShard, }; pub use crate::durable::persist::shard_id; use crate::durable::persist::{Timestamp, UnopenedPersistCatalogState}; diff --git a/src/catalog/src/durable/initialize.rs b/src/catalog/src/durable/initialize.rs index a2b79847fbb2f..7ded07f91dc8e 100644 --- a/src/catalog/src/durable/initialize.rs +++ b/src/catalog/src/durable/initialize.rs @@ -792,6 +792,9 @@ fn default_cluster_config(args: &BootstrapArgs) -> Result Result, pub schedule: ClusterSchedule, + /// User-configured autoscaling policy, distinct from the in-flight runtime + /// records below. + pub auto_scaling_strategy: Option, + /// In-flight graceful reconfiguration the controller is converging on. + pub reconfiguration: Option, + /// In-flight hydration burst the controller is running. + pub burst: Option, +} + +/// An in-flight graceful reconfiguration: the config shape the cluster is +/// moving to plus the deadline by which it must complete. +/// +/// `ALTER` writes this record and returns; the realized config (`cluster.size`, +/// ...) is advanced by the controller only at cut-over. The controller clears +/// the record either way once it settles: at cut-over, or — under `Rollback` +/// past the deadline — without touching the realized config. The timeout +/// leaves its trace in the audit log, not here. +#[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Ord)] +pub struct ReconfigurationState { + pub target: ReconfigurationTarget, + pub deadline: mz_repr::Timestamp, + /// The action the controller applies if `deadline` passes before the + /// target hydrates. Success takes precedence: a hydrated target cuts over + /// regardless of this field. + pub on_timeout: OnTimeoutAction, +} + +/// The full config shape a reconfiguration is moving the cluster to, so a +/// combined size + replication-factor + availability-zone change is one record. +#[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Ord)] +pub struct ReconfigurationTarget { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, +} + +/// An active hydration burst the controller is running. +#[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Ord)] +pub struct BurstState { + pub burst_size: String, + pub linger_duration: Duration, + /// When the steady-state replicas were first observed hydrated. Absent + /// until that observation; the linger countdown runs from this point. + pub steady_hydrated_at: Option, } #[derive(Clone, Debug, Ord, PartialOrd, PartialEq, Eq)] @@ -474,8 +520,16 @@ pub enum ReplicaLocation { }, Managed { size: String, - /// `Some(az)` if the AZ was specified by the user and must be respected; - availability_zone: Option, + /// The availability zones the replica was provisioned under. + /// + /// For a replica of a managed cluster this is the cluster's + /// `AVAILABILITY ZONES` pool at provision time; the cluster controller + /// compares it against a cluster's target `availability_zones` to tell + /// realized- from target-shape replicas (including an + /// `AVAILABILITY ZONES` divergence). For a replica of an unmanaged + /// cluster it is the user-pinned `AVAILABILITY ZONE`, as a zero- or + /// one-element list. Empty when no zones constrain placement. + availability_zones: Vec, internal: bool, billed_as: Option, pending: bool, @@ -505,15 +559,7 @@ impl From for ReplicaLocation { }, ) => ReplicaLocation::Managed { size, - availability_zone: - if let mz_controller::clusters::ManagedReplicaAvailabilityZones::FromReplica( - Some(az), - ) = availability_zones - { - Some(az) - } else { - None - }, + availability_zones, internal, billed_as, pending, diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index 28a164509d6d3..59f306a2b8ed8 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -26,7 +26,8 @@ use crate::durable::objects::{ SystemPrivilegesValue, TxnWalShardValue, UnfinalizedShardKey, }; use crate::durable::{ - ClusterConfig, ClusterVariant, ClusterVariantManaged, ReplicaConfig, ReplicaLocation, + BurstState, ClusterConfig, ClusterVariant, ClusterVariantManaged, ReconfigurationState, + ReconfigurationTarget, ReplicaConfig, ReplicaLocation, }; use super::{RoleAuthKey, RoleAuthValue}; @@ -75,6 +76,9 @@ impl RustType for ClusterVariant { replication_factor, optimizer_feature_overrides, schedule, + auto_scaling_strategy, + reconfiguration, + burst, }) => proto::ClusterVariant::Managed(proto::ManagedCluster { size: size.to_string(), availability_zones: availability_zones.clone(), @@ -82,6 +86,9 @@ impl RustType for ClusterVariant { replication_factor: *replication_factor, optimizer_feature_overrides: optimizer_feature_overrides.into_proto(), schedule: schedule.into_proto(), + auto_scaling_strategy: auto_scaling_strategy.into_proto(), + reconfiguration: reconfiguration.into_proto(), + burst: burst.into_proto(), }), ClusterVariant::Unmanaged => proto::ClusterVariant::Unmanaged, } @@ -97,11 +104,70 @@ impl RustType for ClusterVariant { replication_factor: managed.replication_factor, optimizer_feature_overrides: managed.optimizer_feature_overrides.into_rust()?, schedule: managed.schedule.into_rust()?, + auto_scaling_strategy: managed.auto_scaling_strategy.into_rust()?, + reconfiguration: managed.reconfiguration.into_rust()?, + burst: managed.burst.into_rust()?, })), } } } +impl RustType for ReconfigurationState { + fn into_proto(&self) -> proto::ReconfigurationState { + proto::ReconfigurationState { + target: self.target.into_proto(), + deadline: self.deadline.into(), + on_timeout: self.on_timeout.into_proto(), + } + } + + fn from_proto(proto: proto::ReconfigurationState) -> Result { + Ok(Self { + target: proto.target.into_rust()?, + deadline: mz_repr::Timestamp::new(proto.deadline), + on_timeout: proto.on_timeout.into_rust()?, + }) + } +} + +impl RustType for ReconfigurationTarget { + fn into_proto(&self) -> proto::ReconfigurationTarget { + proto::ReconfigurationTarget { + size: self.size.clone(), + replication_factor: self.replication_factor, + availability_zones: self.availability_zones.clone(), + logging: self.logging.into_proto(), + } + } + + fn from_proto(proto: proto::ReconfigurationTarget) -> Result { + Ok(Self { + size: proto.size, + replication_factor: proto.replication_factor, + availability_zones: proto.availability_zones, + logging: proto.logging.into_rust()?, + }) + } +} + +impl RustType for BurstState { + fn into_proto(&self) -> proto::BurstState { + proto::BurstState { + burst_size: self.burst_size.clone(), + linger_duration: self.linger_duration.into_proto(), + steady_hydrated_at: self.steady_hydrated_at.map(Into::into), + } + } + + fn from_proto(proto: proto::BurstState) -> Result { + Ok(Self { + burst_size: proto.burst_size, + linger_duration: proto.linger_duration.into_rust()?, + steady_hydrated_at: proto.steady_hydrated_at.map(mz_repr::Timestamp::new), + }) + } +} + impl RustType for ReplicaConfig { fn into_proto(&self) -> proto::ReplicaConfig { proto::ReplicaConfig { @@ -130,13 +196,13 @@ impl RustType for ReplicaLocation { }), ReplicaLocation::Managed { size, - availability_zone, + availability_zones, billed_as, internal, pending, } => proto::ReplicaLocation::Managed(proto::ManagedLocation { size: size.to_string(), - availability_zone: availability_zone.clone(), + availability_zones: availability_zones.clone(), billed_as: billed_as.clone(), internal: *internal, pending: *pending, @@ -151,7 +217,7 @@ impl RustType for ReplicaLocation { computectl_addrs: location.computectl_addrs, }), proto::ReplicaLocation::Managed(location) => Ok(ReplicaLocation::Managed { - availability_zone: location.availability_zone, + availability_zones: location.availability_zones, billed_as: location.billed_as, internal: location.internal, size: location.size, diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index f47b60b32cbf8..81aa81009c14a 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -242,7 +242,7 @@ macro_rules! objects { objects!( [v74, v75, v76, v77, v78], - [v79, v80, v81, v82, v83, v84, v85] + [v79, v80, v81, v82, v83, v84, v85, v86] ); /// The current version of the `Catalog`. @@ -266,6 +266,7 @@ mod v81_to_v82; mod v82_to_v83; mod v83_to_v84; mod v84_to_v85; +mod v85_to_v86; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -434,6 +435,15 @@ async fn run_upgrade( ) .await } + 85 => { + run_versioned_upgrade( + unopened_catalog_state, + version, + commit_ts, + v85_to_v86::upgrade, + ) + .await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok((CATALOG_VERSION, commit_ts)), FUTURE_VERSION.. => Err(incompatible), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v86.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v86.txt new file mode 100644 index 0000000000000..8f3fc2c54b2ca --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v86.txt @@ -0,0 +1,100 @@ +CkQKQroBPwohCgNrZXkSGroBFwoVCgVzaGFyZBIMQgo6yLrwkICrJM6GChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== 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 +CpEGCo4GugGKBgovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLARglRZl4KSEZiSwKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQq8BQoFdmFsdWUSsgW6Aa4FCioKCmNsdXN0ZXJfaWQSHLoBGQoXCgRVc2VyEg/CAQwKCoYkJogYkBdDAzwKpgQKBmNvbmZpZxKbBLoBlwQKpwMKCGxvY2F0aW9uEpoDugGWAwqTAwoHTWFuYWdlZBKHA7oBgwMKvAIKEmF2YWlsYWJpbGl0eV96b25lcxKlArIBoQIKMEIuJT3guoEvwqXwkY6kR+GdiSbwnZyO8J2VhjxXJi7wkKyCP+OHvjTitK3jhYxnJwoFQgNpMz8KM0IxSC0kJSXwnrmb76y6cjnqn5PwnbyIZnhUe/CflbRr4KiB8JGOiyLgt69XKuOFiSUqRgoxQi8/8JGoniNI8JG7rvCRr5Z7Lz9h4aSawq7CpSw/4La96qelJvCdlYYqwrtwwqVqewpBQj8lwrFmw7kk4aSoUdGoXMi6JOCni++/vdGoPSLCpeC6iuCulXvwsLSUPfCRioLhi4AvQ/Cen6XhoJHwkbWDQD0KEkIQOj/gsqhgLjUl8JargtGoJgoaQhgkVyRF4Kar4Y+7RtGo8LG1tDxE8LCtkycKC0IJXG9BdOGikT0gCg8KCWJpbGxlZF9hcxICCAQKDgoIaW50ZXJuYWwSAggDCg0KB3BlbmRpbmcSAggDChIKBHNpemUSCkIIPeCug37vrYAKawoHbG9nZ2luZxJgugFdCkgKCGludGVydmFsEjy6ATkKHgoFbmFub3MSFcIBEgoFIjAiaWwQ////////////AQoXCgRzZWNzEg/CAQwKCmg0AAVHInQ4VGwKEQoLbG9nX2xvZ2dpbmcSAggCCiYKBG5hbWUSHkIcZ2HwkYy18J6fqEvwkbWFN3jwlq2fNnlB8J6CjwovCghvd25lcl9pZBIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASKFcQVBN0ZiKZw= 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 +Co4BCosBugGHAQpLCgNrZXkSRLoBQQo/CgNrZXkSOEI2OyQ/4reFTuGmjvCRjIPwnZS+WvCWqofwn5W08J6kg/CflbTwkpGjJCXwnYaIJPCflbR7MDgvChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKJRQQR1F5U4QCnA== +CoUDCoIDugH+AgrnAgoDa2V5Et8CugHbAgrYAgoFZXZlbnQSzgK6AcoCCscCCgJWMRLAAroBvAIKjQEKB2RldGFpbHMSgQG6AX4KfAoLR3JhbnRSb2xlVjESbboBagoYCgpncmFudG9yX2lkEgpCCHDDv+C7gFwiCjYKCW1lbWJlcl9pZBIpQifgrYE/4ZS98K+omfCQoq/wm4WlI+K3lTxbIi4+LzI6yLrwlq2+wqUKFgoHcm9sZV9pZBILQgkvUmrDn+Cti2oKFAoKZXZlbnRfdHlwZRIGwgEDCgFMCiAKAmlkEhrCARcKChICEUZ3hglIWZwQ////////////AQoWCgtvYmplY3RfdHlwZRIHwgEECgIBfAotCgtvY2N1cnJlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgpGOJghU1WSCXV8CisKBHVzZXISI7oBIAoeCgVpbm5lchIVQhPhpJdg8JGkiTMiImBLI/CeuYs/ChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CvIECu8EugHrBAouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKQSgpVFKIYDA1fAoSCgRraW5kEgpCCERhdGFiYXNlCqQECgV2YWx1ZRKaBLoBlgQKHQoEbmFtZRIVQhPirobwkJel77+9TvCQk4A9Ly8lChIKA29pZBILwgEICgYCVDZpVzwKOQoIb3duZXJfaWQSLboBKgooCgpQcmVkZWZpbmVkEhrCARcKCgJWZpVBZSWFOHwQ////////////AQqlAwoKcHJpdmlsZWdlcxKWA7IBkgMKcLoBbQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmNiRVMWMQKJdDwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAQR3klgIBgQFNGwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKkQG6AY0BCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKWAVmJzkRNnlVLAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgo3VAZoGCkjZEgsCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEoUFGWAlIVd1BcCokBugGFAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFFITcUh5GJWICMCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKGVh2BBVIMpUgXAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKClVBFRkFg1mIiXw= +CrkCCrYCugGyAgq1AQoDa2V5Eq0BugGpAQpLCgtvYmplY3RfbmFtZRI8QjpiXPCRtKfhv4A6PPCQhIDRqOGhpz3hiLfCpfCRk5Xit5VdXF7wkJCmKvCWroop0agn8Ja6hPCQlrciChUKC29iamVjdF90eXBlEgbCAQMKAWwKQwoLc2NoZW1hX25hbWUSNEIy4Z2QYCQmLU5cdfCflbTwkoKv4K2jTuG9mzkl8J+PqUzhn44kYGY98JGxqz/wkJWxdioKFAoEa2luZBIMQgpHaWRNYXBwaW5nCmIKBXZhbHVlElm6AVYKHgoKY2F0YWxvZ19pZBIQwgENCgsBRlJIKFaINAdYPAoWCgtmaW5nZXJwcmludBIHQgXwkICDTwocCglnbG9iYWxfaWQSD8IBDAoKEgdpYzdpCVQwfA== +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgpidkCIFEgJgilMChgKBWVwb2NoEg/CAQwKCoMDBVVEFwJSGUwKFAoEa2luZBIMQgpGZW5jZVRva2Vu +CkMKQboBPgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCiUKBXZhbHVlEhy6ARkKFwoFc2hhcmQSDkIMYPCflbQ/4oGx6pmP +CvUECvIEugHuBArXBAoDa2V5Es8EugHLBArIBAoFZXZlbnQSvgS6AboECrcECgJWMRKwBLoBrAQK6wIKB2RldGFpbHMS3wK6AdsCCtgCChJDcmVhdGVTb3VyY2VTaW5rVjISwQK6Ab0CCjYKDWV4dGVybmFsX3R5cGUSJUIjwqXIuik64LiRemVs8JCMok9EICovT++/vdGoa1nwn5W0JWAKMwoCaWQSLUIrJ0XRqC9cJ0PhjbEl8JCkv+K2oci6LuGymVzgsaLwkJCFwqUveCUiRMKlawqOAQoEbmFtZRKFAboBgQEKIAoIZGF0YWJhc2USFEISMfCRtagi8J+VtF5tw45oOFBiCiYKBGl0ZW0SHkIc8J+nu04zKjlc4Kme8JGMrVTitoPwnLO08JGSvwo1CgZzY2hlbWESK0IpJHt8J9Go8JGMsj89Skxf8Jy+lVx78JGPhTTwkI25YivgqKzwmKGUPC4KPQoEc2l6ZRI1ugEyCjAKBWlubmVyEidCJeOBqCbhvbwqVPCRiqAk8J+VtHM6ViTgrpzhpbNY4KmL8JCsqSYKFAoKZXZlbnRfdHlwZRIGwgEDCgEcChYKAmlkEhDCAQ0KCwFCV4FEQ2ggmZBsChUKC29iamVjdF90eXBlEgbCAQMKAYwKLgoLb2NjdXJyZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLAWVUWJFGAFdVF3wKRwoEdXNlchI/ugE8CjoKBWlubmVyEjFCL3jwnrmd8JapoeqpkjInTDzwn5W08J+VtOGqk/CflbR1V8i6ZvCdkrt777+94Z2jChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CnQKcroBbwosCgNrZXkSJboBIgogCgRuYW1lEhhCFuKEly4uJCXgs6nwnpeQ4LeDwqXguoEKHQoEa2luZBIVQhNTZXJ2ZXJDb25maWd1cmF0aW9uCiAKBXZhbHVlEhe6ARQKEgoFdmFsdWUSCUIHPWBN8J65tA== +CuEBCt4BugHaAQpMCgNrZXkSRboBQgotCgpjbHVzdGVyX2lkEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEoGYRmkANpSQIsChEKBG5hbWUSCUIHJMK8JuGlsAopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKXwoFdmFsdWUSVroBUwoeCgpjYXRhbG9nX2lkEhDCAQ0KCwFAIpkkZlBxFhlcCh0KCWdsb2JhbF9pZBIQwgENCgsBFzmQhZEYBUOYLAoSCgNvaWQSC8IBCAoGAzB3AlJ8 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 +Co4BCosBugGHAQozCgNrZXkSLLoBKQonCgRuYW1lEh9CHWHgr4su6qOW4LOe8J6Lv++/vWAiwqVb8JuFlTx1Ch0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoxCgV2YWx1ZRIougElCiMKBXZhbHVlEhpCGGoualJGKcObJCLwkLSn4YuELz3wn5W0JQ== +CnQKcroBbwpRCgNrZXkSSroBRwpFCgVzaGFyZBI8Qjrwnri5JmHwkbSAOeGMrG/CpVw/IT8iOuCvkG0rPSUmJ+K1sPCRtIgm4KKoP1LwkbKv8J6ktHY34Z2nChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CkoKSLoBRQoVCgRraW5kEg1CC1R4bldhbFNoYXJkCiwKBXZhbHVlEiO6ASAKHgoFc2hhcmQSFUIT4KyB8J+Hr2d0ZfCQioAkJ8OCJw== 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 +CogCCoUCugGBAgqiAQoDa2V5EpoBugGWAQoRCgtkYXRhYmFzZV9pZBICCAQKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgogeRB3AoEDMEUcChYKC29iamVjdF90eXBlEgfCAQQKAgEcChMKB3JvbGVfaWQSCEIGUHVibGljCikKCXNjaGVtYV9pZBIcugEZChcKBFVzZXISD8IBDAoKZTREM2FgEhUgPAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCj0KBXZhbHVlEjS6ATEKLwoKcHJpdmlsZWdlcxIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE0SUGTgIQXk1JM +CmkKZ7oBZAonCgNrZXkSILoBHQobCgNrZXkSFEISOvCesprwkpGy8JGsgGjwnaW5ChAKBGtpbmQSCEIGQ29uZmlnCicKBXZhbHVlEh66ARsKGQoFdmFsdWUSEMIBDQoLARACZlYiZgZCVjw= +CocCCoQCugGAAgqiAQoDa2V5EpoBugGWAQoRCgtkYXRhYmFzZV9pZBICCAQKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgolYAAHSTI4NINsChUKC29iamVjdF90eXBlEgbCAQMKASwKEwoHcm9sZV9pZBIIQgZQdWJsaWMKKgoJc2NoZW1hX2lkEh26ARoKGAoEVXNlchIQwgENCgsBBTRJFxhhExSYHAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCjwKBXZhbHVlEjO6ATAKLgoKcHJpdmlsZWdlcxIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkaSOENQhHQwgXw= +CpgFCpUFugGRBQr6BAoDa2V5EvIEugHuBArrBAoFZXZlbnQS4QS6Ad0ECtoECgJWMRLTBLoBzwQKwgMKB2RldGFpbHMStgO6AbIDCq8DChZDcmVhdGVDbHVzdGVyUmVwbGljYVYyEpQDugGQAwoPCgliaWxsZWRfYXMSAggECj4KCmNsdXN0ZXJfaWQSMEIu4Y698Jatk++sgT8hIsOk77mqL8OuSSpc8J6frS3qn5Hwn5W0JOC3p8KlwqV7JwpLCgxjbHVzdGVyX25hbWUSO0I58JGQg0tBZuC6pfCRgr7wkLmi77+98JCWtMO24K2WXGDgq6jhnKLvv73wnoSgdT/hpLPgrp5cP3N7CgoKBGRpc2sSAggCCg4KCGludGVybmFsEgIIAgo6Cgxsb2dpY2FsX3NpemUSKkIozoh9bzDRqOCujio68JGPoeC+h9W0SyJy8J65iSXCpeK9tSrvt4/RqAotCgZyZWFzb24SI7oBIAoeCgZyZWFzb24SFLoBEQoPCghTY2hlZHVsZRIDugEACioKCnJlcGxpY2FfaWQSHLoBGQoXCgVpbm5lchIOQgxv6qCXJvCskZknIj8KIgoMcmVwbGljYV9uYW1lEhJCECpqe8KlJ+Gnr/CflbTgp6AKGQoTc2NoZWR1bGluZ19wb2xpY2llcxICCAQKFAoKZXZlbnRfdHlwZRIGwgEDCgEMChUKAmlkEg/CAQwKCjdhRgZ1AmIXkzwKIAoLb2JqZWN0X3R5cGUSEcIBDgoBHBD///////////8BCi0KC29jY3VycmVkX2F0Eh66ARsKGQoGbWlsbGlzEg/CAQwKCkAXcANBVTaIRDwKCgoEdXNlchICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CvkECvYEugHyBArbBAoDa2V5EtMEugHPBArMBAoFZXZlbnQSwgS6Ab4ECrsECgJWMRK0BLoBsAQKrgMKB2RldGFpbHMSogO6AZ4DCpsDCgxSZW5hbWVJdGVtVjESigO6AYYDChUKAmlkEg9CDSQxacO6wrbwn4mCw5MK7gEKCG5ld19uYW1lEuEBugHdAQpGCghkYXRhYmFzZRI6QjjwkYqFLyLDl8Kp77+9YX7wn5uiL+GnmeCzoVl9Ii9X8J+qiHgl8JCdpHvwnrm36qCAKDfwn4CcOgo+CgRpdGVtEjZCNFvikYoi4LeW8JCXieC3r/CQnY3jhIrRqC4n4LqJOiXwnoSFIuqpkSLwkZ2E8J2SjSDfqD0KUwoGc2NoZW1hEklCR08nRfCTkZXwn6OB4KyG8JCpmCQvIvCRjZfgqpHgsIow8Jinhe2fseC6jzrwn5W0ayVgbPCfgKI+77+98J+rseGaquGMlT9QCnwKCG9sZF9uYW1lEnC6AW0KKAoIZGF0YWJhc2USHEIa8J65my9cPTw/ejzRqPCQqZDhpbBge3s8ZUMKGgoEaXRlbRISQhB4Yi5M77+9MeKCjCUuyLpZCiUKBnNjaGVtYRIbQhnIuvCdnqNV8J2VhGJQduCjv/CRjovwn5ukChQKCmV2ZW50X3R5cGUSBsIBAwoBLAoVCgJpZBIPwgEMCgqDiJkwCZGJhxZMChUKC29iamVjdF90eXBlEgbCAQMKATwKLQoLb2NjdXJyZWRfYXQSHroBGwoZCgZtaWxsaXMSD8IBDAoKcmOVlTBiWXYgfAoKCgR1c2VyEgIIBAoSCgRraW5kEgpCCEF1ZGl0TG9n +Cs0ICsoIugHGCAoxCgNrZXkSKroBJwolCgJpZBIfugEcChoKBlN5c3RlbRIQwgENCgsBdlFidyMDGBRzLAoRCgRraW5kEglCB0NsdXN0ZXIK/QcKBXZhbHVlEvMHugHvBwpzCgZjb25maWcSaboBZgoWCgd2YXJpYW50EgtCCVVubWFuYWdlZApMCg53b3JrbG9hZF9jbGFzcxI6QjjgtYrwkKiTYOGnv9GoLjoy8JCggfCeubzwnrmCJPCQs5Vj8Ja+mjx7JyUlIHtE4LqBImrwkY6HagojCgRuYW1lEhtCGS/wnrm3LlDgt4rRqPCeuKR08JGLoPCdlIgKFAoIb3duZXJfaWQSCEIGUHVibGljCrwGCgpwcml2aWxlZ2VzEq0GsgGpBgpvugFsCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKiQZBRnUIMyBRPAoTCgdncmFudGVlEghCBlB1YmxpYwonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgpWc0I1mZMpgVBcCocBugGDAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpFlJJRhZQkHcJwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgpIkidAhwFicCVMCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwF3UVMggVlwkpQcCo0BugGJAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpAYNhE3hoZUeFwKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBJDNykABQVGdwbAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgo2YlYjNzUHGYGcCne6AXQKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBOCUBMpKVEXgTXAoTCgdncmFudGVlEghCBlB1YmxpYwouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBAzECVyJUkiWJPAqTAboBjwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBFUmJRSggORCIjAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBUzc2lBkWlGmCnAouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBZANkODiRVXBkHAqMAboBiAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpJNSSXB3aFiAZcCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwElB1YHaTSIEmcsCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwEoQlYwMWJhRwBc +CrwECrkEugG1BAqeBAoDa2V5EpYEugGSBAqPBAoFZXZlbnQShQS6AYEECv4DCgJWMRL3A7oB8wMK5QIKB2RldGFpbHMS2QK6AdUCCtICChdBbHRlckRlZmF1bHRQcml2aWxlZ2VWMRK2AroBsgIKWAoLZGF0YWJhc2VfaWQSSboBRgpECgVpbm5lchI7Qjnwn5W04Yu/8JGglXvwnoC3NHfwnp+q77aiTT8iR0o/1bHwkJ60LvCQgIZgXHIk4LGGLiE8KuK3jS4KFwoKZ3JhbnRlZV9pZBIJQgci4Y6H77+9CkoKCnByaXZpbGVnZXMSPEI6RmB777+X4aCWLypCPjokyLo84YONLmx08J+VtPCfiYDwkbGl0ajwkI+B4pW8Y/Ccsrsq0ahq4La7JgogCgdyb2xlX2lkEhVCE13Dt+GNknbvuIHitrjqnKPDny8KTwoJc2NoZW1hX2lkEkK6AT8KPQoFaW5uZXISNEIyKuGMlfCeuKnwkY6O8JarhuqcqcKl8JCtu/CeuakqP+C3lj/wkbKlIvCRmoPhjabhv5gKFAoKZXZlbnRfdHlwZRIGwgEDCgEsChYKAmlkEhDCAQ0KCwFHCHcXERgXh4WcChUKC29iamVjdF90eXBlEgbCAQMKATwKOAoLb2NjdXJyZWRfYXQSKboBJgokCgZtaWxsaXMSGsIBFwoKCHkxdHMZFpOIbBD///////////8BCgoKBHVzZXISAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CvcBCvQBugHwAQp/CgNrZXkSeLoBdQo/CgZvYmplY3QSNboBMgowChBNYXRlcmlhbGl6ZWRWaWV3Ehy6ARkKFwoEVXNlchIPwgEMCgqFZYeIdnk4iFQcCjIKDXN1Yl9jb21wb25lbnQSIboBHgocCglDb2x1bW5Qb3MSD8IBDAoKRZEZAnlVJzE3XAoRCgRraW5kEglCB0NvbW1lbnQKWgoFdmFsdWUSUboBTgpMCgdjb21tZW50EkFCP+qphOC2sCjgqrM08JCgldGoJinig5RpcvCfp7vguoFk8J+puSrwnZS+Pyjhi4B1wqXhsLzIuvCeuZJEyLohOg== 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 +CmcKZboBYgoiCgNrZXkSG7oBGAoWCgRuYW1lEg5CDDZGb/CflbTwkJa7PQoRCgRraW5kEglCB0lkQWxsb2MKKQoFdmFsdWUSILoBHQobCgduZXh0X2lkEhDCAQ0KCwFiYgkQgxWDU5JM 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 +Cp4BCpsBugGXAQobCgNrZXkSFLoBEQoPCgJpZBIJQgdFeHBsYWluCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQpTCgV2YWx1ZRJKugFHCkUKBXNoYXJkEjxCOiLwn5W0w5Lgtrp7WjwkJfCRtaI5MeC9j+qbtSAi8JGRnSUu8J66osO+yLo7wqXgsL/wkZGY8JCgqnA= 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 +CocCCoQCugGAAgpQCgNrZXkSSboBRgoZCgtvYmplY3RfbmFtZRIKQgjwnYSpI+qluQoVCgtvYmplY3RfdHlwZRIGwgEDCgEsChIKC3NjaGVtYV9uYW1lEgNCAWAKFAoEa2luZBIMQgpHaWRNYXBwaW5nCpUBCgV2YWx1ZRKLAboBhwEKHQoKY2F0YWxvZ19pZBIPwgEMCgoRInVBQkBEMBl8CkcKC2ZpbmdlcnByaW50EjhCNuGhuMKjJPCeuZ1RKnw48JGZlVQlP1wrLjzwnoSgJN+MKcOvw7/wkIac4oSfKljDmSN7L+KEiwodCglnbG9iYWxfaWQSEMIBDQoLAYQymEiVaZAIAVw= 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 +CqwBCqkBugGlAQpKCgNrZXkSQ7oBQAoTCgdncmFudGVlEghCBlB1YmxpYwopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCoWHdURjNzmBmBwKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCjsKBXZhbHVlEjK6AS8KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBgyaHFgM2l4R0PA== +CqoBCqcBugGjAQpICgNrZXkSQboBPgonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgqUIleZlVhyA2NcChMKB2dyYW50b3ISCEIGUHVibGljChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo7CgV2YWx1ZRIyugEvCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXRiMkIiNpZnBnw= +CrMCCrACugGsAgqMAQoDa2V5EoQBugGAAQo8CgtvYmplY3RfbmFtZRItQitY8JGMuyZqOj9JOnV5T/CQvIdc4Kuo44KUJ/Cel6zIuuC9suK2gVPgsIgiChUKC29iamVjdF90eXBlEgbCAQMKAYwKKQoLc2NoZW1hX25hbWUSGkIY8JGOi3rgqrLwlq2c8J+VtGBS8J+VtMOnChQKBGtpbmQSDEIKR2lkTWFwcGluZwqEAQoFdmFsdWUSe7oBeAoeCgpjYXRhbG9nX2lkEhDCAQ0KCwEjh5SReZmIRAksCjcKC2ZpbmdlcnByaW50EihCJvCQhpl0wqU98JGSuirgrqlX8JGMsuG9jPCbhZEmO/CRr5zhna8iCh0KCWdsb2JhbF9pZBIQwgENCgsBcEAjUlUgIhB1TA== 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 +Cm8KbboBagpMCgNrZXkSRboBQgpACgVzaGFyZBI3QjVcWS/guK09TDrCpd+m8JCAtvCQl5hlJS7IuvCQhpfwkaCJcPCRsrEvMyfvv70iezrhsIJvZgoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CqcBCqQBugGgAQouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKRpdVlJeWhZF5bAoSCgRraW5kEgpCCFJvbGVBdXRoCloKBXZhbHVlElG6AU4KEwoNcGFzc3dvcmRfaGFzaBICCAQKNwoKdXBkYXRlZF9hdBIpugEmCiQKBm1pbGxpcxIawgEXCgoJMhk2kEM0UUGcEP///////////wE= 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 +CtgBCtUBugHRAQo1CgNrZXkSLroBKwopCgJpZBIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAUR4dnFhUDQACHwKEgoEa2luZBIKQghSb2xlQXV0aAqDAQoFdmFsdWUSeroBdwpHCg1wYXNzd29yZF9oYXNoEjZCNGB7J3t2VfCRoIU6fFzwkYC7Ki9LPjzwkKyQ8JGbnV7jgK/CpU00762E4KegYCzwkYCHW1AKLAoKdXBkYXRlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgpxJwEhlXUZiCeM +CqIBCp8BugGbAQpSCgNrZXkSS7oBSApGCgRuYW1lEj5CPHkkYCTwnp+gIuGksuCppuC3kiI/8JGdg/CQjZnwnYSj4oOcOiduYPCWrZ/gq5ArZGDIumVgQvCQhpR7PQoRCgRraW5kEglCB1NldHRpbmcKMgoFdmFsdWUSKboBJgokCgV2YWx1ZRIbQhnwnY2gLTwm8JGwvPCeuqnwkaek4aS4Ujo6 +CkIKQLoBPQoVCgRraW5kEg1CC1R4bldhbFNoYXJkCiQKBXZhbHVlEhu6ARgKFgoFc2hhcmQSDUILwqV54KyB4Ki1wqU= +CpEBCo4BugGKAQpLCgNrZXkSRLoBQQo/CgRuYW1lEjdCNXUye9Go8JGDtNqa8LG7ovCeuahB4KeLJFvwkbaRUCov4raSwqXwn5W0P/CflbTvv73wnaqbChEKBGtpbmQSCUIHSWRBbGxvYwooCgV2YWx1ZRIfugEcChoKB25leHRfaWQSD8IBDAoKGREmUCRBI1dXjA== +CogCCoUCugGBAgqiAQoDa2V5EpoBugGWAQotCgtkYXRhYmFzZV9pZBIeugEbChkKBlN5c3RlbRIPwgEMCgo0GQFEcxQ4FxF8CicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCmhHKQCZglFhYDwKFgoLb2JqZWN0X3R5cGUSB8IBBAoCASwKEwoHcm9sZV9pZBIIQgZQdWJsaWMKDwoJc2NoZW1hX2lkEgIIBAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCj0KBXZhbHVlEjS6ATEKLwoKcHJpdmlsZWdlcxIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEYKZeSU3gSF2ZM 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 +CjwKOroBNwoVCgRraW5kEg1CC1R4bldhbFNoYXJkCh4KBXZhbHVlEhW6ARIKEAoFc2hhcmQSB0IFbci6Ons= +CqABCp0BugGZAQoxCgNrZXkSKroBJwolCgJpZBIfugEcChoKBlN5c3RlbRIQwgENCgsBFXkgVgAQE5UpnAoSCgRraW5kEgpCCFJvbGVBdXRoClAKBXZhbHVlEke6AUQKEwoNcGFzc3dvcmRfaGFzaBICCAQKLQoKdXBkYXRlZF9hdBIfugEcChoKBm1pbGxpcxIQwgENCgsBMhRZmAkEZmZjLA== +CngKdroBcwo0CgNrZXkSLboBKgooCgRuYW1lEiBCHjVg8Ja/sfCRtL1N4ayy8JCBiCI88J6CjyIk8JCnnQoRCgRraW5kEglCB0lkQWxsb2MKKAoFdmFsdWUSH7oBHAoaCgduZXh0X2lkEg/CAQwKCmFmIxkFMQJUZJw= +CjgKNroBMwoVCgRraW5kEg1CC1R4bldhbFNoYXJkChoKBXZhbHVlEhG6AQ4KDAoFc2hhcmQSA0IBJA== +ClcKVboBUgoiCgNrZXkSG7oBGAoWCgRuYW1lEg5CDOOBr2ngu4bgvYw8PQoRCgRraW5kEglCB1NldHRpbmcKGQoFdmFsdWUSELoBDQoLCgV2YWx1ZRICQgA= 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 +CsUBCsIBugG+AQpkCgNrZXkSXboBWgotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqYFCU0OQVmIQKMCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKlhaSgFMFBRUSjAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKOgoFdmFsdWUSMboBLgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnQGWSFiMllAYiw= +CkgKRroBQwolCgNrZXkSHroBGwoZCgVzaGFyZBIQQg7gspBNJyrwnrmf8JGOpwoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CowBCokBugGFAQo5CgNrZXkSMroBLwotCgRuYW1lEiVCIybCpXBh4LKb4aS6w7nwn5+w6Zquzp0nOuCgrHtYPcOh4LCQChEKBGtpbmQSCUIHU2V0dGluZwo1CgV2YWx1ZRIsugEpCicKBXZhbHVlEh5CHCwlSFVjevCRgaAq8Ji0gD8vI8i6Vy8v8JCWlHs= +Cp8BCpwBugGYAQpACgNrZXkSOboBNgo0CgRuYW1lEixCKlw5eyVr4oGwIsK+KuGJnFPgob8/WEE18Jq/vV1q8JCtjOGKkTrwn6mzVQoRCgRraW5kEglCB1NldHRpbmcKQQoFdmFsdWUSOLoBNQozCgV2YWx1ZRIqQig78J+VtGtnJOCunzjwkLqpWFrDgGY90ajgqqDgr4fIuiLCtGMvbS5c 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 +CmoKaLoBZQpHCgNrZXkSQLoBPQo7CgVzaGFyZBIyQjBkYPCflbThv7MiLvCeuJsk4LOieGA9wqXgu4ZcInRs8Japp/Cdkp/wlq2h8Ja1qjcKGgoEa2luZBISQhBVbmZpbmFsaXplZFNoYXJk +CpkBCpYBugGSAQowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgoRllYkmVkTWGMcCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQo5CgV2YWx1ZRIwugEtCisKBXNoYXJkEiJCIPCflbQuKuCxryTvuIpv8Jy5q0HwnY2DcPCdqqTitrU8 +CuUDCuIDugHeAwrHAwoDa2V5Er8DugG7Awq4AwoFZXZlbnQSrgO6AaoDCqcDCgJWMRKgA7oBnAMKmQIKB2RldGFpbHMSjQK6AYkCCoYCChREcm9wQ2x1c3RlclJlcGxpY2FWMxLtAboB6QEKJAoKY2x1c3Rlcl9pZBIWQhTwkYePLyXwnYCvUuC7hiYy4La9fQoSCgxjbHVzdGVyX25hbWUSAkIACjQKBnJlYXNvbhIqugEnCiUKBnJlYXNvbhIbugEYChYKD1JlY29uZmlndXJhdGlvbhIDugEACi8KCnJlcGxpY2FfaWQSIboBHgocCgVpbm5lchITQhEoQcKl8J2RsfCbspw677+9dAorCgxyZXBsaWNhX25hbWUSG0IZNjxg4KiC4LGp77+98J6frTVqYPCflbQucwoZChNzY2hlZHVsaW5nX3BvbGljaWVzEgIIBAoUCgpldmVudF90eXBlEgbCAQMKATwKFQoCaWQSD8IBDAoKcVYGEjBZQAgwPAoVCgtvYmplY3RfdHlwZRIGwgEDCgF8Ci4KC29jY3VycmVkX2F0Eh+6ARwKGgoGbWlsbGlzEhDCAQ0KCwFneWl2Y3ZpOGaMCgoKBHVzZXISAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cl8KXboBWgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkEKBXZhbHVlEji6ATUKMwoFc2hhcmQSKkIoe3U2avCdkr4v8JKQgGs94KquJMi6LmI8XGjwkKC88JGyjV3wkYyPew== +CrgDCrUDugGxAwqaAwoDa2V5EpIDugGOAwqLAwoFZXZlbnQSgQO6Af0CCvoCCgJWMRLzAroB7wIK7AEKB2RldGFpbHMS4AG6AdwBCtkBCgxVcGRhdGVJdGVtVjESyAG6AcQBCiAKAmlkEhpCGD7wm4WnJFUqJ37igbzCqsi6yLoqN3s8PwqfAQoEbmFtZRKWAboBkgEKOgoIZGF0YWJhc2USLkIs8JOykzrwnZiGw5Hvv73wkbyMwqVDXHw677+98JGRnzrgrZ1CJu+8lu+4oCoKHQoEaXRlbRIVQhPqpIvwkJa7KvCRnKBgOkDigpVcCjUKBnNjaGVtYRIrQik8aNaJ4YSSPCrwn6GWJvCRmZPgrZ3wkaWB8J2SosKl8JGgsDpu8LC9rwoUCgpldmVudF90eXBlEgbCAQMKAVwKFQoCaWQSD8IBDAoKdUGUVZmDQmA3XAoWCgtvYmplY3RfdHlwZRIHwgEECgIBHAotCgtvY2N1cnJlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgpQUzAAKAYQVhBsCgoKBHVzZXISAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cp8BCpwBugGYAQoxCgNrZXkSKroBJwolCgJpZBIfugEcChoKBlN5c3RlbRIQwgENCgsBJ4SWdJcXQ0gzbAoSCgRraW5kEgpCCFJvbGVBdXRoCk8KBXZhbHVlEka6AUMKEwoNcGFzc3dvcmRfaGFzaBICCAQKLAoKdXBkYXRlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgpgIIJjeYYwRpMc +CnQKcroBbwobCgNrZXkSFLoBEQoPCgJpZBIJQgdFeHBsYWluCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQorCgV2YWx1ZRIiugEfCh0KBXNoYXJkEhRCEjwqQuCunyLwkaO/8JuEksOiPw== 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 +Cu0BCuoBugHmAQrPAQoDa2V5EscBugHDAQrAAQoFZXZlbnQStgG6AbIBCq8BCgJWMRKoAboBpAEKIQoHZGV0YWlscxIWugETChEKClJlc2V0QWxsVjESA7oBAAoUCgpldmVudF90eXBlEgbCAQMKARwKFgoCaWQSEMIBDQoLAQcRI5BJJ4BJMHwKFgoLb2JqZWN0X3R5cGUSB8IBBAoCAYwKLQoLb2NjdXJyZWRfYXQSHroBGwoZCgZtaWxsaXMSD8IBDAoKNiR3MjVjNygQHAoKCgR1c2VyEgIIBAoSCgRraW5kEgpCCEF1ZGl0TG9n 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 +CpsBCpgBugGUAQowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgpDYHZlAyd0gzIsCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQo7CgV2YWx1ZRIyugEvCi0KBXNoYXJkEiRCIlwv8J+VtO+/veG+uzIhaFwq0ah0L9aA8J+VtDkkey8ld3s= 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 +CqsBCqgBugGkAQpKCgNrZXkSQ7oBQAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCpNyQHgngWRUF1wKEwoHZ3JhbnRvchIIQgZQdWJsaWMKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCjoKBXZhbHVlEjG6AS4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpZQxeFR5FBFSSM +CqMCCqACugGcAgqFAQoDa2V5En66AXsKLQoKY2x1c3Rlcl9pZBIfugEcChoKBlN5c3RlbRIQwgENCgsBIBEnYHNGSFEhPApKCgRuYW1lEkJCQDwn8JGnoOK2s/CRmp7wkICl8Ja/sSU18J64pz8m4Ka/YPCcvLN6PMOOXMKl8JGvsvCRr5rCvnnwkYGTP3s/w68KKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4CmcKBXZhbHVlEl66AVsKKAoKY2F0YWxvZ19pZBIawgEXCgoFKYI5OXdggZFsEP///////////wEKHAoJZ2xvYmFsX2lkEg/CAQwKCgNXYXE5gQJ0IWwKEQoDb2lkEgrCAQcKBZVihhI8 +CrACCq0CugGpAgqZAQoDa2V5EpEBugGNAQpKCgtvYmplY3RfbmFtZRI7QjkuaNGo8JGnozwn6qOX4LOzRcKl4rSnNcO74ZyiLzBvwr3wkZaNUeGKveCupDrwkbWgXiVu762DyLoKFQoLb2JqZWN0X3R5cGUSBsIBAwoBHAooCgtzY2hlbWFfbmFtZRIZQhfvv5bRqNGoNnxp8JGkgPCflbRkKjwvLgoUCgRraW5kEgxCCkdpZE1hcHBpbmcKdQoFdmFsdWUSbLoBaQodCgpjYXRhbG9nX2lkEg/CAQwKCocHdElDYmaHIJwKKgoLZmluZ2VycHJpbnQSG0IZam3CpVYlYDwzPVk0JHonLiU9yLpHXD1FYAocCglnbG9iYWxfaWQSD8IBDAoKhBBVhjIDdVYJbA== +Co8BCowBugGIAQpDCgNrZXkSPLoBOQo3CgRuYW1lEi9CLeGlm8Kl8JapkV3wkIC9LzPwnZKmez/wkZODJOqpkHBtL++/vfCfq5/wn4OSbQodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KIgoFdmFsdWUSGboBFgoUCgV2YWx1ZRILQgnhmq1aPFY6w6M= +CusBCugBugHkAQpYCgNrZXkSUboBTgorCgpjbHVzdGVyX2lkEh26ARoKGAoGU3lzdGVtEg7CAQsKCQSSICRxghkmTAofCgRuYW1lEhdCFXnwkJa84bytwqXqn5ngs43wm4C1PAopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKXQoFdmFsdWUSVLoBUQodCgpjYXRhbG9nX2lkEg/CAQwKCmOYgxRXZTGVgZwKHQoJZ2xvYmFsX2lkEhDCAQ0KCwFDOJhWMZhgOAUcChEKA29pZBIKwgEHCgVWFGlBfA== +CpECCo4CugGKAgp+CgNrZXkSd7oBdAorCgpjbHVzdGVyX2lkEh26ARoKGAoEVXNlchIQwgENCgsBdTdWYYBQMolJbApFCgRuYW1lEj1CO/CQq6TgroLwnLWp8JCXiPCQoLfvv709w6BRe/CehYdnUPCeuLl74LqbOkbvv71KwqUk8JCNqibRqNGoCikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleApdCgV2YWx1ZRJUugFRCh0KCmNhdGFsb2dfaWQSD8IBDAoKNCOXGVVxYyOUjAodCglnbG9iYWxfaWQSEMIBDQoLAQCWAWiFBThBAxwKEQoDb2lkEgrCAQcKBWhRYwgs +CowCCokCugGFAgqMAQoDa2V5EoQBugGAAQo/CgtvYmplY3RfbmFtZRIwQi5gQeCviy8uXuqplUbqmKt0evCeuYnwkKSKOmdnRNaqSuKAiuK3muCumvCeuY5rChUKC29iamVjdF90eXBlEgbCAQMKAXwKJgoLc2NoZW1hX25hbWUSF0IV8Jq/vW1CRD3gr5fwn5um0ajhs4NjChQKBGtpbmQSDEIKR2lkTWFwcGluZwpeCgV2YWx1ZRJVugFSCh4KCmNhdGFsb2dfaWQSEMIBDQoLAQM2hTaRAQR2AlwKEQoLZmluZ2VycHJpbnQSAkIACh0KCWdsb2JhbF9pZBIQwgENCgsBB4EAR0N5UEEEPA== +CqQCCqECugGdAgqPAQoDa2V5EocBugGDAQotCgpjbHVzdGVyX2lkEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFolXaIZhRYZHlMClIKBG5hbWUSSkJIXDfwkLycMEzwkJaN8JCErvCRtIUv8J+il3jwkY6SJuGEteCpryIt4rSnR1vwnZiF8J64tS/wkY2Xe+qki9Go8J2NoDov0agmCikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleApeCgV2YWx1ZRJVugFSCh4KCmNhdGFsb2dfaWQSEMIBDQoLAWZCJHMJR4mUVSwKHAoJZ2xvYmFsX2lkEg/CAQwKCmljUogzeYMXVnwKEgoDb2lkEgvCAQgKBgMQaTkBXA== +CqwCCqkCugGlAgovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLAQU5Vxg4cDWAhYwKEAoEa2luZBIIQgZTY2hlbWEK3wEKBXZhbHVlEtUBugHRAQouCgtkYXRhYmFzZV9pZBIfugEcChoKBlN5c3RlbRIQwgENCgsBJ2AWSEgGBEhlfApNCgRuYW1lEkVCQ8OoPScv4KiP4KykIljgupYmw5PgspLwkKeE4b64J/CflbTis7/RqPCegKki4YmW8JG8pPCflbTvrJZH4Z+zImBPJyQKEgoDb2lkEgvCAQgKBgQoOWaYXAopCghvd25lcl9pZBIdugEaChgKBFVzZXISEMIBDQoLASEjVoJ5aZcRJiwKEQoKcHJpdmlsZWdlcxIDsgEA +Cm4KbLoBaQpLCgNrZXkSRLoBQQo/CgVzaGFyZBI2QjR2XDoq4LKL4Yq6w5LwkY6O8JG8hTwn8JGjjvCbhZXwlquGNeC3ik7vv71t4aOvQvCRpLh6ChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +ClMKUboBTgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCjUKBXZhbHVlEiy6ASkKJwoFc2hhcmQSHkIcIvCdvKjhv74qbzrwkIyHPu+/vU0vVtGo8JCAvw== +CuYBCuMBugHfAQoxCgNrZXkSKroBJwolCgJpZBIfugEcChoKBlN5c3RlbRIQwgENCgsBJRIoMGV1SGkhfAoSCgRraW5kEgpCCFJvbGVBdXRoCpUBCgV2YWx1ZRKLAboBhwEKTAoNcGFzc3dvcmRfaGFzaBI7QjlsOvCRjZDwkKiF4pGJ6qeZL/CRhakk0ajwn6qWcFdgJlwlJPCQto/wkICJ44KaYOCpnsKlJT8l2IcKNwoKdXBkYXRlZF9hdBIpugEmCiQKBm1pbGxpcxIawgEXCgoEBQOQFQI4SSFsEP///////////wE= +CrsCCrgCugG0AgqsAQoDa2V5EqQBugGgAQpKCgtvYmplY3RfbmFtZRI7QjkmXDpcZci6ay488J65n/CflbTguojDu/Cct6vqoKUu8JGkvvCWqYNc4bC/IiQ6ISQ8de+/veCvkEIKFQoLb2JqZWN0X3R5cGUSBsIBAwoBbAo7CgtzY2hlbWFfbmFtZRIsQirvv706LfCQoLzhqpd8QEYi6qWIbUjgqr/wn4ez8JCguFNRLj3vv73jhaIKFAoEa2luZBIMQgpHaWRNYXBwaW5nCm0KBXZhbHVlEmS6AWEKHgoKY2F0YWxvZ19pZBIQwgENCgsBARklGIU5YEkmnAohCgtmaW5nZXJwcmludBISQhAt8J2UrHbDm/CRhKPhv6oiChwKCWdsb2JhbF9pZBIPwgEMCgpTCDh4MAKGBDGc +CmYKZLoBYQokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgpFgjIUcEMhEnMcCiMKBWVwb2NoEhrCARcKCgMCACNgUzVEZX0Q////////////AQoUCgRraW5kEgxCCkZlbmNlVG9rZW4= +CkgKRroBQwoVCgRraW5kEg1CC1R4bldhbFNoYXJkCioKBXZhbHVlEiG6AR4KHAoFc2hhcmQSE0IR77+90ajwm7G1Kl55SvCdlYY= +CsMCCsACugG8AgqlAgoDa2V5Ep0CugGZAgqWAgoFZXZlbnQSjAK6AYgCCoUCCgJWMRL+AboB+gEKeAoHZGV0YWlscxJtugFqCmgKEEZyb21QcmV2aW91c0lkVjESVLoBUQotCgJpZBInQiVD8JGymGTqnKHwkLWfZOKEv/CeuajRqPCflbTwnYil8JGcvMKlCiAKC3ByZXZpb3VzX2lkEhFCD/CWtaMm6qinyLoiOsKldwoUCgpldmVudF90eXBlEgbCAQMKAWwKFgoCaWQSEMIBDQoLAYQndFJJIUEydBwKFQoLb2JqZWN0X3R5cGUSBsIBAwoBnAotCgtvY2N1cnJlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgpgAZMikUgACZKMCgoKBHVzZXISAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Co4BCosBugGHAQpLCgNrZXkSRLoBQQo/CgNrZXkSOEI28J2LkkXgpqwn77+98JGEuH3wkKO18JCdp/CfgrJ+8J2UmvCRtaXwkYimIuqopfCRjIHRqD04ChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKV0FxeHlzSDYJfA== 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 +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBVoaCNJdFdGQWPAoYCgVlcG9jaBIPwgEMCgplFWcjYHEwVJYcChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CncKdboBcgoyCgNrZXkSK7oBKAomCgRuYW1lEh5CHDzgrIVA8JuIuj1bYGDirogu4L+KYDp74Ke+LzoKEQoEa2luZBIJQgdJZEFsbG9jCikKBXZhbHVlEiC6AR0KGwoHbmV4dF9pZBIQwgENCgsBcCSVaGBiZpdUjA== +CpQBCpEBugGNAQpOCgNrZXkSR7oBRApCCgRuYW1lEjpCOEIk8J+VtHBJw65y6qGP4KGj8KCGteC0tk/itYvwn5W0SvCQlrPRqOqioXDhnIjwn4ew8JCWvHElChEKBGtpbmQSCUIHSWRBbGxvYwooCgV2YWx1ZRIfugEcChoKB25leHRfaWQSD8IBDAoKFoeRQFUZJ5iYLA== diff --git a/src/catalog/src/durable/upgrade/v85_to_v86.rs b/src/catalog/src/durable/upgrade/v85_to_v86.rs new file mode 100644 index 0000000000000..ba25721099ecc --- /dev/null +++ b/src/catalog/src/durable/upgrade/v85_to_v86.rs @@ -0,0 +1,374 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use std::collections::BTreeMap; + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::json_compatible::JsonCompatible; +use crate::durable::upgrade::objects_v85 as v85; +use crate::durable::upgrade::objects_v86 as v86; + +// Every sub-structure carried across the version unchanged. The only shapes +// that actually gained fields between v85 and v86 are the managed `Cluster` +// variant and the managed `ReplicaLocation`; everything else is JSON-identical +// and is moved across via `JsonCompatible::convert`. The macro also generates +// proptest round-trips asserting the two encodings stay byte-compatible. +crate::json_compatible!(v85::ClusterKey with v86::ClusterKey); +crate::json_compatible!(v85::RoleId with v86::RoleId); +crate::json_compatible!(v85::MzAclItem with v86::MzAclItem); +crate::json_compatible!(v85::ReplicaLogging with v86::ReplicaLogging); +crate::json_compatible!(v85::OptimizerFeatureOverride with v86::OptimizerFeatureOverride); +crate::json_compatible!(v85::ClusterSchedule with v86::ClusterSchedule); +crate::json_compatible!(v85::ClusterReplicaKey with v86::ClusterReplicaKey); +crate::json_compatible!(v85::ClusterId with v86::ClusterId); +crate::json_compatible!(v85::UnmanagedLocation with v86::UnmanagedLocation); + +/// Adds the additive, behaviorally-inert durable cluster-controller state and +/// reshapes the managed replica location's availability-zone field: +/// +/// - `ManagedCluster` gains `auto_scaling_strategy`, `reconfiguration`, and +/// `burst`, all defaulted to `None`. +/// - The managed `ReplicaLocation`'s single `availability_zone` user-pin +/// becomes an `availability_zones` list recording the zones the replica was +/// provisioned under: for a replica of a managed cluster the owning +/// *cluster*'s current `availability_zones` (the placement pool); for a +/// replica of an unmanaged cluster its prior single pin, carried across as +/// a zero- or one-element list. +/// +/// Only the managed `Cluster` variant and managed `ReplicaLocation` changed +/// shape, so only those records are rewritten. Unmanaged clusters and unmanaged +/// replica locations are JSON-identical in v86 and are left untouched — +/// emitting an update for them would just retract and re-add the same bytes. +pub fn upgrade( + snapshot: Vec, +) -> Vec> { + // The per-replica provisioned-AZ list is backfilled from the owning + // cluster's `availability_zones`, so collect every managed cluster's list + // before rewriting replicas. Unmanaged clusters contribute no entry, so a + // replica of one backfills the empty list. + let mut cluster_azs: BTreeMap> = BTreeMap::new(); + for update in &snapshot { + if let v85::StateUpdateKind::Cluster(cluster) = update { + if let v85::ClusterVariant::Managed(managed) = &cluster.value.config.variant { + cluster_azs.insert(cluster.key.id.clone(), managed.availability_zones.clone()); + } + } + } + + let mut migrations = Vec::new(); + for update in snapshot { + match update { + v85::StateUpdateKind::Cluster(old_cluster) + if matches!( + old_cluster.value.config.variant, + v85::ClusterVariant::Managed(_) + ) => + { + let new_cluster = migrate_managed_cluster(old_cluster.clone()); + migrations.push(MigrationAction::Update( + v85::StateUpdateKind::Cluster(old_cluster), + v86::StateUpdateKind::Cluster(new_cluster), + )); + } + v85::StateUpdateKind::ClusterReplica(old_replica) + if matches!( + old_replica.value.config.location, + v85::ReplicaLocation::Managed(_) + ) => + { + // `Some(pool)` for a replica of a managed cluster (the cluster's + // AZ list, possibly empty); `None` for a replica of an unmanaged + // cluster, which contributes no entry and keeps its own pin. + let cluster_pool = cluster_azs.get(&old_replica.value.cluster_id).cloned(); + let new_replica = migrate_managed_replica(old_replica.clone(), cluster_pool); + migrations.push(MigrationAction::Update( + v85::StateUpdateKind::ClusterReplica(old_replica), + v86::StateUpdateKind::ClusterReplica(new_replica), + )); + } + // Unmanaged clusters and unmanaged locations are JSON-identical + // across the version; nothing else changed shape. + _ => {} + } + } + migrations +} + +/// Rewrites a managed `Cluster`, reconstructing only the `ManagedCluster` that +/// gained fields and carrying every other sub-structure across unchanged. +fn migrate_managed_cluster(old: v85::Cluster) -> v86::Cluster { + let v85::Cluster { key, value } = old; + let v85::ClusterVariant::Managed(m) = value.config.variant else { + unreachable!("caller guards on the managed variant"); + }; + v86::Cluster { + key: JsonCompatible::convert(&key), + value: v86::ClusterValue { + name: value.name, + owner_id: JsonCompatible::convert(&value.owner_id), + privileges: value + .privileges + .iter() + .map(JsonCompatible::convert) + .collect(), + config: v86::ClusterConfig { + workload_class: value.config.workload_class, + variant: v86::ClusterVariant::Managed(v86::ManagedCluster { + size: m.size, + replication_factor: m.replication_factor, + availability_zones: m.availability_zones, + logging: JsonCompatible::convert(&m.logging), + optimizer_feature_overrides: m + .optimizer_feature_overrides + .iter() + .map(JsonCompatible::convert) + .collect(), + schedule: JsonCompatible::convert(&m.schedule), + // Additive, defaulted: no policy or in-flight state for + // existing clusters. + auto_scaling_strategy: None, + reconfiguration: None, + burst: None, + }), + }, + }, + } +} + +/// Rewrites a `ClusterReplica` with a managed location, reconstructing only the +/// `ManagedLocation` whose `availability_zone` user-pin became an +/// `availability_zones` list and carrying every other sub-structure across +/// unchanged. `cluster_pool` is `Some` (the owning managed cluster's AZ list) +/// for a replica of a managed cluster and `None` for a replica of an unmanaged +/// cluster. +fn migrate_managed_replica( + old: v85::ClusterReplica, + cluster_pool: Option>, +) -> v86::ClusterReplica { + let v85::ClusterReplica { key, value } = old; + let v85::ReplicaLocation::Managed(m) = value.config.location else { + unreachable!("caller guards on the managed location"); + }; + let availability_zones = match cluster_pool { + // Managed cluster: provisioned under the cluster's `AVAILABILITY ZONES` + // pool. (A managed cluster's replica never carries its own single-AZ + // pin, so `m.availability_zone` is always `None` here.) + Some(pool) => pool, + // Unmanaged cluster: carry the replica's user-pinned `AVAILABILITY ZONE` + // across as a zero- or one-element list. + None => m.availability_zone.into_iter().collect(), + }; + v86::ClusterReplica { + key: JsonCompatible::convert(&key), + value: v86::ClusterReplicaValue { + cluster_id: JsonCompatible::convert(&value.cluster_id), + name: value.name, + config: v86::ReplicaConfig { + logging: JsonCompatible::convert(&value.config.logging), + location: v86::ReplicaLocation::Managed(v86::ManagedLocation { + size: m.size, + availability_zones, + internal: m.internal, + billed_as: m.billed_as, + pending: m.pending, + }), + }, + owner_id: JsonCompatible::convert(&value.owner_id), + }, + } +} + +#[cfg(test)] +mod tests { + use super::upgrade; + use crate::durable::upgrade::MigrationAction; + use crate::durable::upgrade::objects_v85 as v85; + use crate::durable::upgrade::objects_v86 as v86; + + fn managed_cluster(id: u64, availability_zones: Vec) -> v85::StateUpdateKind { + v85::StateUpdateKind::Cluster(v85::Cluster { + key: v85::ClusterKey { + id: v85::ClusterId::User(id), + }, + value: v85::ClusterValue { + name: format!("cluster_{id}"), + owner_id: v85::RoleId::User(1), + privileges: vec![], + config: v85::ClusterConfig { + workload_class: None, + variant: v85::ClusterVariant::Managed(v85::ManagedCluster { + size: "100cc".to_string(), + replication_factor: 1, + availability_zones, + logging: v85::ReplicaLogging { + log_logging: false, + interval: None, + }, + optimizer_feature_overrides: vec![], + schedule: v85::ClusterSchedule::Manual, + }), + }, + }, + }) + } + + fn unmanaged_cluster(id: u64) -> v85::StateUpdateKind { + v85::StateUpdateKind::Cluster(v85::Cluster { + key: v85::ClusterKey { + id: v85::ClusterId::User(id), + }, + value: v85::ClusterValue { + name: format!("cluster_{id}"), + owner_id: v85::RoleId::User(1), + privileges: vec![], + config: v85::ClusterConfig { + workload_class: None, + variant: v85::ClusterVariant::Unmanaged, + }, + }, + }) + } + + fn managed_replica( + replica_id: u64, + cluster_id: u64, + availability_zone: Option, + ) -> v85::StateUpdateKind { + v85::StateUpdateKind::ClusterReplica(v85::ClusterReplica { + key: v85::ClusterReplicaKey { + id: v85::ReplicaId::User(replica_id), + }, + value: v85::ClusterReplicaValue { + cluster_id: v85::ClusterId::User(cluster_id), + name: format!("r{replica_id}"), + config: v85::ReplicaConfig { + logging: v85::ReplicaLogging { + log_logging: false, + interval: None, + }, + location: v85::ReplicaLocation::Managed(v85::ManagedLocation { + size: "100cc".to_string(), + availability_zone, + internal: false, + billed_as: None, + pending: false, + }), + }, + owner_id: v85::RoleId::User(1), + }, + }) + } + + #[mz_ore::test] + fn test_cluster_new_fields_default_none() { + let migrations = upgrade(vec![managed_cluster(1, vec!["az1".to_string()])]); + assert_eq!(migrations.len(), 1); + let MigrationAction::Update(_, v86::StateUpdateKind::Cluster(cluster)) = &migrations[0] + else { + panic!("expected a cluster update"); + }; + let v86::ClusterVariant::Managed(managed) = &cluster.value.config.variant else { + panic!("expected a managed cluster"); + }; + assert_eq!(managed.auto_scaling_strategy, None); + assert_eq!(managed.reconfiguration, None); + assert_eq!(managed.burst, None); + // Existing fields are preserved. + assert_eq!(managed.availability_zones, vec!["az1".to_string()]); + } + + #[mz_ore::test] + fn test_replica_backfills_cluster_azs() { + let azs = vec!["az1".to_string(), "az2".to_string()]; + let migrations = upgrade(vec![ + managed_cluster(1, azs.clone()), + managed_replica(10, 1, None), + ]); + assert_eq!(migrations.len(), 2); + + let MigrationAction::Update(_, v86::StateUpdateKind::ClusterReplica(replica)) = + &migrations[1] + else { + panic!("expected a replica update"); + }; + let v86::ReplicaLocation::Managed(loc) = &replica.value.config.location else { + panic!("expected a managed location"); + }; + assert_eq!(loc.availability_zones, azs); + } + + #[mz_ore::test] + fn test_replica_of_unmanaged_cluster_carries_pin_as_list() { + // A managed location can carry a single-AZ user-pin only when its + // owning cluster is unmanaged. That pin is carried across as a + // one-element `availability_zones` list. The unmanaged cluster itself + // is JSON-identical and emits no migration, so the replica is the only + // action. + let migrations = upgrade(vec![ + unmanaged_cluster(1), + managed_replica(10, 1, Some("az1".to_string())), + ]); + assert_eq!(migrations.len(), 1); + let MigrationAction::Update(_, v86::StateUpdateKind::ClusterReplica(replica)) = + &migrations[0] + else { + panic!("expected a replica update"); + }; + let v86::ReplicaLocation::Managed(loc) = &replica.value.config.location else { + panic!("expected a managed location"); + }; + assert_eq!(loc.availability_zones, vec!["az1".to_string()]); + } + + #[mz_ore::test] + fn test_replica_no_cluster_azs_backfills_empty() { + let migrations = upgrade(vec![ + managed_cluster(1, vec![]), + managed_replica(10, 1, None), + ]); + let MigrationAction::Update(_, v86::StateUpdateKind::ClusterReplica(replica)) = + &migrations[1] + else { + panic!("expected a replica update"); + }; + let v86::ReplicaLocation::Managed(loc) = &replica.value.config.location else { + panic!("expected a managed location"); + }; + assert!(loc.availability_zones.is_empty()); + } + + #[mz_ore::test] + fn test_unmanaged_records_are_not_rewritten() { + // Unmanaged clusters and unmanaged replica locations are JSON-identical + // between v85 and v86, so the migration leaves them untouched rather + // than emitting a no-op retract+add of the same bytes. + let unmanaged_replica = v85::StateUpdateKind::ClusterReplica(v85::ClusterReplica { + key: v85::ClusterReplicaKey { + id: v85::ReplicaId::User(20), + }, + value: v85::ClusterReplicaValue { + cluster_id: v85::ClusterId::User(2), + name: "r20".to_string(), + config: v85::ReplicaConfig { + logging: v85::ReplicaLogging { + log_logging: false, + interval: None, + }, + location: v85::ReplicaLocation::Unmanaged(v85::UnmanagedLocation { + storagectl_addrs: vec!["s".to_string()], + computectl_addrs: vec!["c".to_string()], + }), + }, + owner_id: v85::RoleId::User(1), + }, + }); + let migrations = upgrade(vec![unmanaged_cluster(2), unmanaged_replica]); + assert!(migrations.is_empty()); + } +} diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index 3e8a94880c5ab..13975d3bf4a3c 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -52,10 +52,10 @@ use mz_sql::names::{ QualifiedSchemaName, ResolvedDatabaseSpecifier, ResolvedIds, SchemaId, SchemaSpecifier, }; use mz_sql::plan::{ - ClusterSchedule, ComputeReplicaConfig, ComputeReplicaIntrospectionConfig, ConnectionDetails, - CreateClusterManagedPlan, CreateClusterPlan, CreateClusterVariant, CreateSourcePlan, - HirRelationExpr, NetworkPolicyRule, PlanError, WebhookBodyFormat, WebhookHeaders, - WebhookValidation, + AutoScalingStrategy, ClusterSchedule, ComputeReplicaConfig, ComputeReplicaIntrospectionConfig, + ConnectionDetails, CreateClusterManagedPlan, CreateClusterPlan, CreateClusterVariant, + CreateSourcePlan, HirRelationExpr, NetworkPolicyRule, OnTimeoutAction, PlanError, + WebhookBodyFormat, WebhookHeaders, WebhookValidation, }; use mz_sql::rbac; use mz_sql::session::vars::OwnedVarInput; @@ -414,6 +414,12 @@ impl Cluster { replication_factor, optimizer_feature_overrides, schedule, + // The user-configured policy is surfaced in the create plan (so + // `SHOW CREATE CLUSTER` renders it). The in-flight runtime records + // are controller-managed and not part of the create statement. + auto_scaling_strategy, + reconfiguration: _, + burst: _, }) => { let introspection = match logging { ReplicaLogging { @@ -436,6 +442,7 @@ impl Cluster { compute, optimizer_feature_overrides: optimizer_feature_overrides.clone(), schedule: schedule.clone(), + auto_scaling_strategy: auto_scaling_strategy.clone(), }) } ClusterVariant::Unmanaged => { @@ -3290,30 +3297,205 @@ pub struct ClusterVariantManaged { pub replication_factor: u32, pub optimizer_feature_overrides: OptimizerFeatureOverrides, pub schedule: ClusterSchedule, + /// User-configured autoscaling policy, distinct from the in-flight runtime + /// records below. Shared with the durable layer, like [`ClusterSchedule`]. + pub auto_scaling_strategy: Option, + /// In-flight graceful reconfiguration the controller is converging on. + pub reconfiguration: Option, + /// In-flight hydration burst the controller is running. + pub burst: Option, } impl From for durable::ClusterVariantManaged { fn from(managed: ClusterVariantManaged) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let ClusterVariantManaged { + size, + availability_zones, + logging, + replication_factor, + optimizer_feature_overrides, + schedule, + auto_scaling_strategy, + reconfiguration, + burst, + } = managed; Self { - size: managed.size, - availability_zones: managed.availability_zones, - logging: managed.logging, - replication_factor: managed.replication_factor, - optimizer_feature_overrides: managed.optimizer_feature_overrides.into(), - schedule: managed.schedule, + size, + availability_zones, + logging, + replication_factor, + optimizer_feature_overrides: optimizer_feature_overrides.into(), + schedule, + auto_scaling_strategy, + reconfiguration: reconfiguration.map(Into::into), + burst: burst.map(Into::into), } } } impl From for ClusterVariantManaged { fn from(managed: durable::ClusterVariantManaged) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let durable::ClusterVariantManaged { + size, + availability_zones, + logging, + replication_factor, + optimizer_feature_overrides, + schedule, + auto_scaling_strategy, + reconfiguration, + burst, + } = managed; Self { - size: managed.size, - availability_zones: managed.availability_zones, - logging: managed.logging, - replication_factor: managed.replication_factor, - optimizer_feature_overrides: managed.optimizer_feature_overrides.into(), - schedule: managed.schedule, + size, + availability_zones, + logging, + replication_factor, + optimizer_feature_overrides: optimizer_feature_overrides.into(), + schedule, + auto_scaling_strategy, + reconfiguration: reconfiguration.map(Into::into), + burst: burst.map(Into::into), + } + } +} + +/// In-memory mirror of [`durable::ReconfigurationState`]. +/// +/// This runtime state lives only in the durable layer, so the memory layer +/// carries its own `Serialize`/`Deserialize` mirror (to back the catalog +/// `dump()`) and converts across the boundary, rather than embedding the +/// durable-only type. The semantic contract lives on the durable type. +#[derive(Clone, Debug, Deserialize, Serialize, PartialOrd, PartialEq, Eq, Ord)] +pub struct ReconfigurationState { + pub target: ReconfigurationTarget, + pub deadline: Timestamp, + pub on_timeout: OnTimeoutAction, +} + +impl From for durable::ReconfigurationState { + fn from(state: ReconfigurationState) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let ReconfigurationState { + target, + deadline, + on_timeout, + } = state; + Self { + target: target.into(), + deadline, + on_timeout, + } + } +} + +impl From for ReconfigurationState { + fn from(state: durable::ReconfigurationState) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let durable::ReconfigurationState { + target, + deadline, + on_timeout, + } = state; + Self { + target: target.into(), + deadline, + on_timeout, + } + } +} + +/// In-memory mirror of [`durable::ReconfigurationTarget`]. +#[derive(Clone, Debug, Deserialize, Serialize, PartialOrd, PartialEq, Eq, Ord)] +pub struct ReconfigurationTarget { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, +} + +impl From for durable::ReconfigurationTarget { + fn from(target: ReconfigurationTarget) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let ReconfigurationTarget { + size, + replication_factor, + availability_zones, + logging, + } = target; + Self { + size, + replication_factor, + availability_zones, + logging, + } + } +} + +impl From for ReconfigurationTarget { + fn from(target: durable::ReconfigurationTarget) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let durable::ReconfigurationTarget { + size, + replication_factor, + availability_zones, + logging, + } = target; + Self { + size, + replication_factor, + availability_zones, + logging, + } + } +} + +/// In-memory mirror of [`durable::BurstState`]. +#[derive(Clone, Debug, Deserialize, Serialize, PartialOrd, PartialEq, Eq, Ord)] +pub struct BurstState { + pub burst_size: String, + pub linger_duration: Duration, + pub steady_hydrated_at: Option, +} + +impl From for durable::BurstState { + fn from(burst: BurstState) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let BurstState { + burst_size, + linger_duration, + steady_hydrated_at, + } = burst; + Self { + burst_size, + linger_duration, + steady_hydrated_at, + } + } +} + +impl From for BurstState { + fn from(burst: durable::BurstState) -> Self { + // Destructure the source (no `..`): a field added to either side is a + // compile error here until it's carried across the boundary. + let durable::BurstState { + burst_size, + linger_duration, + steady_hydrated_at, + } = burst; + Self { + burst_size, + linger_duration, + steady_hydrated_at, } } } @@ -3517,6 +3699,15 @@ impl mz_sql::catalog::CatalogCluster<'_> for Cluster { } } + fn auto_scaling_strategy(&self) -> Option<&AutoScalingStrategy> { + match &self.config.variant { + ClusterVariant::Managed(ClusterVariantManaged { + auto_scaling_strategy, + .. + }) => auto_scaling_strategy.as_ref(), + ClusterVariant::Unmanaged => None, + } + } fn try_to_plan(&self) -> Result { self.try_to_plan() } diff --git a/src/catalog/tests/snapshots/debug__opened_trace.snap b/src/catalog/tests/snapshots/debug__opened_trace.snap index 5a23178f79b59..4b1dfce833747 100644 --- a/src/catalog/tests/snapshots/debug__opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__opened_trace.snap @@ -1,6 +1,5 @@ --- source: src/catalog/tests/debug.rs -assertion_line: 235 expression: test_trace --- Trace { @@ -447,6 +446,9 @@ Trace { }, optimizer_feature_overrides: [], schedule: Manual, + auto_scaling_strategy: None, + reconfiguration: None, + burst: None, }, ), }, @@ -489,7 +491,7 @@ Trace { location: Managed( ManagedLocation { size: "scale=1,workers=1", - availability_zone: None, + availability_zones: [], internal: false, billed_as: None, pending: false, diff --git a/src/catalog/tests/snapshots/open__initial_snapshot.snap b/src/catalog/tests/snapshots/open__initial_snapshot.snap index 7f7261bde5aec..d572a8cf34b9c 100644 --- a/src/catalog/tests/snapshots/open__initial_snapshot.snap +++ b/src/catalog/tests/snapshots/open__initial_snapshot.snap @@ -1,6 +1,5 @@ --- source: src/catalog/tests/open.rs -assertion_line: 518 expression: test_snapshot --- Snapshot { @@ -624,6 +623,9 @@ Snapshot { }, optimizer_feature_overrides: [], schedule: Manual, + auto_scaling_strategy: None, + reconfiguration: None, + burst: None, }, ), }, @@ -686,7 +688,7 @@ Snapshot { location: Managed( ManagedLocation { size: "scale=1,workers=1", - availability_zone: None, + availability_zones: [], internal: false, billed_as: None, pending: false, diff --git a/src/cluster-controller/Cargo.toml b/src/cluster-controller/Cargo.toml new file mode 100644 index 0000000000000..8bc2600c90b0f --- /dev/null +++ b/src/cluster-controller/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "mz-cluster-controller" +description = "Pure cluster-autoscaling controller: strategies and the reconcile kernel." +version = "0.0.0" +edition.workspace = true +rust-version.workspace = true +publish = false + +[lints] +workspace = true + +[dependencies] +async-trait.workspace = true +mz-compute-types = { path = "../compute-types" } +mz-controller-types = { path = "../controller-types" } +mz-ore = { path = "../ore", features = ["async", "tracing"] } +mz-repr = { path = "../repr" } +timely.workspace = true + +[dev-dependencies] +mz-ore = { path = "../ore", features = ["async", "tracing", "test"] } +tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } + +[features] +default = [] diff --git a/src/cluster-controller/src/ctx.rs b/src/cluster-controller/src/ctx.rs new file mode 100644 index 0000000000000..9e082b2788d9b --- /dev/null +++ b/src/cluster-controller/src/ctx.rs @@ -0,0 +1,521 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +//! The boundary between the controller and its environment. +//! +//! [`ClusterControllerCtx`] is the single, strategy-agnostic seam through which +//! the controller pulls the signals a tick examines and applies the catalog +//! mutations it derives. The signals in are primitive and carry no per-strategy +//! state; the decisions out are primitive catalog mutations plus per-tick audit +//! attribution. A create carries the names of the strategies that desired it, +//! and the on-refresh window decision when that strategy did; the environment +//! turns these into audit events. The controller crate knows nothing about the +//! Coordinator — the Coordinator implements this trait — which is what makes +//! the controller testable against a fake implementation and extractable later +//! without touching controller code. +//! +//! The interface is **pull-based**: a tick fetches only the signals it actually +//! examines (no eager all-clusters-all-replicas snapshot is pushed in), and the +//! controller drives what is fetched. The two whole-tick reads +//! (`managed_cluster_ids`, `cluster_states`) are batched across all clusters; the +//! live signals (`hydrated_replicas`, `has_hydratable_objects`, +//! `refresh_window_inputs`) are pulled per cluster, on demand, only where a +//! strategy needs them. A tick therefore costs the two batched round-trips plus +//! one per cluster needing a live signal — bounded by the managed-cluster count, +//! not constant. Batching the per-cluster pulls is left for when the controller +//! actually moves off-process. + +use std::collections::BTreeSet; +use std::time::Duration; + +use async_trait::async_trait; +use mz_compute_types::config::ComputeReplicaLogging; +use mz_controller_types::{ClusterId, ReplicaId}; +use mz_repr::refresh_schedule::RefreshSchedule; +use mz_repr::{GlobalId, Timestamp}; +use timely::progress::Antichain; + +/// The config shape of a replica: the dimensions a reconfiguration changes and +/// that the reconcile kernel matches desired slots against actual replicas by. +/// +/// Two replicas with equal shape are interchangeable for the purpose of +/// satisfying a desired slot. `availability_zones` is the provisioned AZ pool +/// (order-insensitive — compared as a set), so an `AVAILABILITY ZONES` +/// divergence is a shape difference. +#[derive(Clone, Debug)] +pub struct ReplicaShape { + pub size: String, + pub availability_zones: Vec, + pub logging: ComputeReplicaLogging, +} + +impl ReplicaShape { + /// Whether two shapes are interchangeable. `availability_zones` is compared + /// as a set so provisioning order does not matter. + pub fn matches(&self, other: &ReplicaShape) -> bool { + self.size == other.size + && self.logging == other.logging + && self.availability_zones.iter().collect::>() + == other.availability_zones.iter().collect::>() + } +} + +/// A replica that actually exists on a cluster, as observed through the ctx. +#[derive(Clone, Debug)] +pub struct ObservedReplica { + pub replica_id: ReplicaId, + pub name: String, + pub shape: ReplicaShape, +} + +/// An in-flight graceful reconfiguration record, mirrored from durable state. +/// +/// Opaque to the kernel; the graceful strategy interprets it. Present here so a +/// tick can read it as part of the cluster state and so the compare-and-append +/// guard can carry it as the `expected` value. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ReconfigurationRecord { + pub target: ReconfigurationTarget, + pub deadline: Timestamp, + /// What to do once the deadline passes with the target not yet hydrated. + pub on_timeout: OnTimeout, +} + +/// The action a graceful reconfiguration applies once its `deadline` passes with +/// the target replicas not yet hydrated. Success always takes precedence: a +/// hydrated target cuts over regardless of this. The controller's own mirror of +/// the durable `mz_sql::plan::OnTimeoutAction`, kept here so the pure crate need +/// not depend on the SQL layer. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum OnTimeout { + /// Cut over to the (not-yet-hydrated) target anyway and clear the record. + Commit, + /// Drop the target replica set, reverting to the pre-reconfiguration shape, + /// and clear the record without advancing the realized config. + Rollback, +} + +/// The full config shape a reconfiguration is moving the cluster to. Distinct +/// from [`ReplicaShape`] because it additionally carries `replication_factor` +/// (a cluster-level, not replica-level, dimension). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ReconfigurationTarget { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ComputeReplicaLogging, +} + +impl ReconfigurationTarget { + /// The per-replica shape of the target: everything but `replication_factor`. + pub fn shape(&self) -> ReplicaShape { + ReplicaShape { + size: self.size.clone(), + availability_zones: self.availability_zones.clone(), + logging: self.logging.clone(), + } + } +} + +/// An active hydration-burst record, mirrored from durable state. Opaque to the +/// kernel; the burst strategy interprets it. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct BurstRecord { + pub burst_size: String, + pub linger_duration: Duration, + pub steady_hydrated_at: Option, +} + +/// The user-configured autoscaling policy of a managed cluster, mirrored from +/// durable state. The controller's own mirror of `mz_sql::plan::AutoScalingStrategy`, +/// kept here so the pure crate need not depend on the SQL layer. +/// +/// Extensible: future strategies are additional optional sub-policies. v1 carries +/// only the `ON HYDRATION` burst policy. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct AutoScalingPolicy { + pub on_hydration: Option, +} + +/// The `ON HYDRATION` burst sub-policy: while some object on the cluster is not +/// hydrated on a steady replica, run one extra replica at `hydration_size` to +/// accelerate hydration, lingering for `linger_duration` after the steady set +/// hydrates. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct OnHydrationPolicy { + pub hydration_size: String, + /// `None` falls back to the system default linger when the burst strategy + /// writes its record. + pub linger_duration: Option, +} + +/// A managed cluster's scheduling policy, mirrored from durable state. The +/// controller's own mirror of `mz_sql::plan::ClusterSchedule`, kept here so the +/// pure crate need not depend on the SQL layer. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ClusterSchedule { + /// The cluster is user-managed: the implicit baseline owns the replica set + /// and `replication_factor` is the user's capacity knob. + Manual, + /// The cluster is scheduled `ON REFRESH`: the controller owns the replica + /// set, `replication_factor` is held at `0`, and the on-refresh strategy is + /// the sole contributor of replicas. `hydration_time_estimate` is how far + /// ahead of a refresh the cluster should turn on so it can rehydrate before + /// the refresh time. + Refresh { hydration_time_estimate: Duration }, +} + +/// One REFRESH materialized view bound to a scheduled cluster, as the on-refresh +/// strategy needs to see it. +/// +/// `write_frontier` is the MV's storage write frontier, carried with full +/// fidelity as the `Antichain` the storage controller reports. The strategy +/// compares it against the read timestamp (`less_than`) to decide whether the MV +/// still needs a refresh. For the compaction window it reads the frontier's lone +/// element via `as_option` to find the previous refresh time, falling back to the +/// schedule's last refresh on the empty/sealed frontier `[]`, mirroring the +/// legacy refresh policy. The frontier of a single-input total-order MV holds at +/// most one element. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct RefreshMvInfo { + /// The MV's writes-`GlobalId`: the identity the window decision records in + /// [`RefreshWindowDecision`] so the audit log can say which MVs kept the + /// cluster on. + pub id: GlobalId, + pub write_frontier: Antichain, + pub refresh_schedule: RefreshSchedule, +} + +/// The on-refresh strategy's per-tick window decision: which bound REFRESH MVs +/// keep a scheduled cluster on, and why. The window is open iff either list is +/// non-empty, so an open window always has an explanation. +/// +/// Carried as the `audit_detail` on the create decisions the open window +/// produces; the environment converts it to the audit log's +/// `scheduling_policies` detail. Plain ids and durations so the controller crate +/// stays free of audit-log vocabulary. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct RefreshWindowDecision { + /// MVs whose write frontier has not yet passed the (hydration-adjusted) read + /// timestamp: a refresh is due or imminent. + pub objects_needing_refresh: Vec, + /// MVs estimated to still need Persist compaction after their last refresh. + pub objects_needing_compaction: Vec, + /// The cluster's `HYDRATION TIME ESTIMATE` the refresh window was widened by. + pub hydration_time_estimate: Duration, +} + +impl RefreshWindowDecision { + /// Whether the refresh window is open: some MV still needs a refresh or + /// compaction time. + pub fn window_open(&self) -> bool { + !self.objects_needing_refresh.is_empty() || !self.objects_needing_compaction.is_empty() + } +} + +/// The live signals the on-refresh strategy reads to decide whether a scheduled +/// cluster is inside a refresh window: the current read timestamp, the +/// Persist-compaction time estimate, and the bound REFRESH MVs' frontiers and +/// schedules. +/// +/// Pulled on demand only for scheduled clusters; a MANUAL cluster carries `None` +/// and is never probed. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct RefreshWindowInputs { + /// The local oracle read timestamp the window decision is taken against. + pub read_ts: Timestamp, + /// How long after a refresh an MV is estimated to still need Persist + /// compaction, which also keeps the cluster on. + pub compaction_estimate: Duration, + /// The REFRESH MVs bound to the cluster. + pub refresh_mvs: Vec, +} + +/// The durable state of a single managed cluster plus its observed replicas, as +/// pulled through the ctx for one reconcile tick. +/// +/// This is the input every strategy reads. Unmanaged clusters are not +/// controller-owned and are not represented here. +#[derive(Clone, Debug)] +pub struct ClusterState { + pub cluster_id: ClusterId, + /// The realized config the cluster is currently serving. The implicit + /// baseline desires `replication_factor` replicas at this shape. + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ComputeReplicaLogging, + /// The cluster's scheduling policy. Drives whether the implicit baseline owns + /// the replica set (MANUAL) or the on-refresh strategy does (REFRESH). + pub schedule: ClusterSchedule, + /// The user-configured autoscaling policy, if any. Drives the hydration-burst + /// strategy. + pub auto_scaling_policy: Option, + /// In-flight graceful reconfiguration, if any. + pub reconfiguration: Option, + /// In-flight hydration burst, if any. + pub burst: Option, + /// Whether the hydration-burst strategy is enabled environment-wide (the + /// break-glass flag). A **config signal**, not durable cluster state, so it is + /// excluded from [`ClusterState::expected`]: the controller derives it fresh + /// each tick and a flip does not need to reject an in-flight decision. + pub burst_enabled: bool, + /// The system-default burst linger duration, written into a new `burst` record + /// when the policy's `linger_duration` is omitted. A config signal, excluded + /// from the witness for the same reason as `burst_enabled`. + pub default_burst_linger: Duration, + /// The replicas that actually exist on the cluster. + pub replicas: Vec, + /// Names of replicas physically on the cluster that the controller does *not* + /// own (INTERNAL / BILLED AS): excluded from [`Self::replicas`] so the kernel + /// neither counts nor drops them, but still off-limits as names for replicas + /// the controller creates. The name generator avoids these too, so a generated + /// `rN` can never collide with a user-attached replica that happens to use an + /// `rN` name. + pub reserved_replica_names: Vec, + /// The refresh-window live signals, populated only for scheduled clusters + /// (pulled on demand via [`ClusterControllerCtx::refresh_window_inputs`]); + /// `None` for MANUAL clusters, which are never probed. + pub refresh_window: Option, + /// Whether the cluster has at least one hydratable object (an index, + /// materialized view, ingestion source, or sink bound to it). The burst + /// strategy arms only when this holds: with zero objects there is nothing + /// a burst could accelerate, so a brand-new cluster never bursts at + /// creation. A **live signal** like [`ClusterState::hydrated_replicas`], + /// so it is excluded from [`ClusterState::expected`]. + /// + /// Populated on demand (via [`ClusterControllerCtx::has_hydratable_objects`]) + /// only for clusters where the burst strategy could arm this tick; `false` + /// otherwise, where no strategy consults it. + pub has_hydratable_objects: bool, + /// The replicas observed this tick to have *all* current collections on the + /// cluster hydrated. A **live signal**, not durable state, so it is excluded + /// from [`ClusterState::expected`] (the compare-and-append witness). + /// + /// Populated only for clusters where a strategy needs it (pulled on demand); + /// empty for steady clusters the controller never probes. + pub hydrated_replicas: BTreeSet, +} + +impl ClusterState { + /// The shape the implicit baseline desires: the realized config. + pub fn realized_shape(&self) -> ReplicaShape { + ReplicaShape { + size: self.size.clone(), + availability_zones: self.availability_zones.clone(), + logging: self.logging.clone(), + } + } + + /// The compare-and-append witness for decisions derived from this state: the + /// durable fields a concurrent `ALTER` could change out from under a tick. + pub fn expected(&self) -> ExpectedClusterState { + ExpectedClusterState { + size: self.size.clone(), + replication_factor: self.replication_factor, + availability_zones: self.availability_zones.clone(), + logging: self.logging.clone(), + schedule: self.schedule, + auto_scaling_policy: self.auto_scaling_policy.clone(), + reconfiguration: self.reconfiguration.clone(), + burst: self.burst.clone(), + } + } +} + +/// The durable cluster state a [`Decision`] was derived from. The apply path +/// re-reads it and rejects the batch if it no longer holds (compare-and-append), +/// so a user `ALTER` that lands mid-tick cannot have a stale controller decision +/// clobber it; the controller recomputes from the new state next tick. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ExpectedClusterState { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ComputeReplicaLogging, + /// The scheduling policy. A concurrent `ALTER ... SET (SCHEDULE = ...)` flips + /// which strategy owns the replica set, so it is part of the witness: a + /// scheduled→MANUAL change must reject an in-flight on-refresh decision. + pub schedule: ClusterSchedule, + /// The autoscaling policy. A concurrent `ALTER ... SET/RESET (AUTO SCALING + /// STRATEGY ...)` changes whether (and at what size) a burst is warranted, so + /// it is part of the witness: disabling burst, or changing its `HYDRATION + /// SIZE`, must reject an in-flight burst decision. + pub auto_scaling_policy: Option, + pub reconfiguration: Option, + pub burst: Option, +} + +/// A durable state mutation a strategy's `update_state` asks for: cut over the +/// realized config to a target and/or write or clear the reconfiguration/burst +/// records. The reconcile kernel pairs it with the [`ExpectedClusterState`] it +/// was derived from for the compare-and-append guard. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct StateWrite { + /// New realized config to cut over to. `None` leaves it unchanged. + pub new_size: Option, + pub new_replication_factor: Option, + pub new_availability_zones: Option>, + pub new_logging: Option, + /// Write (`Some(Some(_))`), clear (`Some(None)`), or leave unchanged + /// (`None`) the reconfiguration record. + pub reconfiguration: Option>, + /// Write, clear, or leave unchanged the burst record, as above. + pub burst: Option>, +} + +impl StateWrite { + /// Whether this write would actually mutate any durable field. + pub fn is_empty(&self) -> bool { + // Exhaustive destructure (no `..`): a field added to `StateWrite` is a + // compile error here until it's accounted for. + let StateWrite { + new_size, + new_replication_factor, + new_availability_zones, + new_logging, + reconfiguration, + burst, + } = self; + new_size.is_none() + && new_replication_factor.is_none() + && new_availability_zones.is_none() + && new_logging.is_none() + && reconfiguration.is_none() + && burst.is_none() + } +} + +/// A single command the controller emits for the environment to transact. The +/// apply path interprets these and turns them into catalog operations. +/// +/// Every variant carries the [`ExpectedClusterState`] the decision was derived +/// from. The apply path re-reads each target cluster and rejects the whole batch +/// if any state has since diverged (compare-and-append), so a user `ALTER` that +/// lands mid-tick cannot let a stale create or drop reshape the replica set +/// against the new config; the controller recomputes from the new state next +/// tick. +#[derive(Clone, Debug)] +pub enum Decision { + /// Create a replica of the given shape under a deterministic fresh name. + /// `reasons` records which strategies desired it (for audit attribution); + /// `audit_detail` carries the on-refresh window decision when that strategy + /// desired the shape, for the richer `scheduling_policies` audit detail. + CreateReplica { + cluster_id: ClusterId, + name: String, + shape: ReplicaShape, + reasons: Vec<&'static str>, + audit_detail: Option, + expected: ExpectedClusterState, + }, + /// Drop a specific existing replica. A drop happens exactly when no + /// strategy desires the replica, so it carries no strategy attribution; + /// the apply path audits every controller drop with the uniform `retired` + /// reason. + DropReplica { + cluster_id: ClusterId, + replica_id: ReplicaId, + expected: ExpectedClusterState, + }, + /// Apply a durable state write under a compare-and-append guard against + /// `expected`. + UpdateClusterState { + cluster_id: ClusterId, + expected: ExpectedClusterState, + write: StateWrite, + }, +} + +/// The outcome of applying one tick's batch of [`Decision`]s. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ApplyOutcome { + /// Every decision in the batch was transacted. + Applied, + /// At least one decision failed its compare-and-append guard. The whole + /// batch is rejected; the controller recomputes next tick. + Rejected, +} + +/// The strategy-agnostic pull/apply interface between the controller and its +/// environment. +/// +/// The controller depends on exactly this trait. Reads are batched and pulled +/// on demand; the single write applies a tick's batch under a compare-and-append +/// guard. Implementations marshal these to wherever the live signals live (for +/// v1, the Coordinator's catalog and compute/storage controllers, reached over a +/// channel from the controller's own task — hence the `Send` bound). +#[async_trait] +pub trait ClusterControllerCtx: Send { + /// The wall-clock time the strategies and reconcile kernel should treat as + /// "now". An implementation must keep this stable across a reconcile phase — + /// in practice by latching it at the [`Self::cluster_states`] read — so every + /// strategy and the kernel decide against one consistent time, not a clock + /// that drifts between calls within a tick. + fn now(&self) -> Timestamp; + + /// A consistent durable view of the given managed clusters and their + /// replicas. Clusters that do not exist or are unmanaged are omitted from + /// the result. + async fn cluster_states(&mut self, clusters: &[ClusterId]) -> Vec; + + /// The ids of all managed clusters the controller owns this tick. + async fn managed_cluster_ids(&mut self) -> Vec; + + /// Of `replicas` on `cluster`, which have *all* current (non-transient) + /// collections on the cluster hydrated. The returned set is a subset of + /// `replicas`. + /// + /// Pulled on demand: a tick asks only about the replicas it examines. The + /// controller probes a cluster's replicas only when a hydration-dependent + /// strategy needs the signal this tick — the graceful strategy while a + /// `reconfiguration` is in flight, the hydration-burst strategy while a burst + /// is warranted or in flight. + async fn hydrated_replicas( + &mut self, + cluster_id: ClusterId, + replicas: &[ReplicaId], + ) -> BTreeSet; + + /// Whether `cluster_id` has at least one hydratable object bound to it (an + /// index, materialized view, ingestion source, or sink — the + /// dataflow-backed items). + /// + /// This is a catalog-level approximation of "the hydration check has + /// something to count": the per-replica hydration signal treats some item + /// classes as trivially hydrated, so the two sets can disagree at the + /// margin. The mismatch is self-healing — if this reports objects but the + /// hydration check counts none of them, a steady replica reads hydrated + /// as soon as its (near-instant) introspection-log dataflows do, and the + /// burst record's linger clears it. + /// + /// Pulled on demand like [`Self::hydrated_replicas`]: the controller asks + /// only for clusters where the burst strategy could arm this tick. + async fn has_hydratable_objects(&mut self, cluster_id: ClusterId) -> bool; + + /// The refresh-window live signals for one scheduled cluster: the read + /// timestamp, the compaction estimate, and the bound REFRESH MVs' write + /// frontiers and schedules. Returns `None` for a cluster that is not + /// scheduled `ON REFRESH` (the on-refresh strategy never asks about a MANUAL + /// cluster). + /// + /// Pulled on demand the same way as [`Self::hydrated_replicas`]: the + /// controller probes a cluster only when the on-refresh strategy needs the + /// signal (i.e. the cluster is scheduled), so a steady MANUAL cluster never + /// pays for it. + async fn refresh_window_inputs(&mut self, cluster_id: ClusterId) + -> Option; + + /// Apply a tick's batch of decisions under their compare-and-append guards. + /// Each decision carries the [`ExpectedClusterState`] it was derived from; + /// the implementation re-reads every target cluster and, if any has since + /// diverged, returns [`ApplyOutcome::Rejected`] without transacting anything. + /// Otherwise the batch's catalog operations are transacted together. + async fn apply(&mut self, decisions: Vec) -> ApplyOutcome; +} diff --git a/src/cluster-controller/src/lib.rs b/src/cluster-controller/src/lib.rs new file mode 100644 index 0000000000000..18a40a1798346 --- /dev/null +++ b/src/cluster-controller/src/lib.rs @@ -0,0 +1,497 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +//! The cluster controller: the single decision-maker for the replica set of +//! every managed cluster. +//! +//! It is a **reconciler**. Each tick it reads desired cluster state and live +//! signals through the [`ClusterControllerCtx`] seam, runs a set of pure +//! [`Strategy`]s, unions their desired contributions, diffs that against the +//! actual replica set, and emits the create/drop and durable-state-write +//! [`Decision`]s that close the gap. It holds no in-memory state: the source of +//! truth is always the catalog plus live signals, pulled fresh each tick. +//! +//! The crate is **pure** — it depends only on primitive id/shape types and the +//! [`ClusterControllerCtx`] trait, never on the adapter or catalog. That seam is +//! what makes the controller testable against a fake implementation and +//! extractable later without touching controller code. +//! +//! # The reconcile tick +//! +//! Each tick reconciles every managed cluster in two phases separated by a +//! barrier: +//! +//! 1. **`update_state`.** Run every strategy's [`Strategy::update_state`], +//! collect the durable writes (cut-overs, record writes/clears) as +//! [`Decision::UpdateClusterState`]s, and apply them under their +//! compare-and-append guards, awaiting confirmation. +//! 2. **`desired_replicas`.** With those writes applied, re-read state, run +//! every strategy's [`Strategy::desired_replicas`], union the contributions +//! (the implicit baseline included), match by [`ReplicaShape`] against the +//! actual replicas, and emit the creates and drops that close the gap. +//! +//! Every [`Decision`] — the phase-1 writes and the phase-2 creates/drops alike — +//! carries the durable state it was derived from, and the apply path transacts a +//! batch only if that state still holds (compare-and-append). This is what keeps +//! a create or drop derived from a pre-`ALTER` snapshot from reshaping the +//! replica set against the config the `ALTER` has since established; on a +//! rejection the controller recomputes from the new state next tick. +//! +//! Commands name explicit replicas, so re-emission across a lagging view or a +//! restart is harmless: a create of a name that already exists and a drop of one +//! already gone are both no-ops. +//! +//! [`ClusterControllerCtx`]: crate::ctx::ClusterControllerCtx +//! [`ReplicaShape`]: crate::ctx::ReplicaShape + +pub mod ctx; +pub mod strategy; + +use std::collections::BTreeSet; + +use crate::ctx::{ + ApplyOutcome, ClusterControllerCtx, ClusterState, Decision, ObservedReplica, + RefreshWindowDecision, ReplicaShape, +}; +use crate::strategy::{ + BaselineStrategy, DesiredReplica, GracefulReconfigurationStrategy, HydrationBurstStrategy, + OnRefreshStrategy, Strategy, +}; + +/// The cluster controller. Holds the (stateless) set of strategies and drives a +/// reconcile tick against a [`ClusterControllerCtx`]. +pub struct ClusterController { + strategies: Vec>, +} + +impl Default for ClusterController { + fn default() -> Self { + Self::new() + } +} + +impl ClusterController { + /// A controller with the full set of strategies; each strategy's rustdoc + /// describes when it engages. + pub fn new() -> Self { + Self { + strategies: vec![ + Box::new(BaselineStrategy), + Box::new(GracefulReconfigurationStrategy), + Box::new(OnRefreshStrategy), + Box::new(HydrationBurstStrategy), + ], + } + } + + /// Run one reconcile tick over every managed cluster the ctx reports; see + /// the module docs for the two-phase structure. + pub async fn reconcile(&self, ctx: &mut dyn ClusterControllerCtx) { + let cluster_ids = ctx.managed_cluster_ids().await; + if cluster_ids.is_empty() { + return; + } + + // Phase 1: update_state. Collect every strategy's durable writes and + // apply them under their compare-and-append guards. + let mut states = ctx.cluster_states(&cluster_ids).await; + self.enrich_hydration(ctx, &mut states).await; + self.enrich_refresh_window(ctx, &mut states).await; + let now = ctx.now(); + let mut state_decisions = Vec::new(); + for state in &states { + if let Some(decision) = self.collect_state_write(state, now) { + state_decisions.push(decision); + } + } + + // Clusters whose phase-1 writes were rejected are skipped this tick: a + // rejection means a concurrent `ALTER` changed the durable state the + // write was derived from, so any create/drop derived from the same stale + // snapshot would be unsafe too. We recompute everything next tick. + let phase_1_wrote = !state_decisions.is_empty(); + let rejected = if !phase_1_wrote { + Vec::new() + } else { + match ctx.apply(state_decisions.clone()).await { + ApplyOutcome::Applied => Vec::new(), + ApplyOutcome::Rejected => state_decisions + .iter() + .filter_map(|decision| match decision { + Decision::UpdateClusterState { cluster_id, .. } => Some(*cluster_id), + // collect_state_write only ever produces UpdateClusterState. + Decision::CreateReplica { .. } | Decision::DropReplica { .. } => None, + }) + .collect(), + } + }; + + // Phase 2: desired_replicas. We re-read (and re-enrich) the cluster + // state when phase 1 wrote anything, so that a cut-over performed by + // those writes is visible before we diff the replica set against the + // realized config; if phase 1 wrote nothing the first read is still + // current and we reuse it as is. A stale diff would be harmless either + // way: every create/drop carries its `expected` and is rejected by the + // apply guard if the durable state has since diverged. + let states = if phase_1_wrote { + let mut states = ctx.cluster_states(&cluster_ids).await; + self.enrich_hydration(ctx, &mut states).await; + self.enrich_refresh_window(ctx, &mut states).await; + states + } else { + states + }; + let now = ctx.now(); + let mut replica_decisions = Vec::new(); + for state in &states { + if rejected.contains(&state.cluster_id) { + continue; + } + replica_decisions.extend(self.collect_replica_decisions(state, now)); + } + + if !replica_decisions.is_empty() { + // A rejection here is benign: every command names an explicit + // replica and is reconciled away next tick. We do not retry within + // the tick. + let _ = ctx.apply(replica_decisions).await; + } + } + + /// Populate each cluster's [`ClusterState::has_hydratable_objects`] and + /// [`ClusterState::hydrated_replicas`] live signals where a strategy will + /// consult them this tick (see [`Self::needs_hydration_signal`]). Probing is + /// per-cluster and not free, so a steady cluster with no reconfiguration and + /// no possible burst is never probed. + async fn enrich_hydration( + &self, + ctx: &mut dyn ClusterControllerCtx, + states: &mut [ClusterState], + ) { + for state in states.iter_mut() { + // The burst strategy arms only for a cluster with at least one + // hydratable object, so pull that bit first for arming candidates. + // Besides gating the arm condition itself, it lets us skip the + // hydration probe entirely for an object-less cluster nothing else + // needs probed. + if Self::burst_arming_candidate(state) { + state.has_hydratable_objects = ctx.has_hydratable_objects(state.cluster_id).await; + } + if !Self::needs_hydration_signal(state) { + continue; + } + let replica_ids: Vec<_> = state.replicas.iter().map(|r| r.replica_id).collect(); + if replica_ids.is_empty() { + continue; + } + state.hydrated_replicas = ctx.hydrated_replicas(state.cluster_id, &replica_ids).await; + } + } + + /// Whether the burst strategy could *arm* on this cluster this tick: no + /// burst record yet, but the cluster carries an `ON HYDRATION` policy, burst + /// is enabled env-wide, and the cluster is On. Exactly the condition under + /// which the strategy's arm branch consults the object-existence and + /// hydration signals. + fn burst_arming_candidate(state: &ClusterState) -> bool { + state.burst.is_none() + && state.burst_enabled + && state.replication_factor > 0 + && state + .auto_scaling_policy + .as_ref() + .is_some_and(|p| p.on_hydration.is_some()) + } + + /// Whether a strategy needs this cluster's per-replica hydration signal this + /// tick: a reconfiguration is in flight (graceful cut-over), a burst is in + /// flight (linger/re-arm lifecycle), or a burst could arm *and* the cluster + /// has something to hydrate — with zero hydratable objects the arm branch + /// never fires, so the probe would be wasted. + fn needs_hydration_signal(state: &ClusterState) -> bool { + if state.reconfiguration.is_some() || state.burst.is_some() { + return true; + } + Self::burst_arming_candidate(state) && state.has_hydratable_objects + } + + /// Populate each scheduled cluster's [`ClusterState::refresh_window`] live + /// signal. Only the on-refresh strategy consults it, and only for + /// non-MANUAL clusters, so a MANUAL cluster is never probed. + async fn enrich_refresh_window( + &self, + ctx: &mut dyn ClusterControllerCtx, + states: &mut [ClusterState], + ) { + for state in states.iter_mut() { + if matches!(state.schedule, crate::ctx::ClusterSchedule::Manual) { + continue; + } + state.refresh_window = ctx.refresh_window_inputs(state.cluster_id).await; + } + } + + /// Merge every strategy's `update_state` for one cluster into a single + /// [`Decision::UpdateClusterState`], or `None` if no strategy writes + /// anything. Strategies are additive and never contradict, so a field a + /// strategy leaves unset is taken from another strategy that sets it; if two + /// set the same field the later strategy wins (the baseline never sets any). + fn collect_state_write( + &self, + state: &ClusterState, + now: mz_repr::Timestamp, + ) -> Option { + let mut merged = crate::ctx::StateWrite::default(); + for strategy in &self.strategies { + // Exhaustive destructure (no `..`): a field added to `StateWrite` is a + // compile error here until its merge is spelled out. + let crate::ctx::StateWrite { + new_size, + new_replication_factor, + new_availability_zones, + new_logging, + reconfiguration, + burst, + } = strategy.update_state(state, now); + if new_size.is_some() { + merged.new_size = new_size; + } + if new_replication_factor.is_some() { + merged.new_replication_factor = new_replication_factor; + } + if new_availability_zones.is_some() { + merged.new_availability_zones = new_availability_zones; + } + if new_logging.is_some() { + merged.new_logging = new_logging; + } + if reconfiguration.is_some() { + merged.reconfiguration = reconfiguration; + } + if burst.is_some() { + merged.burst = burst; + } + } + if merged.is_empty() { + return None; + } + Some(Decision::UpdateClusterState { + cluster_id: state.cluster_id, + expected: state.expected(), + write: merged, + }) + } + + /// Diff the unioned desired set against the actual replicas of one cluster + /// and emit the create/drop decisions that close the gap. + fn collect_replica_decisions( + &self, + state: &ClusterState, + now: mz_repr::Timestamp, + ) -> Vec { + // Each strategy's contribution, tagged with the strategy name for + // attribution. + let contributions: Vec<(&'static str, Vec)> = self + .strategies + .iter() + .map(|strategy| (strategy.name(), strategy.desired_replicas(state, now))) + .collect(); + + reconcile_replicas(state, &contributions) + } +} + +/// The pure multiset union/diff kernel for one cluster: given each strategy's +/// desired replica slots and the actual replicas, match slots to replicas by +/// shape and emit the creates and drops that close the gap. +/// +/// Semantics: +/// - The desired set is the multiset **union** of every strategy's slots: a +/// given shape is desired `max` over strategies (not the sum), since a replica +/// of that shape satisfies every strategy that wants one. This is what makes a +/// replica survive iff *some* strategy desires its shape. +/// - For each shape, if actual count < desired count we create the difference; +/// if actual count > desired count we drop the difference, picking specific +/// excess replicas. A replica of a shape no strategy desires is dropped. +/// - Creates carry the names of the strategies that desired the shape, plus the +/// merged `audit_detail` of the slots behind it (per shape, first `Some` wins — +/// only the on-refresh strategy produces one today, so the rule is documented, +/// not load-bearing); drops carry no attribution — a drop happens exactly when +/// no strategy desires the replica. +fn reconcile_replicas( + state: &ClusterState, + contributions: &[(&'static str, Vec)], +) -> Vec { + // Desired count per shape = max over strategies of how many that strategy + // wants of the shape, the union of which strategies want it, and the merged + // audit detail of the slots. + let mut desired: Vec = Vec::new(); + for (name, slots) in contributions { + // How many of each shape this strategy wants, and the detail (if any) it + // attached to the shape's slots. + let mut per_shape: Vec<(ReplicaShape, usize, Option)> = Vec::new(); + for slot in slots { + match per_shape + .iter_mut() + .find(|(s, _, _)| s.matches(&slot.shape)) + { + Some((_, count, detail)) => { + *count += 1; + if detail.is_none() { + *detail = slot.audit_detail.clone(); + } + } + None => per_shape.push((slot.shape.clone(), 1, slot.audit_detail.clone())), + } + } + for (shape, count, audit_detail) in per_shape { + match desired.iter_mut().find(|d| d.shape.matches(&shape)) { + Some(existing) => { + existing.count = existing.count.max(count); + if !existing.reasons.contains(name) { + existing.reasons.push(*name); + } + if existing.audit_detail.is_none() { + existing.audit_detail = audit_detail; + } + } + None => desired.push(DesiredShape { + shape, + count, + reasons: vec![*name], + audit_detail, + }), + } + } + } + + // Bucket the actual replicas by shape. + let mut actual_by_shape: Vec<(ReplicaShape, Vec<&ObservedReplica>)> = Vec::new(); + for replica in &state.replicas { + match actual_by_shape + .iter_mut() + .find(|(s, _)| s.matches(&replica.shape)) + { + Some((_, replicas)) => replicas.push(replica), + None => actual_by_shape.push((replica.shape.clone(), vec![replica])), + } + } + + let mut decisions = Vec::new(); + + // Track existing names so freshly-created replicas avoid collisions: both the + // controller-owned replicas and the non-owned (INTERNAL / BILLED AS) names the + // observation reserves, so a generated name can never collide with a replica + // already on the cluster. + let used_names: Vec<&str> = state + .replicas + .iter() + .map(|r| r.name.as_str()) + .chain(state.reserved_replica_names.iter().map(String::as_str)) + .collect(); + let mut name_gen = ReplicaNameGen::new(&used_names); + + // The compare-and-append witness for every create/drop this tick emits for + // the cluster: the apply path rejects the batch if the cluster's durable + // state has diverged from what we diffed against (e.g. a concurrent `ALTER`), + // so a stale create/drop can never reshape the replica set against the new + // config. + let expected = state.expected(); + + // Creates: for each desired shape, fill the gap below its desired count. + for d in &desired { + let actual_count = actual_by_shape + .iter() + .find(|(s, _)| s.matches(&d.shape)) + .map(|(_, replicas)| replicas.len()) + .unwrap_or(0); + for _ in actual_count..d.count { + decisions.push(Decision::CreateReplica { + cluster_id: state.cluster_id, + name: name_gen.next_name(), + shape: d.shape.clone(), + reasons: d.reasons.clone(), + // Multiple creates of one shape in a tick share the same window + // decision, as the legacy scheduler's events did. + audit_detail: d.audit_detail.clone(), + expected: expected.clone(), + }); + } + } + + // Drops: any actual replica beyond the desired count for its shape, plus + // every replica of a shape no strategy desires. + for (shape, replicas) in &actual_by_shape { + let desired_count = desired + .iter() + .find(|d| d.shape.matches(shape)) + .map(|d| d.count) + .unwrap_or(0); + for replica in replicas.iter().skip(desired_count) { + decisions.push(Decision::DropReplica { + cluster_id: state.cluster_id, + replica_id: replica.replica_id, + expected: expected.clone(), + }); + } + } + + decisions +} + +/// A shape the union desires, how many, which strategies wanted it, and the +/// merged audit detail of the slots behind it. +struct DesiredShape { + shape: ReplicaShape, + count: usize, + reasons: Vec<&'static str>, + audit_detail: Option, +} + +/// Generates deterministic fresh replica names that avoid a set of in-use names. +/// +/// The controller derives names from the observed actual set rather than +/// renaming existing replicas, which keeps re-emission harmless. The concrete +/// naming convention (the `rNN` managed-replica scheme) is the environment's; the +/// kernel only needs distinct, stable-per-tick names, so it uses a simple +/// monotonic scheme starting past the highest observed `rNN` index, and never +/// below `r1` since managed-replica names are 1-based. +struct ReplicaNameGen { + next: u32, + used: BTreeSet, +} + +impl ReplicaNameGen { + fn new(used: &[&str]) -> Self { + let mut highest = 1; + for name in used { + if let Some(idx) = name.strip_prefix('r').and_then(|n| n.parse::().ok()) { + highest = highest.max(idx + 1); + } + } + Self { + next: highest, + used: used.iter().map(|n| n.to_string()).collect(), + } + } + + fn next_name(&mut self) -> String { + loop { + let name = format!("r{}", self.next); + self.next += 1; + if !self.used.contains(&name) { + self.used.insert(name.clone()); + return name; + } + } + } +} + +#[cfg(test)] +mod tests; diff --git a/src/cluster-controller/src/strategy.rs b/src/cluster-controller/src/strategy.rs new file mode 100644 index 0000000000000..5c9c246444957 --- /dev/null +++ b/src/cluster-controller/src/strategy.rs @@ -0,0 +1,558 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +//! The pure strategy interface and the strategy implementations. +//! +//! A strategy is two pure functions over `(observed cluster state, now)`: +//! +//! - [`Strategy::update_state`] returns the durable writes the strategy wants +//! (cut-overs, record writes/clears). The controller transacts these in the +//! tick's first phase. +//! - [`Strategy::desired_replicas`] returns the replica slots the strategy +//! contributes to the cluster's desired set. The controller unions every +//! strategy's contribution in the tick's second phase. +//! +//! Both are pure: same inputs, same output, no I/O. The controller is the sole +//! mutator. Strategies never touch the [`ClusterControllerCtx`]; the controller +//! assembles their inputs by pulling through it. +//! +//! [`ClusterControllerCtx`]: crate::ctx::ClusterControllerCtx + +use mz_repr::{Timestamp, TimestampManipulation}; + +use crate::ctx::{ + BurstRecord, ClusterSchedule, ClusterState, OnTimeout, ReconfigurationRecord, + RefreshWindowDecision, RefreshWindowInputs, ReplicaShape, StateWrite, +}; + +/// A replica slot a strategy desires this tick. The reconcile kernel unions +/// slots across strategies and matches them by [`ReplicaShape`] against the +/// actual replica set. +#[derive(Clone, Debug)] +pub struct DesiredReplica { + pub shape: ReplicaShape, + /// The window decision behind the slot, set only by the on-refresh strategy. + /// Carried onto the create decision a slot may produce, for the audit log's + /// `scheduling_policies` detail. + pub audit_detail: Option, +} + +/// One cluster-autoscaling strategy: a pair of pure functions the controller +/// runs each tick. See the module docs. +/// +/// `Send + Sync` so the controller (which holds a set of boxed strategies) can +/// run on its own task. +pub trait Strategy: Send + Sync { + /// A stable identifier used in audit attribution (which strategies desired a + /// create; drops carry no attribution). + fn name(&self) -> &'static str; + + /// The durable writes this strategy wants for `state` at time `now`. The + /// default is no write, which suits a strategy that only ever contributes + /// replicas (like the baseline). + fn update_state(&self, _state: &ClusterState, _now: Timestamp) -> StateWrite { + StateWrite::default() + } + + /// The replica slots this strategy contributes to `state`'s desired set at + /// time `now`. + fn desired_replicas(&self, state: &ClusterState, now: Timestamp) -> Vec; +} + +/// The implicit baseline strategy, always present. +/// +/// Desires `replication_factor` replicas at the cluster's realized shape +/// (`cluster.size` plus its AZ pool and logging). It holds the steady-state set +/// so that the policy strategies can be purely additive — they only ever add to +/// the baseline. With only the baseline engaged, the desired set equals the +/// realized set, so a steady-state managed cluster reconciles to no decisions. +/// +/// The baseline holds the set only for MANUAL clusters. On a scheduled cluster +/// the controller — not the user's `replication_factor` — owns the replica set, +/// so the baseline desires nothing there and the on-refresh strategy is the sole +/// contributor. (The on-refresh strategy also normalizes a scheduled cluster's +/// `replication_factor` to `0` via `update_state`, so the two views agree after +/// the first tick regardless.) +#[derive(Clone, Copy, Debug, Default)] +pub struct BaselineStrategy; + +/// The audit-attribution name of the baseline strategy. +pub const BASELINE_STRATEGY_NAME: &str = "baseline"; + +impl Strategy for BaselineStrategy { + fn name(&self) -> &'static str { + BASELINE_STRATEGY_NAME + } + + fn desired_replicas(&self, state: &ClusterState, _now: Timestamp) -> Vec { + if !matches!(state.schedule, ClusterSchedule::Manual) { + return Vec::new(); + } + let shape = state.realized_shape(); + (0..state.replication_factor) + .map(|_| DesiredReplica { + shape: shape.clone(), + audit_detail: None, + }) + .collect() + } +} + +/// The graceful (zero-downtime) reconfiguration strategy. +/// +/// Engaged whenever the durable `reconfiguration` record is present. It desires +/// `target.replication_factor` replicas at the target shape *in addition* to +/// the baseline's realized-shape replicas, so both sets serve while the new one +/// hydrates. Once the target replicas are all present and hydrated, +/// `update_state` cuts over: the realized config advances to the target, the +/// record clears, and the old replicas fall out of the union and are dropped. +/// Success takes precedence over the deadline. On a timeout, `Commit` cuts +/// over to the un-hydrated target anyway while `Rollback` (the default) clears +/// the record without touching the realized config and stops desiring the +/// target replicas, reverting to the pre-reconfiguration set; the timeout's +/// papertrail is the audit event the clear induces. +/// +/// Both functions are pure over the observed [`ClusterState`]; hydration is read +/// from [`ClusterState::hydrated_replicas`], which the controller populates by +/// pulling the live signal while a reconfiguration is in flight. +#[derive(Clone, Copy, Debug, Default)] +pub struct GracefulReconfigurationStrategy; + +/// The audit-attribution name of the graceful reconfiguration strategy. +pub const GRACEFUL_RECONFIGURATION_STRATEGY_NAME: &str = "graceful-reconfiguration"; + +impl GracefulReconfigurationStrategy { + /// Whether the target replicas are all present and hydrated: there are at + /// least `target.replication_factor` replicas of the target shape and every + /// such replica reports hydrated. + /// + /// Requiring *all* target replicas (not just one) is deliberate: a partial + /// cut-over would not satisfy the high-availability guarantee of + /// `replication_factor > 1` at any single size, so we wait for the full target + /// set before retiring the old one. + fn target_hydrated(&self, state: &ClusterState, record: &ReconfigurationRecord) -> bool { + let target_shape = record.target.shape(); + let target_replicas: Vec<_> = state + .replicas + .iter() + .filter(|r| r.shape.matches(&target_shape)) + .collect(); + let target_rf = usize::try_from(record.target.replication_factor).unwrap_or(usize::MAX); + target_replicas.len() >= target_rf + && target_replicas + .iter() + .all(|r| state.hydrated_replicas.contains(&r.replica_id)) + } +} + +impl Strategy for GracefulReconfigurationStrategy { + fn name(&self) -> &'static str { + GRACEFUL_RECONFIGURATION_STRATEGY_NAME + } + + fn update_state(&self, state: &ClusterState, now: Timestamp) -> StateWrite { + let Some(record) = &state.reconfiguration else { + return StateWrite::default(); + }; + + // Cut over — advancing the realized config to the target and clearing the + // record — on either of two conditions: + // 1. the target replicas are all present and hydrated (success, which + // takes precedence over the deadline regardless of `on_timeout`), or + // 2. the deadline has passed un-hydrated and `on_timeout` is `Commit` + // (cut over to the not-yet-hydrated target anyway). + let hydrated = self.target_hydrated(state, record); + let commit_on_timeout = + now > record.deadline && matches!(record.on_timeout, OnTimeout::Commit); + if hydrated || commit_on_timeout { + return StateWrite { + new_size: Some(record.target.size.clone()), + new_replication_factor: Some(record.target.replication_factor), + new_availability_zones: Some(record.target.availability_zones.clone()), + new_logging: Some(record.target.logging.clone()), + reconfiguration: Some(None), + ..Default::default() + }; + } + + // Past the deadline un-hydrated under `Rollback`: abandon the + // reconfiguration by clearing the record while leaving the realized + // config untouched. The clear is the durable transition the audit + // `timed-out` event classifies (a clear that does not advance the + // realized config can only be this), so the timeout is in the history + // exactly once. With the record gone the strategy disengages and the + // baseline alone shapes the cluster, dropping the in-flight target set. + if now > record.deadline && matches!(record.on_timeout, OnTimeout::Rollback) { + return StateWrite { + reconfiguration: Some(None), + ..Default::default() + }; + } + + // Before the deadline: keep waiting. + StateWrite::default() + } + + fn desired_replicas(&self, state: &ClusterState, now: Timestamp) -> Vec { + let Some(record) = &state.reconfiguration else { + return Vec::new(); + }; + + // Past the deadline with the target not hydrated under `Rollback`: stop + // contributing the target replicas. `update_state` clears the record in + // this same tick's first phase, so this usually never fires against a + // re-read state — it matters when that clear could not land (e.g. the + // compare-and-append witness was stale), keeping the rollback's replica + // drops prompt rather than waiting for the clear to retry. Everything + // else — before the deadline, awaiting a success cut-over past it, or a + // `Commit` cut-over `update_state` performs this tick — keeps desiring + // the target set. + let timed_out = now > record.deadline && !self.target_hydrated(state, record); + if timed_out && matches!(record.on_timeout, OnTimeout::Rollback) { + return Vec::new(); + } + + let shape = record.target.shape(); + (0..record.target.replication_factor) + .map(|_| DesiredReplica { + shape: shape.clone(), + audit_detail: None, + }) + .collect() + } +} + +/// The `ON REFRESH` scheduling strategy. +/// +/// Engaged for clusters with a non-MANUAL [`ClusterSchedule`]. It contributes one +/// replica at the cluster's realized shape while the cluster is inside a refresh +/// window, and nothing otherwise. The window decision keys on the bound REFRESH +/// materialized views' write frontiers, their refresh schedules, the configured +/// hydration-time estimate, and the current read timestamp — the same signals the +/// legacy scheduler reads — all carried in [`RefreshWindowInputs`]. +/// +/// The controller — not the user's `replication_factor` — owns a scheduled +/// cluster's replica set, so [`Strategy::update_state`] normalizes the realized +/// `replication_factor` to `0`. This is self-healing (no migration needed to +/// enable the controller) and makes `mz_clusters.replication_factor` read `0` for +/// a scheduled cluster, with `mz_cluster_replicas` authoritative for what is +/// actually running. +/// +/// NB: the decision is re-derived purely from the live signals each tick; there +/// is no "all policies have decided" latch like `cluster_scheduling.rs` needs. +/// That scheduler collects policy decisions asynchronously and across ticks, so +/// turning a cluster off is only safe once every policy has reported. We pull a +/// complete decision from durable + storage state on every tick, so the first +/// tick after a restart already decides from the same inputs as a steady tick. +#[derive(Clone, Copy, Debug, Default)] +pub struct OnRefreshStrategy; + +/// The audit-attribution name of the on-refresh scheduling strategy. +pub const ON_REFRESH_STRATEGY_NAME: &str = "on-refresh"; + +/// A millisecond [`Duration`] as a [`Timestamp`], saturating at [`Timestamp::MAX`] +/// on overflow. +/// +/// Both inputs (the cluster's hydration-time estimate and the system compaction +/// estimate) are validated to fit during planning/config, so the saturation is +/// not expected to trigger. Saturating rather than panicking is deliberate: this +/// is a pure strategy kernel, and clamping an out-of-range estimate to the +/// largest representable window degrades to "keep the cluster on" rather than +/// crashing the controller on a bad input. +/// +/// [`Duration`]: std::time::Duration +fn duration_to_ts(duration: std::time::Duration) -> Timestamp { + Timestamp::try_from(duration).unwrap_or(Timestamp::MAX) +} + +impl OnRefreshStrategy { + /// The window decision for the cluster: which bound REFRESH MVs either still + /// need a refresh (their write frontier has not advanced past the read + /// timestamp adjusted by the hydration-time estimate) or are estimated to + /// still need Persist compaction after their last refresh. The cluster + /// should be On iff either list is non-empty + /// ([`RefreshWindowDecision::window_open`]), so an open window always names + /// the MVs that explain it. + /// + /// `hydration_time_estimate` comes from the schedule; the remaining signals + /// come from `inputs`. With no bound REFRESH MVs both lists are empty and + /// the cluster is Off. + fn window_decision( + &self, + hydration_time_estimate: std::time::Duration, + inputs: &RefreshWindowInputs, + ) -> RefreshWindowDecision { + // 1. Needs refresh: write_frontier < read_ts + hydration_time_estimate. + // The cluster is turned on `hydration_time_estimate` ahead of a refresh + // so it can rehydrate before the refresh time. + let read_ts_adjusted = inputs + .read_ts + .step_forward_by(&duration_to_ts(hydration_time_estimate)); + let objects_needing_refresh = inputs + .refresh_mvs + .iter() + .filter(|mv| mv.write_frontier.less_than(&read_ts_adjusted)) + .map(|mv| mv.id) + .collect(); + + // 2. Needs compaction: prev_refresh + compaction_estimate > read_ts. We + // keep the cluster on for a while after a refresh so Persist can compact. + let compaction_estimate = duration_to_ts(inputs.compaction_estimate); + let objects_needing_compaction = inputs + .refresh_mvs + .iter() + .filter(|mv| { + // `prev_refresh` is None in two cases, both meaning "schedule no + // compaction time now": no refresh has happened yet (no frontier to + // round down and no past `AT`), or a `REFRESH EVERY` MV with an empty + // write frontier (we have no wall-clock handle on its last refresh). + let prev_refresh = match mv.write_frontier.as_option() { + Some(frontier) => frontier.round_down_minus_1(&mv.refresh_schedule), + None => mv.refresh_schedule.last_refresh(), + }; + prev_refresh + .is_some_and(|prev| prev.step_forward_by(&compaction_estimate) > inputs.read_ts) + }) + .map(|mv| mv.id) + .collect(); + + RefreshWindowDecision { + objects_needing_refresh, + objects_needing_compaction, + hydration_time_estimate, + } + } +} + +impl Strategy for OnRefreshStrategy { + fn name(&self) -> &'static str { + ON_REFRESH_STRATEGY_NAME + } + + fn update_state(&self, state: &ClusterState, _now: Timestamp) -> StateWrite { + // The controller owns a scheduled cluster's replica set, so hold the + // realized `replication_factor` at `0`. A stale non-zero value (e.g. left + // by the legacy scheduler toggling 0↔1) would otherwise have the implicit + // baseline desire a replica the on-refresh strategy does not — a flap. + // Only write when it is actually non-zero, to keep steady ticks no-ops. + if matches!(state.schedule, ClusterSchedule::Manual) || state.replication_factor == 0 { + return StateWrite::default(); + } + StateWrite { + new_replication_factor: Some(0), + ..Default::default() + } + } + + fn desired_replicas(&self, state: &ClusterState, _now: Timestamp) -> Vec { + let ClusterSchedule::Refresh { + hydration_time_estimate, + } = state.schedule + else { + return Vec::new(); + }; + // The refresh-window signals are pulled only for scheduled clusters; if + // they are absent we cannot decide a window, so contribute nothing (the + // next tick re-pulls). + let Some(inputs) = &state.refresh_window else { + return Vec::new(); + }; + let decision = self.window_decision(hydration_time_estimate, inputs); + if !decision.window_open() { + return Vec::new(); + } + // One replica at the realized shape (`cluster.size` plus the cluster's AZ + // pool and logging), matching what the legacy scheduler brings up. The + // window decision rides along so the create it may produce can carry the + // audit detail. + vec![DesiredReplica { + shape: state.realized_shape(), + audit_detail: Some(decision), + }] + } +} + +/// The hydration-burst strategy. +/// +/// Engaged for clusters whose `AUTO SCALING STRATEGY` sets `ON HYDRATION`. While +/// the cluster is On and there exists an object on it that no steady-state +/// (realized-config) replica has hydrated, it runs one extra replica at the +/// configured `HYDRATION SIZE` to accelerate hydration; the burst replica tears +/// down a `linger_duration` after the steady set first hydrates. Zero objects +/// make the condition vacuously unsatisfied, so a brand-new cluster never bursts +/// before its first object lands. The burst is keyed entirely on the presence of a +/// durable `burst` record (written/cleared by [`Strategy::update_state`]); the +/// burst replica is an ordinary replica — the union/diff reconciler creates and +/// drops it by shape+count with no special identity. +/// +/// There is deliberately no TTL on the burst replica: if the steady set can never +/// hydrate at `cluster.size`, the burst stays up indefinitely (the cluster runs +/// permanently oversized, visible in billing and the audit log) — the accepted +/// trade for keeping the cluster serving. Burst is **not** suppressed during a +/// reconfiguration; the two coexist. +/// +/// Steady-replica hydration is read from [`ClusterState::hydrated_replicas`], which +/// the controller populates by pulling the live signal while a burst is warranted +/// or in flight. +#[derive(Clone, Copy, Debug, Default)] +pub struct HydrationBurstStrategy; + +/// The audit-attribution name of the hydration-burst strategy. +pub const HYDRATION_BURST_STRATEGY_NAME: &str = "hydration-burst"; + +impl HydrationBurstStrategy { + /// The cluster's active `ON HYDRATION` policy, but only when burst is permitted + /// at all: the break-glass flag is on and the cluster is On (`rf > 0`). `None` + /// otherwise — no burst is warranted and any existing record is torn down. + fn active_policy<'a>( + &self, + state: &'a ClusterState, + ) -> Option<&'a crate::ctx::OnHydrationPolicy> { + if !state.burst_enabled || state.replication_factor == 0 { + return None; + } + state.auto_scaling_policy.as_ref()?.on_hydration.as_ref() + } + + /// Whether at least one steady-state (realized-config) replica reports all + /// current objects hydrated. On a cluster with zero user objects a replica + /// reads hydrated once its (near-instant) introspection-log dataflows + /// hydrate — the hydration signal counts those too; false when no steady + /// replica reports at all (absent, or not yet registered with the compute + /// controller). + fn steady_hydrated(&self, state: &ClusterState) -> bool { + let steady_shape = state.realized_shape(); + state + .replicas + .iter() + .filter(|r| r.shape.matches(&steady_shape)) + .any(|r| state.hydrated_replicas.contains(&r.replica_id)) + } +} + +impl Strategy for HydrationBurstStrategy { + fn name(&self) -> &'static str { + HYDRATION_BURST_STRATEGY_NAME + } + + fn update_state(&self, state: &ClusterState, now: Timestamp) -> StateWrite { + let clear = StateWrite { + burst: Some(None), + ..Default::default() + }; + + // Cleanup precedence: a burst no longer warranted by current config tears + // down regardless of linger. `active_policy` is `None` when burst is + // disabled / the cluster is off / no policy; a `HYDRATION SIZE` change makes + // the record's size stale (a fresh record at the new size is written below + // on a later tick once warranted). + let Some(policy) = self.active_policy(state) else { + return if state.burst.is_some() { + clear + } else { + StateWrite::default() + }; + }; + if let Some(record) = &state.burst { + if record.burst_size != policy.hydration_size { + return clear; + } + } + + let steady_hydrated = self.steady_hydrated(state); + + match &state.burst { + // No record: arm a burst only while some object exists that the + // steady set has not hydrated. The object gate is what keeps an + // object-less cluster from bursting: without it, an absent or + // not-yet-registered steady replica reads as un-hydrated and a + // brand-new cluster would burst at creation with nothing to + // accelerate. It also makes `steady_hydrated`'s zero-object + // ambiguity (true once a reporting replica's log dataflows hydrate, + // false for an absent one) irrelevant here. The record-present arms + // below deliberately do not consult the gate: if all objects are + // dropped mid-burst, the steady set reads hydrated as soon as a + // replica's log dataflows do and the linger clears the record. + None => { + if steady_hydrated || !state.has_hydratable_objects { + StateWrite::default() + } else { + let linger_duration = + policy.linger_duration.unwrap_or(state.default_burst_linger); + StateWrite { + burst: Some(Some(BurstRecord { + burst_size: policy.hydration_size.clone(), + linger_duration, + steady_hydrated_at: None, + })), + ..Default::default() + } + } + } + // Record present: drive the linger/teardown/re-arm lifecycle. + Some(record) => { + match (record.steady_hydrated_at, steady_hydrated) { + // Steady set hydrated and the linger has elapsed: tear down. + // A linger so large it overflows the timestamp space reads as + // never-elapsed (hold the burst), matching `duration_to_ts`'s + // degrade-to-keep-on intent and keeping the kernel panic-free. + (Some(hydrated_at), true) + if now + > hydrated_at + .try_step_forward_by(&duration_to_ts(record.linger_duration)) + .unwrap_or(Timestamp::MAX) => + { + clear + } + // Steady set hydrated, linger not yet elapsed: hold. + (Some(_), true) => StateWrite::default(), + // First observation of the steady set hydrated: stamp the + // linger start. + (None, true) => StateWrite { + burst: Some(Some(BurstRecord { + steady_hydrated_at: Some(now), + ..record.clone() + })), + ..Default::default() + }, + // The steady set went un-hydrated again after we had stamped a + // hydration time: re-arm so the linger restarts after the next + // successful hydration. + (Some(_), false) => StateWrite { + burst: Some(Some(BurstRecord { + steady_hydrated_at: None, + ..record.clone() + })), + ..Default::default() + }, + // Steady set still un-hydrated and never stamped: keep waiting. + (None, false) => StateWrite::default(), + } + } + } + } + + fn desired_replicas(&self, state: &ClusterState, _now: Timestamp) -> Vec { + // Keyed purely on the record's presence: the cleanup arm of `update_state` + // clears a stale record, so a record present here always reflects a burst + // the current config still warrants. One replica at the burst size, with + // the cluster's AZ pool and logging (only the size differs from steady). + let Some(record) = &state.burst else { + return Vec::new(); + }; + vec![DesiredReplica { + shape: ReplicaShape { + size: record.burst_size.clone(), + availability_zones: state.availability_zones.clone(), + logging: state.logging.clone(), + }, + audit_detail: None, + }] + } +} diff --git a/src/cluster-controller/src/tests.rs b/src/cluster-controller/src/tests.rs new file mode 100644 index 0000000000000..4bbb150b01f51 --- /dev/null +++ b/src/cluster-controller/src/tests.rs @@ -0,0 +1,2562 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +//! Boundary and kernel tests. +//! +//! The headline boundary is the [`ClusterControllerCtx`] seam: we drive the +//! controller against a fake implementation and assert the reconcile loop is a +//! no-op for a steady cluster and that a compare-and-append conflict is rejected +//! and recovered. A handful of pure-kernel tests cover the multiset union/diff. + +use std::collections::{BTreeMap, BTreeSet}; +use std::time::Duration; + +use async_trait::async_trait; +use mz_compute_types::config::ComputeReplicaLogging; +use mz_controller_types::{ClusterId, ReplicaId}; +use mz_ore::cast::CastFrom; +use mz_repr::{GlobalId, Timestamp}; + +use crate::ClusterController; +use crate::ctx::{ + ApplyOutcome, AutoScalingPolicy, ClusterControllerCtx, ClusterSchedule, ClusterState, Decision, + ObservedReplica, RefreshWindowInputs, ReplicaShape, StateWrite, +}; +use crate::strategy::{DesiredReplica, Strategy}; + +fn cluster(n: u64) -> ClusterId { + ClusterId::user(n).expect("valid user cluster id") +} + +fn replica(n: u64) -> ReplicaId { + ReplicaId::User(n) +} + +fn shape(size: &str) -> ReplicaShape { + ReplicaShape { + size: size.to_string(), + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + } +} + +fn observed(replica_id: ReplicaId, name: &str, size: &str) -> ObservedReplica { + ObservedReplica { + replica_id, + name: name.to_string(), + shape: shape(size), + } +} + +/// Builds a MANUAL managed cluster state with the given realized size, +/// replication factor, and replicas. No reconfiguration or burst in flight. +/// `has_hydratable_objects` defaults to `true` so kernel-level scenarios that +/// are about replica hydration (not object existence) keep their meaning; +/// through the seam the field is irrelevant — `FakeCtx::cluster_states` +/// returns it at the adapter default and the controller's pull consults +/// `FakeCtx::has_hydratable_objects` instead. +fn state( + cluster_id: ClusterId, + size: &str, + replication_factor: u32, + replicas: Vec, +) -> ClusterState { + ClusterState { + cluster_id, + size: size.to_string(), + replication_factor, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + schedule: ClusterSchedule::Manual, + auto_scaling_policy: None, + reconfiguration: None, + burst: None, + burst_enabled: true, + default_burst_linger: Duration::ZERO, + replicas, + reserved_replica_names: Vec::new(), + hydrated_replicas: BTreeSet::new(), + refresh_window: None, + has_hydratable_objects: true, + } +} + +/// A fake [`ClusterControllerCtx`] over an in-memory map of cluster states. It +/// records the decisions each `apply` saw, and can be told to reject the next +/// `apply` once (simulating a compare-and-append conflict from a concurrent +/// `ALTER`). +struct FakeCtx { + now: Timestamp, + states: BTreeMap, + /// Each batch of decisions passed to `apply`, in order. + applied: Vec>, + /// If set, the next `apply` is rejected and this count decremented. + reject_next: usize, + /// If set, `apply` performs the real compare-and-append witness check: it + /// re-reads each decision's target and rejects the batch if any carried + /// `expected` no longer matches the stored durable state. Off by default so + /// the blunt `reject_next` counter drives most tests; on for the seam tests + /// that assert a specific witness *field* (e.g. `schedule`) actually guards a + /// decision, mirroring the adapter's `cluster_state_matches`. + witness_check: bool, + /// A concurrent `ALTER` to splice in just before the first `apply`: each + /// entry's `ClusterSchedule` is written onto the stored state, modeling an + /// `ALTER ... SET (SCHEDULE = ...)` that lands after the controller's read + /// but before its append. Combined with `witness_check`, this exercises the + /// `schedule` field of the compare-and-append witness end-to-end. + concurrent_schedule_alter: BTreeMap, + /// As `concurrent_schedule_alter`, but for the autoscaling policy: each + /// entry's value is written onto the stored state's `auto_scaling_policy` + /// before the witness check, modeling an `ALTER ... SET/RESET (AUTO SCALING + /// STRATEGY ...)` that lands mid-tick. Exercises the `auto_scaling_policy` + /// field of the witness. + concurrent_policy_alter: BTreeMap>, + /// Replicas the fake reports as hydrated when the controller probes. A + /// graceful test sets this to drive cut-over. + hydrated: BTreeSet, + /// How many times the controller probed hydration, for asserting that an + /// object-less cluster is never probed. + hydration_probes: usize, + /// What the fake answers when the controller pulls the object-existence + /// signal; an absent entry reads `false` (no objects). Held beside the + /// states (like `hydrated`) rather than read from them, and + /// `cluster_states` returns the state field at the adapter default + /// (`false`), so the signal reaches the controller only through the + /// `has_hydratable_objects` pull — keeping that pull load-bearing for + /// the seam tests. + has_hydratable_objects: BTreeMap, + /// Refresh-window inputs the fake returns per cluster when the controller + /// probes a scheduled cluster. An on-refresh test sets this to drive the + /// window decision. + refresh_window: BTreeMap, +} + +impl FakeCtx { + fn new(states: Vec) -> Self { + Self { + now: Timestamp::from(1000u64), + states: states.into_iter().map(|s| (s.cluster_id, s)).collect(), + applied: Vec::new(), + reject_next: 0, + witness_check: false, + concurrent_schedule_alter: BTreeMap::new(), + concurrent_policy_alter: BTreeMap::new(), + hydrated: BTreeSet::new(), + hydration_probes: 0, + has_hydratable_objects: BTreeMap::new(), + refresh_window: BTreeMap::new(), + } + } + + /// All create decisions across every applied batch. + fn creates(&self) -> Vec<&Decision> { + self.applied + .iter() + .flatten() + .filter(|d| matches!(d, Decision::CreateReplica { .. })) + .collect() + } + + /// All drop decisions across every applied batch. + fn drops(&self) -> Vec<&Decision> { + self.applied + .iter() + .flatten() + .filter(|d| matches!(d, Decision::DropReplica { .. })) + .collect() + } +} + +#[async_trait] +impl ClusterControllerCtx for FakeCtx { + fn now(&self) -> Timestamp { + self.now + } + + async fn cluster_states(&mut self, clusters: &[ClusterId]) -> Vec { + clusters + .iter() + .filter_map(|id| self.states.get(id).cloned()) + .map(|mut s| { + // Live signal, delivered only via the `has_hydratable_objects` + // pull: return the field at the adapter default so a seam test + // fails if the controller skips the pull. + s.has_hydratable_objects = false; + s + }) + .collect() + } + + async fn managed_cluster_ids(&mut self) -> Vec { + self.states.keys().copied().collect() + } + + async fn hydrated_replicas( + &mut self, + _cluster_id: ClusterId, + replicas: &[ReplicaId], + ) -> BTreeSet { + self.hydration_probes += 1; + replicas + .iter() + .copied() + .filter(|r| self.hydrated.contains(r)) + .collect() + } + + async fn has_hydratable_objects(&mut self, cluster_id: ClusterId) -> bool { + self.has_hydratable_objects + .get(&cluster_id) + .copied() + .unwrap_or(false) + } + + async fn refresh_window_inputs( + &mut self, + cluster_id: ClusterId, + ) -> Option { + self.refresh_window.get(&cluster_id).cloned() + } + + async fn apply(&mut self, decisions: Vec) -> ApplyOutcome { + if self.reject_next > 0 { + self.reject_next -= 1; + // A real apply rejects without recording any catalog change. We + // still record the attempt so tests can assert what was tried. + self.applied.push(decisions); + return ApplyOutcome::Rejected; + } + // Splice in a concurrent `ALTER` that lands between the controller's read + // and this append: rewrite the stored schedule before the witness check + // runs, so a decision derived from the pre-`ALTER` view fails its guard. + for (cluster_id, schedule) in std::mem::take(&mut self.concurrent_schedule_alter) { + if let Some(state) = self.states.get_mut(&cluster_id) { + state.schedule = schedule; + } + } + for (cluster_id, policy) in std::mem::take(&mut self.concurrent_policy_alter) { + if let Some(state) = self.states.get_mut(&cluster_id) { + state.auto_scaling_policy = policy; + } + } + if self.witness_check && !self.witness_holds(&decisions) { + // A real apply rejects without recording any catalog change. We still + // record the attempt so tests can assert what was tried. + self.applied.push(decisions); + return ApplyOutcome::Rejected; + } + // Mirror the real apply: a confirmed batch mutates the durable state, so + // a subsequent tick reads the post-apply view (cut-overs visible, created + // replicas present, dropped replicas gone). + for decision in &decisions { + self.apply_to_state(decision); + } + self.applied.push(decisions); + ApplyOutcome::Applied + } +} + +impl FakeCtx { + /// Whether every decision's carried `expected` still matches the durable + /// state of its target cluster, mirroring the adapter's + /// `cluster_state_matches`. A divergence (e.g. a concurrent `ALTER` that + /// flipped the `schedule`) makes the whole batch fail its compare-and-append. + fn witness_holds(&self, decisions: &[Decision]) -> bool { + decisions.iter().all(|decision| { + let (cluster_id, expected) = match decision { + Decision::CreateReplica { + cluster_id, + expected, + .. + } + | Decision::DropReplica { + cluster_id, + expected, + .. + } + | Decision::UpdateClusterState { + cluster_id, + expected, + .. + } => (cluster_id, expected), + }; + self.states + .get(cluster_id) + .is_some_and(|state| &state.expected() == expected) + }) + } + + /// Fold one applied decision into the in-memory durable state, mirroring what + /// the real catalog transaction would do. + fn apply_to_state(&mut self, decision: &Decision) { + match decision { + Decision::UpdateClusterState { + cluster_id, write, .. + } => { + let Some(state) = self.states.get_mut(cluster_id) else { + return; + }; + // Exhaustive destructure (no `..`): keeps this fake mirror of the + // adapter's `build_update_cluster_config_op` from silently + // forgetting a field added to `StateWrite`. + let StateWrite { + new_size, + new_replication_factor, + new_availability_zones, + new_logging, + reconfiguration, + burst, + } = write; + if let Some(size) = new_size { + state.size = size.clone(); + } + if let Some(rf) = new_replication_factor { + state.replication_factor = *rf; + } + if let Some(azs) = new_availability_zones { + state.availability_zones = azs.clone(); + } + if let Some(logging) = new_logging { + state.logging = logging.clone(); + } + if let Some(reconfiguration) = reconfiguration { + state.reconfiguration = reconfiguration.clone(); + } + if let Some(burst) = burst { + state.burst = burst.clone(); + } + } + Decision::CreateReplica { + cluster_id, + name, + shape, + .. + } => { + if let Some(state) = self.states.get_mut(cluster_id) { + let next_id = u64::cast_from(state.replicas.len()) + 1; + state.replicas.push(ObservedReplica { + replica_id: replica(next_id), + name: name.clone(), + shape: shape.clone(), + }); + } + } + Decision::DropReplica { + cluster_id, + replica_id, + .. + } => { + if let Some(state) = self.states.get_mut(cluster_id) { + state.replicas.retain(|r| r.replica_id != *replica_id); + } + } + } + } +} + +#[mz_ore::test(tokio::test)] +async fn steady_state_is_a_noop() { + let c = cluster(1); + let states = vec![state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + )]; + let mut ctx = FakeCtx::new(states); + + ClusterController::new().reconcile(&mut ctx).await; + + // Desired (2 @ 100cc) equals actual, so no decision of any kind was applied. + assert!( + ctx.applied.is_empty(), + "steady cluster should produce no decisions, got {:?}", + ctx.applied + ); +} + +#[mz_ore::test(tokio::test)] +async fn create_skips_reserved_replica_names() { + // A non-owned (INTERNAL / BILLED AS) replica already occupies "r1": it is + // reserved but not part of the controller-owned set, so the baseline's create + // must skip that name rather than collide with it. + let c = cluster(1); + let mut s = state(c, "100cc", 1, vec![]); + s.reserved_replica_names = vec!["r1".to_string()]; + let mut ctx = FakeCtx::new(vec![s]); + + ClusterController::new().reconcile(&mut ctx).await; + + let created: Vec<&str> = ctx + .applied + .iter() + .flatten() + .filter_map(|d| match d { + Decision::CreateReplica { name, .. } => Some(name.as_str()), + _ => None, + }) + .collect(); + assert_eq!( + created, + vec!["r2"], + "the created replica should skip the reserved name r1" + ); +} + +#[mz_ore::test(tokio::test)] +async fn no_managed_clusters_is_a_noop() { + let mut ctx = FakeCtx::new(vec![]); + ClusterController::new().reconcile(&mut ctx).await; + assert!(ctx.applied.is_empty()); +} + +#[mz_ore::test(tokio::test)] +async fn under_provisioned_baseline_creates() { + let c = cluster(1); + // replication_factor 3, but only one replica exists. + let states = vec![state( + c, + "100cc", + 3, + vec![observed(replica(1), "r0", "100cc")], + )]; + let mut ctx = FakeCtx::new(states); + + ClusterController::new().reconcile(&mut ctx).await; + + let creates = ctx.creates(); + assert_eq!(creates.len(), 2, "should create the two missing replicas"); + assert!(ctx.drops().is_empty()); + // Fresh names avoid the in-use `r0`. + for create in creates { + if let Decision::CreateReplica { name, shape, .. } = create { + assert_ne!(name, "r0"); + assert_eq!(shape.size, "100cc"); + } + } +} + +#[mz_ore::test(tokio::test)] +async fn over_provisioned_baseline_drops() { + let c = cluster(1); + // replication_factor 1, but two replicas exist. + let states = vec![state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + )]; + let mut ctx = FakeCtx::new(states); + + ClusterController::new().reconcile(&mut ctx).await; + + assert!(ctx.creates().is_empty()); + let drops = ctx.drops(); + assert_eq!(drops.len(), 1, "should drop the one excess replica"); +} + +#[mz_ore::test(tokio::test)] +async fn wrong_shape_replica_dropped() { + let c = cluster(1); + // The realized config is 200cc rf=1, but the single replica is at 100cc: + // no strategy desires the 100cc shape, and a 200cc slot is unfilled. + let states = vec![state( + c, + "200cc", + 1, + vec![observed(replica(1), "r0", "100cc")], + )]; + let mut ctx = FakeCtx::new(states); + + ClusterController::new().reconcile(&mut ctx).await; + + let creates = ctx.creates(); + let drops = ctx.drops(); + assert_eq!(creates.len(), 1); + assert_eq!(drops.len(), 1); + if let Decision::CreateReplica { shape, .. } = creates[0] { + assert_eq!(shape.size, "200cc"); + } +} + +// ----- A second, fake additive strategy, to exercise the union/diff. ----- + +/// Desires `count` replicas at `size`, regardless of state. Stands in for a +/// policy strategy (graceful/burst) for union/diff tests. +struct FixedStrategy { + name: &'static str, + size: String, + count: u32, +} + +impl Strategy for FixedStrategy { + fn name(&self) -> &'static str { + self.name + } + + fn desired_replicas(&self, _state: &ClusterState, _now: Timestamp) -> Vec { + (0..self.count) + .map(|_| DesiredReplica { + shape: shape(&self.size), + audit_detail: None, + }) + .collect() + } +} + +fn controller_with(strategies: Vec>) -> ClusterController { + // The kernel runs whatever strategies it holds; we construct one directly + // for union/diff tests rather than going through `new()`. + ClusterController { strategies } +} + +#[mz_ore::test(tokio::test)] +async fn union_takes_max_not_sum_per_shape() { + use crate::strategy::BaselineStrategy; + + let c = cluster(1); + // Baseline desires 2 @ 100cc; the extra strategy also desires 1 @ 100cc. + // The union is max(2, 1) = 2 @ 100cc, NOT 3. With two actual replicas the + // result is a no-op. + let states = vec![state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + )]; + let mut ctx = FakeCtx::new(states); + + let controller = controller_with(vec![ + Box::new(BaselineStrategy), + Box::new(FixedStrategy { + name: "extra", + size: "100cc".to_string(), + count: 1, + }), + ]); + controller.reconcile(&mut ctx).await; + + assert!( + ctx.applied.is_empty(), + "union of 2 and 1 at the same shape is 2, matching actual; got {:?}", + ctx.applied + ); +} + +#[mz_ore::test(tokio::test)] +async fn distinct_shapes_union_and_attribute() { + use crate::strategy::{BASELINE_STRATEGY_NAME, BaselineStrategy}; + + let c = cluster(1); + // Baseline desires 2 @ 100cc; the extra strategy desires 1 @ 200cc. Actual + // has the two 100cc replicas, so the controller creates one 200cc replica, + // attributed to "extra" only. + let states = vec![state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + )]; + let mut ctx = FakeCtx::new(states); + + let controller = controller_with(vec![ + Box::new(BaselineStrategy), + Box::new(FixedStrategy { + name: "extra", + size: "200cc".to_string(), + count: 1, + }), + ]); + controller.reconcile(&mut ctx).await; + + let creates = ctx.creates(); + assert_eq!(creates.len(), 1); + assert!(ctx.drops().is_empty()); + if let Decision::CreateReplica { + shape, + reasons, + audit_detail, + .. + } = creates[0] + { + assert_eq!(shape.size, "200cc"); + assert_eq!(reasons, &vec!["extra"]); + assert!(!reasons.contains(&BASELINE_STRATEGY_NAME)); + assert!( + audit_detail.is_none(), + "only on-refresh creates carry a window decision" + ); + } +} + +#[mz_ore::test] +fn shared_shape_merge_keeps_audit_detail() { + use crate::ctx::RefreshWindowDecision; + use crate::strategy::ON_REFRESH_STRATEGY_NAME; + + // Two strategies desire the same shape, one slot with a window decision and + // one without (the order strategies run in puts the detail-less slot + // first). The merged create keeps the detail, so a shape shared with + // another contributor still explains its on-refresh side. + let c = cluster(1); + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), None); + let detail = RefreshWindowDecision { + objects_needing_refresh: vec![GlobalId::User(7)], + objects_needing_compaction: Vec::new(), + hydration_time_estimate: Duration::ZERO, + }; + let contributions: Vec<(&'static str, Vec)> = vec![ + ( + "extra", + vec![DesiredReplica { + shape: shape("100cc"), + audit_detail: None, + }], + ), + ( + ON_REFRESH_STRATEGY_NAME, + vec![DesiredReplica { + shape: shape("100cc"), + audit_detail: Some(detail.clone()), + }], + ), + ]; + let decisions = crate::reconcile_replicas(&state, &contributions); + assert_eq!(decisions.len(), 1); + if let Decision::CreateReplica { + reasons, + audit_detail, + .. + } = &decisions[0] + { + assert_eq!(reasons, &vec!["extra", ON_REFRESH_STRATEGY_NAME]); + assert_eq!(audit_detail.as_ref(), Some(&detail)); + } else { + panic!("expected a CreateReplica"); + } +} + +#[mz_ore::test(tokio::test)] +async fn caa_conflict_is_rejected_and_recovered() { + use crate::ctx::{ + ExpectedClusterState, OnTimeout, ReconfigurationRecord, ReconfigurationTarget, + }; + + // A strategy that mirrors the cluster's current replication factor into a + // reconfiguration record's target, so phase 1 produces an UpdateClusterState + // whose contents depend on the state it was derived from. This lets the test + // distinguish a write recomputed against the pre-ALTER state from one + // recomputed against the post-ALTER state. + struct WritingStrategy; + impl Strategy for WritingStrategy { + fn name(&self) -> &'static str { + "writing" + } + fn update_state(&self, state: &ClusterState, now: Timestamp) -> StateWrite { + // Only write while no record exists, so once the write lands the + // strategy stops contributing and the controller reaches a no-op. + if state.reconfiguration.is_some() { + return StateWrite::default(); + } + StateWrite { + reconfiguration: Some(Some(ReconfigurationRecord { + target: ReconfigurationTarget { + size: "200cc".to_string(), + replication_factor: state.replication_factor, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + }, + deadline: now, + on_timeout: OnTimeout::Rollback, + })), + ..Default::default() + } + } + fn desired_replicas(&self, state: &ClusterState, _now: Timestamp) -> Vec { + // Mirror the realized set so phase 2 is a no-op for a steady cluster: + // this test is about the phase-1 write recomputation, not reshaping. + let shape = state.realized_shape(); + (0..state.replication_factor) + .map(|_| DesiredReplica { + shape: shape.clone(), + audit_detail: None, + }) + .collect() + } + } + + let c = cluster(1); + // rf=1 with one replica. + let states = vec![state( + c, + "100cc", + 1, + vec![observed(replica(1), "r0", "100cc")], + )]; + let mut ctx = FakeCtx::new(states); + ctx.reject_next = 1; + + let controller = controller_with(vec![Box::new(WritingStrategy)]); + controller.reconcile(&mut ctx).await; + + // The single applied batch is the rejected phase-1 write. Because the + // cluster's phase-1 write was rejected, phase 2 was skipped for it, so no + // create/drop was applied, and the rejection left the state untouched. + assert_eq!(ctx.applied.len(), 1); + assert!(matches!( + ctx.applied[0][0], + Decision::UpdateClusterState { .. } + )); + assert!(ctx.creates().is_empty()); + assert!(ctx.drops().is_empty()); + + // The carried `expected` reflects the (pre-ALTER) state the write was + // derived from: replication factor 1. + if let Decision::UpdateClusterState { + expected, write, .. + } = &ctx.applied[0][0] + { + assert_eq!( + expected, + &ExpectedClusterState { + size: "100cc".to_string(), + replication_factor: 1, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + schedule: ClusterSchedule::Manual, + auto_scaling_policy: None, + reconfiguration: None, + burst: None, + } + ); + if let Some(Some(record)) = &write.reconfiguration { + assert_eq!(record.target.replication_factor, 1); + } else { + panic!("expected a reconfiguration write"); + } + } + + // Simulate the concurrent `ALTER` that caused the rejection: the durable + // replication factor changed out from under the tick, and (as a real rf + // `ALTER` would) the replica set changed with it, so the new state is + // self-consistent and phase 2 stays a no-op. + { + let state = ctx.states.get_mut(&c).expect("cluster present"); + state.replication_factor = 2; + state.replicas = vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ]; + } + + // Next tick, with no rejection, the controller recomputes from the NEW state + // and the write applies. The recovered write must reflect the post-ALTER + // replication factor (2), proving the controller did not reuse its stale + // (rf=1) computation. Phase 2 is a no-op against the self-consistent state, + // so the only new batch is the recovered write. + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.applied.len(), 2); + if let Decision::UpdateClusterState { + expected, write, .. + } = &ctx.applied[1][0] + { + assert_eq!(expected.replication_factor, 2); + match &write.reconfiguration { + Some(Some(record)) => assert_eq!(record.target.replication_factor, 2), + other => panic!("expected a reconfiguration write derived from rf=2, got {other:?}"), + } + } else { + panic!("expected the recovered tick to apply an UpdateClusterState"); + } + + // The record is now durable; a third tick recomputes against it and reaches + // a no-op (the strategy stops writing once the record exists, and phase 2 + // matches the realized set), so the controller converges. + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.applied.len(), 2, "converged: no further decisions"); +} + +#[mz_ore::test(tokio::test)] +async fn create_drop_is_caa_guarded_and_recovers() { + use crate::ctx::ExpectedClusterState; + + let c = cluster(1); + // Over-provisioned: rf=1 with two replicas, so the baseline-only controller + // emits a phase-2 drop. There is no phase-1 write, so this exercises the + // compare-and-append guard on the create/drop batch specifically. + let states = vec![state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + )]; + let mut ctx = FakeCtx::new(states); + // Reject the (sole, phase-2) apply this tick. + ctx.reject_next = 1; + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + // The drop carried the durable state it was derived from and was rejected; + // because the fake records rejected batches but applies no catalog change, + // both replicas remain. + assert_eq!(ctx.applied.len(), 1); + let drops = ctx.drops(); + assert_eq!(drops.len(), 1, "should have attempted one drop"); + if let Decision::DropReplica { expected, .. } = drops[0] { + assert_eq!( + expected, + &ExpectedClusterState { + size: "100cc".to_string(), + replication_factor: 1, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + schedule: ClusterSchedule::Manual, + auto_scaling_policy: None, + reconfiguration: None, + burst: None, + } + ); + } else { + panic!("expected a DropReplica decision"); + } + assert_eq!( + ctx.states[&c].replicas.len(), + 2, + "rejected drop must not retire a replica" + ); + + // Next tick, with no rejection, the drop applies and the cluster converges to + // the single desired replica. + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.drops().len(), 2, "the recovered tick re-emits the drop"); + assert_eq!(ctx.states[&c].replicas.len(), 1, "converged to rf=1"); + + // A third tick is a no-op: desired equals actual. + let before = ctx.applied.len(); + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.applied.len(), before, "converged: no further decisions"); +} + +#[mz_ore::test] +fn replica_name_gen_is_one_based_and_avoids_used() { + use crate::ReplicaNameGen; + + // Managed-replica names are 1-based: an empty cluster's first generated + // name is `r1`. + let mut name_gen = ReplicaNameGen::new(&[]); + assert_eq!(name_gen.next_name(), "r1"); + assert_eq!(name_gen.next_name(), "r2"); + + // Fresh names start past the highest observed `rNN` index and skip names + // in use. + let mut name_gen = ReplicaNameGen::new(&["r2", "custom"]); + assert_eq!(name_gen.next_name(), "r3"); +} + +// ----- Graceful reconfiguration strategy. ----- + +use crate::ctx::{OnTimeout, ReconfigurationRecord, ReconfigurationTarget}; +use crate::strategy::{GRACEFUL_RECONFIGURATION_STRATEGY_NAME, GracefulReconfigurationStrategy}; + +/// A reconfiguration record targeting `size` at `rf` with the given `deadline`, +/// the (default) `Rollback` timeout action, empty AZ list and default logging. +fn record(size: &str, rf: u32, deadline: u64) -> ReconfigurationRecord { + record_on_timeout(size, rf, deadline, OnTimeout::Rollback) +} + +/// As [`record`], with an explicit `on_timeout` action. +fn record_on_timeout( + size: &str, + rf: u32, + deadline: u64, + on_timeout: OnTimeout, +) -> ReconfigurationRecord { + ReconfigurationRecord { + target: ReconfigurationTarget { + size: size.to_string(), + replication_factor: rf, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + }, + deadline: Timestamp::from(deadline), + on_timeout, + } +} + +/// Convenience: a `ClusterState` with an in-flight reconfiguration and an +/// explicit hydrated-replica set. +fn reconfiguring_state( + cluster_id: ClusterId, + size: &str, + rf: u32, + replicas: Vec, + rec: ReconfigurationRecord, + hydrated: BTreeSet, +) -> ClusterState { + ClusterState { + cluster_id, + size: size.to_string(), + replication_factor: rf, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + schedule: ClusterSchedule::Manual, + auto_scaling_policy: None, + reconfiguration: Some(rec), + burst: None, + burst_enabled: true, + default_burst_linger: Duration::ZERO, + replicas, + reserved_replica_names: Vec::new(), + hydrated_replicas: hydrated, + refresh_window: None, + has_hydratable_objects: true, + } +} + +#[mz_ore::test] +fn graceful_desires_target_while_in_flight() { + // Realized 100cc rf=2; target 200cc rf=2; nothing hydrated; before deadline. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + record("200cc", 2, 5000), + BTreeSet::new(), + ); + let now = Timestamp::from(1000u64); + + let g = GracefulReconfigurationStrategy; + // No cut-over while not hydrated. + assert!(g.update_state(&state, now).is_empty()); + // Desires the two target-shape replicas. + let desired = g.desired_replicas(&state, now); + assert_eq!(desired.len(), 2); + assert!(desired.iter().all(|d| d.shape.size == "200cc")); +} + +#[mz_ore::test] +fn graceful_cuts_over_when_target_hydrated() { + // Both target replicas present and hydrated -> cut over, even before deadline. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + observed(replica(3), "r2", "200cc"), + observed(replica(4), "r3", "200cc"), + ], + record("200cc", 2, 5000), + BTreeSet::from([replica(3), replica(4)]), + ); + let now = Timestamp::from(1000u64); + + let g = GracefulReconfigurationStrategy; + let write = g.update_state(&state, now); + assert_eq!(write.new_size.as_deref(), Some("200cc")); + assert_eq!(write.new_replication_factor, Some(2)); + // The record is cleared on cut-over. + assert_eq!(write.reconfiguration, Some(None)); +} + +#[mz_ore::test] +fn graceful_partial_hydration_does_not_cut_over() { + // Only one of the two target replicas is hydrated: not enough for HA, so no + // cut-over and the target set is still desired. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + observed(replica(3), "r2", "200cc"), + observed(replica(4), "r3", "200cc"), + ], + record("200cc", 2, 5000), + BTreeSet::from([replica(3)]), + ); + let now = Timestamp::from(1000u64); + + let g = GracefulReconfigurationStrategy; + assert!(g.update_state(&state, now).is_empty()); + assert_eq!(g.desired_replicas(&state, now).len(), 2); +} + +#[mz_ore::test] +fn graceful_timeout_vs_hydrated_precedence() { + // Past the deadline AND fully hydrated: success takes precedence over timeout, + // so we still cut over and keep desiring the target until the cut-over lands. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "200cc"), + ], + record("200cc", 1, 1000), + BTreeSet::from([replica(2)]), + ); + let now = Timestamp::from(9999u64); // well past the deadline + + let g = GracefulReconfigurationStrategy; + let write = g.update_state(&state, now); + assert_eq!( + write.new_size.as_deref(), + Some("200cc"), + "success cuts over" + ); + // Still desired (awaiting the cut-over a rejected tick could not apply). + assert_eq!(g.desired_replicas(&state, now).len(), 1); +} + +#[mz_ore::test] +fn graceful_timeout_clears_record_and_drops_target() { + // Past the deadline and NOT hydrated: abandon. `update_state` clears the + // record without touching the realized config, and the strategy ceases to + // contribute the target replicas, so the controller drops them. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "200cc"), + ], + record("200cc", 1, 1000), + BTreeSet::new(), + ); + let now = Timestamp::from(9999u64); + + let g = GracefulReconfigurationStrategy; + let write = g.update_state(&state, now); + assert!(write.new_size.is_none(), "no cut-over on timeout"); + assert!( + write.new_replication_factor.is_none() + && write.new_availability_zones.is_none() + && write.new_logging.is_none(), + "the realized config is untouched" + ); + assert_eq!(write.reconfiguration, Some(None), "the record is cleared"); + + // Even before the clear lands (e.g. the compare-and-append witness was + // stale), the target replicas are no longer desired past the deadline, so + // the rollback's replica drops stay prompt. + assert!( + g.desired_replicas(&state, now).is_empty(), + "timed out: target replicas no longer desired" + ); +} + +#[mz_ore::test] +fn graceful_commit_on_timeout_cuts_over_unhydrated() { + // Past the deadline and NOT hydrated, but `on_timeout` is `Commit`: cut over to + // the un-hydrated target anyway and clear the record. The target replicas stay + // desired (they become the realized set at the cut-over), in contrast to the + // `Rollback` default which drops them. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "200cc"), + ], + record_on_timeout("200cc", 1, 1000, OnTimeout::Commit), + BTreeSet::new(), + ); + let now = Timestamp::from(9999u64); // past the deadline, target un-hydrated + + let g = GracefulReconfigurationStrategy; + let write = g.update_state(&state, now); + assert_eq!( + write.new_size.as_deref(), + Some("200cc"), + "commit-on-timeout cuts over the un-hydrated target" + ); + assert_eq!( + write.reconfiguration, + Some(None), + "commit-on-timeout clears the record" + ); + assert_eq!( + g.desired_replicas(&state, now).len(), + 1, + "commit keeps desiring the target (it becomes the realized set)" + ); +} + +#[mz_ore::test] +fn graceful_rollback_on_timeout_before_deadline_still_overlaps() { + // Before the deadline, `Rollback` behaves exactly like the live overlap: the + // target is desired and there is no cut-over. The action only takes effect once + // the deadline passes un-hydrated (covered by graceful_timeout_parks_and_drops). + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![observed(replica(1), "r0", "100cc")], + record_on_timeout("200cc", 1, 5000, OnTimeout::Rollback), + BTreeSet::new(), + ); + let now = Timestamp::from(1000u64); // before the deadline + + let g = GracefulReconfigurationStrategy; + assert!( + g.update_state(&state, now).is_empty(), + "no cut-over before the deadline" + ); + assert_eq!( + g.desired_replicas(&state, now).len(), + 1, + "target desired during the overlap regardless of on_timeout" + ); +} + +#[mz_ore::test] +fn graceful_az_only_reconfiguration_is_a_shape_change() { + // Same size, different AZ list: the target shape differs from the realized + // shape, so the in-flight replica is at a distinct shape and is desired + // separately from the baseline's realized-shape replica. + let c = cluster(1); + let mut state = ClusterState { + cluster_id: c, + size: "100cc".to_string(), + replication_factor: 1, + availability_zones: vec!["az1".to_string()], + logging: ComputeReplicaLogging::default(), + schedule: ClusterSchedule::Manual, + auto_scaling_policy: None, + reconfiguration: Some(ReconfigurationRecord { + target: ReconfigurationTarget { + size: "100cc".to_string(), + replication_factor: 1, + availability_zones: vec!["az2".to_string()], + logging: ComputeReplicaLogging::default(), + }, + deadline: Timestamp::from(5000u64), + on_timeout: OnTimeout::Rollback, + }), + burst: None, + burst_enabled: true, + default_burst_linger: Duration::ZERO, + replicas: vec![ObservedReplica { + replica_id: replica(1), + name: "r0".to_string(), + shape: ReplicaShape { + size: "100cc".to_string(), + availability_zones: vec!["az1".to_string()], + logging: ComputeReplicaLogging::default(), + }, + }], + reserved_replica_names: Vec::new(), + hydrated_replicas: BTreeSet::new(), + refresh_window: None, + has_hydratable_objects: true, + }; + let now = Timestamp::from(1000u64); + + let g = GracefulReconfigurationStrategy; + let desired = g.desired_replicas(&state, now); + assert_eq!(desired.len(), 1); + assert_eq!(desired[0].shape.availability_zones, vec!["az2".to_string()]); + // The desired AZ shape does not match the realized replica's AZ shape. + assert!(!desired[0].shape.matches(&state.replicas[0].shape)); + + // Mark the realized replica hydrated: it is NOT a target replica (wrong AZ), + // so this must not trigger a cut-over. + state.hydrated_replicas.insert(replica(1)); + assert!(g.update_state(&state, now).is_empty()); +} + +#[mz_ore::test(tokio::test)] +async fn graceful_full_flow_overlap_then_cutover() { + // End-to-end through the kernel: a 100cc rf=2 cluster reconfiguring to 200cc. + // Tick 1 creates the two 200cc target replicas (overlap). Once they hydrate, + // a later tick cuts over and the old 100cc replicas fall out. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 2, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "100cc"), + ], + record("200cc", 2, 9_000_000), + BTreeSet::new(), + ); + let mut ctx = FakeCtx::new(vec![state]); + + let controller = ClusterController::new(); + + // Tick 1: overlap — create two 200cc replicas, no drops, no cut-over. + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.creates().len(), 2); + assert!(ctx.drops().is_empty()); + assert_eq!(ctx.states[&c].size, "100cc", "realized config unchanged"); + assert_eq!(ctx.states[&c].replicas.len(), 4); + + // The target replicas are the two 200cc ones; mark them hydrated. + let target_ids: BTreeSet<_> = ctx.states[&c] + .replicas + .iter() + .filter(|r| r.shape.size == "200cc") + .map(|r| r.replica_id) + .collect(); + assert_eq!(target_ids.len(), 2); + ctx.hydrated = target_ids.clone(); + + // Tick 2: cut over (phase 1) then drop the old 100cc replicas (phase 2). + let before = ctx.applied.len(); + controller.reconcile(&mut ctx).await; + assert!(ctx.applied.len() > before); + assert_eq!(ctx.states[&c].size, "200cc", "cut over to the target size"); + assert!(ctx.states[&c].reconfiguration.is_none(), "record cleared"); + assert_eq!(ctx.states[&c].replicas.len(), 2); + assert!( + ctx.states[&c] + .replicas + .iter() + .all(|r| r.shape.size == "200cc"), + "only the target replicas remain" + ); + + // The old set was retired via explicit drop decisions (no strategy desired + // the old shape after cut-over; drops carry no per-strategy attribution). + let dropped = ctx + .applied + .iter() + .flatten() + .any(|d| matches!(d, Decision::DropReplica { .. })); + assert!(dropped, "a drop happened"); + + // Tick 3: converged, no further decisions. + let before = ctx.applied.len(); + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.applied.len(), before, "converged"); +} + +#[mz_ore::test(tokio::test)] +async fn graceful_alter_back_clears_record_without_churn() { + // ALTER-back/cancel: a reconfiguration whose target equals the realized + // config. The target shape matches the existing replicas, so there is nothing + // to create; once those replicas hydrate the cut-over just clears the record. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![observed(replica(1), "r0", "100cc")], + record("100cc", 1, 9_000_000), + BTreeSet::new(), + ); + let mut ctx = FakeCtx::new(vec![state]); + // The controller probes hydration through the ctx; the existing replica is + // already hydrated. + ctx.hydrated = BTreeSet::from([replica(1)]); + let controller = ClusterController::new(); + + controller.reconcile(&mut ctx).await; + + // No create, no drop — the realized replica already satisfies the target. + assert!(ctx.creates().is_empty()); + assert!(ctx.drops().is_empty()); + // The cut-over clears the record (realized config is unchanged). + assert!(ctx.states[&c].reconfiguration.is_none()); + assert_eq!(ctx.states[&c].size, "100cc"); + assert_eq!(ctx.states[&c].replicas.len(), 1); + + let _ = GRACEFUL_RECONFIGURATION_STRATEGY_NAME; +} + +#[mz_ore::test(tokio::test)] +async fn graceful_rollback_at_timeout_drops_target_through_seam() { + // End-to-end through the seam: a 100cc rf=1 cluster reconfiguring to 200cc + // whose target never hydrated and whose deadline has passed, under the default + // `Rollback` action. The realized 100cc replica and the in-flight 200cc target + // replica both exist (an earlier overlap tick created the target). The tick + // must drop the in-flight target via `apply`, revert to the pre-reconfiguration + // set, and clear the record without a cut-over. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "200cc"), + ], + record_on_timeout("200cc", 1, 1000, OnTimeout::Rollback), + BTreeSet::new(), + ); + let mut ctx = FakeCtx::new(vec![state]); + // Past the deadline (1000), target un-hydrated. + ctx.now = Timestamp::from(9999u64); + let controller = ClusterController::new(); + + controller.reconcile(&mut ctx).await; + + // The only phase-1 write is the record clear: no cut-over (the realized + // config fields are untouched). + let state_writes: Vec<_> = ctx + .applied + .iter() + .flatten() + .filter_map(|d| match d { + Decision::UpdateClusterState { write, .. } => Some(write), + _ => None, + }) + .collect(); + assert_eq!( + state_writes.len(), + 1, + "exactly one phase-1 write: the record clear" + ); + assert!( + state_writes[0].new_size.is_none(), + "rollback-at-timeout must not cut over" + ); + assert_eq!( + state_writes[0].reconfiguration, + Some(None), + "the record is cleared" + ); + // Phase 2 drops the un-desired in-flight target replica. + assert!(ctx.creates().is_empty()); + let drops = ctx.drops(); + assert_eq!(drops.len(), 1, "the in-flight 200cc target is dropped"); + if let Decision::DropReplica { replica_id, .. } = drops[0] { + assert_eq!( + *replica_id, + replica(2), + "the 200cc target replica is dropped" + ); + } else { + panic!("expected a DropReplica decision"); + } + // Reverted to the pre-reconfiguration set; the record is gone, so the + // strategy is disengaged and the baseline alone shapes the cluster. + assert_eq!(ctx.states[&c].size, "100cc", "realized config unchanged"); + assert_eq!(ctx.states[&c].replicas.len(), 1); + assert_eq!(ctx.states[&c].replicas[0].shape.size, "100cc"); + assert!( + ctx.states[&c].reconfiguration.is_none(), + "the record is cleared under rollback" + ); + + // A second tick is a no-op: no record means no strategy engagement, the + // realized set already matches, and there is nothing left to drop. + let before = ctx.applied.len(); + controller.reconcile(&mut ctx).await; + assert_eq!( + ctx.applied.len(), + before, + "rolled back: converged to a no-op" + ); +} + +#[mz_ore::test(tokio::test)] +async fn graceful_commit_at_timeout_cuts_over_through_seam() { + // End-to-end through the seam: the same timed-out, un-hydrated reconfiguration + // but under `Commit`. The tick must cut the realized config over to the + // un-hydrated 200cc target (phase 1) and then drop the now-undesired 100cc + // replica (phase 2), clearing the record. + let c = cluster(1); + let state = reconfiguring_state( + c, + "100cc", + 1, + vec![ + observed(replica(1), "r0", "100cc"), + observed(replica(2), "r1", "200cc"), + ], + record_on_timeout("200cc", 1, 1000, OnTimeout::Commit), + BTreeSet::new(), + ); + let mut ctx = FakeCtx::new(vec![state]); + // Past the deadline (1000), target un-hydrated. + ctx.now = Timestamp::from(9999u64); + let controller = ClusterController::new(); + + controller.reconcile(&mut ctx).await; + + // Phase 1 cut the realized config over to the target and cleared the record. + assert_eq!(ctx.states[&c].size, "200cc", "commit-at-timeout cuts over"); + assert!( + ctx.states[&c].reconfiguration.is_none(), + "commit-at-timeout clears the record" + ); + assert!( + ctx.applied + .iter() + .flatten() + .any(|d| matches!(d, Decision::UpdateClusterState { .. })), + "commit-at-timeout writes the cut-over" + ); + // Phase 2 dropped the old 100cc replica; only the target shape remains. + assert!(ctx.creates().is_empty()); + let drops = ctx.drops(); + assert_eq!(drops.len(), 1, "the old 100cc replica is dropped"); + assert_eq!(ctx.states[&c].replicas.len(), 1); + assert_eq!( + ctx.states[&c].replicas[0].shape.size, "200cc", + "only the target replica remains" + ); + + // A second tick is a no-op: the realized set matches the cut-over config and + // there is no record left to act on. + let before = ctx.applied.len(); + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.applied.len(), before, "converged after the cut-over"); +} + +// ----- On-refresh scheduling strategy. ----- + +use mz_repr::refresh_schedule::RefreshSchedule; +use timely::progress::Antichain; + +use crate::ctx::{ClusterSchedule as Sched, RefreshMvInfo}; +use crate::strategy::{ON_REFRESH_STRATEGY_NAME, OnRefreshStrategy}; + +/// A scheduled (`ON REFRESH`) cluster state with the given realized size, +/// replication factor, replicas, and optional refresh-window inputs. +fn scheduled_state( + cluster_id: ClusterId, + size: &str, + replication_factor: u32, + hydration_time_estimate_ms: u64, + replicas: Vec, + refresh_window: Option, +) -> ClusterState { + ClusterState { + cluster_id, + size: size.to_string(), + replication_factor, + availability_zones: Vec::new(), + logging: ComputeReplicaLogging::default(), + schedule: Sched::Refresh { + hydration_time_estimate: Duration::from_millis(hydration_time_estimate_ms), + }, + auto_scaling_policy: None, + reconfiguration: None, + burst: None, + burst_enabled: true, + default_burst_linger: Duration::ZERO, + replicas, + reserved_replica_names: Vec::new(), + hydrated_replicas: BTreeSet::new(), + refresh_window, + has_hydratable_objects: true, + } +} + +/// A `REFRESH AT` schedule with a single refresh time. +fn refresh_at(at: u64) -> RefreshSchedule { + RefreshSchedule { + everies: Vec::new(), + ats: vec![Timestamp::from(at)], + } +} + +/// Refresh-window inputs: read ts, compaction estimate, and one MV (id `u1`) +/// with the given write frontier and schedule. `Some(ts)` is a single-element +/// write frontier `[ts]`; `None` is the empty (sealed) frontier `[]`. +fn window_inputs( + read_ts: u64, + compaction_ms: u64, + write_frontier: Option, + schedule: RefreshSchedule, +) -> RefreshWindowInputs { + RefreshWindowInputs { + read_ts: Timestamp::from(read_ts), + compaction_estimate: Duration::from_millis(compaction_ms), + refresh_mvs: vec![refresh_mv(1, write_frontier, schedule)], + } +} + +/// One REFRESH MV with id `u`, the given write frontier, and schedule. +fn refresh_mv(id: u64, write_frontier: Option, schedule: RefreshSchedule) -> RefreshMvInfo { + let write_frontier = match write_frontier { + Some(ts) => Antichain::from_elem(Timestamp::from(ts)), + None => Antichain::new(), + }; + RefreshMvInfo { + id: GlobalId::User(id), + write_frontier, + refresh_schedule: schedule, + } +} + +#[mz_ore::test] +fn on_refresh_baseline_holds_nothing_on_scheduled() { + // Even with a stale non-zero rf, the baseline contributes nothing to a + // scheduled cluster — the on-refresh strategy is the sole contributor. + let c = cluster(1); + let state = scheduled_state(c, "100cc", 1, 0, Vec::new(), None); + let baseline = crate::strategy::BaselineStrategy; + assert!( + baseline + .desired_replicas(&state, Timestamp::from(0u64)) + .is_empty(), + "baseline must hold nothing on a scheduled cluster" + ); +} + +#[mz_ore::test] +fn on_refresh_normalizes_replication_factor() { + // A scheduled cluster carrying a stale non-zero rf is normalized to 0. + let c = cluster(1); + let state = scheduled_state(c, "100cc", 1, 0, Vec::new(), None); + let s = OnRefreshStrategy; + let write = s.update_state(&state, Timestamp::from(0u64)); + assert_eq!(write.new_replication_factor, Some(0)); + + // Already 0 (or MANUAL): no write, so steady ticks stay no-ops. + let normalized = scheduled_state(c, "100cc", 0, 0, Vec::new(), None); + assert!( + s.update_state(&normalized, Timestamp::from(0u64)) + .is_empty() + ); + let manual = state_(c, "100cc", 1); + assert!(s.update_state(&manual, Timestamp::from(0u64)).is_empty()); +} + +/// A MANUAL cluster with no replicas, for the normalization no-op check. +fn state_(cluster_id: ClusterId, size: &str, rf: u32) -> ClusterState { + state(cluster_id, size, rf, Vec::new()) +} + +#[mz_ore::test] +fn on_refresh_in_window_desires_one_replica() { + // Read ts 100, MV write frontier 50 (strictly below the read ts), so the MV + // still needs a refresh and the cluster is On. One replica at the realized + // shape. + let c = cluster(1); + let inputs = window_inputs(100, 0, Some(50), refresh_at(1000)); + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + let desired = s.desired_replicas(&state, Timestamp::from(0u64)); + assert_eq!(desired.len(), 1, "in-window cluster desires one replica"); + assert_eq!(desired[0].shape.size, "100cc"); + + // The slot carries the window decision: the refresh-due MV explains the + // open window, and there is no compaction reason. + let detail = desired[0].audit_detail.as_ref().expect("window decision"); + assert_eq!(detail.objects_needing_refresh, vec![GlobalId::User(1)]); + assert!(detail.objects_needing_compaction.is_empty()); + assert_eq!(detail.hydration_time_estimate, Duration::ZERO); +} + +#[mz_ore::test] +fn on_refresh_window_decision_lists_due_mvs() { + // Two MVs: u1's frontier (50) is below the read ts (100), u2's (200) is + // past it. Only u1 appears in the window decision's refresh list — the + // lists name exactly the MVs that explain the open window. + let c = cluster(1); + let inputs = RefreshWindowInputs { + read_ts: Timestamp::from(100u64), + compaction_estimate: Duration::ZERO, + refresh_mvs: vec![ + refresh_mv(1, Some(50), refresh_at(1000)), + refresh_mv(2, Some(200), refresh_at(1000)), + ], + }; + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + let desired = s.desired_replicas(&state, Timestamp::from(0u64)); + assert_eq!(desired.len(), 1); + let detail = desired[0].audit_detail.as_ref().expect("window decision"); + assert_eq!(detail.objects_needing_refresh, vec![GlobalId::User(1)]); + assert!(detail.objects_needing_compaction.is_empty()); +} + +#[mz_ore::test] +fn on_refresh_caught_up_at_read_ts_is_off() { + // Frontier exactly at the read ts (and no hydration lead, no compaction + // window): the MV is caught up, so the cluster is Off. The needs-refresh check + // is strict (`frontier < read_ts + estimate`), matching the legacy scheduler. + let c = cluster(1); + let inputs = window_inputs(100, 0, Some(100), refresh_at(50)); + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + assert!( + s.desired_replicas(&state, Timestamp::from(0u64)).is_empty(), + "a caught-up MV at the read ts leaves the cluster off" + ); +} + +#[mz_ore::test] +fn on_refresh_out_of_window_desires_nothing() { + // Read ts 100, MV write frontier 200 (already advanced past the read ts), no + // hydration lead and no compaction window, so the MV needs no refresh: Off. + let c = cluster(1); + let inputs = window_inputs(100, 0, Some(200), refresh_at(50)); + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + assert!( + s.desired_replicas(&state, Timestamp::from(0u64)).is_empty(), + "out-of-window cluster desires nothing" + ); +} + +#[mz_ore::test] +fn on_refresh_empty_frontier_needs_no_refresh() { + // An empty (sealed) write frontier `[]` is the "complete past every timestamp" + // state: `Antichain::less_than` is `false` for every timestamp, so the MV never + // reads as needing a refresh on that count — exactly as the legacy refresh + // policy decides it with `Antichain::less_than`. The compaction window is also + // closed here (read ts 1000 is well past the last `AT 200` plus the compaction + // estimate), so the cluster is Off. + // + // This guards the empty/sealed-frontier arm of the window decision. A + // single-input total-order MV's write frontier holds at most one element, so a + // multi-element frontier is not reachable and is not exercised here; the + // `Antichain` seam keeps the model faithful regardless. + let c = cluster(1); + let inputs = window_inputs(1000, 100, None, refresh_at(200)); + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + assert!( + s.desired_replicas(&state, Timestamp::from(0u64)).is_empty(), + "an empty write frontier needs no refresh and leaves the cluster off" + ); +} + +#[mz_ore::test] +fn on_refresh_hydration_estimate_opens_window_early() { + // Write frontier 200 is past the read ts 100, so on its own the MV needs no + // refresh. But a hydration-time estimate of 150 adjusts the read ts to 250, + // which the frontier (200) is now below, so the cluster turns on early to + // rehydrate ahead of the refresh. + let c = cluster(1); + let inputs = window_inputs(100, 0, Some(200), refresh_at(1000)); + let state = scheduled_state(c, "100cc", 0, 150, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + assert_eq!( + s.desired_replicas(&state, Timestamp::from(0u64)).len(), + 1, + "the hydration estimate opens the window early" + ); + + // With no estimate the same frontier leaves the cluster Off. + let no_estimate = scheduled_state( + c, + "100cc", + 0, + 0, + Vec::new(), + Some(window_inputs(100, 0, Some(200), refresh_at(1000))), + ); + assert!( + s.desired_replicas(&no_estimate, Timestamp::from(0u64)) + .is_empty() + ); +} + +#[mz_ore::test] +fn on_refresh_compaction_window_keeps_cluster_on() { + // The MV's frontier (300) is past the read ts (250), so it needs no refresh. + // But its previous refresh was recent: with frontier 300 rounded down past + // the `AT 200` schedule, prev_refresh = 200, and 200 + compaction_estimate + // (100) = 300 > read ts 250, so the cluster stays on for compaction. + let c = cluster(1); + let inputs = window_inputs(250, 100, Some(300), refresh_at(200)); + let state = scheduled_state(c, "100cc", 0, 0, Vec::new(), Some(inputs)); + let s = OnRefreshStrategy; + let desired = s.desired_replicas(&state, Timestamp::from(0u64)); + assert_eq!( + desired.len(), + 1, + "the compaction window keeps the cluster on" + ); + + // The window decision attributes the open window to compaction, not a + // pending refresh. + let detail = desired[0].audit_detail.as_ref().expect("window decision"); + assert!(detail.objects_needing_refresh.is_empty()); + assert_eq!(detail.objects_needing_compaction, vec![GlobalId::User(1)]); + + // A later read ts past the compaction window turns it off: the frontier (500) + // needs no refresh at read ts 400, and prev_refresh 200 + compaction 100 = 300 + // is not > read ts 400. + let past = scheduled_state( + c, + "100cc", + 0, + 0, + Vec::new(), + Some(window_inputs(400, 100, Some(500), refresh_at(200))), + ); + assert!(s.desired_replicas(&past, Timestamp::from(0u64)).is_empty()); +} + +#[mz_ore::test(tokio::test)] +async fn on_refresh_creates_in_window_through_seam() { + // End-to-end through the ctx seam: a scheduled cluster with a stale rf=1 and + // no replicas, inside its refresh window. Phase 1 normalizes rf to 0; phase 2 + // creates the one in-window replica. + let c = cluster(1); + let state = scheduled_state(c, "100cc", 1, 0, Vec::new(), None); + let mut ctx = FakeCtx::new(vec![state]); + ctx.refresh_window + .insert(c, window_inputs(100, 0, Some(50), refresh_at(1000))); + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + assert_eq!( + ctx.states[&c].replication_factor, 0, + "rf normalized to 0 at runtime" + ); + let creates = ctx.creates(); + assert_eq!(creates.len(), 1, "one in-window replica is created"); + if let Decision::CreateReplica { + reasons, + shape, + audit_detail, + .. + } = creates[0] + { + assert!(reasons.contains(&ON_REFRESH_STRATEGY_NAME)); + assert_eq!(shape.size, "100cc"); + // The create carries the window decision through the kernel for the + // audit log's `scheduling_policies` detail. + let detail = audit_detail.as_ref().expect("window decision"); + assert_eq!(detail.objects_needing_refresh, vec![GlobalId::User(1)]); + assert!(detail.objects_needing_compaction.is_empty()); + } else { + panic!("expected a CreateReplica"); + } + assert!(ctx.drops().is_empty()); + + // A second tick converges: rf is 0 (no write), and the in-window replica + // matches the on-refresh desire, so nothing changes. + let before = ctx.applied.len(); + controller.reconcile(&mut ctx).await; + assert_eq!(ctx.applied.len(), before, "converged inside the window"); +} + +#[mz_ore::test(tokio::test)] +async fn on_refresh_drops_outside_window_through_seam() { + // A scheduled cluster (already normalized rf=0) with a running replica, now + // outside its refresh window: the on-refresh strategy desires nothing, so the + // replica is dropped. + let c = cluster(1); + let state = scheduled_state( + c, + "100cc", + 0, + 0, + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![state]); + ctx.refresh_window + .insert(c, window_inputs(100, 0, Some(200), refresh_at(50))); + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + assert!(ctx.creates().is_empty()); + let drops = ctx.drops(); + assert_eq!(drops.len(), 1, "the out-of-window replica is dropped"); + assert!(ctx.states[&c].replicas.is_empty()); +} + +#[mz_ore::test(tokio::test)] +async fn on_refresh_schedule_alter_rejects_in_flight_decision() { + // The `schedule` field of the compare-and-append witness is load-bearing: a + // concurrent `ALTER ... SET (SCHEDULE = MANUAL)` that lands between the + // controller's read and its append must reject the in-flight on-refresh drop, + // so the on-refresh strategy never reshapes a cluster the user just handed + // back to the baseline. With `witness_check` on, this exercises the real + // per-decision compare (not the blunt `reject_next` counter), so dropping + // `schedule` from `ExpectedClusterState` would make this test fail. + let c = cluster(1); + // Scheduled, already-normalized (rf=0), one running replica, outside its + // window — so the on-refresh strategy emits a phase-2 drop and no phase-1 + // write. The drop carries `expected.schedule = Refresh`. + let state = scheduled_state( + c, + "100cc", + 0, + 0, + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![state]); + ctx.refresh_window + .insert(c, window_inputs(100, 0, Some(200), refresh_at(50))); + ctx.witness_check = true; + // The `ALTER` flips only the schedule (rf, size, azs, logging unchanged), so + // the rejection is attributable solely to the witness `schedule` field. + ctx.concurrent_schedule_alter.insert(c, Sched::Manual); + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + // The drop was attempted but rejected by its compare-and-append guard, so the + // replica the user's now-MANUAL cluster owns is left untouched. + let drops = ctx.drops(); + assert_eq!(drops.len(), 1, "the drop was attempted"); + if let Decision::DropReplica { expected, .. } = drops[0] { + assert_eq!( + expected.schedule, + Sched::Refresh { + hydration_time_estimate: Duration::from_millis(0) + }, + "the drop was derived from the pre-ALTER (Refresh) schedule" + ); + } else { + panic!("expected a DropReplica"); + } + assert_eq!( + ctx.states[&c].replicas.len(), + 1, + "the rejected drop left the replica in place" + ); + assert_eq!(ctx.states[&c].schedule, Sched::Manual); +} + +#[mz_ore::test(tokio::test)] +async fn on_refresh_unchanged_schedule_passes_witness() { + // The dual of the rejection test: with the witness check on but no concurrent + // `ALTER`, the matching `schedule` lets the same out-of-window drop apply, so + // the check is not vacuously rejecting. + let c = cluster(1); + let state = scheduled_state( + c, + "100cc", + 0, + 0, + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![state]); + ctx.refresh_window + .insert(c, window_inputs(100, 0, Some(200), refresh_at(50))); + ctx.witness_check = true; + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + assert_eq!(ctx.drops().len(), 1, "the out-of-window replica is dropped"); + assert!( + ctx.states[&c].replicas.is_empty(), + "the drop applied under a matching witness" + ); +} + +mod hydration_burst { + use std::time::Duration; + + use mz_compute_types::config::ComputeReplicaLogging; + use mz_repr::Timestamp; + + use super::{ObservedReplica, cluster, observed, replica, state}; + use crate::ctx::{ + AutoScalingPolicy, BurstRecord, ClusterState, OnHydrationPolicy, ReplicaShape, StateWrite, + }; + use crate::strategy::{HYDRATION_BURST_STRATEGY_NAME, HydrationBurstStrategy, Strategy}; + + /// A MANUAL cluster carrying an `ON HYDRATION` policy at `hydration_size` with + /// the given linger, plus an optional in-flight burst record. `burst_enabled` + /// is on and the default linger is zero, matching a steady environment. + fn burst_state( + size: &str, + rf: u32, + hydration_size: &str, + linger: Duration, + replicas: Vec, + burst: Option, + ) -> ClusterState { + let mut s = state(cluster(1), size, rf, replicas); + s.auto_scaling_policy = Some(AutoScalingPolicy { + on_hydration: Some(OnHydrationPolicy { + hydration_size: hydration_size.to_string(), + linger_duration: Some(linger), + }), + }); + s.burst = burst; + s + } + + fn record(burst_size: &str, linger: Duration, stamped: Option) -> BurstRecord { + BurstRecord { + burst_size: burst_size.to_string(), + linger_duration: linger, + steady_hydrated_at: stamped.map(Timestamp::from), + } + } + + fn now(ms: u64) -> Timestamp { + Timestamp::from(ms) + } + + #[mz_ore::test] + fn burst_arms_when_steady_unhydrated() { + // Policy set, cluster On, the one steady replica not hydrated, no record: + // arm a burst at the hydration size. + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let write = HydrationBurstStrategy.update_state(&s, now(1000)); + let burst = write + .burst + .expect("a burst record is written") + .expect("present"); + assert_eq!(burst.burst_size, "400cc"); + assert_eq!(burst.linger_duration, Duration::from_millis(10)); + assert_eq!(burst.steady_hydrated_at, None); + } + + #[mz_ore::test] + fn burst_uses_default_linger_when_omitted() { + // The policy omits LINGER DURATION, so the record takes the env default. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::ZERO, + vec![observed(replica(1), "r0", "100cc")], + None, + ); + s.auto_scaling_policy = Some(AutoScalingPolicy { + on_hydration: Some(OnHydrationPolicy { + hydration_size: "400cc".to_string(), + linger_duration: None, + }), + }); + s.default_burst_linger = Duration::from_secs(42); + let write = HydrationBurstStrategy.update_state(&s, now(1000)); + let burst = write.burst.expect("written").expect("present"); + assert_eq!(burst.linger_duration, Duration::from_secs(42)); + } + + #[mz_ore::test] + fn burst_does_not_arm_when_steady_hydrated() { + // The steady replica is already hydrated, so no burst is warranted: no + // record is written. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + s.hydrated_replicas.insert(replica(1)); + assert!( + HydrationBurstStrategy + .update_state(&s, now(1000)) + .is_empty() + ); + } + + #[mz_ore::test] + fn burst_does_not_arm_without_objects() { + // Zero hydratable objects: a burst is never warranted, no matter what + // the steady set looks like. Neither an un-hydrated steady replica, an + // absent one, nor a hydrated one arms a burst. + let base = |replicas| { + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + replicas, + None, + ); + s.has_hydratable_objects = false; + s + }; + + // Steady replica present but un-hydrated. + let s = base(vec![observed(replica(1), "r0", "100cc")]); + assert!( + HydrationBurstStrategy + .update_state(&s, now(1000)) + .is_empty() + ); + // Steady replica absent entirely (a brand-new cluster's first ticks). + let s = base(Vec::new()); + assert!( + HydrationBurstStrategy + .update_state(&s, now(1000)) + .is_empty() + ); + // Steady replica reporting hydrated despite zero user objects (its + // log dataflows hydrated). + let mut s = base(vec![observed(replica(1), "r0", "100cc")]); + s.hydrated_replicas.insert(replica(1)); + assert!( + HydrationBurstStrategy + .update_state(&s, now(1000)) + .is_empty() + ); + } + + #[mz_ore::test] + fn burst_arms_with_unreporting_steady_replica_and_objects() { + // A cluster WITH objects whose steady replica reports nothing (crashed, + // restarting, or not yet registered with the compute controller) reads + // as un-hydrated, so a burst arms — correct: the objects are not served + // and a burst replica can pick them up. + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let write = HydrationBurstStrategy.update_state(&s, now(1000)); + assert!( + write.burst.is_some(), + "burst arms on an unreporting steady replica" + ); + + // Same with the steady replica absent entirely. + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + Vec::new(), + None, + ); + let write = HydrationBurstStrategy.update_state(&s, now(1000)); + assert!( + write.burst.is_some(), + "burst arms with no steady replica at all" + ); + } + + #[mz_ore::test] + fn burst_desires_one_replica_at_hydration_size() { + // With a record present, the strategy desires exactly one replica at the + // burst size (with the cluster's AZ pool and logging). + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + vec![observed(replica(1), "r0", "100cc")], + Some(record("400cc", Duration::from_millis(10), None)), + ); + let desired = HydrationBurstStrategy.desired_replicas(&s, now(1000)); + assert_eq!(desired.len(), 1); + assert_eq!(desired[0].shape.size, "400cc"); + } + + #[mz_ore::test] + fn burst_no_record_desires_nothing() { + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + assert!( + HydrationBurstStrategy + .desired_replicas(&s, now(1000)) + .is_empty() + ); + } + + #[mz_ore::test] + fn burst_stamps_then_lingers_then_tears_down() { + // Record present, steady replica hydrated for the first time: stamp the + // linger start. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(100), + vec![observed(replica(1), "r0", "100cc")], + Some(record("400cc", Duration::from_millis(100), None)), + ); + s.hydrated_replicas.insert(replica(1)); + let write = HydrationBurstStrategy.update_state(&s, now(1000)); + let burst = write.burst.expect("stamped").expect("present"); + assert_eq!(burst.steady_hydrated_at, Some(now(1000))); + + // Stamped, linger not yet elapsed (now=1050, stamped=1000, linger=100): hold. + let mut s = s.clone(); + s.burst = Some(record("400cc", Duration::from_millis(100), Some(1000))); + assert!( + HydrationBurstStrategy + .update_state(&s, now(1050)) + .is_empty() + ); + + // Stamped, linger elapsed (now=1101 > 1000+100): tear down. + let write = HydrationBurstStrategy.update_state(&s, now(1101)); + assert_eq!(write.burst, Some(None), "burst record cleared at teardown"); + } + + #[mz_ore::test] + fn burst_re_arms_when_steady_unhydrates() { + // Record present, previously stamped, but the steady set is no longer + // hydrated: reset the stamp so the linger restarts after the next hydration. + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(100), + vec![observed(replica(1), "r0", "100cc")], + Some(record("400cc", Duration::from_millis(100), Some(1000))), + ); + // hydrated_replicas is empty: the steady replica went un-hydrated. + let write = HydrationBurstStrategy.update_state(&s, now(1050)); + let burst = write.burst.expect("rewritten").expect("present"); + assert_eq!(burst.steady_hydrated_at, None, "stamp reset on re-arm"); + } + + #[mz_ore::test] + fn burst_tears_down_when_cluster_off() { + // The cluster was turned off (rf=0). A burst is no longer warranted, so the + // record is cleared regardless of linger. + let mut s = burst_state( + "100cc", + 0, + "400cc", + Duration::from_millis(100), + Vec::new(), + Some(record("400cc", Duration::from_millis(100), None)), + ); + s.replication_factor = 0; + assert_eq!( + HydrationBurstStrategy.update_state(&s, now(1000)).burst, + Some(None) + ); + } + + #[mz_ore::test] + fn burst_tears_down_when_policy_removed() { + // The policy was removed (the cluster no longer carries ON HYDRATION). The + // stale record is cleared. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(100), + vec![observed(replica(1), "r0", "100cc")], + Some(record("400cc", Duration::from_millis(100), None)), + ); + s.auto_scaling_policy = None; + assert_eq!( + HydrationBurstStrategy.update_state(&s, now(1000)).burst, + Some(None) + ); + } + + #[mz_ore::test] + fn burst_tears_down_on_size_change() { + // The HYDRATION SIZE changed from the record's size: the stale record is + // cleared (a fresh one at the new size is written on a later tick). + let s = burst_state( + "100cc", + 1, + "800cc", + Duration::from_millis(100), + vec![observed(replica(1), "r0", "100cc")], + Some(record("400cc", Duration::from_millis(100), None)), + ); + assert_eq!( + HydrationBurstStrategy.update_state(&s, now(1000)).burst, + Some(None) + ); + } + + #[mz_ore::test] + fn burst_break_glass_disables_strategy() { + // The break-glass flag is off: no burst is armed even when steady is + // un-hydrated, and an existing record is torn down. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(100), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + s.burst_enabled = false; + assert!( + HydrationBurstStrategy + .update_state(&s, now(1000)) + .is_empty() + ); + + s.burst = Some(record("400cc", Duration::from_millis(100), None)); + assert_eq!( + HydrationBurstStrategy.update_state(&s, now(1000)).burst, + Some(None) + ); + } + + #[mz_ore::test] + fn burst_no_policy_is_a_noop() { + // A plain MANUAL cluster with no autoscaling policy: the strategy never + // writes or desires anything. + let s = state( + cluster(1), + "100cc", + 1, + vec![observed(replica(1), "r0", "100cc")], + ); + assert!( + HydrationBurstStrategy + .update_state(&s, now(1000)) + .is_empty() + ); + assert!( + HydrationBurstStrategy + .desired_replicas(&s, now(1000)) + .is_empty() + ); + } + + #[mz_ore::test] + fn burst_replica_shape_carries_az_and_logging() { + // The burst replica differs from steady only in size: it carries the + // cluster's AZ pool and logging. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(10), + Vec::new(), + Some(record("400cc", Duration::from_millis(10), None)), + ); + s.availability_zones = vec!["az1".to_string(), "az2".to_string()]; + let desired = HydrationBurstStrategy.desired_replicas(&s, now(1000)); + let expected = ReplicaShape { + size: "400cc".to_string(), + availability_zones: s.availability_zones.clone(), + logging: ComputeReplicaLogging::default(), + }; + assert!(desired[0].shape.matches(&expected)); + } + + #[mz_ore::test] + fn burst_strategy_name() { + assert_eq!(HydrationBurstStrategy.name(), HYDRATION_BURST_STRATEGY_NAME); + } + + #[mz_ore::test(tokio::test)] + async fn burst_seam_creates_then_tears_down() { + use super::FakeCtx; + use crate::ClusterController; + use crate::ctx::Decision; + + // A cluster with a 100cc steady replica that is not hydrated and an + // ON HYDRATION (400cc) policy. The controller writes a burst record + // (phase 1) and creates the 400cc burst replica (phase 2). + let c = cluster(1); + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(0), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![s]); + ctx.has_hydratable_objects.insert(c, true); + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + // The burst replica was created at the hydration size. + let burst_creates: Vec<_> = ctx + .creates() + .into_iter() + .filter(|d| matches!(d, Decision::CreateReplica { shape, .. } if shape.size == "400cc")) + .collect(); + assert_eq!(burst_creates.len(), 1, "one 400cc burst replica created"); + assert!( + matches!(&burst_creates[0], Decision::CreateReplica { reasons, .. } if reasons.contains(&HYDRATION_BURST_STRATEGY_NAME)), + "the create is attributed to the burst strategy" + ); + assert!( + matches!( + &burst_creates[0], + Decision::CreateReplica { + audit_detail: None, + .. + } + ), + "only on-refresh creates carry a window decision" + ); + assert!( + ctx.states[&c].burst.is_some(), + "the burst record was written" + ); + + // Now mark the steady replica hydrated; with a zero linger the next tick + // (advancing `now`) stamps and then tears down the burst. + ctx.hydrated.insert(replica(1)); + ctx.now = Timestamp::from(2000u64); + controller.reconcile(&mut ctx).await; + // First post-hydration tick stamps `steady_hydrated_at`. + ctx.now = Timestamp::from(3000u64); + controller.reconcile(&mut ctx).await; + assert!( + ctx.states[&c].burst.is_none(), + "the burst record is cleared after the (zero) linger elapses" + ); + assert!( + !ctx.states[&c] + .replicas + .iter() + .any(|r| r.shape.size == "400cc"), + "the burst replica is torn down" + ); + } + + #[mz_ore::test(tokio::test)] + async fn burst_empty_cluster_never_arms_through_seam() { + use super::FakeCtx; + use crate::ClusterController; + + // A strategy-carrying cluster with zero hydratable objects never arms, + // tick after tick — neither while its steady replica has not yet + // registered (reports un-hydrated) nor once it reports hydrated (its + // log dataflows). This is the brand-new-cluster case: no burst at + // creation. + let c = cluster(1); + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(0), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + // No `has_hydratable_objects` entry on the ctx: the pull reports no + // objects. + let mut ctx = FakeCtx::new(vec![s]); + let controller = ClusterController::new(); + + // Ticks with the steady replica not reporting hydrated (booting). + controller.reconcile(&mut ctx).await; + ctx.now = Timestamp::from(2000u64); + controller.reconcile(&mut ctx).await; + // Ticks once it reports. + ctx.hydrated.insert(replica(1)); + ctx.now = Timestamp::from(3000u64); + controller.reconcile(&mut ctx).await; + + assert!( + ctx.applied.is_empty(), + "an object-less cluster produces no decisions at all, got {:?}", + ctx.applied + ); + assert!(ctx.states[&c].burst.is_none(), "no burst record ever"); + assert_eq!( + ctx.hydration_probes, 0, + "an object-less cluster is never even probed for hydration" + ); + } + + #[mz_ore::test(tokio::test)] + async fn burst_arms_when_first_object_lands_through_seam() { + use super::FakeCtx; + use crate::ClusterController; + use crate::ctx::Decision; + + // The dual of the never-arms test: the same cluster arms as soon as its + // first hydratable object exists while the steady set is un-hydrated. + let c = cluster(1); + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(0), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![s]); + let controller = ClusterController::new(); + + controller.reconcile(&mut ctx).await; + assert!(ctx.applied.is_empty(), "no objects: nothing happens"); + + // The first object lands (e.g. CREATE INDEX); the steady replica has + // not hydrated it. The controller only learns this through its + // `has_hydratable_objects` pull. + ctx.has_hydratable_objects.insert(c, true); + ctx.now = Timestamp::from(2000u64); + controller.reconcile(&mut ctx).await; + + assert!( + ctx.states[&c].burst.is_some(), + "the burst record was written once an object existed" + ); + let burst_creates: Vec<_> = ctx + .creates() + .into_iter() + .filter(|d| matches!(d, Decision::CreateReplica { shape, .. } if shape.size == "400cc")) + .collect(); + assert_eq!(burst_creates.len(), 1, "one 400cc burst replica created"); + } + + #[mz_ore::test(tokio::test)] + async fn burst_policy_alter_rejects_in_flight_decision() { + use super::FakeCtx; + use crate::ClusterController; + use crate::ctx::Decision; + + // The `auto_scaling_policy` field of the compare-and-append witness is + // load-bearing: a concurrent `ALTER ... RESET (AUTO SCALING STRATEGY)` + // that lands between the controller's read and its append must reject the + // in-flight burst write, so the controller never arms a burst on a cluster + // whose policy the user just cleared. With `witness_check` on, this + // exercises the real per-decision compare, so dropping `auto_scaling_policy` + // from `ExpectedClusterState` would make this test fail. + let c = cluster(1); + // Policy set, cluster On, the steady replica not hydrated, no record: the + // strategy emits a phase-1 burst write carrying `expected.auto_scaling_policy`. + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(0), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![s]); + ctx.has_hydratable_objects.insert(c, true); + ctx.witness_check = true; + // The `ALTER` clears only the policy (size, rf, azs, logging unchanged), so + // the rejection is attributable solely to the witness `auto_scaling_policy`. + ctx.concurrent_policy_alter.insert(c, None); + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + // The burst write was attempted but rejected by its compare-and-append + // guard, so no burst record landed and no burst replica was created. + let writes: Vec<_> = ctx + .applied + .iter() + .flatten() + .filter(|d| matches!(d, Decision::UpdateClusterState { .. })) + .collect(); + assert_eq!(writes.len(), 1, "the burst write was attempted"); + assert!( + ctx.states[&c].burst.is_none(), + "the rejected write left no burst record" + ); + assert!( + !ctx.states[&c] + .replicas + .iter() + .any(|r| r.shape.size == "400cc"), + "no burst replica was created under the rejected witness" + ); + assert!( + ctx.states[&c].auto_scaling_policy.is_none(), + "the user's policy reset stands" + ); + } + + #[mz_ore::test(tokio::test)] + async fn burst_unchanged_policy_passes_witness() { + use super::FakeCtx; + use crate::ClusterController; + + // The dual of the rejection test: with the witness check on but no + // concurrent policy `ALTER`, the matching `auto_scaling_policy` lets the + // same burst write apply, so the check is not vacuously rejecting. + let c = cluster(1); + let s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(0), + vec![observed(replica(1), "r0", "100cc")], + None, + ); + let mut ctx = FakeCtx::new(vec![s]); + ctx.has_hydratable_objects.insert(c, true); + ctx.witness_check = true; + + let controller = ClusterController::new(); + controller.reconcile(&mut ctx).await; + + assert!( + ctx.states[&c].burst.is_some(), + "the burst record was written under a matching witness" + ); + assert!( + ctx.states[&c] + .replicas + .iter() + .any(|r| r.shape.size == "400cc"), + "the burst replica was created under a matching witness" + ); + } + + #[mz_ore::test] + fn burst_success_precedence_when_hydrated_with_record() { + // Record present and steady hydrated, but already stamped within linger: + // the record is held, not torn down, until linger elapses (a previous + // arm/stamp test path). Here a fresh stamp happens because not yet stamped. + let mut s = burst_state( + "100cc", + 1, + "400cc", + Duration::from_millis(50), + vec![observed(replica(1), "r0", "100cc")], + Some(record("400cc", Duration::from_millis(50), None)), + ); + s.hydrated_replicas.insert(replica(1)); + let write: StateWrite = HydrationBurstStrategy.update_state(&s, now(2000)); + let burst = write.burst.expect("stamped").expect("present"); + assert_eq!(burst.steady_hydrated_at, Some(now(2000))); + } +} diff --git a/src/controller/src/clusters.rs b/src/controller/src/clusters.rs index 38437c72ea4c8..f840acab6d153 100644 --- a/src/controller/src/clusters.rs +++ b/src/controller/src/clusters.rs @@ -351,18 +351,6 @@ pub struct UnmanagedReplicaLocation { pub computectl_addrs: Vec, } -/// Information about availability zone constraints for replicas. -#[derive(Clone, Debug, PartialEq, Eq)] -pub enum ManagedReplicaAvailabilityZones { - /// Specified if the `Replica` is from `MANAGED` cluster, - /// and specifies if there is an `AVAILABILITY ZONES` - /// constraint. Empty lists are represented as `None`. - FromCluster(Option>), - /// Specified if the `Replica` is from a non-`MANAGED` cluster, - /// and specifies if there is a specific `AVAILABILITY ZONE`. - FromReplica(Option), -} - /// The location of a managed replica. #[derive(Clone, Debug, Serialize, PartialEq)] pub struct ManagedReplicaLocation { @@ -374,21 +362,18 @@ pub struct ManagedReplicaLocation { pub internal: bool, /// Optional SQL size parameter used for billing. pub billed_as: Option, - /// The replica's availability zones, if specified. - /// - /// This is either the replica's specific `AVAILABILITY ZONE`, - /// or the zones placed here during replica concretization - /// from the `MANAGED` cluster config. + /// The availability zones the replica may be placed in; empty means + /// unconstrained. /// - /// We skip serialization (which is used for some validation - /// in tests) as the latter case is a "virtual" piece of information, - /// that exists only at runtime. + /// For a replica of a managed cluster this is the cluster's + /// `AVAILABILITY ZONES` pool; for a replica of an unmanaged cluster it is + /// the single user-pinned `AVAILABILITY ZONE`, as a zero- or one-element + /// list. /// - /// An empty list of availability zones is concretized as `None`, - /// as the on-disk serialization of `MANAGED CLUSTER AVAILABILITY ZONES` - /// is an empty list if none are specified + /// Not serialized: this is re-derived from the cluster config at + /// concretization, not read back from a durable record. #[serde(skip)] - pub availability_zones: ManagedReplicaAvailabilityZones, + pub availability_zones: Vec, /// Whether the replica is pending reconfiguration pub pending: bool, } @@ -882,10 +867,9 @@ impl Controller { ), ("cluster-name".into(), cluster_name), ]), - availability_zones: match location.availability_zones { - ManagedReplicaAvailabilityZones::FromCluster(azs) => azs, - ManagedReplicaAvailabilityZones::FromReplica(az) => az.map(|z| vec![z]), - }, + // An empty list means no AZ constraint; a non-empty one pins + // placement to those zones. + availability_zones: Some(location.availability_zones).filter(|azs| !azs.is_empty()), // This provides the orchestrator with some label selectors that // are used to constraint the scheduling of replicas, based on // its internal configuration. diff --git a/src/mz-deploy/src/project/compiler/typecheck/catalog.rs b/src/mz-deploy/src/project/compiler/typecheck/catalog.rs index 6bbc59c432230..3de2c248faef3 100644 --- a/src/mz-deploy/src/project/compiler/typecheck/catalog.rs +++ b/src/mz-deploy/src/project/compiler/typecheck/catalog.rs @@ -295,6 +295,9 @@ impl<'a> CatalogCluster<'a> for StubCluster { None } + fn auto_scaling_strategy(&self) -> Option<&mz_sql::plan::AutoScalingStrategy> { + None + } fn try_to_plan(&self) -> Result { Err(PlanError::Unsupported { feature: "clusters are not supported by the catalog typecheck backend".into(), diff --git a/src/pgrepr-consts/src/oid.rs b/src/pgrepr-consts/src/oid.rs index 87dcf0b05b9e8..8f61a96a8ae85 100644 --- a/src/pgrepr-consts/src/oid.rs +++ b/src/pgrepr-consts/src/oid.rs @@ -800,3 +800,7 @@ pub const FUNC_MZ_SESSION_ROLE_MEMBERSHIPS_OID: u32 = 17086; pub const VIEW_MZ_BUILTIN_SOURCES_OID: u32 = 17087; pub const TABLE_MZ_CLUSTER_REPLICA_SIZE_INTERNAL_OID: u32 = 17088; pub const INDEX_MZ_CLUSTER_REPLICA_SIZE_INTERNAL_IND_OID: u32 = 17089; +pub const MV_MZ_CLUSTER_RECONFIGURATIONS_OID: u32 = 17090; +pub const INDEX_MZ_CLUSTER_RECONFIGURATIONS_IND_OID: u32 = 17091; +pub const MV_MZ_CLUSTER_AUTO_SCALING_STRATEGIES_OID: u32 = 17092; +pub const INDEX_MZ_CLUSTER_AUTO_SCALING_STRATEGIES_IND_OID: u32 = 17093; diff --git a/src/sql-lexer/src/keywords.txt b/src/sql-lexer/src/keywords.txt index 7a1d427d27d7b..669a0007a302a 100644 --- a/src/sql-lexer/src/keywords.txt +++ b/src/sql-lexer/src/keywords.txt @@ -56,6 +56,7 @@ Assume At Auction Authority +Auto Availability Avro Aws @@ -155,6 +156,7 @@ Doc Dot Double Drop +Duration Eager Element Else @@ -269,6 +271,7 @@ Level Like Limit Linear +Linger List Load Local @@ -420,6 +423,7 @@ Rows Rules Sasl Scale +Scaling Schedule Schema Schemas diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index bd58e4f71711c..8b479389330c7 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -2218,6 +2218,8 @@ impl_display_t!(CreateTypeStatement); #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum ClusterOptionName { + /// The `AUTO SCALING STRATEGY [[=] (...)]` option. + AutoScalingStrategy, /// The `AVAILABILITY ZONES [[=] '[' ']' ]` option. AvailabilityZones, /// The `DISK` option. @@ -2243,6 +2245,7 @@ pub enum ClusterOptionName { impl AstDisplay for ClusterOptionName { fn fmt(&self, f: &mut AstFormatter) { match self { + ClusterOptionName::AutoScalingStrategy => f.write_str("AUTO SCALING STRATEGY"), ClusterOptionName::AvailabilityZones => f.write_str("AVAILABILITY ZONES"), ClusterOptionName::Disk => f.write_str("DISK"), ClusterOptionName::IntrospectionDebugging => f.write_str("INTROSPECTION DEBUGGING"), @@ -2265,7 +2268,8 @@ impl WithOptionName for ClusterOptionName { /// on the conservative side and return `true`. fn redact_value(&self) -> bool { match self { - ClusterOptionName::AvailabilityZones + ClusterOptionName::AutoScalingStrategy + | ClusterOptionName::AvailabilityZones | ClusterOptionName::Disk | ClusterOptionName::IntrospectionDebugging | ClusterOptionName::IntrospectionInterval @@ -4416,6 +4420,7 @@ pub enum WithOptionValue { RetainHistoryFor(Value), Refresh(RefreshOptionValue), ClusterScheduleOptionValue(ClusterScheduleOptionValue), + ClusterAutoScalingStrategyOptionValue(ClusterAutoScalingStrategyOptionValue), ClusterAlterStrategy(ClusterAlterOptionValue), NetworkPolicyRules(Vec>), } @@ -4446,6 +4451,7 @@ impl AstDisplay for WithOptionValue { | WithOptionValue::KafkaMatchingBrokerRule(_) | WithOptionValue::ClusterReplicas(_) | WithOptionValue::ClusterScheduleOptionValue(_) + | WithOptionValue::ClusterAutoScalingStrategyOptionValue(_) | WithOptionValue::ClusterAlterStrategy(_) | WithOptionValue::NetworkPolicyRules(_) => { // These do not need redaction. @@ -4507,6 +4513,7 @@ impl AstDisplay for WithOptionValue { } WithOptionValue::Refresh(opt) => f.write_node(opt), WithOptionValue::ClusterScheduleOptionValue(value) => f.write_node(value), + WithOptionValue::ClusterAutoScalingStrategyOptionValue(value) => f.write_node(value), WithOptionValue::ClusterAlterStrategy(value) => f.write_node(value), } } @@ -4608,6 +4615,67 @@ impl AstDisplay for ClusterScheduleOptionValue { } } +/// The value of the `AUTO SCALING STRATEGY` cluster option: the autoscaling +/// policy block. Extensible — future strategies are additional optional +/// sub-policies, so the block grows without changing existing ones. An empty +/// block (all sub-policies absent) disables autoscaling for the cluster, the same +/// as `RESET (AUTO SCALING STRATEGY)`. +#[derive( + Debug, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Deserialize, + Serialize +)] +pub struct ClusterAutoScalingStrategyOptionValue { + pub on_hydration: Option, +} + +impl AstDisplay for ClusterAutoScalingStrategyOptionValue { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("("); + if let Some(on_hydration) = &self.on_hydration { + f.write_node(on_hydration); + } + f.write_str(")"); + } +} + +/// The `ON HYDRATION` autoscaling sub-policy: while objects are un-hydrated, run +/// an extra replica at `hydration_size` to accelerate hydration, lingering for +/// `linger_duration` after the steady-state replicas hydrate. +#[derive( + Debug, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Deserialize, + Serialize +)] +pub struct OnHydrationOptionValue { + pub hydration_size: Value, + pub linger_duration: Option, +} + +impl AstDisplay for OnHydrationOptionValue { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("ON HYDRATION (HYDRATION SIZE = "); + f.write_node(&self.hydration_size); + if let Some(linger_duration) = &self.linger_duration { + f.write_str(", LINGER DURATION = "); + f.write_node(linger_duration); + } + f.write_str(")"); + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub enum TransactionMode { AccessMode(TransactionAccessMode), diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index 7d9d1008b314f..b0cb2beb2755b 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -4499,6 +4499,7 @@ impl<'a> Parser<'a> { fn parse_cluster_option_name(&mut self) -> Result { let option = self.expect_one_of_keywords(&[ + AUTO, AVAILABILITY, DISK, INTROSPECTION, @@ -4510,6 +4511,10 @@ impl<'a> Parser<'a> { WORKLOAD, ])?; let name = match option { + AUTO => { + self.expect_keywords(&[SCALING, STRATEGY])?; + ClusterOptionName::AutoScalingStrategy + } AVAILABILITY => { self.expect_keyword(ZONES)?; ClusterOptionName::AvailabilityZones @@ -4543,6 +4548,9 @@ impl<'a> Parser<'a> { match name { ClusterOptionName::Replicas => self.parse_cluster_option_replicas(), ClusterOptionName::Schedule => self.parse_cluster_option_schedule(), + ClusterOptionName::AutoScalingStrategy => { + self.parse_cluster_option_auto_scaling_strategy() + } _ => { let value = self.parse_optional_option_value()?; Ok(ClusterOption { name, value }) @@ -4645,6 +4653,60 @@ impl<'a> Parser<'a> { }) } + /// Parse the value of the `AUTO SCALING STRATEGY` cluster option: a + /// paren-enclosed list of strategy sub-policies. v1 supports only + /// `ON HYDRATION (HYDRATION SIZE = '...' [, LINGER DURATION = '...'])`. An + /// empty list `()` disables autoscaling. + fn parse_cluster_option_auto_scaling_strategy( + &mut self, + ) -> Result, ParserError> { + let _ = self.consume_token(&Token::Eq); + self.expect_token(&Token::LParen)?; + let mut value = ClusterAutoScalingStrategyOptionValue { on_hydration: None }; + if !self.consume_token(&Token::RParen) { + // The list is a comma-separated set of strategy sub-policies, each + // named by a leading keyword. Only `ON HYDRATION` exists in v1. + loop { + self.expect_keywords(&[ON, HYDRATION])?; + self.expect_token(&Token::LParen)?; + self.expect_keywords(&[HYDRATION, SIZE])?; + let _ = self.consume_token(&Token::Eq); + let hydration_size = self.parse_value()?; + let linger_duration = if self.consume_token(&Token::Comma) { + self.expect_keywords(&[LINGER, DURATION])?; + let _ = self.consume_token(&Token::Eq); + Some(self.parse_value()?) + } else { + None + }; + self.expect_token(&Token::RParen)?; + // Each sub-policy may appear at most once; a repeated entry would + // otherwise silently keep only the last. + if value.on_hydration.is_some() { + return parser_err!( + self, + self.peek_prev_pos(), + "ON HYDRATION specified more than once" + ); + } + value.on_hydration = Some(OnHydrationOptionValue { + hydration_size, + linger_duration, + }); + if !self.consume_token(&Token::Comma) { + break; + } + } + self.expect_token(&Token::RParen)?; + } + Ok(ClusterOption { + name: ClusterOptionName::AutoScalingStrategy, + value: Some(WithOptionValue::ClusterAutoScalingStrategyOptionValue( + value, + )), + }) + } + fn parse_replica_option(&mut self) -> Result, ParserError> { let name = match self.expect_one_of_keywords(&[ AVAILABILITY, diff --git a/src/sql-parser/tests/testdata/ddl b/src/sql-parser/tests/testdata/ddl index d76559b4e05f2..9c05b5d9af82e 100644 --- a/src/sql-parser/tests/testdata/ddl +++ b/src/sql-parser/tests/testdata/ddl @@ -1978,14 +1978,14 @@ CreateCluster(CreateClusterStatement { name: Ident("cluster"), options: [Cluster parse-statement CREATE CLUSTER cluster WITH REPLICAS () ---- -error: Expected one of AVAILABILITY or DISK or INTROSPECTION or MANAGED or REPLICAS or REPLICATION or SIZE or SCHEDULE or WORKLOAD, found WITH +error: Expected one of AUTO or AVAILABILITY or DISK or INTROSPECTION or MANAGED or REPLICAS or REPLICATION or SIZE or SCHEDULE or WORKLOAD, found WITH CREATE CLUSTER cluster WITH REPLICAS () ^ parse-statement CREATE CLUSTER cluster REPLICAS (), BADOPT ---- -error: Expected one of AVAILABILITY or DISK or INTROSPECTION or MANAGED or REPLICAS or REPLICATION or SIZE or SCHEDULE or WORKLOAD, found identifier "badopt" +error: Expected one of AUTO or AVAILABILITY or DISK or INTROSPECTION or MANAGED or REPLICAS or REPLICATION or SIZE or SCHEDULE or WORKLOAD, found identifier "badopt" CREATE CLUSTER cluster REPLICAS (), BADOPT ^ @@ -2164,6 +2164,55 @@ error: Expected right parenthesis, found EOF CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', SCHEDULE = ON REFRESH (HYDRATION TIME ESTIMATE = '1 hour') ^ +parse-statement +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc', LINGER DURATION = '600s'))) +---- +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc', LINGER DURATION = '600s'))) +=> +CreateCluster(CreateClusterStatement { name: Ident("cluster"), options: [ClusterOption { name: Size, value: Some(Value(String("scale=1,workers=1"))) }, ClusterOption { name: AutoScalingStrategy, value: Some(ClusterAutoScalingStrategyOptionValue(ClusterAutoScalingStrategyOptionValue { on_hydration: Some(OnHydrationOptionValue { hydration_size: String("400cc"), linger_duration: Some(String("600s")) }) })) }], features: [] }) + +parse-statement +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc'))) +---- +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc'))) +=> +CreateCluster(CreateClusterStatement { name: Ident("cluster"), options: [ClusterOption { name: Size, value: Some(Value(String("scale=1,workers=1"))) }, ClusterOption { name: AutoScalingStrategy, value: Some(ClusterAutoScalingStrategyOptionValue(ClusterAutoScalingStrategyOptionValue { on_hydration: Some(OnHydrationOptionValue { hydration_size: String("400cc"), linger_duration: None }) })) }], features: [] }) + +parse-statement +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = ()) +---- +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = ()) +=> +CreateCluster(CreateClusterStatement { name: Ident("cluster"), options: [ClusterOption { name: Size, value: Some(Value(String("scale=1,workers=1"))) }, ClusterOption { name: AutoScalingStrategy, value: Some(ClusterAutoScalingStrategyOptionValue(ClusterAutoScalingStrategyOptionValue { on_hydration: None })) }], features: [] }) + +parse-statement +ALTER CLUSTER cluster SET (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc'))) +---- +ALTER CLUSTER cluster SET (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc'))) +=> +AlterCluster(AlterClusterStatement { if_exists: false, name: Ident("cluster"), action: SetOptions { options: [ClusterOption { name: AutoScalingStrategy, value: Some(ClusterAutoScalingStrategyOptionValue(ClusterAutoScalingStrategyOptionValue { on_hydration: Some(OnHydrationOptionValue { hydration_size: String("400cc"), linger_duration: None }) })) }], with_options: [] } }) + +parse-statement +ALTER CLUSTER cluster RESET (AUTO SCALING STRATEGY) +---- +ALTER CLUSTER cluster RESET (AUTO SCALING STRATEGY) +=> +AlterCluster(AlterClusterStatement { if_exists: false, name: Ident("cluster"), action: ResetOptions([AutoScalingStrategy]) }) + +parse-statement +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION)) +---- +error: Expected left parenthesis, found right parenthesis +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION)) + ^ + +parse-statement +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc'), ON HYDRATION (HYDRATION SIZE = '800cc'))) +---- +error: ON HYDRATION specified more than once +CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '400cc'), ON HYDRATION (HYDRATION SIZE = '800cc'))) + ^ + parse-statement CREATE CLUSTER cluster (SIZE = 'scale=1,workers=1', WORKLOAD CLASS NULL) ---- diff --git a/src/sql/src/catalog.rs b/src/sql/src/catalog.rs index 68c0eb1a1065b..9ece063cb4417 100644 --- a/src/sql/src/catalog.rs +++ b/src/sql/src/catalog.rs @@ -53,7 +53,9 @@ use crate::names::{ }; use crate::plan::statement::StatementDesc; use crate::plan::statement::ddl::PlannedRoleAttributes; -use crate::plan::{ClusterSchedule, CreateClusterPlan, PlanError, PlanNotice, query}; +use crate::plan::{ + AutoScalingStrategy, ClusterSchedule, CreateClusterPlan, PlanError, PlanNotice, query, +}; use crate::session::vars::{OwnedVarInput, SystemVars}; /// A catalog keeps track of SQL objects and session state available to the @@ -777,6 +779,9 @@ pub trait CatalogCluster<'a> { /// Returns the replication factor of the cluster, if the cluster is a managed cluster. fn replication_factor(&self) -> Option; + /// Returns the user-configured autoscaling strategy of the cluster, if the + /// cluster is managed and has one set. + fn auto_scaling_strategy(&self) -> Option<&AutoScalingStrategy>; /// Try to convert this cluster into a [`CreateClusterPlan`]. // TODO(jkosh44) Make this infallible and convert to `to_plan`. fn try_to_plan(&self) -> Result; diff --git a/src/sql/src/names.rs b/src/sql/src/names.rs index b45b63477c169..76eb89744dff4 100644 --- a/src/sql/src/names.rs +++ b/src/sql/src/names.rs @@ -2041,6 +2041,9 @@ impl<'a> Fold for NameResolver<'a> { RetainHistoryFor(value) => RetainHistoryFor(self.fold_value(value)), Refresh(refresh) => Refresh(self.fold_refresh_option_value(refresh)), ClusterScheduleOptionValue(value) => ClusterScheduleOptionValue(value), + ClusterAutoScalingStrategyOptionValue(value) => { + ClusterAutoScalingStrategyOptionValue(value) + } ClusterAlterStrategy(value) => { ClusterAlterStrategy(self.fold_cluster_alter_option_value(value)) } diff --git a/src/sql/src/plan.rs b/src/sql/src/plan.rs index c475f02d4c413..e6fded28f61c5 100644 --- a/src/sql/src/plan.rs +++ b/src/sql/src/plan.rs @@ -587,6 +587,9 @@ pub struct CreateClusterManagedPlan { pub compute: ComputeReplicaConfig, pub optimizer_feature_overrides: OptimizerFeatureOverrides, pub schedule: ClusterSchedule, + /// The user-configured autoscaling policy, or `None` if autoscaling is + /// disabled for the cluster. + pub auto_scaling_strategy: Option, } #[derive(Debug)] @@ -653,6 +656,25 @@ impl Default for ClusterSchedule { } } +/// The user-configured autoscaling policy of a managed cluster. +/// +/// Extensible: future strategies are added as additional optional sub-policies, +/// so the block as a whole can grow without changing existing ones. +#[derive(Clone, Debug, Deserialize, Serialize, PartialOrd, PartialEq, Eq, Ord)] +pub struct AutoScalingStrategy { + pub on_hydration: Option, +} + +/// The `ON HYDRATION` autoscaling sub-policy: while objects are un-hydrated, run +/// an extra replica at `hydration_size` to accelerate hydration. +#[derive(Clone, Debug, Deserialize, Serialize, PartialOrd, PartialEq, Eq, Ord)] +pub struct OnHydration { + pub hydration_size: String, + /// How long the burst replica lingers after the steady-state replicas + /// hydrate. `None` falls back to the system default at the controller. + pub linger_duration: Option, +} + #[derive(Debug)] pub struct CreateSourcePlan { pub name: QualifiedItemName, @@ -2063,6 +2085,9 @@ pub struct PlanClusterOption { pub size: AlterOptionParameter, pub schedule: AlterOptionParameter, pub workload_class: AlterOptionParameter>, + /// The autoscaling policy block. `Set(None)` disables autoscaling (an empty + /// `AUTO SCALING STRATEGY = ()` or `RESET (AUTO SCALING STRATEGY)`). + pub auto_scaling_strategy: AlterOptionParameter>, } impl Default for PlanClusterOption { @@ -2077,6 +2102,7 @@ impl Default for PlanClusterOption { size: AlterOptionParameter::Unchanged, schedule: AlterOptionParameter::Unchanged, workload_class: AlterOptionParameter::Unchanged, + auto_scaling_strategy: AlterOptionParameter::Unchanged, } } } @@ -2091,15 +2117,32 @@ pub enum AlterClusterPlanStrategy { }, } -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive( + Clone, + Copy, + Debug, + Deserialize, + Serialize, + PartialOrd, + PartialEq, + Eq, + Ord +)] pub enum OnTimeoutAction { + /// Cut over to the target shape even though it has not hydrated. Commit, + /// Drop the target replicas and keep the pre-reconfiguration set. Rollback, } impl Default for OnTimeoutAction { fn default() -> Self { - Self::Commit + // The safe, conservative default: a reconfiguration that times out + // un-hydrated reverts to its pre-reconfiguration shape rather than cutting + // over to a not-yet-hydrated target (which could induce downtime). Applied + // uniformly — the controller and the legacy foreground wait path both read + // this default when an `ALTER` omits `ON TIMEOUT`. + Self::Rollback } } diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index 5b9ab10417a33..58b29012356ed 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -53,11 +53,11 @@ use mz_sql_parser::ast::{ AlterSystemResetStatement, AlterSystemSetStatement, AlterTableAddColumnStatement, AvroSchema, AvroSchemaOption, AvroSchemaOptionName, ClusterAlterOption, ClusterAlterOptionName, ClusterAlterOptionValue, ClusterAlterUntilReadyOption, ClusterAlterUntilReadyOptionName, - ClusterFeature, ClusterFeatureName, ClusterOption, ClusterOptionName, - ClusterScheduleOptionValue, ColumnDef, ColumnOption, CommentObjectType, CommentStatement, - ConnectionOption, ConnectionOptionName, CreateClusterReplicaStatement, CreateClusterStatement, - CreateConnectionOption, CreateConnectionOptionName, CreateConnectionStatement, - CreateConnectionType, CreateDatabaseStatement, CreateIndexStatement, + ClusterAutoScalingStrategyOptionValue, ClusterFeature, ClusterFeatureName, ClusterOption, + ClusterOptionName, ClusterScheduleOptionValue, ColumnDef, ColumnOption, CommentObjectType, + CommentStatement, ConnectionOption, ConnectionOptionName, CreateClusterReplicaStatement, + CreateClusterStatement, CreateConnectionOption, CreateConnectionOptionName, + CreateConnectionStatement, CreateConnectionType, CreateDatabaseStatement, CreateIndexStatement, CreateMaterializedViewStatement, CreateNetworkPolicyStatement, CreateRoleStatement, CreateSchemaStatement, CreateSecretStatement, CreateSinkConnection, CreateSinkOption, CreateSinkOptionName, CreateSinkStatement, CreateSourceConnection, CreateSourceOption, @@ -73,12 +73,12 @@ use mz_sql_parser::ast::{ LoadGeneratorOptionName, MaterializedViewOption, MaterializedViewOptionName, MySqlConfigOption, MySqlConfigOptionName, NetworkPolicyOption, NetworkPolicyOptionName, NetworkPolicyRuleDefinition, NetworkPolicyRuleOption, NetworkPolicyRuleOptionName, - PgConfigOption, PgConfigOptionName, ProtobufSchema, QualifiedReplica, RefreshAtOptionValue, - RefreshEveryOptionValue, RefreshOptionValue, ReplicaDefinition, ReplicaOption, - ReplicaOptionName, RoleAttribute, SetRoleVar, SourceErrorPolicy, SourceIncludeMetadata, - SqlServerConfigOption, SqlServerConfigOptionName, Statement, TableConstraint, - TableFromSourceColumns, TableFromSourceOption, TableFromSourceOptionName, TableOption, - TableOptionName, UnresolvedDatabaseName, UnresolvedItemName, UnresolvedObjectName, + OnHydrationOptionValue, PgConfigOption, PgConfigOptionName, ProtobufSchema, QualifiedReplica, + RefreshAtOptionValue, RefreshEveryOptionValue, RefreshOptionValue, ReplicaDefinition, + ReplicaOption, ReplicaOptionName, RoleAttribute, SetRoleVar, SourceErrorPolicy, + SourceIncludeMetadata, SqlServerConfigOption, SqlServerConfigOptionName, Statement, + TableConstraint, TableFromSourceColumns, TableFromSourceOption, TableFromSourceOptionName, + TableOption, TableOptionName, UnresolvedDatabaseName, UnresolvedItemName, UnresolvedObjectName, UnresolvedSchemaName, Value, ViewDefinition, WithOptionValue, }; use mz_sql_parser::ident; @@ -151,22 +151,23 @@ use crate::plan::{ AlterOptionParameter, AlterRetainHistoryPlan, AlterRolePlan, AlterSchemaRenamePlan, AlterSchemaSwapPlan, AlterSecretPlan, AlterSetClusterPlan, AlterSinkPlan, AlterSourceTimestampIntervalPlan, AlterSystemResetAllPlan, AlterSystemResetPlan, - AlterSystemSetPlan, AlterTablePlan, ClusterSchedule, CommentPlan, ComputeReplicaConfig, - ComputeReplicaIntrospectionConfig, ConnectionDetails, CreateClusterManagedPlan, - CreateClusterPlan, CreateClusterReplicaPlan, CreateClusterUnmanagedPlan, CreateClusterVariant, - CreateConnectionPlan, CreateDatabasePlan, CreateIndexPlan, CreateMaterializedViewPlan, - CreateNetworkPolicyPlan, CreateRolePlan, CreateSchemaPlan, CreateSecretPlan, CreateSinkPlan, - CreateSourcePlan, CreateTablePlan, CreateTypePlan, CreateViewPlan, DataSourceDesc, - DropObjectsPlan, DropOwnedPlan, HirRelationExpr, Index, MaterializedView, NetworkPolicyRule, - NetworkPolicyRuleAction, NetworkPolicyRuleDirection, Plan, PlanClusterOption, PlanNotice, - PolicyAddress, QueryContext, ReplicaConfig, Secret, Sink, Source, Table, TableDataSource, Type, - VariableValue, View, WebhookBodyFormat, WebhookHeaderFilters, WebhookHeaders, - WebhookValidation, literal, plan_utils, query, transform_ast, + AlterSystemSetPlan, AlterTablePlan, AutoScalingStrategy, ClusterSchedule, CommentPlan, + ComputeReplicaConfig, ComputeReplicaIntrospectionConfig, ConnectionDetails, + CreateClusterManagedPlan, CreateClusterPlan, CreateClusterReplicaPlan, + CreateClusterUnmanagedPlan, CreateClusterVariant, CreateConnectionPlan, CreateDatabasePlan, + CreateIndexPlan, CreateMaterializedViewPlan, CreateNetworkPolicyPlan, CreateRolePlan, + CreateSchemaPlan, CreateSecretPlan, CreateSinkPlan, CreateSourcePlan, CreateTablePlan, + CreateTypePlan, CreateViewPlan, DataSourceDesc, DropObjectsPlan, DropOwnedPlan, + HirRelationExpr, Index, MaterializedView, NetworkPolicyRule, NetworkPolicyRuleAction, + NetworkPolicyRuleDirection, OnHydration, Plan, PlanClusterOption, PlanNotice, PolicyAddress, + QueryContext, ReplicaConfig, Secret, Sink, Source, Table, TableDataSource, Type, VariableValue, + View, WebhookBodyFormat, WebhookHeaderFilters, WebhookHeaders, WebhookValidation, literal, + plan_utils, query, transform_ast, }; use crate::session::vars::{ - self, ENABLE_CLUSTER_SCHEDULE_REFRESH, ENABLE_COLLECTION_PARTITION_BY, - ENABLE_CREATE_TABLE_FROM_SOURCE, ENABLE_KAFKA_SINK_HEADERS, ENABLE_REFRESH_EVERY_MVS, - ENABLE_REPLICA_TARGETED_MATERIALIZED_VIEWS, VarInput, + self, ENABLE_AUTO_SCALING_STRATEGY, ENABLE_CLUSTER_SCHEDULE_REFRESH, + ENABLE_COLLECTION_PARTITION_BY, ENABLE_CREATE_TABLE_FROM_SOURCE, ENABLE_KAFKA_SINK_HEADERS, + ENABLE_REFRESH_EVERY_MVS, ENABLE_REPLICA_TARGETED_MATERIALIZED_VIEWS, VarInput, }; use crate::{names, parse}; @@ -4619,6 +4620,7 @@ pub fn describe_create_cluster( // to ALTER CLUSTER would always reset the value of that option to the default. generate_extracted_config!( ClusterOption, + (AutoScalingStrategy, ClusterAutoScalingStrategyOptionValue), (AvailabilityZones, Vec), (Disk, bool), (IntrospectionDebugging, bool), @@ -4715,6 +4717,7 @@ pub fn plan_create_cluster_inner( }: CreateClusterStatement, ) -> Result { let ClusterOptionExtracted { + auto_scaling_strategy, availability_zones, introspection_debugging, introspection_interval, @@ -4815,6 +4818,23 @@ pub fn plan_create_cluster_inner( ..Default::default() }; + // Plan the autoscaling strategy. Gated by a `feature_flags!` flag (not a + // dyncfg) because a stored `CREATE CLUSTER` is re-parsed at catalog + // rehydration, where dyncfgs are not consulted. + let auto_scaling_strategy = match auto_scaling_strategy { + Some(value) => { + scx.require_feature_flag(&ENABLE_AUTO_SCALING_STRATEGY)?; + let strategy = plan_auto_scaling_strategy(value)?; + if let Some(strategy) = &strategy { + let schedule_non_manual = + !matches!(schedule, ClusterScheduleOptionValue::Manual); + validate_auto_scaling_strategy(strategy, Some(&size), schedule_non_manual)?; + } + strategy + } + None => None, + }; + let schedule = plan_cluster_schedule(schedule)?; Ok(CreateClusterPlan { @@ -4826,6 +4846,7 @@ pub fn plan_create_cluster_inner( compute, optimizer_feature_overrides, schedule, + auto_scaling_strategy, }), workload_class, }) @@ -4833,6 +4854,9 @@ pub fn plan_create_cluster_inner( let Some(replica_defs) = replicas else { sql_bail!("REPLICAS must be specified for unmanaged clusters"); }; + if auto_scaling_strategy.is_some() { + sql_bail!("AUTO SCALING STRATEGY not supported for unmanaged clusters"); + } if availability_zones.is_some() { sql_bail!("AVAILABILITY ZONES not supported for unmanaged clusters"); } @@ -4892,8 +4916,12 @@ pub fn unplan_create_cluster( compute, optimizer_feature_overrides, schedule, + auto_scaling_strategy, }) => { let schedule = unplan_cluster_schedule(schedule); + let auto_scaling_strategy = auto_scaling_strategy + .as_ref() + .map(unplan_auto_scaling_strategy); let OptimizerFeatureOverrides { enable_reduce_mfp_fusion: _, enable_cardinality_estimates: _, @@ -4957,6 +4985,7 @@ pub fn unplan_create_cluster( let options_extracted = ClusterOptionExtracted { // Seen is ignored when unplanning. seen: Default::default(), + auto_scaling_strategy, availability_zones, disk: None, introspection_debugging: Some(introspection_debugging), @@ -5193,6 +5222,95 @@ fn unplan_cluster_schedule(schedule: ClusterSchedule) -> ClusterScheduleOptionVa } } +/// Convert a [`ClusterAutoScalingStrategyOptionValue`] into an +/// [`AutoScalingStrategy`]. An empty block (no sub-policies) maps to `None` — +/// autoscaling disabled — so an empty `AUTO SCALING STRATEGY = ()` behaves like +/// a reset. +/// +/// This is a pure conversion. The cross-config invariants (`HYDRATION SIZE` vs. +/// the cluster `SIZE`, and incompatibility with a non-MANUAL `SCHEDULE`) are +/// checked separately by [`validate_auto_scaling_strategy`] against the cluster's +/// *effective* config, so that they hold no matter which side of the constraint +/// an `ALTER` changes. +/// +/// The reverse of [`unplan_auto_scaling_strategy`]. +fn plan_auto_scaling_strategy( + value: ClusterAutoScalingStrategyOptionValue, +) -> Result, PlanError> { + let ClusterAutoScalingStrategyOptionValue { on_hydration } = value; + let Some(on_hydration) = on_hydration else { + // An empty block disables autoscaling. + return Ok(None); + }; + + let hydration_size = String::try_from_value(on_hydration.hydration_size)?; + + let linger_duration = on_hydration + .linger_duration + .map(Duration::try_from_value) + .transpose()?; + + Ok(Some(AutoScalingStrategy { + on_hydration: Some(OnHydration { + hydration_size, + linger_duration, + }), + })) +} + +/// Validate an effective [`AutoScalingStrategy`] against the cluster's effective +/// `SIZE` and `SCHEDULE`. Rejects a burst `HYDRATION SIZE` equal to the cluster +/// `SIZE` (a no-op burst) and the `AUTO SCALING STRATEGY` + non-MANUAL `SCHEDULE` +/// combination. +/// +/// Called on both `CREATE` and `ALTER` with the *effective* config (the values an +/// `ALTER` sets, else the cluster's current ones), so the invariants cannot be +/// established by changing either side of the constraint independently. +/// +/// `cluster_size` is `None` only when the effective size is unknown at plan time +/// (an unmanaged→managed `ALTER` that does not set `SIZE`, which fails later for +/// the missing size); the size equality check is then skipped, but the +/// schedule-incompatibility check still runs. +fn validate_auto_scaling_strategy( + strategy: &AutoScalingStrategy, + cluster_size: Option<&str>, + schedule_non_manual: bool, +) -> Result<(), PlanError> { + if let (Some(on_hydration), Some(cluster_size)) = (&strategy.on_hydration, cluster_size) { + if on_hydration.hydration_size == cluster_size { + sql_bail!( + "HYDRATION SIZE must differ from the cluster SIZE ('{cluster_size}'); a burst replica at the same size would not accelerate hydration" + ); + } + } + if schedule_non_manual { + sql_bail!("AUTO SCALING STRATEGY cannot be combined with a SCHEDULE other than MANUAL"); + } + Ok(()) +} + +/// Convert an [`AutoScalingStrategy`] back into a +/// [`ClusterAutoScalingStrategyOptionValue`] for `SHOW CREATE CLUSTER` rendering. +/// +/// The reverse of [`plan_auto_scaling_strategy`]. +fn unplan_auto_scaling_strategy( + strategy: &AutoScalingStrategy, +) -> ClusterAutoScalingStrategyOptionValue { + ClusterAutoScalingStrategyOptionValue { + on_hydration: strategy + .on_hydration + .as_ref() + .map(|on_hydration| OnHydrationOptionValue { + hydration_size: Value::String(on_hydration.hydration_size.clone()), + linger_duration: on_hydration.linger_duration.map(|d| { + let interval = Interval::from_duration(&d) + .expect("planning ensured this is convertible back to Interval"); + Value::Interval(literal::unplan_interval(&interval)) + }), + }), + } +} + pub fn describe_create_cluster_replica( _: &StatementContext, _: CreateClusterReplicaStatement, @@ -6147,6 +6265,7 @@ pub fn plan_alter_cluster( with_options, } => { let ClusterOptionExtracted { + auto_scaling_strategy, availability_zones, introspection_debugging, introspection_interval, @@ -6224,11 +6343,47 @@ pub fn plan_alter_cluster( } } } + + if let Some(value) = auto_scaling_strategy { + scx.require_feature_flag(&ENABLE_AUTO_SCALING_STRATEGY)?; + let strategy = plan_auto_scaling_strategy(value)?; + options.auto_scaling_strategy = AlterOptionParameter::Set(strategy); + } + + // Validate the two `AUTO SCALING STRATEGY` invariants against the + // cluster's *effective* config (the values this `ALTER` sets, else + // the cluster's current ones). Doing this here — rather than only + // when the strategy option itself is present — catches the case + // where the constraint is established by changing the *other* side: + // setting `SIZE` to equal an existing `HYDRATION SIZE`, or setting a + // non-MANUAL `SCHEDULE` on a cluster that already has a strategy. + let effective_strategy = match &options.auto_scaling_strategy { + AlterOptionParameter::Set(s) => s.clone(), + AlterOptionParameter::Reset => None, + AlterOptionParameter::Unchanged => cluster.auto_scaling_strategy().cloned(), + }; + if let Some(effective_strategy) = &effective_strategy { + let effective_size = size.as_deref().or_else(|| cluster.managed_size()); + let schedule_non_manual = match &schedule { + Some(s) => !matches!(s, ClusterScheduleOptionValue::Manual), + None => cluster + .schedule() + .is_some_and(|s| !matches!(s, ClusterSchedule::Manual)), + }; + validate_auto_scaling_strategy( + effective_strategy, + effective_size, + schedule_non_manual, + )?; + } } false => { if !alter_strategy.is_none() { sql_bail!("ALTER... WITH not supported for unmanaged clusters"); } + if auto_scaling_strategy.is_some() { + sql_bail!("AUTO SCALING STRATEGY not supported for unmanaged clusters"); + } if availability_zones.is_some() { sql_bail!("AVAILABILITY ZONES not supported for unmanaged clusters"); } @@ -6333,8 +6488,13 @@ pub fn plan_alter_cluster( } } + if reset_options.contains(&AutoScalingStrategy) { + scx.require_feature_flag(&ENABLE_AUTO_SCALING_STRATEGY)?; + } + for option in reset_options { match option { + AutoScalingStrategy => options.auto_scaling_strategy = Reset, AvailabilityZones => options.availability_zones = Reset, Disk => scx .catalog diff --git a/src/sql/src/plan/statement/show.rs b/src/sql/src/plan/statement/show.rs index 545d5b6c55a5f..d7af4b1cf05fd 100644 --- a/src/sql/src/plan/statement/show.rs +++ b/src/sql/src/plan/statement/show.rs @@ -757,13 +757,14 @@ pub fn show_clusters<'a>( scx: &'a StatementContext<'a>, filter: Option>, ) -> Result, PlanError> { - let query = "SELECT name, replicas, comment FROM mz_internal.mz_show_clusters".to_string(); + let query = + "SELECT name, replicas, activity, comment FROM mz_internal.mz_show_clusters".to_string(); ShowSelect::new( scx, query, filter, None, - Some(&["name", "replicas", "comment"]), + Some(&["name", "replicas", "activity", "comment"]), ) } diff --git a/src/sql/src/plan/with_options.rs b/src/sql/src/plan/with_options.rs index 7145414592bb9..71ec13e986b0f 100644 --- a/src/sql/src/plan/with_options.rs +++ b/src/sql/src/plan/with_options.rs @@ -16,9 +16,9 @@ use mz_repr::adt::interval::Interval; use mz_repr::bytes::ByteSize; use mz_repr::{CatalogItemId, RelationVersionSelector, strconv}; use mz_sql_parser::ast::{ - ClusterAlterOptionValue, ClusterScheduleOptionValue, ConnectionDefaultAwsPrivatelink, Expr, - Ident, KafkaBroker, KafkaMatchingBrokerRule, NetworkPolicyRuleDefinition, RefreshOptionValue, - ReplicaDefinition, + ClusterAlterOptionValue, ClusterAutoScalingStrategyOptionValue, ClusterScheduleOptionValue, + ConnectionDefaultAwsPrivatelink, Expr, Ident, KafkaBroker, KafkaMatchingBrokerRule, + NetworkPolicyRuleDefinition, RefreshOptionValue, ReplicaDefinition, }; use mz_storage_types::connections::IcebergCatalogType; use mz_storage_types::connections::string_or_secret::StringOrSecret; @@ -711,6 +711,7 @@ impl, T: AstInfo + std::fmt::Debug> TryFromValue sql_bail!( "incompatible value types: cannot convert {} to {}", match v { @@ -732,6 +733,8 @@ impl, T: AstInfo + std::fmt::Debug> TryFromValue "matching broker rule", WithOptionValue::Refresh(_) => "refresh option values", WithOptionValue::ClusterScheduleOptionValue(_) => "cluster schedule", + WithOptionValue::ClusterAutoScalingStrategyOptionValue(_) => + "cluster auto scaling strategy", WithOptionValue::NetworkPolicyRules(_) => "network policy rules", }, V::name() @@ -986,6 +989,30 @@ impl TryFromValue> for ClusterScheduleOptionValue { } } +impl ImpliedValue for ClusterAutoScalingStrategyOptionValue { + fn implied_value() -> Result { + sql_bail!("must provide an auto scaling strategy option value") + } +} + +impl TryFromValue> for ClusterAutoScalingStrategyOptionValue { + fn try_from_value(v: WithOptionValue) -> Result { + if let WithOptionValue::ClusterAutoScalingStrategyOptionValue(r) = v { + Ok(r) + } else { + sql_bail!("cannot use value `{}` for an auto scaling strategy", v) + } + } + + fn try_into_value(self, _catalog: &dyn SessionCatalog) -> Option> { + Some(WithOptionValue::ClusterAutoScalingStrategyOptionValue(self)) + } + + fn name() -> String { + "auto scaling strategy option value".to_string() + } +} + impl ImpliedValue for BTreeMap { fn implied_value() -> Result { sql_bail!("must provide a map of key-value pairs") diff --git a/src/sql/src/session/vars/definitions.rs b/src/sql/src/session/vars/definitions.rs index c88cb1b1dd1f5..9aba709fc9724 100644 --- a/src/sql/src/session/vars/definitions.rs +++ b/src/sql/src/session/vars/definitions.rs @@ -2105,6 +2105,17 @@ feature_flags!( default: false, enable_for_item_parsing: true, }, + { + name: enable_auto_scaling_strategy, + // `enable_for_item_parsing: true` is required: stored `CREATE CLUSTER` + // statements carrying `AUTO SCALING STRATEGY` are re-parsed at catalog + // rehydration, where dyncfgs are not consulted. A `feature_flags!` gate + // holds there, so a stored statement does not fail to re-parse after the + // flag is turned off. + desc: "`AUTO SCALING STRATEGY` cluster option", + default: false, + enable_for_item_parsing: true, + }, { name: enable_reduce_mfp_fusion, desc: "fusion of MFPs in reductions", diff --git a/src/sqllogictest/src/bin/sqllogictest.rs b/src/sqllogictest/src/bin/sqllogictest.rs index f610dada2d21e..c846d9c7467c1 100644 --- a/src/sqllogictest/src/bin/sqllogictest.rs +++ b/src/sqllogictest/src/bin/sqllogictest.rs @@ -18,6 +18,7 @@ use std::process::ExitCode; use chrono::Utc; use clap::ArgAction; +use mz_adapter_types::dyncfgs::{ENABLE_BACKGROUND_ALTER_CLUSTER, ENABLE_CLUSTER_CONTROLLER}; use mz_orchestrator_tracing::{StaticTracingConfig, TracingCliArgs}; use mz_ore::cli::{self, CliConfig, KeyValueArg}; use mz_ore::metrics::MetricsRegistry; @@ -167,6 +168,20 @@ async fn main() -> ExitCode { } } + // The cluster controller and background ALTER CLUSTER land dark in + // production (the dyncfg defaults stay false); force them on for + // sqllogictest so the suite exercises the controller owning the + // managed-cluster replica set. These are dyncfgs (set by name), and a + // caller-provided value wins. + for name in [ + ENABLE_CLUSTER_CONTROLLER.name(), + ENABLE_BACKGROUND_ALTER_CLUSTER.name(), + ] { + system_parameter_defaults + .entry(name.to_string()) + .or_insert_with(|| "true".to_string()); + } + let config = RunConfig { stdout: &OutputStream::new(io::stdout(), args.timestamps), stderr: &OutputStream::new(io::stderr(), args.timestamps), diff --git a/test/cloud-canary/canary-clusters.td b/test/cloud-canary/canary-clusters.td index 6581525b2e618..4015ab563259c 100644 --- a/test/cloud-canary/canary-clusters.td +++ b/test/cloud-canary/canary-clusters.td @@ -13,8 +13,10 @@ > SET cluster=cluster1; +# SHOW CLUSTERS gained a single `activity` column summarizing any in-flight +# reconfiguration or autoscaling action; an idle cluster has none. > SHOW CLUSTERS LIKE 'cluster1'; -cluster1 "replica1 (3xsmall), replica2 (3xsmall)" "" +cluster1 "replica1 (3xsmall), replica2 (3xsmall)" "" > SHOW CLUSTER REPLICAS WHERE cluster = 'cluster1'; cluster1 replica1 3xsmall true "" diff --git a/test/cloudtest/test_managed_cluster.py b/test/cloudtest/test_managed_cluster.py index abae065597259..2a4fbdb3d9538 100644 --- a/test/cloudtest/test_managed_cluster.py +++ b/test/cloudtest/test_managed_cluster.py @@ -9,7 +9,6 @@ import time from textwrap import dedent -from threading import Thread from typing import Any from pg8000 import Connection @@ -41,12 +40,28 @@ def test_managed_cluster_sizing(mz: MaterializeApplication) -> None: assert check is not None assert check == True - mz.environmentd.sql("ALTER CLUSTER sized1 SET (AVAILABILITY ZONES ('1', '2', '3'))") - check = mz.environmentd.sql_query( - "SELECT list_length(availability_zones) = 3 FROM mz_clusters WHERE name = 'sized1'" - )[0][0] - assert check is not None - assert check == True + # Setting the availability-zone pool is a config-shape change. With the + # cluster controller on it is realized as a graceful reconfiguration — the new + # pool takes effect only once replacement replicas have hydrated and the + # controller cuts over — so the realized `availability_zones` and the steady + # replica set settle asynchronously; with the controller off the change is + # applied synchronously in place. Poll (testdrive retries each query) for the + # settled state so this passes either way. The cut-over does not preserve + # replica names, so assert on replica *count* rather than specific names. + mz.testdrive.run( + input=dedent(""" + > ALTER CLUSTER sized1 SET (AVAILABILITY ZONES ('1', '2', '3')) + + > SELECT list_length(availability_zones) FROM mz_clusters WHERE name = 'sized1' + 3 + + > SELECT count(*) + FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id + WHERE c.name = 'sized1' + 2 + """), + no_reset=True, + ) mz.testdrive.run( input=dedent(""" @@ -59,19 +74,32 @@ def test_managed_cluster_sizing(mz: MaterializeApplication) -> None: replicas = mz.environmentd.sql_query( "SELECT mz_cluster_replicas.name, mz_cluster_replicas.id FROM mz_cluster_replicas JOIN mz_clusters ON mz_cluster_replicas.cluster_id = mz_clusters.id WHERE mz_clusters.name = 'sized1' ORDER BY 1" ) - assert [replica[0] for replica in replicas] == ["r1", "r2"] + assert len(replicas) == SIZE for compute_id in range(0, SIZE): for replica in replicas: compute_pod = cluster_pod_name(cluster_id, replica[1], compute_id) wait(condition="condition=Ready", resource=compute_pod) - mz.environmentd.sql("ALTER CLUSTER sized1 SET (REPLICATION FACTOR 1)") + # Reducing the replication factor drops a replica: the controller does this on + # its next reconcile tick (asynchronously), the legacy path synchronously. + # Poll for the settled count. + mz.testdrive.run( + input=dedent(""" + > ALTER CLUSTER sized1 SET (REPLICATION FACTOR 1) + + > SELECT count(*) + FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id + WHERE c.name = 'sized1' + 1 + """), + no_reset=True, + ) replicas = mz.environmentd.sql_query( "SELECT mz_cluster_replicas.name, mz_cluster_replicas.id FROM mz_cluster_replicas JOIN mz_clusters ON mz_cluster_replicas.cluster_id = mz_clusters.id WHERE mz_clusters.name = 'sized1' ORDER BY 1" ) - assert [replica[0] for replica in replicas] == ["r1"] + assert len(replicas) == 1 for compute_id in range(0, SIZE): for replica in replicas: @@ -114,49 +142,82 @@ def test_managed_cluster_sizing(mz: MaterializeApplication) -> None: def test_zero_downtime_reconfiguration(mz: MaterializeApplication) -> None: + # Drive the controller tick down so background reconfigurations converge + # within the short poll loops below. mz.environmentd.sql( """ ALTER SYSTEM SET enable_zero_downtime_cluster_reconfiguration = true; + ALTER SYSTEM SET cluster_controller_tick_interval = '5ms'; """, port="internal", user="mz_system", ) - def assert_replica_names(names, allow_pending=False): - replicas = mz.environmentd.sql_query(""" + def get_replica_names(cluster: str) -> list[str]: + replicas = mz.environmentd.sql_query(f""" SELECT mz_cluster_replicas.name FROM mz_cluster_replicas, mz_clusters WHERE mz_cluster_replicas.cluster_id = mz_clusters.id - AND mz_clusters.name = 'zdtaltertest'; + AND mz_clusters.name = '{cluster}'; """) - assert [replica[0] for replica in replicas] == names - if not allow_pending: - assert len(mz.environmentd.sql_query(""" - SELECT cr.name - FROM mz_internal.mz_pending_cluster_replicas ur - INNER join mz_cluster_replicas cr ON cr.id=ur.id - INNER join mz_clusters c ON c.id=cr.cluster_id - WHERE c.name = 'zdtaltertest'; - """)) == 0, "There should be no pending replicas" + return sorted(replica[0] for replica in replicas) + + def assert_no_pending(cluster: str) -> None: + # The controller never creates a legacy "-pending" replica. + pending = mz.environmentd.sql_query(f""" + SELECT cr.name + FROM mz_internal.mz_pending_cluster_replicas pr + INNER JOIN mz_cluster_replicas cr ON cr.id = pr.id + INNER JOIN mz_clusters c ON c.id = cr.cluster_id + WHERE c.name = '{cluster}'; + """) + assert ( + len(pending) == 0 + ), f"There should be no pending replicas, found {pending}" + + def wait_for_replica_names(names: list[str], cluster: str = "zdtaltertest"): + """Poll until the cluster's replica set settles on `names`. + + A background ALTER returns immediately and the controller converges the + replica set on its tick, so readbacks have to wait for the settled + state. + """ + observed = None + for _ in range(240): + observed = get_replica_names(cluster) + if observed == sorted(names): + break + time.sleep(0.25) + assert observed == sorted( + names + ), f"expected replicas {names} on {cluster}, found {observed}" + assert_no_pending(cluster) # Basic zero-downtime reconfig test cases matrix # - size change, no replica change - # - replica size up, no other change - # - replica size down, with size change - # - replica size down, no other change - # - replica size up, with size change + # - size down, with replication factor up + # - replication factor down, no other change + # - size up, with replication factor up + # - size down, with replication factor down # Other assertions - # - no pending replicas after alter finishes - # - names should match r# patter, not end with `-pending` - # - cancelled statements correctly roll back - # - timedout until ready queries take the appropriate action - # - Fails to zero-downtime alter cluster with source + # - replica names churn across reshapes: the controller realizes a + # config-shape change by bringing up freshly-named target replicas and + # dropping the old set at cut-over, never renaming back + # - no pending replicas at any point + # - a session cancel does not abort a durable background reconfiguration + # - an ON TIMEOUT ROLLBACK reconfiguration that cannot hydrate in time + # rolls back in the background, leaving the realized config untouched + # - fails to alter replication factor beyond max_replicas_per_cluster mz.environmentd.sql( 'CREATE CLUSTER zdtaltertest ( SIZE = "scale=1,workers=1" )', port="internal", user="mz_system", ) + wait_for_replica_names(["r1"]) + # A size change reshapes in the background: a fresh target replica comes + # up, the realized config cuts over, and the old replica is dropped + # (r1 -> r2). mz.environmentd.sql( """ ALTER CLUSTER zdtaltertest SET ( SIZE = 'scale=1,workers=2' ) WITH ( WAIT FOR '1ms' ) @@ -164,8 +225,15 @@ def assert_replica_names(names, allow_pending=False): port="internal", user="mz_system", ) - assert_replica_names(["r1"]) + wait_for_replica_names(["r2"]) + assert ( + mz.environmentd.sql_query(""" + SELECT size FROM mz_clusters WHERE name='zdtaltertest'; + """) == (["scale=1,workers=2"],) + ), "Realized size should have cut over to the target" + # A size change with a replication-factor increase brings up two fresh + # target replicas. mz.environmentd.sql( """ ALTER CLUSTER zdtaltertest SET ( SIZE = 'scale=1,workers=1', REPLICATION FACTOR 2 ) WITH ( WAIT FOR '1ms' ) @@ -173,8 +241,10 @@ def assert_replica_names(names, allow_pending=False): port="internal", user="mz_system", ) - assert_replica_names(["r1", "r2"]) + wait_for_replica_names(["r3", "r4"]) + # A replication-factor-only decrease reconciles in place (no reshape): the + # oldest replica is kept. mz.environmentd.sql( """ ALTER CLUSTER zdtaltertest SET ( SIZE = 'scale=1,workers=1', REPLICATION FACTOR 1 ) WITH ( WAIT FOR '1ms' ) @@ -182,8 +252,9 @@ def assert_replica_names(names, allow_pending=False): port="internal", user="mz_system", ) - assert_replica_names(["r1"]) + wait_for_replica_names(["r3"]) + # Fresh names continue past the highest index ever observed. mz.environmentd.sql( """ ALTER CLUSTER zdtaltertest SET ( SIZE = 'scale=1,workers=2', REPLICATION FACTOR 2 ) WITH ( WAIT FOR '1ms' ) @@ -191,7 +262,7 @@ def assert_replica_names(names, allow_pending=False): port="internal", user="mz_system", ) - assert_replica_names(["r1", "r2"]) + wait_for_replica_names(["r4", "r5"]) mz.environmentd.sql( """ @@ -200,7 +271,7 @@ def assert_replica_names(names, allow_pending=False): port="internal", user="mz_system", ) - assert_replica_names(["r1"]) + wait_for_replica_names(["r6"]) # Setup for validating cancelation and # replica checks during alter @@ -243,37 +314,39 @@ def assert_replica_names(names, allow_pending=False): """), ) - # Valudate replicas are correct during an ongoing alter - def zero_downtime_alter(): - mz.environmentd.sql( - """ - ALTER CLUSTER zdtaltertest SET (SIZE = 'scale=1,workers=2') WITH ( WAIT FOR '5s') - """, - port="internal", - user="mz_system", - ) - - thread = Thread(target=zero_downtime_alter) - thread.start() - time.sleep(1) - - assert_replica_names(["r1", "r1-pending"], allow_pending=True) - assert ( - mz.environmentd.sql_query(""" - SELECT size FROM mz_clusters WHERE name='zdtaltertest'; - """) == (["scale=1,workers=1"],) - ), "Cluster should use original config during alter" - - thread.join() - - assert_replica_names(["r1"], allow_pending=False) + # Validate replicas are correct during an ongoing alter. The background + # ALTER returns immediately; the controller brings the fresh target replica + # up next to r1 (both serve while the target hydrates), then cuts over and + # drops r1. The in-flight window may be short, so don't require observing + # the overlap — but any state we do observe must never include a legacy + # "-pending" replica. + mz.environmentd.sql( + """ + ALTER CLUSTER zdtaltertest SET (SIZE = 'scale=1,workers=2') WITH ( WAIT FOR '5s') + """, + port="internal", + user="mz_system", + ) + for _ in range(240): + names = get_replica_names("zdtaltertest") + assert not any( + name.endswith("-pending") for name in names + ), f"controller reconfiguration must not use pending replicas, found {names}" + if names == ["r2"]: + break + time.sleep(0.25) + + wait_for_replica_names(["r2"]) assert ( mz.environmentd.sql_query(""" SELECT size FROM mz_clusters WHERE name='zdtaltertest'; """) == (["scale=1,workers=2"],) ), "Cluster should use new config after alter completes" - # Validate cancelation of alter cluster..with + # Validate cancelation around alter cluster..with: the reconfiguration is a + # durable record the controller converges on independently of the session, + # so canceling the issuing backend does not abort it — the cluster still + # cuts over to the target config. mz.environmentd.sql( """ DROP CLUSTER IF EXISTS cluster1 CASCADE; @@ -282,6 +355,7 @@ def zero_downtime_alter(): port="internal", user="mz_system", ) + wait_for_replica_names(["r1"], cluster="cluster1") # We need persistent connection that we can later issue a cancel backend to conn = mz.environmentd.sql_conn( @@ -306,31 +380,25 @@ def query_with_conn( raise pid = query_with_conn("select pg_backend_pid();", conn)[0][0] - thread = Thread( - target=query_with_conn, - args=[ - """ - ALTER CLUSTER cluster1 SET (SIZE = 'scale=1,workers=2') WITH ( WAIT FOR '5s') - """, - conn, - True, - ], + query_with_conn( + """ + ALTER CLUSTER cluster1 SET (SIZE = 'scale=1,workers=2') WITH ( WAIT FOR '5s') + """, + conn, + True, ) - thread.start() - time.sleep(1) mz.environmentd.sql( f"select pg_cancel_backend({pid});", port="internal", user="mz_system", ) - time.sleep(1) - assert_replica_names(["r1"], allow_pending=False) + wait_for_replica_names(["r2"], cluster="cluster1") assert ( mz.environmentd.sql_query(""" SELECT size FROM mz_clusters WHERE name='cluster1'; - """) == (["scale=1,workers=1"],) - ), "Cluster should not have updated if canceled during alter" + """) == (["scale=1,workers=2"],) + ), "Cancel must not abort the durable background reconfiguration" # Test zero-downtime reconfig wait until ready mz.environmentd.sql( @@ -358,13 +426,65 @@ def query_with_conn( CREATE INDEX test_view_idx ON test_view(id); """) - mz.testdrive.run( - input=dedent(""" - ! ALTER CLUSTER slow_hydration set (size='scale=1,workers=4') WITH (WAIT UNTIL READY (TIMEOUT='1s', ON TIMEOUT ROLLBACK)) - contains: canceling statement, provided timeout lapsed - """), - no_reset=True, - ) + # The background ALTER returns immediately; the target replica cannot + # hydrate the slow view within the timeout, so the controller rolls back at + # the deadline: it drops the target set and clears the record, leaving the + # realized config untouched. + mz.environmentd.sql(""" + ALTER CLUSTER slow_hydration SET (SIZE='scale=1,workers=4') WITH (WAIT UNTIL READY (TIMEOUT='1s', ON TIMEOUT ROLLBACK)) + """) + + # The rollback's definitive signal is the `timed-out` audit transition: the + # controller writes it when it rolls back at the deadline (drops the target + # set, clears the record). Poll for that transition before reading the settled + # state back. We cannot key on the replica set alone: the post-rollback set is + # just [r1], which is indistinguishable from the transient window before the + # target replica is even created — so a bare replica-name wait could latch the + # pre-rollback state and race the deadline. + for _ in range(240): + if mz.environmentd.sql_query(""" + SELECT 1 FROM mz_catalog.mz_audit_events + WHERE event_type = 'alter' AND object_type = 'cluster' + AND details->>'cluster_name' = 'slow_hydration' + AND details->>'transition' = 'timed-out'; + """): + break + time.sleep(0.25) + wait_for_replica_names(["r1"], cluster="slow_hydration") + # Rolled back: the record is cleared, so the sparse relation has no row for + # the cluster. + reconfiguration = mz.environmentd.sql_query(""" + SELECT recon.target->>'size' + FROM mz_internal.mz_cluster_reconfigurations recon + JOIN mz_clusters c ON c.id = recon.cluster_id + WHERE c.name = 'slow_hydration'; + """) + assert ( + reconfiguration == () + ), f"Expected the rolled-back reconfiguration record to be cleared, found {reconfiguration}" + # The realized config is untouched. + realized = mz.environmentd.sql_query(""" + SELECT size FROM mz_clusters WHERE name = 'slow_hydration'; + """) + assert realized == ( + ["scale=1,workers=1"], + ), f"Expected the realized config to be untouched, found {realized}" + + # The timeout's papertrail is the audit log: a started and a timed-out + # transition, the latter carrying the abandoned target. + transitions = mz.environmentd.sql_query(""" + SELECT details->>'transition', details->>'target_size' + FROM mz_catalog.mz_audit_events + WHERE event_type = 'alter' + AND object_type = 'cluster' + AND details->>'cluster_name' = 'slow_hydration' + AND details->>'transition' IS NOT NULL + ORDER BY id; + """) + assert transitions == ( + ["started", "scale=1,workers=4"], + ["timed-out", "scale=1,workers=4"], + ), f"Expected a started and a timed-out transition, found {transitions}" # Test fails to alter with source mz.environmentd.sql(""" diff --git a/test/cluster/github-7645/01-create-source.td b/test/cluster/github-7645/01-create-source.td index fb3666a812aa6..5a8e19a6fb162 100644 --- a/test/cluster/github-7645/01-create-source.td +++ b/test/cluster/github-7645/01-create-source.td @@ -10,6 +10,9 @@ $ postgres-execute connection=postgres://mz_system:materialize@${testdrive.materialize-internal-sql-addr} ALTER SYSTEM SET storage_statistics_collection_interval = 1000 ALTER SYSTEM SET storage_statistics_interval = 2000 +# The controller drops the paused replica asynchronously; drive the tick down so +# the drop wait below converges quickly. +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' > DROP CLUSTER IF EXISTS test_cluster CASCADE; > CREATE CLUSTER test_cluster (SIZE 'scale=1,workers=1'); @@ -26,3 +29,13 @@ ALTER SYSTEM SET storage_statistics_interval = 2000 true > ALTER CLUSTER test_cluster SET (REPLICATION FACTOR = 0) + +# The controller drops the replica asynchronously. Wait for it to be gone before +# the workflow captures rehydration_latency and restarts environmentd: a replica +# still present at restart would boot and re-rehydrate, reporting a fresh latency +# that diverges from the captured value. The dropped replica's statistic persists. +> SELECT count(*) + FROM mz_cluster_replicas cr + JOIN mz_clusters c ON c.id = cr.cluster_id + WHERE c.name = 'test_cluster' +0 diff --git a/test/cluster/mzcompose.py b/test/cluster/mzcompose.py index f5076a57d9206..2517676a2dbad 100644 --- a/test/cluster/mzcompose.py +++ b/test/cluster/mzcompose.py @@ -30,7 +30,6 @@ from psycopg.errors import ( DatabaseError, InternalError_, - OperationalError, QueryCanceled, ) @@ -5402,6 +5401,14 @@ def workflow_test_zero_downtime_reconfigure( ENVELOPE UPSERT """), ) + # Drive the controller tick down so the reconfiguration converges quickly. + c.sql( + "ALTER SYSTEM SET cluster_controller_tick_interval = '5ms'", + port=6877, + user="mz_system", + ) + + # No reconfiguration in flight yet: exactly the one managed replica. replicas = c.sql_query(""" SELECT mz_cluster_replicas.name FROM mz_cluster_replicas, mz_clusters WHERE @@ -5411,43 +5418,36 @@ def workflow_test_zero_downtime_reconfigure( ("r1",) ], f"Cluster should only have one replica prior to alter, found {replicas}" - replicas = c.sql_query(""" - SELECT cr.name - FROM mz_internal.mz_pending_cluster_replicas ur - INNER join mz_cluster_replicas cr ON cr.id=ur.id - INNER join mz_clusters c ON c.id=cr.cluster_id - WHERE c.name = 'cluster1'; - """) - assert ( - len(replicas) == 0 - ), f"Cluster should only have no pending replica prior to alter, found {replicas}" - - def zero_downtime_alter(): - try: - c.sql( - """ - ALTER CLUSTER cluster1 SET (SIZE = 'scale=1,workers=2') WITH ( WAIT FOR '10s') - """, - port=6877, - user="mz_system", - ) - except OperationalError: - # We expect the network to drop during this - pass + # Kick off a graceful reconfiguration. With the controller owning the + # replica set and background ALTER on, this writes a durable + # reconfiguration record and returns immediately; the controller brings up + # a fresh target replica alongside r1, re-hydrates it, then cuts the + # realized size over and drops r1. `WAIT FOR` resolves to ON TIMEOUT + # COMMIT, so the reconfiguration commits even if its deadline passes during + # the restart below. + c.sql( + """ + ALTER CLUSTER cluster1 SET (SIZE = 'scale=1,workers=2') WITH (WAIT FOR '10s') + """, + port=6877, + user="mz_system", + ) - # Run a reconfigure - thread = Thread(target=zero_downtime_alter) - thread.start() - time.sleep(3) + # Wait until the reconfiguration is in flight (the controller has brought + # up the target replica alongside r1) so the restart interrupts it. + for _ in range(60): + replicas = c.sql_query(""" + SELECT mz_cluster_replicas.name + FROM mz_cluster_replicas, mz_clusters + WHERE mz_cluster_replicas.cluster_id = mz_clusters.id + AND mz_clusters.name='cluster1'; + """) + if len(replicas) >= 2: + break + time.sleep(0.5) - # Validate that there is a pending replica - replicas = c.sql_query(""" - SELECT mz_cluster_replicas.name - FROM mz_cluster_replicas, mz_clusters WHERE - mz_cluster_replicas.cluster_id = mz_clusters.id AND mz_clusters.name='cluster1'; - """) - assert replicas == [("r1",), ("r1-pending",)], replicas - replicas = c.sql_query(""" + # The controller never creates a legacy "-pending" replica. + pending = c.sql_query(""" SELECT cr.name FROM mz_internal.mz_pending_cluster_replicas ur INNER join mz_cluster_replicas cr ON cr.id=ur.id @@ -5455,28 +5455,41 @@ def zero_downtime_alter(): WHERE c.name = 'cluster1'; """) assert ( - len(replicas) == 1 - ), "pending replica should be in mz_pending_cluster_replicas" + len(pending) == 0 + ), f"controller reconfiguration must not use pending replicas, found {pending}" - # Restart environmentd + # Restart environmentd while the reconfiguration may still be in flight. c.kill("materialized") c.up("materialized") - # Ensure there is no pending replica + # The reconfiguration record is durable, so the controller resumes and + # completes it across the restart: the realized size cuts over and the + # cluster settles back to a single managed replica at the new size. + size = None + for _ in range(120): + size = c.sql_query("SELECT size FROM mz_clusters WHERE name='cluster1';") + if size == [("scale=1,workers=2",)]: + break + time.sleep(1) + assert size == [ + ("scale=1,workers=2",) + ], f"reconfiguration did not complete across the restart, size is {size}" + replicas = c.sql_query(""" - SELECT mz_cluster_replicas.name + SELECT mz_cluster_replicas.size FROM mz_cluster_replicas, mz_clusters WHERE mz_cluster_replicas.cluster_id = mz_clusters.id AND mz_clusters.name='cluster1'; """) assert replicas == [ - ("r1",) - ], f"Expected one non pending replica, found {replicas}" + ("scale=1,workers=2",) + ], f"Expected one replica at the new size, found {replicas}" - # Ensure the cluster config did not change - assert c.sql_query(""" - SELECT size FROM mz_clusters WHERE name='cluster1'; - """) == [("scale=1,workers=1",)] + # The source's data survived the zero-downtime reconfiguration. + c.testdrive(dedent(""" + > SELECT count(*) FROM kafka_tbl + 1000 + """)) c.sql( """ ALTER SYSTEM RESET enable_zero_downtime_cluster_reconfiguration; @@ -5490,17 +5503,21 @@ def workflow_test_pending_replica_audit_events( c: Composition, parser: WorkflowArgumentParser ) -> None: """ - Regression test: when envd is killed while an ALTER CLUSTER ... WAIT FOR - is in progress, pending replicas are cleaned up on restart. The drop - must be recorded in mz_audit_events so that every "create" for a - cluster-replica has a matching "drop" (unless the replica still exists). + Regression test: a cluster reconfiguration interrupted by an environmentd + restart must not orphan a replica in mz_audit_events. The controller's + reconfiguration record is durable, so on restart the controller resumes and + completes the reconfiguration; every cluster-replica "create" must still end + up matched by a "drop" (unless the replica still exists), with no leftover + legacy "-pending" replica. """ c.up("materialized") - # Enable the feature flag and create a managed cluster. + # Enable the WAIT surface and drive the controller tick down so the (empty) + # cluster's reconfiguration converges quickly. c.sql( """ ALTER SYSTEM SET enable_zero_downtime_cluster_reconfiguration = true; + ALTER SYSTEM SET cluster_controller_tick_interval = '5ms'; CREATE CLUSTER test_audit (SIZE = 'scale=1,workers=1'); GRANT ALL ON CLUSTER test_audit TO materialize; """, @@ -5508,57 +5525,63 @@ def workflow_test_pending_replica_audit_events( user="mz_system", ) - # Kick off an ALTER that creates a pending replica, but will - # block waiting for it to hydrate (with a long timeout so it - # doesn't finish before we kill envd). - def zero_downtime_alter(): - try: - c.sql( - """ - ALTER CLUSTER test_audit SET (SIZE = 'scale=1,workers=2') - WITH (WAIT FOR '300s') - """, - port=6877, - user="mz_system", - ) - except (OperationalError, DatabaseError): - pass + # Kick off a background graceful reconfiguration. With the controller owning + # the replica set and background ALTER on, this writes a durable + # reconfiguration record and returns immediately; the controller brings up a + # fresh target replica, cuts the size over, and drops the old one. `WAIT FOR` + # resolves to ON TIMEOUT COMMIT with a long deadline, so the in-flight + # reconfiguration commits once the (empty) target hydrates. + c.sql( + """ + ALTER CLUSTER test_audit SET (SIZE = 'scale=1,workers=2') WITH (WAIT FOR '300s') + """, + port=6877, + user="mz_system", + ) - thread = Thread(target=zero_downtime_alter) - thread.start() + # The controller never creates a legacy "-pending" replica. + pending = c.sql_query(""" + SELECT cr.name + FROM mz_internal.mz_pending_cluster_replicas pr + JOIN mz_cluster_replicas cr ON cr.id = pr.id + JOIN mz_clusters c ON c.id = cr.cluster_id + WHERE c.name = 'test_audit'; + """) + assert ( + len(pending) == 0 + ), f"controller reconfiguration must not use pending replicas, found {pending}" - # Wait until the pending replica appears. - for _ in range(60): - pending = c.sql_query(""" - SELECT cr.name - FROM mz_internal.mz_pending_cluster_replicas pr - JOIN mz_cluster_replicas cr ON cr.id = pr.id + # Kill envd while the reconfiguration may still be in flight, then restart. + c.kill("materialized") + c.up("materialized") + + # The controller resumes the durable reconfiguration and completes it: the + # cluster settles on a single managed replica at the new size. + replicas = None + for _ in range(120): + replicas = c.sql_query(""" + SELECT cr.size FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'test_audit'; """) - if len(pending) > 0: + if replicas == [("scale=1,workers=2",)]: break - time.sleep(0.5) - else: - raise RuntimeError("Pending replica never appeared") - - # Kill envd while the ALTER is still in progress. - c.kill("materialized") - thread.join(timeout=10) - - # Restart envd — the pending replica should be cleaned up and - # an audit log drop event should be emitted. - c.up("materialized") - - # Verify that the pending replica was removed. - replicas = c.sql_query(""" - SELECT cr.name FROM mz_cluster_replicas cr + time.sleep(1) + assert replicas == [ + ("scale=1,workers=2",) + ], f"reconfiguration did not complete across the restart, found {replicas}" + + # No leftover pending replica. + pending = c.sql_query(""" + SELECT cr.name + FROM mz_internal.mz_pending_cluster_replicas pr + JOIN mz_cluster_replicas cr ON cr.id = pr.id JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'test_audit'; """) - assert replicas == [ - ("r1",) - ], f"Expected only the original replica, found {replicas}" + assert ( + len(pending) == 0 + ), f"Expected no pending replica after restart, found {pending}" # Verify that every 'create' of a cluster-replica in # mz_audit_events has a matching 'drop' (or the replica still @@ -6046,6 +6069,30 @@ def workflow_test_paused_cluster_readhold_downgrade(c: Composition): c.up("materialized") + # The controller reconciles the replica set asynchronously; drive the tick + # down so pause/unpause converge quickly. + c.sql( + "ALTER SYSTEM SET cluster_controller_tick_interval = '5ms'", + port=6877, + user="mz_system", + ) + + def wait_for_replica_count(expected: int) -> None: + for _ in range(120): + count = int( + c.sql_query( + "SELECT count(*) FROM mz_cluster_replicas cr " + "JOIN mz_clusters c ON c.id = cr.cluster_id " + "WHERE c.name = 'test'" + )[0][0] + ) + if count == expected: + return + time.sleep(0.5) + raise AssertionError( + f"cluster 'test' did not converge to {expected} replica(s)" + ) + # Create a pause-able cluster, with indexes with different kinds of inputs. c.sql(""" CREATE CLUSTER test SIZE 'scale=1,workers=1'; @@ -6070,13 +6117,18 @@ def workflow_test_paused_cluster_readhold_downgrade(c: Composition): # Sanity check. check_read_frontiers_not_stuck(c, ["idx1", "idx2", "idx3"]) - # Pause the cluster; read frontiers should still advance. + # Pause the cluster; read frontiers should still advance. The controller drops + # the replica asynchronously, so wait for the pause to take effect first. c.sql("ALTER CLUSTER test SET (REPLICATION FACTOR 0)") + wait_for_replica_count(0) check_read_frontiers_not_stuck(c, ["idx1", "idx2", "idx3"]) - # Unpause the cluster; indexes should still be queryable. + # Unpause the cluster; indexes should still be queryable. The controller + # recreates the replica asynchronously, so wait for it before issuing index + # peeks, which require a replica. + c.sql("ALTER CLUSTER test SET (REPLICATION FACTOR 1)") + wait_for_replica_count(1) c.sql(""" - ALTER CLUSTER test SET (REPLICATION FACTOR 1); SET cluster = test; SELECT a FROM t; diff --git a/test/launchdarkly-flag-consistency/mzcompose.py b/test/launchdarkly-flag-consistency/mzcompose.py index a65065f47da21..82f2be6e6e1e7 100644 --- a/test/launchdarkly-flag-consistency/mzcompose.py +++ b/test/launchdarkly-flag-consistency/mzcompose.py @@ -191,6 +191,7 @@ catalog_info_metrics_reconcile_interval cluster_alter_check_ready_interval cluster_check_scheduling_policies_interval + cluster_controller_tick_interval cluster_enable_topology_spread cluster_multi_process_replica_az_affinity_weight cluster_soften_az_affinity @@ -221,13 +222,18 @@ crdb_keepalives_interval crdb_keepalives_retries crdb_tcp_user_timeout + default_cluster_reconfiguration_timeout + default_hydration_burst_linger default_timestamp_interval disallow_unmaterializable_functions_as_of enable_0dt_caught_up_replica_status_check enable_0dt_deployment_panic_after_timeout enable_alter_table_add_column + enable_auto_scaling_strategy + enable_background_alter_cluster enable_binary_date_bin enable_bounded_staleness_isolation + enable_cluster_controller enable_coalesce_case_transform enable_compute_half_join2 enable_compute_render_fueled_as_specific_collection @@ -238,6 +244,7 @@ enable_eq_classes_withholding_errors enable_frontend_subscribes enable_glue_schema_registry + enable_hydration_burst enable_introspection_subscribes enable_kafka_broker_matching_rules enable_less_reduce_in_eqprop diff --git a/test/mysql-cdc-old-syntax/statistics.td b/test/mysql-cdc-old-syntax/statistics.td index b04a7cf658d0d..4b4d7f7492ccc 100644 --- a/test/mysql-cdc-old-syntax/statistics.td +++ b/test/mysql-cdc-old-syntax/statistics.td @@ -118,6 +118,13 @@ SELECT > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (the original replica never restarts). Wait for the +# drop to land so RF=1 below brings up a genuinely new replica with no snapshot +# stats. The old replica's stats persist in mz_source_statistics after it drops. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id WHERE c.name = 'stats_cluster' +0 + $ mysql-execute name=mysql INSERT INTO t1 VALUES ('three'); diff --git a/test/mysql-cdc/gtid-mode-error.td b/test/mysql-cdc/gtid-mode-error.td index 67d02c035552a..b699ed84f81ed 100644 --- a/test/mysql-cdc/gtid-mode-error.td +++ b/test/mysql-cdc/gtid-mode-error.td @@ -56,7 +56,12 @@ SET GLOBAL enforce_gtid_consistency = WARN; # Force the source to reconnect by cycling the cluster replication factor, # which causes the replication reader to restart and re-validate MySQL settings. +# The controller drops the replica asynchronously and would otherwise coalesce +# this 0->1 cycle into a no-op (the reader would keep running and never +# re-validate); wait for the drop to land so RF=1 starts a fresh reader. > ALTER CLUSTER gtid_cluster SET (REPLICATION FACTOR 0) +> SELECT count(*) FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'gtid_cluster' +0 > ALTER CLUSTER gtid_cluster SET (REPLICATION FACTOR 1) # The source should now be stalled due to the invalid enforce_gtid_consistency setting. diff --git a/test/mysql-cdc/statistics.td b/test/mysql-cdc/statistics.td index 488aae2367e74..348e3560d3601 100644 --- a/test/mysql-cdc/statistics.td +++ b/test/mysql-cdc/statistics.td @@ -127,6 +127,13 @@ SELECT > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (the original replica never restarts). Wait for the +# drop to land so RF=1 below brings up a genuinely new replica with no snapshot +# stats. The old replica's stats persist in mz_source_statistics after it drops. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id WHERE c.name = 'stats_cluster' +0 + $ mysql-execute name=mysql INSERT INTO t1 VALUES ('three'); diff --git a/test/pg-cdc-old-syntax/statistics.td b/test/pg-cdc-old-syntax/statistics.td index 4ce8bb70d5194..be2ddcaeef19a 100644 --- a/test/pg-cdc-old-syntax/statistics.td +++ b/test/pg-cdc-old-syntax/statistics.td @@ -128,6 +128,13 @@ SELECT > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (the original replica never restarts). Wait for the +# drop to land so RF=1 below brings up a genuinely new replica with no snapshot +# stats. The old replica's stats persist in mz_source_statistics after it drops. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id WHERE c.name = 'stats_cluster' +0 + $ postgres-execute connection=postgres://postgres:postgres@postgres INSERT INTO t1 VALUES ('four'); diff --git a/test/pg-cdc/statistics.td b/test/pg-cdc/statistics.td index 332b04aebbcc6..2e80924cdc33d 100644 --- a/test/pg-cdc/statistics.td +++ b/test/pg-cdc/statistics.td @@ -134,6 +134,17 @@ SELECT > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (the original replica never restarts). Wait for the +# drop to actually land so the RF=1 below brings up a genuinely new replica with no +# snapshot stats. The old replica's stats persist in mz_source_statistics after it +# is dropped, so the "old replica" assertions below still hold. +> SELECT count(*) + FROM mz_clusters c + JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id + WHERE c.name = 'stats_cluster' +0 + $ postgres-execute connection=postgres://postgres:postgres@postgres INSERT INTO t1 VALUES ('four'); diff --git a/test/sql-server-cdc-old-syntax/statistics.td b/test/sql-server-cdc-old-syntax/statistics.td index 7434485742096..046cc59f2eb4f 100644 --- a/test/sql-server-cdc-old-syntax/statistics.td +++ b/test/sql-server-cdc-old-syntax/statistics.td @@ -124,6 +124,13 @@ $ unset-regex > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (the original replica never restarts). Wait for the +# drop to land so RF=1 below brings up a genuinely new replica with no snapshot +# stats. The old replica's stats persist in mz_source_statistics after it drops. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id WHERE c.name = 'stats_cluster' +0 + $ sql-server-execute name=sql-server INSERT INTO t1 VALUES ('four'); diff --git a/test/sql-server-cdc/statistics.td b/test/sql-server-cdc/statistics.td index 820cd53ab7f95..654e85fa8e7fe 100644 --- a/test/sql-server-cdc/statistics.td +++ b/test/sql-server-cdc/statistics.td @@ -154,6 +154,13 @@ SELECT > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (the original replica never restarts). Wait for the +# drop to land so RF=1 below brings up a genuinely new replica with no snapshot +# stats. The old replica's stats persist in mz_source_statistics after it drops. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id WHERE c.name = 'stats_cluster' +0 + $ sql-server-execute name=sql-server INSERT INTO t1 VALUES ('three'); diff --git a/test/sqllogictest/autogenerated/mz_internal.slt b/test/sqllogictest/autogenerated/mz_internal.slt index 2ebdc4b4f9af7..b23c2430ab86e 100644 --- a/test/sqllogictest/autogenerated/mz_internal.slt +++ b/test/sqllogictest/autogenerated/mz_internal.slt @@ -122,6 +122,21 @@ cluster_id text The␠ID␠of␠the␠cluster.␠Corresponds␠to␠`mz_cluste type text `on-refresh`,␠or␠`manual`.␠Default:␠`manual` refresh_hydration_time_estimate interval The␠interval␠given␠in␠the␠`HYDRATION␠TIME␠ESTIMATE`␠option. +query TTT +SELECT name, type, comment FROM objects WHERE schema = 'mz_internal' AND object = 'mz_cluster_reconfigurations' ORDER BY position +---- +cluster_id text The␠ID␠of␠the␠cluster.␠Corresponds␠to␠`mz_clusters.id`. +deadline mz_timestamp The␠deadline␠by␠which␠the␠reconfiguration␠must␠complete;␠after␠it␠passes␠the␠`on_timeout`␠action␠applies.␠Compare␠against␠`mz_now()`␠to␠distinguish␠an␠in-progress␠reconfiguration␠from␠one␠past␠its␠deadline. +on_timeout text The␠action␠applied␠if␠`deadline`␠passes␠before␠the␠target␠hydrates:␠`commit`␠(cut␠over␠to␠the␠not-yet-hydrated␠target)␠or␠`rollback`␠(revert␠to␠the␠pre-reconfiguration␠shape). +target jsonb The␠config␠shape␠the␠cluster␠is␠reconfiguring␠to,␠as␠JSON:␠`size`,␠`replication_factor`,␠`availability_zones`,␠and␠`logging`.␠The␠realized␠(current)␠shape␠is␠in␠`mz_clusters`. + +query TTT +SELECT name, type, comment FROM objects WHERE schema = 'mz_internal' AND object = 'mz_cluster_auto_scaling_strategies' ORDER BY position +---- +cluster_id text The␠ID␠of␠the␠cluster.␠Corresponds␠to␠`mz_clusters.id`. +strategy jsonb **Unstable**␠The␠configured␠autoscaling␠policy,␠as␠JSON.␠Currently␠an␠`on_hydration`␠sub-policy␠carrying␠its␠`hydration_size`␠and␠optional␠`linger_duration`. +state jsonb **Unstable**␠The␠in-flight␠autoscaling␠runtime␠state,␠as␠JSON␠keyed␠by␠strategy,␠or␠`NULL`␠when␠nothing␠is␠running.␠Currently␠a␠`burst`␠key␠carrying␠the␠active␠hydration␠burst:␠its␠`burst_size`,␠`linger_duration`,␠and␠`steady_hydrated_at`. + query TTT SELECT name, type, comment FROM objects WHERE schema = 'mz_internal' AND object = 'mz_cluster_replica_metrics' ORDER BY position ---- @@ -744,7 +759,9 @@ mz_aws_privatelink_connection_statuses mz_builtin_materialized_views mz_builtin_sources mz_catalog_raw +mz_cluster_auto_scaling_strategies mz_cluster_deployment_lineage +mz_cluster_reconfigurations mz_cluster_replica_history mz_cluster_replica_metrics mz_cluster_replica_metrics_history diff --git a/test/sqllogictest/catalog_server_explain.slt b/test/sqllogictest/catalog_server_explain.slt index 22e9d60235f3d..5c8665e277a61 100644 --- a/test/sqllogictest/catalog_server_explain.slt +++ b/test/sqllogictest/catalog_server_explain.slt @@ -469,6 +469,19 @@ Target cluster: mz_catalog_server EOF +query T multiline +EXPLAIN INDEX "mz_internal"."mz_cluster_auto_scaling_strategies_ind"; +---- +mz_internal.mz_cluster_auto_scaling_strategies_ind: + →Arrange (#0{cluster_id}) + →Stream mz_internal.mz_cluster_auto_scaling_strategies + +Source mz_internal.mz_cluster_auto_scaling_strategies + +Target cluster: mz_catalog_server + +EOF + query T multiline EXPLAIN INDEX "mz_internal"."mz_cluster_deployment_lineage_ind"; ---- @@ -540,6 +553,19 @@ Target cluster: mz_catalog_server EOF +query T multiline +EXPLAIN INDEX "mz_internal"."mz_cluster_reconfigurations_ind"; +---- +mz_internal.mz_cluster_reconfigurations_ind: + →Arrange (#0{cluster_id}) + →Stream mz_internal.mz_cluster_reconfigurations + +Source mz_internal.mz_cluster_reconfigurations + +Target cluster: mz_catalog_server + +EOF + query T multiline EXPLAIN INDEX "mz_internal"."mz_cluster_replica_history_ind"; ---- @@ -1646,43 +1672,118 @@ mz_internal.mz_show_clusters: Key: (#0{id}) →Stream l1 cte l3 = - →Arrange (#0{id}) - →Arranged l2 - cte l4 = - →Differential Join %1:mz_comments[#0{id}] » %0:l3[#0{id}] - after %0: - Project: #0, #4, #5, #3 - Filter: (#1{object_type} = "cluster") AND (#2{object_sub_id}) IS NULL - →Arranged l3 - →Arranged mz_internal.mz_comments + →Distinct GroupAggregate + →Fused with Child Map/Filter/Project + Project: #0 + →Arranged l2 + Key: (#0, #1) →Return - →Map/Filter/Project - Project: #0, #1, #3 - Map: coalesce(#2{comment}, "") + →Delta Join [%0:l2[#0] » %1[#0] » %2[#0] » %3[#0]] [%1[#0] » %0:l2[#0] » %2[#0] » %3[#0]] [%2[#0] » %0:l2[#0] » %1[#0] » %3[#0]] [%3[#0] » %0:l2[#0] » %1[#0] » %2[#0]] + path %0: + after %1: + Project: #0..=#2, #5 + Map: case when (#4) IS NULL then "" else coalesce(#3, "") end + after %2: + Project: #0..=#3, #7, #8 + Map: (#5) IS NULL, case when #6 then null else #0 end, case when #6 then null else #4 end + after %3: + Project: #1, #2, #9, #3 + Map: case when (#7) IS NULL then null else #6 end, case when ((#4{cluster_id}) IS NOT NULL AND (#8{state}) IS NOT NULL) then ((("reconfiguring to " || (#5 ->> "size")) || "; hydration burst at ") || ((#8 -> "burst") ->> "burst_size")) else case when (#4) IS NOT NULL then ("reconfiguring to " || (#5 ->> "size")) else case when (#8) IS NOT NULL then ("hydration burst at " || ((#8 -> "burst") ->> "burst_size")) else null end end end + path %1: + after %2: + Project: #2, #3, #0, #4, #8, #9 + Map: (#6) IS NULL, case when #7 then null else #1 end, case when #7 then null else #5 end + after %3: + Project: #1, #2, #9, #3 + Map: case when (#7) IS NULL then null else #6 end, case when ((#4{cluster_id}) IS NOT NULL AND (#8{state}) IS NOT NULL) then ((("reconfiguring to " || (#5 ->> "size")) || "; hydration burst at ") || ((#8 -> "burst") ->> "burst_size")) else case when (#4) IS NOT NULL then ("reconfiguring to " || (#5 ->> "size")) else case when (#8) IS NOT NULL then ("hydration burst at " || ((#8 -> "burst") ->> "burst_size")) else null end end end + path %2: + after %0: + Project: #3, #4, #0, #2, #5 + Map: case when #1 then null else #0 end + after %1: + Project: #1, #2, #0, #3, #4, #7 + Map: case when (#6) IS NULL then "" else coalesce(#5, "") end + after %3: + Project: #1, #2, #9, #5 + Map: case when (#7) IS NULL then null else #6 end, case when ((#4{cluster_id}) IS NOT NULL AND (#8{state}) IS NOT NULL) then ((("reconfiguring to " || (#3 ->> "size")) || "; hydration burst at ") || ((#8 -> "burst") ->> "burst_size")) else case when (#4) IS NOT NULL then ("reconfiguring to " || (#3 ->> "size")) else case when (#8) IS NOT NULL then ("hydration burst at " || ((#8 -> "burst") ->> "burst_size")) else null end end end + path %3: + after %1: + Project: #1..=#3, #0, #4, #7 + Map: case when (#6) IS NULL then "" else coalesce(#5, "") end + after %2: + Project: #2, #3, #11, #5 + Map: (#7) IS NULL, case when #8 then null else #1 end, case when #8 then null else #6 end, case when ((#9{cluster_id}) IS NOT NULL AND (#4{state}) IS NOT NULL) then ((("reconfiguring to " || (#10 ->> "size")) || "; hydration burst at ") || ((#4 -> "burst") ->> "burst_size")) else case when (#9) IS NOT NULL then ("reconfiguring to " || (#10 ->> "size")) else case when (#4) IS NOT NULL then ("hydration burst at " || ((#4 -> "burst") ->> "burst_size")) else null end end end + →Arrange (#0) + →Arranged l2 + →Arrange (#0) →Union + →Fused with Child Map/Filter/Project + Project: #0, #3, #4 + Filter: (#1{object_type} = "cluster") AND (#2{object_sub_id}) IS NULL + Map: true + →Arranged mz_internal.mz_comments + Key: (#0{id}) →Map/Filter/Project Project: #0..=#2 - Map: null - →Consolidating Union - →Negate Diffs - →Differential Join %1[#0] » %0:l3[#0{id}] - →Arranged l3 - →Distinct GroupAggregate + Map: null, null + →Threshold Diffs #0 + →Arrange (#0) + →Consolidating Union + →Negate Diffs →Fused with Child Map/Filter/Project Project: #0 - →Read l4 - →Fused with Child Map/Filter/Project - Project: #1, #2 - →Arranged l2 - Key: (#0, #1) + Filter: (#1{object_type} = "cluster") AND (#2{object_sub_id}) IS NULL + →Arranged mz_internal.mz_comments + Key: (#0{id}) + →Unarranged Raw Stream + →Arranged l3 + →Arrange (#0) + →Union →Fused with Child Map/Filter/Project - Project: #1..=#3 - →Read l4 + Project: #0, #3, #4 + Map: true + →Arranged mz_internal.mz_cluster_reconfigurations + Key: (#0{cluster_id}) + →Map/Filter/Project + Project: #0..=#2 + Map: null, null + →Threshold Diffs #0 + →Arrange (#0) + →Consolidating Union + →Negate Diffs + →Fused with Child Map/Filter/Project + Project: #0 + →Arranged mz_internal.mz_cluster_reconfigurations + Key: (#0{cluster_id}) + →Unarranged Raw Stream + →Arranged l3 + →Arrange (#0) + →Union + →Fused with Child Map/Filter/Project + Project: #0, #2, #3 + Map: true + →Arranged mz_internal.mz_cluster_auto_scaling_strategies + Key: (#0{cluster_id}) + →Map/Filter/Project + Project: #0..=#2 + Map: null, null + →Threshold Diffs #0 + →Arrange (#0) + →Consolidating Union + →Negate Diffs + →Fused with Child Map/Filter/Project + Project: #0 + →Arranged mz_internal.mz_cluster_auto_scaling_strategies + Key: (#0{cluster_id}) + →Unarranged Raw Stream + →Arranged l3 Used Indexes: - mz_catalog.mz_clusters_ind (*** full scan ***, differential join) + - mz_internal.mz_cluster_reconfigurations_ind (*** full scan ***) + - mz_internal.mz_cluster_auto_scaling_strategies_ind (*** full scan ***) - mz_catalog.mz_cluster_replicas_ind (*** full scan ***) - - mz_internal.mz_comments_ind (differential join) + - mz_internal.mz_comments_ind (*** full scan ***) Target cluster: mz_catalog_server @@ -4216,7 +4317,7 @@ mz_catalog.mz_indexes: Project: #2, #0, #1, #3, #4, #7, #5, #6 Map: "s1" →Arrange (#1{name}) (#2{on_schema}, #3{on_name}) - →Constant (76 rows) + →Constant (78 rows) →Arrange (empty key) (#1{name}) →Fused with Child Map/Filter/Project Project: #4, #3 @@ -4322,7 +4423,7 @@ mz_catalog.mz_materialized_views: Project: #4, #0, #5, #1, #6, #2, #9, #8, #3, #7 Map: {=r/s1, s1=r/s1}, "s1" →Arrange (#1{schema_name}, #2{name}) - →Constant (18 rows) + →Constant (20 rows) →Arrange (empty key) (#0{schema_name}) (#0{schema_name}, #1{name}) →Fused with Child Map/Filter/Project Project: #4, #3, #5 @@ -4595,6 +4696,36 @@ Target cluster: mz_catalog_server EOF +query T multiline +EXPLAIN MATERIALIZED VIEW "mz_internal"."mz_cluster_auto_scaling_strategies"; +---- +mz_internal.mz_cluster_auto_scaling_strategies: + →Read mz_internal.mz_catalog_raw + +Source mz_internal.mz_catalog_raw + project=(#5..=#7) + filter=(("Cluster" = (#0{data} ->> "kind")) AND (#1) IS NOT NULL AND ((json_null != #2) OR (json_null != #3)) AND (#4 OR (#3 != json_null))) + map=(((((#0{data} -> "value") -> "config") -> "variant") -> "Managed"), (#1 -> "burst"), (#1 -> "auto_scaling_strategy"), (#2 != json_null), parse_catalog_id(((#0{data} -> "key") -> "id")), coalesce(#3{strategy}, json_null), case when #4 then jsonb_build_object("burst", jsonbable_to_jsonb(#2)) else null end) + +Target cluster: mz_catalog_server + +EOF + +query T multiline +EXPLAIN MATERIALIZED VIEW "mz_internal"."mz_cluster_reconfigurations"; +---- +mz_internal.mz_cluster_reconfigurations: + →Read mz_internal.mz_catalog_raw + +Source mz_internal.mz_catalog_raw + project=(#2..=#5) + filter=(("Cluster" = (#0{data} ->> "kind")) AND (json_null != #1) AND (#1 != json_null)) + map=((((((#0{data} -> "value") -> "config") -> "variant") -> "Managed") -> "reconfiguration"), parse_catalog_id(((#0{data} -> "key") -> "id")), text_to_mz_timestamp((#1{reconfiguration} ->> "deadline")), lower((#1{reconfiguration} ->> "on_timeout")), (#1{reconfiguration} -> "target")) + +Target cluster: mz_catalog_server + +EOF + query T multiline EXPLAIN MATERIALIZED VIEW "mz_internal"."mz_cluster_schedules"; ---- @@ -6903,7 +7034,7 @@ query T multiline EXPLAIN SELECT * FROM "mz_internal"."mz_builtin_materialized_views"; ---- Explained Query (fast path): - →Constant (18 rows) + →Constant (20 rows) Target cluster: mz_catalog_server @@ -8767,7 +8898,7 @@ query T multiline EXPLAIN SELECT * FROM "mz_internal"."mz_ontology_entity_types"; ---- Explained Query (fast path): - →Constant (129 rows) + →Constant (131 rows) Target cluster: mz_catalog_server @@ -8777,7 +8908,7 @@ query T multiline EXPLAIN SELECT * FROM "mz_internal"."mz_ontology_link_types"; ---- Explained Query (fast path): - →Constant (169 rows) + →Constant (171 rows) Target cluster: mz_catalog_server @@ -8791,7 +8922,7 @@ Explained Query: cte l0 = →Differential Join %1:mz_schemas[#0{id}] » %2:mz_objects[#2{schema_id}] » %0[#0{schema_name}, #1{table_name}] » %3:mz_columns[#0{id}] →Arrange (#0{schema_name}, #1{table_name}) - →Constant (129 rows) + →Constant (131 rows) →Arrange (#0{id}) →Fused with Child Map/Filter/Project Project: #1, #3 @@ -8844,7 +8975,7 @@ Explained Query: →Differential Join %0:l4[#0{entity_name}, #1{name}] » %1[#0{entity_name}, #1{column_name}] →Arranged l4 →Arrange (#0{entity_name}, #1{column_name}) - →Constant (268 rows) + →Constant (270 rows) →Return →Union →Map/Filter/Project diff --git a/test/sqllogictest/cluster.slt b/test/sqllogictest/cluster.slt index b3015f21d86b8..17a26bb437e1d 100644 --- a/test/sqllogictest/cluster.slt +++ b/test/sqllogictest/cluster.slt @@ -19,7 +19,7 @@ ALTER SYSTEM SET unsafe_enable_unorchestrated_cluster_replicas = on; ---- COMPLETE 0 -statement error Expected one of AVAILABILITY or DISK or INTROSPECTION or MANAGED or REPLICAS or REPLICATION or SIZE or SCHEDULE or WORKLOAD, found EOF +statement error Expected one of AUTO or AVAILABILITY or DISK or INTROSPECTION or MANAGED or REPLICAS or REPLICATION or SIZE or SCHEDULE or WORKLOAD, found EOF CREATE CLUSTER foo statement ok @@ -420,7 +420,7 @@ CREATE CLUSTER test REPLICAS (foo (SIZE 'scale=1,workers=1')); query I SELECT COUNT(name) FROM mz_indexes; ---- -300 +302 statement ok DROP CLUSTER test CASCADE @@ -428,7 +428,7 @@ DROP CLUSTER test CASCADE query T SELECT COUNT(name) FROM mz_indexes; ---- -268 +270 simple conn=mz_system,user=mz_system ALTER CLUSTER quickstart OWNER TO materialize @@ -874,15 +874,6 @@ SHOW CREATE CLUSTER c1 c1 CREATE CLUSTER "c1" (INTROSPECTION DEBUGGING = false, INTROSPECTION INTERVAL = INTERVAL '00:00:01', MANAGED = true, REPLICATION FACTOR = 2, SIZE = 'scale=1,workers=1', SCHEDULE = MANUAL) -statement ok -ALTER CLUSTER c1 SET (SIZE = 'scale=1,workers=2'); - -query TT -SHOW CREATE CLUSTER c1 ----- -c1 -CREATE CLUSTER "c1" (INTROSPECTION DEBUGGING = false, INTROSPECTION INTERVAL = INTERVAL '00:00:01', MANAGED = true, REPLICATION FACTOR = 2, SIZE = 'scale=1,workers=2', SCHEDULE = MANUAL) - statement ok DROP CLUSTER c1 diff --git a/test/sqllogictest/information_schema_tables.slt b/test/sqllogictest/information_schema_tables.slt index c9565d8195420..5d687c80ad077 100644 --- a/test/sqllogictest/information_schema_tables.slt +++ b/test/sqllogictest/information_schema_tables.slt @@ -301,10 +301,18 @@ mz_catalog_raw SOURCE materialize mz_internal +mz_cluster_auto_scaling_strategies +MATERIALIZED VIEW +materialize +mz_internal mz_cluster_deployment_lineage VIEW materialize mz_internal +mz_cluster_reconfigurations +MATERIALIZED VIEW +materialize +mz_internal mz_cluster_replica_history VIEW materialize diff --git a/test/sqllogictest/managed_cluster.slt b/test/sqllogictest/managed_cluster.slt index 189f6ac2ad9da..f75dc15370a61 100644 --- a/test/sqllogictest/managed_cluster.slt +++ b/test/sqllogictest/managed_cluster.slt @@ -214,90 +214,6 @@ DROP CLUSTER REPLICA foo.r1 statement error cannot modify managed cluster foo ALTER CLUSTER REPLICA foo.r2 RENAME TO bar -statement ok -ALTER CLUSTER foo SET (REPLICATION FACTOR 1) - -query TTT -SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster != 'quickstart' ORDER BY 1, 2, 3 ----- -foo r1 scale=1,workers=1 -mz_catalog_server r1 scale=1,workers=2 -mz_probe r1 scale=1,workers=2 -mz_system r1 scale=1,workers=2 - -query TTTTT rowsort -SELECT id, name, managed, replication_factor, size FROM mz_clusters WHERE name LIKE 'foo' ----- -u5 foo true 1 scale=1,workers=1 - -statement ok -ALTER CLUSTER foo SET (REPLICATION FACTOR 2) - -query TTT -SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster != 'quickstart' ORDER BY 1, 2, 3 ----- -foo r1 scale=1,workers=1 -foo r2 scale=1,workers=1 -mz_catalog_server r1 scale=1,workers=2 -mz_probe r1 scale=1,workers=2 -mz_system r1 scale=1,workers=2 - -query TTTTT rowsort -SELECT id, name, managed, replication_factor, size FROM mz_clusters WHERE name LIKE 'foo' ----- -u5 foo true 2 scale=1,workers=1 - -statement ok -ALTER CLUSTER foo RESET (REPLICATION FACTOR) - -query TTT -SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster != 'quickstart' ORDER BY 1, 2, 3 ----- -foo r1 scale=1,workers=1 -mz_catalog_server r1 scale=1,workers=2 -mz_probe r1 scale=1,workers=2 -mz_system r1 scale=1,workers=2 - -query TTTTT rowsort -SELECT id, name, managed, replication_factor, size FROM mz_clusters WHERE name LIKE 'foo' ----- -u5 foo true 1 scale=1,workers=1 - -statement ok -ALTER CLUSTER foo SET (SIZE 'scale=1,workers=2') - -query TTT -SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster != 'quickstart' ORDER BY 1, 2, 3 ----- -foo r1 scale=1,workers=2 -mz_catalog_server r1 scale=1,workers=2 -mz_probe r1 scale=1,workers=2 -mz_system r1 scale=1,workers=2 - -query TTTTT rowsort -SELECT id, name, managed, replication_factor, size FROM mz_clusters WHERE name LIKE 'foo' ----- -u5 foo true 1 scale=1,workers=2 - -statement ok -ALTER CLUSTER foo SET (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) - -query TTT -SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster != 'quickstart' ORDER BY 1, 2, 3 ----- -foo r1 scale=1,workers=1 -mz_catalog_server r1 scale=1,workers=2 -mz_probe r1 scale=1,workers=2 -mz_system r1 scale=1,workers=2 - -query TTTTT rowsort -SELECT id, name, managed, replication_factor, size FROM mz_clusters WHERE name LIKE 'foo' ----- -u5 foo true 1 scale=1,workers=1 - -statement error cannot drop replica of managed cluster -DROP CLUSTER REPLICA foo.r1 - statement ok ALTER CLUSTER foo SET (REPLICATION FACTOR 0) @@ -313,16 +229,8 @@ DROP CLUSTER REPLICA IF EXISTS bar.foo statement ok DROP CLUSTER REPLICA IF EXISTS quickstart.foo -statement error CLUSTER foo has no CLUSTER REPLICA named "r1" -DROP CLUSTER REPLICA foo.r1 - - -query TTT -SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster != 'quickstart' ORDER BY 1, 2, 3 ----- -mz_catalog_server r1 scale=1,workers=2 -mz_probe r1 scale=1,workers=2 -mz_system r1 scale=1,workers=2 +statement ok +DROP CLUSTER foo CASCADE query TTTTTTT SELECT r.name, r.size, s.processes, s.cpu_nano_cores, s.memory_bytes, s.workers, s.credits_per_hour FROM mz_cluster_replicas r JOIN mz_catalog.mz_cluster_replica_sizes s ON r.size = s.size JOIN mz_clusters ON r.cluster_id = mz_clusters.id WHERE mz_clusters.name != 'quickstart' ORDER BY r.name @@ -331,9 +239,6 @@ r1 scale=1,workers=2 1 18446744073709000000 18446744073709551615 2 1 r1 scale=1,workers=2 1 18446744073709000000 18446744073709551615 2 1 r1 scale=1,workers=2 1 18446744073709000000 18446744073709551615 2 1 -statement ok -DROP CLUSTER foo CASCADE - statement ok CREATE CLUSTER foo REPLICAS (r1 (SIZE 'scale=1,workers=1'), r2 (SIZE 'scale=1,workers=2')) diff --git a/test/sqllogictest/materialized_views.slt b/test/sqllogictest/materialized_views.slt index 23863cfb835a4..a3fe510e8b35d 100644 --- a/test/sqllogictest/materialized_views.slt +++ b/test/sqllogictest/materialized_views.slt @@ -1285,6 +1285,18 @@ UNION ALL # Automated cluster scheduling for REFRESH # ---------------------------------------- +# The controller owns scheduled clusters (the legacy scheduler is inert while the +# gate is on): it holds the realized `replication_factor` at 0 and toggles a +# single replica in and out of the refresh window, so on/off is checked by the +# replica count in `mz_cluster_replicas` rather than `replication_factor`. It +# audits the window-open creates as `schedule` with the legacy scheduler's +# `scheduling_policies` detail, and the window-close drops as `retired` with +# none. Drive the tick down so the transitions settle within the sleeps below. +simple conn=mz_system,user=mz_system +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' +---- +COMPLETE 0 + simple conn=mz_system,user=mz_system ALTER SYSTEM SET enable_cluster_schedule_refresh = false ---- @@ -1346,7 +1358,7 @@ SELECT mz_unsafe.mz_sleep(3+2); # Should turn off. query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_1'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_1'; ---- 0 @@ -1435,7 +1447,7 @@ SELECT * FROM mv10 # The other refresh cluster should be off, because there is no refresh MV on it yet. query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_3'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_3'; ---- 0 @@ -1487,7 +1499,7 @@ SELECT mz_unsafe.mz_sleep(3); # Should stay off, because it was reset to manual. query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_4'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_4'; ---- 0 @@ -1584,6 +1596,14 @@ c_schedule_hydration_time_estimate on-refresh 00:16:35 statement ok SELECT mz_unsafe.mz_sleep(8); +# The controller audits the window-open creates as "schedule", carrying the +# same per-decision `scheduling_policies` detail the legacy scheduler recorded +# (objects needing compaction/refresh, hydration time estimate). Window-close +# drops are "retired" with no detail: a drop happens exactly when no strategy +# desires the replica, so there is no decision to record (the legacy "off" +# blob does not come back). The "manual" rows are user-issued: replica creates +# at CREATE CLUSTER and the replica drops cascading from DROP CLUSTER (the +# `other` cluster). query TTTTBT rowsort SELECT DISTINCT event_type, @@ -1604,8 +1624,8 @@ create cluster-replica "other" "manual" true NULL create cluster-replica "c_schedule_1" "manual" true NULL create cluster-replica "c_schedule_2" "manual" true NULL create cluster-replica "c_schedule_5" "manual" true NULL -drop cluster-replica "c_schedule_1" "schedule" false {"decision":"off","hydration_time_estimate":"00:00:00","objects_needing_compaction":[],"objects_needing_refresh":[]} -drop cluster-replica "c_schedule_3" "schedule" false {"decision":"off","hydration_time_estimate":"00:00:00","objects_needing_compaction":[],"objects_needing_refresh":[]} +drop cluster-replica "c_schedule_1" "retired" true NULL +drop cluster-replica "c_schedule_3" "retired" true NULL create cluster-replica "c_schedule_1" "schedule" false {"decision":"on","hydration_time_estimate":"00:00:00","objects_needing_compaction":[],"objects_needing_refresh":["uXXX"]} create cluster-replica "c_schedule_3" "schedule" false {"decision":"on","hydration_time_estimate":"00:00:00","objects_needing_compaction":[],"objects_needing_refresh":["uXXX"]} create cluster-replica "c_schedule_hydration_time_estimate" "schedule" false {"decision":"on","hydration_time_estimate":"00:16:35","objects_needing_compaction":[],"objects_needing_refresh":["uXXX"]} @@ -1621,7 +1641,7 @@ statement ok CREATE CLUSTER c_schedule_6 (SIZE = 'scale=1,workers=1', SCHEDULE = ON REFRESH); query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_6'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_6'; ---- 0 @@ -1642,7 +1662,7 @@ statement ok SELECT mz_unsafe.mz_sleep(3+1+1); query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_6'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_6'; ---- 1 @@ -1656,7 +1676,7 @@ statement ok SELECT mz_unsafe.mz_sleep(3+1+1); query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_6'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_6'; ---- 0 @@ -1670,11 +1690,14 @@ statement ok SELECT mz_unsafe.mz_sleep(3+1+1); query I -SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_6'; +SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_6'; ---- 1 -# The audit events should now have a row that has a non-empty `objects_needing_compaction`. +# The audit events should now have a creation row with a non-empty +# `objects_needing_compaction`: the controller records the compaction-driven +# window decision just as the legacy scheduler did. The window-close drop is +# `retired` with no detail. query TTTTBT rowsort SELECT DISTINCT event_type, @@ -1689,7 +1712,7 @@ WHERE object_type = 'cluster-replica' AND (details->'cluster_name')::text = '"c_schedule_6"'; ---- -drop cluster-replica "c_schedule_6" "schedule" false {"decision":"off","hydration_time_estimate":"00:00:00","objects_needing_compaction":[],"objects_needing_refresh":[]} +drop cluster-replica "c_schedule_6" "retired" true NULL create cluster-replica "c_schedule_6" "schedule" false {"decision":"on","hydration_time_estimate":"00:00:00","objects_needing_compaction":["uXXX"],"objects_needing_refresh":[]} create cluster-replica "c_schedule_6" "schedule" false {"decision":"on","hydration_time_estimate":"00:00:00","objects_needing_compaction":[],"objects_needing_refresh":["uXXX"]} diff --git a/test/sqllogictest/mz_catalog_server_index_accounting.slt b/test/sqllogictest/mz_catalog_server_index_accounting.slt index e021da2e7a6ec..647f41d073354 100644 --- a/test/sqllogictest/mz_catalog_server_index_accounting.slt +++ b/test/sqllogictest/mz_catalog_server_index_accounting.slt @@ -37,103 +37,105 @@ mz_arrangement_heap_capacity_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangemen mz_arrangement_heap_size_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_heap_size_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_heap_size_raw"␠("operator_id",␠"worker_id") mz_arrangement_records_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_records_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_records_raw"␠("operator_id",␠"worker_id") mz_arrangement_sharing_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_sharing_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_sharing_raw"␠("operator_id",␠"worker_id") -mz_cluster_deployment_lineage_ind CREATE␠INDEX␠"mz_cluster_deployment_lineage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s748␠AS␠"mz_internal"."mz_cluster_deployment_lineage"]␠("cluster_id") +mz_cluster_auto_scaling_strategies_ind CREATE␠INDEX␠"mz_cluster_auto_scaling_strategies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s508␠AS␠"mz_internal"."mz_cluster_auto_scaling_strategies"]␠("cluster_id") +mz_cluster_deployment_lineage_ind CREATE␠INDEX␠"mz_cluster_deployment_lineage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s750␠AS␠"mz_internal"."mz_cluster_deployment_lineage"]␠("cluster_id") mz_cluster_prometheus_metrics_s2_primary_idx CREATE␠INDEX␠"mz_cluster_prometheus_metrics_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_cluster_prometheus_metrics"␠("process_id",␠"metric_name",␠"labels") -mz_cluster_replica_frontiers_ind CREATE␠INDEX␠"mz_cluster_replica_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s742␠AS␠"mz_catalog"."mz_cluster_replica_frontiers"]␠("object_id") -mz_cluster_replica_history_ind CREATE␠INDEX␠"mz_cluster_replica_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s600␠AS␠"mz_internal"."mz_cluster_replica_history"]␠("dropped_at") -mz_cluster_replica_metrics_history_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s511␠AS␠"mz_internal"."mz_cluster_replica_metrics_history"]␠("replica_id") -mz_cluster_replica_metrics_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s512␠AS␠"mz_internal"."mz_cluster_replica_metrics"]␠("replica_id") -mz_cluster_replica_name_history_ind CREATE␠INDEX␠"mz_cluster_replica_name_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s601␠AS␠"mz_internal"."mz_cluster_replica_name_history"]␠("id") +mz_cluster_reconfigurations_ind CREATE␠INDEX␠"mz_cluster_reconfigurations_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s507␠AS␠"mz_internal"."mz_cluster_reconfigurations"]␠("cluster_id") +mz_cluster_replica_frontiers_ind CREATE␠INDEX␠"mz_cluster_replica_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s744␠AS␠"mz_catalog"."mz_cluster_replica_frontiers"]␠("object_id") +mz_cluster_replica_history_ind CREATE␠INDEX␠"mz_cluster_replica_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s602␠AS␠"mz_internal"."mz_cluster_replica_history"]␠("dropped_at") +mz_cluster_replica_metrics_history_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s513␠AS␠"mz_internal"."mz_cluster_replica_metrics_history"]␠("replica_id") +mz_cluster_replica_metrics_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s514␠AS␠"mz_internal"."mz_cluster_replica_metrics"]␠("replica_id") +mz_cluster_replica_name_history_ind CREATE␠INDEX␠"mz_cluster_replica_name_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s603␠AS␠"mz_internal"."mz_cluster_replica_name_history"]␠("id") mz_cluster_replica_size_internal_ind CREATE␠INDEX␠"mz_cluster_replica_size_internal_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s503␠AS␠"mz_internal"."mz_cluster_replica_size_internal"]␠("size") mz_cluster_replica_sizes_ind CREATE␠INDEX␠"mz_cluster_replica_sizes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s502␠AS␠"mz_catalog"."mz_cluster_replica_sizes"]␠("size") -mz_cluster_replica_status_history_ind CREATE␠INDEX␠"mz_cluster_replica_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s513␠AS␠"mz_internal"."mz_cluster_replica_status_history"]␠("replica_id") -mz_cluster_replica_statuses_ind CREATE␠INDEX␠"mz_cluster_replica_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s514␠AS␠"mz_internal"."mz_cluster_replica_statuses"]␠("replica_id") -mz_cluster_replicas_ind CREATE␠INDEX␠"mz_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s510␠AS␠"mz_catalog"."mz_cluster_replicas"]␠("id") +mz_cluster_replica_status_history_ind CREATE␠INDEX␠"mz_cluster_replica_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s515␠AS␠"mz_internal"."mz_cluster_replica_status_history"]␠("replica_id") +mz_cluster_replica_statuses_ind CREATE␠INDEX␠"mz_cluster_replica_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s516␠AS␠"mz_internal"."mz_cluster_replica_statuses"]␠("replica_id") +mz_cluster_replicas_ind CREATE␠INDEX␠"mz_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s512␠AS␠"mz_catalog"."mz_cluster_replicas"]␠("id") mz_clusters_ind CREATE␠INDEX␠"mz_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s504␠AS␠"mz_catalog"."mz_clusters"]␠("id") mz_columns_ind CREATE␠INDEX␠"mz_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s475␠AS␠"mz_catalog"."mz_columns"]␠("name") -mz_comments_ind CREATE␠INDEX␠"mz_comments_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s526␠AS␠"mz_internal"."mz_comments"]␠("id") +mz_comments_ind CREATE␠INDEX␠"mz_comments_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s528␠AS␠"mz_internal"."mz_comments"]␠("id") mz_compute_dataflow_global_ids_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_dataflow_global_ids_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_dataflow_global_ids_per_worker"␠("id",␠"worker_id",␠"global_id") -mz_compute_dependencies_ind CREATE␠INDEX␠"mz_compute_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s726␠AS␠"mz_internal"."mz_compute_dependencies"]␠("dependency_id") +mz_compute_dependencies_ind CREATE␠INDEX␠"mz_compute_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s728␠AS␠"mz_internal"."mz_compute_dependencies"]␠("dependency_id") mz_compute_error_counts_raw_s2_primary_idx CREATE␠INDEX␠"mz_compute_error_counts_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_error_counts_raw"␠("export_id",␠"worker_id") mz_compute_exports_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_exports_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_exports_per_worker"␠("export_id",␠"worker_id") mz_compute_frontiers_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_frontiers_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_frontiers_per_worker"␠("export_id",␠"worker_id") -mz_compute_hydration_times_ind CREATE␠INDEX␠"mz_compute_hydration_times_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s733␠AS␠"mz_internal"."mz_compute_hydration_times"]␠("replica_id") +mz_compute_hydration_times_ind CREATE␠INDEX␠"mz_compute_hydration_times_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s735␠AS␠"mz_internal"."mz_compute_hydration_times"]␠("replica_id") mz_compute_hydration_times_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_hydration_times_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_hydration_times_per_worker"␠("export_id",␠"worker_id") mz_compute_import_frontiers_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_import_frontiers_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_import_frontiers_per_worker"␠("export_id",␠"import_id",␠"worker_id") mz_compute_lir_mapping_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_lir_mapping_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_lir_mapping_per_worker"␠("global_id",␠"lir_id",␠"worker_id") mz_compute_operator_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_compute_operator_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_operator_durations_histogram_raw"␠("id",␠"worker_id",␠"duration_ns") mz_compute_operator_hydration_statuses_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_operator_hydration_statuses_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_operator_hydration_statuses_per_worker"␠("export_id",␠"lir_id",␠"worker_id") -mz_connections_ind CREATE␠INDEX␠"mz_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s508␠AS␠"mz_catalog"."mz_connections"]␠("schema_id") -mz_console_cluster_utilization_overview_ind CREATE␠INDEX␠"mz_console_cluster_utilization_overview_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s729␠AS␠"mz_internal"."mz_console_cluster_utilization_overview"]␠("cluster_id") +mz_connections_ind CREATE␠INDEX␠"mz_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s510␠AS␠"mz_catalog"."mz_connections"]␠("schema_id") +mz_console_cluster_utilization_overview_ind CREATE␠INDEX␠"mz_console_cluster_utilization_overview_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s731␠AS␠"mz_internal"."mz_console_cluster_utilization_overview"]␠("cluster_id") mz_databases_ind CREATE␠INDEX␠"mz_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s473␠AS␠"mz_catalog"."mz_databases"]␠("name") mz_dataflow_addresses_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_addresses_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_addresses_per_worker"␠("id",␠"worker_id") mz_dataflow_channels_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_channels_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_channels_per_worker"␠("id",␠"worker_id") mz_dataflow_operator_reachability_raw_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_operator_reachability_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_operator_reachability_raw"␠("id",␠"worker_id",␠"source",␠"port",␠"update_type",␠"time") mz_dataflow_operators_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_operators_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_operators_per_worker"␠("id",␠"worker_id") -mz_frontiers_ind CREATE␠INDEX␠"mz_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s717␠AS␠"mz_internal"."mz_frontiers"]␠("object_id") -mz_hydration_statuses_ind CREATE␠INDEX␠"mz_hydration_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s744␠AS␠"mz_internal"."mz_hydration_statuses"]␠("object_id",␠"replica_id") +mz_frontiers_ind CREATE␠INDEX␠"mz_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s719␠AS␠"mz_internal"."mz_frontiers"]␠("object_id") +mz_hydration_statuses_ind CREATE␠INDEX␠"mz_hydration_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s746␠AS␠"mz_internal"."mz_hydration_statuses"]␠("object_id",␠"replica_id") mz_indexes_ind CREATE␠INDEX␠"mz_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s476␠AS␠"mz_catalog"."mz_indexes"]␠("id") mz_kafka_sources_ind CREATE␠INDEX␠"mz_kafka_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s470␠AS␠"mz_catalog"."mz_kafka_sources"]␠("id") -mz_materialized_views_ind CREATE␠INDEX␠"mz_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s529␠AS␠"mz_catalog"."mz_materialized_views"]␠("id") +mz_materialized_views_ind CREATE␠INDEX␠"mz_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s531␠AS␠"mz_catalog"."mz_materialized_views"]␠("id") mz_message_batch_counts_received_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_batch_counts_received_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_batch_counts_received_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_batch_counts_sent_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_batch_counts_sent_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_batch_counts_sent_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_counts_received_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_counts_received_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_counts_received_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_counts_sent_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_counts_sent_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_counts_sent_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") -mz_notices_ind CREATE␠INDEX␠"mz_notices_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s814␠AS␠"mz_internal"."mz_notices"]␠("id") -mz_object_arrangement_size_history_object_ind CREATE␠INDEX␠"mz_object_arrangement_size_history_object_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s736␠AS␠"mz_internal"."mz_object_arrangement_size_history"]␠("object_id") -mz_object_arrangement_size_history_ts_ind CREATE␠INDEX␠"mz_object_arrangement_size_history_ts_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s736␠AS␠"mz_internal"."mz_object_arrangement_size_history"]␠("collection_timestamp") -mz_object_arrangement_sizes_ind CREATE␠INDEX␠"mz_object_arrangement_sizes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s734␠AS␠"mz_internal"."mz_object_arrangement_sizes"]␠("replica_id") +mz_notices_ind CREATE␠INDEX␠"mz_notices_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s818␠AS␠"mz_internal"."mz_notices"]␠("id") +mz_object_arrangement_size_history_object_ind CREATE␠INDEX␠"mz_object_arrangement_size_history_object_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s738␠AS␠"mz_internal"."mz_object_arrangement_size_history"]␠("object_id") +mz_object_arrangement_size_history_ts_ind CREATE␠INDEX␠"mz_object_arrangement_size_history_ts_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s738␠AS␠"mz_internal"."mz_object_arrangement_size_history"]␠("collection_timestamp") +mz_object_arrangement_sizes_ind CREATE␠INDEX␠"mz_object_arrangement_sizes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s736␠AS␠"mz_internal"."mz_object_arrangement_sizes"]␠("replica_id") mz_object_dependencies_ind CREATE␠INDEX␠"mz_object_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s471␠AS␠"mz_internal"."mz_object_dependencies"]␠("object_id") -mz_object_history_ind CREATE␠INDEX␠"mz_object_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s540␠AS␠"mz_internal"."mz_object_history"]␠("id") -mz_object_lifetimes_ind CREATE␠INDEX␠"mz_object_lifetimes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s541␠AS␠"mz_internal"."mz_object_lifetimes"]␠("id") -mz_object_transitive_dependencies_ind CREATE␠INDEX␠"mz_object_transitive_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s557␠AS␠"mz_internal"."mz_object_transitive_dependencies"]␠("object_id") -mz_objects_ind CREATE␠INDEX␠"mz_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s537␠AS␠"mz_catalog"."mz_objects"]␠("schema_id") +mz_object_history_ind CREATE␠INDEX␠"mz_object_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s542␠AS␠"mz_internal"."mz_object_history"]␠("id") +mz_object_lifetimes_ind CREATE␠INDEX␠"mz_object_lifetimes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s543␠AS␠"mz_internal"."mz_object_lifetimes"]␠("id") +mz_object_transitive_dependencies_ind CREATE␠INDEX␠"mz_object_transitive_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s559␠AS␠"mz_internal"."mz_object_transitive_dependencies"]␠("object_id") +mz_objects_ind CREATE␠INDEX␠"mz_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s539␠AS␠"mz_catalog"."mz_objects"]␠("schema_id") mz_peek_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_peek_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_peek_durations_histogram_raw"␠("worker_id",␠"type",␠"duration_ns") -mz_recent_activity_log_thinned_ind CREATE␠INDEX␠"mz_recent_activity_log_thinned_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s701␠AS␠"mz_internal"."mz_recent_activity_log_thinned"]␠("sql_hash") -mz_recent_sql_text_ind CREATE␠INDEX␠"mz_recent_sql_text_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s697␠AS␠"mz_internal"."mz_recent_sql_text"]␠("sql_hash") -mz_recent_storage_usage_ind CREATE␠INDEX␠"mz_recent_storage_usage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s807␠AS␠"mz_catalog"."mz_recent_storage_usage"]␠("object_id") +mz_recent_activity_log_thinned_ind CREATE␠INDEX␠"mz_recent_activity_log_thinned_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s703␠AS␠"mz_internal"."mz_recent_activity_log_thinned"]␠("sql_hash") +mz_recent_sql_text_ind CREATE␠INDEX␠"mz_recent_sql_text_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s699␠AS␠"mz_internal"."mz_recent_sql_text"]␠("sql_hash") +mz_recent_storage_usage_ind CREATE␠INDEX␠"mz_recent_storage_usage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s811␠AS␠"mz_catalog"."mz_recent_storage_usage"]␠("object_id") mz_roles_ind CREATE␠INDEX␠"mz_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s494␠AS␠"mz_catalog"."mz_roles"]␠("id") mz_scheduling_elapsed_raw_s2_primary_idx CREATE␠INDEX␠"mz_scheduling_elapsed_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_scheduling_elapsed_raw"␠("id",␠"worker_id") mz_scheduling_parks_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_scheduling_parks_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_scheduling_parks_histogram_raw"␠("worker_id",␠"slept_for_ns",␠"requested_ns") mz_schemas_ind CREATE␠INDEX␠"mz_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s474␠AS␠"mz_catalog"."mz_schemas"]␠("database_id") -mz_secrets_ind CREATE␠INDEX␠"mz_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s507␠AS␠"mz_catalog"."mz_secrets"]␠("name") -mz_show_all_objects_ind CREATE␠INDEX␠"mz_show_all_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s585␠AS␠"mz_internal"."mz_show_all_objects"]␠("schema_id") -mz_show_cluster_replicas_ind CREATE␠INDEX␠"mz_show_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s746␠AS␠"mz_internal"."mz_show_cluster_replicas"]␠("cluster") -mz_show_clusters_ind CREATE␠INDEX␠"mz_show_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s587␠AS␠"mz_internal"."mz_show_clusters"]␠("name") -mz_show_columns_ind CREATE␠INDEX␠"mz_show_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s586␠AS␠"mz_internal"."mz_show_columns"]␠("id") -mz_show_connections_ind CREATE␠INDEX␠"mz_show_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s595␠AS␠"mz_internal"."mz_show_connections"]␠("schema_id") -mz_show_databases_ind CREATE␠INDEX␠"mz_show_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s589␠AS␠"mz_internal"."mz_show_databases"]␠("name") -mz_show_indexes_ind CREATE␠INDEX␠"mz_show_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s599␠AS␠"mz_internal"."mz_show_indexes"]␠("schema_id") -mz_show_materialized_views_ind CREATE␠INDEX␠"mz_show_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s598␠AS␠"mz_internal"."mz_show_materialized_views"]␠("schema_id") -mz_show_roles_ind CREATE␠INDEX␠"mz_show_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s594␠AS␠"mz_internal"."mz_show_roles"]␠("name") -mz_show_schemas_ind CREATE␠INDEX␠"mz_show_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s590␠AS␠"mz_internal"."mz_show_schemas"]␠("database_id") -mz_show_secrets_ind CREATE␠INDEX␠"mz_show_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s588␠AS␠"mz_internal"."mz_show_secrets"]␠("schema_id") -mz_show_sinks_ind CREATE␠INDEX␠"mz_show_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s597␠AS␠"mz_internal"."mz_show_sinks"]␠("schema_id") -mz_show_sources_ind CREATE␠INDEX␠"mz_show_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s596␠AS␠"mz_internal"."mz_show_sources"]␠("schema_id") -mz_show_tables_ind CREATE␠INDEX␠"mz_show_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s591␠AS␠"mz_internal"."mz_show_tables"]␠("schema_id") -mz_show_types_ind CREATE␠INDEX␠"mz_show_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s593␠AS␠"mz_internal"."mz_show_types"]␠("schema_id") -mz_show_views_ind CREATE␠INDEX␠"mz_show_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s592␠AS␠"mz_internal"."mz_show_views"]␠("schema_id") -mz_sink_statistics_ind CREATE␠INDEX␠"mz_sink_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s714␠AS␠"mz_internal"."mz_sink_statistics"]␠("id",␠"replica_id") -mz_sink_status_history_ind CREATE␠INDEX␠"mz_sink_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s686␠AS␠"mz_internal"."mz_sink_status_history"]␠("sink_id") -mz_sink_statuses_ind CREATE␠INDEX␠"mz_sink_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s687␠AS␠"mz_internal"."mz_sink_statuses"]␠("id") +mz_secrets_ind CREATE␠INDEX␠"mz_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s509␠AS␠"mz_catalog"."mz_secrets"]␠("name") +mz_show_all_objects_ind CREATE␠INDEX␠"mz_show_all_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s587␠AS␠"mz_internal"."mz_show_all_objects"]␠("schema_id") +mz_show_cluster_replicas_ind CREATE␠INDEX␠"mz_show_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s748␠AS␠"mz_internal"."mz_show_cluster_replicas"]␠("cluster") +mz_show_clusters_ind CREATE␠INDEX␠"mz_show_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s589␠AS␠"mz_internal"."mz_show_clusters"]␠("name") +mz_show_columns_ind CREATE␠INDEX␠"mz_show_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s588␠AS␠"mz_internal"."mz_show_columns"]␠("id") +mz_show_connections_ind CREATE␠INDEX␠"mz_show_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s597␠AS␠"mz_internal"."mz_show_connections"]␠("schema_id") +mz_show_databases_ind CREATE␠INDEX␠"mz_show_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s591␠AS␠"mz_internal"."mz_show_databases"]␠("name") +mz_show_indexes_ind CREATE␠INDEX␠"mz_show_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s601␠AS␠"mz_internal"."mz_show_indexes"]␠("schema_id") +mz_show_materialized_views_ind CREATE␠INDEX␠"mz_show_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s600␠AS␠"mz_internal"."mz_show_materialized_views"]␠("schema_id") +mz_show_roles_ind CREATE␠INDEX␠"mz_show_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s596␠AS␠"mz_internal"."mz_show_roles"]␠("name") +mz_show_schemas_ind CREATE␠INDEX␠"mz_show_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s592␠AS␠"mz_internal"."mz_show_schemas"]␠("database_id") +mz_show_secrets_ind CREATE␠INDEX␠"mz_show_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s590␠AS␠"mz_internal"."mz_show_secrets"]␠("schema_id") +mz_show_sinks_ind CREATE␠INDEX␠"mz_show_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s599␠AS␠"mz_internal"."mz_show_sinks"]␠("schema_id") +mz_show_sources_ind CREATE␠INDEX␠"mz_show_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s598␠AS␠"mz_internal"."mz_show_sources"]␠("schema_id") +mz_show_tables_ind CREATE␠INDEX␠"mz_show_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s593␠AS␠"mz_internal"."mz_show_tables"]␠("schema_id") +mz_show_types_ind CREATE␠INDEX␠"mz_show_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s595␠AS␠"mz_internal"."mz_show_types"]␠("schema_id") +mz_show_views_ind CREATE␠INDEX␠"mz_show_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s594␠AS␠"mz_internal"."mz_show_views"]␠("schema_id") +mz_sink_statistics_ind CREATE␠INDEX␠"mz_sink_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s716␠AS␠"mz_internal"."mz_sink_statistics"]␠("id",␠"replica_id") +mz_sink_status_history_ind CREATE␠INDEX␠"mz_sink_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s688␠AS␠"mz_internal"."mz_sink_status_history"]␠("sink_id") +mz_sink_statuses_ind CREATE␠INDEX␠"mz_sink_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s689␠AS␠"mz_internal"."mz_sink_statuses"]␠("id") mz_sinks_ind CREATE␠INDEX␠"mz_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s486␠AS␠"mz_catalog"."mz_sinks"]␠("id") -mz_source_statistics_ind CREATE␠INDEX␠"mz_source_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s712␠AS␠"mz_internal"."mz_source_statistics"]␠("id",␠"replica_id") -mz_source_statistics_with_history_ind CREATE␠INDEX␠"mz_source_statistics_with_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s710␠AS␠"mz_internal"."mz_source_statistics_with_history"]␠("id",␠"replica_id") -mz_source_status_history_ind CREATE␠INDEX␠"mz_source_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s688␠AS␠"mz_internal"."mz_source_status_history"]␠("source_id") -mz_source_statuses_ind CREATE␠INDEX␠"mz_source_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s705␠AS␠"mz_internal"."mz_source_statuses"]␠("id") +mz_source_statistics_ind CREATE␠INDEX␠"mz_source_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s714␠AS␠"mz_internal"."mz_source_statistics"]␠("id",␠"replica_id") +mz_source_statistics_with_history_ind CREATE␠INDEX␠"mz_source_statistics_with_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s712␠AS␠"mz_internal"."mz_source_statistics_with_history"]␠("id",␠"replica_id") +mz_source_status_history_ind CREATE␠INDEX␠"mz_source_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s690␠AS␠"mz_internal"."mz_source_status_history"]␠("source_id") +mz_source_statuses_ind CREATE␠INDEX␠"mz_source_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s707␠AS␠"mz_internal"."mz_source_statuses"]␠("id") mz_sources_ind CREATE␠INDEX␠"mz_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s479␠AS␠"mz_catalog"."mz_sources"]␠("id") mz_tables_ind CREATE␠INDEX␠"mz_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s478␠AS␠"mz_catalog"."mz_tables"]␠("schema_id") mz_types_ind CREATE␠INDEX␠"mz_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s488␠AS␠"mz_catalog"."mz_types"]␠("schema_id") mz_views_ind CREATE␠INDEX␠"mz_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s487␠AS␠"mz_catalog"."mz_views"]␠("schema_id") -mz_wallclock_global_lag_recent_history_ind CREATE␠INDEX␠"mz_wallclock_global_lag_recent_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s721␠AS␠"mz_internal"."mz_wallclock_global_lag_recent_history"]␠("object_id") -mz_webhook_sources_ind CREATE␠INDEX␠"mz_webhook_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s527␠AS␠"mz_internal"."mz_webhook_sources"]␠("id") -pg_attrdef_all_databases_ind CREATE␠INDEX␠"pg_attrdef_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s626␠AS␠"mz_internal"."pg_attrdef_all_databases"]␠("oid",␠"adrelid",␠"adnum",␠"adbin",␠"adsrc") -pg_attribute_all_databases_ind CREATE␠INDEX␠"pg_attribute_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s619␠AS␠"mz_internal"."pg_attribute_all_databases"]␠("attrelid",␠"attname",␠"atttypid",␠"attlen",␠"attnum",␠"atttypmod",␠"attnotnull",␠"atthasdef",␠"attidentity",␠"attgenerated",␠"attisdropped",␠"attcollation",␠"database_name",␠"pg_type_database_name") -pg_authid_core_ind CREATE␠INDEX␠"pg_authid_core_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s636␠AS␠"mz_internal"."pg_authid_core"]␠("rolname") -pg_class_all_databases_ind CREATE␠INDEX␠"pg_class_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s607␠AS␠"mz_internal"."pg_class_all_databases"]␠("relname") -pg_description_all_databases_ind CREATE␠INDEX␠"pg_description_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s616␠AS␠"mz_internal"."pg_description_all_databases"]␠("objoid",␠"classoid",␠"objsubid",␠"description",␠"oid_database_name",␠"class_database_name") -pg_namespace_all_databases_ind CREATE␠INDEX␠"pg_namespace_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s604␠AS␠"mz_internal"."pg_namespace_all_databases"]␠("nspname") -pg_type_all_databases_ind CREATE␠INDEX␠"pg_type_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s613␠AS␠"mz_internal"."pg_type_all_databases"]␠("oid") +mz_wallclock_global_lag_recent_history_ind CREATE␠INDEX␠"mz_wallclock_global_lag_recent_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s723␠AS␠"mz_internal"."mz_wallclock_global_lag_recent_history"]␠("object_id") +mz_webhook_sources_ind CREATE␠INDEX␠"mz_webhook_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s529␠AS␠"mz_internal"."mz_webhook_sources"]␠("id") +pg_attrdef_all_databases_ind CREATE␠INDEX␠"pg_attrdef_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s628␠AS␠"mz_internal"."pg_attrdef_all_databases"]␠("oid",␠"adrelid",␠"adnum",␠"adbin",␠"adsrc") +pg_attribute_all_databases_ind CREATE␠INDEX␠"pg_attribute_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s621␠AS␠"mz_internal"."pg_attribute_all_databases"]␠("attrelid",␠"attname",␠"atttypid",␠"attlen",␠"attnum",␠"atttypmod",␠"attnotnull",␠"atthasdef",␠"attidentity",␠"attgenerated",␠"attisdropped",␠"attcollation",␠"database_name",␠"pg_type_database_name") +pg_authid_core_ind CREATE␠INDEX␠"pg_authid_core_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s638␠AS␠"mz_internal"."pg_authid_core"]␠("rolname") +pg_class_all_databases_ind CREATE␠INDEX␠"pg_class_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s609␠AS␠"mz_internal"."pg_class_all_databases"]␠("relname") +pg_description_all_databases_ind CREATE␠INDEX␠"pg_description_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s618␠AS␠"mz_internal"."pg_description_all_databases"]␠("objoid",␠"classoid",␠"objsubid",␠"description",␠"oid_database_name",␠"class_database_name") +pg_namespace_all_databases_ind CREATE␠INDEX␠"pg_namespace_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s606␠AS␠"mz_internal"."pg_namespace_all_databases"]␠("nspname") +pg_type_all_databases_ind CREATE␠INDEX␠"pg_type_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s615␠AS␠"mz_internal"."pg_type_all_databases"]␠("oid") # Record all transitive dependencies (tables, sources, views, mvs) of indexes on # the mz_catalog_server cluster. @@ -221,6 +223,9 @@ mz_builtin_materialized_views oid mz_builtin_materialized_views privileges mz_builtin_materialized_views schema_name mz_catalog_raw data +mz_cluster_auto_scaling_strategies cluster_id +mz_cluster_auto_scaling_strategies state +mz_cluster_auto_scaling_strategies strategy mz_cluster_deployment_lineage cluster_id mz_cluster_deployment_lineage cluster_name mz_cluster_deployment_lineage current_deployment_cluster_id @@ -230,6 +235,10 @@ mz_cluster_prometheus_metrics metric_name mz_cluster_prometheus_metrics metric_type mz_cluster_prometheus_metrics process_id mz_cluster_prometheus_metrics value +mz_cluster_reconfigurations cluster_id +mz_cluster_reconfigurations deadline +mz_cluster_reconfigurations on_timeout +mz_cluster_reconfigurations target mz_cluster_replica_frontiers object_id mz_cluster_replica_frontiers replica_id mz_cluster_replica_frontiers write_frontier @@ -615,6 +624,7 @@ mz_show_cluster_replicas ready mz_show_cluster_replicas replica mz_show_cluster_replicas replica_id mz_show_cluster_replicas size +mz_show_clusters activity mz_show_clusters comment mz_show_clusters name mz_show_clusters replicas diff --git a/test/sqllogictest/oid.slt b/test/sqllogictest/oid.slt index f9a8c2fdb0013..c00b1933347a0 100644 --- a/test/sqllogictest/oid.slt +++ b/test/sqllogictest/oid.slt @@ -1194,3 +1194,7 @@ SELECT oid, name FROM mz_objects WHERE id LIKE 's%' AND oid < 20000 ORDER BY oid 17087 mz_builtin_sources 17088 mz_cluster_replica_size_internal 17089 mz_cluster_replica_size_internal_ind +17090 mz_cluster_reconfigurations +17091 mz_cluster_reconfigurations_ind +17092 mz_cluster_auto_scaling_strategies +17093 mz_cluster_auto_scaling_strategies_ind diff --git a/test/sqllogictest/show_clusters.slt b/test/sqllogictest/show_clusters.slt index 58ea3eb6bd4fa..edd1c125247c8 100644 --- a/test/sqllogictest/show_clusters.slt +++ b/test/sqllogictest/show_clusters.slt @@ -42,3 +42,22 @@ mz_support NULL mz_system r1 (scale=1,workers=2) + +# `SHOW CLUSTERS` surfaces any in-flight reconfiguration or autoscaling action in a +# single `activity` column. With the cluster controller at its default (off), no +# reconfiguration or burst record is ever written, so `activity` is NULL for every +# cluster — managed (baz) or unmanaged (foo). +statement ok +CREATE CLUSTER baz (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) + +query TT rowsort +SELECT name, activity +FROM (SHOW CLUSTERS) WHERE name IN ('baz', 'foo') +---- +baz +NULL +foo +NULL + +statement ok +DROP CLUSTER baz diff --git a/test/sqllogictest/singlereplica_mz_clusters.slt b/test/sqllogictest/singlereplica_mz_clusters.slt index 1da5156359e48..30b0bc030b194 100644 --- a/test/sqllogictest/singlereplica_mz_clusters.slt +++ b/test/sqllogictest/singlereplica_mz_clusters.slt @@ -110,14 +110,6 @@ SELECT replication_factor FROM mz_clusters WHERE name = 'c_managed' ---- 2 -statement ok -ALTER CLUSTER c_managed SET (SIZE = 'scale=2,workers=2') - -query T -SELECT size FROM mz_clusters WHERE name = 'c_managed' ----- -scale=2,workers=2 - # Replication factor 0 is allowed and must round-trip. statement ok ALTER CLUSTER c_managed SET (REPLICATION FACTOR = 0) @@ -188,16 +180,9 @@ FROM mz_clusters WHERE name = 'c_introspection' ---- true 00:00:05 -# INTROSPECTION INTERVAL = 0 must round-trip to NULL (matches Option::None for -# the duration in the ReplicaLogging.interval field). -statement ok -ALTER CLUSTER c_introspection SET (INTROSPECTION INTERVAL = 0) - -query B -SELECT introspection_interval IS NULL -FROM mz_clusters WHERE name = 'c_introspection' ----- -true +# The INTROSPECTION INTERVAL = 0 -> NULL round-trip is now a config-shape change +# the controller reshapes asynchronously; it is asserted in +# test/testdrive/cluster-controller.td (cc_logging), where the readback can retry. statement ok DROP CLUSTER c_introspection diff --git a/test/testdrive-old-kafka-src-syntax/kafka-recreate-topic.td b/test/testdrive-old-kafka-src-syntax/kafka-recreate-topic.td index 4a9fcb8588659..8ec040afe2341 100644 --- a/test/testdrive-old-kafka-src-syntax/kafka-recreate-topic.td +++ b/test/testdrive-old-kafka-src-syntax/kafka-recreate-topic.td @@ -49,6 +49,13 @@ $ kafka-create-topic topic=topic1 partitions=4 # deletion before the new topic was created. > ALTER CLUSTER to_recreate SET (REPLICATION FACTOR 0) +# The controller drops the replica asynchronously and would otherwise coalesce a +# 0->1 cycle into a no-op; wait for the spin-down to actually land so the source +# is gone before the topic is deleted (otherwise it observes the deletion and +# reports "topic was deleted" instead of "topic was recreated"). +> SELECT count(*) FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'to_recreate' +0 + # Recreate the topic with fewer partitions. $ kafka-delete-topic-flaky topic=topic1 @@ -87,6 +94,13 @@ $ kafka-ingest format=bytes topic=topic2 # deletion before the new topic was created. > ALTER CLUSTER to_recreate SET (REPLICATION FACTOR 0) +# The controller drops the replica asynchronously and would otherwise coalesce a +# 0->1 cycle into a no-op; wait for the spin-down to actually land so the source +# is gone before the topic is deleted (otherwise it observes the deletion and +# reports "topic was deleted" instead of "topic was recreated"). +> SELECT count(*) FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'to_recreate' +0 + # Recreate the topic with the same number of partitions but a lower watermark. $ kafka-delete-topic-flaky topic=topic2 diff --git a/test/testdrive/catalog.td b/test/testdrive/catalog.td index 3ef0a71e31b03..2c5e063775357 100644 --- a/test/testdrive/catalog.td +++ b/test/testdrive/catalog.td @@ -721,6 +721,8 @@ pg_authid_core "" > SHOW MATERIALIZED VIEWS FROM mz_internal name cluster comment ---------------------------------------------------- +mz_cluster_auto_scaling_strategies mz_catalog_server "" +mz_cluster_reconfigurations mz_catalog_server "" mz_cluster_schedules mz_catalog_server "" mz_cluster_workload_classes mz_catalog_server "" mz_internal_cluster_replicas mz_catalog_server "" @@ -827,7 +829,7 @@ test_table "" # There is one entry in mz_indexes for each field_number/expression of the index. > SELECT COUNT(id) FROM mz_indexes WHERE id LIKE 's%' -268 +270 # Create a second schema with the same table name as above > CREATE SCHEMA tester2 diff --git a/test/testdrive/cluster-controller.td b/test/testdrive/cluster-controller.td new file mode 100644 index 0000000000000..cc2abd38d186f --- /dev/null +++ b/test/testdrive/cluster-controller.td @@ -0,0 +1,519 @@ +# Copyright Materialize, Inc. and contributors. All rights reserved. +# +# Use of this software is governed by the Business Source License +# included in the LICENSE file at the root of this repository. +# +# As of the Change Date specified in that file, in accordance with +# the Business Source License, use of this software will be governed +# by the Apache License, Version 2.0. + +# Boundary test for the cluster controller. With the master gate forced on and +# the tick interval driven down, the controller reconciles managed clusters many +# times within the test window. Convergence is asynchronous (a config-shape ALTER +# returns before the realized config settles), so every readback below is a +# retrying testdrive query (`>` re-runs until it matches or the SQL timeout +# elapses) — never a fixed-duration sleep. Where a transient in-flight state must +# be observed, the controller is frozen first so the state cannot move; where the +# assertion is a negative ("the controller does nothing"), a sibling +# reconfiguration is used as a liveness synchronizer, proving the reconcile loop +# ran many ticks without acting on the cluster under test. + +# Give convergence (provision + hydrate + cut-over) ample room on a loaded CI host +# without ever sleeping the full budget — `>` returns as soon as it matches. +$ set-sql-timeout duration=120s + +# Force the gate on and drive the tick interval down so the controller ticks +# ~hundreds of times across the waits below. Both are re-read each tick, so the +# flips take effect without a restart. The graceful cases use the WITH (WAIT ...) +# surface, whose planner acceptance is gated on enable_zero_downtime. +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_cluster_controller = true +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' +ALTER SYSTEM SET enable_zero_downtime_cluster_reconfiguration = true + +# ----- Baseline reconcile is a no-op (PR 2) ----- +# +# With only the implicit baseline strategy the desired replica set equals the +# realized one, so the controller never creates, drops, or renames a steady +# cluster's replicas no matter how often it ticks. + +> CREATE CLUSTER cc_steady (SIZE 'scale=1,workers=1', REPLICATION FACTOR 2) + +> SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster = 'cc_steady' +cc_steady r1 scale=1,workers=1 +cc_steady r2 scale=1,workers=1 + +# Liveness synchronizer: an RF increase on a scratch cluster forces the controller +# to act (bring a replica up), proving the reconcile loop is live and has run many +# ticks. The controller reconciles every cluster on the same tick, so once the +# scratch cluster reaches its new RF, cc_steady has had every chance to be churned. +> CREATE CLUSTER cc_tick (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) +> ALTER CLUSTER cc_tick SET (REPLICATION FACTOR 2) +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_tick' +2 +> DROP CLUSTER cc_tick + +# A controller that churned a steady replica — dropped and recreated it, even +# reusing the same name — would leave a dropped replica in the history. The +# baseline controller never does, so cc_steady has no dropped replica recorded. +# (Materialize forbids copying these system rows into a user table, so we assert +# no-drop directly.) This is not satisfied by gate-off legacy behavior, which +# never runs the reconcile loop at all. +> SELECT count(*) FROM mz_internal.mz_cluster_replica_history WHERE cluster_name = 'cc_steady' AND dropped_at IS NOT NULL +0 + +# A replication-factor change is a normal, immediate config update (PR 2 does not +# reshape ALTER); the controller then reconciles to the new steady set without +# churn, retiring the surplus replica. +> ALTER CLUSTER cc_steady SET (REPLICATION FACTOR 1) + +> SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster = 'cc_steady' +cc_steady r1 scale=1,workers=1 + +# The controller retired the surplus replica, so the drop is audited `retired` +# even though the replication-factor change was user-initiated. +> SELECT event_type, details->>'reason' FROM mz_catalog.mz_audit_events WHERE event_type = 'drop' AND object_type = 'cluster-replica' AND details->>'cluster_name' = 'cc_steady' +drop retired + +> DROP CLUSTER cc_steady + +# ----- Graceful background reconfiguration (PR 3) ----- +# +# With the master gate on and background ALTER enabled, a config-shape ALTER (SIZE +# change) writes a durable reconfiguration record and returns immediately; the +# controller creates the target replica, and once it hydrates (an empty cluster +# hydrates promptly) cuts the realized size over to the target and drops the old +# replica. + +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_background_alter_cluster = true + +> CREATE CLUSTER cc_graceful (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) + +# Background ALTER returns immediately; the readbacks retry until cut-over. +> ALTER CLUSTER cc_graceful SET (SIZE 'scale=1,workers=2') + +> SELECT size FROM mz_clusters WHERE name = 'cc_graceful' +scale=1,workers=2 + +# The cluster settled back to exactly REPLICATION FACTOR replicas at the new size, +# under a fresh name (r1 -> r2): a reshape never renames back. +> SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster = 'cc_graceful' +cc_graceful r2 scale=1,workers=2 + +# The record was cleared after cut-over, so a fresh config-shape ALTER writes a new +# record and reshapes again (r2 -> r3) rather than folding onto a stale one. (An +# identical no-op ALTER would early-return before the reshape branch.) +> ALTER CLUSTER cc_graceful SET (SIZE 'scale=1,workers=1') + +> SELECT size FROM mz_clusters WHERE name = 'cc_graceful' +scale=1,workers=1 + +> SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster = 'cc_graceful' +cc_graceful r3 scale=1,workers=1 + +# Replica lifecycle attribution, in order: the CREATE CLUSTER replica is `manual`, +# each reconfiguration's target replica is `reconfiguration`, and every controller +# drop (the old set retired at cut-over) is `retired`. testdrive sorts result rows +# (discarding ORDER BY), so we prepend a row_number() over the audit id — a +# deterministic ordinal that sorts the rows back into chronological order. +> SELECT row_number() OVER (ORDER BY id), event_type, details->>'reason' FROM mz_catalog.mz_audit_events WHERE object_type = 'cluster-replica' AND details->>'cluster_name' = 'cc_graceful' +1 create manual +2 create reconfiguration +3 drop retired +4 create reconfiguration +5 drop retired + +> DROP CLUSTER cc_graceful + +# A logging (INTROSPECTION) change is also a config-shape change: the controller +# reshapes it in the background and advances the realized config at cut-over. +# INTROSPECTION INTERVAL = 0 round-trips to NULL (Option::None for the interval). +> CREATE CLUSTER cc_logging (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1, INTROSPECTION INTERVAL = '5s') + +> SELECT introspection_interval::text FROM mz_clusters WHERE name = 'cc_logging' +00:00:05 + +> ALTER CLUSTER cc_logging SET (INTROSPECTION INTERVAL = 0) + +> SELECT introspection_interval IS NULL FROM mz_clusters WHERE name = 'cc_logging' +true + +> DROP CLUSTER cc_logging + +# ----- Per-ALTER timeout / ON TIMEOUT (PR 3) ----- +# +# The deadline and the on-timeout action come from the WITH (WAIT ...) surface and +# are written into the durable record, so the controller enforces them. These +# cases use a promptly-hydrating (empty) cluster, so success precedence cuts over +# before any deadline matters; they assert the three spellings are accepted under +# the gate and drive the record to a successful cut-over. ROLLBACK-vs-COMMIT +# behavior *at* a timeout (a target that never hydrates) is asserted +# deterministically in the controller's kernel unit tests. + +> CREATE CLUSTER cc_timeout (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) + +# Omitting WITH (WAIT ...): default deadline and default ON TIMEOUT (now ROLLBACK). +# The target hydrates, so it cuts over regardless. +> ALTER CLUSTER cc_timeout SET (SIZE 'scale=1,workers=2') +> SELECT size FROM mz_clusters WHERE name = 'cc_timeout' +scale=1,workers=2 + +# Explicit ON TIMEOUT ROLLBACK with a generous deadline: success precedence cuts over. +> ALTER CLUSTER cc_timeout SET (SIZE 'scale=1,workers=4') WITH (WAIT UNTIL READY (TIMEOUT '60s', ON TIMEOUT 'ROLLBACK')) +> SELECT size FROM mz_clusters WHERE name = 'cc_timeout' +scale=1,workers=4 + +# Explicit ON TIMEOUT COMMIT, and WAIT FOR (which desugars to ON TIMEOUT COMMIT): +# both accepted under the gate and drive a cut-over. +> ALTER CLUSTER cc_timeout SET (SIZE 'scale=1,workers=2') WITH (WAIT UNTIL READY (TIMEOUT '60s', ON TIMEOUT 'COMMIT')) +> SELECT size FROM mz_clusters WHERE name = 'cc_timeout' +scale=1,workers=2 + +> ALTER CLUSTER cc_timeout SET (SIZE 'scale=1,workers=1') WITH (WAIT FOR '60s') +> SELECT size FROM mz_clusters WHERE name = 'cc_timeout' +scale=1,workers=1 + +> DROP CLUSTER cc_timeout + +# ----- Observability: introspection relations + SHOW CLUSTERS (PR 4) ----- +# +# mz_internal.mz_cluster_reconfigurations is sparse: a row only while a graceful +# reconfiguration is in flight, carrying the in-flight delta (target shape as JSON, +# deadline, on_timeout). SHOW CLUSTERS folds that and the auto-scaling state into a +# single `activity` summary, NULL when steady. + +> CREATE CLUSTER cc_obs (SIZE 'scale=1,workers=1', REPLICATION FACTOR 2) + +# Steady state: nothing in flight, so the sparse relation has no row ... +> SELECT count(*) FROM mz_internal.mz_cluster_reconfigurations recon JOIN mz_clusters ON mz_clusters.id = recon.cluster_id WHERE mz_clusters.name = 'cc_obs' +0 + +# ... and SHOW CLUSTERS reports no activity. +> SELECT name, activity FROM (SHOW CLUSTERS) WHERE name = 'cc_obs' +cc_obs + +# A completed background reconfiguration advances the realized config and clears +# the in-flight record, so the cluster settles back to no activity. +> ALTER CLUSTER cc_obs SET (SIZE 'scale=1,workers=2') +> SELECT size FROM mz_clusters WHERE name = 'cc_obs' +scale=1,workers=2 +> SELECT name, activity FROM (SHOW CLUSTERS) WHERE name = 'cc_obs' +cc_obs + +# The audit log captured the lifecycle: `started` when the record was written, +# `finalized` at cut-over. Every transition records the active deadline. +> SELECT row_number() OVER (ORDER BY id), details->>'transition', details->>'deadline' IS NOT NULL FROM mz_catalog.mz_audit_events WHERE event_type = 'alter' AND object_type = 'cluster' AND details->>'cluster_name' = 'cc_obs' AND details->>'transition' IS NOT NULL +1 started true +2 finalized true + +> DROP CLUSTER cc_obs + +# An ALTER-back cancel: a reconfiguration is started, then re-targeted back to the +# cluster's still-realized size before it cuts over. The lifecycle records a +# `started`, then `cancelled` at the ALTER-back, then `finalized` as the now-trivial +# (target == realized) reconfiguration clears. The two ALTERs are issued back to +# back so the controller cannot cut the first over (a cut-over needs a target +# replica to boot and hydrate) before the re-target lands. +> CREATE CLUSTER cc_cancel (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_cancel' +1 + +> ALTER CLUSTER cc_cancel SET (SIZE 'scale=1,workers=2') +> ALTER CLUSTER cc_cancel SET (SIZE 'scale=1,workers=1') + +> SELECT size FROM mz_clusters WHERE name = 'cc_cancel' +scale=1,workers=1 +> SELECT name, activity FROM (SHOW CLUSTERS) WHERE name = 'cc_cancel' +cc_cancel +> SELECT row_number() OVER (ORDER BY id), details->>'transition' FROM mz_catalog.mz_audit_events WHERE event_type = 'alter' AND object_type = 'cluster' AND details->>'cluster_name' = 'cc_cancel' AND details->>'transition' IS NOT NULL +1 started +2 cancelled +3 finalized + +> DROP CLUSTER cc_cancel + +# ----- Rollback at the deadline: record cleared + timed-out event (PR 8b) ----- +# +# A reconfiguration whose deadline passes before the target hydrates under ON +# TIMEOUT ROLLBACK is abandoned: the controller drops the target set and clears the +# record without touching the realized config, and the audit log records a +# `timed-out` transition — the timeout's only papertrail. A TIMEOUT of '0s' puts +# the deadline in the past, so the rollback happens on the controller's first tick. + +> CREATE CLUSTER cc_rollback (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) + +> ALTER CLUSTER cc_rollback SET (SIZE 'scale=1,workers=2') WITH (WAIT UNTIL READY (TIMEOUT '0s', ON TIMEOUT 'ROLLBACK')) + +# The `timed-out` transition is the definitive rollback signal; poll for it, then +# read back the settled state. The deadline rides along on every transition. +> SELECT row_number() OVER (ORDER BY id), details->>'transition', details->>'deadline' IS NOT NULL FROM mz_catalog.mz_audit_events WHERE event_type = 'alter' AND object_type = 'cluster' AND details->>'cluster_name' = 'cc_rollback' AND details->>'transition' IS NOT NULL +1 started true +2 timed-out true + +# Rolled back: realized config untouched, nothing in flight, replica set unchanged. +> SELECT size FROM mz_clusters WHERE name = 'cc_rollback' +scale=1,workers=1 +> SELECT count(*) FROM mz_internal.mz_cluster_reconfigurations recon JOIN mz_clusters ON mz_clusters.id = recon.cluster_id WHERE mz_clusters.name = 'cc_rollback' +0 +> SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster = 'cc_rollback' +cc_rollback r1 scale=1,workers=1 + +# A forced cut-over: TIMEOUT '0s' with ON TIMEOUT COMMIT advances the realized +# config to the (necessarily un-hydrated) target on the first tick. The clear +# classifies `finalized` with the deadline carried, so a reader can tell it was a +# past-deadline (forced) cut-over. +> ALTER CLUSTER cc_rollback SET (SIZE 'scale=1,workers=2') WITH (WAIT UNTIL READY (TIMEOUT '0s', ON TIMEOUT 'COMMIT')) +> SELECT size FROM mz_clusters WHERE name = 'cc_rollback' +scale=1,workers=2 +> SELECT count(*) FROM mz_internal.mz_cluster_reconfigurations recon JOIN mz_clusters ON mz_clusters.id = recon.cluster_id WHERE mz_clusters.name = 'cc_rollback' +0 + +# An in-flight reconfiguration observed deterministically: freeze the controller by +# flipping the master gate off right after the record is written (both are re-read +# each tick), so the record cannot move. The flip lands within milliseconds, while +# a cut-over first needs a target replica to boot and report hydration. +> ALTER CLUSTER cc_rollback SET (SIZE 'scale=1,workers=4') WITH (WAIT UNTIL READY (TIMEOUT '60s', ON TIMEOUT 'ROLLBACK')) + +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_cluster_controller = false + +# The sparse relation has a row: the in-flight target (as JSON), the deadline, and +# the on_timeout action, while the realized size stays at the pre-ALTER shape. +> SELECT recon.on_timeout, recon.target->>'size', mz_clusters.size FROM mz_internal.mz_cluster_reconfigurations recon JOIN mz_clusters ON mz_clusters.id = recon.cluster_id WHERE mz_clusters.name = 'cc_rollback' +rollback scale=1,workers=4 scale=1,workers=2 + +# SHOW CLUSTERS folds that into the single `activity` column. (Compared as a +# boolean because the multi-word activity string cannot be matched as a bare value.) +> SELECT name, activity = 'reconfiguring to scale=1,workers=4' FROM (SHOW CLUSTERS) WHERE name = 'cc_rollback' +cc_rollback true + +# Unfreeze: the controller converges the in-flight record and settles. +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_cluster_controller = true + +> SELECT size FROM mz_clusters WHERE name = 'cc_rollback' +scale=1,workers=4 +> SELECT count(*) FROM mz_internal.mz_cluster_reconfigurations recon JOIN mz_clusters ON mz_clusters.id = recon.cluster_id WHERE mz_clusters.name = 'cc_rollback' +0 + +# The full lifecycle history, in order: the rolled-back attempt, the forced COMMIT +# cut-over, and the frozen-then-converged success. Every transition carries the deadline. +> SELECT row_number() OVER (ORDER BY id), details->>'transition', details->>'deadline' IS NOT NULL FROM mz_catalog.mz_audit_events WHERE event_type = 'alter' AND object_type = 'cluster' AND details->>'cluster_name' = 'cc_rollback' AND details->>'transition' IS NOT NULL +1 started true +2 timed-out true +3 started true +4 finalized true +5 started true +6 finalized true + +> DROP CLUSTER cc_rollback + +# ----- ON REFRESH scheduling driven by the controller (PR 5) ----- +# +# With the gate on, the on-refresh strategy — not the legacy scheduling tick — owns +# a scheduled cluster's replica set: it normalizes the realized replication factor +# to 0 and brings up a single replica while the cluster is inside a refresh window. + +# A scheduled cluster with no bound REFRESH MV is outside any refresh window, so it +# has no replica and its replication factor reads 0. The large HYDRATION TIME +# ESTIMATE makes the window deterministically open once a fast-refreshing MV is +# bound (the cluster must stay on to keep that far ahead of the next refresh). +> CREATE CLUSTER cc_sched (SIZE 'scale=1,workers=1', SCHEDULE = ON REFRESH (HYDRATION TIME ESTIMATE = '60 seconds')) + +> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'cc_sched' +0 +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_sched' +0 + +# Bind a REFRESH EVERY materialized view: the cluster is now inside a refresh window +# (it must rehydrate ahead of each refresh), so the controller brings up exactly one +# replica at the cluster size. The replication factor still reads 0 — it is the +# controller's domain for a scheduled cluster — and mz_cluster_replicas is +# authoritative for what is actually running. +> CREATE TABLE sched_t (x int) +> CREATE MATERIALIZED VIEW cc_sched_mv IN CLUSTER cc_sched WITH (REFRESH = EVERY '1 second') AS SELECT count(*) FROM sched_t + +> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'cc_sched' +0 +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_sched' +1 + +# The replica runs at the cluster size, and the MV computes a result on it. +> SELECT r.size FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_sched' +scale=1,workers=1 +> SELECT count FROM cc_sched_mv +0 + +> DROP MATERIALIZED VIEW cc_sched_mv + +# With the MV gone the refresh window closes and the controller retires the replica. +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_sched' +0 + +# The window-open create is audited `schedule` and carries the window decision as +# the `scheduling_policies` detail, like the legacy scheduler's creates did: the +# decision is `on`, the hydration-time estimate rides along, and the open window +# names the REFRESH MV behind it. +> SELECT event_type, details->>'reason', details->'scheduling_policies'->'on_refresh'->>'decision', details->'scheduling_policies'->'on_refresh'->>'hydration_time_estimate', jsonb_array_length(details->'scheduling_policies'->'on_refresh'->'objects_needing_refresh') > 0 FROM mz_catalog.mz_audit_events WHERE object_type = 'cluster-replica' AND details->>'cluster_name' = 'cc_sched' AND event_type = 'create' +create schedule on 00:01:00 true + +# The window-close drop is `retired` with no decision detail — a drop happens +# exactly when no strategy desires the replica, so there is no decision to record. +> SELECT event_type, details->>'reason', details->'scheduling_policies' IS NULL FROM mz_catalog.mz_audit_events WHERE object_type = 'cluster-replica' AND details->>'cluster_name' = 'cc_sched' AND event_type = 'drop' +drop retired true + +> DROP TABLE sched_t +> DROP CLUSTER cc_sched + +# A MANUAL cluster is untouched by the on-refresh strategy: its replica set is the +# user's replication factor, owned by the implicit baseline. +> CREATE CLUSTER cc_manual (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) +> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'cc_manual' +1 +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_manual' +1 +> DROP CLUSTER cc_manual + +# ----- Hydration burst: AUTO SCALING STRATEGY SQL surface (PR 6) ----- + +# SQL acceptance is gated by a feature flag (not a dyncfg) so stored CREATE CLUSTER +# statements re-parse at rehydration regardless of the dyncfgs. The break-glass +# burst strategy is disabled so the in-flight burst state here is deterministically +# empty regardless of arming semantics — this section exercises parse/render/ +# validation, not arming. +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_auto_scaling_strategy = true +ALTER SYSTEM SET enable_hydration_burst = false + +# A managed cluster can carry an ON HYDRATION burst policy. +> CREATE CLUSTER cc_burst (SIZE 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2', LINGER DURATION = '600s'))) + +# SHOW CREATE CLUSTER renders the policy back, and the rendered statement re-parses +# (the planner's create-roundtrip asserts unplan->parse->plan equality). +> SELECT create_sql LIKE '%AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = ''scale=2,workers=2''%' FROM (SHOW CREATE CLUSTER cc_burst) +true + +# The cluster serves a steady replica set at its own size (the baseline). +> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'cc_burst' +1 + +# mz_cluster_auto_scaling_strategies surfaces the configured policy (the strategy +# JSON carries the HYDRATION SIZE) and the in-flight state. With the burst strategy +# disabled no burst is ever armed, so `state` is NULL. +> SELECT mz_clusters.name, ass.strategy->'on_hydration'->>'hydration_size', ass.state IS NULL FROM mz_internal.mz_cluster_auto_scaling_strategies ass JOIN mz_clusters ON mz_clusters.id = ass.cluster_id WHERE mz_clusters.name = 'cc_burst' +cc_burst scale=2,workers=2 true + +# With nothing in flight, SHOW CLUSTERS reports no activity. +> SELECT name, activity FROM (SHOW CLUSTERS) WHERE name = 'cc_burst' +cc_burst + +# RESET disables autoscaling; SHOW CREATE no longer renders the block. +> ALTER CLUSTER cc_burst RESET (AUTO SCALING STRATEGY) +> SELECT create_sql LIKE '%AUTO SCALING STRATEGY%' FROM (SHOW CREATE CLUSTER cc_burst) +false + +# Setting it back via ALTER also works (omitting LINGER DURATION). +> ALTER CLUSTER cc_burst SET (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2'))) +> SELECT create_sql LIKE '%AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = ''scale=2,workers=2''))%' FROM (SHOW CREATE CLUSTER cc_burst) +true + +> DROP CLUSTER cc_burst + +# HYDRATION SIZE equal to the cluster SIZE is rejected (a burst at the same size +# would not accelerate hydration). +! CREATE CLUSTER cc_burst_bad (SIZE 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=1'))) +contains:HYDRATION SIZE must differ from the cluster SIZE + +# AUTO SCALING STRATEGY combined with a non-MANUAL SCHEDULE is rejected. +! CREATE CLUSTER cc_burst_sched (SIZE 'scale=1,workers=1', SCHEDULE = ON REFRESH, AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2'))) +contains:AUTO SCALING STRATEGY cannot be combined with a SCHEDULE other than MANUAL + +# The two invariants are also enforced when an ALTER changes the *other* side of +# the constraint on a cluster that already carries a strategy. +> CREATE CLUSTER cc_burst_alt (SIZE 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2'))) + +# Setting SIZE equal to the existing HYDRATION SIZE would make the burst a no-op. +! ALTER CLUSTER cc_burst_alt SET (SIZE = 'scale=2,workers=2') +contains:HYDRATION SIZE must differ from the cluster SIZE + +# Setting a non-MANUAL SCHEDULE on a cluster that already has a strategy is rejected. +! ALTER CLUSTER cc_burst_alt SET (SCHEDULE = ON REFRESH) +contains:AUTO SCALING STRATEGY cannot be combined with a SCHEDULE other than MANUAL + +> DROP CLUSTER cc_burst_alt + +# The invariants also fire when an ALTER *introduces* a strategy that conflicts with +# the cluster's current config. +> CREATE CLUSTER cc_burst_set (SIZE 'scale=1,workers=1') + +! ALTER CLUSTER cc_burst_set SET (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=1,workers=1'))) +contains:HYDRATION SIZE must differ from the cluster SIZE + +> DROP CLUSTER cc_burst_set + +> CREATE CLUSTER cc_burst_onref (SIZE 'scale=1,workers=1', SCHEDULE = ON REFRESH) + +! ALTER CLUSTER cc_burst_onref SET (AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2'))) +contains:AUTO SCALING STRATEGY cannot be combined with a SCHEDULE other than MANUAL + +> DROP CLUSTER cc_burst_onref + +# With SQL acceptance gated off, the option is rejected at plan time. +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_auto_scaling_strategy = false + +! CREATE CLUSTER cc_burst_gated (SIZE 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2'))) +contains:`AUTO SCALING STRATEGY` cluster option is not available + +# ----- Hydration burst: no burst on a cluster with nothing to hydrate (PR 8c) ----- +# +# Burst arming is existential: a burst is warranted iff there exists an object on +# the cluster that no steady replica has hydrated. A strategy-carrying cluster with +# zero objects therefore never bursts — in particular not at creation, before its +# steady replica has even registered. With the burst strategy enabled this is +# deterministic exactly because of the object gate. + +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET enable_auto_scaling_strategy = true +ALTER SYSTEM SET enable_hydration_burst = true + +> CREATE CLUSTER cc_burst_empty (SIZE 'scale=1,workers=1', AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = 'scale=2,workers=2', LINGER DURATION = '600s'))) + +# Liveness synchronizer: a reconfiguration elsewhere proves the controller ran many +# ticks with the burst strategy enabled — every tick was a chance to arm a burst on +# cc_burst_empty. It never does, because the cluster has no object to hydrate. (A +# burst that did arm would stick around for its 600s linger and fail the checks below.) +> CREATE CLUSTER cc_burst_tick (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1) +> ALTER CLUSTER cc_burst_tick SET (REPLICATION FACTOR 2) +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cc_burst_tick' +2 +> DROP CLUSTER cc_burst_tick + +# No burst is in flight: the auto-scaling state is empty ... +> SELECT mz_clusters.name, ass.state IS NULL FROM mz_internal.mz_cluster_auto_scaling_strategies ass JOIN mz_clusters ON mz_clusters.id = ass.cluster_id WHERE mz_clusters.name = 'cc_burst_empty' +cc_burst_empty true + +# ... SHOW CLUSTERS reports no activity ... +> SELECT name, activity FROM (SHOW CLUSTERS) WHERE name = 'cc_burst_empty' +cc_burst_empty + +# ... the replica set is exactly the steady baseline ... +> SELECT cluster, replica, size FROM (SHOW CLUSTER REPLICAS) WHERE cluster = 'cc_burst_empty' +cc_burst_empty r1 scale=1,workers=1 + +# ... and the audit log records neither a burst lifecycle event nor a +# burst-attributed replica. +> SELECT count(*) FROM mz_catalog.mz_audit_events WHERE (details->>'cluster_name' = 'cc_burst_empty' AND details->>'burst_size' IS NOT NULL) OR (object_type = 'cluster-replica' AND details->>'cluster_name' = 'cc_burst_empty' AND details->>'reason' = 'hydration-burst') +0 + +> DROP CLUSTER cc_burst_empty + +# Restore pristine server state (including the tick-interval override). +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM RESET enable_cluster_controller +ALTER SYSTEM RESET cluster_controller_tick_interval +ALTER SYSTEM RESET enable_zero_downtime_cluster_reconfiguration +ALTER SYSTEM RESET enable_background_alter_cluster +ALTER SYSTEM RESET enable_auto_scaling_strategy +ALTER SYSTEM RESET enable_hydration_burst diff --git a/test/testdrive/indexes.td b/test/testdrive/indexes.td index 07aa9746dbe31..92aa1c867582f 100644 --- a/test/testdrive/indexes.td +++ b/test/testdrive/indexes.td @@ -296,6 +296,8 @@ mz_arrangement_batcher_capacity_raw_s2_primary_idx mz_arrangement_batch mz_arrangement_batcher_records_raw_s2_primary_idx mz_arrangement_batcher_records_raw mz_catalog_server {operator_id,worker_id} "" mz_arrangement_batcher_size_raw_s2_primary_idx mz_arrangement_batcher_size_raw mz_catalog_server {operator_id,worker_id} "" mz_cluster_deployment_lineage_ind mz_cluster_deployment_lineage mz_catalog_server {cluster_id} "" +mz_cluster_reconfigurations_ind mz_cluster_reconfigurations mz_catalog_server {cluster_id} "" +mz_cluster_auto_scaling_strategies_ind mz_cluster_auto_scaling_strategies mz_catalog_server {cluster_id} "" mz_cluster_replica_frontiers_ind mz_cluster_replica_frontiers mz_catalog_server {object_id} "" mz_cluster_replica_history_ind mz_cluster_replica_history mz_catalog_server {dropped_at} "" mz_cluster_replica_name_history_ind mz_cluster_replica_name_history mz_catalog_server {id} "" diff --git a/test/testdrive/kafka-recreate-topic.td b/test/testdrive/kafka-recreate-topic.td index 13fba06e1aa34..6f6ff619f2e67 100644 --- a/test/testdrive/kafka-recreate-topic.td +++ b/test/testdrive/kafka-recreate-topic.td @@ -57,6 +57,13 @@ $ kafka-create-topic topic=topic1 partitions=4 # deletion before the new topic was created. > ALTER CLUSTER to_recreate SET (REPLICATION FACTOR 0) +# The controller drops the replica asynchronously and would otherwise coalesce a +# 0->1 cycle into a no-op; wait for the spin-down to actually land so the source +# is gone before the topic is deleted (otherwise it observes the deletion and +# reports "topic was deleted" instead of "topic was recreated"). +> SELECT count(*) FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'to_recreate' +0 + # Recreate the topic with fewer partitions. $ kafka-delete-topic-flaky topic=topic1 @@ -98,6 +105,13 @@ $ kafka-ingest format=bytes topic=topic2 # deletion before the new topic was created. > ALTER CLUSTER to_recreate SET (REPLICATION FACTOR 0) +# The controller drops the replica asynchronously and would otherwise coalesce a +# 0->1 cycle into a no-op; wait for the spin-down to actually land so the source +# is gone before the topic is deleted (otherwise it observes the deletion and +# reports "topic was deleted" instead of "topic was recreated"). +> SELECT count(*) FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'to_recreate' +0 + # Recreate the topic with the same number of partitions but a lower watermark. $ kafka-delete-topic-flaky topic=topic2 @@ -154,7 +168,12 @@ source1_tbl paused source2 stalled "kafka: source must be dropped and recreated due to failure: topic was recreated" source2_tbl stalled "kafka: source must be dropped and recreated due to failure: topic was recreated" +# Suspend the cluster so the stalled source2 transitions to paused. The +# controller drops the replica asynchronously and would otherwise coalesce this +# 0->1 cycle into a no-op (source2 would stay stalled); wait for the drop. > ALTER CLUSTER to_recreate SET (REPLICATION FACTOR 0) +> SELECT count(*) FROM mz_cluster_replicas cr JOIN mz_clusters c ON c.id = cr.cluster_id WHERE c.name = 'to_recreate' +0 > ALTER CLUSTER to_recreate SET (REPLICATION FACTOR 1) $ kafka-ingest format=bytes topic=good-topic repeat=1 diff --git a/test/testdrive/materialization-lag.td b/test/testdrive/materialization-lag.td index e3b376bab1a74..16e835c328b8e 100644 --- a/test/testdrive/materialization-lag.td +++ b/test/testdrive/materialization-lag.td @@ -23,6 +23,9 @@ $ postgres-connect name=mz_system url=postgres://mz_system:materialize@${testdri $ postgres-execute connection=mz_system ALTER SYSTEM SET max_clusters = 15 +# The controller reconciles a replica-set change asynchronously; drive the tick +# down so the replica-drop waits below converge quickly. +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' > CREATE CLUSTER source SIZE 'scale=1,workers=1' > CREATE CLUSTER compute SIZE 'scale=1,workers=1' @@ -150,6 +153,15 @@ snk > ALTER CLUSTER compute SET (REPLICATION FACTOR 0) +# The controller drops the replica asynchronously. Wait for it to be gone before +# creating the MVs: a still-running replica would compute mv_behind_empty straight +# to the (permanent) empty frontier, making its lag read 00:00:00 instead of NULL. +> SELECT count(*) + FROM mz_cluster_replicas r + JOIN mz_clusters c ON r.cluster_id = c.id + WHERE c.name = 'compute' +0 + > CREATE MATERIALIZED VIEW mv_empty IN CLUSTER source AS SELECT 1; diff --git a/test/testdrive/materialized-view-refresh-options.td b/test/testdrive/materialized-view-refresh-options.td index eb38ef75bd06e..5293f5927dba1 100644 --- a/test/testdrive/materialized-view-refresh-options.td +++ b/test/testdrive/materialized-view-refresh-options.td @@ -391,10 +391,18 @@ true # Automated cluster scheduling for REFRESH # ---------------------------------------- +# The controller owns a scheduled cluster's replica set (the legacy scheduler is +# inert while the gate is on): it holds the realized `replication_factor` at 0 and +# toggles a single replica in and out of the refresh window, so on/off is checked +# by the replica count in `mz_cluster_replicas` rather than `replication_factor`. +# Drive the controller tick down so those transitions settle quickly. +$ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}/materialize +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' + > CREATE CLUSTER scheduled_cluster (SIZE = 'scale=1,workers=1', SCHEDULE = ON REFRESH); # No MV yet, so the cluster should be turned off. -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'scheduled_cluster'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'scheduled_cluster'; 0 > CREATE MATERIALIZED VIEW mv11 @@ -403,7 +411,7 @@ true AS SELECT count(*) FROM t2; # The cluster should be turned on at some point. -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'scheduled_cluster'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'scheduled_cluster'; 1 # And then the cluster should compute MV results. @@ -414,36 +422,40 @@ true $ set-max-tries max-tries=5000 # The cluster should be turned off at some point. -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'scheduled_cluster'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'scheduled_cluster'; 0 -# We should have a "drop" in `mz_audit_events` +# We should have a "drop" in `mz_audit_events`; the controller retires the +# replica when the refresh window closes. > SELECT count(*) > 0 FROM mz_audit_events WHERE event_type = 'drop' AND object_type = 'cluster-replica' AND (details->'cluster_name')::text = '"scheduled_cluster"' AND + (details->'reason')::text = '"retired"' AND user IS NULL; true > DELETE FROM t2; # The cluster should be turned on at some point again. -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'scheduled_cluster'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'scheduled_cluster'; 1 # And then the cluster should compute MV results again. > SELECT * FROM mv11; 0 -# We should have a "create" in `mz_audit_events` +# We should have a "create" in `mz_audit_events`; a window-open create carries +# the schedule reason. > SELECT count(*) > 0 FROM mz_audit_events WHERE event_type = 'create' AND object_type = 'cluster-replica' AND (details->'cluster_name')::text = '"scheduled_cluster"' AND + (details->'reason')::text = '"schedule"' AND user IS NULL; true @@ -460,7 +472,7 @@ true ## that the Persist shard's write frontier moves from 0 to the first refresh time. > CREATE CLUSTER scheduled_cluster_2 (SIZE = 'scale=1,workers=1', SCHEDULE = ON REFRESH); -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'scheduled_cluster_2'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'scheduled_cluster_2'; 0 > CREATE MATERIALIZED VIEW mv12 @@ -476,7 +488,7 @@ true true # But then the cluster should turn off. -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'scheduled_cluster_2'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'scheduled_cluster_2'; 0 ## Unbilled replicas. @@ -539,9 +551,9 @@ DROP CLUSTER REPLICA scheduled_cluster.unbilled; AS SELECT count(*) FROM t2; # Should be turned on soon due to the HYDRATION TIME ESTIMATE. -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_6'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_6'; 1 -> SELECT replication_factor FROM mz_catalog.mz_clusters WHERE name = 'c_schedule_7'; +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'c_schedule_7'; 1 # ---------------------------------------- @@ -653,8 +665,13 @@ true # Make the next hydration take 1000000 ms. > INSERT INTO t6 VALUES (1000000); -# Restart the cluster to force a hydration. +# Restart the cluster to force a hydration. The controller tears the replica down +# and brings it back asynchronously, so wait for the teardown to actually land +# between the two ALTERs — otherwise the controller coalesces them against the +# final replication factor and the replica (and its hydration) never restarts. > ALTER CLUSTER cluster_to_be_bricked SET (REPLICATION FACTOR 0); +> SELECT count(*) FROM mz_cluster_replicas r JOIN mz_clusters c ON r.cluster_id = c.id WHERE c.name = 'cluster_to_be_bricked'; +0 > ALTER CLUSTER cluster_to_be_bricked SET (REPLICATION FACTOR 1); # Give the following hydration status query some time to wrongly turn to true if there is a bug. diff --git a/test/testdrive/materialized-view-replica-targeted.td b/test/testdrive/materialized-view-replica-targeted.td index 4cbf9813bc73b..8a3de466cdda9 100644 --- a/test/testdrive/materialized-view-replica-targeted.td +++ b/test/testdrive/materialized-view-replica-targeted.td @@ -17,9 +17,14 @@ $ set-sql-timeout duration=60s -# Enable the feature flag. +# Enable the feature flag. Also drive the cluster controller's tick down: with +# the controller on, a SIZE change reshapes in the background (create new +# replica, cut over, drop the old one), and the resize regression test below +# relies on the old replica — and the MV targeted at it — being torn down within +# testdrive's retry window. $ postgres-execute connection=postgres://mz_system:materialize@${testdrive.materialize-internal-sql-addr} ALTER SYSTEM SET enable_replica_targeted_materialized_views = true +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' > CREATE TABLE t (a int) > INSERT INTO t VALUES (1), (2), (3) diff --git a/test/testdrive/snapshot-source-statistics.td b/test/testdrive/snapshot-source-statistics.td index 9a9839bde8449..e589a13aa1da0 100644 --- a/test/testdrive/snapshot-source-statistics.td +++ b/test/testdrive/snapshot-source-statistics.td @@ -13,6 +13,9 @@ $ set-arg-default default-replica-size=scale=1,workers=1 $ postgres-execute connection=postgres://mz_system:materialize@${testdrive.materialize-internal-sql-addr} ALTER SYSTEM SET storage_statistics_collection_interval = 1000 ALTER SYSTEM SET storage_statistics_interval = 2000 +# The controller reconciles a replica-set change asynchronously; drive the tick +# down so the replica-drop wait below converges quickly. +ALTER SYSTEM SET cluster_controller_tick_interval = '5ms' $ set keyschema={ "type": "record", @@ -142,6 +145,17 @@ SELECT cr.id > ALTER CLUSTER stats_cluster SET (REPLICATION FACTOR 0) +# The controller reconciles RF asynchronously and would otherwise coalesce this +# 1->0->1 cycle into a no-op (no new replica generation). Wait for the drop to +# actually land so the RF=1 below creates a new replica distinct from old_replica_id +# (the "previous replica" generation the null-stat rows below depend on). The old +# replica's stats persist in mz_source_statistics after it is dropped. +> SELECT count(*) + FROM mz_clusters c + JOIN mz_cluster_replicas cr ON c.id = cr.cluster_id + WHERE c.name = 'stats_cluster' +0 + $ kafka-ingest format=avro topic=upsert key-format=avro key-schema=${keyschema} schema=${schema} {"key": "mammalmore"} {"f1":"moose", "f2": 100} diff --git a/test/testdrive/status-history.td b/test/testdrive/status-history.td index 4fd05fd55d19a..378cdc7280985 100644 --- a/test/testdrive/status-history.td +++ b/test/testdrive/status-history.td @@ -114,6 +114,11 @@ mysql_tbl paused > ALTER CLUSTER sources SET (REPLICATION FACTOR 1) +# The controller creates the replica asynchronously; set-from-sql does not retry, +# so wait for the replica to exist before capturing its id. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sources' +1 + $ set-from-sql var=replica_id_1 SELECT r.id FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sources' @@ -241,6 +246,11 @@ mysql_tbl paused > ALTER CLUSTER sources SET (REPLICATION FACTOR 1) +# The controller creates the replica asynchronously; set-from-sql does not retry, +# so wait for the replica to exist before capturing its id. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sources' +1 + $ set-from-sql var=replica_id_2 SELECT r.id FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sources' @@ -383,6 +393,11 @@ kafka2 paused > ALTER CLUSTER sinks SET (REPLICATION FACTOR 1) +# The controller creates the replica asynchronously; set-from-sql does not retry, +# so wait for the replica to exist before capturing its id. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sinks' +1 + $ set-from-sql var=replica_id_1 SELECT r.id FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sinks' @@ -432,6 +447,11 @@ kafka2 paused > ALTER CLUSTER sinks SET (REPLICATION FACTOR 1) +# The controller creates the replica asynchronously; set-from-sql does not retry, +# so wait for the replica to exist before capturing its id. +> SELECT count(*) FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sinks' +1 + $ set-from-sql var=replica_id_2 SELECT r.id FROM mz_clusters c JOIN mz_cluster_replicas r ON c.id = r.cluster_id WHERE c.name = 'sinks'