beads/internal/storage/dbproxy/server/doltserver.go
2026-05-10 06:57:41 -07:00

372 lines
9.7 KiB
Go

package server
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"net"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/dolthub/dolt/go/libraries/doltcore/servercfg"
"github.com/dolthub/dolt/go/libraries/utils/filesys"
"golang.org/x/sync/errgroup"
"github.com/steveyegge/beads/internal/storage/dbproxy/pidfile"
"github.com/steveyegge/beads/internal/storage/dbproxy/util"
)
const defaultKeepAlivePeriod = 30 * time.Second
const (
PIDFileName = "proxy-child.pid"
LockFileName = "proxy-child.lock"
)
const (
startReadyTimeout = 30 * time.Second
startReadyPollInterval = 50 * time.Millisecond
startReadyDialTimeout = 250 * time.Millisecond
)
type DoltServer struct {
id string
doltBinExec string
rootDir string
configPath string
config servercfg.ServerConfig
keepAlivePeriod time.Duration
logFile *os.File
eg *errgroup.Group
egCtx context.Context
cancel context.CancelFunc
pid int
}
var _ DatabaseServer = (*DoltServer)(nil)
func NewDoltServer(doltBinExec, rootDir, configPath, logFilePath string, keepAlivePeriod time.Duration) (*DoltServer, error) {
if doltBinExec == "" {
return nil, errors.New("server: NewDoltServer: doltBinExec is required")
}
if rootDir == "" {
return nil, errors.New("server: NewDoltServer: rootDir is required")
}
if configPath == "" {
return nil, errors.New("server: NewDoltServer: configPath is required")
}
absDoltBinExec, err := filepath.Abs(doltBinExec)
if err != nil {
return nil, errors.New("server: NewDoltServer: failed to determine absolute path of doltBinExec")
}
absRootDir, err := filepath.Abs(rootDir)
if err != nil {
return nil, errors.New("server: NewDoltServer: failed to determine absolute path of rootDir")
}
absConfigPath, err := filepath.Abs(configPath)
if err != nil {
return nil, errors.New("server: NewDoltServer: failed to determine absolute path of configPath")
}
cfg, err := servercfg.YamlConfigFromFile(filesys.LocalFS, configPath)
if err != nil {
return nil, fmt.Errorf("server: NewDoltServer: parse config %q: %w", configPath, err)
}
var logFile *os.File
if logFilePath != "" {
absLogFilePath, err := filepath.Abs(logFilePath)
if err != nil {
return nil, errors.New("server: NewDoltServer: failed to determine absolute path of logFilePath")
}
logFile, err = os.OpenFile(absLogFilePath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600) //nolint:gosec // logFilePath is caller-derived, not user-request input
if err != nil {
return nil, fmt.Errorf("server: NewDoltServer: open log %q: %w", logFilePath, err)
}
}
if keepAlivePeriod == 0 {
keepAlivePeriod = defaultKeepAlivePeriod
}
sum := sha256.Sum256([]byte(absRootDir))
return &DoltServer{
id: hex.EncodeToString(sum[:]),
doltBinExec: absDoltBinExec,
rootDir: absRootDir,
configPath: absConfigPath,
config: cfg,
keepAlivePeriod: keepAlivePeriod,
logFile: logFile,
}, nil
}
func (s *DoltServer) ID(_ context.Context) string {
return s.id
}
func (s *DoltServer) DSN(_ context.Context, database, user, password string) string {
dsn := util.DoltServerDSN{
User: user,
Password: password,
Database: database,
TLSRequired: s.config.RequireSecureTransport(),
TLSCert: s.config.TLSCert(),
TLSKey: s.config.TLSKey(),
}
if sock := s.config.Socket(); sock != "" {
dsn.Socket = sock
} else {
dsn.Host = s.config.Host()
dsn.Port = s.config.Port()
}
return dsn.String()
}
func (s *DoltServer) doltConfigure(ctx context.Context) error {
probe := exec.CommandContext(ctx, s.doltBinExec, "config", "--global", "--get", "user.name")
if out, err := probe.Output(); err == nil && strings.TrimSpace(string(out)) != "" {
return nil
}
name, email := "beads", "beads@localhost"
if out, err := exec.CommandContext(ctx, "git", "config", "user.name").Output(); err == nil {
if v := strings.TrimSpace(string(out)); v != "" {
name = v
}
}
if out, err := exec.CommandContext(ctx, "git", "config", "user.email").Output(); err == nil {
if v := strings.TrimSpace(string(out)); v != "" {
email = v
}
}
if out, err := exec.CommandContext(ctx, s.doltBinExec, "config", "--global", "--add", "user.name", name).CombinedOutput(); err != nil {
return fmt.Errorf("server: DoltServer.doltConfigure: set user.name: %w\n%s", err, out)
}
if out, err := exec.CommandContext(ctx, s.doltBinExec, "config", "--global", "--add", "user.email", email).CombinedOutput(); err != nil {
return fmt.Errorf("server: DoltServer.doltConfigure: set user.email: %w\n%s", err, out)
}
return nil
}
func (s *DoltServer) doltInit(ctx context.Context) error {
if err := os.MkdirAll(s.rootDir, 0o755); err != nil {
return fmt.Errorf("server: DoltServer.doltInit: mkdir %q: %w", s.rootDir, err)
}
cmd := exec.CommandContext(ctx, s.doltBinExec, "init")
cmd.Dir = s.rootDir
if out, err := cmd.CombinedOutput(); err != nil {
if strings.Contains(string(out), "already been initialized") {
return nil
}
return fmt.Errorf("server: DoltServer.doltInit: %w\n%s", err, out)
}
return nil
}
var retryableDoltInitErrSubstrings = []string{
"repository state is invalid",
}
func isRetryableDoltInitErr(err error) bool {
if err == nil {
return false
}
msg := err.Error()
for _, s := range retryableDoltInitErrSubstrings {
if strings.Contains(msg, s) {
return true
}
}
return false
}
func (s *DoltServer) doltInitWithRetries(ctx context.Context) error {
const maxRetries = 4
bo := backoff.NewExponentialBackOff()
bo.InitialInterval = 100 * time.Millisecond
bo.MaxInterval = 1 * time.Second
bo.MaxElapsedTime = 0
op := func() error {
err := s.doltInit(ctx)
if err == nil {
return nil
}
if !isRetryableDoltInitErr(err) {
return backoff.Permanent(err)
}
return err
}
return backoff.Retry(op, backoff.WithMaxRetries(backoff.WithContext(bo, ctx), maxRetries))
}
func (s *DoltServer) Start(ctx context.Context) error {
if s.eg != nil || s.egCtx != nil {
return fmt.Errorf("server: DoltServer.Start: server already started")
}
lock, err := util.TryLock(filepath.Join(s.rootDir, LockFileName))
if err != nil {
return fmt.Errorf("server: DoltServer.Start: acquire %s: %w", LockFileName, err)
}
if err := s.doltConfigure(ctx); err != nil {
lock.Unlock()
return err
}
if err := s.doltInitWithRetries(ctx); err != nil {
lock.Unlock()
return err
}
args := []string{
"sql-server",
"--config", s.configPath,
}
managedCtx, cancel := context.WithCancel(context.Background())
eg, egCtx := errgroup.WithContext(managedCtx)
s.eg = eg
s.egCtx = egCtx
s.cancel = cancel
cmd := exec.CommandContext(managedCtx, s.doltBinExec, args...)
cmd.Dir = s.rootDir
cmd.Stdin = nil
if s.logFile != nil {
cmd.Stdout = s.logFile
cmd.Stderr = s.logFile
}
cmd.Env = os.Environ()
if err := cmd.Start(); err != nil {
s.eg, s.egCtx, s.cancel = nil, nil, nil
cancel()
lock.Unlock()
return fmt.Errorf("server: DoltServer.Start: spawn dolt: %w", err)
}
s.pid = cmd.Process.Pid
if err := pidfile.Write(s.rootDir, PIDFileName, pidfile.PidFile{
Pid: s.pid,
Port: s.config.Port(),
}); err != nil {
_ = cmd.Process.Kill()
_, _ = cmd.Process.Wait()
s.eg, s.egCtx, s.cancel, s.pid = nil, nil, nil, 0
cancel()
lock.Unlock()
return fmt.Errorf("server: DoltServer.Start: write pidfile: %w", err)
}
eg.Go(func() error {
defer lock.Unlock()
return cmd.Wait()
})
if err := s.waitReady(ctx); err != nil {
cancel()
_ = s.eg.Wait()
s.eg, s.egCtx, s.cancel, s.pid = nil, nil, nil, 0
_ = pidfile.Remove(s.rootDir, PIDFileName)
return fmt.Errorf("server: DoltServer.Start: %w", err)
}
return nil
}
func (s *DoltServer) waitReady(ctx context.Context) error {
deadline := time.Now().Add(startReadyTimeout)
for {
if s.egCtx.Err() != nil {
return errors.New("dolt sql-server exited before listener became ready")
}
dctx, dcancel := context.WithTimeout(ctx, startReadyDialTimeout)
conn, err := s.Dial(dctx)
dcancel()
if err == nil {
_ = conn.Close()
return nil
}
if time.Now().After(deadline) {
return fmt.Errorf("listener not ready after %s: %w", startReadyTimeout, err)
}
select {
case <-ctx.Done():
return ctx.Err()
case <-s.egCtx.Done():
return errors.New("dolt sql-server exited before listener became ready")
case <-time.After(startReadyPollInterval):
}
}
}
func (s *DoltServer) Stop(_ context.Context) error {
if s.cancel != nil {
s.cancel()
}
var waitErr error
if s.eg != nil {
waitErr = s.eg.Wait()
var exitErr *exec.ExitError
if errors.As(waitErr, &exitErr) || errors.Is(waitErr, context.Canceled) {
waitErr = nil
}
}
var closeErr error
if s.logFile != nil {
closeErr = s.logFile.Close()
s.logFile = nil
}
var rmErr error
if s.pid != 0 {
rmErr = pidfile.Remove(s.rootDir, PIDFileName)
s.pid = 0
}
if waitErr != nil {
return fmt.Errorf("server: DoltServer.Stop: %w", waitErr)
}
if closeErr != nil {
return fmt.Errorf("server: DoltServer.Stop: close log: %w", closeErr)
}
if rmErr != nil {
return fmt.Errorf("server: DoltServer.Stop: remove pidfile: %w", rmErr)
}
return nil
}
func (s *DoltServer) Running(_ context.Context) bool {
if s.egCtx == nil {
return false
}
return s.egCtx.Err() == nil
}
func (s *DoltServer) Dial(ctx context.Context) (net.Conn, error) {
network, addr := "tcp", net.JoinHostPort(s.config.Host(), strconv.Itoa(s.config.Port()))
if sock := s.config.Socket(); sock != "" {
network, addr = "unix", sock
}
var d net.Dialer
conn, err := d.DialContext(ctx, network, addr)
if err != nil {
return nil, fmt.Errorf("server: DoltServer.Dial: %w", err)
}
if tc, ok := conn.(*net.TCPConn); ok {
_ = tc.SetKeepAlive(true)
_ = tc.SetKeepAlivePeriod(s.keepAlivePeriod)
}
return conn, nil
}