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 }