beads/cmd/bd/doctor/federation.go
beads/crew/emma 2137693dad revert: restore embedded Dolt mode (was only supposed to be removed from Gas Town)
Revert commits e5330641 and 0df41523 which removed embedded Dolt mode
from the beads codebase. The embedded Dolt removal was only intended for
Gas Town, not for Beads.

Restores:
- dolthub/driver dependency and embedded connection path
- Advisory flock (AccessLock) for concurrent process protection
- Embedded connector lifecycle management in DoltStore
- All CGO build tags across ~45 files
- Vendored go-icu-regex library
- nocgo stub files for non-CGO builds
- Bootstrap and embedded_uow helpers
- factory_dolt_test.go and dolt_singleprocess_test.go

Merge conflict resolutions:
- store.go: TCP fail-fast check wrapped inside if cfg.ServerMode
- store.go: backtick-quoting for embedded CREATE DATABASE (prefix-based names)
- perf_dolt.go: port references updated from 3306 to 3307
- ci.yml: restored continue-on-error for Nix (dolthub/driver requires Go 1.25.6+)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Executed-By: beads/crew/emma
Rig: beads
Role: crew
2026-02-07 21:21:24 -08:00

575 lines
16 KiB
Go

//go:build cgo
package doctor
import (
"context"
"fmt"
"net"
"os"
"path/filepath"
"strings"
"time"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/dolt"
storagefactory "github.com/steveyegge/beads/internal/storage/factory"
)
// CheckFederationRemotesAPI checks if the remotesapi port is accessible for federation.
// This is the port used for peer-to-peer sync operations.
func CheckFederationRemotesAPI(path string) DoctorCheck {
backend, beadsDir := getBackendAndBeadsDir(path)
// Only relevant for Dolt backend
if backend != configfile.BackendDolt {
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusOK,
Message: "N/A (SQLite backend)",
Category: CategoryFederation,
}
}
// Check if dolt directory exists
doltPath := filepath.Join(beadsDir, "dolt")
if _, err := os.Stat(doltPath); os.IsNotExist(err) {
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusOK,
Message: "N/A (no dolt database)",
Category: CategoryFederation,
}
}
// Check if server PID file exists (indicates server mode might be running)
pidFile := filepath.Join(doltPath, "dolt-server.pid")
serverPID := dolt.GetRunningServerPID(doltPath)
if serverPID == 0 {
// No server running - check if we have remotes configured
ctx := context.Background()
store, err := storagefactory.NewFromConfigWithOptions(ctx, beadsDir, storagefactory.Options{ReadOnly: true})
if err != nil {
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusOK,
Message: "N/A (embedded mode, no remotes check needed)",
Category: CategoryFederation,
}
}
defer func() { _ = store.Close() }()
fedStore, ok := storage.AsFederated(store)
if !ok {
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusOK,
Message: "N/A (storage does not support federation)",
Category: CategoryFederation,
}
}
remotes, err := fedStore.ListRemotes(ctx)
if err != nil || len(remotes) == 0 {
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusOK,
Message: "N/A (no peers configured)",
Category: CategoryFederation,
}
}
// Has remotes but no server running - suggest starting in federation mode
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusWarning,
Message: fmt.Sprintf("Server not running (%d peers configured)", len(remotes)),
Detail: "Federation requires dolt sql-server for peer sync",
Fix: "Run 'bd daemon start --federation' to enable peer-to-peer sync",
Category: CategoryFederation,
}
}
// Server is running - check if remotesapi port is accessible
// Default remotesapi port is 8080
remotesAPIPort := dolt.DefaultRemotesAPIPort
host := "127.0.0.1"
addr := net.JoinHostPort(host, fmt.Sprintf("%d", remotesAPIPort))
conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
if err != nil {
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusError,
Message: fmt.Sprintf("remotesapi port %d not accessible", remotesAPIPort),
Detail: fmt.Sprintf("Server PID %d found in %s but port unreachable: %v", serverPID, pidFile, err),
Fix: "Check if dolt sql-server is running with --remotesapi-port flag",
Category: CategoryFederation,
}
}
_ = conn.Close()
return DoctorCheck{
Name: "Federation remotesapi",
Status: StatusOK,
Message: fmt.Sprintf("Port %d accessible", remotesAPIPort),
Category: CategoryFederation,
}
}
// CheckFederationPeerConnectivity checks if configured peer remotes are reachable.
func CheckFederationPeerConnectivity(path string) DoctorCheck {
backend, beadsDir := getBackendAndBeadsDir(path)
// Only relevant for Dolt backend
if backend != configfile.BackendDolt {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusOK,
Message: "N/A (SQLite backend)",
Category: CategoryFederation,
}
}
// Check if dolt directory exists
doltPath := filepath.Join(beadsDir, "dolt")
if _, err := os.Stat(doltPath); os.IsNotExist(err) {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusOK,
Message: "N/A (no dolt database)",
Category: CategoryFederation,
}
}
ctx := context.Background()
store, err := storagefactory.NewFromConfigWithOptions(ctx, beadsDir, storagefactory.Options{ReadOnly: true})
if err != nil {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusWarning,
Message: "Unable to open database",
Detail: err.Error(),
Category: CategoryFederation,
}
}
defer func() { _ = store.Close() }()
fedStore, ok := storage.AsFederated(store)
if !ok {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusOK,
Message: "N/A (storage does not support federation)",
Category: CategoryFederation,
}
}
remotes, err := fedStore.ListRemotes(ctx)
if err != nil {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusWarning,
Message: "Unable to list remotes",
Detail: err.Error(),
Category: CategoryFederation,
}
}
if len(remotes) == 0 {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusOK,
Message: "No peers configured",
Category: CategoryFederation,
}
}
// Try to get sync status for each peer (this doesn't require network for cached data)
var reachable, unreachable []string
var statusDetails []string
for _, remote := range remotes {
// Skip origin - it's typically the DoltHub remote, not a peer
if remote.Name == "origin" {
continue
}
status, err := fedStore.SyncStatus(ctx, remote.Name)
if err != nil {
unreachable = append(unreachable, remote.Name)
statusDetails = append(statusDetails, fmt.Sprintf("%s: %v", remote.Name, err))
} else {
reachable = append(reachable, remote.Name)
if status.LocalAhead > 0 || status.LocalBehind > 0 {
statusDetails = append(statusDetails, fmt.Sprintf("%s: %d ahead, %d behind",
remote.Name, status.LocalAhead, status.LocalBehind))
}
}
}
// If no peers (only origin), report as OK
if len(reachable) == 0 && len(unreachable) == 0 {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusOK,
Message: "No federation peers configured (only origin remote)",
Category: CategoryFederation,
}
}
if len(unreachable) > 0 {
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusWarning,
Message: fmt.Sprintf("%d/%d peers unreachable", len(unreachable), len(reachable)+len(unreachable)),
Detail: strings.Join(statusDetails, "\n"),
Fix: "Check peer URLs and network connectivity",
Category: CategoryFederation,
}
}
msg := fmt.Sprintf("%d peers reachable", len(reachable))
detail := ""
if len(statusDetails) > 0 {
detail = strings.Join(statusDetails, "\n")
}
return DoctorCheck{
Name: "Peer Connectivity",
Status: StatusOK,
Message: msg,
Detail: detail,
Category: CategoryFederation,
}
}
// CheckFederationSyncStaleness checks for stale sync status with peers.
func CheckFederationSyncStaleness(path string) DoctorCheck {
backend, beadsDir := getBackendAndBeadsDir(path)
// Only relevant for Dolt backend
if backend != configfile.BackendDolt {
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusOK,
Message: "N/A (SQLite backend)",
Category: CategoryFederation,
}
}
// Check if dolt directory exists
doltPath := filepath.Join(beadsDir, "dolt")
if _, err := os.Stat(doltPath); os.IsNotExist(err) {
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusOK,
Message: "N/A (no dolt database)",
Category: CategoryFederation,
}
}
ctx := context.Background()
store, err := storagefactory.NewFromConfigWithOptions(ctx, beadsDir, storagefactory.Options{ReadOnly: true})
if err != nil {
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusWarning,
Message: "Unable to open database",
Detail: err.Error(),
Category: CategoryFederation,
}
}
defer func() { _ = store.Close() }()
fedStore, ok := storage.AsFederated(store)
if !ok {
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusOK,
Message: "N/A (storage does not support federation)",
Category: CategoryFederation,
}
}
remotes, err := fedStore.ListRemotes(ctx)
if err != nil || len(remotes) == 0 {
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusOK,
Message: "No peers configured",
Category: CategoryFederation,
}
}
// Check sync status for each peer
var staleWarnings []string
var totalBehind int
for _, remote := range remotes {
// Skip origin - check only federation peers
if remote.Name == "origin" {
continue
}
status, err := fedStore.SyncStatus(ctx, remote.Name)
if err != nil {
continue // Already handled in peer connectivity check
}
// Warn if significantly behind
if status.LocalBehind > 0 {
totalBehind += status.LocalBehind
staleWarnings = append(staleWarnings, fmt.Sprintf("%s: %d commits behind",
remote.Name, status.LocalBehind))
}
// Note: LastSync time tracking is not yet implemented in SyncStatus
// When it is, we can add time-based staleness warnings here
}
if len(staleWarnings) == 0 {
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusOK,
Message: "Sync is up to date",
Category: CategoryFederation,
}
}
return DoctorCheck{
Name: "Sync Staleness",
Status: StatusWarning,
Message: fmt.Sprintf("%d total commits behind peers", totalBehind),
Detail: strings.Join(staleWarnings, "\n"),
Fix: "Run 'bd federation sync' to synchronize with peers",
Category: CategoryFederation,
}
}
// CheckFederationConflicts checks for unresolved merge conflicts.
func CheckFederationConflicts(path string) DoctorCheck {
backend, beadsDir := getBackendAndBeadsDir(path)
// Only relevant for Dolt backend
if backend != configfile.BackendDolt {
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusOK,
Message: "N/A (SQLite backend)",
Category: CategoryFederation,
}
}
// Check if dolt directory exists
doltPath := filepath.Join(beadsDir, "dolt")
if _, err := os.Stat(doltPath); os.IsNotExist(err) {
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusOK,
Message: "N/A (no dolt database)",
Category: CategoryFederation,
}
}
ctx := context.Background()
store, err := storagefactory.NewFromConfigWithOptions(ctx, beadsDir, storagefactory.Options{ReadOnly: true})
if err != nil {
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusWarning,
Message: "Unable to open database",
Detail: err.Error(),
Category: CategoryFederation,
}
}
defer func() { _ = store.Close() }()
// Check if storage supports versioning (needed for conflict detection)
verStore, ok := storage.AsVersioned(store)
if !ok {
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusOK,
Message: "N/A (storage does not support versioning)",
Category: CategoryFederation,
}
}
conflicts, err := verStore.GetConflicts(ctx)
if err != nil {
// Some errors are expected (e.g., no conflicts table)
if strings.Contains(err.Error(), "no such table") || strings.Contains(err.Error(), "doesn't exist") {
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusOK,
Message: "No conflicts",
Category: CategoryFederation,
}
}
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusWarning,
Message: "Unable to check conflicts",
Detail: err.Error(),
Category: CategoryFederation,
}
}
if len(conflicts) == 0 {
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusOK,
Message: "No conflicts",
Category: CategoryFederation,
}
}
// Group conflicts by issue ID
issueConflicts := make(map[string][]string)
for _, c := range conflicts {
issueConflicts[c.IssueID] = append(issueConflicts[c.IssueID], c.Field)
}
var details []string
for issueID, fields := range issueConflicts {
details = append(details, fmt.Sprintf("%s: %s", issueID, strings.Join(fields, ", ")))
}
return DoctorCheck{
Name: "Federation Conflicts",
Status: StatusError,
Message: fmt.Sprintf("%d unresolved conflicts in %d issues", len(conflicts), len(issueConflicts)),
Detail: strings.Join(details, "\n"),
Fix: "Run 'bd federation sync --strategy ours|theirs' to resolve conflicts",
Category: CategoryFederation,
}
}
// CheckDoltServerModeMismatch checks for mismatch between Dolt init and server mode.
// This detects cases where:
// - Server mode is expected but no server is running
// - Embedded mode is being used when server mode should be used (federation with peers)
func CheckDoltServerModeMismatch(path string) DoctorCheck {
backend, beadsDir := getBackendAndBeadsDir(path)
// Only relevant for Dolt backend
if backend != configfile.BackendDolt {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusOK,
Message: "N/A (SQLite backend)",
Category: CategoryFederation,
}
}
// Check if dolt directory exists
doltPath := filepath.Join(beadsDir, "dolt")
if _, err := os.Stat(doltPath); os.IsNotExist(err) {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusOK,
Message: "N/A (no dolt database)",
Category: CategoryFederation,
}
}
// Check for server PID file
serverPID := dolt.GetRunningServerPID(doltPath)
// Open storage to check for remotes
ctx := context.Background()
store, err := storagefactory.NewFromConfigWithOptions(ctx, beadsDir, storagefactory.Options{ReadOnly: true})
if err != nil {
// If we can't open the store, check if there's a lock file indicating embedded mode
lockFile := filepath.Join(doltPath, ".dolt", "lock")
if _, lockErr := os.Stat(lockFile); lockErr == nil && serverPID == 0 {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusWarning,
Message: "Embedded mode with lock file",
Detail: "Another process may be using the database in embedded mode",
Fix: "Close other bd processes or start daemon with --federation",
Category: CategoryFederation,
}
}
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusWarning,
Message: "Unable to open database",
Detail: err.Error(),
Category: CategoryFederation,
}
}
defer func() { _ = store.Close() }()
// Check if storage supports federation
fedStore, isFederated := storage.AsFederated(store)
if !isFederated {
if serverPID > 0 {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusOK,
Message: "Server mode (no federation)",
Category: CategoryFederation,
}
}
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusOK,
Message: "Embedded mode",
Category: CategoryFederation,
}
}
// Check for configured remotes
remotes, err := fedStore.ListRemotes(ctx)
if err != nil {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusWarning,
Message: "Unable to list remotes",
Detail: err.Error(),
Category: CategoryFederation,
}
}
// Count federation peers (exclude origin)
peerCount := 0
for _, r := range remotes {
if r.Name != "origin" {
peerCount++
}
}
// Determine expected vs actual mode
if peerCount > 0 && serverPID == 0 {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusWarning,
Message: fmt.Sprintf("Embedded mode with %d peers configured", peerCount),
Detail: "Federation with peers requires server mode for multi-writer support",
Fix: "Run 'bd daemon start --federation' to enable server mode",
Category: CategoryFederation,
}
}
if serverPID > 0 {
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusOK,
Message: fmt.Sprintf("Server mode (PID %d)", serverPID),
Detail: fmt.Sprintf("%d peers configured", peerCount),
Category: CategoryFederation,
}
}
return DoctorCheck{
Name: "Dolt Mode",
Status: StatusOK,
Message: "Embedded mode",
Detail: "No federation peers configured",
Category: CategoryFederation,
}
}