From 2e094610800ac6f3a500aca3aa98705e7cd9d99d Mon Sep 17 00:00:00 2001 From: Julian Sommer <115516918+juliansommer@users.noreply.github.com> Date: Tue, 4 Aug 2026 14:19:58 +1000 Subject: [PATCH] chore: cleanup code comments --- .github/actions/e2e-analyze/README.md | 2 +- .github/actions/e2e-analyze/analyze.go | 6 ++-- .github/actions/e2e-analyze/bundle.go | 6 ++-- .github/actions/e2e-analyze/main.go | 2 +- .github/actions/e2e-analyze/slice.go | 2 +- .github/workflows/e2e-ddil.yml | 5 ++-- .github/workflows/e2e-suites.yml | 6 ++-- .github/workflows/gpu-e2e.yml | 8 ++---- .github/workflows/segscan-oracle.yml | 4 +-- cmd/ecs-agent/taskrun_test.go | 6 ++-- cmd/rds-agent/engine.go | 4 +-- cmd/rds-agent/engine_test.go | 4 +-- cmd/rds-agent/storage.go | 2 +- cmd/spinifex/cmd/admin.go | 2 +- cmd/spinifex/cmd/admin_test.go | 6 ++-- cmd/spinifex/cmd/service.go | 4 +-- images/mkosi.conf | 2 +- scripts/README.md | 3 -- scripts/images/ecs-agent/manifest.conf | 2 +- scripts/images/ecs-agent/setup.sh | 2 +- scripts/images/eks-node/eks-node-role.sh | 2 +- scripts/reset-dev-env.sh | 4 +-- scripts/setup-ovn.sh | 6 ++-- scripts/setup.sh | 2 +- spinifex/daemon/daemon.go | 8 +++--- spinifex/daemon/daemon_handlers_eni.go | 2 +- .../daemon/daemon_handlers_instance_test.go | 4 +-- spinifex/daemon/daemon_handlers_volume.go | 2 +- spinifex/daemon/daemon_mgmt_ip.go | 6 ++-- spinifex/daemon/daemon_mgmt_ip_test.go | 2 +- spinifex/daemon/daemon_system_instance.go | 2 +- .../daemon/daemon_system_instance_test.go | 2 +- spinifex/daemon/daemon_test.go | 4 +-- spinifex/daemon/daemon_wire_lb_test.go | 4 +-- spinifex/daemon/eks_worker_launch_test.go | 2 +- spinifex/daemon/gpu_pool_reconciler_test.go | 2 +- spinifex/daemon/jetstream.go | 2 +- spinifex/daemon/jetstream_test.go | 2 +- spinifex/daemon/perf_bench_test.go | 12 ++++---- spinifex/daemon/resource_test.go | 4 +-- spinifex/daemon/vm_adapters_trace_test.go | 2 +- spinifex/gateway/bedrockruntime.go | 2 +- .../ec2/instance/DescribeInstances_test.go | 6 ++-- .../RunInstancesIntoReservation_test.go | 2 +- spinifex/gateway/ecr/authorization_test.go | 2 +- spinifex/gateway/ecr/registry_image.go | 2 +- spinifex/gateway/ecs.go | 2 +- spinifex/gateway/gateway.go | 4 +-- .../handlers/ec2/image/service_impl_test.go | 2 +- .../ec2/instance/service_impl_test.go | 2 +- .../handlers/ec2/volume/service_impl_test.go | 2 +- spinifex/handlers/ec2/vpc/eni_test.go | 4 +-- .../handlers/ec2/vpc/security_group_test.go | 6 ++-- spinifex/handlers/ecs/bus/subjects.go | 2 +- spinifex/handlers/ecs/conv_test.go | 2 +- .../handlers/ecs/taskdef_validation_test.go | 10 +++---- spinifex/handlers/eks/create_cluster_test.go | 8 +++--- spinifex/handlers/eks/delete_cluster_test.go | 4 +-- .../handlers/eks/eks_deleting_reaper_test.go | 2 +- spinifex/handlers/imds/trace_test.go | 2 +- spinifex/handlers/quota/bedrock.go | 6 ++-- spinifex/handlers/quota/quota.go | 4 +-- spinifex/handlers/rds/arn.go | 2 +- spinifex/handlers/rds/arn_parse_test.go | 2 +- spinifex/handlers/rds/backup.go | 26 ++++++++--------- spinifex/handlers/rds/backup_sweep.go | 8 +++--- spinifex/handlers/rds/backup_sweep_test.go | 4 +-- spinifex/handlers/rds/backup_test.go | 12 ++++---- spinifex/handlers/rds/commands.go | 16 +++++------ spinifex/handlers/rds/commands_test.go | 4 +-- spinifex/handlers/rds/create.go | 8 +++--- spinifex/handlers/rds/create_test.go | 6 ++-- spinifex/handlers/rds/delete.go | 8 +++--- spinifex/handlers/rds/delete_test.go | 4 +-- spinifex/handlers/rds/describe.go | 2 +- spinifex/handlers/rds/describe_test.go | 2 +- spinifex/handlers/rds/dns.go | 2 +- spinifex/handlers/rds/engine.go | 4 +-- spinifex/handlers/rds/engine_test.go | 2 +- spinifex/handlers/rds/launch.go | 2 +- spinifex/handlers/rds/lifecycle.go | 8 +++--- spinifex/handlers/rds/lifecycle_test.go | 6 ++-- spinifex/handlers/rds/modify.go | 12 ++++---- spinifex/handlers/rds/modify_test.go | 16 +++++------ spinifex/handlers/rds/paramcatalog.go | 6 ++-- spinifex/handlers/rds/paramcatalog_test.go | 4 +-- spinifex/handlers/rds/parametergroup.go | 6 ++-- spinifex/handlers/rds/parametergroup_test.go | 2 +- spinifex/handlers/rds/pending.go | 6 ++-- spinifex/handlers/rds/pending_test.go | 10 +++---- spinifex/handlers/rds/reconciler.go | 4 +-- spinifex/handlers/rds/records.go | 28 +++++++++---------- spinifex/handlers/rds/recovery.go | 6 ++-- spinifex/handlers/rds/replace.go | 12 ++++---- spinifex/handlers/rds/replace_test.go | 4 +-- spinifex/handlers/rds/restore.go | 8 +++--- spinifex/handlers/rds/restore_test.go | 4 +-- spinifex/handlers/rds/service.go | 4 +-- spinifex/handlers/rds/snapshot.go | 20 ++++++------- spinifex/handlers/rds/snapshot_test.go | 4 +-- spinifex/handlers/rds/status.go | 2 +- spinifex/handlers/rds/storage.go | 2 +- spinifex/handlers/rds/storage_test.go | 2 +- spinifex/handlers/rds/userdata_test.go | 2 +- spinifex/handlers/rds/validate.go | 6 ++-- spinifex/handlers/sts/assume_role_test.go | 2 +- spinifex/handlers/sts/oidc_jwks_test.go | 2 +- spinifex/network/external/dhcp/kv.go | 2 +- spinifex/network/external/dhcp/manager.go | 2 +- .../network/external/dhcp/pool_allocator.go | 2 +- spinifex/network/external/static_pool_test.go | 2 +- spinifex/services/awsgw/awsgw.go | 2 +- .../services/qmpcollector/qmpcollector.go | 2 +- .../elbv2/attributes-editor.test.tsx | 2 +- .../-components/target-group-detail-page.tsx | 2 +- spinifex/systemd/units_invariants_test.go | 6 ++-- spinifex/types/telemetry.go | 2 +- spinifex/vm/crash_recovery_test.go | 4 +-- spinifex/vm/lifecycle_test.go | 6 ++-- spinifex/vm/manager_test.go | 2 +- spinifex/vm/orphan_qemu_reaper_test.go | 2 +- spinifex/vm/shutdown_test.go | 2 +- spinifex/vm/volumes.go | 7 ++--- spinifex/vm/volumes_test.go | 6 ++-- spinifex/vpcd/vpcd_test.go | 8 +++--- tests/e2e/Makefile | 6 ++-- tests/e2e/cert/tlsposture_test.go | 2 +- tests/e2e/ddil/README.md | 5 +--- tests/e2e/ecr/capacity_test.go | 8 ++---- tests/e2e/ecs/ecs_test.go | 6 ++-- tests/e2e/harness/diag.go | 6 ++-- tests/e2e/harness/rds.go | 2 +- tests/e2e/harness/rds_client.go | 4 +-- .../harness/testdata/cloud-init-witness.yaml | 2 +- tests/e2e/manifest-check/manifest.go | 8 ++---- .../manifest-lint/cmd/manifest-lint/main.go | 2 +- tests/e2e/rds/api_matrix_test.go | 14 +++++----- tests/e2e/rds/authz_test.go | 2 +- tests/e2e/rds/automated_backup_test.go | 2 +- tests/e2e/rds/connect_test.go | 8 +++--- tests/e2e/rds/delete_test.go | 6 ++-- tests/e2e/rds/failure_test.go | 2 +- tests/e2e/rds/groups_test.go | 2 +- tests/e2e/rds/lifecycle_test.go | 10 +++---- tests/e2e/rds/main_test.go | 2 +- tests/e2e/rds/modify_test.go | 22 +++++++-------- tests/e2e/rds/snapshot_restore_test.go | 14 +++++----- tests/e2e/run-bm-multinode-e2e.sh | 2 +- tests/e2e/single/createimage_test.go | 8 +++--- tests/e2e/storagegrowth/image_pull_test.go | 6 ++-- tests/integration/daemon_lite.go | 4 +-- tests/integration/tags_test.go | 4 +-- 152 files changed, 367 insertions(+), 385 deletions(-) diff --git a/.github/actions/e2e-analyze/README.md b/.github/actions/e2e-analyze/README.md index 5afa9ec76..10937301c 100644 --- a/.github/actions/e2e-analyze/README.md +++ b/.github/actions/e2e-analyze/README.md @@ -70,7 +70,7 @@ When the report format changes intentionally, regenerate the snapshots: go test ./.github/actions/e2e-analyze/ -update ``` -## Per-failure bundles (Stage 2) +## Per-failure bundles After parsing, the action materialises a bundle directory per failure under `/analysis/NN-/`. The report links to it from diff --git a/.github/actions/e2e-analyze/analyze.go b/.github/actions/e2e-analyze/analyze.go index 05bf14379..73ab4d76a 100644 --- a/.github/actions/e2e-analyze/analyze.go +++ b/.github/actions/e2e-analyze/analyze.go @@ -1,6 +1,6 @@ // Package main implements the e2e-analyze GitHub Action. // -// Stage 1: cluster failures from go-junit-report's junit-*.xml by error signature, +// Cluster failures from go-junit-report's junit-*.xml by error signature, // pick the earliest non-cascade failure per suite as the likely root cause, // and render a human-readable report. // @@ -80,7 +80,7 @@ type Failure struct { // slicing a plausible-looking window around the wrong minute. SuiteSpan time.Duration // BundlePath is the relative path (from log-dir) to the per-failure - // bundle written by Stage 2's WriteBundles. Empty when bundles were + // bundle written by WriteBundles. Empty when bundles were // not generated (e.g. unit tests that call Render directly). BundlePath string } @@ -552,7 +552,7 @@ func ParseFile(path string, data []byte) (SuiteReport, error) { return rep, nil } -// Render writes the markdown report (Stage 1). +// Render writes the markdown report. func Render(r Report) string { var b strings.Builder fmt.Fprintf(&b, "## %s\n\n", r.Title) diff --git a/.github/actions/e2e-analyze/bundle.go b/.github/actions/e2e-analyze/bundle.go index 334821ab0..db75e766a 100644 --- a/.github/actions/e2e-analyze/bundle.go +++ b/.github/actions/e2e-analyze/bundle.go @@ -17,9 +17,9 @@ import ( ) // bundlePad is the per-failure window padding either side of the -// [StartAt, StartAt+Duration] testcase span. Five seconds matches the -// plan doc: long enough to catch the daemon's pre-test setup and -// post-test cleanup chatter, short enough to keep the slice focused. +// [StartAt, StartAt+Duration] testcase span. Five seconds catches the +// daemon's pre-test setup and post-test cleanup chatter while keeping +// the slice focused. const bundlePad = 5 * time.Second // nameSanitiseRe replaces characters unsafe in directory names with `_`. diff --git a/.github/actions/e2e-analyze/main.go b/.github/actions/e2e-analyze/main.go index f1e449604..480961b27 100644 --- a/.github/actions/e2e-analyze/main.go +++ b/.github/actions/e2e-analyze/main.go @@ -45,7 +45,7 @@ func main() { report.Suites = append(report.Suites, sr) } - // Stage 2: prefer authoritative per-suite start times written by the + // Prefer authoritative per-suite start times written by the // workflow over junit-report's conversion-time `timestamp` attribute, // then materialise per-failure bundles so Render can link them. if logDir != "" { diff --git a/.github/actions/e2e-analyze/slice.go b/.github/actions/e2e-analyze/slice.go index 99c3193b0..34793786d 100644 --- a/.github/actions/e2e-analyze/slice.go +++ b/.github/actions/e2e-analyze/slice.go @@ -1,6 +1,6 @@ package main -// Stage 2: per-failure log slicers used by bundle.go to materialise time-window / +// Per-failure log slicers used by bundle.go to materialise time-window / // testcase-window log excerpts next to each named failure. import ( diff --git a/.github/workflows/e2e-ddil.yml b/.github/workflows/e2e-ddil.yml index d5f079c1b..19a958135 100644 --- a/.github/workflows/e2e-ddil.yml +++ b/.github/workflows/e2e-ddil.yml @@ -1,8 +1,7 @@ name: E2E DDIL -# Phase 1 trigger: workflow_dispatch only. Nightly cron + on-main-merge -# land in mulga-siv-5.8 once ≥4 scenarios are asserting. See -# docs/development/improvements/ddil-e2e-test-harness.md §4 / §Dependencies. +# This workflow is manually triggered while the DDIL scenarios are being +# validated. on: workflow_dispatch: inputs: diff --git a/.github/workflows/e2e-suites.yml b/.github/workflows/e2e-suites.yml index 12fd0bced..68d3ed3a8 100644 --- a/.github/workflows/e2e-suites.yml +++ b/.github/workflows/e2e-suites.yml @@ -1,7 +1,5 @@ -# E2E (per-suite blocks) — EXPERIMENTAL, workflow_dispatch only. -# -# Restructures the looped e2e.yml into env-grouped job blocks so each suite -# surfaces as its own node in the Actions graph (mulga-siv-283): +# E2E per-suite blocks. Each suite appears as its own node in the Actions +# graph: # # single_provision ─┬─ single_suite (matrix: the single-node-eligible suites) # └─ single_teardown (if: always) diff --git a/.github/workflows/gpu-e2e.yml b/.github/workflows/gpu-e2e.yml index 91e5688bd..bb6e109c9 100644 --- a/.github/workflows/gpu-e2e.yml +++ b/.github/workflows/gpu-e2e.yml @@ -1,6 +1,6 @@ # GPU E2E — drives wattle's persistent, shared-host Spinifex stack over SSH to # exercise GPU passthrough (raw EC2, ECS task GPU exposure, EKS pod GPU -# exposure). See docs/development/feature/wattle-deploy-and-ci.md (Part B). +# exposure). # # --------------------------------------------------------------------------- # ONE-TIME HOST-SIDE SETUP — NOT part of this repo, a human must do this: @@ -32,7 +32,6 @@ # to skip cleanly (job succeeds, all work steps skipped) instead of # queuing behind manual work indefinitely. # -# Runbook: docs/development/feature/wattle-deploy-and-ci.md (Part B). # --------------------------------------------------------------------------- name: GPU E2E @@ -236,9 +235,8 @@ jobs: # (SPINIFEX_E2E=1 SPINIFEX_MODE=single, ./.test -test.v # -test.timeout=NNm), plus SPINIFEX_WAN_IP: wattle's ~24 bridges make # net.InterfaceAddrs() enumeration pick a co-tenant bridge instead of - # the advertised gateway (mulga-7suds), so the override is required - # here (proper fix tracked separately: tests/e2e/harness/env.go should - # prefer spinifex.toml's advertised bridge). + # the advertised gateway, so the override is required here. The harness + # should prefer spinifex.toml's advertised bridge. - name: Run GPU e2e suite on wattle id: e2e if: steps.gate.outputs.paused != 'true' diff --git a/.github/workflows/segscan-oracle.yml b/.github/workflows/segscan-oracle.yml index 7a95a14a5..b4d625aba 100644 --- a/.github/workflows/segscan-oracle.yml +++ b/.github/workflows/segscan-oracle.yml @@ -8,8 +8,8 @@ # every PR; adding a second-repo checkout there would make every spinifex PR # depend on mulga main being healthy and pay that checkout cost on every run, # for one storage-accounting oracle test. Mirrors e2e.yml's push-only trigger -# (mulga-siv-283 precedent): this never gates a PR before merge, matching how -# e2e.yml's own "front gate" job already works. +# This never gates a PR before merge, matching how e2e.yml's own +# "front gate" job works. name: Segscan Storage Oracle on: diff --git a/cmd/ecs-agent/taskrun_test.go b/cmd/ecs-agent/taskrun_test.go index d51e8f50f..2cf192a55 100644 --- a/cmd/ecs-agent/taskrun_test.go +++ b/cmd/ecs-agent/taskrun_test.go @@ -70,8 +70,8 @@ func TestRunTask_PullRunReportsRunning(t *testing.T) { } } -// TestRunTask_GPUCarriedToRunSpec covers mulga-11opz (Epic C task C1): the -// AssignContainer's GPU count reaches the runtime RunSpec unchanged; a +// TestRunTask_GPUCarriedToRunSpec verifies that the AssignContainer's GPU count +// reaches the runtime RunSpec unchanged; a // container with no GPU request keeps RunSpec.GPU at zero (regression). func TestRunTask_GPUCarriedToRunSpec(t *testing.T) { cp := &fakeCP{} @@ -534,7 +534,7 @@ func (sentinelResolver) Authorize(context.Context, string) (string, string, stri return "", "", "", nil } -// TestPullResolver covers siv-459: an assign with no execution role (or no +// TestPullResolver verifies that an assign with no execution role (or no // credential endpoint) uses the instance resolver; with both, a distinct // exec-role resolver is built. func TestPullResolver(t *testing.T) { diff --git a/cmd/rds-agent/engine.go b/cmd/rds-agent/engine.go index d136ec984..6addc0484 100644 --- a/cmd/rds-agent/engine.go +++ b/cmd/rds-agent/engine.go @@ -24,7 +24,7 @@ import ( // stays engine-agnostic. type engineOps interface { // Rotates the master role's password live. Never persisted anywhere in the - // guest: it exists only for the length of this call (D8). + // guest: it exists only for the length of this call. SetPassword(ctx context.Context, username, password string) error // Installs the resolved parameter set and reloads. Returns the settings the // engine accepted but will not honour until it restarts. @@ -180,7 +180,7 @@ ALTER ROLE :"master" WITH LOGIN PASSWORD :'password'; // The include the resolved parameter set is rendered to, and the copy of the // last one the engine accepted. Both live beside the data rather than in /etc, // matching rds-init: a class change boots a fresh root volume, which would -// otherwise revert them (D9). +// otherwise revert them when a fresh root volume is used. const ( parametersFileName = "10-rds-parameters.conf" // Deliberately not a .conf name: include_dir globs *.conf, so the rollback diff --git a/cmd/rds-agent/engine_test.go b/cmd/rds-agent/engine_test.go index d209cb694..370dc3abc 100644 --- a/cmd/rds-agent/engine_test.go +++ b/cmd/rds-agent/engine_test.go @@ -156,7 +156,7 @@ func newTestEngine(t *testing.T, run commandRunner) *postgresEngine { return newPostgresEngine(cfg, run, nil) } -// D8: the password reaches psql through the environment and is re-quoted there, +// The password reaches psql through the environment and is re-quoted there, // so it is never a shell word or an argv another process can read. func TestPostgresEngine_SetPasswordKeepsTheSecretOutOfArgv(t *testing.T) { runner := &recordingRunner{} @@ -215,7 +215,7 @@ func TestPostgresEngine_SetPasswordRejectsAnIncompleteCommand(t *testing.T) { } } -// D21: the apply runs as the cluster superuser under peer auth, so a reserved +// The apply runs as the cluster superuser under peer auth, so a reserved // name arriving in a command payload would rotate the bootstrap superuser's // password rather than the customer's own role. func TestPostgresEngine_SetPasswordRefusesReservedRoles(t *testing.T) { diff --git a/cmd/rds-agent/storage.go b/cmd/rds-agent/storage.go index d1c8956c4..6689ad0b3 100644 --- a/cmd/rds-agent/storage.go +++ b/cmd/rds-agent/storage.go @@ -10,7 +10,7 @@ import ( "strings" ) -// The in-guest half of a storage grow (D12). The control plane has already +// The in-guest half of a storage grow. The control plane has already // grown the block device by the time this runs; all that is left is to put the // filesystem on the capacity that is now there. Both ext4 and XFS grow while // mounted, so this needs no ordering against the engine start. diff --git a/cmd/spinifex/cmd/admin.go b/cmd/spinifex/cmd/admin.go index 5f853152d..33803d13f 100644 --- a/cmd/spinifex/cmd/admin.go +++ b/cmd/spinifex/cmd/admin.go @@ -2529,7 +2529,7 @@ func buildRemoteNodes(allNodes map[string]formation.NodeInfo, localNode, northst continue } // Prefer the peer's advertise IP (off-host dial target); fall back - // to BindIP for pre-siv-8 joiners that didn't send AdvertiseIP. + // to BindIP for joiners that did not send AdvertiseIP. host := n.AdvertiseIP if host == "" { host = n.BindIP diff --git a/cmd/spinifex/cmd/admin_test.go b/cmd/spinifex/cmd/admin_test.go index fc3fd9e59..1a6ef792f 100644 --- a/cmd/spinifex/cmd/admin_test.go +++ b/cmd/spinifex/cmd/admin_test.go @@ -47,7 +47,7 @@ func TestPrintChecksumError(t *testing.T) { } // buildRemoteNodes must prefer AdvertiseIP (off-host dial target) and fall -// back to BindIP when the peer pre-dates siv-8 and didn't send AdvertiseIP. +// back to BindIP when the peer did not send AdvertiseIP. func TestBuildRemoteNodes_AdvertiseFallback(t *testing.T) { nodes := map[string]formation.NodeInfo{ "node1": {Name: "node1", BindIP: "10.0.0.1", AdvertiseIP: "203.0.113.1"}, @@ -190,7 +190,7 @@ func TestSpinifexTomlTemplate_GatewayListensOnAllPlanes(t *testing.T) { assert.Contains(t, content, `host = "10.0.0.3:4432"`, "daemon stays internal") } -// Empty AdvertiseIP (e.g. loading an existing cluster pre-siv-8) must NOT +// Empty AdvertiseIP (for example when loading an existing cluster) must NOT // render an empty advertise = "" line — downstream fallback to Host kicks in. func TestSpinifexTomlTemplate_AdvertiseOmittedWhenEmpty(t *testing.T) { dir := t.TempDir() @@ -253,7 +253,7 @@ func TestSpinifexTomlTemplate_NorthstarDomains(t *testing.T) { } // Legacy `wan_bridge` TOML key must fail-start vpcd with guidance, not silently -// alias (per mulga-998 D3). Prevents the footgun where operators inherited the +// alias. Prevents the footgun where operators inherited the // old key pointing at 'br-ext' and got broken DHCP on veth-mode hosts. func TestCheckLegacyWanBridgeKey_TOMLRejected(t *testing.T) { dir := t.TempDir() diff --git a/cmd/spinifex/cmd/service.go b/cmd/spinifex/cmd/service.go index a053cf9c9..d256d577b 100644 --- a/cmd/spinifex/cmd/service.go +++ b/cmd/spinifex/cmd/service.go @@ -784,8 +784,8 @@ var spinifexUIStatusCmd = &cobra.Command{ } // checkLegacyWanBridgeKey fails vpcd startup if the deprecated `wan_bridge` -// TOML key or `SPINIFEX_VPCD_WAN_BRIDGE` env-var is present. Per D3: no silent -// alias, no auto-rewrite — operator must remove the key before vpcd will start. +// TOML key or `SPINIFEX_VPCD_WAN_BRIDGE` env-var is present. There is no silent +// alias or auto-rewrite; the operator must remove the key before vpcd will start. func checkLegacyWanBridgeKey(node, cfgFile string) error { legacyInTOML := viper.IsSet("nodes." + node + ".vpcd.wan_bridge") legacyInEnv := os.Getenv("SPINIFEX_VPCD_WAN_BRIDGE") != "" diff --git a/images/mkosi.conf b/images/mkosi.conf index eaae34b56..674f1a721 100644 --- a/images/mkosi.conf +++ b/images/mkosi.conf @@ -20,7 +20,7 @@ Seed=deadbeef-dead-beef-dead-beefdeadbeef RepartOffline=yes [Content] -# Every image built from this base is a bootable UEFI disk (D11). mkosi +# Every image built from this base is a bootable UEFI disk. mkosi # installs the kernel below and owns the bootloader/ESP itself, so boot-time # tweaks are expressed as mkosi settings rather than sed patches against # extlinux/GRUB. Bootloader= defaults to systemd-boot, the native fit for diff --git a/scripts/README.md b/scripts/README.md index 16ca9170e..af4d0df8b 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -3,9 +3,6 @@ Node installation, dev-environment lifecycle, guest image builds, and verification tooling for Spinifex. -Repo-level tooling (releases, CI infrastructure, ISO builds, beads) lives in -[`mulga/scripts/`](../../scripts/README.md). - ## Install and node setup | Script | What it does | diff --git a/scripts/images/ecs-agent/manifest.conf b/scripts/images/ecs-agent/manifest.conf index 1ba7d922a..07a4bb191 100644 --- a/scripts/images/ecs-agent/manifest.conf +++ b/scripts/images/ecs-agent/manifest.conf @@ -10,7 +10,7 @@ IMAGE_SIZE="4G" # containerd-openrc ships the OpenRC service for containerd (the containerd apk # itself has no init script). cni-plugins + the baked bridge conflist ready the -# image for Sprint 4d task networking. curl is used by the first-boot CA hook and +# image for task networking. curl is used by the first-boot CA hook and # IMDS probes. iproute2 supplies the full `ip` (busybox lacks `ip netns`) the # agent uses to build awsvpc task netns; udhcpc is busybox built-in. iptables is # the credential endpoint's DNAT rule (cmd/ecs-agent/credendpoint.go) fronting diff --git a/scripts/images/ecs-agent/setup.sh b/scripts/images/ecs-agent/setup.sh index 307d667ac..2a2f0833b 100644 --- a/scripts/images/ecs-agent/setup.sh +++ b/scripts/images/ecs-agent/setup.sh @@ -14,7 +14,7 @@ chmod 0755 /etc/init.d/ecs-agent /etc/init.d/ecs-ca-install # cni-plugins (alpine) installs to /usr/libexec/cni; containerd's CRI plugin # defaults its bin dir to /opt/cni/bin. Symlink so the baked bridge conflist -# resolves its plugins when Sprint 4d wires task networking. +# resolves its plugins when task networking is configured. mkdir -p /opt/cni ln -sf /usr/libexec/cni /opt/cni/bin diff --git a/scripts/images/eks-node/eks-node-role.sh b/scripts/images/eks-node/eks-node-role.sh index e077dfe87..1c3cc1b17 100755 --- a/scripts/images/eks-node/eks-node-role.sh +++ b/scripts/images/eks-node/eks-node-role.sh @@ -138,7 +138,7 @@ case "${ROLE}" in # Managed-addon delivery runs only on the primary server: it renders # staged addon bundles into the K3s auto-deploy dir, which a single # writer owns. HA multi-server addon delivery is tracked separately - # (mulga-siv-231.7); server-join nodes do not run it. + # Server-join nodes do not run this setup. svc_enable mulga-eks-addon-sync svc_start eks-token-webhook svc_start mulga-eks-k3s-recovery diff --git a/scripts/reset-dev-env.sh b/scripts/reset-dev-env.sh index 07f2a4452..f4a969d3e 100755 --- a/scripts/reset-dev-env.sh +++ b/scripts/reset-dev-env.sh @@ -398,8 +398,8 @@ if ip link show veth-wan-br >/dev/null 2>&1; then sudo ip link del veth-wan-br 2>/dev/null || true fi -# Remove veth persistence units (Fix 1, mulga-998.b). Without this, systemd-networkd -# recreates the veth on next reboot even after a full dev reset. +# Remove veth persistence units. Without this, systemd-networkd recreates the +# veth on next reboot even after a full dev reset. if [ -e /etc/systemd/network/15-spinifex-veth-wan.netdev ] || \ [ -e /etc/systemd/network/15-spinifex-veth-wan.network ] || \ [ -e /etc/systemd/network/16-spinifex-veth-wan-ovs.network ]; then diff --git a/scripts/setup-ovn.sh b/scripts/setup-ovn.sh index de6700573..f51b2c5fd 100755 --- a/scripts/setup-ovn.sh +++ b/scripts/setup-ovn.sh @@ -544,7 +544,7 @@ if [ -n "$WAN_BRIDGE" ]; then # when switching to any non-veth mode. Idempotent — each command uses # --if-exists / 2>/dev/null to tolerate absence. Without this, the # veth pair re-materialises on reboot and fights the current mode's - # bridge plumbing (Fix 1, mulga-998.b, per D17). + # Bridge plumbing for the host-to-OVN datapath. if [ "$WAN_BRIDGE_MODE" != "veth" ]; then sudo rm -f /etc/systemd/network/14-spinifex-br-wan.netdev \ /etc/systemd/network/15-spinifex-veth-wan.netdev \ @@ -621,7 +621,7 @@ if [ -n "$WAN_BRIDGE" ]; then # Persist the veth pair across reboot via systemd-networkd. Veths # are kernel-only and vanish on reboot; without persistence vpcd # starts with the OVS port pointing at a nonexistent peer and - # silently falls back to direct mode (Fix 1, mulga-998.b). + # silently falls back to direct mode. # # networkd's Bridge= directive requires the target bridge to be a # known NetDev. On ISO-installed nodes the installer writes @@ -673,7 +673,7 @@ NETWORK # (enslaved via ovs-vsctl add-port above) but does not flip admin # state on external ports — that's networkd's job. Without this, # veth-wan-ovs stays DOWN after reboot, peer goes LOWERLAYERDOWN, - # br-wan loses carrier (Fix 1 follow-up, mulga-998.b). + # br-wan loses carrier. sudo tee "$VETH_OVS_NETWORK" >/dev/null < ECR action -// -> resource table exactly. Every row here must match the plan doc's table; +// -> resource table exactly. Every row here must match the service's table; // changing an entry without a corresponding plan-doc update is a regression. func TestClassifyOperation_RouteMatrix(t *testing.T) { cases := []struct { diff --git a/spinifex/gateway/ecr/registry_image.go b/spinifex/gateway/ecr/registry_image.go index 1ab8abc09..81688b1f0 100644 --- a/spinifex/gateway/ecr/registry_image.go +++ b/spinifex/gateway/ecr/registry_image.go @@ -211,7 +211,7 @@ func (reg *Registry) ListImages(ctx context.Context, account, repo string) ([]Im // DeleteImage removes an image by tag and/or digest. A tag deletes only that tag // pointer; a digest deletes the manifest meta and every tag pointing at it. Blob -// and manifest-object GC is deferred (siv-361). The resolved digest is returned. +// and manifest-object GC is deferred. The resolved digest is returned. // A missing image yields ErrImageNotFound. func (reg *Registry) DeleteImage(ctx context.Context, account, repo, tag, digest string) (string, error) { scoped := reg.forAccount(account) diff --git a/spinifex/gateway/ecs.go b/spinifex/gateway/ecs.go index e3aa7c23d..7a1c5482e 100644 --- a/spinifex/gateway/ecs.go +++ b/spinifex/gateway/ecs.go @@ -23,7 +23,7 @@ func ecsActionFromTarget(target string) string { // ECS_Request dispatches AWS JSON 1.1 ECS control-plane requests. The action // comes from X-Amz-Target; errors are returned as awserrors codes and rendered // by the shared ErrorHandler. Every action is a NotImplemented (501) stub until -// its real handler lands in a later Phase 4 sprint. +// its real handler is added when the service supports the operation. func (gw *GatewayConfig) ECS_Request(w http.ResponseWriter, r *http.Request) error { action := ecsActionFromTarget(r.Header.Get("X-Amz-Target")) if action == "" { diff --git a/spinifex/gateway/gateway.go b/spinifex/gateway/gateway.go index cecc8ed9f..c5e30de3c 100644 --- a/spinifex/gateway/gateway.go +++ b/spinifex/gateway/gateway.go @@ -120,8 +120,8 @@ type GatewayConfig struct { // routes. Nil falls back to no external providers (self-host models only). BedrockCredentials *gateway_bedrock.CredentialStore // BedrockEndpoints maps a self-hosted modelId to its OpenAI-compatible base - // URL. Phase 1 endpoints are pinned/always-resident, so this is static - // config; a later phase backs it with the daemon's dynamic endpoint + // URL. These endpoints are pinned/always-resident, so this is static + // config; a future implementation can back it with the daemon's dynamic endpoint // registry. Nil/empty means no self-hosted models are reachable. BedrockEndpoints map[string]string // BedrockLoggingConfig persists per-account invocation-logging preferences diff --git a/spinifex/handlers/ec2/image/service_impl_test.go b/spinifex/handlers/ec2/image/service_impl_test.go index dfbea07bc..5ada15cff 100644 --- a/spinifex/handlers/ec2/image/service_impl_test.go +++ b/spinifex/handlers/ec2/image/service_impl_test.go @@ -737,7 +737,7 @@ func TestDescribeImages_InvalidConfigJSON(t *testing.T) { assert.Empty(t, result.Images) } -// TestDescribeImages_ConfigFaultCounting covers mulga-7r6pm: a config.json that +// TestDescribeImages_ConfigFaultCounting covers a config.json that // exists but can't be fetched/read/parsed must be promoted to WARN and counted // as unreadable so it stays visible at INFO, while a genuinely absent // config.json (a non-AMI directory) stays silent at DEBUG and uncounted, and a diff --git a/spinifex/handlers/ec2/instance/service_impl_test.go b/spinifex/handlers/ec2/instance/service_impl_test.go index d38c3cef1..766dc22df 100644 --- a/spinifex/handlers/ec2/instance/service_impl_test.go +++ b/spinifex/handlers/ec2/instance/service_impl_test.go @@ -1940,7 +1940,7 @@ func TestTerminateStoppedInstance_UserVolumeDeleted(t *testing.T) { assert.Equal(t, []string{"vol-user-001"}, vd.deleted) } -// TestTerminateStoppedInstance_StampsTeardownVolumesDone locks the mulga-1dzx9 +// TestTerminateStoppedInstance_StampsTeardownVolumesDone locks the // fix: TerminateStoppedInstance must stamp Teardown[vm.TeardownVolumes] on // success, mirroring the running-instance path's markTeardownResult // (vm/shutdown.go). Without this, daemon.leakedVolumeInstances() and diff --git a/spinifex/handlers/ec2/volume/service_impl_test.go b/spinifex/handlers/ec2/volume/service_impl_test.go index 1f2cad9f9..6598e7049 100644 --- a/spinifex/handlers/ec2/volume/service_impl_test.go +++ b/spinifex/handlers/ec2/volume/service_impl_test.go @@ -1492,7 +1492,7 @@ func TestDeleteVolume_EmptyStateUnattachedDeletable(t *testing.T) { } // TestDeleteVolumeOnTerminate_ClearsAttachmentThenDeletes locks the -// mulga-1dzx9 fix: a DeleteOnTermination root volume left attached to a +// A DeleteOnTermination root volume left attached to a // stopped instance (Stop's Unmount deliberately never clears a Boot volume's // AttachedInstance, daemon/vm_adapters.go) hits DeleteVolume's in-use guard // directly — see TestDeleteVolume_VolumeAttachedButAvailable above. diff --git a/spinifex/handlers/ec2/vpc/eni_test.go b/spinifex/handlers/ec2/vpc/eni_test.go index 7e6c9a332..6e71e7b01 100644 --- a/spinifex/handlers/ec2/vpc/eni_test.go +++ b/spinifex/handlers/ec2/vpc/eni_test.go @@ -1169,7 +1169,7 @@ func TestIsEIPOwned_MultipleRecords_OneMatches(t *testing.T) { assert.True(t, owned) } -// --- validateSGAttachment (Phase 2.2) --- +// --- validateSGAttachment --- func TestValidateSGAttachment_OK(t *testing.T) { svc := setupTestVPCService(t) @@ -1224,7 +1224,7 @@ func TestValidateSGAttachment_CrossVPC(t *testing.T) { assert.ErrorContains(t, err, "InvalidParameterValue") } -// Phase 7: ModifyNetworkInterfaceAttribute must propagate vpcd errors so the +// ModifyNetworkInterfaceAttribute must propagate vpcd errors so the // caller knows OVN port-group reconciliation didn't happen. The KV record // already changed by this point — that's intentional (reconciler converges). func TestModifyNetworkInterfaceAttribute_VpcdError_Propagated(t *testing.T) { diff --git a/spinifex/handlers/ec2/vpc/security_group_test.go b/spinifex/handlers/ec2/vpc/security_group_test.go index 9c6f8d33d..ccb3d1658 100644 --- a/spinifex/handlers/ec2/vpc/security_group_test.go +++ b/spinifex/handlers/ec2/vpc/security_group_test.go @@ -1112,7 +1112,7 @@ func TestDescribeSecurityGroups_FilterNoResults(t *testing.T) { assert.Empty(t, out.SecurityGroups) } -// --- Phase 3: default SG lifecycle, dependency checks, quotas --- +// --- default SG lifecycle, dependency checks, quotas --- // findDefaultSGInVPC returns the default-SG ID for a VPC by filtering on // IsDefault=true (production code keys off IsDefault, not GroupName). @@ -1302,7 +1302,7 @@ func TestEnsureDefaultVPC_CreatesDefaultSG(t *testing.T) { require.Len(t, desc.SecurityGroups, 1) } -// --- Phase 5.3: SourceSG existence + same-VPC validation on Authorize --- +// --- SourceSG existence + same-VPC validation on Authorize --- func TestAuthorizeSecurityGroupIngress_SourceSG_SameVPC(t *testing.T) { svc := setupTestVPCService(t) @@ -1439,7 +1439,7 @@ func TestAuthorizeSecurityGroupEgress_RuleLimit(t *testing.T) { assert.Contains(t, err.Error(), "RulesPerSecurityGroupLimitExceeded") } -// --- Phase 7: vpcd error propagation across the SG surface --- +// --- vpcd error propagation across the SG surface --- // CreateSecurityGroup writes to KV before requesting vpcd, so the record // persists on vpcd error — the orphan-PG reconciler is the safety net. This diff --git a/spinifex/handlers/ecs/bus/subjects.go b/spinifex/handlers/ecs/bus/subjects.go index 1c014e229..fce4757c6 100644 --- a/spinifex/handlers/ecs/bus/subjects.go +++ b/spinifex/handlers/ecs/bus/subjects.go @@ -4,7 +4,7 @@ // subject shape and message schema have a single source of truth. // // Cluster identity is "." (matching the KV layout), not a -// UUID. The Phase 5 per-AZ NATS cutover inserts "{azID}" after "ecs." — keep +// UUID. The per-AZ NATS routing inserts "{azID}" after "ecs." — keep // these builders the one place that knows the shape so that change stays local. package bus diff --git a/spinifex/handlers/ecs/conv_test.go b/spinifex/handlers/ecs/conv_test.go index 03c4dc9b3..5670436d5 100644 --- a/spinifex/handlers/ecs/conv_test.go +++ b/spinifex/handlers/ecs/conv_test.go @@ -82,7 +82,7 @@ func TestContainerDefsFromAWS_SkipsNil(t *testing.T) { assert.Empty(t, containerDefsFromAWS([]*ecs.ContainerDefinition{nil})) } -// TestContainerDefsFromAWS_GPU covers mulga-11opz (Epic C task C1): a +// TestContainerDefsFromAWS_GPU verifies that a // resourceRequirements entry of type=GPU is parsed as a whole-GPU count and // carried onto ContainerDef, its AWS round trip, and the bus AssignContainer. func TestContainerDefsFromAWS_GPU(t *testing.T) { diff --git a/spinifex/handlers/ecs/taskdef_validation_test.go b/spinifex/handlers/ecs/taskdef_validation_test.go index 47aae1757..c7eac6b1f 100644 --- a/spinifex/handlers/ecs/taskdef_validation_test.go +++ b/spinifex/handlers/ecs/taskdef_validation_test.go @@ -10,7 +10,7 @@ import ( "github.com/stretchr/testify/require" ) -// TestRegisterTaskDefinition_RejectsSecrets covers siv-458: a container secrets[] +// TestRegisterTaskDefinition_RejectsSecrets verifies that a container secrets[] // is hard-rejected rather than silently dropped. func TestRegisterTaskDefinition_RejectsSecrets(t *testing.T) { svc, _ := newTestService(t) @@ -27,7 +27,7 @@ func TestRegisterTaskDefinition_RejectsSecrets(t *testing.T) { assert.Contains(t, err.Error(), "InvalidParameterException") } -// TestRegisterTaskDefinition_AcceptsUnsupportedLogDriver covers siv-455/458: a +// TestRegisterTaskDefinition_AcceptsUnsupportedLogDriver verifies that a // non-json-file driver is accepted for parity (warned, not rejected) and the // driver round-trips through DescribeTaskDefinition. func TestRegisterTaskDefinition_AcceptsUnsupportedLogDriver(t *testing.T) { @@ -77,8 +77,8 @@ func TestRegisterTaskDefinition_EchoesRequiresCompatibilities(t *testing.T) { assert.Equal(t, []string{"EC2"}, aws.StringValueSlice(d.TaskDefinition.RequiresCompatibilities)) } -// TestRunTask_AssignCarriesExecutionRoleAndLogDriver covers siv-459 (execution -// role plumbed to the agent) and siv-455 (log driver reaches the assign). +// TestRunTask_AssignCarriesExecutionRoleAndLogDriver verifies that execution +// role plumbed to the agent) and the log driver reaches the assign. func TestRunTask_AssignCarriesExecutionRoleAndLogDriver(t *testing.T) { svc, _ := newTestService(t) _, err := svc.CreateCluster(context.Background(), &ecs.CreateClusterInput{ClusterName: aws.String("web")}, testAccountID) @@ -113,7 +113,7 @@ func TestRunTask_AssignCarriesExecutionRoleAndLogDriver(t *testing.T) { assert.Equal(t, LogDriverJSONFile, poll.Assignments[0].Containers[0].LogDriver) } -// TestRunTask_AssignCarriesGPU covers mulga-11opz (Epic C task C1): a +// TestRunTask_AssignCarriesGPU verifies that a // resourceRequirements GPU count on the task def is threaded end-to-end — // conv -> ContainerDef -> task-level aggregate (TaskRecord.GPU) -> the // AssignContainer the agent polls for. diff --git a/spinifex/handlers/eks/create_cluster_test.go b/spinifex/handlers/eks/create_cluster_test.go index 5ded3e44d..504d8c3b0 100644 --- a/spinifex/handlers/eks/create_cluster_test.go +++ b/spinifex/handlers/eks/create_cluster_test.go @@ -28,7 +28,7 @@ func createInput(name string) *eks.CreateClusterInput { // A create that fails after the NLB is provisioned must leave the NLB ARNs // persisted on the (now FAILED) meta, otherwise the resources leak with no -// owning record and DeleteCluster cannot reclaim them (bead 165.3). +// owning record and DeleteCluster cannot reclaim them. func TestCreateCluster_NLBArnPersistedBeforeLaterFailure(t *testing.T) { f := newEKSServiceFixture(t) @@ -235,7 +235,7 @@ func TestCreateCluster_FailedClusterIsReclaimedOnRetry(t *testing.T) { assert.NotEmpty(t, f.nlb.deleteLBCalls, "reclaim must tear down the failed attempt's NLB") } -// A FAILED cluster is observable via Describe and List (bead 165.6) — no state +// A FAILED cluster is observable via Describe and List — no state // where create blocks but describe/list show nothing. func TestCreateCluster_FailedClusterVisibleInDescribeAndList(t *testing.T) { f := newEKSServiceFixture(t) @@ -262,7 +262,7 @@ func TestCreateCluster_FailedClusterVisibleInDescribeAndList(t *testing.T) { // An ACTIVE cluster whose reconciler recorded a /healthz failure must surface // that as a ClusterHealth issue in describe-cluster, so a dead control plane is -// visible behind the still-ACTIVE status (bead 165.13). +// visible behind the still-ACTIVE status . func TestDescribeCluster_SurfacesHealthIssueForActiveCluster(t *testing.T) { f := newEKSServiceFixture(t) @@ -295,7 +295,7 @@ func TestDescribeCluster_HealthyActiveClusterHasNoIssues(t *testing.T) { // A missing eks-server AMI is an operator/config gap surfaced during the async // launch: CreateCluster accepts the request (CREATING) and the background launch -// marks the half-built cluster FAILED so the reclaim path can retry (bead 165.4). +// marks the half-built cluster FAILED so the reclaim path can retry . func TestCreateCluster_MissingAMIReturnsServiceUnavailable(t *testing.T) { f := newEKSServiceFixture(t) f.ami.describeOut = &ec2.DescribeImagesOutput{} // no images tagged managed-by=eks diff --git a/spinifex/handlers/eks/delete_cluster_test.go b/spinifex/handlers/eks/delete_cluster_test.go index ec7de2a83..a4971c3b3 100644 --- a/spinifex/handlers/eks/delete_cluster_test.go +++ b/spinifex/handlers/eks/delete_cluster_test.go @@ -424,7 +424,7 @@ func TestDeleteCluster_ManagedCPVPCReclaimsCustomerVPCSGs(t *testing.T) { } // TestDeleteCluster_ManagedCPVPCAlreadyGoneClearsStateRecord locks the -// mulga-jbb2i teardown-idempotency fix: when the managed CP VPC is already +// Teardown is idempotent when the managed CP VPC is already // gone (its tag-indexed EC2 record is absent — the "InvalidVpcID.NotFound" // case confirmed live), DeleteClusterCPVPC converges to success, and the // internal cp-vpc state record (meta.ManagedCPVPC) must be cleared right away — @@ -491,7 +491,7 @@ func subscribeVPCDelete(t *testing.T, nc *nats.Conn) func() string { } // TestDeleteClusterCPVPC_OVNGCSelection locks the OVN-GC half of the -// mulga-jbb2i fix: DeleteClusterCPVPC must republish vpc.delete for the CP +// DeleteClusterCPVPC must republish vpc.delete for the CP // VPC so vpcd's topology manager gets another chance to remove the orphaned // logical router/subnets/egress-drop policies — both when the EC2 VPC is // actually deleted this call, and when it was already gone, where the only diff --git a/spinifex/handlers/eks/eks_deleting_reaper_test.go b/spinifex/handlers/eks/eks_deleting_reaper_test.go index 494be332d..d836cfad6 100644 --- a/spinifex/handlers/eks/eks_deleting_reaper_test.go +++ b/spinifex/handlers/eks/eks_deleting_reaper_test.go @@ -166,7 +166,7 @@ func TestDeletingReaper_ExhaustsAfterMaxAttempts(t *testing.T) { assert.Len(t, f.inst.terminateCalls, terminateCallsAtExhaustion, "an exhausted cluster must never be re-driven again") } -// TestDeletingReaper_PersistsLastErrorOnFailure guards mulga-djaep criterion 2: +// TestDeletingReaper_PersistsLastErrorOnFailure guards the second cleanup condition: // a terminal give-up must carry the last error, not just a bare boolean flag. // The error must be visible on the very first failed attempt (so an operator // checking a still-retrying cluster already sees why), and the same error must diff --git a/spinifex/handlers/imds/trace_test.go b/spinifex/handlers/imds/trace_test.go index cd0fe2bd4..8e892c74d 100644 --- a/spinifex/handlers/imds/trace_test.go +++ b/spinifex/handlers/imds/trace_test.go @@ -47,7 +47,7 @@ func TestHTTPHandler_ProducesSpan(t *testing.T) { // TestHTTPHandler_RejectedForwardedStillTraced is the load-bearing assertion // for the middleware-ordering call: otelsetup.HTTPMiddleware wraps OUTSIDE // rejectForwarded, so an X-Forwarded-For request rejected by the SSRF guard -// still produces a span (the 431+431 rooted fan-out gap the bead reports +// still produces a span (the 431+431 rooted fan-out gap // starts on requests exactly like this) — but the rejection itself is // unaffected by tracing being present. A span cannot let a rejected request // through; it only observes it. diff --git a/spinifex/handlers/quota/bedrock.go b/spinifex/handlers/quota/bedrock.go index 29c7a703b..184d541a4 100644 --- a/spinifex/handlers/quota/bedrock.go +++ b/spinifex/handlers/quota/bedrock.go @@ -16,7 +16,7 @@ import ( // BedrockUsageReader resolves accountID's current-period Bedrock token usage // (input+output, across every model), the counter gateway_bedrock's usage -// consumer maintains from the invocation stream (mulga-vmfng.7.6). The +// consumer maintains from the invocation stream. The // interface is defined here rather than importing gateway_bedrock so the two // packages stay decoupled; gateway_bedrock.UsageStore satisfies it // structurally, and awsgw.go wires the two together at startup. @@ -39,7 +39,7 @@ func (s *Service) SetBedrockUsage(r BedrockUsageReader) { // gate: the invocation that crosses the cap is itself allowed (its cost // isn't known until it finishes), and the next one is rejected once the // stream-fed counter catches up. A few seconds of lag behind real usage is -// an accepted property of a monthly cap (D8). +// an accepted property of a monthly cap. func (s *Service) CheckBedrockTokens(ctx context.Context, accountID string) error { if s == nil || !s.limits.TokensPerMonthEnabled || accountID == utils.GlobalAccountID { return nil @@ -192,7 +192,7 @@ func (l *rpmLimiter) snapshot() map[string]int { // KVBucketBedrockRPMUsage is the gateway-owned KV bucket RunBedrockRPMSync // writes each account's current bucket occupancy to, keyed by accountID. It // exists for cross-node visibility and dashboards only: CheckBedrockRPM never -// reads it back. Enforcement must stay local and immediate (D8) — reading a +// reads it back. Enforcement must stay local and immediate — reading a // remote value here would reintroduce exactly the round-trip latency that // ruled out stream-fed RPM enforcement in the first place. Concurrent // gateways overwrite each other's snapshot for the same account with no diff --git a/spinifex/handlers/quota/quota.go b/spinifex/handlers/quota/quota.go index 928401bf2..43664eabe 100644 --- a/spinifex/handlers/quota/quota.go +++ b/spinifex/handlers/quota/quota.go @@ -29,7 +29,7 @@ const KVBucketQuotaReconcile = "spinifex-quota-reconcile" // false) is a valid no-op, so gateways without a [quota] block are unaffected. // // TokensPerMonthEnabled and RequestsPerMinuteEnabled are deliberately -// separate from Enabled above (mulga-vmfng.7.6): a deployment already +// separate from Enabled above: a deployment already // enforcing standing-infra quotas (Enabled=true for VCPUs/VPCs/...) must opt // in to Bedrock token/RPM enforcement independently, since a bare Enabled // would otherwise silently cap Bedrock usage at zero the moment any other @@ -60,7 +60,7 @@ type Service struct { usage jetstream.KeyValue // bedrockUsage resolves the stream-fed Bedrock token counter - // (mulga-vmfng.7.6). Nil until SetBedrockUsage is called, in which case + // Nil until SetBedrockUsage is called, in which case // CheckBedrockTokens treats the dimension as unconfigured rather than // erroring — a wiring gap must not block every Bedrock call. bedrockUsage BedrockUsageReader diff --git a/spinifex/handlers/rds/arn.go b/spinifex/handlers/rds/arn.go index 14a769c77..3a16b1282 100644 --- a/spinifex/handlers/rds/arn.go +++ b/spinifex/handlers/rds/arn.go @@ -66,7 +66,7 @@ type ParsedARN struct { // arn:aws:rds:{region}:{accountID}:{kind}:{identifier} const arnSegmentCount = 7 -// Parses one of the four D17 ARNs and validates it belongs to the caller. +// Parses one of the four supported RDS ARNs and validates it belongs to the caller. // Region and account are checked here rather than at policy evaluation, so a // foreign-account reference never reaches the evaluator at all. func ParseARN(arn, region, accountID string) (ParsedARN, error) { diff --git a/spinifex/handlers/rds/arn_parse_test.go b/spinifex/handlers/rds/arn_parse_test.go index 1f2d68219..2e22f21dd 100644 --- a/spinifex/handlers/rds/arn_parse_test.go +++ b/spinifex/handlers/rds/arn_parse_test.go @@ -8,7 +8,7 @@ import ( "github.com/stretchr/testify/require" ) -// Every D17 ARN the builders mint must parse back into the parts it was built +// Every ARN the builders mint must parse back into the parts it was built // from, so a resource named by a describe is addressable by a tag action. func TestParseARN_RoundTripsEveryResourceType(t *testing.T) { cases := []struct { diff --git a/spinifex/handlers/rds/backup.go b/spinifex/handlers/rds/backup.go index f73bb327e..92106f7d4 100644 --- a/spinifex/handlers/rds/backup.go +++ b/spinifex/handlers/rds/backup.go @@ -15,13 +15,13 @@ import ( "github.com/nats-io/nats.go/jetstream" ) -// Automated backups (D11 Phase A): one snapshot per instance per day inside its -// backup window, taken through rds-8's snapshot path and swept past +// Automated backups: one snapshot per instance per day inside its +// backup window, taken through the shared snapshot path and swept past // BackupRetentionPeriod. PITR, WAL archiving and LatestRestorableTime are Phase B // and stay unreported, so nothing here implies continuous recovery. const ( - // AWS's own bound is 35 days; this platform's is 7 (D11 Phase A). The cost of + // AWS's own bound is 35 days; this platform's is 7. The cost of // a retained snapshot here is metadata and restore surface, not chunks: any // snapshot latches viperblock chunk GC off for the life of the source volume, // so one day and seven pin exactly the same data. @@ -60,7 +60,7 @@ const ( automatedBackupRetryShiftCap = 3 ) -// The operator-tunable half of rds-9: bounds and defaults, never a per-instance +// The operator-tunable backup settings: bounds and defaults, never a per-instance // setting — those live on the DB instance record. type BackupPolicy struct { // The upper bound ModifyDBInstance and CreateDBInstance accept. Zero takes @@ -131,7 +131,7 @@ func (s *Service) windowBlock(configured, fallback, kind string) dailyWindow { } // The window in force for this instance. A record that names one uses it; one -// that does not — a record written before rds-9, or an instance whose create +// that does not — a record written before these settings existed, or an instance whose create // named neither — takes the deterministic assignment, which is the same value // this phase persists at create. func (s *Service) resolvedBackupWindow(rec *DBInstanceRecord) (dailyWindow, error) { @@ -177,7 +177,7 @@ func (s *Service) scheduledBackupWindow(rec *DBInstanceRecord) (dailyWindow, boo return window, err == nil } -// The windows as a describe reports them. A record written before rds-9 carries +// The windows as a describe reports them. A record written before these settings existed carries // neither, so the derived window is reported rather than an empty string: it is // the window the scheduler will actually use, and reporting nothing would have the // customer believe no backup is scheduled. @@ -206,7 +206,7 @@ var backupCapableStatuses = []Status{StatusAvailable, StatusStopped} // Fires this instance's automated backup when its window is open and none has // succeeded since the window opened, reporting whether it took one. Called from // the leader-elected reconciler pass, which is what makes it cluster-singular; -// rds-8's per-instance in-flight guard is what makes it safe anyway. +// the per-instance in-flight guard is what makes it safe anyway. func (s *Service) runBackupWindow(ctx context.Context, kv jetstream.KeyValue, rev uint64, accountID string, rec *DBInstanceRecord) (bool, error) { now := time.Now().UTC() @@ -235,9 +235,9 @@ func (s *Service) runBackupWindow(ctx context.Context, kv jetstream.KeyValue, re } if err := s.takeAutomatedBackup(ctx, kv, rev, accountID, rec, now); err != nil { - // D-rds-9: the database is healthy and stays available. The failure is + // The database is healthy and stays available. The failure is // counted and evented so it is visible, and retried while the window is - // open; it never reaches rds-6's recovery ladder. + // open; it never reaches the instance recovery path. return false, s.recordBackupFailure(ctx, kv, accountID, rec, err) } return true, nil @@ -266,7 +266,7 @@ func backupRetryDelay(failures int) time.Duration { return automatedBackupRetryBase << min(max(failures-1, 0), automatedBackupRetryShiftCap) } -// Takes the snapshot through rds-8's path, indexes it, and stamps the window as +// Takes the snapshot through the shared path, indexes it, and stamps the window as // fired. The index is written before the stamp: an indexed backup with no stamp // costs one duplicate snapshot at worst and is swept on schedule, while a stamped // backup with no index would be invisible to retention for the life of the @@ -442,7 +442,7 @@ func (s *Service) DescribeDBInstanceAutomatedBackups(ctx context.Context, return &rds.DescribeDBInstanceAutomatedBackupsOutput{DBInstanceAutomatedBackups: backups}, nil } -// D19: a filter this phase cannot honour is rejected rather than dropped, since a +// A filter this phase cannot honour is rejected rather than dropped, since a // silently unfiltered list reads as a complete answer. Returns the DB instance to // report on, empty for every one. func validateDescribeAutomatedBackupsRequest(input *rds.DescribeDBInstanceAutomatedBackupsInput) (string, error) { @@ -464,11 +464,11 @@ func validateDescribeAutomatedBackupsRequest(input *rds.DescribeDBInstanceAutoma // RestoreWindow and LatestRestorableTime are deliberately absent: this phase // backs discrete daily snapshots, and reporting a restore window would tell a -// client it can recover to any instant inside it (D11 Phase B). +// client it can recover to any instant inside it. func (s *Service) projectAutomatedBackup(rec *DBInstanceRecord, snapshots int) *rds.DBInstanceAutomatedBackup { // AWS's own vocabulary: creating until the first snapshot exists, active once // one does. retained — an automated backup outliving its instance — is not - // offered, because it would pin the source data volume indefinitely (D10). + // offered, because it would pin the source data volume indefinitely. status := "creating" if snapshots > 0 { status = "active" diff --git a/spinifex/handlers/rds/backup_sweep.go b/spinifex/handlers/rds/backup_sweep.go index b949de831..eedee421f 100644 --- a/spinifex/handlers/rds/backup_sweep.go +++ b/spinifex/handlers/rds/backup_sweep.go @@ -15,7 +15,7 @@ import ( ) // The retention sweep is a cluster-wide vm.Reaper rather than a reconciler tick, -// because it is the one part of rds-9 that deletes customer data. The shared GC +// because it is the one part of retention that deletes customer data. The shared GC // backstop buys it the two properties that matters most for: it is skipped // entirely while KV is unhealthy, so it can never reap against a desired state it // cannot read, and cluster-wide scope is leader-gated by the framework. Backup @@ -100,7 +100,7 @@ func (r *BackupRetentionReaper) sweepAccount(ctx context.Context, kv jetstream.K } } - // The backstop for a crash between rds-8's last DeleteDBSnapshot and the + // The backstop for a crash between the last DeleteDBSnapshot and the // inline volume delete that follows it: nothing else references the volume by // then, so without this it is orphaned permanently. volumes, err := r.svc.reclaimOrphanedVolumes(ctx, kv) @@ -289,7 +289,7 @@ func (s *Service) dropAutomatedBackupIndex(ctx context.Context, kv jetstream.Key // Two callers, both of which mean "there is nothing left to retain for": a // BackupRetentionPeriod=0 modify, which turns the feature off, and the teardown // of the instance itself, whose automated backups would otherwise pin its data -// volume after the instance is gone (D10). +// volume after the instance is gone. func (s *Service) purgeAutomatedBackups(ctx context.Context, kv jetstream.KeyValue, accountID, dbInstanceIdentifier string) error { stamps, err := ListAutomatedBackupStamps(ctx, kv, dbInstanceIdentifier) @@ -309,7 +309,7 @@ func (s *Service) purgeAutomatedBackups(ctx context.Context, kv jetstream.KeyVal return errors.Join(failures...) } -// Deletes the data volumes retained for snapshots that no longer exist. rds-8 +// Deletes the data volumes retained for snapshots that no longer exist. The service // deletes the volume inline on the last DeleteDBSnapshot, so this only ever fires // for a crash between those two steps — which is precisely what a KV-health-gated // cluster-wide sweep is for. diff --git a/spinifex/handlers/rds/backup_sweep_test.go b/spinifex/handlers/rds/backup_sweep_test.go index 56c861b40..dea2fb59c 100644 --- a/spinifex/handlers/rds/backup_sweep_test.go +++ b/spinifex/handlers/rds/backup_sweep_test.go @@ -304,7 +304,7 @@ func TestSweep_FailsWhenTheAccountBucketsCannotBeEnumerated(t *testing.T) { require.Error(t, err) } -// The backstop for a crash between rds-8's last DeleteDBSnapshot and the inline +// The backstop for a crash between the last DeleteDBSnapshot and the inline // volume delete that follows it: nothing else references the volume by then. func TestSweep_ReclaimsAnOrphanedRetainedVolume(t *testing.T) { h := newSnapshotHarness(t, false) @@ -392,7 +392,7 @@ func TestModifyDBInstance_SweepsTheAutomatedBackupsWhenRetentionGoesToZero(t *te assert.Empty(t, h.automatedStamps(t, testDBID)) } -// D10: an automated backup outliving its instance would pin the instance's data +// An automated backup outliving its instance would pin the instance's data // volume for good, so teardown sweeps the set before releasing the volume. func TestDeleteDBInstance_SweepsTheAutomatedBackups(t *testing.T) { h := newLifecycleHarness(t, false) diff --git a/spinifex/handlers/rds/backup_test.go b/spinifex/handlers/rds/backup_test.go index f0b5f9e55..f3c0426ea 100644 --- a/spinifex/handlers/rds/backup_test.go +++ b/spinifex/handlers/rds/backup_test.go @@ -409,7 +409,7 @@ func TestRunBackupWindow_TakesIndexesAndStampsTheBackup(t *testing.T) { require.True(t, h.runBackupPass(t)) - // One EC2 snapshot, taken through rds-8's path: the engine was quiesced and let + // One EC2 snapshot, taken through the automated backup path: the engine was quiesced and let // go again rather than copied mid-write. require.Len(t, h.snaps.created, 1) issued := make([]string, 0, 2) @@ -506,7 +506,7 @@ func TestRunBackupWindow_SkipsAnInstanceItCannotBackUp(t *testing.T) { assert.Len(t, h.events(t, EventSourceTypeDBInstance, testDBID), len(messages)) } -// D-rds-9: a failed backup is a backup fault, never an instance fault. The +// A failed backup is a backup fault, never an instance fault. The // database stays available and the failure is counted so it is visible. func TestRunBackupWindow_CountsAFailureAndLeavesTheInstanceAvailable(t *testing.T) { h := newSnapshotHarness(t, false) @@ -542,7 +542,7 @@ func TestRunBackupWindow_IgnoresAMalformedStoredWindow(t *testing.T) { // The other half of the pair is resolved for the overlap check, not to be // written down. A record that carried no maintenance window before the modify // still carries none after it: reporting one back would show as drift in the next -// plan of a config that never set it. +// configuration read for a request that never set it. func TestModifyDBInstance_DoesNotPersistTheWindowItWasNotGiven(t *testing.T) { h := newSnapshotHarness(t, false) rec := retainingRecord(7) @@ -561,7 +561,7 @@ func TestModifyDBInstance_DoesNotPersistTheWindowItWasNotGiven(t *testing.T) { assert.Empty(t, stored.PreferredMaintenanceWindow, "a window the request did not name is not stored") } -// A record written before rds-9 carries no window at all, and still has to be +// A record written before window fields existed carries no window at all, and still has to be // backed up — on the window a describe reports for it. func TestResolvedBackupWindow_DerivesAWindowForARecordWithoutOne(t *testing.T) { svc := NewService(nil, testRegion) @@ -710,7 +710,7 @@ func TestDescribeDBInstanceAutomatedBackups_ReportsTheBackupSet(t *testing.T) { assert.Equal(t, int64(7), aws.Int64Value(backup.BackupRetentionPeriod)) assert.Equal(t, testRegion, aws.StringValue(backup.Region)) - // D11 Phase B: this phase backs discrete daily snapshots. A restore window + // This phase backs discrete daily snapshots. A restore window // would tell a client it can recover to any instant inside it. assert.Nil(t, backup.RestoreWindow) } @@ -736,7 +736,7 @@ func TestDescribeDBInstanceAutomatedBackups_RejectsAnUnknownInstance(t *testing. assert.Contains(t, err.Error(), awserrors.ErrorDBInstanceNotFound) } -// D19: a filter this phase cannot honour is rejected, because a silently +// A filter this phase cannot honour is rejected, because a silently // unfiltered list reads as a complete answer. func TestDescribeDBInstanceAutomatedBackups_RejectsUnimplementedFilters(t *testing.T) { cases := map[string]*rds.DescribeDBInstanceAutomatedBackupsInput{ diff --git a/spinifex/handlers/rds/commands.go b/spinifex/handlers/rds/commands.go index eda3c6165..aeaf67315 100644 --- a/spinifex/handlers/rds/commands.go +++ b/spinifex/handlers/rds/commands.go @@ -14,7 +14,7 @@ import ( "github.com/nats-io/nats.go" ) -// The control-plane half of the rds-2b command channel. The agent side is a +// The control-plane half of the command channel. The agent side is a // long poll over the gateway; this publishes on the bus subject that poll is // subscribed to and waits for the reply the agent carries back on its next one. @@ -23,10 +23,10 @@ const ( CommandApplyParams = "apply-params" CommandStopEngine = "stop-engine" // Extends the in-guest filesystem onto a data volume the control plane has - // already grown (D12). + // already grown. CommandGrowFilesystem = "grow-filesystem" // Holds the engine at a checkpoint for the length of a snapshot, and releases - // it again (D10). The hold is a session the agent keeps open, so the pair is + // it again. The hold is a session the agent keeps open, so the pair is // two commands rather than one with a duration. CommandQuiesce = "quiesce" CommandUnquiesce = "unquiesce" @@ -67,7 +67,7 @@ const ( // time in backup mode rather than the rest of its life. quiesceHold = 6 * time.Minute - // The channel is a live subscription rather than a durable queue (D8), so a + // The channel is a live subscription rather than a durable queue, so a // command published between two of the agent's polls reaches nobody. // Re-publishing on this interval closes that gap without queueing anything. commandRepublishEvery = 2 * time.Second @@ -80,7 +80,7 @@ var ErrCommandUnreachable = errors.New("rds: the instance agent did not answer t // Sets the engine's master password live. It is never persisted anywhere: an // unreachable agent fails loudly rather than leaving cleartext queued for -// later (D8). +// later. func (s *Service) setMasterPassword(ctx context.Context, accountID, dbInstanceIdentifier, username, password string) error { _, err := s.issueCommand(ctx, accountID, dbInstanceIdentifier, CommandSetPassword, setPasswordTimeout, []Parameter{ {Name: CommandParamMasterUsername, Value: username}, @@ -91,7 +91,7 @@ func (s *Service) setMasterPassword(ctx context.Context, accountID, dbInstanceId // Writes the resolved parameter set into the engine's config and reloads it. // Returns the settings the engine accepted but will not apply until it -// restarts, which is what RebootDBInstance then clears (D16). +// restarts, which is what RebootDBInstance then clears. func (s *Service) applyParameters(ctx context.Context, accountID, dbInstanceIdentifier string, params []Parameter) ([]string, error) { reply, err := s.issueCommand(ctx, accountID, dbInstanceIdentifier, CommandApplyParams, applyParamsTimeout, params) if err != nil { @@ -109,7 +109,7 @@ func (s *Service) stopEngine(ctx context.Context, accountID, dbInstanceIdentifie // Extends the guest's filesystem onto the already-grown data volume. Issued // once the agent is back rather than during boot: both ext4 and XFS grow while -// mounted, so this needs no ordering against the engine start (D12). +// mounted, so this needs no ordering against the engine start. func (s *Service) growFilesystem(ctx context.Context, accountID, dbInstanceIdentifier string) error { _, err := s.issueCommand(ctx, accountID, dbInstanceIdentifier, CommandGrowFilesystem, growFilesystemTimeout, nil) return err @@ -118,7 +118,7 @@ func (s *Service) growFilesystem(ctx context.Context, accountID, dbInstanceIdent // Holds the engine at a checkpoint so the data volume can be snapshotted at a // consistent point. The agent keeps the backup session open until the release // below, or until the deadline expires — so a control plane that dies here does -// not leave the engine in backup mode indefinitely (D10). +// not leave the engine in backup mode indefinitely. func (s *Service) quiesceEngine(ctx context.Context, accountID, dbInstanceIdentifier, label string) error { _, err := s.issueCommand(ctx, accountID, dbInstanceIdentifier, CommandQuiesce, quiesceTimeout, []Parameter{ {Name: CommandParamQuiesceLabel, Value: label}, diff --git a/spinifex/handlers/rds/commands_test.go b/spinifex/handlers/rds/commands_test.go index 11ffdac97..b5d32dd27 100644 --- a/spinifex/handlers/rds/commands_test.go +++ b/spinifex/handlers/rds/commands_test.go @@ -7,7 +7,7 @@ import ( "github.com/stretchr/testify/require" ) -// D8: the password is handed straight to the agent and never persisted, so the +// The password is handed straight to the agent and never persisted, so the // command is the only place it exists between the request and the engine. func TestSetMasterPassword_CarriesTheCredentialsToTheAgent(t *testing.T) { h := newLifecycleHarness(t, false) @@ -34,7 +34,7 @@ func TestSetMasterPassword_FailsWhenTheAgentRejectsIt(t *testing.T) { assert.Contains(t, err.Error(), CommandSetPassword) } -// D16: the settings the engine accepted but will not honour until it restarts +// The settings the engine accepted but will not honour until it restarts // come back as the reply message, which is what a later reboot then clears. func TestApplyParameters_ReportsWhatIsPendingARestart(t *testing.T) { h := newLifecycleHarness(t, false) diff --git a/spinifex/handlers/rds/create.go b/spinifex/handlers/rds/create.go index f4c7c1fa2..451127015 100644 --- a/spinifex/handlers/rds/create.go +++ b/spinifex/handlers/rds/create.go @@ -14,7 +14,7 @@ import ( "github.com/nats-io/nats.go/jetstream" ) -// The first VM behind a DB instance. rds-5b and rds-6 increment it on replace, +// The first VM behind a DB instance. Replacement and recovery increment it, // so an agent report carrying an older generation is a superseded VM. const firstVMGeneration = 1 @@ -22,7 +22,7 @@ const firstVMGeneration = 1 // the identifier, place and launch the dual-NIC VM with its data volume and // customer ENI, seed the one-shot bootstrap config, and publish the endpoint // record. The instance is returned at status=creating; the reconciler flips it -// to available on the first healthy agent heartbeat (D7). +// to available on the first healthy agent heartbeat. func (s *Service) CreateDBInstance(ctx context.Context, input *rds.CreateDBInstanceInput, accountID string) (out *rds.CreateDBInstanceOutput, err error) { req, err := s.validateCreateRequest(input) if err != nil { @@ -39,7 +39,7 @@ func (s *Service) CreateDBInstance(ctx context.Context, input *rds.CreateDBInsta // Resolved before the identifier is reserved, so a create naming a group that // does not exist leaves no record behind. The set is literals only: the // class's memory has already been folded into every size-derived default, so - // the agent never sees a formula (D20). + // the agent never sees a formula. parameters, err := s.resolveGroupParameters(ctx, kv, accountID, req.DBParameterGroupName, req.InstanceClass) if err != nil { return nil, err @@ -202,7 +202,7 @@ func (s *Service) recordLaunch(ctx context.Context, kv jetstream.KeyValue, key, } rec.DNSName = s.dnsName(accountID, rec.DBInstanceIdentifier) // Without northstar there is no resolvable name, so the endpoint is the ENI - // IP itself — stable per D5 and therefore as durable as a hostname (D6). + // IP itself — stable across VM replacement and therefore as durable as a hostname. rec.EndpointAddress = rec.DNSName if rec.EndpointAddress == "" { rec.EndpointAddress = rec.ENIPrivateIP diff --git a/spinifex/handlers/rds/create_test.go b/spinifex/handlers/rds/create_test.go index 54f5f5524..4e18bcdb6 100644 --- a/spinifex/handlers/rds/create_test.go +++ b/spinifex/handlers/rds/create_test.go @@ -372,7 +372,7 @@ func TestCreateDBInstance_FailureAfterLaunchUnwindsEveryResource(t *testing.T) { assert.Len(t, h.launch.enis.deleted, 2, "both the customer and system ENI are deleted") } -// D19 honesty: the request may not be answered with an instance whose storage is +// The request may not be answered with an instance whose storage is // not actually encrypted, so an unencrypted volume fails the whole create. func TestCreateDBInstance_UnencryptedDataVolumeFailsTheCreate(t *testing.T) { h := newCreateHarness(t, "") @@ -426,7 +426,7 @@ func TestCreateDBInstance_RequiresADefaultVPCWithASubnet(t *testing.T) { // need one. A zero policy carries the built-in defaults. func newCreateValidator() *Service { return NewService(nil, testRegion) } -// D19: a parameter that would create a false safety, security or availability +// A parameter that would create a false safety, security or availability // guarantee is rejected rather than silently dropped. func TestValidateCreateRequest_RejectsUnimplementedParameters(t *testing.T) { cases := []struct { @@ -460,7 +460,7 @@ func TestValidateCreateRequest_RejectsUnimplementedParameters(t *testing.T) { } } -// DeletionProtection is honoured from rds-5a onwards, so it has to be accepted +// DeletionProtection is honoured, so it has to be accepted // at create and carried onto the record DeleteDBInstance checks. func TestValidateCreateRequest_AcceptsDeletionProtection(t *testing.T) { input := validCreateInput() diff --git a/spinifex/handlers/rds/delete.go b/spinifex/handlers/rds/delete.go index b0e903e53..f5c99d516 100644 --- a/spinifex/handlers/rds/delete.go +++ b/spinifex/handlers/rds/delete.go @@ -193,7 +193,7 @@ func (s *Service) teardownDBInstance(ctx context.Context, kv jetstream.KeyValue, // Before the volume is released, so the automated backups are no longer holding // its chunks when that decides between deleting and retaining it. AWS keeps // automated backups after a delete as a separate resource; doing that here - // would pin the data volume indefinitely under rds-8's retention rule (D10). + // would pin the data volume indefinitely under the retention rule. if err := s.purgeAutomatedBackups(ctx, kv, accountID, rec.DBInstanceIdentifier); err != nil { return fmt.Errorf("rds: sweep the automated backups of %s: %w", rec.DBInstanceIdentifier, err) } @@ -248,7 +248,7 @@ func (s *Service) reserveFinalSnapshot(ctx context.Context, kv jetstream.KeyValu } // Manual, deliberately: the customer named it, so only the customer removes it - // — which is also what keeps rds-9's retention sweep away from it. + // — which is also what keeps the retention sweep away from it. record := newDBSnapshotRecord(accountID, rec, &validatedSnapshot{ DBSnapshotIdentifier: identifier, SnapshotType: SnapshotTypeManual, @@ -443,7 +443,7 @@ func (s *Service) recordFinalSnapshotCreated(ctx context.Context, accountID stri // A viperblock snapshot references its source volume's chunk files rather than // copying them, so the volume cannot be deleted while any snapshot survives — // including the final one just taken. It is retained instead, recorded with the -// snapshots holding it so the last DeleteDBSnapshot can release it (D10). +// snapshots holding it so the last DeleteDBSnapshot can release it. func (s *Service) releaseDataVolume(ctx context.Context, kv jetstream.KeyValue, accountID string, rec *DBInstanceRecord) error { if rec.DataVolumeID == "" { return nil @@ -476,7 +476,7 @@ func (s *Service) releaseDataVolume(ctx context.Context, kv jetstream.KeyValue, } // Records a volume the teardown left behind, with the snapshots holding it so -// the last DeleteDBSnapshot can release it (D10). holdersUnresolved marks the +// the last DeleteDBSnapshot can release it. holdersUnresolved marks the // case where the volume store refused the delete but named nobody, so a release // has to re-check rather than trust an empty list. func (s *Service) retainDataVolume(ctx context.Context, kv jetstream.KeyValue, accountID string, diff --git a/spinifex/handlers/rds/delete_test.go b/spinifex/handlers/rds/delete_test.go index 9366a74f7..3dfdc0247 100644 --- a/spinifex/handlers/rds/delete_test.go +++ b/spinifex/handlers/rds/delete_test.go @@ -120,7 +120,7 @@ func TestDeleteDBInstance_HonoursDeletionProtection(t *testing.T) { assert.Empty(t, h.volumes.deleted) } -// D18: the snapshot is taken once the VM is gone, so it reads a sealed data +// The snapshot is taken once the VM is gone, so it reads a sealed data // volume rather than one a live engine is still writing to. func TestDeleteDBInstance_TakesTheFinalSnapshotAfterTheEngineAndVMAreDown(t *testing.T) { h := newLifecycleHarness(t, false) @@ -207,7 +207,7 @@ func TestDeleteDBInstance_AdoptsAnInterruptedFinalSnapshot(t *testing.T) { assert.Equal(t, "snap-cut-before-crash", stored.SnapshotID) } -// D10: a snapshot references its source volume's chunks, so the volume cannot +// A snapshot references its source volume's chunks, so the volume cannot // be deleted while the final snapshot survives. It is retained and recorded // with the snapshots holding it. func TestDeleteDBInstance_RetainsTheVolumeAFinalSnapshotStillHolds(t *testing.T) { diff --git a/spinifex/handlers/rds/describe.go b/spinifex/handlers/rds/describe.go index 5f952ead7..28acc25e2 100644 --- a/spinifex/handlers/rds/describe.go +++ b/spinifex/handlers/rds/describe.go @@ -240,7 +240,7 @@ func projectPendingModifiedValues(pending *PendingModifiedValues) *rds.PendingMo // AWS reports a parameter group's state on the membership rather than in // PendingModifiedValues, and the Terraform provider reads it there: applying // while a modify is draining, pending-reboot while static settings await the -// restart that adopts them (D16). +// restart that adopts them. func projectParameterGroup(rec *DBInstanceRecord) []*rds.DBParameterGroupStatus { if rec.DBParameterGroupName == "" { return nil diff --git a/spinifex/handlers/rds/describe_test.go b/spinifex/handlers/rds/describe_test.go index 1635f9e87..45131980d 100644 --- a/spinifex/handlers/rds/describe_test.go +++ b/spinifex/handlers/rds/describe_test.go @@ -316,7 +316,7 @@ func TestProjectDBInstance_ReportsTheParameterGroupApplyStatus(t *testing.T) { assert.Equal(t, "in-sync", statusOf(rec)) - // D16: static settings are in the engine's config but not in effect until + // Static settings are in the engine's config but not in effect until // the restart that adopts them. rec.PendingRebootParameters = []string{"shared_buffers"} assert.Equal(t, "pending-reboot", statusOf(rec)) diff --git a/spinifex/handlers/rds/dns.go b/spinifex/handlers/rds/dns.go index 6e5145d3b..d661b7ea7 100644 --- a/spinifex/handlers/rds/dns.go +++ b/spinifex/handlers/rds/dns.go @@ -9,7 +9,7 @@ import ( ) // The vanity hostname for a DB instance, or "" on a deployment with no base -// domain — where the endpoint is the bare ENI IP instead (D6). +// domain — where the endpoint is the bare ENI IP instead. func (s *Service) dnsName(accountID, dbInstanceIdentifier string) string { if s.baseDomain == "" { return "" diff --git a/spinifex/handlers/rds/engine.go b/spinifex/handlers/rds/engine.go index ddc0269d0..479402f2a 100644 --- a/spinifex/handlers/rds/engine.go +++ b/spinifex/handlers/rds/engine.go @@ -64,7 +64,7 @@ func SupportedEngines() []string { // An empty version takes the pin. A supplied one must name the pinned major, // with or without a minor, since a mismatch would silently run a version the -// customer did not ask for (D19). +// customer did not ask for. func (e Engine) ValidateVersion(version string) error { v := strings.TrimSpace(version) if v == "" || v == e.MajorVersion { @@ -118,7 +118,7 @@ func (e Engine) ValidateUsernameNotReserved(username string) error { } // Bounds only. The password is never inspected beyond this and never stored in -// cleartext past the first bootstrap fetch (D8). +// cleartext past the first bootstrap fetch. func ValidateMasterUserPassword(password string) error { switch { case password == "": diff --git a/spinifex/handlers/rds/engine_test.go b/spinifex/handlers/rds/engine_test.go index 1d86131b6..c2490184a 100644 --- a/spinifex/handlers/rds/engine_test.go +++ b/spinifex/handlers/rds/engine_test.go @@ -25,7 +25,7 @@ func TestLookupEngine(t *testing.T) { assert.Equal(t, []string{"postgres"}, SupportedEngines()) } -// D19: a version other than the pinned one would be served by an image that is +// A version other than the pinned one would be served by an image that is // not the one asked for, so it is rejected rather than quietly substituted. func TestEngineValidateVersion(t *testing.T) { engine, err := LookupEngine("postgres") diff --git a/spinifex/handlers/rds/launch.go b/spinifex/handlers/rds/launch.go index 8090b4a08..800567a4c 100644 --- a/spinifex/handlers/rds/launch.go +++ b/spinifex/handlers/rds/launch.go @@ -113,7 +113,7 @@ type LaunchInput struct { RequireEncryptedData bool // A replace re-uses the DB instance's persisted customer ENI and data - // volume instead of minting new ones (D5/D9): the endpoint address and the + // volume instead of minting new ones: the endpoint address and the // datadir are the identity that must survive the VM. Both empty is a // create, which builds them. ExistingCustomerENI string diff --git a/spinifex/handlers/rds/lifecycle.go b/spinifex/handlers/rds/lifecycle.go index b32f93247..cc517a771 100644 --- a/spinifex/handlers/rds/lifecycle.go +++ b/spinifex/handlers/rds/lifecycle.go @@ -45,8 +45,8 @@ const instanceCommandTimeout = 90 * time.Second // How often the fleet is re-read while a stop is settling. const vmStopPollInterval = 500 * time.Millisecond -// Reboots the engine, applying any static parameters stored pending-reboot -// (D16). ForceFailover is rejected outright: there is no standby to fail over +// Reboots the engine, applying any static parameters stored pending-reboot. +// ForceFailover is rejected outright: there is no standby to fail over // to, and silently ignoring it would report a failover that never happened. func (s *Service) RebootDBInstance(ctx context.Context, input *rds.RebootDBInstanceInput, accountID string) (*rds.RebootDBInstanceOutput, error) { if input == nil { @@ -93,12 +93,12 @@ func (s *Service) RebootDBInstance(ctx context.Context, input *rds.RebootDBInsta // Stops the engine and then the VM. The data volume, the customer ENI and its // IP, and the DNS record are all retained, so a start comes back on the same -// datadir at the same address (D5/D9). +// datadir at the same address. func (s *Service) StopDBInstance(ctx context.Context, input *rds.StopDBInstanceInput, accountID string) (*rds.StopDBInstanceOutput, error) { if input == nil { return nil, awserrors.Errorf(awserrors.ErrorInvalidParameterValue, "empty request") } - // A pre-stop snapshot is rds-8's; accepting it here would report a snapshot + // A pre-stop snapshot is already in progress; accepting it here would report a snapshot // the customer would then not find. if aws.StringValue(input.DBSnapshotIdentifier) != "" { return nil, unimplemented("DBSnapshotIdentifier", "taking a snapshot as part of a stop is not implemented yet") diff --git a/spinifex/handlers/rds/lifecycle_test.go b/spinifex/handlers/rds/lifecycle_test.go index 7bb126c62..dcf500431 100644 --- a/spinifex/handlers/rds/lifecycle_test.go +++ b/spinifex/handlers/rds/lifecycle_test.go @@ -327,7 +327,7 @@ func TestRebootDBInstance_StopsTheEngineThenTheVM(t *testing.T) { assert.Equal(t, StatusRebooting, h.record(t).Status) } -// D16: the static parameters are already in the engine's config, so the restart +// The static parameters are already in the engine's config, so the restart // is what applies them and the record stops advertising them. func TestRebootDBInstance_ClearsThePendingRebootParameters(t *testing.T) { h := newLifecycleHarness(t, false) @@ -343,7 +343,7 @@ func TestRebootDBInstance_ClearsThePendingRebootParameters(t *testing.T) { assert.Contains(t, eventMessages(h.events(t)), "Applied the parameters that were pending a reboot.") } -// D19: there is no standby to fail over to, so silently ignoring the flag would +// There is no standby to fail over to, so silently ignoring the flag would // report a failover that never happened. func TestRebootDBInstance_RejectsForceFailover(t *testing.T) { h := newLifecycleHarness(t, false) @@ -466,7 +466,7 @@ func TestReconciler_DoesNotCallAStillRunningVMStopped(t *testing.T) { assert.Equal(t, StatusStopping, h.record(t).Status) } -// D5/D9: the data volume, the customer ENI and the DNS record are all retained, +// The data volume, the customer ENI and the DNS record are all retained, // so a start comes back on the same datadir at the same address. func TestStopDBInstance_RetainsTheEndpointAndTheVolume(t *testing.T) { h := newLifecycleHarness(t, false) diff --git a/spinifex/handlers/rds/modify.go b/spinifex/handlers/rds/modify.go index c3e4ef317..041e569f5 100644 --- a/spinifex/handlers/rds/modify.go +++ b/spinifex/handlers/rds/modify.go @@ -23,7 +23,7 @@ import ( type modifyPlan struct { // Applied on the spot whatever ApplyImmediately says, because none of them // interrupts service and AWS applies them as soon as possible too. The - // password especially: D8 forbids persisting the cleartext, so there is + // password especially: cleartext is never persisted, so there is // nothing that could be deferred. MasterUserPassword string SecurityGroupIDs []string @@ -65,7 +65,7 @@ func (p *modifyPlan) empty() bool { // Changes a live DB instance. The non-disruptive settings land immediately; a // storage grow, a class change or a parameter-group change is applied now when // ApplyImmediately is set and otherwise recorded in PendingModifiedValues for -// the maintenance window (rds-9) to drain through applyPendingModifications. +// the maintenance window to drain through applyPendingModifications. // // The endpoint survives every path: the data volume, the customer ENI and its // address, and the DNS A-record are untouched by a grow and by a class change. @@ -221,7 +221,7 @@ func (s *Service) planModify(ctx context.Context, input *rds.ModifyDBInstanceInp if input.DeletionProtection != nil && aws.BoolValue(input.DeletionProtection) != rec.DeletionProtection { plan.DeletionProtection = input.DeletionProtection } - // Nothing acts on it (D19), but a value the record does not adopt is one the + // Nothing acts on it, but a value the record does not adopt is one the // next describe contradicts, and the client re-sends it forever. if input.AutoMinorVersionUpgrade != nil && aws.BoolValue(input.AutoMinorVersionUpgrade) != rec.AutoMinorVersionUpgrade { plan.AutoMinorVersionUpgrade = input.AutoMinorVersionUpgrade @@ -255,7 +255,7 @@ func (s *Service) planSecurityGroups(ctx context.Context, accountID string, rec return requested, nil } -// The rds-9 fields, now validated and effective rather than record-only. Both +// The backup fields, now validated and effective rather than record-only. Both // windows are resolved as a pair even when the request names one, because AWS's // non-overlap rule is about the pair: a request moving the backup window onto the // stored maintenance window has to be rejected too. @@ -311,7 +311,7 @@ func (s *Service) applyImmediateModify(ctx context.Context, kv jetstream.KeyValu return nil } // Never persisted anywhere: an unreachable agent fails the call rather than - // leaving cleartext queued for a later window (D8). + // leaving cleartext queued for a later window. if plan.MasterUserPassword != "" { if err := s.setMasterPassword(ctx, accountID, rec.DBInstanceIdentifier, rec.MasterUsername, plan.MasterUserPassword); err != nil { return awserrors.Errorf(awserrors.ErrorDBInstanceInvalidState, @@ -404,7 +404,7 @@ func (s *Service) reassociateSecurityGroups(ctx context.Context, accountID strin return nil } -// D19: a supported action carrying an unimplemented parameter must not silently +// A supported action carrying an unimplemented parameter must not silently // drop it. Every rejection below is a parameter whose omission would create a // false safety, security or availability guarantee; the inert ones — // AutoMinorVersionUpgrade, CopyTagsToSnapshot, Performance Insights, Enhanced diff --git a/spinifex/handlers/rds/modify_test.go b/spinifex/handlers/rds/modify_test.go index 142b5ffd2..8bae0d6a1 100644 --- a/spinifex/handlers/rds/modify_test.go +++ b/spinifex/handlers/rds/modify_test.go @@ -145,7 +145,7 @@ func TestModifyDBInstance_AppliesTheNonDisruptiveSettingsAtOnce(t *testing.T) { assert.Nil(t, rec.PendingModifiedValues) } -// D8: only the fact of the rotation is recorded. A password that reached KV +// Only the fact of the rotation is recorded. A password that reached KV // would be readable by anything that can read the bucket, forever. func TestModifyDBInstance_NeverPersistsTheRotatedPassword(t *testing.T) { h := newModifyHarness(t) @@ -231,7 +231,7 @@ func TestModifyDBInstance_IgnoresTheSecurityGroupsAlreadyAttached(t *testing.T) assert.Empty(t, h.launch.enis.modified) } -// D12: storage is grow-only, and a request to shrink must be refused before the +// Storage is grow-only, and a request to shrink must be refused before the // instance moves anywhere — a rejected request cannot cost a running database // its availability. func TestModifyDBInstance_RejectsAStorageShrinkBeforeAnythingMoves(t *testing.T) { @@ -257,7 +257,7 @@ func TestModifyDBInstance_RejectsAStorageShrinkBeforeAnythingMoves(t *testing.T) // Terraform sends the whole body on every apply, so a size that repeats the // current one accompanies unrelated changes constantly. Failing it would fail -// every one of them; it contributes nothing to the plan instead. +// every one of them; it contributes nothing to the resulting configuration instead. func TestModifyDBInstance_TreatsTheCurrentStorageSizeAsNoChange(t *testing.T) { h := newModifyHarness(t) seedInstance(t, h.svc, modifiableRecord()) @@ -296,7 +296,7 @@ func TestModifyDBInstance_IsANoOpWhenNothingDiffers(t *testing.T) { assert.Nil(t, h.record(t).PendingModifiedValues) } -// D15: the db.* classes are a facade over the platform's instance types, so a +// The db.* classes are a facade over the platform's instance types, so a // class with nothing behind it is rejected with the set that has. func TestModifyDBInstance_RejectsAnUnmappedInstanceClass(t *testing.T) { h := newModifyHarness(t) @@ -312,7 +312,7 @@ func TestModifyDBInstance_RejectsAnUnmappedInstanceClass(t *testing.T) { assert.Equal(t, StatusAvailable, h.record(t).Status) } -// Until rds-7 materialises real groups the implicit default is the only name +// Until real groups are materialised the implicit default is the only name // that resolves, so any other one names a group that does not exist. func TestModifyDBInstance_RejectsAnUnknownParameterGroup(t *testing.T) { h := newModifyHarness(t) @@ -327,7 +327,7 @@ func TestModifyDBInstance_RejectsAnUnknownParameterGroup(t *testing.T) { assert.Nil(t, h.record(t).PendingModifiedValues) } -// The rds-9 fields are stored rather than acted on, but a value outside AWS's +// These fields are stored rather than acted on, but a value outside AWS's // range would fail in a maintenance window nobody is watching. func TestModifyDBInstance_RejectsAnOutOfRangeBackupRetention(t *testing.T) { h := newModifyHarness(t) @@ -342,7 +342,7 @@ func TestModifyDBInstance_RejectsAnOutOfRangeBackupRetention(t *testing.T) { assert.Zero(t, h.record(t).BackupRetentionPeriod) } -// D19: a supported action carrying a parameter this platform does not implement +// A supported action carrying a parameter this platform does not implement // is rejected, never served with the parameter quietly dropped. Each of these // would otherwise leave the customer believing in a guarantee they do not have. func TestModifyDBInstance_RejectsTheUnimplementedParameters(t *testing.T) { @@ -397,7 +397,7 @@ func TestModifyDBInstance_AcceptsTheStorageTypeItAlreadyHas(t *testing.T) { assert.True(t, h.record(t).DeletionProtection) } -// A disruptive change without ApplyImmediately is recorded and left for rds-9's +// A disruptive change without ApplyImmediately is recorded and left for the // maintenance window: the database keeps serving until then. func TestModifyDBInstance_DefersADisruptiveChangeToTheMaintenanceWindow(t *testing.T) { h := newModifyHarness(t) diff --git a/spinifex/handlers/rds/paramcatalog.go b/spinifex/handlers/rds/paramcatalog.go index af4fafde1..9c15e5d00 100644 --- a/spinifex/handlers/rds/paramcatalog.go +++ b/spinifex/handlers/rds/paramcatalog.go @@ -19,7 +19,7 @@ import ( // is a boot loop, and the bad config is on the persistent data volume. // When a parameter takes effect. Static settings are stored and reported -// pending-reboot; dynamic ones are adopted by a reload (D16). +// pending-reboot; dynamic ones are adopted by a reload. const ( ApplyTypeStatic = "static" ApplyTypeDynamic = "dynamic" @@ -50,7 +50,7 @@ const ( // One catalog entry. Exactly one of Default and DefaultFor is set: a literal for // the parameters whose engine default is size-independent, and a formula over -// the instance class's memory for the ones that are not (D20). +// the instance class's memory for the ones that are not. type ParameterSpec struct { Name string DataType string @@ -441,7 +441,7 @@ func CatalogParameterNames() []string { } // The engine default for one parameter at one instance class: the literal, or -// the formula evaluated against the class's memory (D20). +// the formula evaluated against the class's memory. func (s ParameterSpec) DefaultAt(memoryMiB int64) string { if s.DefaultFor != nil { return s.DefaultFor(memoryMiB) diff --git a/spinifex/handlers/rds/paramcatalog_test.go b/spinifex/handlers/rds/paramcatalog_test.go index a9e11af7c..9132f3563 100644 --- a/spinifex/handlers/rds/paramcatalog_test.go +++ b/spinifex/handlers/rds/paramcatalog_test.go @@ -53,8 +53,8 @@ func TestParameterCatalog_EntriesAreWellFormed(t *testing.T) { } } -// D20: the size-derived defaults have to actually move with the class, or the -// formulas are decoration and one end of the D15 range is mis-tuned. +// The size-derived defaults have to actually move with the class, or the +// formulas are decoration and one end of the supported range is mis-tuned. func TestParameterCatalog_SizeDerivedDefaultsScaleWithClassMemory(t *testing.T) { smallest, err := classMemoryMiB("db.t3.micro") require.NoError(t, err) diff --git a/spinifex/handlers/rds/parametergroup.go b/spinifex/handlers/rds/parametergroup.go index f423d889b..f65f20ec1 100644 --- a/spinifex/handlers/rds/parametergroup.go +++ b/spinifex/handlers/rds/parametergroup.go @@ -129,7 +129,7 @@ func (s *Service) DescribeDBParameterGroups(ctx context.Context, input *rds.Desc } // Stores validated overrides, one KV key per parameter, so a modify touching one -// setting cannot clobber a concurrent change to another (D3). The whole request +// setting cannot clobber a concurrent change to another. The whole request // is validated before anything is written: a batch with one bad value must leave // the group exactly as it was rather than half-applied. func (s *Service) ModifyDBParameterGroup(ctx context.Context, input *rds.ModifyDBParameterGroupInput, accountID string) (*rds.DBParameterGroupNameMessage, error) { @@ -186,7 +186,7 @@ func (s *Service) ModifyDBParameterGroup(ctx context.Context, input *rds.ModifyD // Merges catalog defaults with the group's stored overrides. The defaults are // evaluated at the smallest supported class, because a parameter group is not // bound to an instance: a customer reading a group's values before creating -// anything has to see literals, and D20 keeps formulas off this surface. +// anything has to see literals, and formulas stay off this surface. func (s *Service) DescribeDBParameters(ctx context.Context, input *rds.DescribeDBParametersInput, accountID string) (*rds.DescribeDBParametersOutput, error) { if input == nil { return nil, awserrors.Errorf(awserrors.ErrorInvalidParameterValue, "empty request") @@ -428,7 +428,7 @@ func parameterSource(isOverride bool) string { } // A computed default is reported as engine-default with its literal value, never -// as the formula that produced it (D20). +// as the formula that produced it. func projectParameter(spec ParameterSpec, value string, isOverride bool) *rds.Parameter { out := &rds.Parameter{ ParameterName: aws.String(spec.Name), diff --git a/spinifex/handlers/rds/parametergroup_test.go b/spinifex/handlers/rds/parametergroup_test.go index de8485bfb..db3f19ab9 100644 --- a/spinifex/handlers/rds/parametergroup_test.go +++ b/spinifex/handlers/rds/parametergroup_test.go @@ -269,7 +269,7 @@ func TestModifyDBParameterGroup_RejectsAnUnknownGroup(t *testing.T) { "the code has to survive resolution or the client sees a 500") } -// D20: a computed default reaches the customer as the literal it evaluated to, +// A computed default reaches the customer as the literal it evaluated to, // never as the formula that produced it. func TestDescribeDBParameters_ReportsComputedDefaultsAsLiterals(t *testing.T) { h := newCreateHarness(t, testBaseDomain) diff --git a/spinifex/handlers/rds/pending.go b/spinifex/handlers/rds/pending.go index d72c5ffa0..fd4dc4fb9 100644 --- a/spinifex/handlers/rds/pending.go +++ b/spinifex/handlers/rds/pending.go @@ -16,7 +16,7 @@ import ( // modify that quietly does something different from the one the customer // watched happen. // -// rds-9 owns the trigger: its window machinery — parsing, deterministic +// The backup scheduler owns the trigger: its window machinery — parsing, deterministic // assignment, a persisted last-fired stamp, exactly-once firing across leader // churn — is the same mechanism a maintenance window needs, so it is built once // there and calls this. @@ -35,7 +35,7 @@ func (s *Service) applyPendingModifications(ctx context.Context, kv jetstream.Ke // puts any statically-scoped setting into effect. // // A class change re-derives every size-derived default, so the set is - // recomputed when either the group or the class moves (D20). It is resolved + // recomputed when either the group or the class moves. It is resolved // against the class the instance is becoming: the include lives on the data // volume, so it is the replacement VM that adopts it. if pending.DBParameterGroupName != "" || pending.DBInstanceClass != "" { @@ -124,7 +124,7 @@ func (s *Service) applyPendingModifications(ctx context.Context, kv jetstream.Ke // Re-resolves the effective set and installs it into the engine's config, // recording the settings the engine accepted but will not honour until it -// restarts (D16). The set lives on the data volume, so it survives the VM +// restarts. The set lives on the data volume, so it survives the VM // replace a class change performs and needs no second apply afterwards. // // A re-resolve, never a merge: the whole set is recomputed from the catalog and diff --git a/spinifex/handlers/rds/pending_test.go b/spinifex/handlers/rds/pending_test.go index bab5f14cc..3ae2d98a7 100644 --- a/spinifex/handlers/rds/pending_test.go +++ b/spinifex/handlers/rds/pending_test.go @@ -44,7 +44,7 @@ func TestApplyPendingModifications_GrowsStorageOnTheSameVM(t *testing.T) { assert.Nil(t, stored.PendingModifiedValues.AllocatedStorage) } -// D15: a class change is a VM replace, and a grow asked for alongside it rides +// A class change is a VM replace, and a grow asked for alongside it rides // the same outage rather than opening a second one. func TestApplyPendingModifications_ClassChangeReplacesTheVMAndCarriesTheGrow(t *testing.T) { h := newModifyHarness(t) @@ -71,7 +71,7 @@ func TestApplyPendingModifications_ClassChangeReplacesTheVMAndCarriesTheGrow(t * assert.True(t, stored.PendingModifiedValues.FilesystemGrowPending) } -// D16: the parameters go in while the engine this modify started against is +// The parameters go in while the engine this modify started against is // still the one running, so the restart that follows is what adopts the // statically-scoped ones. func TestApplyPendingModifications_AppliesTheParametersBeforeTheOutage(t *testing.T) { @@ -119,10 +119,10 @@ func TestApplyPendingModifications_KeepsThePendingRebootParametersWithoutAnOutag assert.Equal(t, []string{"shared_buffers"}, h.record(t).PendingRebootParameters) } -// D16: a class change re-resolves the size-derived defaults and the replacement +// A class change re-resolves the size-derived defaults and the replacement // VM boots on them, so the record must not report a change that has landed — // the customer would reboot a healthy database to clear it, and Terraform would -// see it on every plan. +// see it in every configuration read. func TestApplyPendingModifications_ClassChangeClearsThePendingRebootParameters(t *testing.T) { h := newModifyHarness(t) h.agent.replyWith("shared_buffers") @@ -308,7 +308,7 @@ func TestReconciler_RetriesAFailedModifyInsideTheBudget(t *testing.T) { assert.Equal(t, int64(50), h.record(t).AllocatedStorage) } -// D20: the size-derived defaults are the reason a class change has to re-resolve +// The size-derived defaults are the reason a class change has to re-resolve // rather than carry the old set forward — a shared_buffers computed for the old // class is wrong at the new one in whichever direction the class moved. func TestApplyPendingModifications_ReResolvesTheParametersForTheNewClass(t *testing.T) { diff --git a/spinifex/handlers/rds/reconciler.go b/spinifex/handlers/rds/reconciler.go index dd799ccf6..95f9725ef 100644 --- a/spinifex/handlers/rds/reconciler.go +++ b/spinifex/handlers/rds/reconciler.go @@ -71,7 +71,7 @@ type InstanceStateResolver interface { // Its responsibilities are the transitions no single API call can finish — the // ones it drives itself and the ones whose caller died partway through — plus // the failure classifier that gives a settled instance an honest health state. -// The backup sweep (rds-9) extends the same loop. +// The backup sweep extends the same loop. type Reconciler struct { svc *Service holder string @@ -436,7 +436,7 @@ func (r *Reconciler) reconcileBackingUp(ctx context.Context, kv jetstream.KeyVal return r.transition(ctx, kv, rev, rec, resume, "") } -// The two scheduled passes (rds-9): the automated backup its backup window is +// The two scheduled passes: the automated backup's backup window is // due, and the deferred modify its maintenance window opens. Both ride the leader // lease, and both are driven from a persisted stamp rather than a timer, so a // leader change cannot fire either of them twice for one window. diff --git a/spinifex/handlers/rds/records.go b/spinifex/handlers/rds/records.go index e61f98e7a..cd100b4b0 100644 --- a/spinifex/handlers/rds/records.go +++ b/spinifex/handlers/rds/records.go @@ -24,14 +24,14 @@ type DBInstanceRecord struct { MasterUsername string `json:"masterUsername"` Port int64 `json:"port"` - // A one-way marker (D8). A rotated password is handed to the agent over the + // A one-way marker. A rotated password is handed to the agent over the // command channel and never persisted, so this records only that it changed. MasterPasswordUpdatedAt *time.Time `json:"masterPasswordUpdatedAt,omitempty"` - // Blocks DeleteDBInstance outright (D18). Settable at create and modify. + // Blocks DeleteDBInstance outright. Settable at create and modify. DeletionProtection bool `json:"deletionProtection,omitempty"` - // Inert (D19) — the engine version is pinned, so nothing upgrades either way. + // Inert — the engine version is pinned, so nothing upgrades either way. // Recorded anyway because a describe that does not echo it back reads as // false against a Terraform schema that defaults it to true, and the plan // then never settles on a change no modify can deliver. @@ -106,7 +106,7 @@ type DBInstanceRecord struct { // When the classifier first observed the instance dark, and the timestamp the // failure grace window is measured from. Persisted rather than held in leader // memory so a leader change does not restart the clock. Cleared only by a - // healthy heartbeat or an explicit lifecycle op (D13). + // healthy heartbeat or an explicit lifecycle operation. UnhealthySince *time.Time `json:"unhealthySince,omitempty"` // When the lifecycle op that put the instance in its current transitional @@ -128,7 +128,7 @@ type DBInstanceRecord struct { RestoredFromDBSnapshot string `json:"restoredFromDbSnapshot,omitempty"` // Static parameters written to the engine's config but not yet in effect. - // Cleared by the reboot that applies them (D16). + // Cleared by the reboot that applies them. PendingRebootParameters []string `json:"pendingRebootParameters,omitempty"` // Inline rather than a separate key space, so the record delete that ends the @@ -146,10 +146,10 @@ type DBInstanceRecord struct { // each is recorded before the work starts and cleared as it lands. That makes // one structure serve both meanings AWS gives PendingModifiedValues — a // deferred change waiting for its maintenance window, and an in-flight change a -// crashed leader has to be able to finish (D12/D15/D16). +// crashed leader has to be able to finish. // -// MasterUserPassword is deliberately absent: D8 forbids persisting the -// cleartext, and AWS applies a password change as soon as possible regardless +// MasterUserPassword is deliberately absent: cleartext is never persisted, +// and AWS applies a password change as soon as possible regardless // of ApplyImmediately, so there is nothing to defer. type PendingModifiedValues struct { AllocatedStorage *int64 `json:"allocatedStorage,omitempty"` @@ -229,7 +229,7 @@ const ( // The snapshot operation holding a DB instance, written under the same CAS that // moves it to backing-up so a second request is rejected rather than queued. An -// rds-9 automated snapshot and a manual one serialise against each other here. +// An automated snapshot and a manual one serialise against each other here. type SnapshotOperation struct { DBSnapshotIdentifier string `json:"dbSnapshotIdentifier"` // Where the instance goes when the snapshot finishes. Recorded rather than @@ -282,7 +282,7 @@ type DBSnapshotRecord struct { // True when the engine was still writing as it was taken, so a restore // replays WAL. A final snapshot is taken with the engine already down, so it - // is never crash-consistent; rds-8's quiesce fallback is what sets this. + // is never crash-consistent; the quiesce fallback is what sets this. CrashConsistent bool `json:"crashConsistent,omitempty"` Tags map[string]string `json:"tags,omitempty"` @@ -307,8 +307,8 @@ type AutomatedBackupRecord struct { } // A data volume that outlived its DB instance because a COW snapshot still -// references its chunks (D10). The last DeleteDBSnapshot to empty Snapshots -// deletes it; rds-9's reaper is the backstop for a crash in between. +// references its chunks. The last DeleteDBSnapshot to empty Snapshots +// deletes it; the retention reaper is the backstop for a crash in between. type RetainedVolumeRecord struct { VolumeID string `json:"volumeId"` AccountID string `json:"accountId"` @@ -365,7 +365,7 @@ func (r *DBSubnetGroupRecord) SetTags(tags map[string]string) { r.Tags = tags } // The db-parameter-groups/{name}/meta record. The values themselves live one key // each under .../params/, so a modify touching one parameter cannot clobber a -// concurrent change to another (D3). +// concurrent change to another. type DBParameterGroupRecord struct { Name string `json:"name"` AccountID string `json:"accountId"` @@ -386,7 +386,7 @@ func (r *DBParameterGroupRecord) SetTags(tags map[string]string) { r.Tags = tags // One stored override, at db-parameter-groups/{name}/params/{key}. ApplyMethod // is the customer's request rather than a fact: whether a change lands live is -// decided by the parameter's own ApplyType (D16). +// decided by the parameter's own ApplyType. type DBParameterRecord struct { Name string `json:"name"` Value string `json:"value"` diff --git a/spinifex/handlers/rds/recovery.go b/spinifex/handlers/rds/recovery.go index b9683effb..96ad46304 100644 --- a/spinifex/handlers/rds/recovery.go +++ b/spinifex/handlers/rds/recovery.go @@ -17,7 +17,7 @@ const defaultFailureGrace = HeartbeatInterval // What the classifier decides about one instance. Reduced from the EKS // classifier's live/restartable/lost to healthy/failed, because v1.0 RDS reports -// failure rather than repairing it (D13). +// failure rather than repairing it. type healthVerdict int const ( @@ -54,7 +54,7 @@ type healthObservation struct { func classifyHealth(obs healthObservation) healthVerdict { // Every other state is owned by something already acting on the VM, and // stopped is legitimate rather than a failure. This is the interlock that - // keeps the classifier from fighting rds-5a/rds-5b over the same VM. + // keeps the classifier from fighting other recovery paths over the same VM. if obs.status != StatusAvailable && obs.status != StatusFailed { return verdictSkip } @@ -207,7 +207,7 @@ func (r *Reconciler) lastHeartbeat(accountID string, rec *DBInstanceRecord) (tim // Whether the record's VM is running, fanned out across the fleet. A nil // resolver answers true, which is what leaves failure undetectable on a node -// with EC2 unwired instead of declaring it on the heartbeat alone (D13). +// with EC2 unwired instead of declaring it on the heartbeat alone. func (r *Reconciler) vmRunning(ctx context.Context, accountID string, rec *DBInstanceRecord) (bool, error) { if r.svc.deps.InstanceState == nil || rec.InstanceID == "" { return true, nil diff --git a/spinifex/handlers/rds/replace.go b/spinifex/handlers/rds/replace.go index 87ecad2c0..dc26d0519 100644 --- a/spinifex/handlers/rds/replace.go +++ b/spinifex/handlers/rds/replace.go @@ -11,10 +11,10 @@ import ( ) // The one primitive a class change, a storage grow that rides the same outage, -// and rds-6's auto-recovery all reduce to: stop the engine, terminate the VM, -// launch a fresh one at the target size, re-attach the same data volume (D9) -// and the same persisted customer ENI (D5), and rewrite the rds-system index so -// the superseded agent can no longer authenticate as this instance (D3). +// and automatic recovery all reduce to: stop the engine, terminate the VM, +// launch a fresh one at the target size, re-attach the same data volume and +// persisted customer ENI, and rewrite the rds-system index so the superseded +// agent can no longer authenticate as this instance. // // The endpoint is untouched throughout: the customer ENI keeps its address, so // the DNS record and the serving cert's SANs stay correct and clients reconnect @@ -122,7 +122,7 @@ func (s *Service) replaceInstanceVM(ctx context.Context, kv jetstream.KeyValue, // A fresh COW clone of the engine AMI, re-attached to the identity the DB // instance owns. The new agent fetches its bootstrap config in attach mode -// (D8): it gets the port, the resolved parameters and a freshly minted serving +// It gets the port, the resolved parameters and a freshly minted serving // cert, but no master password, and rds-init skips initdb on the datadir it // finds already initialised. func (s *Service) launchReplacementVM(ctx context.Context, accountID string, rec *DBInstanceRecord, instanceType, profileARN string) (*LaunchOutput, error) { @@ -155,7 +155,7 @@ func (s *Service) launchReplacementVM(ctx context.Context, accountID string, rec // The instance index keys off the internal EC2 instance ID, which every replace // mints anew. The old entry is removed first: while it exists the superseded -// agent's IMDS credentials still resolve to this DB instance (D3). +// agent's IMDS credentials still resolve to this DB instance. func (s *Service) rewriteInstanceIndex(ctx context.Context, accountID string, rec *DBInstanceRecord, oldInstanceID, newInstanceID string) error { if oldInstanceID != "" && oldInstanceID != newInstanceID { if err := s.DeleteInstanceIndex(ctx, oldInstanceID); err != nil && !errors.Is(err, jetstream.ErrKeyNotFound) { diff --git a/spinifex/handlers/rds/replace_test.go b/spinifex/handlers/rds/replace_test.go index 932846b61..5dc0999ce 100644 --- a/spinifex/handlers/rds/replace_test.go +++ b/spinifex/handlers/rds/replace_test.go @@ -28,7 +28,7 @@ func seedReplaceable(t *testing.T, h *modifyHarness, rec DBInstanceRecord) DBIns return rec } -// D5/D9: the endpoint ENI and the datadir outlive the VM, so a replace adopts +// The endpoint ENI and the datadir outlive the VM, so a replace adopts // both. Minting either would move the address clients resolve or hand the // customer an empty database. func TestReplaceInstanceVM_ReusesTheEndpointENIAndDataVolume(t *testing.T) { @@ -101,7 +101,7 @@ func TestReplaceInstanceVM_StopsTheEngineAndTerminatesTheOldVMFirst(t *testing.T assert.Contains(t, h.launch.enis.deleted, "eni-sys01") } -// D3: while the old index entry exists the superseded agent's IMDS credentials +// While the old index entry exists the superseded agent's IMDS credentials // still resolve to this DB instance, so it goes before the new one lands. func TestReplaceInstanceVM_RewritesTheInstanceIndex(t *testing.T) { h := newModifyHarness(t) diff --git a/spinifex/handlers/rds/restore.go b/spinifex/handlers/rds/restore.go index b8f659da2..4b3e77fac 100644 --- a/spinifex/handlers/rds/restore.go +++ b/spinifex/handlers/rds/restore.go @@ -22,7 +22,7 @@ import ( // instance in every respect but its data: a new identifier, customer ENI, DNS // name, serving certificate and VM. What it inherits is the datadir — which // already holds the database, its roles and their password hashes, so the engine -// starts on it rather than running initdb (D10). +// starts on it rather than running initdb. func (s *Service) RestoreDBInstanceFromDBSnapshot(ctx context.Context, input *rds.RestoreDBInstanceFromDBSnapshotInput, accountID string) (out *rds.RestoreDBInstanceFromDBSnapshotOutput, err error) { if input == nil { return nil, awserrors.Errorf(awserrors.ErrorInvalidParameterValue, "empty request") @@ -236,7 +236,7 @@ func resolveRestoreRequest(input *rds.RestoreDBInstanceFromDBSnapshotInput, snap Port: port, MasterUsername: snapshot.MasterUsername, // Deliberately empty: the datadir already holds the master role and its - // password hash, so there is nothing for a bootstrap to set (D8). + // password hash, so there is nothing for a bootstrap to set. DBName: snapshot.DBName, SecurityGroupIDs: securityGroups, DBSubnetGroupName: subnetGroup, @@ -298,7 +298,7 @@ func resolveRestorePort(input *rds.RestoreDBInstanceFromDBSnapshotInput, snapsho return engine.DefaultPort, nil } -// D19: a parameter that would create a false safety, security or availability +// A parameter that would create a false safety, security or availability // guarantee is rejected rather than silently dropped. The list mirrors the one // at create, plus what only a restore can be asked for. func rejectUnimplementedRestore(input *rds.RestoreDBInstanceFromDBSnapshotInput) error { @@ -347,7 +347,7 @@ func rejectUnimplementedRestore(input *rds.RestoreDBInstanceFromDBSnapshotInput) // The reserved record for a restored instance: everything the request and the // snapshot decided, with the bootstrap marked consumed so the agent's first -// fetch returns attach rather than a password it would use to run initdb (D8). +// fetch returns attach rather than a password it would use to run initdb. func newRestoredDBInstanceRecord(accountID string, req *validatedCreate, placement *endpointPlacement, parameters []Parameter, snapshot *DBSnapshotRecord) DBInstanceRecord { rec := newDBInstanceRecord(accountID, req, placement, parameters) diff --git a/spinifex/handlers/rds/restore_test.go b/spinifex/handlers/rds/restore_test.go index adca56542..d178b2b99 100644 --- a/spinifex/handlers/rds/restore_test.go +++ b/spinifex/handlers/rds/restore_test.go @@ -61,7 +61,7 @@ func TestRestoreDBInstanceFromDBSnapshot_BuildsANewInstanceOnTheSnapshotsData(t assert.Equal(t, testSnapshotID, stored.RestoredFromDBSnapshot) assert.True(t, stored.StorageEncrypted) - // D8: the datadir already holds the master role and its password hash, so + // The datadir already holds the master role and its password hash, so // the agent's first bootstrap fetch has to attach rather than run initdb. assert.True(t, stored.Bootstrap.Consumed) require.NotNil(t, stored.Bootstrap.ConsumedAt) @@ -201,7 +201,7 @@ func TestRestoreDBInstanceFromDBSnapshot_RejectsASnapshotStillBeingTaken(t *test assert.Contains(t, err.Error(), awserrors.ErrorDBSnapshotInvalidState) } -// D19: a parameter that would create a false safety, security or availability +// A parameter that would create a false safety, security or availability // guarantee is rejected rather than silently dropped. func TestRestoreDBInstanceFromDBSnapshot_RejectsUnimplementedParameters(t *testing.T) { h := newSnapshotHarness(t, false) diff --git a/spinifex/handlers/rds/service.go b/spinifex/handlers/rds/service.go index 6fe51ff1c..b08e0a8ed 100644 --- a/spinifex/handlers/rds/service.go +++ b/spinifex/handlers/rds/service.go @@ -37,10 +37,10 @@ type Deps struct { // Takes the final snapshot at delete, and reports which snapshots still // reference a data volume before it can be deleted. Snapshots snapshotProvider - // Grows the data volume behind an AllocatedStorage modify (D12). + // Grows the data volume behind an AllocatedStorage modify. Storage volumeResizer // The northstar base zone. Empty means no vanity hostname, and the endpoint - // is the customer-ENI IP instead (D6). + // is the customer-ENI IP instead. BaseDomain string // Identifies this node in the reconciler lease. HolderID string diff --git a/spinifex/handlers/rds/snapshot.go b/spinifex/handlers/rds/snapshot.go index 44054e693..1518d30b1 100644 --- a/spinifex/handlers/rds/snapshot.go +++ b/spinifex/handlers/rds/snapshot.go @@ -20,7 +20,7 @@ import ( // The EC2 snapshot surface the RDS control plane drives. A DB snapshot is an // ec2.CreateSnapshot of the instance's data volume wrapped in an agent quiesce -// (D10); DescribeSnapshots is also what answers whether a volume is still +// consistent; DescribeSnapshots is also what answers whether a volume is still // referenced, which is what decides between deleting and retaining it. type snapshotProvider interface { CreateSnapshot(ctx context.Context, input *ec2.CreateSnapshotInput, accountID string) (*ec2.Snapshot, error) @@ -45,7 +45,7 @@ const ( // Takes a customer-requested snapshot of the instance's data volume. The engine // is held at a checkpoint for the length of it, so the captured datadir is a // checkpoint rather than a mid-write state — and if it cannot be, the snapshot -// is still taken and reported as crash consistent (D10). +// is still taken and reported as crash consistent. func (s *Service) CreateDBSnapshot(ctx context.Context, input *rds.CreateDBSnapshotInput, accountID string) (*rds.CreateDBSnapshotOutput, error) { req, err := validateCreateSnapshotRequest(input) if err != nil { @@ -70,8 +70,8 @@ func (s *Service) CreateDBSnapshot(ctx context.Context, input *rds.CreateDBSnaps return &rds.CreateDBSnapshotOutput{DBSnapshot: s.projectDBSnapshot(record)}, nil } -// The one snapshot path (D10). A customer's CreateDBSnapshot and an rds-9 -// automated backup differ only in who asks and in the type stamped on the record; +// The one snapshot path. A customer's CreateDBSnapshot and an automated +// backup differ only in who asks and in the type stamped on the record; // the quiesce, the node-addressed EC2 snapshot, the db-snapshots record and the // per-instance in-flight guard are the same for both. // @@ -147,7 +147,7 @@ func (s *Service) snapshotDataVolume(ctx context.Context, accountID string, rec // graceful stop, which is the checkpoint a quiesce would be forcing. if resume == StatusAvailable { if quiesceErr := s.quiesceEngine(ctx, accountID, rec.DBInstanceIdentifier, dbSnapshotIdentifier); quiesceErr != nil { - // D10: still a restorable backup, so it is taken and reported honestly + // Still a restorable backup, so it is taken and reported honestly // rather than refused. The engine replays WAL on restore. crashConsistent = true slog.WarnContext(ctx, "rds: the engine could not be quiesced; taking a crash-consistent snapshot", @@ -287,7 +287,7 @@ func (s *Service) DeleteDBSnapshot(ctx context.Context, input *rds.DeleteDBSnaps } // Removes a DB snapshot, its EC2 data and — when this was the last reference — the -// data volume behind it. Shared with rds-9's retention sweep, which cannot go +// data volume behind it. Shared with the retention sweep, which cannot go // through DeleteDBSnapshot: that rejects the rds: namespace automated snapshots // live in, so a customer can never delete one by hand. func (s *Service) removeDBSnapshot(ctx context.Context, kv jetstream.KeyValue, accountID string, rec *DBSnapshotRecord) error { @@ -388,7 +388,7 @@ func (s *Service) releaseRetainedVolume(ctx context.Context, kv jetstream.KeyVal } // Deletes a retained data volume once nothing holds it, or records the holders it -// still has. Reports whether the volume actually went, which is what lets rds-9's +// still has. Reports whether the volume actually went, which is what lets the // reaper count the ones it reclaimed. func (s *Service) reclaimRetainedVolume(ctx context.Context, kv jetstream.KeyValue, retained *RetainedVolumeRecord) (bool, error) { @@ -428,7 +428,7 @@ func (s *Service) reclaimRetainedVolume(ctx context.Context, kv jetstream.KeyVal return true, nil } -// The request as CreateDBSnapshot resolved it, or as rds-9's scheduler and the +// The request as CreateDBSnapshot resolved it, or as the scheduler and the // delete path's final-snapshot reservation construct it. SnapshotType is what the // record is stamped with, and the only thing separating an automated backup from // a manual snapshot once it exists. @@ -463,7 +463,7 @@ func validateCreateSnapshotRequest(input *rds.CreateDBSnapshotInput) (*validated }, nil } -// Returns the snapshot type to filter on, empty for "any". D19: a filter this +// Returns the snapshot type to filter on, empty for "any". A filter this // phase cannot honour is rejected rather than dropped, because a silently // unfiltered list reads as a complete answer. func validateDescribeSnapshotsRequest(input *rds.DescribeDBSnapshotsInput) (string, error) { @@ -608,7 +608,7 @@ func (s *Service) discardSnapshotRecord(ctx context.Context, kv jetstream.KeyVal // Moves the instance into backing-up and records the snapshot holding it in one // CAS, returning the status the instance goes back to. That write is the -// per-instance guard: a second snapshot, an rds-9 automated one or a lifecycle +// per-instance guard: a second snapshot, an automated one or a lifecycle // op finds the instance already backing-up and is rejected rather than queued. func (s *Service) beginSnapshotOperation(ctx context.Context, kv jetstream.KeyValue, rev uint64, rec *DBInstanceRecord, dbSnapshotIdentifier string) (Status, error) { diff --git a/spinifex/handlers/rds/snapshot_test.go b/spinifex/handlers/rds/snapshot_test.go index b33a0dd81..043f9a9ca 100644 --- a/spinifex/handlers/rds/snapshot_test.go +++ b/spinifex/handlers/rds/snapshot_test.go @@ -205,7 +205,7 @@ func TestCreateDBSnapshot_DoesNotQuiesceAStoppedInstance(t *testing.T) { assert.False(t, stored.CrashConsistent) } -// D10: a snapshot that could not be quiesced is still a restorable backup, so it +// A snapshot that could not be quiesced is still a restorable backup, so it // is taken and reported honestly rather than refused. func TestCreateDBSnapshot_FallsBackToCrashConsistentWhenTheQuiesceFails(t *testing.T) { h := newSnapshotHarness(t, true) @@ -334,7 +334,7 @@ func TestDescribeDBSnapshots_NamedSnapshotThatDoesNotExistIsAnError(t *testing.T assert.Contains(t, err.Error(), awserrors.ErrorDBSnapshotNotFound) } -// D19: a filter this phase cannot honour is rejected, because a silently +// A filter this phase cannot honour is rejected, because a silently // unfiltered list reads as a complete answer. func TestDescribeDBSnapshots_RejectsUnhonouredScoping(t *testing.T) { h := newSnapshotHarness(t, false) diff --git a/spinifex/handlers/rds/status.go b/spinifex/handlers/rds/status.go index 9c60dd94e..6d9017e7f 100644 --- a/spinifex/handlers/rds/status.go +++ b/spinifex/handlers/rds/status.go @@ -90,7 +90,7 @@ func CanTransition(from, to Status) bool { } // The snapshot's own lifecycle, separate from the instance's backing-up state -// (D4): the instance is derived from an in-flight control-plane operation, while +// The instance is derived from an in-flight control-plane operation, while // the snapshot record moves creating → available once the data exists. There is // no failed state — a snapshot that never completed is removed rather than kept // as an unrestorable record. diff --git a/spinifex/handlers/rds/storage.go b/spinifex/handlers/rds/storage.go index eb0bd2533..27e2a733f 100644 --- a/spinifex/handlers/rds/storage.go +++ b/spinifex/handlers/rds/storage.go @@ -12,7 +12,7 @@ import ( "github.com/mulgadc/spinifex/spinifex/utils" ) -// D12: ModifyVolume refuses a volume a running VM holds, so a storage grow is +// ModifyVolume refuses a volume a running VM holds, so a storage grow is // stop the engine, stop the VM, grow the volume, start the VM, and extend the // filesystem inside the guest. There is no online grow in v1, and a shrink is // rejected outright — as AWS rejects it. diff --git a/spinifex/handlers/rds/storage_test.go b/spinifex/handlers/rds/storage_test.go index 7cc0267b8..8f8a17e73 100644 --- a/spinifex/handlers/rds/storage_test.go +++ b/spinifex/handlers/rds/storage_test.go @@ -125,7 +125,7 @@ func TestGrowDataVolume_FailsWithoutAVolume(t *testing.T) { require.Error(t, h.svc.growDataVolume(t.Context(), "", 50)) } -// D12: ModifyVolume refuses a volume a running VM holds, so the order is the +// ModifyVolume refuses a volume a running VM holds, so the order is the // whole mechanism — engine down, VM down, grow, VM back. func TestGrowInstanceStorage_StopsTheEngineAndTheVMBeforeGrowing(t *testing.T) { h := newModifyHarness(t) diff --git a/spinifex/handlers/rds/userdata_test.go b/spinifex/handlers/rds/userdata_test.go index 8114aa35b..68ebe602b 100644 --- a/spinifex/handlers/rds/userdata_test.go +++ b/spinifex/handlers/rds/userdata_test.go @@ -43,7 +43,7 @@ func TestBuildAgentUserData(t *testing.T) { } } -// D8: the master password reaches the guest only over GetDBBootstrapConfig, and +// The master password reaches the guest only over GetDBBootstrapConfig, and // the agent's gateway credentials come from IMDS — so nothing secret is written // to a data source any process on the VM can read. func TestBuildAgentUserDataCarriesNoCredentials(t *testing.T) { diff --git a/spinifex/handlers/rds/validate.go b/spinifex/handlers/rds/validate.go index 278c6d5d7..1a7ceee17 100644 --- a/spinifex/handlers/rds/validate.go +++ b/spinifex/handlers/rds/validate.go @@ -55,7 +55,7 @@ type validatedCreate struct { AutoMinorVersionUpgrade bool // Automated backups as they will be in force: the retention defaulted when the // request names none, and both windows in canonical text — assigned from the - // instance identifier when unnamed, never left empty (rds-9). + // instance identifier when unnamed, never left empty. BackupRetentionPeriod int64 PreferredBackupWindow string PreferredMaintenanceWindow string @@ -183,7 +183,7 @@ func (s *Service) validateCreateRequest(input *rds.CreateDBInstanceInput) (*vali } // AWS's own identifier rules. Enforcing them here keeps the identifier usable -// as a DNS label, which D6 makes it. +// as a DNS label, which makes it suitable for hostname use. func validateDBInstanceIdentifier(id string) error { switch { case id == "": @@ -208,7 +208,7 @@ func validateDBInstanceIdentifier(id string) error { return nil } -// D19: a supported action carrying an unimplemented parameter must not silently +// A supported action carrying an unimplemented parameter must not silently // drop it. Each rejection below is a parameter whose omission would create a // false safety, security or availability guarantee. Parameters that are merely // inert — AutoMinorVersionUpgrade, Performance Insights, Enhanced Monitoring, diff --git a/spinifex/handlers/sts/assume_role_test.go b/spinifex/handlers/sts/assume_role_test.go index 6ee2ce7b9..871a138e1 100644 --- a/spinifex/handlers/sts/assume_role_test.go +++ b/spinifex/handlers/sts/assume_role_test.go @@ -185,7 +185,7 @@ func TestAssumeRole_ExplicitDenyWinsOverAllow(t *testing.T) { caller := testCallerARN() // Allow listed first; Deny second. A single-pass "return on first Allow" - // loop would silently skip the Deny and grant the session — see plan §4. + // loop would silently skip the Deny and grant the session. policyAllowThenDeny := fmt.Sprintf(`{"Version":"2012-10-17","Statement":[ {"Effect":"Allow","Principal":{"AWS":"*"},"Action":"sts:AssumeRole"}, {"Effect":"Deny","Principal":{"AWS":%q},"Action":"sts:AssumeRole"} diff --git a/spinifex/handlers/sts/oidc_jwks_test.go b/spinifex/handlers/sts/oidc_jwks_test.go index 6c5b46da1..1a8f1d937 100644 --- a/spinifex/handlers/sts/oidc_jwks_test.go +++ b/spinifex/handlers/sts/oidc_jwks_test.go @@ -19,7 +19,7 @@ func TestParseEKSIssuerURL_Valid(t *testing.T) { // Cross-component contract: a token whose iss is built by ClusterOIDCIssuer // must parse cleanly via ParseEKSIssuerURL and resolve to the same -// (accountID, clusterName). This is the collision that bead 165.11 fixes. +// (accountID, clusterName). This is the collision the lookup must avoid. func TestParseEKSIssuerURL_RoundTripsClusterOIDCIssuer(t *testing.T) { issuer, err := handlers_eks.ClusterOIDCIssuer("https://10.0.0.1:9999", "au-mel-1", "123456789012", "my-cluster") require.NoError(t, err) diff --git a/spinifex/network/external/dhcp/kv.go b/spinifex/network/external/dhcp/kv.go index b4fbbb4c3..a18297866 100644 --- a/spinifex/network/external/dhcp/kv.go +++ b/spinifex/network/external/dhcp/kv.go @@ -17,7 +17,7 @@ import ( // KVBucketPrefix is the lease bucket's name prefix. The full bucket name // is BucketName(az), per-AZ to keep chassis-failover within the AZ scope -// (D7 in the design doc). +// as part of the DHCP lease record. const KVBucketPrefix = "spinifex-dhcp-leases" // BucketName returns the per-AZ lease bucket name. Empty az is allowed diff --git a/spinifex/network/external/dhcp/manager.go b/spinifex/network/external/dhcp/manager.go index 251ad8f44..15bb76eb3 100644 --- a/spinifex/network/external/dhcp/manager.go +++ b/spinifex/network/external/dhcp/manager.go @@ -23,7 +23,7 @@ const renewJitter = time.Second // postExpiryBackoff is the cool-off applied after a re-DORA fails post // lease expiry. Bounded — the manager keeps re-DORAing in the -// background until the server comes back (per plan §Failure modes). +// background until the server comes back. const postExpiryBackoff = 30 * time.Second // defaultAcquireSchedule is the per-attempt timeout schedule for the outer DORA diff --git a/spinifex/network/external/dhcp/pool_allocator.go b/spinifex/network/external/dhcp/pool_allocator.go index e39e86382..604f8e160 100644 --- a/spinifex/network/external/dhcp/pool_allocator.go +++ b/spinifex/network/external/dhcp/pool_allocator.go @@ -115,7 +115,7 @@ func (a *DHCPPoolAllocator) rememberHWAddr(clientID string, hw net.HardwareAddr) } // poolClientID picks the first non-empty AWS identifier. Mirrors the -// precedence documented in the plan: AllocationID > ENIID > InstanceID. +// precedence: AllocationID > ENIID > InstanceID. func poolClientID(req external.AllocateRequest) string { switch { case req.AllocationID != "": diff --git a/spinifex/network/external/static_pool_test.go b/spinifex/network/external/static_pool_test.go index e93f676af..462e6b276 100644 --- a/spinifex/network/external/static_pool_test.go +++ b/spinifex/network/external/static_pool_test.go @@ -180,7 +180,7 @@ func TestStaticPool_Release_OwnershipScoped(t *testing.T) { } // TestNextAvailableIP_SkipsGwLrpRange verifies the static allocator honors -// gw_lrp_range — addresses inside the reservation are skipped (siv-36). +// gw_lrp_range — addresses inside the reservation are skipped. func TestNextAvailableIP_SkipsGwLrpRange(t *testing.T) { rec := &PoolRecord{ PoolName: "wan", diff --git a/spinifex/services/awsgw/awsgw.go b/spinifex/services/awsgw/awsgw.go index 73486d4e6..9b60210db 100644 --- a/spinifex/services/awsgw/awsgw.go +++ b/spinifex/services/awsgw/awsgw.go @@ -308,7 +308,7 @@ func launchService(config *config.ClusterConfig) error { // are called from gateway/bedrock.go's fixed-arity route table. gateway_bedrock.SetWeightsResolver(gateway_bedrock.NewWeightsStore(js, len(config.Nodes))) - // Bedrock self-host endpoints: Phase 1 models are pinned, so their + // Bedrock self-host endpoints are pinned, so their // OpenAI-compatible base URLs come from static config. OCHRE_VLLM_ENDPOINTS // is a comma-separated list of modelId=baseURL pairs. bedrockEndpoints := parseBedrockEndpoints(os.Getenv("OCHRE_VLLM_ENDPOINTS")) diff --git a/spinifex/services/qmpcollector/qmpcollector.go b/spinifex/services/qmpcollector/qmpcollector.go index 39b61e93a..5b8cfa5ab 100644 --- a/spinifex/services/qmpcollector/qmpcollector.go +++ b/spinifex/services/qmpcollector/qmpcollector.go @@ -1,4 +1,4 @@ -// Package qmpcollector is the per-node guest-metrics producer (Goanna Phase 1): +// Package qmpcollector is the per-node guest-metrics producer: // it discovers running VMs via their qmp-telemetry-*.json sidecar files, polls // each VM's dedicated telemetry QMP socket (never the manager's control // socket) plus host tap counters, and publishes CloudWatch-mappable series to diff --git a/spinifex/services/spinifexui/frontend/src/components/elbv2/attributes-editor.test.tsx b/spinifex/services/spinifexui/frontend/src/components/elbv2/attributes-editor.test.tsx index 3c87fcf06..bcbb8fe04 100644 --- a/spinifex/services/spinifexui/frontend/src/components/elbv2/attributes-editor.test.tsx +++ b/spinifex/services/spinifexui/frontend/src/components/elbv2/attributes-editor.test.tsx @@ -147,7 +147,7 @@ describe("AttributesEditor", () => { expect(screen.getByRole("alert")).toHaveTextContent("boom") }) - it("exports spec sets covering every DefaultLoadBalancerAttributes/TG key required by plan", () => { + it("exports spec sets covering every DefaultLoadBalancerAttributes/TG key", () => { const lbKeys = albAttributeSpecs.map((s) => s.key) expect(lbKeys).toContain("deletion_protection.enabled") expect(lbKeys).toContain("load_balancing.cross_zone.enabled") diff --git a/spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/(target-groups)/-components/target-group-detail-page.tsx b/spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/(target-groups)/-components/target-group-detail-page.tsx index da1fbcdf9..a6309b125 100644 --- a/spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/(target-groups)/-components/target-group-detail-page.tsx +++ b/spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/(target-groups)/-components/target-group-detail-page.tsx @@ -140,7 +140,7 @@ export function TargetGroupDetailPage({ arn }: Props) {

Health-check settings are set at creation time. Editing lands in a - future slice (mulga-948). + future enhancement.

Health check diff --git a/spinifex/systemd/units_invariants_test.go b/spinifex/systemd/units_invariants_test.go index 6467c1fa9..fb755edee 100644 --- a/spinifex/systemd/units_invariants_test.go +++ b/spinifex/systemd/units_invariants_test.go @@ -245,10 +245,10 @@ func TestGracefulDrainOrdering(t *testing.T) { // TestRG11_LeanUnits asserts the RG-11 contract: unit/slice files carry settings // plus terse # RG-n references, not paragraphs of rationale, and never reference -// a plan doc, bead, or CI run (project policy — reasoning lives in the ADR). +// external planning or CI artifacts (reasoning is kept separately). func TestRG11_LeanUnits(t *testing.T) { dir := unitsDir(t) - // Plan/bead/doc/CI-run references that must not appear in a unit comment. + // External planning and CI references that must not appear in a unit comment. planRef := regexp.MustCompile(`(?i)siv-[0-9]+|mulga-[a-z0-9-]+|[a-z0-9_-]+\.md|\b[0-9]{9,}\b`) const maxComments = 12 @@ -262,7 +262,7 @@ func TestRG11_LeanUnits(t *testing.T) { } comments++ if m := planRef.FindString(ls); m != "" { - t.Errorf("RG-11: %s comment references a plan/bead/CI artifact (%q); rationale belongs in the ADR: %s", name, m, ls) + t.Errorf("unit comment references external planning or CI material (%q): %s", m, ls) } } if comments > maxComments { diff --git a/spinifex/types/telemetry.go b/spinifex/types/telemetry.go index 9463d9f98..e0baa6045 100644 --- a/spinifex/types/telemetry.go +++ b/spinifex/types/telemetry.go @@ -22,7 +22,7 @@ type GuestTelemetryMeta struct { const MetricsEC2SubjectPrefix = "metrics.ec2." // TelemetrySeries is one CloudWatch-mappable datapoint. Names and labels -// follow the schema locked in the Goanna plan: goanna_ec2_* metrics with +// follow the Goanna schema: goanna_ec2_* metrics with // namespace/instance_id/account_id labels. type TelemetrySeries struct { Name string `json:"name"` diff --git a/spinifex/vm/crash_recovery_test.go b/spinifex/vm/crash_recovery_test.go index 66bccf96e..69e9322a1 100644 --- a/spinifex/vm/crash_recovery_test.go +++ b/spinifex/vm/crash_recovery_test.go @@ -323,7 +323,7 @@ func TestMaybeRestart_ExceedsMaxInWindow(t *testing.T) { } // TestMaybeRestart_ExceedsMaxInWindow_ReleasesGPU is the regression test for -// mulga-keptb: a GPU instance that crashes past restart-exhaustion must +// A GPU instance that crashes past restart-exhaustion must // release its GPU pool slot instead of holding it forever in StateError, // since no restart will ever be scheduled to reclaim it. func TestMaybeRestart_ExceedsMaxInWindow_ReleasesGPU(t *testing.T) { @@ -615,7 +615,7 @@ func TestRestartCrashedInstance_RunFailureRollback(t *testing.T) { } // TestRestartCrashedInstance_RunFailureReleasesGPU is the regression test for -// mulga-keptb: when the relaunch attempt itself fails, the instance settles +// When the relaunch attempt itself fails, the instance settles // back in StateError for good — the GPU pool slot it still held from before // the crash must be released, not left claimed forever. func TestRestartCrashedInstance_RunFailureReleasesGPU(t *testing.T) { diff --git a/spinifex/vm/lifecycle_test.go b/spinifex/vm/lifecycle_test.go index 30bafa8e8..139da6e33 100644 --- a/spinifex/vm/lifecycle_test.go +++ b/spinifex/vm/lifecycle_test.go @@ -515,7 +515,7 @@ func TestStart_AbortedByConcurrentTerminate(t *testing.T) { // TestLaunchStillValid_Allowlist locks in the launchStillValid allowlist // across every defined InstanceState plus the zero value. The parent -// plan flagged: "a regression in the allowlist would silently break the +// A regression in the allowlist would silently break the // start-stopped path" — e.g. dropping StateStopped would make // StartInstances on a stopped VM no-op without surfacing an error. func TestLaunchStillValid_Allowlist(t *testing.T) { @@ -582,7 +582,7 @@ func startBrokenQMPListener(t *testing.T) (string, func()) { } // TestAttachQMP_DialFailure_NoHeartbeatLeak covers the regression the -// parent plan flagged: a swap that started qmpHeartbeat before checking +// A swap that started qmpHeartbeat before checking // the factory error would leak one goroutine per failed reconnect. With // no listener at the configured socket, net.Dial fails inside // newQMPClientWithHandshake and AttachQMP must return without spawning @@ -1200,7 +1200,7 @@ func serveSingleClientQMPConn(conn net.Conn) { } // TestSendQMPCommand_ReconnectsAgainstSingleClientServer is the regression -// test for the reconnectQMP ordering bug (PR #487): against a real QEMU +// test for the reconnectQMP ordering bug against a real QEMU // `server,nowait` QMP monitor, only one client may hold a connection at a // time. A wedged client's reconnect must close its own stale connection // BEFORE dialing fresh, freeing the slot — dialing fresh first (the pre-fix diff --git a/spinifex/vm/manager_test.go b/spinifex/vm/manager_test.go index 4ce3d3e3f..5837bb239 100644 --- a/spinifex/vm/manager_test.go +++ b/spinifex/vm/manager_test.go @@ -388,7 +388,7 @@ func TestManager_ConcurrentSoak(t *testing.T) { } } -// TestManager_SlotOccupancyRace simulates the production race the plan calls +// TestManager_SlotOccupancyRace simulates the production race the implementation // out at daemon_handlers_instance.go:594-626 and daemon.go:2140/2149: a // terminate handler running DeleteIf(id, original) concurrently with a start // handler running InsertIfAbsent(replacement) for the same slot, plus the diff --git a/spinifex/vm/orphan_qemu_reaper_test.go b/spinifex/vm/orphan_qemu_reaper_test.go index 4409a113a..1ec6f391c 100644 --- a/spinifex/vm/orphan_qemu_reaper_test.go +++ b/spinifex/vm/orphan_qemu_reaper_test.go @@ -40,7 +40,7 @@ func TestOrphanQEMUReaper(t *testing.T) { assert.Equal(t, 1, reaped, "the orphan QEMU for a terminated instance must be reaped") assert.False(t, utils.ProcessAlive(pid), - "a terminated instance must have no surviving process — otherwise it holds OVN ports (siv-476)") + "a terminated instance must have no surviving process — otherwise it holds OVN ports ") _, perr := utils.ReadPidFile(id) assert.Error(t, perr, "the PID file must be removed after reaping") }) diff --git a/spinifex/vm/shutdown_test.go b/spinifex/vm/shutdown_test.go index c7141215f..eeedc700f 100644 --- a/spinifex/vm/shutdown_test.go +++ b/spinifex/vm/shutdown_test.go @@ -1112,7 +1112,7 @@ func TestTerminate_WriteRunningStateFailure_RollbackInsert(t *testing.T) { } // TestMarkRecoveryFailed_PreservesVolumesAndAWSResources locks down the -// siv-25 architectural invariant: when daemon recovery cannot bring a +// Architectural invariant: when daemon recovery cannot bring a // previously-running instance back online, the cleanup path must NOT // invoke DeleteVolumes, ReleasePublicIP, DetachAndDeleteENI, or // RemoveFromPlacementGroup. A regression here re-introduces the P0 data diff --git a/spinifex/vm/volumes.go b/spinifex/vm/volumes.go index 95b816cbd..2c36fcb0a 100644 --- a/spinifex/vm/volumes.go +++ b/spinifex/vm/volumes.go @@ -252,10 +252,9 @@ func (m *Manager) AttachVolume(ctx context.Context, id, volumeID, device string) // BlockDeviceMappings[].DeviceName carries the in-guest path so // callers who SSH into the VM and `lsblk` see names that match - // DescribeInstances (mulga-599 / PR #55). UpdateGuestDeviceNames - // re-applies this convention on every Launch/Start, so any "fix" - // to use the API name here would be silently overwritten on the - // next start. + // DescribeInstances. UpdateGuestDeviceNames re-applies this convention on + // every Launch/Start, so using the API name here would be silently overwritten + // on the next start. m.UpdateState(id, func(v *VM) { if v.Instance == nil { return diff --git a/spinifex/vm/volumes_test.go b/spinifex/vm/volumes_test.go index 664315306..c918d5f16 100644 --- a/spinifex/vm/volumes_test.go +++ b/spinifex/vm/volumes_test.go @@ -588,7 +588,7 @@ func TestReboot_NotRunning(t *testing.T) { } // TestReboot_DoesNotFireHooks asserts that Manager.Reboot fires neither -// OnInstanceUp nor OnInstanceDown. The plan's "Hook firing contract" requires +// OnInstanceUp nor OnInstanceDown. The hook contract requires // hooks to fire only on Pending→Running and terminal transitions; reboot keeps // the VM in StateRunning across system_reset, so firing OnInstanceDown + // OnInstanceUp would tear down per-instance NATS subs on every reboot. @@ -920,7 +920,7 @@ func captureSlog(t *testing.T) *bytes.Buffer { // The QMP responder returns a query-block payload where vdisk-vol-1 // maps to /dev/vdc (the third virtio slot after os + cloudinit), so the // test can distinguish the API name from the guest name in every assertion. -// BlockDeviceMappings still carries the guest device name per mulga-599; +// BlockDeviceMappings still carries the guest device name; // only the volume-metadata path uses the API name. func TestAttachVolume_PersistsAPIDeviceNameInVolumeMetadata(t *testing.T) { qmpClient, cancel := newMockQMPClient(t, func(cmd qmp.QMPCommand) map[string]any { @@ -985,7 +985,7 @@ func TestAttachVolume_PersistsAPIDeviceNameInVolumeMetadata(t *testing.T) { bdm := v.Instance.BlockDeviceMappings[0] require.NotNil(t, bdm.DeviceName) assert.Equal(t, "/dev/vdc", *bdm.DeviceName, - "BlockDeviceMappings[].DeviceName must carry the guest virtio path so `lsblk` inside the VM matches DescribeInstances (mulga-599 / PR #55)") + "BlockDeviceMappings[].DeviceName must carry the guest virtio path so `lsblk` inside the VM matches DescribeInstances") require.NotNil(t, bdm.Ebs) require.NotNil(t, bdm.Ebs.VolumeId) assert.Equal(t, "vol-1", *bdm.Ebs.VolumeId) diff --git a/spinifex/vpcd/vpcd_test.go b/spinifex/vpcd/vpcd_test.go index fc41c9a29..8c2c82468 100644 --- a/spinifex/vpcd/vpcd_test.go +++ b/spinifex/vpcd/vpcd_test.go @@ -148,7 +148,7 @@ func TestPreflightOVN_BothFail_ReportsFirst(t *testing.T) { } } -// verifyBridgeMode is the post-detect sanity check — mulga-998.b Fix 2. +// verifyBridgeMode is the post-detect sanity check. // portToBr and readLinkMaster are injected for tests. func stubBridgeProbes(t *testing.T, ovsPorts map[string]string, links map[string]string) { @@ -248,7 +248,7 @@ func TestVerifyBridgeMode_UnknownModeLists(t *testing.T) { func TestVerifyBridgeMode_EmptyModeRejected(t *testing.T) { err := verifyBridgeMode("", "", "") if err == nil { - t.Fatal("expected error for empty mode (D12)") + t.Fatal("expected error for empty mode") } } @@ -283,7 +283,7 @@ func TestVerifyBridgeMode_VethLinuxBrMissing(t *testing.T) { } } -// detectBridgeMode — mulga-998.b Fix 2. +// detectBridgeMode selects the bridge mode after detection. func stubDetectProbes(t *testing.T, links []string) { t.Helper() @@ -331,7 +331,7 @@ func TestResolveBridgeConfig_AutoDetects(t *testing.T) { func TestResolveBridgeConfig_EmptyStaysEmptyWithNoIface(t *testing.T) { mode, _ := resolveBridgeConfig("", "") if mode != "" { - t.Errorf("empty mode + no iface should stay empty (D12); got %q", mode) + t.Errorf("empty mode + no iface should stay empty; got %q", mode) } } diff --git a/tests/e2e/Makefile b/tests/e2e/Makefile index ccae72818..8727acea7 100644 --- a/tests/e2e/Makefile +++ b/tests/e2e/Makefile @@ -14,9 +14,9 @@ RUN ?= GOTESTSUM ?= SUITE_TAG ?= $(notdir $(patsubst %/...,%,$(firstword $(PKG)))) -# Pre-built test binaries — see mulga-siv-80. `e2e-build` cross-compiles each -# named suite into BIN_DIR/.test so CI can ship binaries (not source + -# go toolchain) to the remote VM. +# Pre-built test binaries. `e2e-build` cross-compiles each named suite into +# BIN_DIR/.test so CI can ship binaries (not source + go toolchain) to +# the remote VM. BIN_DIR ?= $(CURDIR)/_bin SUITES_BUILD ?= cert lb eks ecs single iam ecr bedrock gpu natuplink multinode storagegrowth partialblock rds diff --git a/tests/e2e/cert/tlsposture_test.go b/tests/e2e/cert/tlsposture_test.go index 16ad43d4e..dc5150ede 100644 --- a/tests/e2e/cert/tlsposture_test.go +++ b/tests/e2e/cert/tlsposture_test.go @@ -14,7 +14,7 @@ import ( // TestTLSPosture asserts the deployed awsgw listeners actually negotiate // TLS 1.3 and a PQ-hybrid curve from the pinned policy. This is the live -// proof for the PQC Phase 2.1 work: +// proof for the PQC interoperability requirements: // it runs under the production FIPS build (GOFIPS140=v1.0.0, // GODEBUG=fips140=on) and catches regressions where unit tests pass but // something in the deploy path silently disables ML-KEM. diff --git a/tests/e2e/ddil/README.md b/tests/e2e/ddil/README.md index c7aaf384a..5380ff125 100644 --- a/tests/e2e/ddil/README.md +++ b/tests/e2e/ddil/README.md @@ -5,9 +5,6 @@ Go-based E2E harness that exercises Spinifex and Predastore against DDIL daemon-without-NATS restart, cluster partition, degraded links, Predastore writes under partition, Raft under SATCOM latency. -Design: [`docs/development/improvements/ddil-e2e-test-harness.md`](../../../../docs/development/improvements/ddil-e2e-test-harness.md) -(in the mulga monorepo). - ## Layout ``` @@ -47,7 +44,7 @@ DDIL_DRY_RUN=1 go test -tags=e2e ./tests/e2e/ddil/scenarios/... ``` Quarantine listed scenarios (failures downgrade to `t.Skip` with a tagged -reason; quarantined scenarios must have a linked bead): +reason): ```bash DDIL_QUARANTINED=D,F go test -tags=e2e ./tests/e2e/ddil/scenarios/... diff --git a/tests/e2e/ecr/capacity_test.go b/tests/e2e/ecr/capacity_test.go index 9b9e9a977..9d2e107ee 100644 --- a/tests/e2e/ecr/capacity_test.go +++ b/tests/e2e/ecr/capacity_test.go @@ -4,11 +4,9 @@ package ecr import "testing" -// TestECRCapacityLoad is the predastore capacity/load leg of Sprint 2f (parallel -// crane push of many large images, asserting predastore throughput with no -// manifest corruption). Deferred: it depends on predastore fixes -// (':'-in-key SigV4 canonicalization) and (404 NoSuchBucket), -// which are owned elsewhere. Unskip once those land. +// TestECRCapacityLoad pushes many large images with crane and asserts +// Predastore throughput without manifest corruption. It remains disabled until +// the required SigV4 canonicalization and NoSuchBucket behavior are available. func TestECRCapacityLoad(t *testing.T) { t.Skip("deferred: blocked on predastore fixes") } diff --git a/tests/e2e/ecs/ecs_test.go b/tests/e2e/ecs/ecs_test.go index d6c3cb1c1..6da8fd153 100644 --- a/tests/e2e/ecs/ecs_test.go +++ b/tests/e2e/ecs/ecs_test.go @@ -137,9 +137,9 @@ func TestECS(t *testing.T) { // teardown so the assertion below observes a clean sweep. By this point the // instance carries its own primary ENI plus a post-launch-attached one per // awsvpc task/service subtest above (TaskAwsvpc, TaskRoleCredentials, - // ServiceWithELB) — none of those ever touch vm.VM.ENIId, so this is the - // regression proof for mulga-73xte: relying on the launch-time scalar alone - // would leave every one of them attached, blocking SG/subnet/VPC teardown + // ServiceWithELB) — none of those ever touch vm.VM.ENIId. Relying on the + // launch-time scalar alone would leave every one attached, blocking + // SG/subnet/VPC teardown // behind DependencyViolation. t.Run("TerminateReleasesAttachedENIs", func(t *testing.T) { terminateContainerInstanceAndAssertENIsReleased(t, c, fx) diff --git a/tests/e2e/harness/diag.go b/tests/e2e/harness/diag.go index 018810dca..c324555e1 100644 --- a/tests/e2e/harness/diag.go +++ b/tests/e2e/harness/diag.go @@ -33,8 +33,8 @@ type VPCDiagnosticsOpts struct { LogicalIP string // ArtifactDir is the per-test bundle directory (typically // `fix.Artifacts`). When set, every capture is also persisted as - // a separate file so the Stage 2 analyzer bundler picks it up - // alongside the journal + test-log slices. + // a separate file so the analyzer bundler picks it up alongside the + // journal + test-log slices. ArtifactDir string } @@ -269,7 +269,7 @@ type hostCapture struct { // runHostCaptures runs each capture under `sudo -n`, echoes it to stdout for the // CI log, and persists it as a separate file under artifactDir (when set) so the -// Stage 2 analyzer bundler picks it up. Assumes the caller already verified +// analyzer bundler picks it up. Assumes the caller already verified // passwordless sudo is available. func runHostCaptures(t *testing.T, artifactDir string, caps []hostCapture) { t.Helper() diff --git a/tests/e2e/harness/rds.go b/tests/e2e/harness/rds.go index 157dedbd6..daafe5d9d 100644 --- a/tests/e2e/harness/rds.go +++ b/tests/e2e/harness/rds.go @@ -416,7 +416,7 @@ func dumpDBInstanceEvents(t *testing.T, d DBDiag, id string) { // per-instance tag, so it can only be asserted against an ID captured while the // instance was alive — see AssertVMGone. And the DNS withdrawal: a record only // proves anything resolved the way a customer resolves it, from inside a guest -// (D6), so that assertion belongs with ResolveInGuest. +// so that assertion belongs with ResolveInGuest. func AssertNoRDSRemnants(t *testing.T, d DBDiag, id string, opts ...PollOpt) { t.Helper() cfg := applyOpts(pollCfg{timeout: 3 * time.Minute, interval: 5 * time.Second}, opts...) diff --git a/tests/e2e/harness/rds_client.go b/tests/e2e/harness/rds_client.go index dd518344c..842fa7759 100644 --- a/tests/e2e/harness/rds_client.go +++ b/tests/e2e/harness/rds_client.go @@ -16,7 +16,7 @@ import ( "github.com/aws/aws-sdk-go/service/rds" ) -// A DB instance's endpoint only ever has a private address (D5 rejects +// A DB instance's endpoint only ever has a private address (public access is rejected // PubliclyAccessible), and nothing on the runner routes into a customer subnet. // So the client that proves a customer can reach the database has to be a VM in // that subnet, driven over SSH — not psql on the machine running the test. @@ -269,7 +269,7 @@ func psqlCommand(conn PSQLConn, sql string) string { // ResolveInGuest returns the addresses host resolves to inside the guest. // // This is the only resolution that proves anything about the guest's DNS path -// (D6): the runner's own resolver may point straight at northstar, so a +// The runner's own resolver may point straight at northstar, so a // host-side lookup can pass on a cluster where no guest can resolve anything. An // empty result means the name does not resolve, which is the assertion after a // delete withdraws the record. diff --git a/tests/e2e/harness/testdata/cloud-init-witness.yaml b/tests/e2e/harness/testdata/cloud-init-witness.yaml index e8f64dc08..dbff43364 100644 --- a/tests/e2e/harness/testdata/cloud-init-witness.yaml +++ b/tests/e2e/harness/testdata/cloud-init-witness.yaml @@ -1,7 +1,7 @@ #cloud-config # DDIL witness VM payload. Runs a monotonic counter-to-file loop so the # harness can prove a workload kept making progress across a fault injection. -# See docs/development/improvements/ddil-e2e-test-harness.md §1 (witness helpers). +# Witness helper cloud-init configuration. write_files: - path: /usr/local/bin/witness-counter.sh diff --git a/tests/e2e/manifest-check/manifest.go b/tests/e2e/manifest-check/manifest.go index 06f15d580..19453f2ac 100644 --- a/tests/e2e/manifest-check/manifest.go +++ b/tests/e2e/manifest-check/manifest.go @@ -1,10 +1,8 @@ // Package manifestcheck loads and validates spinifex/docs/service-interfaces.yaml. // -// The validator is documentation-only at this stage of Bead 1: it confirms -// the manifest parses, that every declared service/suite path exists on -// disk, and that cross-references (suites.covers → services, fixtures → -// services) resolve. It does not yet enforce that subjects in the manifest -// match subjects in source — that's Bead 5 (e2e-manifest-drift-lint). +// The validator confirms the manifest parses, every declared service/suite +// path exists on disk, and cross-references (suites.covers → services, +// fixtures → services) resolve. Subject-to-source drift is checked separately. package manifestcheck import ( diff --git a/tests/e2e/manifest-lint/cmd/manifest-lint/main.go b/tests/e2e/manifest-lint/cmd/manifest-lint/main.go index f4a0d08a5..76f47d549 100644 --- a/tests/e2e/manifest-lint/cmd/manifest-lint/main.go +++ b/tests/e2e/manifest-lint/cmd/manifest-lint/main.go @@ -1,4 +1,4 @@ -// Command manifest-lint runs the e2e manifest drift guards (Bead 5): +// Command manifest-lint runs the e2e manifest drift guards: // fixture-create lint + NATS subject lint, both ratcheted against a checked-in // baseline. // diff --git a/tests/e2e/rds/api_matrix_test.go b/tests/e2e/rds/api_matrix_test.go index ed78f4c49..8b22249a9 100644 --- a/tests/e2e/rds/api_matrix_test.go +++ b/tests/e2e/rds/api_matrix_test.go @@ -19,9 +19,9 @@ const ( // it is refused at validation rather than surfacing as a launch failure after // a volume and an ENI exist. unmappedDBClass = "db.r5.large" - // Deferred to rds-11: until then it has to be refused rather than half-served. + // Until this is supported, it has to be refused rather than half-served. unsupportedDBEngine = "mysql" - // One day over the D11 retention cap. + // One day over the retention cap. overCapRetentionDays = 8 ) @@ -46,14 +46,14 @@ var outOfScopeRDSActions = []string{ // The two catalog describes a Terraform module may reach for are unimplemented, // so today they are unknown actions rather than empty results. Pinned here so a -// provider that needs one produces a bead instead of a silent success. +// provider that needs one produces a clear failure instead of a silent success. var unregisteredRDSActions = []string{ "DescribeDBEngineVersions", "DescribeOrderableDBInstanceOptions", "NotAnRDSAction", } -// TestAPIMatrix is the negative matrix: validation, the D19 rejections, the +// TestAPIMatrix is the negative matrix: validation and unsupported requests, // actions that are recognised but not offered, and the parameters that are // accepted as no-ops. It runs first and boots almost nothing, so a broken API // surface fails the suite in seconds rather than after a VM boot. @@ -72,7 +72,7 @@ func TestAPIMatrix(t *testing.T) { suffix := time.Now().Unix() rejectedID := fmt.Sprintf("%s-rejected-%d", dbInstancePfx, suffix) - // D5 and D19: a parameter whose omission would create a false safety, + // A parameter whose omission would create a false safety, // security or availability guarantee is refused outright. t.Run("RejectsUnimplementedCreateParameters", func(t *testing.T) { for _, tc := range []struct { @@ -230,7 +230,7 @@ func TestAPIMatrix(t *testing.T) { // Above the floor so a shrink request is reachable: a shrink to anything below // the floor is refused by the floor rule first. probe.AllocatedStorage = aws.Int64(dbStorageGiB + 10) - // The inert parameters D19 accepts rather than rejects. Each one names a + // The inert parameters accepted rather than rejected. Each one names a // feature this platform does not have, but omitting it promises nothing. probe.AutoMinorVersionUpgrade = aws.Bool(true) probe.EnablePerformanceInsights = aws.Bool(true) @@ -242,7 +242,7 @@ func TestAPIMatrix(t *testing.T) { require.NotNil(t, created.DBInstance) t.Cleanup(func() { deleteInstance(t, f, probeID) }) - // D19's other half: an inert parameter is accepted and then reported honestly, + // An inert parameter is accepted and then reported honestly, // so a customer reading the instance back is never told a feature is on when // nothing implements it. t.Run("InertParametersAreAcceptedAndReportedOff", func(t *testing.T) { diff --git a/tests/e2e/rds/authz_test.go b/tests/e2e/rds/authz_test.go index 30a2156c3..6a7531778 100644 --- a/tests/e2e/rds/authz_test.go +++ b/tests/e2e/rds/authz_test.go @@ -56,7 +56,7 @@ func TestAuthorization(t *testing.T) { }) // The internal actions are refused by principal class, before any policy is - // read: GetDBBootstrapConfig hands back the master password (D8), so rds:* — + // read: GetDBBootstrapConfig hands back the master password, so rds:* — // a legitimate administrator grant — must not reach it. Asserted with a // principal that holds rds:*, or the denial would only prove a missing grant. t.Run("RDSStarCannotReachAnInternalAction", func(t *testing.T) { diff --git a/tests/e2e/rds/automated_backup_test.go b/tests/e2e/rds/automated_backup_test.go index a026c40fd..edb0149b1 100644 --- a/tests/e2e/rds/automated_backup_test.go +++ b/tests/e2e/rds/automated_backup_test.go @@ -25,7 +25,7 @@ const ( retentionSweepTimeout = 7 * time.Minute ) -// TestAutomatedBackups drives what only a live cluster can prove about rds-9: +// TestAutomatedBackups drives what only a live cluster can prove about automated backups: // the leader's window pass actually fires against a real engine, the snapshot it // takes is a real quiesced copy of the data volume, it fires once and not once per // pass, and turning retention off sweeps the set through the cluster-wide reaper. diff --git a/tests/e2e/rds/connect_test.go b/tests/e2e/rds/connect_test.go index b2427b1d2..52f44d4c7 100644 --- a/tests/e2e/rds/connect_test.go +++ b/tests/e2e/rds/connect_test.go @@ -77,7 +77,7 @@ func TestConnectivity(t *testing.T) { assert.Equal(t, connectNote, strings.TrimSpace(out), "the row written over the endpoint must read back") }) - // D6: the name is the customer's handle on the instance, and it has to resolve + // The name is the customer's handle on the instance, and it has to resolve // where a customer resolves it — inside the VPC. A lookup on the runner proves // nothing, because the runner's resolver may point straight at northstar. t.Run("TheEndpointNameResolvesInTheGuest", func(t *testing.T) { @@ -95,7 +95,7 @@ func TestConnectivity(t *testing.T) { "the name and the address must reach the same database") }) - // D14 puts both the vanity name and the ENI address in the serving + // Both the vanity name and the ENI address are in the serving // certificate's SAN set specifically so verify-full works either way, and that // is the mode a customer who cares about TLS actually uses. t.Run("VerifyFullSucceedsByNameAndByIP", func(t *testing.T) { @@ -149,7 +149,7 @@ func TestConnectivity(t *testing.T) { }, sgSettleTimeout, 5*time.Second) }) - // D21: the master user is administrative but not a PostgreSQL superuser. This + // The master user is administrative but not a PostgreSQL superuser. This // is the only leg that can prove it — the bootstrap unit test sees the SQL // that was sent, not what the engine then refuses. t.Run("TheMasterUserIsAdministrativeButNotASuperuser", func(t *testing.T) { @@ -181,7 +181,7 @@ func TestConnectivity(t *testing.T) { "the master user must be able to install a trusted extension in a database it owns") }) - // Last: it retires the credential every subtest above connects with. D8 keeps + // Last: it retires the credential every subtest above connects with. The system keeps // no cleartext password anywhere, so the only proof the rotation reached the // engine is that the new one authenticates and the old one does not. t.Run("TheMasterPasswordRotates", func(t *testing.T) { diff --git a/tests/e2e/rds/delete_test.go b/tests/e2e/rds/delete_test.go index 5b3e73c3b..ddeaba3d4 100644 --- a/tests/e2e/rds/delete_test.go +++ b/tests/e2e/rds/delete_test.go @@ -139,7 +139,7 @@ func TestDelete(t *testing.T) { // The engine is stopped cleanly before the VM goes, so the final snapshot is a // checkpoint rather than a datadir needing WAL replay. The volume it was cut - // from outlives the instance, because the snapshot references its chunks (D18). + // from outlives the instance, because the snapshot references its chunks. t.Run("AFinalSnapshotIsTakenAndTheVolumeRetained", func(t *testing.T) { harness.Phase(t, "Deleting %q with final snapshot %q", protectedID, finalSnapshotID) out, err := f.AWS.RDS.DeleteDBInstance(&rds.DeleteDBInstanceInput{ @@ -158,7 +158,7 @@ func TestDelete(t *testing.T) { require.NoError(t, err, "the final snapshot must exist once the delete has returned") assert.Equal(t, harness.DBSnapshotAvailable, aws.StringValue(snapshot.Status)) // Manual, not automated: the customer named it, so only the customer removes - // it — and rds-9's retention sweep must not. + // it — and the retention sweep must not. assert.Equal(t, "manual", aws.StringValue(snapshot.SnapshotType)) assert.Equal(t, protectedID, aws.StringValue(snapshot.DBInstanceIdentifier), "the snapshot must name the instance it outlived") @@ -228,7 +228,7 @@ func TestDelete(t *testing.T) { }) }) - // D6: the record only proves anything from inside a guest, and its withdrawal + // The record only proves anything from inside a guest, and its withdrawal // is the half nothing else in the suite covers. t.Run("TheEndpointNameStopsResolvingInTheGuest", func(t *testing.T) { requireEndpointName(t, endpoint) diff --git a/tests/e2e/rds/failure_test.go b/tests/e2e/rds/failure_test.go index 0f7e788ee..b128a132b 100644 --- a/tests/e2e/rds/failure_test.go +++ b/tests/e2e/rds/failure_test.go @@ -61,7 +61,7 @@ func TestFailureDetection(t *testing.T) { harness.WithTimeout(failureDetectionBudget)) detectionTime := time.Since(failureStarted) require.LessOrEqual(t, detectionTime, failureDetectionBudget, - "failure detection exceeded the D13 bound") + "failure detection exceeded the allowed bound") t.Logf("DB instance %s was classified failed after %s", id, detectionTime.Round(time.Second)) require.Len(t, failed.StatusInfos, 1, "a failed instance must explain its status") diff --git a/tests/e2e/rds/groups_test.go b/tests/e2e/rds/groups_test.go index 360eb4f7b..2691f55cf 100644 --- a/tests/e2e/rds/groups_test.go +++ b/tests/e2e/rds/groups_test.go @@ -91,7 +91,7 @@ func TestSubnetAndParameterGroups(t *testing.T) { teardownGroups(t, f, subnetGroup, paramGroup) }) - // D20: the size-derived defaults are formulas internally, but a customer only + // The size-derived defaults are formulas internally, but a customer only // ever sees the literal they resolved to. t.Run("DescribeDBParametersReportsLiterals", func(t *testing.T) { params := describeAllParameters(t, f, paramGroup) diff --git a/tests/e2e/rds/lifecycle_test.go b/tests/e2e/rds/lifecycle_test.go index a81b94b31..df15558f0 100644 --- a/tests/e2e/rds/lifecycle_test.go +++ b/tests/e2e/rds/lifecycle_test.go @@ -30,7 +30,7 @@ const ( staticParameterName = "max_connections" staticParameterValue = "137" - // How long the rds-6 classifier is watched for a false positive: the ladder is + // How long the failure classifier is watched for a false positive: the ladder is // 90s of heartbeat staleness plus a 30s grace plus one 15s reconciler pass, so // a window past all three is what proves a stop is not read as a failure. failureClassifierWindow = 3 * time.Minute @@ -70,7 +70,7 @@ func TestLifecycle(t *testing.T) { "CREATE TABLE %s (id int primary key, note text); INSERT INTO %s VALUES (1, '%s');", lifecycleTable, lifecycleTable, lifecycleNote)) - // D5/D9: a stop keeps the data volume, the customer ENI and its address, so a + // A stop keeps the data volume, the customer ENI and its address, so a // start comes back on the same datadir at the same endpoint. The VM is stopped // rather than terminated — only a class change replaces it. t.Run("StopKeepsTheDataAndTheAddress", func(t *testing.T) { @@ -88,7 +88,7 @@ func TestLifecycle(t *testing.T) { assert.Equal(t, endpoint, aws.StringValue(stopped.Endpoint.Address)) }) - // rds-6 classifies an instance whose heartbeats go stale as failed. A stop the + // The failure classifier treats an instance whose heartbeats go stale as failed. A stop the // control plane itself performed is the one case where they go stale by design, // and reading it as a failure would page an operator for a working database. t.Run("AStoppedInstanceIsNotClassifiedFailed", func(t *testing.T) { @@ -111,7 +111,7 @@ func TestLifecycle(t *testing.T) { require.NotNil(t, started.Endpoint) assert.Equal(t, endpoint, aws.StringValue(started.Endpoint.Address), "the endpoint must survive a stop/start") assert.Equal(t, privateIP, aws.StringValue(harness.DBEndpointENI(t, f.AWS, id).PrivateIpAddress), - "D5: the private address is what the endpoint name resolves to, so it must persist") + "the private address is what the endpoint name resolves to, so it must persist") out := harness.PSQL(t, client, conn, fmt.Sprintf("SELECT note FROM %s WHERE id = 1;", lifecycleTable)) assert.Equal(t, lifecycleNote, strings.TrimSpace(out), "the row written before the stop must still be there") @@ -184,7 +184,7 @@ func TestLifecycle(t *testing.T) { "the window must leave the instance on the group the modify named") require.NotEmpty(t, applied.DBParameterGroups) assert.Equal(t, "pending-reboot", aws.StringValue(applied.DBParameterGroups[0].ParameterApplyStatus), - "a static parameter is accepted by the engine but not in force until it restarts (D16)") + "a static parameter is accepted by the engine but not in force until it restarts") // Still the old value: the whole point of pending-reboot is that the engine // is running without it. diff --git a/tests/e2e/rds/main_test.go b/tests/e2e/rds/main_test.go index fedb35420..e4afcc8c7 100644 --- a/tests/e2e/rds/main_test.go +++ b/tests/e2e/rds/main_test.go @@ -34,7 +34,7 @@ import ( // plane publishes is region-qualified. const defaultRegion = "ap-southeast-2" -// The instance spec every test in the suite creates from. The class is the D15 +// The instance spec every test in the suite creates from. The class is the // floor and the storage is the API's own minimum: nothing here needs more, and // each DB VM booted is charged against the phase's instance budget. Only a // class-sensitive assertion names a bigger class, and only a grow names a diff --git a/tests/e2e/rds/modify_test.go b/tests/e2e/rds/modify_test.go index 9de6d17b1..bb10d29c4 100644 --- a/tests/e2e/rds/modify_test.go +++ b/tests/e2e/rds/modify_test.go @@ -18,7 +18,7 @@ import ( const ( // The table both modifications are asserted across: a grow that loses it has // grown the wrong volume, and a class change that loses it has replaced the VM - // without re-attaching the data (D9). + // without re-attaching the data. modifyTable = "e2e_modify" modifyNote = "written before the grow" @@ -27,8 +27,8 @@ const ( // costs nothing. grownStorageGiB = 30 - // The one place in the suite a second class is meaningful: it is the class D20 - // exists to protect, and one step up from the D15 floor. + // The one place in the suite a second class is meaningful: it protects the size-derived defaults + // and is one step up from the smallest supported class. grownClass = "db.t3.small" // shared_buffers is a quarter of class memory, so it is the parameter that @@ -50,7 +50,7 @@ const ( // // The filesystem-level half of the grow is deliberately not here. Proving in SQL // that the guest's filesystem grew means writing enough data to exceed the old -// volume, which does not belong in a PR gate; the runbook reads df -h off the +// volume, which does not belong in an automated gate; the runbook reads df -h off the // serial console instead. func TestModifyStorageAndClass(t *testing.T) { f := requireRDSFixture(t) @@ -87,7 +87,7 @@ func TestModifyStorageAndClass(t *testing.T) { "CREATE TABLE %s (id int primary key, note text); INSERT INTO %s VALUES (1, '%s');", modifyTable, modifyTable, modifyNote)) - // D12: there is no online grow, so a grow is a stop, a ModifyVolume the volume + // There is no online grow, so a grow is a stop, a ModifyVolume the volume // will only accept while nothing holds it, and a start. The VM is restarted // rather than replaced — only a class change replaces it. t.Run("AGrowEnlargesTheVolumeUnderTheSameVM", func(t *testing.T) { @@ -136,9 +136,9 @@ func TestModifyStorageAndClass(t *testing.T) { assertGrowEventRecorded(t, f, id) }) - // D15 and D20 in one assertion: the class moves, which replaces the VM, and the + // The class moves, which replaces the VM, and the // size-derived defaults have to be re-resolved against the class the instance is - // becoming. D12 keeps the endpoint through it — the data volume and the customer + // becoming. The endpoint is kept through it — the data volume and the customer // ENI are re-attached to the replacement, so the address clients hold is unmoved. t.Run("AClassChangeReplacesTheVMAndReResolvesTheDefaults", func(t *testing.T) { assert.Equal(t, sharedBuffersAtFloor, showParameter(t, client, conn, "shared_buffers"), @@ -165,14 +165,14 @@ func TestModifyStorageAndClass(t *testing.T) { assert.Equal(t, endpoint, aws.StringValue(changed.Endpoint.Address), "the endpoint is the customer's handle on the instance and must survive the VM being replaced") assert.Equal(t, privateIP, aws.StringValue(harness.DBEndpointENI(t, f.AWS, id).PrivateIpAddress), - "D5: the ENI is re-attached to the replacement, so the address the name resolves to is unchanged") + "the ENI is re-attached to the replacement, so the address the name resolves to is unchanged") assert.Equal(t, dataVolumeID, aws.StringValue(harness.DBInstanceDataVolume(t, system, id).VolumeId), - "D9: the data volume is re-attached rather than rebuilt") + "the data volume is re-attached rather than rebuilt") replacementID := aws.StringValue(harness.DBInstanceVM(t, system, id).InstanceId) assert.NotEqual(t, vmID, replacementID, "a class change is delivered by replacing the VM") // The old VM has to actually go: one left running would still hold the class - // the customer has stopped paying for, and D3's index rewrite assumes it is + // the customer has stopped paying for, and the index rewrite assumes it is // gone rather than merely superseded. harness.AssertVMGone(t, system, vmID) @@ -180,7 +180,7 @@ func TestModifyStorageAndClass(t *testing.T) { assert.Equal(t, modifyNote, strings.TrimSpace(note), "the row written before both modifications must survive the replace") - // The whole point of D20: the defaults are formulas over class memory, so a + // The defaults are formulas over class memory, so a // class change that did not re-resolve them leaves a 2 GiB instance running a // 1 GiB configuration. assert.Equal(t, sharedBuffersAtSmall, showParameter(t, client, conn, "shared_buffers"), diff --git a/tests/e2e/rds/snapshot_restore_test.go b/tests/e2e/rds/snapshot_restore_test.go index 05205ffdd..a2e2e2703 100644 --- a/tests/e2e/rds/snapshot_restore_test.go +++ b/tests/e2e/rds/snapshot_restore_test.go @@ -27,7 +27,7 @@ const ( snapshotRowsBefore = 1 // The message a snapshot taken over a running engine must not carry: the - // engine was available, so the quiesce had every opportunity to work, and D10's + // engine was available, so the quiesce had every opportunity to work, and the // crash-consistent fallback is for the case where it does not. crashConsistentNotice = "could not be quiesced" @@ -44,8 +44,8 @@ const ( // that the restore is a wholly separate instance — its own volume, its own ENI, // its own endpoint. // -// Both instances are consumed: the source is deleted to prove D18's retained -// volume is released, which is an assertion that cannot be made while it exists. +// Both instances are consumed: deleting the source proves the retained volume +// is released, which is an assertion that cannot be made while it exists. func TestSnapshotRestore(t *testing.T) { f := requireRDSFixture(t) t.Parallel() @@ -146,7 +146,7 @@ func TestSnapshotRestore(t *testing.T) { assert.NotEqual(t, sourceVolumeID, aws.StringValue(harness.DBInstanceDataVolume(t, system, restoredID).VolumeId), "the restore reads a volume created from the snapshot, never the source's own") - // D8: no password was supplied to the restore and none could be — the role + // No password was supplied to the restore and none could be — the role // and its hash came from the datadir, so the source's credentials are the // restore's. A restore that needed new credentials would be unusable. conn := harness.PSQLConnFor(t, instance, dbMasterUser, dbMasterPassword, dbName) @@ -174,7 +174,7 @@ func TestSnapshotRestore(t *testing.T) { require.NotEmpty(t, created, "a snapshot with no event is a backup a customer cannot audit") assert.Contains(t, strings.Join(created, "\n"), "DB snapshot created") - // D10 reports an unquiesced snapshot rather than refusing it, which makes the + // An unquiesced snapshot is reported rather than refused, which makes the // notice the only signal that a backup is crash consistent. The engine was // available here, so its absence is the assertion. instanceEvents := dbInstanceEventMessages(t, f, sourceID) @@ -236,7 +236,7 @@ func TestSnapshotRestore(t *testing.T) { assert.Equal(t, snapshotID, aws.StringValue(mine.DBSnapshotIdentifier)) }) - // D18: a data volume whose chunks a snapshot still references outlives its DB + // A data volume whose chunks a snapshot still references outlives its DB // instance, and is reclaimed by the delete of the last snapshot holding it. The // failure this catches is the expensive one — a volume nothing points at, paid // for indefinitely, invisible to the customer who deleted the database. @@ -276,7 +276,7 @@ func createDBSnapshot(t *testing.T, f *Fixture, dbInstanceID, snapshotID string) } // Idempotent teardown for one snapshot, so the assertions above can delete -// snapshots in the order D18 is proven in without the cleanups then failing. +// snapshots in the order the retention behavior is proven without the cleanups then failing. func deleteDBSnapshot(t *testing.T, f *Fixture, snapshotID string) { t.Helper() if _, err := f.AWS.RDS.DeleteDBSnapshot(&rds.DeleteDBSnapshotInput{ diff --git a/tests/e2e/run-bm-multinode-e2e.sh b/tests/e2e/run-bm-multinode-e2e.sh index 6148b83d2..1ded8b12a 100755 --- a/tests/e2e/run-bm-multinode-e2e.sh +++ b/tests/e2e/run-bm-multinode-e2e.sh @@ -164,7 +164,7 @@ dump_guest_ssh_diagnostics() { peer_ssh "$LOCAL_IP" "sudo ovn-sbctl --bare --columns=logical_port,chassis,mac list Port_Binding 2>&1 | grep -F '${mac}' || echo '(no Port_Binding matched MAC ${mac})'" 2>&1 || true fi - # ----- Cross-chassis dataplane diagnostics (mulga-siv-27 follow-up) ----- + # ----- Cross-chassis dataplane diagnostics ----- echo " --- OVN SB chassis registrations (from primary) ---" peer_ssh "$LOCAL_IP" "sudo ovn-sbctl show 2>&1 || true" 2>&1 || true diff --git a/tests/e2e/single/createimage_test.go b/tests/e2e/single/createimage_test.go index 13c400ca5..29de465ab 100644 --- a/tests/e2e/single/createimage_test.go +++ b/tests/e2e/single/createimage_test.go @@ -20,8 +20,8 @@ import ( // Boot-verifies both CreateImage paths: --no-reboot against the running // singleton (IsRunning path), and a second image against the same instance // stopped (offline path). The IsRunning path can register a well-formed AMI -// that never reaches the OS — mulga-i8nfx found this stuck at the UEFI shell -// on a root volume grown past the base image's native size — so +// that never reaches the OS, such as one stuck at the UEFI shell on a root +// volume grown past the base image's native size — so // describe-images reporting State=available is not itself evidence the AMI // boots; only a real guest login is. func runCreateImage(t *testing.T, fix *Fixture) { @@ -103,8 +103,8 @@ func runCreateImage(t *testing.T, fix *Fixture) { // runBootVerifyAMI launches a short-lived, test-owned instance from amiID and // requires it to reach a real SSH login — not just EC2 State=running — so a -// well-formed-but-unbootable AMI (mulga-i8nfx: stuck at the UEFI shell) fails -// this test instead of shipping silently. Terminates the probe instance via +// well-formed-but-unbootable AMI fails this test instead of shipping +// silently. Terminates the probe instance via // t.Cleanup regardless of outcome. func runBootVerifyAMI(t *testing.T, fix *Fixture, amiID, label string) { t.Helper() diff --git a/tests/e2e/storagegrowth/image_pull_test.go b/tests/e2e/storagegrowth/image_pull_test.go index 01985f37a..56a5d98df 100644 --- a/tests/e2e/storagegrowth/image_pull_test.go +++ b/tests/e2e/storagegrowth/image_pull_test.go @@ -78,10 +78,8 @@ const ( // root mode. service_impl.go's parseVolumeParams defaults to exactly this // string when BlockDeviceMappings[0].DeviceName is unset on a // RunInstances request, and DescribeInstances reports the same name back - // for a virtio-blk-pci root volume (see - // docs/development/archive/bugs/fix-blockdevicemappings-devicename.md), - // so this one constant is used both to request the mapping and to - // re-identify it afterward. + // for a virtio-blk-pci root volume. This constant is used both to request + // the mapping and to re-identify it afterward. imagePullRootDevice = "/dev/vda" // imagePullPullCyclesEnv selects how many pull-then-free cycles the guest diff --git a/tests/integration/daemon_lite.go b/tests/integration/daemon_lite.go index e29f766b2..3e2ca14f6 100644 --- a/tests/integration/daemon_lite.go +++ b/tests/integration/daemon_lite.go @@ -244,8 +244,8 @@ func (dl *DaemonLite) subscribe(t *testing.T, nc *nats.Conn) { // TagsServiceImpl and skips the instance-ID routing split and the // recordTagMirrors projection onto owning resource records — both exist // only to support instance/volume tagging, which is out of scope here - // (see mulga-xaa9f), and neither is observed by the ported - // TestTagManagement assertions (all of which read back through + // and neither is observed by the ported TestTagManagement assertions (all + // of which read back through // DescribeTags, the central tag store both paths write identically). sub(t, nc, "ec2.CreateTags", func(m *nats.Msg) { dispatch(m, dl.Tags.CreateTags) }) sub(t, nc, "ec2.DeleteTags", func(m *nats.Msg) { dispatch(m, dl.Tags.DeleteTags) }) diff --git a/tests/integration/tags_test.go b/tests/integration/tags_test.go index 5bd43492b..a408a7c72 100644 --- a/tests/integration/tags_test.go +++ b/tests/integration/tags_test.go @@ -15,8 +15,8 @@ import ( // runTagManagement, driving the REAL tags/service_impl.go over the harness's // DaemonLite. The E2E source tags a running instance and its root EBS // volume; instance lifecycle and volume creation are out of scope for this -// tier (they need vm.Manager/QEMU and viperblock respectively — see -// mulga-xaa9f), so this port substitutes two in-scope resources that stand +// tier (they need vm.Manager/QEMU and viperblock respectively), so this port +// substitutes two in-scope resources that stand // in for the same two-resource-isolation shape: a scratch VPC (stand-in for // "instance") and its own auto-created main route table (stand-in for "root // volume"). CreateTags/DescribeTags/DeleteTags never inspect resource