fix(backup): report embedded database size (#4920) (#4928)

Resolve backup status sizing through an optional per-instance ActiveDatabaseSizer instead of inferring storage locality from generic paths. Embedded and authoritatively local server stores measure only the active database; unsupported or external stores omit the optional field, while declared-local filesystem failures remain fatal.

Agent-Signature: codex-tui-gpt-5.6-sol-ultra on behalf of Ewen Cuthiell

Co-authored-by: matt wilkie <maphew@gmail.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
ecuthiell 2026-07-25 17:14:07 -06:00 • committed by GitHub
commit b37558b6ab
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 1148 additions and 146 deletions

View file

@ -1,6 +1,7 @@
package main
import (
"context"
"encoding/json"
"fmt"
"time"
@ -43,93 +44,109 @@ Auto-backup default:
GroupID: "sync",
}
var backupStatusCmd = &cobra.Command{
Use: "status",
Short: "Show last backup status",
RunE: func(cmd *cobra.Command, args []string) error {
if usesProxiedServer() {
return HandleErrorRespectJSON("backup status is not supported in proxied-server mode")
}
evt := metrics.NewCommandEvent("backup-status")
defer func() {
if c := metrics.Global(); c != nil {
c.CloseEventAndAdd(evt)
}
}()
type backupSizeFunc func(context.Context) (bytes int64, available bool, err error)
dir, err := backupDir()
if err != nil {
return err
}
var backupStatusCmd = newBackupStatusCommand(doltBackupSize)
state, err := loadBackupState(dir)
if err != nil {
return err
}
func newBackupStatusCommand(sizeDatabase backupSizeFunc) *cobra.Command {
return &cobra.Command{
Use: "status",
Short: "Show last backup status",
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
if usesProxiedServer() {
return HandleErrorRespectJSON("backup status is not supported in proxied-server mode")
}
evt := metrics.NewCommandEvent("backup-status")
defer func() {
if c := metrics.Global(); c != nil {
c.CloseEventAndAdd(evt)
}
}()
if jsonOutput {
result := map[string]interface{}{
"backup": state,
"dolt": showDoltBackupStatusJSON(),
}
if dbSize := showDBSizeJSON(); dbSize != nil {
result["database_size"] = dbSize
}
data, err := json.MarshalIndent(result, "", " ")
dir, err := backupDir()
if err != nil {
return err
}
fmt.Println(string(data))
return nil
}
hasBackup := state.LastDoltCommit != ""
hasDolt := false
if cfg, _ := loadDoltBackupConfig(); cfg != nil {
hasDolt = true
}
if !hasBackup && !hasDolt {
fmt.Println("No backup has been performed yet.")
fmt.Println()
fmt.Println("Setup:")
fmt.Println(" bd backup init <path> Set up a backup destination")
fmt.Println(" bd backup sync Push to backup destination")
showDBSize()
return nil
}
if hasBackup {
fmt.Println("Backup:")
fmt.Printf(" Last backup: %s (%s ago)\n",
state.Timestamp.Format(time.RFC3339),
time.Since(state.Timestamp).Round(time.Second))
fmt.Printf(" Dolt commit: %s\n", state.LastDoltCommit)
}
// Show config (effective values with source)
enabled := isBackupAutoEnabled()
interval := config.GetDuration("backup.interval")
enabledSource := config.GetValueSource("backup.enabled")
enabledNote := ""
if enabledSource == config.SourceDefault {
if enabled {
enabledNote = " (auto: git remote detected)"
} else {
enabledNote = " (auto: no git remote)"
state, err := loadBackupState(dir)
if err != nil {
return err
}
databaseSize, sizeAvailable, err := sizeDatabase(cmd.Context())
if err != nil {
return HandleErrorRespectJSON("measure database size: %v", err)
}
}
fmt.Printf("\nConfig: enabled=%v%s interval=%s\n",
enabled, enabledNote, interval)
// Show Dolt backup info
showDoltBackupStatus()
if jsonOutput {
result := map[string]interface{}{
"backup": state,
"dolt": showDoltBackupStatusJSON(),
}
if sizeAvailable {
result["database_size"] = showDBSizeJSON(databaseSize)
}
data, err := json.MarshalIndent(result, "", " ")
if err != nil {
return err
}
fmt.Println(string(data))
return nil
}
// Show database size
showDBSize()
hasBackup := state.LastDoltCommit != ""
hasDolt := false
if cfg, _ := loadDoltBackupConfig(); cfg != nil {
hasDolt = true
}
return nil
},
if !hasBackup && !hasDolt {
fmt.Println("No backup has been performed yet.")
fmt.Println()
fmt.Println("Setup:")
fmt.Println(" bd backup init <path> Set up a backup destination")
fmt.Println(" bd backup sync Push to backup destination")
if sizeAvailable {
showDBSize(databaseSize)
}
return nil
}
if hasBackup {
fmt.Println("Backup:")
fmt.Printf(" Last backup: %s (%s ago)\n",
state.Timestamp.Format(time.RFC3339),
time.Since(state.Timestamp).Round(time.Second))
fmt.Printf(" Dolt commit: %s\n", state.LastDoltCommit)
}
// Show config (effective values with source)
enabled := isBackupAutoEnabled()
interval := config.GetDuration("backup.interval")
enabledSource := config.GetValueSource("backup.enabled")
enabledNote := ""
if enabledSource == config.SourceDefault {
if enabled {
enabledNote = " (auto: git remote detected)"
} else {
enabledNote = " (auto: no git remote)"
}
}
fmt.Printf("\nConfig: enabled=%v%s interval=%s\n",
enabled, enabledNote, interval)
// Show Dolt backup info
showDoltBackupStatus()
// Show database size when the active backend can measure it locally.
if sizeAvailable {
showDBSize(databaseSize)
}
return nil
},
}
}
func init() {

View file

@ -1,7 +1,9 @@
package main
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
@ -10,7 +12,6 @@ import (
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/beads"
"github.com/steveyegge/beads/internal/doltserver"
"github.com/steveyegge/beads/internal/metrics"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/versioncontrolops"
@ -354,46 +355,43 @@ func showDoltBackupStatusJSON() map[string]interface{} {
return result
}
// doltBackupSize returns the approximate size of the Dolt data directory in bytes.
func doltBackupSize() (int64, error) {
beadsDir := beads.FindBeadsDir()
if beadsDir == "" {
return 0, fmt.Errorf("%s", activeWorkspaceNotFoundError())
// doltBackupSize returns the active database size when the current store
// instance can measure its storage locally. Unsupported backends preserve the
// optional status-field contract instead of failing the command.
func doltBackupSize(ctx context.Context) (int64, bool, error) {
if store == nil {
return 0, false, fmt.Errorf("no storage backend is open")
}
dataDir := doltserver.ResolveDoltDir(beadsDir)
return dirSize(dataDir)
return doltBackupSizeForStore(ctx, store)
}
// dirSize walks a directory tree and sums file sizes.
func dirSize(path string) (int64, error) {
var size int64
err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
if err != nil {
return nil // skip errors (permission denied, etc.)
func doltBackupSizeForStore(ctx context.Context, candidate storage.DoltStorage) (int64, bool, error) {
sizer, ok := storage.UnwrapStore(candidate).(storage.ActiveDatabaseSizer)
if !ok {
return 0, false, nil
}
return doltBackupSizeFromSizer(ctx, sizer)
}
func doltBackupSizeFromSizer(ctx context.Context, sizer storage.ActiveDatabaseSizer) (int64, bool, error) {
size, err := sizer.ActiveDatabaseSize(ctx)
if err != nil {
var unsupported *storage.ErrUnsupported
if errors.As(err, &unsupported) {
return 0, false, nil
}
if !info.IsDir() {
size += info.Size()
}
return nil
})
return size, err
return 0, false, err
}
return size, true, nil
}
// showDBSize prints the database size as part of status.
func showDBSize() {
size, err := doltBackupSize()
if err != nil {
return
}
func showDBSize(size int64) {
fmt.Printf(" Database size: %s\n", formatBytes(size))
}
// showDBSizeJSON returns database size for JSON output.
func showDBSizeJSON() map[string]interface{} {
size, err := doltBackupSize()
if err != nil {
return nil
}
func showDBSizeJSON(size int64) map[string]interface{} {
return map[string]interface{}{
"bytes": size,
"human": formatBytes(size),

View file

@ -1,11 +1,15 @@
package main
import (
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"testing"
"time"
"github.com/steveyegge/beads/internal/storage"
)
func TestResolveDoltBackupURL(t *testing.T) {
@ -182,29 +186,57 @@ func TestFormatBytes(t *testing.T) {
}
}
func TestDirSize(t *testing.T) {
type backupSizeStub struct {
size int64
err error
}
func (s backupSizeStub) ActiveDatabaseSize(context.Context) (int64, error) {
return s.size, s.err
}
func TestDoltBackupSizeFromSizer(t *testing.T) {
t.Parallel()
dir := t.TempDir()
// Create a few test files
if err := os.WriteFile(filepath.Join(dir, "a.txt"), []byte("hello"), 0600); err != nil {
t.Fatalf("write: %v", err)
failure := errors.New("measurement failed")
tests := []struct {
name string
sizer storage.ActiveDatabaseSizer
wantSize int64
wantAvailable bool
wantErr error
}{
{
name: "available",
sizer: backupSizeStub{size: 42},
wantSize: 42,
wantAvailable: true,
},
{
name: "unsupported",
sizer: backupSizeStub{err: &storage.ErrUnsupported{
Op: "ActiveDatabaseSize",
Backend: "external",
}},
},
{
name: "declared local failure",
sizer: backupSizeStub{err: failure},
wantErr: failure,
},
}
sub := filepath.Join(dir, "sub")
if err := os.MkdirAll(sub, 0700); err != nil {
t.Fatalf("mkdir: %v", err)
}
if err := os.WriteFile(filepath.Join(sub, "b.txt"), []byte("world!"), 0600); err != nil {
t.Fatalf("write: %v", err)
}
size, err := dirSize(dir)
if err != nil {
t.Fatalf("dirSize: %v", err)
}
// "hello" = 5 bytes, "world!" = 6 bytes = 11 total
if size != 11 {
t.Errorf("dirSize = %d, want 11", size)
for _, tc := range tests {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
size, available, err := doltBackupSizeFromSizer(t.Context(), tc.sizer)
if size != tc.wantSize || available != tc.wantAvailable || !errors.Is(err, tc.wantErr) {
t.Fatalf(
"doltBackupSizeFromSizer = (%d, %v, %v), want (%d, %v, %v)",
size, available, err, tc.wantSize, tc.wantAvailable, tc.wantErr,
)
}
})
}
}

View file

@ -3,6 +3,7 @@
package main
import (
"encoding/json"
"fmt"
"os"
"os/exec"
@ -70,6 +71,22 @@ func TestEmbeddedBackup(t *testing.T) {
if out == "" {
t.Error("expected non-empty status output")
}
if strings.Contains(out, "Database size: 0 B") {
t.Errorf("embedded backup status reported an empty database: %s", out)
}
jsonOut := bdBackup(t, bd, dir, "status", "--json")
var status struct {
DatabaseSize struct {
Bytes int64 `json:"bytes"`
} `json:"database_size"`
}
if err := json.Unmarshal([]byte(jsonOut), &status); err != nil {
t.Fatalf("parse backup status JSON: %v\noutput: %s", err, jsonOut)
}
if status.DatabaseSize.Bytes <= 0 {
t.Errorf("database_size.bytes = %d, want > 0; output: %s", status.DatabaseSize.Bytes, jsonOut)
}
})
t.Run("init_and_sync", func(t *testing.T) {

View file

@ -0,0 +1,270 @@
package main
import (
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"github.com/spf13/cobra"
)
func TestBackupStatusSizeErrorRespectsOutputMode(t *testing.T) {
prepareBackupStatusTest(t)
missingRoot := filepath.Join(t.TempDir(), "missing")
sizeErr := errors.New("active database directory is missing: " + missingRoot)
sizeDatabase := func(context.Context) (int64, bool, error) {
return 0, false, sizeErr
}
t.Run("json", func(t *testing.T) {
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status", "--json"})
stdout, stderr, err := executeBackupStatusCommand(t, cmd)
assertExitCode(t, err, 1)
if stderr != "" {
t.Errorf("stderr = %q, want empty", stderr)
}
var response struct {
Error string `json:"error"`
}
if err := json.Unmarshal([]byte(stdout), &response); err != nil {
t.Fatalf("stdout is not a single valid JSON response: %v\nstdout: %s", err, stdout)
}
if !strings.Contains(response.Error, "measure database size") || !strings.Contains(response.Error, missingRoot) {
t.Errorf("error = %q, want database-size diagnostic containing %q", response.Error, missingRoot)
}
if strings.Contains(stdout, "Usage:") {
t.Errorf("stdout contains usage noise: %s", stdout)
}
})
t.Run("human", func(t *testing.T) {
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status"})
stdout, stderr, err := executeBackupStatusCommand(t, cmd)
assertExitCode(t, err, 1)
if stdout != "" {
t.Errorf("stdout = %q, want empty", stdout)
}
if !strings.Contains(stderr, "Error: measure database size:") || !strings.Contains(stderr, missingRoot) {
t.Errorf("stderr = %q, want database-size diagnostic containing %q", stderr, missingRoot)
}
if strings.Contains(stderr, "Usage:") || strings.Contains(stderr, "exit code 1") {
t.Errorf("stderr contains Cobra noise: %s", stderr)
}
})
}
func TestBackupStatusOmitsUnsupportedDatabaseSize(t *testing.T) {
prepareBackupStatusTest(t)
sizeDatabase := func(context.Context) (int64, bool, error) {
return 0, false, nil
}
t.Run("json", func(t *testing.T) {
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status", "--json"})
stdout, stderr, err := executeBackupStatusCommand(t, cmd)
if err != nil {
t.Fatalf("backup status: %v", err)
}
if stderr != "" {
t.Errorf("stderr = %q, want empty", stderr)
}
var response map[string]json.RawMessage
if err := json.Unmarshal([]byte(stdout), &response); err != nil {
t.Fatalf("stdout is not valid JSON: %v\nstdout: %s", err, stdout)
}
if _, ok := response["database_size"]; ok {
t.Errorf("database_size should be omitted: %s", stdout)
}
if _, ok := response["backup"]; !ok {
t.Errorf("backup status missing backup field: %s", stdout)
}
if _, ok := response["dolt"]; !ok {
t.Errorf("backup status missing dolt field: %s", stdout)
}
})
t.Run("human", func(t *testing.T) {
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status"})
stdout, stderr, err := executeBackupStatusCommand(t, cmd)
if err != nil {
t.Fatalf("backup status: %v", err)
}
if stderr != "" {
t.Errorf("stderr = %q, want empty", stderr)
}
if strings.Contains(stdout, "Database size:") {
t.Errorf("unsupported database size should be omitted: %s", stdout)
}
if !strings.Contains(stdout, "No backup has been performed yet.") {
t.Errorf("remaining status output was not rendered: %s", stdout)
}
})
}
func TestBackupStatusIncludesAvailableDatabaseSize(t *testing.T) {
prepareBackupStatusTest(t)
sizeDatabase := func(context.Context) (int64, bool, error) {
return 1536, true, nil
}
t.Run("json", func(t *testing.T) {
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status", "--json"})
stdout, stderr, err := executeBackupStatusCommand(t, cmd)
if err != nil {
t.Fatalf("backup status: %v", err)
}
if stderr != "" {
t.Errorf("stderr = %q, want empty", stderr)
}
var response struct {
DatabaseSize struct {
Bytes int64 `json:"bytes"`
} `json:"database_size"`
}
if err := json.Unmarshal([]byte(stdout), &response); err != nil {
t.Fatalf("stdout is not valid JSON: %v\nstdout: %s", err, stdout)
}
if response.DatabaseSize.Bytes != 1536 {
t.Errorf("database_size.bytes = %d, want 1536", response.DatabaseSize.Bytes)
}
})
t.Run("human", func(t *testing.T) {
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status"})
stdout, stderr, err := executeBackupStatusCommand(t, cmd)
if err != nil {
t.Fatalf("backup status: %v", err)
}
if stderr != "" {
t.Errorf("stderr = %q, want empty", stderr)
}
if !strings.Contains(stdout, "Database size: 1.5 KB") {
t.Errorf("available database size missing: %s", stdout)
}
})
}
func TestBackupStatusProxiedGuardDoesNotMeasureSize(t *testing.T) {
prepareBackupStatusTest(t)
proxiedServerMode = true
called := false
sizeDatabase := func(context.Context) (int64, bool, error) {
called = true
return 1, true, nil
}
cmd := newBackupStatusTestRoot(sizeDatabase)
cmd.SetArgs([]string{"backup", "status"})
_, _, err := executeBackupStatusCommand(t, cmd)
assertExitCode(t, err, 1)
if called {
t.Fatal("proxied-server guard called database size provider")
}
}
func prepareBackupStatusTest(t *testing.T) {
t.Helper()
beadsDir := filepath.Join(t.TempDir(), ".beads")
if err := os.MkdirAll(filepath.Join(beadsDir, "embeddeddolt"), 0o700); err != nil {
t.Fatalf("create workspace marker: %v", err)
}
t.Setenv("BEADS_DIR", beadsDir)
t.Setenv("BD_JSON_ENVELOPE", "0")
initConfigForTest(t)
oldJSONOutput := jsonOutput
oldProxiedServerMode := proxiedServerMode
jsonOutput = false
proxiedServerMode = false
resetCommandContext()
t.Cleanup(func() {
jsonOutput = oldJSONOutput
proxiedServerMode = oldProxiedServerMode
resetCommandContext()
})
}
func newBackupStatusTestRoot(sizeDatabase backupSizeFunc) *cobra.Command {
root := &cobra.Command{Use: "bd"}
root.PersistentFlags().BoolVar(&jsonOutput, "json", false, "output JSON")
backup := &cobra.Command{Use: "backup"}
backup.AddCommand(newBackupStatusCommand(sizeDatabase))
root.AddCommand(backup)
return root
}
func executeBackupStatusCommand(t *testing.T, cmd *cobra.Command) (string, string, error) {
t.Helper()
stdioMutex.Lock()
defer stdioMutex.Unlock()
captureDir := t.TempDir()
stdoutPath := filepath.Join(captureDir, "stdout")
stderrPath := filepath.Join(captureDir, "stderr")
stdoutFile, err := os.Create(stdoutPath)
if err != nil {
t.Fatalf("create stdout capture: %v", err)
}
stderrFile, err := os.Create(stderrPath)
if err != nil {
_ = stdoutFile.Close()
t.Fatalf("create stderr capture: %v", err)
}
oldStdout := os.Stdout
oldStderr := os.Stderr
var commandErr error
func() {
defer func() {
os.Stdout = oldStdout
os.Stderr = oldStderr
}()
os.Stdout = stdoutFile
os.Stderr = stderrFile
commandErr = cmd.Execute()
}()
if err := stdoutFile.Close(); err != nil {
t.Fatalf("close stdout capture: %v", err)
}
if err := stderrFile.Close(); err != nil {
t.Fatalf("close stderr capture: %v", err)
}
stdout, err := os.ReadFile(stdoutPath)
if err != nil {
t.Fatalf("read stdout capture: %v", err)
}
stderr, err := os.ReadFile(stderrPath)
if err != nil {
t.Fatalf("read stderr capture: %v", err)
}
return string(stdout), string(stderr), commandErr
}
func assertExitCode(t *testing.T, err error, want int) {
t.Helper()
if err == nil {
t.Fatalf("command succeeded, want exit code %d", want)
}
got, ok := exitCodeFromError(err)
if !ok || got != want {
t.Fatalf("command error = %v, want exit code %d", err, want)
}
}

View file

@ -1,6 +1,7 @@
package main
import (
"context"
"os"
"testing"
@ -9,11 +10,17 @@ import (
"github.com/steveyegge/beads/internal/telemetry"
)
// stubChainStore is a stand-in for a concrete DoltStorage. It only carries
// identity for type-assertion; method invocations would panic on the embedded
// nil — the chain composition tests must not trigger any of them.
// stubChainStore is a stand-in for a concrete DoltStorage. The embedded
// interface exists only for decorator identity tests; ActiveDatabaseSize is
// implemented explicitly so the sizing-capability test never reaches a nil
// promoted method.
type stubChainStore struct {
storage.DoltStorage
databaseSize int64
}
func (s *stubChainStore) ActiveDatabaseSize(context.Context) (int64, error) {
return s.databaseSize, nil
}
// clearTelemetryEnv unsets every BD_OTEL_* variable telemetry.Enabled
@ -77,6 +84,21 @@ func TestWireStorageDecorators_TelemetryOn_HookOn(t *testing.T) {
}
}
func TestDoltBackupSizeUnwrapsStorageDecorators(t *testing.T) {
clearTelemetryEnv(t)
t.Setenv("BD_OTEL_STDOUT", "true")
raw := &stubChainStore{databaseSize: 99}
wrapped := wireStorageDecorators(raw, hooks.NewRunner("/nonexistent"), false)
size, available, err := doltBackupSizeForStore(t.Context(), wrapped)
if err != nil {
t.Fatalf("doltBackupSizeForStore: %v", err)
}
if !available || size != 99 {
t.Fatalf("doltBackupSizeForStore = (%d, %v), want (99, true)", size, available)
}
}
func TestWireStorageDecorators_TelemetryOn_HookDisabled(t *testing.T) {
clearTelemetryEnv(t)
t.Setenv("BD_OTEL_STDOUT", "true")

View file

@ -0,0 +1,66 @@
package storage
import (
"context"
"errors"
"fmt"
"io/fs"
"math"
"os"
"path/filepath"
)
type directoryWalkFunc func(string, filepath.WalkFunc) error
// MeasureDirectorySize returns the approximate size of the live file tree at
// root. It tolerates descendants disappearing while the tree is being walked,
// but a missing root or any other filesystem error is a failed measurement.
func MeasureDirectorySize(ctx context.Context, root string) (int64, error) {
if root == "" {
return 0, fmt.Errorf("directory path is empty")
}
resolvedRoot, err := filepath.EvalSymlinks(root)
if err != nil {
return 0, err
}
info, err := os.Stat(resolvedRoot)
if err != nil {
return 0, err
}
if !info.IsDir() {
return 0, fmt.Errorf("%s is not a directory", root)
}
return measureDirectorySizeWithWalk(ctx, resolvedRoot, filepath.Walk)
}
func measureDirectorySizeWithWalk(ctx context.Context, root string, walk directoryWalkFunc) (int64, error) {
var size int64
err := walk(root, func(path string, info os.FileInfo, walkErr error) error {
if err := ctx.Err(); err != nil {
return err
}
if walkErr != nil {
if path != root && errors.Is(walkErr, fs.ErrNotExist) {
return nil
}
return walkErr
}
if info == nil {
return fmt.Errorf("walk returned no file information for %s", path)
}
if info.IsDir() {
return nil
}
if info.Size() < 0 || info.Size() > math.MaxInt64-size {
return fmt.Errorf("directory size overflows int64 at %s", path)
}
size += info.Size()
return nil
})
if err != nil {
return 0, err
}
return size, nil
}

View file

@ -0,0 +1,155 @@
package storage
import (
"context"
"errors"
"io/fs"
"math"
"os"
"path/filepath"
"testing"
"time"
)
func TestMeasureDirectorySize(t *testing.T) {
t.Parallel()
root := t.TempDir()
if err := os.WriteFile(filepath.Join(root, "first"), []byte("hello"), 0o600); err != nil {
t.Fatal(err)
}
nested := filepath.Join(root, "nested")
if err := os.Mkdir(nested, 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(nested, "second"), []byte("world!"), 0o600); err != nil {
t.Fatal(err)
}
got, err := MeasureDirectorySize(t.Context(), root)
if err != nil {
t.Fatalf("MeasureDirectorySize: %v", err)
}
if got != 11 {
t.Fatalf("MeasureDirectorySize = %d, want 11", got)
}
}
func TestMeasureDirectorySizeEmptyDirectory(t *testing.T) {
t.Parallel()
got, err := MeasureDirectorySize(t.Context(), t.TempDir())
if err != nil {
t.Fatalf("MeasureDirectorySize: %v", err)
}
if got != 0 {
t.Fatalf("MeasureDirectorySize = %d, want 0", got)
}
}
func TestMeasureDirectorySizeRejectsMissingRoot(t *testing.T) {
t.Parallel()
_, err := MeasureDirectorySize(t.Context(), filepath.Join(t.TempDir(), "missing"))
if !errors.Is(err, fs.ErrNotExist) {
t.Fatalf("MeasureDirectorySize error = %v, want fs.ErrNotExist", err)
}
}
func TestMeasureDirectorySizeSkipsVanishedDescendant(t *testing.T) {
t.Parallel()
root := filepath.Clean("/root")
walk := func(_ string, visit filepath.WalkFunc) error {
if err := visit(root, fakeFileInfo{name: "root", dir: true}, nil); err != nil {
return err
}
if err := visit(filepath.Join(root, "vanished"), nil, fs.ErrNotExist); err != nil {
return err
}
return visit(filepath.Join(root, "present"), fakeFileInfo{name: "present", size: 7}, nil)
}
got, err := measureDirectorySizeWithWalk(t.Context(), root, walk)
if err != nil {
t.Fatalf("measureDirectorySizeWithWalk: %v", err)
}
if got != 7 {
t.Fatalf("measureDirectorySizeWithWalk = %d, want 7", got)
}
}
func TestMeasureDirectorySizeDoesNotSuppressRootOrOtherWalkErrors(t *testing.T) {
t.Parallel()
sentinel := errors.New("permission denied")
tests := []struct {
name string
path string
err error
}{
{name: "missing root", path: filepath.Clean("/root"), err: fs.ErrNotExist},
{name: "descendant permission failure", path: filepath.Clean("/root/child"), err: sentinel},
}
for _, tc := range tests {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
root := filepath.Clean("/root")
walk := func(_ string, visit filepath.WalkFunc) error {
return visit(tc.path, nil, tc.err)
}
_, err := measureDirectorySizeWithWalk(t.Context(), root, walk)
if !errors.Is(err, tc.err) {
t.Fatalf("measureDirectorySizeWithWalk error = %v, want %v", err, tc.err)
}
})
}
}
func TestMeasureDirectorySizeHonorsCancellation(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancel(context.Background())
cancel()
root := filepath.Clean("/root")
walk := func(_ string, visit filepath.WalkFunc) error {
return visit(root, fakeFileInfo{name: "root", dir: true}, nil)
}
_, err := measureDirectorySizeWithWalk(ctx, root, walk)
if !errors.Is(err, context.Canceled) {
t.Fatalf("measureDirectorySizeWithWalk error = %v, want context.Canceled", err)
}
}
func TestMeasureDirectorySizeRejectsOverflow(t *testing.T) {
t.Parallel()
root := filepath.Clean("/root")
walk := func(_ string, visit filepath.WalkFunc) error {
if err := visit(root, fakeFileInfo{name: "root", dir: true}, nil); err != nil {
return err
}
if err := visit(filepath.Join(root, "large"), fakeFileInfo{name: "large", size: math.MaxInt64}, nil); err != nil {
return err
}
return visit(filepath.Join(root, "overflow"), fakeFileInfo{name: "overflow", size: 1}, nil)
}
_, err := measureDirectorySizeWithWalk(t.Context(), root, walk)
if err == nil {
t.Fatal("measureDirectorySizeWithWalk succeeded, want overflow error")
}
}
type fakeFileInfo struct {
name string
size int64
dir bool
}
func (f fakeFileInfo) Name() string { return f.name }
func (f fakeFileInfo) Size() int64 { return f.size }
func (f fakeFileInfo) Mode() fs.FileMode { return 0 }
func (f fakeFileInfo) ModTime() time.Time { return time.Time{} }
func (f fakeFileInfo) IsDir() bool { return f.dir }
func (f fakeFileInfo) Sys() any { return nil }

View file

@ -0,0 +1,297 @@
package dolt
import (
"errors"
"os"
"path/filepath"
"testing"
"github.com/steveyegge/beads/internal/storage"
)
func TestResolveLocalActiveDatabaseDir(t *testing.T) {
clearSizingModeEnv(t)
t.Run("owned local", func(t *testing.T) {
clearSizingModeEnv(t)
beadsDir := t.TempDir()
root := filepath.Join(beadsDir, "dolt")
cfg := &Config{
Path: root,
BeadsDir: beadsDir,
Database: "active",
ServerHost: "127.0.0.1",
AutoStart: true,
}
want := filepath.Join(root, "active")
if got := resolveLocalActiveDatabaseDir(cfg); got != want {
t.Fatalf("resolveLocalActiveDatabaseDir = %q, want %q", got, want)
}
})
t.Run("shared local", func(t *testing.T) {
clearSizingModeEnv(t)
sharedDir := t.TempDir()
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
cfg := &Config{
Path: filepath.Join(t.TempDir(), "dolt"),
BeadsDir: t.TempDir(),
Database: "shared_active",
ServerHost: "localhost",
}
want := filepath.Join(sharedDir, "dolt", "shared_active")
if got := resolveLocalActiveDatabaseDir(cfg); got != want {
t.Fatalf("resolveLocalActiveDatabaseDir = %q, want %q", got, want)
}
})
tests := []struct {
name string
setup func(*testing.T, *Config)
}{
{
name: "owned without auto-start authority",
setup: func(_ *testing.T, cfg *Config) {
cfg.AutoStart = false
},
},
{
name: "external server mode",
setup: func(t *testing.T, _ *Config) {
t.Setenv("BEADS_DOLT_SERVER_MODE", "1")
},
},
{
name: "environment endpoint",
setup: func(t *testing.T, _ *Config) {
t.Setenv("BEADS_DOLT_SERVER_PORT", "44001")
},
},
{
name: "legacy environment endpoint",
setup: func(t *testing.T, _ *Config) {
t.Setenv("BEADS_DOLT_PORT", "44001")
},
},
{
name: "shared mode with explicit endpoint",
setup: func(t *testing.T, _ *Config) {
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
t.Setenv("BEADS_SHARED_SERVER_DIR", t.TempDir())
t.Setenv("BEADS_DOLT_SERVER_PORT", "44001")
},
},
{
name: "remote host",
setup: func(_ *testing.T, cfg *Config) {
cfg.ServerHost = "db.example.test"
},
},
{
name: "socket",
setup: func(_ *testing.T, cfg *Config) {
cfg.ServerSocket = "/tmp/dolt.sock"
},
},
{
name: "TLS",
setup: func(_ *testing.T, cfg *Config) {
cfg.ServerTLS = true
},
},
{
name: "gateway",
setup: func(_ *testing.T, cfg *Config) {
cfg.Gateway = true
},
},
{
name: "proxied",
setup: func(_ *testing.T, cfg *Config) {
cfg.ProxiedServer = true
},
},
}
for _, tc := range tests {
tc := tc
t.Run(tc.name, func(t *testing.T) {
clearSizingModeEnv(t)
beadsDir := t.TempDir()
cfg := &Config{
Path: filepath.Join(beadsDir, "dolt"),
BeadsDir: beadsDir,
Database: "active",
ServerHost: "127.0.0.1",
AutoStart: true,
}
tc.setup(t, cfg)
if got := resolveLocalActiveDatabaseDir(cfg); got != "" {
t.Fatalf("resolveLocalActiveDatabaseDir = %q, want unsupported", got)
}
})
}
}
func TestDoltStoreActiveDatabaseSizeKeepsPerInstanceAuthorityAcrossModeChurn(t *testing.T) {
clearSizingModeEnv(t)
newSizingStore := func(cfg *Config) *DoltStore {
return &DoltStore{
dbPath: cfg.Path,
beadsDir: cfg.BeadsDir,
database: cfg.Database,
localActiveDatabaseDir: resolveLocalActiveDatabaseDir(cfg),
serverMode: true,
}
}
requireSize := func(store *DoltStore, want int64) {
t.Helper()
got, err := store.ActiveDatabaseSize(t.Context())
if err != nil {
t.Fatalf("ActiveDatabaseSize: %v", err)
}
if got != want {
t.Fatalf("ActiveDatabaseSize = %d, want %d", got, want)
}
}
requireUnsupported := func(store *DoltStore) {
t.Helper()
_, err := store.ActiveDatabaseSize(t.Context())
var unsupported *storage.ErrUnsupported
if !errors.As(err, &unsupported) {
t.Fatalf("ActiveDatabaseSize error = %v, want *storage.ErrUnsupported", err)
}
}
ownedBeadsDir := t.TempDir()
ownedConfig := &Config{
Path: filepath.Join(ownedBeadsDir, "dolt"),
BeadsDir: ownedBeadsDir,
Database: "owned_active",
ServerHost: "127.0.0.1",
AutoStart: true,
}
ownedDatabaseDir := filepath.Join(ownedConfig.Path, ownedConfig.Database)
if err := os.MkdirAll(ownedDatabaseDir, 0o700); err != nil {
t.Fatal(err)
}
const ownedPayload = "owned database"
if err := os.WriteFile(filepath.Join(ownedDatabaseDir, "data"), []byte(ownedPayload), 0o600); err != nil {
t.Fatal(err)
}
ownedStore := newSizingStore(ownedConfig)
if ownedStore.localActiveDatabaseDir != ownedDatabaseDir {
t.Fatalf("owned localActiveDatabaseDir = %q, want %q", ownedStore.localActiveDatabaseDir, ownedDatabaseDir)
}
t.Setenv("BEADS_DOLT_PORT", "44001")
externalBeadsDir := t.TempDir()
externalConfig := &Config{
Path: filepath.Join(externalBeadsDir, "dolt"),
BeadsDir: externalBeadsDir,
Database: "external_active",
ServerHost: "127.0.0.1",
AutoStart: true,
}
externalStore := newSizingStore(externalConfig)
if externalStore.localActiveDatabaseDir != "" {
t.Fatalf("external localActiveDatabaseDir = %q, want unsupported", externalStore.localActiveDatabaseDir)
}
requireSize(ownedStore, int64(len(ownedPayload)))
requireUnsupported(externalStore)
t.Setenv("BEADS_DOLT_PORT", "")
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
t.Setenv("BEADS_SHARED_SERVER_DIR", t.TempDir())
requireSize(ownedStore, int64(len(ownedPayload)))
requireUnsupported(externalStore)
t.Setenv("BEADS_DOLT_SERVER_PORT", "44002")
sharedConfig := &Config{
Path: filepath.Join(t.TempDir(), "dolt"),
BeadsDir: t.TempDir(),
Database: "shared_explicit",
ServerHost: "localhost",
}
if got := resolveLocalActiveDatabaseDir(sharedConfig); got != "" {
t.Fatalf("shared explicit-endpoint path = %q, want unsupported", got)
}
requireSize(ownedStore, int64(len(ownedPayload)))
requireUnsupported(externalStore)
}
func TestDoltStoreActiveDatabaseSizeScopesToActiveDatabase(t *testing.T) {
t.Parallel()
root := t.TempDir()
active := filepath.Join(root, "active")
sibling := filepath.Join(root, "sibling")
if err := os.Mkdir(active, 0o700); err != nil {
t.Fatal(err)
}
if err := os.Mkdir(sibling, 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(active, "data"), []byte("active"), 0o600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(sibling, "data"), []byte("much larger sibling data"), 0o600); err != nil {
t.Fatal(err)
}
store := &DoltStore{localActiveDatabaseDir: active}
got, err := store.ActiveDatabaseSize(t.Context())
if err != nil {
t.Fatalf("ActiveDatabaseSize: %v", err)
}
if got != int64(len("active")) {
t.Fatalf("ActiveDatabaseSize = %d, want %d", got, len("active"))
}
}
func TestDoltStoreActiveDatabaseSizeUnsupportedIgnoresStaleLocalPath(t *testing.T) {
t.Parallel()
staleRoot := t.TempDir()
if err := os.WriteFile(filepath.Join(staleRoot, "unrelated"), []byte("stale"), 0o600); err != nil {
t.Fatal(err)
}
store := &DoltStore{dbPath: staleRoot}
_, err := store.ActiveDatabaseSize(t.Context())
var unsupported *storage.ErrUnsupported
if !errors.As(err, &unsupported) {
t.Fatalf("ActiveDatabaseSize error = %v, want *storage.ErrUnsupported", err)
}
}
func TestDoltStoreActiveDatabaseSizeFailsForDeclaredLocalMissingPath(t *testing.T) {
t.Parallel()
missing := filepath.Join(t.TempDir(), "missing")
store := &DoltStore{localActiveDatabaseDir: missing}
_, err := store.ActiveDatabaseSize(t.Context())
if err == nil {
t.Fatal("ActiveDatabaseSize succeeded, want missing-path error")
}
var unsupported *storage.ErrUnsupported
if errors.As(err, &unsupported) {
t.Fatalf("ActiveDatabaseSize error = %v, want declared-local measurement failure", err)
}
}
func clearSizingModeEnv(t *testing.T) {
t.Helper()
for _, name := range []string{
"BEADS_DOLT_SERVER_MODE",
"BEADS_DOLT_SHARED_SERVER",
"BEADS_SHARED_SERVER_DIR",
"BEADS_DOLT_SERVER_PORT",
"BEADS_DOLT_PORT",
"BEADS_DOLT_SERVER_SOCKET",
"BEADS_DOLT_SERVER_HOST",
} {
t.Setenv(name, "")
}
}

View file

@ -244,6 +244,7 @@ func shouldStopAutoStartedServerOnClose(cfg *Config) bool {
var _ storage.DoltStorage = (*DoltStore)(nil)
var _ storage.RawDBAccessor = (*DoltStore)(nil)
var _ storage.StoreLocator = (*DoltStore)(nil)
var _ storage.ActiveDatabaseSizer = (*DoltStore)(nil)
var _ storage.LifecycleManager = (*DoltStore)(nil)
var _ storage.PendingCommitter = (*DoltStore)(nil)
var _ storage.GarbageCollector = (*DoltStore)(nil)
@ -264,6 +265,11 @@ type DoltStore struct {
readOnly bool // True if opened in read-only mode
credentialKey []byte // Random encryption key for federation credentials
// localActiveDatabaseDir is the exact active database directory when this
// store instance has authoritative local filesystem access. It is resolved
// once at construction; empty means sizing is unsupported for this instance.
localActiveDatabaseDir string
customStatusDetailedCache []types.CustomStatus
customStatusCache []string
customStatusCached bool
@ -1257,6 +1263,36 @@ func New(ctx context.Context, cfg *Config) (*DoltStore, error) {
return newServerMode(ctx, cfg)
}
// resolveLocalActiveDatabaseDir returns an authoritative local path only for
// server configurations whose storage ownership is known. It deliberately
// does not infer locality from Path, CLIDir, or filesystem existence: external
// servers may leave unrelated client-local directories at those locations.
func resolveLocalActiveDatabaseDir(cfg *Config) string {
if cfg == nil || cfg.BeadsDir == "" || cfg.Database == "" ||
cfg.Gateway || cfg.ProxiedServer || cfg.ServerSocket != "" ||
cfg.ServerTLS || !isLocalHost(cfg.ServerHost) {
return ""
}
// An endpoint supplied directly by the environment may be any server,
// including a container or tunnel on localhost. It is not proof that this
// process can inspect the server's data directory.
if os.Getenv("BEADS_DOLT_SERVER_PORT") != "" || os.Getenv("BEADS_DOLT_PORT") != "" {
return ""
}
if doltserver.IsSharedServerMode() {
return filepath.Join(doltserver.ResolveDoltDir(cfg.BeadsDir), cfg.Database)
}
// Owned mode plus effective auto-start authority is the affirmative proof
// that the configured data root belongs to this local beads instance.
if !cfg.AutoStart || doltserver.ResolveServerMode(cfg.BeadsDir) != doltserver.ServerModeOwned {
return ""
}
return filepath.Join(cfg.Path, cfg.Database)
}
// buildTestModeProductionPortPanic returns the multi-line panic message for
// the BEADS_TEST_MODE=1 + production-port hard-guard. Format follows
// AD-01 Wireframe 1: scannable header + database/path/server fields,
@ -1449,21 +1485,22 @@ func newServerMode(ctx context.Context, cfg *Config) (*DoltStore, error) {
}
store := &DoltStore{
db: db,
dbPath: cfg.Path,
beadsDir: beadsDir,
database: cfg.Database,
connStr: connStr,
breaker: breaker,
committerName: cfg.CommitterName,
committerEmail: cfg.CommitterEmail,
remote: cfg.Remote,
branch: "main",
remoteUser: cfg.RemoteUser,
remotePassword: cfg.RemotePassword,
serverMode: true,
readOnly: cfg.ReadOnly,
autoStartedServerDir: autoStartedDir,
db: db,
dbPath: cfg.Path,
beadsDir: beadsDir,
database: cfg.Database,
localActiveDatabaseDir: resolveLocalActiveDatabaseDir(cfg),
connStr: connStr,
breaker: breaker,
committerName: cfg.CommitterName,
committerEmail: cfg.CommitterEmail,
remote: cfg.Remote,
branch: "main",
remoteUser: cfg.RemoteUser,
remotePassword: cfg.RemotePassword,
serverMode: true,
readOnly: cfg.ReadOnly,
autoStartedServerDir: autoStartedDir,
}
// Forward-drift guard runs on read-only AND writable opens. A binary older
@ -2080,6 +2117,23 @@ func (s *DoltStore) CLIDir() string {
return filepath.Join(s.dbPath, s.database)
}
// ActiveDatabaseSize returns the approximate size of the active database.
// External server instances have no authoritative local path and report the
// capability as unsupported even if a stale client-local directory exists.
func (s *DoltStore) ActiveDatabaseSize(ctx context.Context) (int64, error) {
if s.localActiveDatabaseDir == "" {
return 0, &storage.ErrUnsupported{
Op: "ActiveDatabaseSize",
Backend: "dolt-server",
}
}
size, err := storage.MeasureDirectorySize(ctx, s.localActiveDatabaseDir)
if err != nil {
return 0, fmt.Errorf("measure active database directory %q: %w", s.localActiveDatabaseDir, err)
}
return size, nil
}
// DoltGC runs Dolt garbage collection to reclaim disk space.
// Pins a single connection to avoid session state loss on pooled *sql.DB.
func (s *DoltStore) DoltGC(ctx context.Context) error {

View file

@ -0,0 +1,47 @@
//go:build cgo
package embeddeddolt
import (
"os"
"path/filepath"
"testing"
)
func TestActiveDatabaseSizeScopesToActiveEmbeddedDatabase(t *testing.T) {
t.Parallel()
root := t.TempDir()
active := filepath.Join(root, "active")
sibling := filepath.Join(root, "sibling")
if err := os.Mkdir(active, 0o700); err != nil {
t.Fatal(err)
}
if err := os.Mkdir(sibling, 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(active, "data"), []byte("active"), 0o600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(sibling, "data"), []byte("much larger sibling data"), 0o600); err != nil {
t.Fatal(err)
}
store := &EmbeddedDoltStore{dataDir: root, database: "active"}
got, err := store.ActiveDatabaseSize(t.Context())
if err != nil {
t.Fatalf("ActiveDatabaseSize: %v", err)
}
if got != int64(len("active")) {
t.Fatalf("ActiveDatabaseSize = %d, want %d", got, len("active"))
}
}
func TestActiveDatabaseSizeFailsForMissingEmbeddedDatabase(t *testing.T) {
t.Parallel()
store := &EmbeddedDoltStore{dataDir: t.TempDir(), database: "missing"}
if _, err := store.ActiveDatabaseSize(t.Context()); err == nil {
t.Fatal("ActiveDatabaseSize succeeded, want missing-path error")
}
}

View file

@ -25,6 +25,7 @@ import (
// Compile-time interface checks.
var _ storage.DoltStorage = (*EmbeddedDoltStore)(nil)
var _ storage.StoreLocator = (*EmbeddedDoltStore)(nil)
var _ storage.ActiveDatabaseSizer = (*EmbeddedDoltStore)(nil)
var _ storage.GarbageCollector = (*EmbeddedDoltStore)(nil)
var _ storage.Flattener = (*EmbeddedDoltStore)(nil)
var _ storage.Compactor = (*EmbeddedDoltStore)(nil)
@ -755,6 +756,24 @@ func (s *EmbeddedDoltStore) CLIDir() string {
return filepath.Join(s.dataDir, s.database)
}
// ActiveDatabaseSize returns the approximate size of this store's active
// database directory. Sibling databases under the embedded data root are not
// part of the result.
func (s *EmbeddedDoltStore) ActiveDatabaseSize(ctx context.Context) (int64, error) {
if s.closed.Load() {
return 0, errClosed
}
activeDir := s.CLIDir()
if activeDir == "" {
return 0, fmt.Errorf("embeddeddolt: active database directory is empty")
}
size, err := storage.MeasureDirectorySize(ctx, activeDir)
if err != nil {
return 0, fmt.Errorf("measure active database directory %q: %w", activeDir, err)
}
return size, nil
}
// ---------------------------------------------------------------------------
// storage.VersionControl
// ---------------------------------------------------------------------------

View file

@ -419,6 +419,14 @@ type StoreLocator interface {
CLIDir() string
}
// ActiveDatabaseSizer reports the approximate on-disk size of the active
// database when the current store instance has authoritative local filesystem
// access. Implementations return *ErrUnsupported when that particular instance
// is backed by storage that is not locally measurable.
type ActiveDatabaseSizer interface {
ActiveDatabaseSize(ctx context.Context) (int64, error)
}
// GarbageCollector provides Dolt garbage collection capability.
// Callers that need to reclaim disk space should type-assert to this interface.
type GarbageCollector interface {