From b37558b6ab7f2d5624a6ab2c12cc4e337ca50fdf Mon Sep 17 00:00:00 2001 From: ecuthiell Date: Sat, 25 Jul 2026 17:14:07 -0600 Subject: [PATCH] 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 Co-authored-by: Claude Fable 5 --- cmd/bd/backup.go | 169 +++++----- cmd/bd/backup_dolt.go | 58 ++-- cmd/bd/backup_dolt_test.go | 72 +++-- cmd/bd/backup_embedded_test.go | 17 + cmd/bd/backup_status_test.go | 270 ++++++++++++++++ cmd/bd/storage_chain_test.go | 28 +- internal/storage/directory_size.go | 66 ++++ internal/storage/directory_size_test.go | 155 +++++++++ .../storage/dolt/active_database_size_test.go | 297 ++++++++++++++++++ internal/storage/dolt/store.go | 84 ++++- .../embeddeddolt/active_database_size_test.go | 47 +++ internal/storage/embeddeddolt/store.go | 19 ++ internal/storage/storage.go | 8 + 13 files changed, 1146 insertions(+), 144 deletions(-) create mode 100644 cmd/bd/backup_status_test.go create mode 100644 internal/storage/directory_size.go create mode 100644 internal/storage/directory_size_test.go create mode 100644 internal/storage/dolt/active_database_size_test.go create mode 100644 internal/storage/embeddeddolt/active_database_size_test.go diff --git a/cmd/bd/backup.go b/cmd/bd/backup.go index 64b5f5d10..4f5249ef1 100644 --- a/cmd/bd/backup.go +++ b/cmd/bd/backup.go @@ -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 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 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() { diff --git a/cmd/bd/backup_dolt.go b/cmd/bd/backup_dolt.go index 114dfd557..2e42ad2c0 100644 --- a/cmd/bd/backup_dolt.go +++ b/cmd/bd/backup_dolt.go @@ -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), diff --git a/cmd/bd/backup_dolt_test.go b/cmd/bd/backup_dolt_test.go index 096de8797..2cbacf3de 100644 --- a/cmd/bd/backup_dolt_test.go +++ b/cmd/bd/backup_dolt_test.go @@ -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, + ) + } + }) } } diff --git a/cmd/bd/backup_embedded_test.go b/cmd/bd/backup_embedded_test.go index fee082087..c4e94d9fc 100644 --- a/cmd/bd/backup_embedded_test.go +++ b/cmd/bd/backup_embedded_test.go @@ -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) { diff --git a/cmd/bd/backup_status_test.go b/cmd/bd/backup_status_test.go new file mode 100644 index 000000000..0d6159b61 --- /dev/null +++ b/cmd/bd/backup_status_test.go @@ -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) + } +} diff --git a/cmd/bd/storage_chain_test.go b/cmd/bd/storage_chain_test.go index e6a80fd9d..9ecb0dfa0 100644 --- a/cmd/bd/storage_chain_test.go +++ b/cmd/bd/storage_chain_test.go @@ -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") diff --git a/internal/storage/directory_size.go b/internal/storage/directory_size.go new file mode 100644 index 000000000..c096bf5a2 --- /dev/null +++ b/internal/storage/directory_size.go @@ -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 +} diff --git a/internal/storage/directory_size_test.go b/internal/storage/directory_size_test.go new file mode 100644 index 000000000..ef58867c1 --- /dev/null +++ b/internal/storage/directory_size_test.go @@ -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 } diff --git a/internal/storage/dolt/active_database_size_test.go b/internal/storage/dolt/active_database_size_test.go new file mode 100644 index 000000000..db8dd5f03 --- /dev/null +++ b/internal/storage/dolt/active_database_size_test.go @@ -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, "") + } +} diff --git a/internal/storage/dolt/store.go b/internal/storage/dolt/store.go index 1b4aadd11..6616117be 100644 --- a/internal/storage/dolt/store.go +++ b/internal/storage/dolt/store.go @@ -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 { diff --git a/internal/storage/embeddeddolt/active_database_size_test.go b/internal/storage/embeddeddolt/active_database_size_test.go new file mode 100644 index 000000000..724ac7bf8 --- /dev/null +++ b/internal/storage/embeddeddolt/active_database_size_test.go @@ -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") + } +} diff --git a/internal/storage/embeddeddolt/store.go b/internal/storage/embeddeddolt/store.go index fc90f7c62..968bd9261 100644 --- a/internal/storage/embeddeddolt/store.go +++ b/internal/storage/embeddeddolt/store.go @@ -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 // --------------------------------------------------------------------------- diff --git a/internal/storage/storage.go b/internal/storage/storage.go index 4bec038cc..cd5ef7795 100644 --- a/internal/storage/storage.go +++ b/internal/storage/storage.go @@ -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 {