fix(storage): an env-pointed server is shared, not owned — close the migrate-gate bypass (#6118)

* 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 <noreply@anthropic.com>

* 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 <noreply@anthropic.com>

* 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 <noreply@anthropic.com>
This commit is contained in:
Julian Knutsen 2026-09-04 23:37:32 -07:00 • committed by GitHub
commit 62884bb87d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 537 additions and 37 deletions

View file

@ -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

View file

@ -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)
}
}
})
}

View file

@ -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)")
}
}

View file

@ -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
}