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:
parent
b96b992ba8
commit
b37558b6ab
13 changed files with 1148 additions and 146 deletions
169
cmd/bd/backup.go
169
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 <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() {
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
270
cmd/bd/backup_status_test.go
Normal file
270
cmd/bd/backup_status_test.go
Normal 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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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")
|
||||
|
|
|
|||
66
internal/storage/directory_size.go
Normal file
66
internal/storage/directory_size.go
Normal 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
|
||||
}
|
||||
155
internal/storage/directory_size_test.go
Normal file
155
internal/storage/directory_size_test.go
Normal 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 }
|
||||
297
internal/storage/dolt/active_database_size_test.go
Normal file
297
internal/storage/dolt/active_database_size_test.go
Normal 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, "")
|
||||
}
|
||||
}
|
||||
|
|
@ -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 {
|
||||
|
|
|
|||
47
internal/storage/embeddeddolt/active_database_size_test.go
Normal file
47
internal/storage/embeddeddolt/active_database_size_test.go
Normal 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")
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
// ---------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue