/internal/storage/dbproxy/server: wip, external dolt server

coffeegoddd · coffeegoddd · commit 7ce1330a5bfb · 2026-05-27T14:06:33.000-07:00
diff --git a/internal/configfile/configfile_test.go b/internal/configfile/configfile_test.go
@@ -5,6 +5,7 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/steveyegge/beads/internal/config"
 )
@@ -528,6 +529,75 @@ func TestProxiedServerClientInfo_RoundTrip(t *testing.T) {
 			t.Errorf("got %+v, want %+v", got, want)
 		}
 	})
+
+	t.Run("external section survives save/load", func(t *testing.T) {
+		sub := t.TempDir()
+		want := &ProxiedServerClientInfo{
+			External: &ExternalDoltConfig{
+				Host:            "db.internal",
+				Port:            3306,
+				TLSRequired:     true,
+				TLSCert:         "/etc/beads/client.pem",
+				TLSKey:          "/etc/beads/client.key",
+				KeepAlivePeriod: 45 * time.Second,
+			},
+		}
+		if err := SaveProxiedServerClientInfo(sub, want); err != nil {
+			t.Fatalf("Save: %v", err)
+		}
+		got, err := LoadProxiedServerClientInfo(sub)
+		if err != nil || got == nil {
+			t.Fatalf("Load: %v got=%v", err, got)
+		}
+		if got.RootPath != "" || got.ConfigPath != "" || got.LogPath != "" {
+			t.Errorf("local fields leaked into external-only sidecar: %+v", got)
+		}
+		if got.External == nil {
+			t.Fatalf("External section dropped on round-trip")
+		}
+		if *got.External != *want.External {
+			t.Errorf("got %+v, want %+v", got.External, want.External)
+		}
+	})
+
+	t.Run("local fields and external section coexist", func(t *testing.T) {
+		sub := t.TempDir()
+		want := &ProxiedServerClientInfo{
+			RootPath: "/var/lib/beads/proxieddb",
+			External: &ExternalDoltConfig{Socket: "/var/run/dolt.sock"},
+		}
+		if err := SaveProxiedServerClientInfo(sub, want); err != nil {
+			t.Fatalf("Save: %v", err)
+		}
+		got, err := LoadProxiedServerClientInfo(sub)
+		if err != nil || got == nil {
+			t.Fatalf("Load: %v got=%v", err, got)
+		}
+		if got.RootPath != want.RootPath {
+			t.Errorf("RootPath = %q, want %q", got.RootPath, want.RootPath)
+		}
+		if got.External == nil || got.External.Socket != "/var/run/dolt.sock" {
+			t.Errorf("External round-trip lost data: %+v", got.External)
+		}
+	})
+
+	t.Run("legacy sidecar without external section still loads", func(t *testing.T) {
+		sub := t.TempDir()
+		legacy := []byte(`{"root_path":"/var/lib/beads/proxieddb","config_path":"/etc/dolt/server.yaml","log_path":"/var/log/beads/server.log"}`)
+		if err := os.WriteFile(ProxiedServerClientInfoPath(sub), legacy, 0o600); err != nil {
+			t.Fatalf("seed legacy: %v", err)
+		}
+		got, err := LoadProxiedServerClientInfo(sub)
+		if err != nil || got == nil {
+			t.Fatalf("Load: %v got=%v", err, got)
+		}
+		if got.External != nil {
+			t.Errorf("External should be nil for legacy sidecar, got %+v", got.External)
+		}
+		if got.RootPath != "/var/lib/beads/proxieddb" {
+			t.Errorf("RootPath = %q, want /var/lib/beads/proxieddb", got.RootPath)
+		}
+	})
 }
 
 func TestProxiedServerClientInfo_ResolvedPaths(t *testing.T) {
diff --git a/internal/configfile/external_dolt_config.go b/internal/configfile/external_dolt_config.go
@@ -0,0 +1,63 @@
+package configfile
+
+import (
+	"errors"
+	"fmt"
+	"path/filepath"
+	"time"
+)
+
+type ExternalDoltConfig struct {
+	Host            string        `json:"host,omitempty"`
+	Port            int           `json:"port,omitempty"`
+	Socket          string        `json:"socket,omitempty"`
+	TLSRequired     bool          `json:"tls_required,omitempty"`
+	TLSCert         string        `json:"tls_cert,omitempty"`
+	TLSKey          string        `json:"tls_key,omitempty"`
+	KeepAlivePeriod time.Duration `json:"keep_alive_period,omitempty"`
+}
+
+func (c ExternalDoltConfig) Validate() error {
+	hasHost := c.Host != ""
+	hasPort := c.Port != 0
+	hasSocket := c.Socket != ""
+
+	switch {
+	case hasSocket && (hasHost || hasPort):
+		return errors.New("ExternalDoltConfig: set either Socket OR (Host, Port), not both")
+	case !hasSocket && !hasHost && !hasPort:
+		return errors.New("ExternalDoltConfig: must set Socket or (Host, Port)")
+	case hasHost && !hasPort:
+		return errors.New("ExternalDoltConfig: Host requires Port")
+	case !hasHost && hasPort:
+		return errors.New("ExternalDoltConfig: Port requires Host")
+	}
+
+	if hasHost && (c.Port < 1 || c.Port > 65535) {
+		return fmt.Errorf("ExternalDoltConfig: Port %d out of range [1, 65535]", c.Port)
+	}
+
+	if hasSocket && !filepath.IsAbs(c.Socket) {
+		return fmt.Errorf("ExternalDoltConfig: Socket %q is not absolute", c.Socket)
+	}
+
+	switch {
+	case c.TLSCert != "" && c.TLSKey == "":
+		return errors.New("ExternalDoltConfig: TLSCert set without TLSKey")
+	case c.TLSCert == "" && c.TLSKey != "":
+		return errors.New("ExternalDoltConfig: TLSKey set without TLSCert")
+	}
+
+	if c.TLSCert != "" && !filepath.IsAbs(c.TLSCert) {
+		return fmt.Errorf("ExternalDoltConfig: TLSCert %q is not absolute", c.TLSCert)
+	}
+	if c.TLSKey != "" && !filepath.IsAbs(c.TLSKey) {
+		return fmt.Errorf("ExternalDoltConfig: TLSKey %q is not absolute", c.TLSKey)
+	}
+
+	if c.KeepAlivePeriod < 0 {
+		return fmt.Errorf("ExternalDoltConfig: KeepAlivePeriod %s is negative", c.KeepAlivePeriod)
+	}
+
+	return nil
+}
diff --git a/internal/configfile/proxied_server_client_info.go b/internal/configfile/proxied_server_client_info.go
@@ -10,9 +10,10 @@ import (
 const ProxiedServerClientInfoFileName = "proxied_server_client_info.json"
 
 type ProxiedServerClientInfo struct {
-	RootPath   string `json:"root_path,omitempty"`
-	ConfigPath string `json:"config_path,omitempty"`
-	LogPath    string `json:"log_path,omitempty"`
+	RootPath   string              `json:"root_path,omitempty"`
+	ConfigPath string              `json:"config_path,omitempty"`
+	LogPath    string              `json:"log_path,omitempty"`
+	External   *ExternalDoltConfig `json:"external,omitempty"`
 }
 
 func ProxiedServerClientInfoPath(beadsDir string) string {
diff --git a/internal/storage/dbproxy/server/external_dolt_server.go b/internal/storage/dbproxy/server/external_dolt_server.go
@@ -0,0 +1,114 @@
+package server
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"net"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	"github.com/steveyegge/beads/internal/configfile"
+	"github.com/steveyegge/beads/internal/storage/dbproxy/util"
+)
+
+type ExternalDoltServer struct {
+	id              string
+	host            string
+	port            int
+	socket          string
+	tlsRequired     bool
+	tlsCert         string
+	tlsKey          string
+	keepAlivePeriod time.Duration
+
+	started atomic.Bool
+}
+
+var _ DatabaseServer = (*ExternalDoltServer)(nil)
+
+func NewExternalDoltServer(cfg configfile.ExternalDoltConfig) (*ExternalDoltServer, error) {
+	if err := cfg.Validate(); err != nil {
+		return nil, err
+	}
+	keepAlive := cfg.KeepAlivePeriod
+	if keepAlive == 0 {
+		keepAlive = defaultKeepAlivePeriod
+	}
+	sum := sha256.Sum256([]byte(externalDoltServerTarget(cfg)))
+	return &ExternalDoltServer{
+		id:              hex.EncodeToString(sum[:]),
+		host:            cfg.Host,
+		port:            cfg.Port,
+		socket:          cfg.Socket,
+		tlsRequired:     cfg.TLSRequired,
+		tlsCert:         cfg.TLSCert,
+		tlsKey:          cfg.TLSKey,
+		keepAlivePeriod: keepAlive,
+	}, nil
+}
+
+func externalDoltServerTarget(cfg configfile.ExternalDoltConfig) string {
+	if cfg.Socket != "" {
+		return "unix://" + cfg.Socket
+	}
+	return "tcp://" + net.JoinHostPort(cfg.Host, strconv.Itoa(cfg.Port))
+}
+
+func (s *ExternalDoltServer) ID(_ context.Context) string {
+	return s.id
+}
+
+func (s *ExternalDoltServer) DSN(_ context.Context, database, user, password string) string {
+	dsn := util.DoltServerDSN{
+		User:        user,
+		Password:    password,
+		Database:    database,
+		TLSRequired: s.tlsRequired,
+		TLSCert:     s.tlsCert,
+		TLSKey:      s.tlsKey,
+	}
+	if s.socket != "" {
+		dsn.Socket = s.socket
+	} else {
+		dsn.Host = s.host
+		dsn.Port = s.port
+	}
+	return dsn.String()
+}
+
+func (s *ExternalDoltServer) Start(_ context.Context) error {
+	if !s.started.CompareAndSwap(false, true) {
+		return errors.New("server: ExternalDoltServer.Start: server already started")
+	}
+	return nil
+}
+
+func (s *ExternalDoltServer) Stop(_ context.Context) error {
+	s.started.Store(false)
+	return nil
+}
+
+func (s *ExternalDoltServer) Running(_ context.Context) bool {
+	return s.started.Load()
+}
+
+func (s *ExternalDoltServer) Dial(ctx context.Context) (net.Conn, error) {
+	network, addr := "tcp", net.JoinHostPort(s.host, strconv.Itoa(s.port))
+	if s.socket != "" {
+		network, addr = "unix", s.socket
+	}
+	var d net.Dialer
+	conn, err := d.DialContext(ctx, network, addr)
+	if err != nil {
+		return nil, fmt.Errorf("server: ExternalDoltServer.Dial: %w", err)
+	}
+	if tc, ok := conn.(*net.TCPConn); ok {
+		_ = tc.SetKeepAlive(true)
+		_ = tc.SetKeepAlivePeriod(s.keepAlivePeriod)
+	}
+	return conn, nil
+}
diff --git a/internal/storage/dbproxy/server/external_dolt_server_test.go b/internal/storage/dbproxy/server/external_dolt_server_test.go
