From 62884bb87d175f11c8761fed76e6f75cd84e4d54 Mon Sep 17 00:00:00 2001 From: Julian Knutsen Date: Fri, 4 Sep 2026 23:37:32 -0700 Subject: [PATCH] =?UTF-8?q?fix(storage):=20an=20env-pointed=20server=20is?= =?UTF-8?q?=20shared,=20not=20owned=20=E2=80=94=20close=20the=20migrate-ga?= =?UTF-8?q?te=20bypass=20(#6118)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(storage): an env-pointed server is shared, not owned — close the migrate-gate bypass A workspace pointed at an externally-managed dolt sql-server purely through BEADS_DOLT_SERVER_PORT was classified ServerModeOwned, so the shared-store consent gate (#5920/#6048/#6055) never ran. bd then migrated that server's database in place — no prompt, no warning, exit 0 — and every co-resident bd still on the older schema was hard-refused with "schema version mismatch". The gate added specifically to stop this had a hole straight through it. The asymmetry. Two resolvers disagree about what names the server: - the CONNECTION path takes the env var first. configfile.GetDoltServerPort reads BEADS_DOLT_SERVER_PORT, then BEADS_DOLT_PORT, then metadata.json; doltserver's precedence chain behind ApplyResolvedServerPort does the same and records which step won as Config.ServerPortSource. - the OWNERSHIP path ignores it. ResolveServerMode's step 4 reads dolt_server_port from metadata.json ONLY. So a workspace whose metadata.json says dolt_mode=server with no port, and whose port arrives entirely from the environment, connects to a server it never started while believing it owns a private one. Reproduced on a scratch server shaped exactly like the reported deployment: identical topology, identical database — with the port in metadata.json the gate refuses (exit 1); with the same port supplied only by the env var, bd migrated v65 -> v66 silently (exit 0). The only difference is where the port came from. The fix. sharedServerDatabase stops borrowing the lifecycle resolver's answer for a question it was not written to answer. ResolveServerMode's contract is "may bd manage this server's lifecycle" — deliberately conservative about env ports, because flipping it to External also disables auto-start. The gate needs a stricter question, asked directly: did THIS workspace's own bookkeeping produce the endpoint we connected to? Config.ServerPortSource already carries the answer, stamped by applyConfigDefaults on every open, library path included. Workspace bookkeeping (owned): the port file doltserver.Start wrote, the dolt config.yaml inside the workspace's own dolt dir, an in-process caller assertion (be-wf9a.1), or no port resolved at all. Everything else — the env vars, beads' config.yaml, metadata.json, the two documented fallback defaults — is an operator writing down where a server already lives, and is shared. One escape hatch: .beads/dolt-server.port naming the same port bd is connected on is bd's own proof that it started that server, even when the env read won the chain. Two neighbouring asymmetries in the same family, both found by auditing every signal the connection path honors against what ownership resolution reads: - a gateway credential command mints a token for an authenticating server; bd's auto-start brings up a plain local root@localhost dolt and never issues tokens, so cfg.Gateway now asserts shared on its own rather than depending on port provenance. - applyResolvedConfig never copied dolt_server_socket out of metadata.json, although cmd/bd's resolveDoltServerConnection — which its own doc says it mirrors — always has. The library open path and the CLI therefore chose different transports for the same workspace, and it blinded the predicate's socket arm, which exists precisely because auto-start only ever creates a TCP listener. A configured-but-unreachable socket stays harmless: newServerMode normalizes it back to TCP via ResolveSocketTransport. Not changed: ResolveServerMode itself, and so auto-start. Making an env-named port imply External would also suppress auto-start, which is arguably right — it is the shadow-database hazard External mode exists for — but it is a behavior change on a path the reported blocker does not need, and this is an RC. Left as a documented follow-up. Why #6088's narrowing survives. Every check added here is an early `return true`, so it can only ADD a shared classification, never remove one: any topology gated before still returns at the same place. The auto-started single-workspace server keeps every signal that made it owned — local host, no TLS, no socket, not shared-server mode, ServerModeOwned — and now also resolves its port from its own port file. TestServerModeLenientOpenDirtyTableGate, the #4566/#5781 recovery whose whole shape is refuse-then-commit-then-migrate on exactly such a server, passes unmodified; end to end, bd init --server on a fresh workspace rolled back to v65 still migrates to v66 on the next write, exit 0, no gate. Tests: TestSharedServerDatabaseEndpointProvenance walks all nine port sources plus the port-file hatch in both directions, the disagreeing-port-file case, and the reported shape end to end (including an assertion that ResolveServerMode still says Owned there — if that ever changes, the test has stopped covering the bug). TestSharedServerDatabase gains the gateway case. Reverting the new arm turns seven of them red, including the reported shape. Co-Authored-By: Claude Fable 5 * fix(storage): prove server ownership instead of inferring it from the endpoint Review of the first cut found the bypass still open through two more doors, and two false positives the "can only ADD shared" argument did not cover. All four have the same cause: the predicate inferred ownership from how the endpoint was NAMED, and every such inference is a separate silent bypass. Still-open bypasses: - PortSourceCallerExplicit was treated as workspace bookkeeping, but applyConfigDefaults stamps it onto ANY caller-preset port, and `bd init --server-port` is the documented way to attach a workspace to an existing server. So `bd init --server-port 3307` against a shared server still resolved owned and migrated it in place, exit 0 — the reported failure through a different door. Same for any library embedder building dolt.Config{ServerHost: "127.0.0.1", ServerPort: 3307}. - the port-file escape hatch had no liveness check. A port file records that bd once bound a port, not that the process answering it now is bd's. A workspace whose own server died, with an external server later occupying that port, laundered the foreign endpoint into ownership. 3307 is both the common external port and bd's own default, so the collision is likely rather than exotic. False positives: - PortSourceConfigYaml was classified shared, which hard-refuses a single-user workspace that pinned dolt.port in config.yaml with bd auto-starting its own server on it — the configuration bd's own auto-start warning tells users to adopt ("To pin a port: set dolt.port in .beads/config.yaml"). Newly-gated topologies are exactly where the #6088 class of regression lives, and the additive argument says nothing about them. - reading dolt_server_socket in applyResolvedConfig disabled auto-start on the library path whenever the server was cold: ResolveSocketTransport returns the socket unchanged when neither socket nor TCP answers, and serverOpenCanAutoStart requires an empty socket. The claim that a non-connectable socket stays harmless held only while TCP was up — never in the case where auto-start matters. So ownership is no longer inferred at all. doltserver.ManagesLiveServerOnPort PROVES it from the state files bd writes when it starts a server: a live PID beside a port file naming the port this store is actually connected on. Everything else is shared. Enumerating the ways an endpoint can be foreign is unbounded — an env var, a config.yaml pin, a flag, a hand-built Config, a stale file all produce the same local TCP endpoint — while there is exactly one way to be sure, and it is two cheap file reads and a signal 0. That single rule closes both bypasses and removes both false positives: the config.yaml pin and the env port bd itself bound both carry the proof, because bd started those servers. ManagesLiveServerOnPort deliberately stops short of IsRunning. IsRunning repairs as it goes (deletes stale state, can stop an orphan), and a predicate classifying a connection must not mutate workspace state as a side effect. It also omits IsRunning's isDoltProcess() command-name check, which shells out to `ps` — measured at 765ms on a loaded machine, and this runs on every writable open. The residual gap needs a recycled PID AND a stale port file AND a foreign server on that same port; strictly narrower than the gap left by trusting the port file alone, and documented at the definition. Also dropped: the cfg.Gateway arm, which was unreachable — newServerMode only calls initSchema when !cfg.Gateway, so a gateway config never reaches this predicate. It was listed as a closed asymmetry in the PR body and closed nothing. The socket read in applyResolvedConfig is reverted entirely: besides breaking cold auto-start it never armed the predicate it was written for, because newServerMode overwrites cfg.ServerSocket with the normalized transport before initSchema runs. open.go is byte-identical to the base branch again. The socket topology is covered by the ownership proof instead, without touching the transport. Tests: TestManagesLiveServerOnPort covers the proof directly, including that it does not mutate the state it reads. TestSharedServerDatabaseOwnershipProof replaces the port-source matrix — three of whose nine rows asserted source/host combinations that cannot coexist in production — with the real topologies, both bypasses among them. TestSharedServerDatabaseThroughResolvedConfig drives applyResolvedConfig + applyConfigDefaults so the link between BEADS_DOLT_SERVER_PORT and the classification is pinned by behavior rather than by a hand-stamped field. The duplicated workspace/env helpers are hoisted to package level, one env list. Verified end to end on a scratch server for both new bypasses: the previous build migrated v65 -> v66 exit 0 through each door; this one refuses both. The #6088 auto-start case still migrates on open, exit 0. Refs #6123 for the four-resolver reconciliation this defers. Co-Authored-By: Claude Fable 5 * docs(doltserver): name the adopted-server residual gap in the ownership proof Maintainer review fixup for PR #6118. `ManagesLiveServerOnPort`'s doc stated the invariant as "a workspace whose server bd brought up", but `Start()` writes the same PID and port files for a server it *adopts*: `reclaimPort` returns the PID of a dolt process whose CWD is this workspace's dolt dir, and `Start` records that foreign PID before reporting `Running`. An operator running `dolt sql-server` over `.beads/dolt` under systemd and then typing `bd dolt start` mints the proof for a server bd does not manage — a second, wider residual gap than the recycled-PID one the doc named, and one an auditor was told did not exist. Comment-only. Soften the stated invariant to "started — or adopted — for itself", document both residual gaps explicitly (adopted-server is unix-only in practice: `isProcessInDir` is false on Windows), and point both at #6123, which owns reconciling the four resolvers. Deliberately not changed: no `isDoltProcess` check in the helper — it would close only the recycled-PID gap, since `reclaimPort` already requires `isDoltProcess` before adopting, at hundreds of ms on every writable open. And no change to `Start`'s adopt branch: recording adoption distinctly is the right fix but is a behavior change on the auto-start path, not an RC gate-hardening patch. Both are tracked in #6123. Neither gap is a regression: at base both topologies resolved `ServerModeOwned` and were ungated, and `store.go` is +35/-0 with the new check as an early return ahead of base's unchanged final return, so this PR can only add refusals. * docs(doltserver): the adopted-server gap is incidental and permanent Amend the ManagesLiveServerOnPort ownership-proof comment so the residual adopted-server gap is described the way it actually behaves: typing `bd dolt start` is not required (a 500 ms dial timeout reaches the same adopt branch with no operator action), the two state files the adopt branch writes persist, and `dolt.auto-start: false` / BEADS_DOLT_AUTO_START=0 is the one setting that closes the incidental route while #6123 is open — the deliberate `bd dolt start` route is not affected by it. Also rename the positive proof subtest to say what it pins: any live PID beside an agreeing port file is accepted, dolt process or not. The PID it writes is the test binary's own, which parseDoltProcessPIDs would never match, so the subtest is the live demonstration of the liveness-only contract and is expected to go red when #6123 tightens the predicate. --------- Co-authored-by: Claude Fable 5 --- internal/doltserver/doltserver.go | 94 +++++ .../doltserver/managed_server_proof_test.go | 121 +++++++ .../dolt/shared_server_predicate_test.go | 330 +++++++++++++++--- internal/storage/dolt/store.go | 35 ++ 4 files changed, 540 insertions(+), 40 deletions(-) create mode 100644 internal/doltserver/managed_server_proof_test.go diff --git a/internal/doltserver/doltserver.go b/internal/doltserver/doltserver.go index f0cc047fe..4be44120a 100644 --- a/internal/doltserver/doltserver.go +++ b/internal/doltserver/doltserver.go @@ -542,6 +542,100 @@ func ReadPortFile(beadsDir string) int { return readPortFile(beadsDir) } +// ManagesLiveServerOnPort reports whether beadsDir has a dolt sql-server that +// bd brought under management FOR IT and that is still alive on port. It is +// the affirmative proof of ownership available from local state: bd writes +// both state files in Start(), so a workspace that can show a live PID beside +// a port file naming the port a caller is actually connected on is a workspace +// whose server bd started — or adopted — for itself. Two file reads and a +// signal 0 cannot separate those two, which is why the invariant is stated +// that way; see the residual gaps below. +// +// The absence of that proof is what matters at the call sites. An operator who +// points bd at an endpoint — through BEADS_DOLT_SERVER_PORT, a config.yaml +// pin, `bd init --server-port`, or a hand-built library Config — produces no +// state files at all, because bd never started anything. Nothing else about +// the connection distinguishes the two: both end as "a local TCP dolt +// sql-server on port N". +// +// Read-only, deliberately. IsRunning answers a similar question but repairs as +// it goes: it deletes stale PID and port files, and will stop an orphaned +// server whose port it cannot determine. Callers that are merely classifying a +// connection must not mutate a workspace's server state as a side effect, so +// this duplicates the two cheap checks rather than reusing IsRunning. +// +// Two residual gaps remain, both of which answer "owned" for a server bd did +// not launch. Both are narrower than what trusting the port file alone — or +// ResolveServerMode alone — left open, and #6123 owns closing them as part of +// reconciling the four resolvers that answer "is this dolt server ours?". +// +// Adopted server (the wider of the two). Start() writes these same two state +// files for a server it adopts rather than launches: reclaimPort returns the +// PID of a dolt process whose CWD is this workspace's dolt dir, and Start +// records that foreign PID and the port before reporting Running. So an +// operator running `dolt sql-server` over .beads/dolt under systemd or a +// container — exactly the operator portConflictDiagnostics addresses — mints +// this proof by typing `bd dolt start`. +// +// Typing it is not required, though, and the effect does not wear off. The +// storage layer dials with a 500 ms timeout, so any open that times out — +// under load, or inside a systemd/container restart window — reaches the same +// adopt branch through its auto-start path with no operator action at all. +// Nothing suppresses that by default for the topology this predicate exists to +// gate: when the endpoint comes only from BEADS_DOLT_SERVER_PORT, +// ResolveServerMode still answers Owned (that is the bug being closed here), so +// EnsureRunningDetailed's ServerModeExternal branch never fires and Start() +// proceeds. Once the adopt branch has written the two files they stay: +// IsRunning clears them only for a PID that is corrupt, dead, or not dolt, and +// an adopted server is a live dolt process on all three counts. The workspace +// then answers "owned" from that point on, so a single timed-out dial disarms +// the gate permanently. +// +// One setting does suppress it: `dolt.auto-start: false` (or +// BEADS_DOLT_AUTO_START=0) fails serverOpenCanAutoStart and IsAutoStartDisabled, +// so a timed-out open errors instead of adopting. That closes the incidental +// route only — `bd dolt start` never consults either check, so the deliberate +// route above stays open. It is the one mitigation an operator has while #6123 +// is open. +// +// Closing it means recording adoption distinctly from launch (skip the write on +// the adopt branch, or mark it so this helper declines it), which is a behavior +// change on the auto-start path and belongs with #6123 rather than in a +// gate-hardening patch — though incidental and permanent is a sharper argument +// for #6123 than a resolver tidy-up would be. It is unix-only in practice: +// isProcessInDir returns false on Windows, so reclaimPort never takes the +// CWD-match adopt branch there. +// +// Recycled PID (narrower). This stops short of IsRunning's isDoltProcess() +// command-name check, which shells out to `ps` (PowerShell on Windows) — +// measured at hundreds of milliseconds on a busy machine, and this runs on +// every writable open. So: the recorded server died, an unrelated live process +// inherited its PID number, AND the port file still names the port some other +// server now answers on. It fails toward "owned" only when all three coincide. +// Note that isDoltProcess here would close only this gap, not the adopted-server +// one — reclaimPort already requires isDoltProcess before it will adopt. +// +// Callers needing certainty over latency should use IsRunning. +func ManagesLiveServerOnPort(beadsDir string, port int) bool { + if beadsDir == "" || port <= 0 { + return false + } + // The port file first: it is the cheaper read, and a workspace pointed at + // somebody else's endpoint usually has no port file at all. + if readPortFile(beadsDir) != port { + return false + } + data, err := os.ReadFile(pidPath(beadsDir)) + if err != nil { + return false + } + pid, err := strconv.Atoi(strings.TrimSpace(string(data))) + if err != nil || pid <= 0 { + return false + } + return isProcessAlive(pid) +} + // PortFileSnapshot captures the exact prior contents of a project's port // file, so a caller that speculatively lets EnsureRunningDetailed write a // new one can restore the pre-call state exactly if it later decides not to diff --git a/internal/doltserver/managed_server_proof_test.go b/internal/doltserver/managed_server_proof_test.go new file mode 100644 index 000000000..e4b75e7ef --- /dev/null +++ b/internal/doltserver/managed_server_proof_test.go @@ -0,0 +1,121 @@ +package doltserver + +import ( + "os" + "path/filepath" + "strconv" + "testing" +) + +// TestManagesLiveServerOnPort pins the ownership proof: both state files, a +// live PID, and a port file agreeing with the port the caller is connected on. +// +// Every "false" case below is a silent in-place migration of somebody else's +// database if it ever flips, so each one names the topology it stands for. +func TestManagesLiveServerOnPort(t *testing.T) { + const port = 3307 + + // dead is a PID no live process answers to: above every default pid_max. + const dead = 2147483646 + + newDir := func(t *testing.T) string { + t.Helper() + dir := filepath.Join(t.TempDir(), ".beads") + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatalf("mkdir: %v", err) + } + return dir + } + write := func(t *testing.T, dir, name string, v int) { + t.Helper() + if err := os.WriteFile(filepath.Join(dir, name), []byte(strconv.Itoa(v)), 0o600); err != nil { + t.Fatalf("write %s: %v", name, err) + } + } + + // The PID recorded here is this test binary's, which is emphatically not a + // dolt sql-server: parseDoltProcessPIDs requires "dolt" followed by + // "sql-server" in the command line, so an identity check would never return + // it. That is the point — this subtest pins the predicate's liveness-only + // contract and is the live demonstration that any live PID beside an + // agreeing port file is accepted today, dolt or not. #6123 is expected to + // tighten that (a distinct adoption marker, or an identity check); when it + // does, this subtest goes red, and that is the signal to re-derive #6088's + // guarantee from whatever the new proof is, not to relax the assertion. + t.Run("any live pid with an agreeing port file is proof", func(t *testing.T) { + dir := newDir(t) + write(t, dir, PortFileName, port) + write(t, dir, PIDFileName, os.Getpid()) + if !ManagesLiveServerOnPort(dir, port) { + t.Fatal("a workspace with a live recorded server on this port owns it (#6088 must keep migrating)") + } + }) + + t.Run("dead pid is not proof", func(t *testing.T) { + // The workspace once ran its own server on this port; it died, and an + // externally managed server now answers there. 3307 is both the common + // external port and bd's own default, so the collision is likely. + dir := newDir(t) + write(t, dir, PortFileName, port) + write(t, dir, PIDFileName, dead) + if ManagesLiveServerOnPort(dir, port) { + t.Fatal("a port file records that bd once bound a port, not that bd answers on it now") + } + }) + + t.Run("port file naming a different port is not proof", func(t *testing.T) { + dir := newDir(t) + write(t, dir, PortFileName, 40083) + write(t, dir, PIDFileName, os.Getpid()) + if ManagesLiveServerOnPort(dir, port) { + t.Fatal("bd's server is on another port; this endpoint is somebody else's") + } + }) + + t.Run("missing state files are not proof", func(t *testing.T) { + dir := newDir(t) + if ManagesLiveServerOnPort(dir, port) { + t.Fatal("bd never started a server here") + } + write(t, dir, PortFileName, port) + if ManagesLiveServerOnPort(dir, port) { + t.Fatal("a port file with no pid file proves nothing about liveness") + } + }) + + t.Run("garbage pid file is not proof", func(t *testing.T) { + dir := newDir(t) + write(t, dir, PortFileName, port) + if err := os.WriteFile(filepath.Join(dir, PIDFileName), []byte("not-a-pid"), 0o600); err != nil { + t.Fatalf("write pid: %v", err) + } + if ManagesLiveServerOnPort(dir, port) { + t.Fatal("an unparseable pid file must fail closed") + } + }) + + t.Run("degenerate inputs fail closed", func(t *testing.T) { + if ManagesLiveServerOnPort("", port) { + t.Fatal("no workspace, no proof") + } + if ManagesLiveServerOnPort(newDir(t), 0) { + t.Fatal("port 0 means unresolved; there is no endpoint to own") + } + }) + + // Read-only: unlike IsRunning, classifying a connection must never repair + // or delete a workspace's server state as a side effect. + t.Run("does not mutate workspace state", func(t *testing.T) { + dir := newDir(t) + write(t, dir, PortFileName, port) + write(t, dir, PIDFileName, dead) + if ManagesLiveServerOnPort(dir, port) { + t.Fatal("dead pid must not be proof") + } + for _, name := range []string{PortFileName, PIDFileName} { + if _, err := os.Stat(filepath.Join(dir, name)); err != nil { + t.Fatalf("%s was removed: %v — the predicate must not repair state it merely reads", name, err) + } + } + }) +} diff --git a/internal/storage/dolt/shared_server_predicate_test.go b/internal/storage/dolt/shared_server_predicate_test.go index d1c79335e..0d2ca30de 100644 --- a/internal/storage/dolt/shared_server_predicate_test.go +++ b/internal/storage/dolt/shared_server_predicate_test.go @@ -1,52 +1,97 @@ package dolt import ( + "context" "os" "path/filepath" + "strconv" "testing" + + "github.com/steveyegge/beads/internal/configfile" + "github.com/steveyegge/beads/internal/doltserver" ) -// TestSharedServerDatabase pins which topologies the #5920 consent gate -// applies to. Getting this wrong is expensive in both directions: too broad -// and bd refuses to migrate a workspace's own database (the release blocker -// this predicate was introduced to fix), too narrow and an upgraded client -// silently promotes the schema for a whole team. +// clearPredicateEnv fixes every BEADS_DOLT_* signal the predicate reads. The +// predicate reads process state, so a leaked variable from a sibling test would +// otherwise decide the answer. One list, shared by every test in this file: two +// copies would mean the next signal added to the predicate has to be added to +// both, and forgetting one silently reintroduces exactly the leak this exists +// to prevent. +func clearPredicateEnv(t *testing.T) { + t.Helper() + for _, k := range []string{ + "BEADS_DOLT_SHARED_SERVER", "BEADS_DOLT_SERVER_MODE", + "BEADS_DOLT_SERVER_HOST", "BEADS_DOLT_SERVER_PORT", "BEADS_DOLT_PORT", + "BEADS_DOLT_SERVER_SOCKET", "BEADS_DOLT_SERVER_TLS", + } { + t.Setenv(k, "") + } +} + +// unmanagedWorkspace is a .beads directory with no server state files: bd never +// started a server here. Whatever it is connected to, it was pointed at. +func unmanagedWorkspace(t *testing.T) string { + t.Helper() + dir := filepath.Join(t.TempDir(), ".beads") + if err := os.MkdirAll(dir, 0o755); err != nil { + t.Fatalf("mkdir: %v", err) + } + return dir +} + +// managedWorkspace is a .beads directory carrying the state files +// doltserver.Start writes: a port file naming port, and a PID file naming a +// live process. This is the auto-started single-workspace server of #6088. // -// Every case fixes the environment explicitly — the predicate reads process -// state, so a leaked BEADS_DOLT_* from another test would otherwise decide the -// answer. +// The PID is this test process, which is alive by construction. That is a +// faithful stand-in because the predicate deliberately checks liveness only — +// doltserver.ManagesLiveServerOnPort documents why it stops short of the +// `ps`-based command-name check that would distinguish a dolt process. +func managedWorkspace(t *testing.T, port int) string { + t.Helper() + dir := unmanagedWorkspace(t) + writeServerState(t, dir, port, os.Getpid()) + return dir +} + +func writeServerState(t *testing.T, beadsDir string, port, pid int) { + t.Helper() + if port > 0 { + if err := os.WriteFile(filepath.Join(beadsDir, doltserver.PortFileName), + []byte(strconv.Itoa(port)), 0o600); err != nil { + t.Fatalf("write port file: %v", err) + } + } + if pid > 0 { + if err := os.WriteFile(filepath.Join(beadsDir, doltserver.PIDFileName), + []byte(strconv.Itoa(pid)), 0o600); err != nil { + t.Fatalf("write pid file: %v", err) + } + } +} + +// deadPID returns a PID that is almost certainly not running. Allocating and +// reaping a real child would be exact, but the predicate only needs a number +// no live process answers to; PID 0x7FFFFFFE is above every default pid_max. +const deadPID = 2147483646 + +// TestSharedServerDatabase pins which topologies the #5920 consent gate applies +// to. Getting this wrong is expensive in both directions: too broad and bd +// refuses to migrate a workspace's own database (#6088, the release blocker +// this predicate was narrowed to fix), too narrow and an upgraded client +// silently promotes the schema for a whole team (#5920, and the env-port bypass +// that reopened it). func TestSharedServerDatabase(t *testing.T) { - // A workspace with no metadata.json: doltserver resolves it as a server - // whose lifecycle bd owns. - ownedWorkspace := func(t *testing.T) string { - t.Helper() - dir := filepath.Join(t.TempDir(), ".beads") - if err := os.MkdirAll(dir, 0o755); err != nil { - t.Fatalf("mkdir: %v", err) - } - return dir - } - - clearEnv := func(t *testing.T) { - t.Helper() - for _, k := range []string{ - "BEADS_DOLT_SHARED_SERVER", "BEADS_DOLT_SERVER_MODE", - "BEADS_DOLT_SERVER_HOST", "BEADS_DOLT_SERVER_PORT", "BEADS_DOLT_PORT", - } { - t.Setenv(k, "") - } - } - - t.Run("bd-owned local server is not shared", func(t *testing.T) { - clearEnv(t) - cfg := &Config{BeadsDir: ownedWorkspace(t), ServerHost: "127.0.0.1", ServerPort: 3307} + t.Run("a live bd-managed server for this workspace is not shared", func(t *testing.T) { + clearPredicateEnv(t) + cfg := &Config{BeadsDir: managedWorkspace(t, 3307), ServerHost: "127.0.0.1", ServerPort: 3307} if sharedServerDatabase(cfg) { - t.Fatal("a server bd auto-started for this workspace must migrate on open, as embedded does") + t.Fatal("a server bd started for this workspace must migrate on open, as embedded does (#6088)") } }) t.Run("no workspace fails closed", func(t *testing.T) { - clearEnv(t) + clearPredicateEnv(t) // A bare dolt.New pointed at an endpoint: nothing proves bd owns it, // and a library caller attached to a team's server must not migrate it. cfg := &Config{ServerHost: "127.0.0.1", ServerPort: 3307} @@ -59,18 +104,20 @@ func TestSharedServerDatabase(t *testing.T) { }) t.Run("shared-server mode is shared", func(t *testing.T) { - clearEnv(t) + clearPredicateEnv(t) t.Setenv("BEADS_DOLT_SHARED_SERVER", "1") - cfg := &Config{BeadsDir: ownedWorkspace(t), ServerHost: "127.0.0.1", ServerPort: 3308} + cfg := &Config{BeadsDir: managedWorkspace(t, 3308), ServerHost: "127.0.0.1", ServerPort: 3308} if !sharedServerDatabase(cfg) { t.Fatal("shared-server mode is one server for many workspaces — the #5920 shape") } }) t.Run("explicit external server mode is shared", func(t *testing.T) { - clearEnv(t) + clearPredicateEnv(t) t.Setenv("BEADS_DOLT_SERVER_MODE", "1") - cfg := &Config{BeadsDir: ownedWorkspace(t), ServerHost: "127.0.0.1", ServerPort: 3307} + // Even with the ownership proof present: an explicit declaration that + // the lifecycle is external outranks it. + cfg := &Config{BeadsDir: managedWorkspace(t, 3307), ServerHost: "127.0.0.1", ServerPort: 3307} if !sharedServerDatabase(cfg) { t.Fatal("an operator-managed server is not bd's to migrate unprompted") } @@ -85,12 +132,215 @@ func TestSharedServerDatabase(t *testing.T) { {name: "unix socket", cfg: Config{ServerHost: "127.0.0.1", ServerSocket: "/tmp/dolt.sock"}}, } { t.Run(tt.name+" is shared", func(t *testing.T) { - clearEnv(t) + clearPredicateEnv(t) cfg := tt.cfg - cfg.BeadsDir = ownedWorkspace(t) + cfg.BeadsDir = managedWorkspace(t, 3307) if !sharedServerDatabase(&cfg) { t.Fatalf("%s cannot be a server bd auto-started for this workspace", tt.name) } }) } } + +// TestSharedServerDatabaseOwnershipProof covers the bypasses that made the +// #5920 gate miss the reported deployment, and the false positives that a +// coarser rule would create. +// +// The unifying point: a local TCP endpoint on 127.0.0.1 looks identical however +// bd arrived at it. The env var, a config.yaml pin, `bd init --server-port`, a +// library caller's hand-built Config and a stale port file all produce one, and +// each was (or would be) a separate silent bypass. Only the state files bd +// writes when it starts a server distinguish them. +func TestSharedServerDatabaseOwnershipProof(t *testing.T) { + // 3307 is both the reported deployment's port and + // configfile.DefaultDoltServerPort, which is why these collisions are + // likely rather than exotic. + const port = 3307 + + t.Run("env-pointed server with no bd-managed server is shared", func(t *testing.T) { + clearPredicateEnv(t) + t.Setenv("BEADS_DOLT_SERVER_PORT", strconv.Itoa(port)) + cfg := &Config{ + BeadsDir: unmanagedWorkspace(t), + ServerHost: "127.0.0.1", + ServerPort: port, + ServerPortSource: doltserver.PortSourceEnv, + } + if !sharedServerDatabase(cfg) { + t.Fatal("BEADS_DOLT_SERVER_PORT names a server that already existed; bd never started it") + } + }) + + // The reported bug's second door. applyConfigDefaults stamps + // PortSourceCallerExplicit onto ANY caller-preset port, and + // `bd init --server-port` is the documented way to attach a workspace to an + // existing server — so treating that source as proof of ownership left the + // blocker open through the flag bd's own help text recommends. + t.Run("bd init --server-port at an external server is shared", func(t *testing.T) { + clearPredicateEnv(t) + cfg := &Config{ + BeadsDir: unmanagedWorkspace(t), + ServerHost: "127.0.0.1", + ServerPort: port, + ServerPortSource: doltserver.PortSourceCallerExplicit, + } + if !sharedServerDatabase(cfg) { + t.Fatal("a caller asserting a port is not bd having started that server") + } + }) + + // Same door, library spelling: an embedder building a Config by hand. + t.Run("hand-built library config at an external server is shared", func(t *testing.T) { + clearPredicateEnv(t) + cfg := &Config{BeadsDir: unmanagedWorkspace(t), ServerHost: "127.0.0.1", ServerPort: port} + if !sharedServerDatabase(cfg) { + t.Fatal("an embedder pointed at a team's server must not migrate it") + } + }) + + // A port file records that bd once bound a port, not that the process + // answering it now is bd's. Without a liveness check, a workspace whose own + // server died launders whatever server later occupies that port. + t.Run("stale port file whose server died is shared", func(t *testing.T) { + clearPredicateEnv(t) + dir := unmanagedWorkspace(t) + writeServerState(t, dir, port, deadPID) + t.Setenv("BEADS_DOLT_SERVER_PORT", strconv.Itoa(port)) + cfg := &Config{ + BeadsDir: dir, + ServerHost: "127.0.0.1", + ServerPort: port, + ServerPortSource: doltserver.PortSourceEnv, + } + if !sharedServerDatabase(cfg) { + t.Fatal("the recorded server is gone; an external server now on that port is not ours to migrate") + } + }) + + t.Run("port file with no pid file is shared", func(t *testing.T) { + clearPredicateEnv(t) + dir := unmanagedWorkspace(t) + writeServerState(t, dir, port, 0) + cfg := &Config{BeadsDir: dir, ServerHost: "127.0.0.1", ServerPort: port} + if !sharedServerDatabase(cfg) { + t.Fatal("a port file alone is a record, not a live server") + } + }) + + // The port file must name the port we actually connected on: a live server + // bd manages on one port says nothing about a different endpoint. + t.Run("live bd server on a different port is shared", func(t *testing.T) { + clearPredicateEnv(t) + cfg := &Config{BeadsDir: managedWorkspace(t, 40083), ServerHost: "127.0.0.1", ServerPort: port} + if !sharedServerDatabase(cfg) { + t.Fatal("bd's server is on another port; this endpoint is somebody else's") + } + }) + + // The #6088 direction, and the false positive a coarser rule would create: + // a single-user workspace that pinned dolt.port in config.yaml — the very + // configuration bd's own auto-start warning recommends ("To pin a port: set + // dolt.port in .beads/config.yaml") — with bd auto-starting its own server + // on that port. Classifying the pin itself as shared would hard-refuse it. + t.Run("config.yaml-pinned port with a live bd server still migrates", func(t *testing.T) { + clearPredicateEnv(t) + cfg := &Config{ + BeadsDir: managedWorkspace(t, port), + ServerHost: "127.0.0.1", + ServerPort: port, + ServerPortSource: doltserver.PortSourceConfigYaml, + } + if sharedServerDatabase(cfg) { + t.Fatal("a pinned port bd auto-started on is still this workspace's own server") + } + }) + + // Same, for the env var: exporting BEADS_DOLT_SERVER_PORT is also how a + // caller tells bd which port to BIND before doltserver.Start, which is the + // shape #5781's lenient-open recovery runs in. + t.Run("env port that bd itself bound still migrates", func(t *testing.T) { + clearPredicateEnv(t) + t.Setenv("BEADS_DOLT_SERVER_PORT", "34567") + cfg := &Config{ + BeadsDir: managedWorkspace(t, 34567), + ServerHost: "127.0.0.1", + ServerPort: 34567, + ServerPortSource: doltserver.PortSourceEnv, + } + if sharedServerDatabase(cfg) { + t.Fatal("bd started this server for this workspace and recorded it; it must still migrate on open") + } + }) + + // dolt's own config.yaml inside the workspace's dolt dir is not written by + // bd as an ownership record — an operator can run their own long-lived + // sql-server over that directory, or leave a stale file behind. + t.Run("dolt config.yaml port without a live bd server is shared", func(t *testing.T) { + clearPredicateEnv(t) + cfg := &Config{ + BeadsDir: unmanagedWorkspace(t), + ServerHost: "127.0.0.1", + ServerPort: port, + ServerPortSource: doltserver.PortSourceDoltConfigYaml, + } + if !sharedServerDatabase(cfg) { + t.Fatal("nothing in bd writes dolt's config.yaml as proof of ownership") + } + }) +} + +// TestSharedServerDatabaseThroughResolvedConfig closes the gap between the unit +// tests above, which hand-build a Config, and what a real open produces. +// +// Every other test here asserts the predicate's behavior for a given Config. If +// the config path stopped producing that Config — a caller presetting the port, +// a change to ApplyResolvedServerPort's precedence, applyConfigDefaults' +// re-stamp condition (store.go, be-9tju) — the bug would return with every one +// of them still green. This one drives the real path. +func TestSharedServerDatabaseThroughResolvedConfig(t *testing.T) { + clearPredicateEnv(t) + + // The reported deployment's exact workspace shape: server mode, and NO + // dolt_server_port. The endpoint exists only in the environment. + // + // The port is deliberately NOT 3307. This test binary runs with + // BEADS_TEST_MODE=1, whose production-port firewall rewrites a resolved + // production port to 1 (applyConfigDefaults) — which would mask the very + // resolution this test exists to pin. Provenance is what is under test, not + // the number. + const envPort = 45671 + + dir := unmanagedWorkspace(t) + metadata := `{"database":"beads","backend":"dolt","dolt_mode":"server","dolt_database":"beads"}` + if err := os.WriteFile(filepath.Join(dir, "metadata.json"), []byte(metadata), 0o600); err != nil { + t.Fatalf("write metadata: %v", err) + } + t.Setenv("BEADS_DOLT_SERVER_PORT", strconv.Itoa(envPort)) + + fileCfg, err := configfile.Load(dir) + if err != nil { + t.Fatalf("load metadata: %v", err) + } + cfg := &Config{} + if err := applyResolvedConfig(context.Background(), dir, fileCfg, cfg); err != nil { + t.Fatalf("applyResolvedConfig: %v", err) + } + applyConfigDefaults(cfg) + + // The connection path honors the env var... + if cfg.ServerPort != envPort { + t.Fatalf("resolved ServerPort = %d, want %d — the env var must decide the endpoint", + cfg.ServerPort, envPort) + } + // ...while the lifecycle resolver, which reads metadata.json only, does + // not. That disagreement IS the bug; if it ever closes, this test should be + // revisited rather than silently continuing to pass for a new reason. + if got := doltserver.ResolveServerMode(dir); got != doltserver.ServerModeOwned { + t.Logf("note: ResolveServerMode now returns %v for the env-port shape (was ServerModeOwned)", got) + } + // The predicate must gate it regardless. + if !sharedServerDatabase(cfg) { + t.Fatal("a workspace whose endpoint came only from BEADS_DOLT_SERVER_PORT must be gated, " + + "not migrated in place (#5920 bypass)") + } +} diff --git a/internal/storage/dolt/store.go b/internal/storage/dolt/store.go index e28bde65e..966acedcb 100644 --- a/internal/storage/dolt/store.go +++ b/internal/storage/dolt/store.go @@ -2823,6 +2823,25 @@ func initSchemaOnDBWithRetryAndGateBootstrapHeal( // the right idea but are populated only by the CLI (or, for the last, only // under BEADS_TEST_MODE): a library caller pointed at a genuinely shared // server leaves them false, and reading them would silently ungate it. +// +// ResolveServerMode alone is not enough, because it answers a DIFFERENT +// question. Its contract is "may bd manage this server's lifecycle", and its +// port arm reads dolt_server_port from metadata.json ONLY — while the +// connection path (configfile.GetDoltServerPort, and doltserver's precedence +// chain behind ApplyResolvedServerPort) takes BEADS_DOLT_SERVER_PORT first. +// A workspace pointed at an externally-managed server purely by that env var +// therefore resolved ServerModeOwned while bd was connected to a server it had +// never started: bd believed it owned a private server and silently promoted +// the schema of a shared one. +// +// So ownership is not inferred from the connection at all. It is PROVEN, by +// the state files bd writes when it starts a server (see +// doltserver.ManagesLiveServerOnPort), and everything else is shared. The +// inverse — enumerating the ways an endpoint can be foreign — was tried and is +// unbounded: an env var, a config.yaml pin, `bd init --server-port`, a +// hand-built library Config and a stale port file all produce a local TCP +// endpoint indistinguishable from an owned one, and each is a separate silent +// bypass. There is exactly one way to be sure, and it is cheap. func sharedServerDatabase(cfg *Config) bool { // No workspace to prove ownership from — a bare dolt.New pointed at some // endpoint. Fail closed. @@ -2840,6 +2859,22 @@ func sharedServerDatabase(cfg *Config) bool { if doltserver.IsSharedServerMode() { return true } + // The proof. Without a live server bd started for THIS workspace on the + // very port this store is connected to, the database belongs to someone + // else and migrating it is not this open's call to make. + // + // cfg.BeadsDir, not doltserver.ResolveServerDir(cfg.BeadsDir): the two + // differ only in shared-server mode, which returned above. Resolving here + // would read another directory's state files for the one topology this + // line can no longer be reached in. + if !doltserver.ManagesLiveServerOnPort(cfg.BeadsDir, cfg.ServerPort) { + return true + } + // Proof of a bd-managed server does not override an explicit declaration + // that the lifecycle is external (metadata dolt_server_port, host + // inference, BEADS_DOLT_SERVER_MODE). Keeping this last means the change + // above can only ever ADD shared classifications to what #5920/#6048 + // already gated, never remove one. return doltserver.ResolveServerMode(cfg.BeadsDir) != doltserver.ServerModeOwned }