fix: remove idle monitor and activity signal daemon infrastructure (GH#2452)
Remove the idle monitor sidecar process and activity file mechanism. In Gas Town and external Dolt server setups, the server is managed externally, making this daemon infrastructure unnecessary. The idle monitor also contributed to background connection accumulation and CLOSE_WAIT issues under concurrent polecat load. Co-Authored-By: athosmartins <noreply@github.com> Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
parent
986334fec1
commit
4df17ca344
4 changed files with 4 additions and 460 deletions
|
|
@ -42,8 +42,6 @@ dolt-server.pid
|
|||
dolt-server.log
|
||||
dolt-server.lock
|
||||
dolt-server.port
|
||||
dolt-server.activity
|
||||
dolt-monitor.pid
|
||||
|
||||
# Backup data (auto-exported JSONL, local-only)
|
||||
backup/
|
||||
|
|
@ -87,8 +85,6 @@ var requiredPatterns = []string{
|
|||
"dolt-server.log",
|
||||
"dolt-server.lock",
|
||||
"dolt-server.port",
|
||||
"dolt-server.activity",
|
||||
"dolt-monitor.pid",
|
||||
}
|
||||
|
||||
// CheckGitignore checks if .beads/.gitignore is up to date.
|
||||
|
|
|
|||
|
|
@ -8,11 +8,9 @@ import (
|
|||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
|
|
@ -350,48 +348,6 @@ Displays whether the server is running, its PID, port, and data directory.`,
|
|||
},
|
||||
}
|
||||
|
||||
var doltIdleMonitorCmd = &cobra.Command{
|
||||
Use: "idle-monitor",
|
||||
Short: "Run idle monitor (internal, not for direct use)",
|
||||
Hidden: true,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
beadsDir, _ := cmd.Flags().GetString("beads-dir")
|
||||
if beadsDir == "" {
|
||||
beadsDir = beads.FindBeadsDir()
|
||||
}
|
||||
if beadsDir == "" {
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// PID file and lock management is handled inside RunIdleMonitor
|
||||
// to ensure single-instance enforcement (GH#2367).
|
||||
|
||||
// Parse idle timeout from config
|
||||
idleTimeout := doltserver.DefaultIdleTimeout
|
||||
if v := config.GetYamlConfig("dolt.idle-timeout"); v != "" {
|
||||
if v == "0" {
|
||||
// Disabled
|
||||
return
|
||||
}
|
||||
if d, err := time.ParseDuration(v); err == nil {
|
||||
idleTimeout = d
|
||||
}
|
||||
}
|
||||
|
||||
// Handle SIGTERM gracefully — clean up PID file on signal
|
||||
pidFile := filepath.Join(beadsDir, "dolt-monitor.pid")
|
||||
sigCh := make(chan os.Signal, 1)
|
||||
signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGINT)
|
||||
go func() {
|
||||
<-sigCh
|
||||
_ = os.Remove(pidFile)
|
||||
os.Exit(0)
|
||||
}()
|
||||
|
||||
doltserver.RunIdleMonitor(beadsDir, idleTimeout)
|
||||
},
|
||||
}
|
||||
|
||||
var doltKillallCmd = &cobra.Command{
|
||||
Use: "killall",
|
||||
Short: "Kill all orphan Dolt server processes",
|
||||
|
|
@ -879,7 +835,6 @@ func init() {
|
|||
doltStopCmd.Flags().Bool("force", false, "Force stop the server")
|
||||
doltPushCmd.Flags().Bool("force", false, "Force push (overwrite remote changes)")
|
||||
doltCommitCmd.Flags().StringP("message", "m", "", "Commit message (default: auto-generated)")
|
||||
doltIdleMonitorCmd.Flags().String("beads-dir", "", "Path to .beads directory")
|
||||
doltCleanDatabasesCmd.Flags().Bool("dry-run", false, "Show what would be dropped without dropping")
|
||||
doltRemoteRemoveCmd.Flags().Bool("force", false, "Force remove even when SQL and CLI URLs conflict")
|
||||
doltRemoteCmd.AddCommand(doltRemoteAddCmd)
|
||||
|
|
@ -894,7 +849,6 @@ func init() {
|
|||
doltCmd.AddCommand(doltStartCmd)
|
||||
doltCmd.AddCommand(doltStopCmd)
|
||||
doltCmd.AddCommand(doltStatusCmd)
|
||||
doltCmd.AddCommand(doltIdleMonitorCmd)
|
||||
doltCmd.AddCommand(doltKillallCmd)
|
||||
doltCmd.AddCommand(doltCleanDatabasesCmd)
|
||||
doltCmd.AddCommand(doltRemoteCmd)
|
||||
|
|
|
|||
|
|
@ -96,14 +96,10 @@ type State struct {
|
|||
}
|
||||
|
||||
// file paths within .beads/
|
||||
func pidPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.pid") }
|
||||
func logPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.log") }
|
||||
func lockPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.lock") }
|
||||
func portPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.port") }
|
||||
func activityPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.activity") }
|
||||
func monitorPidPath(beadsDir string) string {
|
||||
return filepath.Join(beadsDir, "dolt-monitor.pid")
|
||||
}
|
||||
func pidPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.pid") }
|
||||
func logPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.log") }
|
||||
func lockPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.lock") }
|
||||
func portPath(beadsDir string) string { return filepath.Join(beadsDir, "dolt-server.port") }
|
||||
|
||||
// MaxDoltServers is the hard ceiling on concurrent dolt sql-server processes.
|
||||
// Allows up to 3 (e.g., multiple projects).
|
||||
|
|
@ -366,8 +362,6 @@ func EnsureRunning(beadsDir string) (int, error) {
|
|||
}
|
||||
if state.Running {
|
||||
_ = EnsurePortFile(serverDir, state.Port)
|
||||
// Touch activity file so idle monitor knows we're active
|
||||
touchActivity(serverDir)
|
||||
return state.Port, nil
|
||||
}
|
||||
|
||||
|
|
@ -375,15 +369,9 @@ func EnsureRunning(beadsDir string) (int, error) {
|
|||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
touchActivity(serverDir)
|
||||
return s.Port, nil
|
||||
}
|
||||
|
||||
// touchActivity updates the activity file timestamp.
|
||||
func touchActivity(beadsDir string) {
|
||||
_ = os.WriteFile(activityPath(beadsDir), []byte(strconv.FormatInt(time.Now().Unix(), 10)), 0600)
|
||||
}
|
||||
|
||||
// Start explicitly starts a dolt sql-server for the project.
|
||||
// Returns the State of the started server, or an error.
|
||||
func Start(beadsDir string) (*State, error) {
|
||||
|
|
@ -473,8 +461,6 @@ func Start(beadsDir string) (*State, error) {
|
|||
_ = logFile.Close()
|
||||
_ = os.WriteFile(pidPath(beadsDir), []byte(strconv.Itoa(adoptPID)), 0600)
|
||||
_ = writePortFile(beadsDir, actualPort)
|
||||
touchActivity(beadsDir)
|
||||
forkIdleMonitor(beadsDir)
|
||||
return &State{Running: true, PID: adoptPID, Port: actualPort, DataDir: doltDir}, nil
|
||||
}
|
||||
|
||||
|
|
@ -524,10 +510,6 @@ func Start(beadsDir string) (*State, error) {
|
|||
pid, actualPort, err, logPath(beadsDir))
|
||||
}
|
||||
|
||||
// Touch activity and fork idle monitor
|
||||
touchActivity(beadsDir)
|
||||
forkIdleMonitor(beadsDir)
|
||||
|
||||
return &State{
|
||||
Running: true,
|
||||
PID: pid,
|
||||
|
|
@ -652,8 +634,6 @@ func StopWithForce(beadsDir string, force bool) error {
|
|||
func cleanupStateFiles(beadsDir string) {
|
||||
_ = os.Remove(pidPath(beadsDir))
|
||||
_ = os.Remove(portPath(beadsDir))
|
||||
_ = os.Remove(activityPath(beadsDir))
|
||||
stopIdleMonitor(beadsDir)
|
||||
}
|
||||
|
||||
// LogPath returns the path to the server log file.
|
||||
|
|
@ -836,229 +816,3 @@ func IsPreV56DoltDir(doltDir string) bool {
|
|||
_, err := os.Stat(markerPath)
|
||||
return os.IsNotExist(err)
|
||||
}
|
||||
|
||||
// --- Idle monitor ---
|
||||
|
||||
// DefaultIdleTimeout is the default duration before the idle monitor stops the server.
|
||||
const DefaultIdleTimeout = 30 * time.Minute
|
||||
|
||||
// MonitorCheckInterval is how often the idle monitor checks activity.
|
||||
const MonitorCheckInterval = 60 * time.Second
|
||||
|
||||
// stopServerProcess stops the Dolt server process without touching the idle
|
||||
// monitor's own state. This is used by the idle monitor to avoid killing itself
|
||||
// when shutting down an idle server. It flushes the working set, gracefully
|
||||
// stops the server, and removes server state files (PID, port) but leaves the
|
||||
// monitor PID file and activity file intact so the monitor can continue running
|
||||
// as a watchdog.
|
||||
func stopServerProcess(beadsDir string) error {
|
||||
state, err := IsRunning(beadsDir)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !state.Running {
|
||||
return nil // already stopped
|
||||
}
|
||||
|
||||
// Flush uncommitted working set changes before stopping.
|
||||
cfg := DefaultConfig(beadsDir)
|
||||
if flushErr := FlushWorkingSet(cfg.Host, state.Port); flushErr != nil {
|
||||
fmt.Fprintf(os.Stderr, "Warning: could not flush working set before stop: %v\n", flushErr)
|
||||
}
|
||||
|
||||
if err := gracefulStop(state.PID, 5*time.Second); err != nil {
|
||||
_ = os.Remove(pidPath(beadsDir))
|
||||
_ = os.Remove(portPath(beadsDir))
|
||||
return err
|
||||
}
|
||||
_ = os.Remove(pidPath(beadsDir))
|
||||
_ = os.Remove(portPath(beadsDir))
|
||||
return nil
|
||||
}
|
||||
|
||||
// forkIdleMonitor starts the idle monitor as a detached process.
|
||||
// It runs `bd dolt idle-monitor --beads-dir=<dir>` in the background.
|
||||
func forkIdleMonitor(beadsDir string) {
|
||||
// Don't fork if there's already a monitor running
|
||||
if isMonitorRunning(beadsDir) {
|
||||
return
|
||||
}
|
||||
|
||||
bdBin, err := os.Executable()
|
||||
if err != nil {
|
||||
return // best effort
|
||||
}
|
||||
|
||||
cmd := exec.Command(bdBin, "dolt", "idle-monitor", "--beads-dir", beadsDir)
|
||||
cmd.Stdin = nil
|
||||
cmd.Stdout = nil
|
||||
cmd.Stderr = nil
|
||||
cmd.SysProcAttr = procAttrDetached()
|
||||
|
||||
if err := cmd.Start(); err != nil {
|
||||
return // best effort
|
||||
}
|
||||
|
||||
// Write monitor PID file
|
||||
_ = os.WriteFile(monitorPidPath(beadsDir), []byte(strconv.Itoa(cmd.Process.Pid)), 0600)
|
||||
_ = cmd.Process.Release()
|
||||
}
|
||||
|
||||
// isMonitorRunning checks if the idle monitor process is alive.
|
||||
func isMonitorRunning(beadsDir string) bool {
|
||||
data, err := os.ReadFile(monitorPidPath(beadsDir))
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return isProcessAlive(pid)
|
||||
}
|
||||
|
||||
// stopIdleMonitor kills the idle monitor process if running.
|
||||
func stopIdleMonitor(beadsDir string) {
|
||||
data, err := os.ReadFile(monitorPidPath(beadsDir))
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
|
||||
if err != nil {
|
||||
_ = os.Remove(monitorPidPath(beadsDir))
|
||||
return
|
||||
}
|
||||
if process, err := os.FindProcess(pid); err == nil {
|
||||
_ = process.Kill()
|
||||
}
|
||||
_ = os.Remove(monitorPidPath(beadsDir))
|
||||
}
|
||||
|
||||
// ReadActivityTime reads the last activity timestamp from the activity file.
|
||||
// Returns zero time if the file doesn't exist or is unreadable.
|
||||
func ReadActivityTime(beadsDir string) time.Time {
|
||||
data, err := os.ReadFile(activityPath(beadsDir))
|
||||
if err != nil {
|
||||
return time.Time{}
|
||||
}
|
||||
ts, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)
|
||||
if err != nil {
|
||||
return time.Time{}
|
||||
}
|
||||
return time.Unix(ts, 0)
|
||||
}
|
||||
|
||||
// RunIdleMonitor is the main loop for the idle monitor sidecar process.
|
||||
// It checks the activity file periodically and stops the server if idle
|
||||
// for longer than the configured timeout. After stopping an idle server,
|
||||
// the monitor continues running as a watchdog: if new activity appears
|
||||
// (e.g. a bd command calls EnsureRunning and touches the activity file),
|
||||
// the monitor restarts the server. The monitor only exits after an
|
||||
// additional full idle timeout passes with no new activity.
|
||||
//
|
||||
// If the server crashed but activity is recent, the monitor restarts it
|
||||
// (watchdog behavior).
|
||||
//
|
||||
// idleTimeout of 0 means monitoring is disabled (exits immediately).
|
||||
func RunIdleMonitor(beadsDir string, idleTimeout time.Duration) {
|
||||
if idleTimeout == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// Single-instance enforcement: acquire an exclusive lock on the monitor
|
||||
// lock file. If another monitor is already running, exit immediately.
|
||||
// This prevents the accumulation bug (GH#2367) where Start() called from
|
||||
// within the monitor's watchdog restart would fork yet another monitor.
|
||||
monitorLockPath := monitorPidPath(beadsDir) + ".lock"
|
||||
var monitorLock *os.File
|
||||
if f, err := os.OpenFile(monitorLockPath, os.O_CREATE|os.O_RDWR, 0600); err == nil { //nolint:gosec // G304: path derived from trusted beadsDir
|
||||
if lockErr := lockfile.FlockExclusiveNonBlocking(f); lockErr != nil {
|
||||
_ = f.Close()
|
||||
return // another monitor holds the lock — exit silently
|
||||
}
|
||||
monitorLock = f
|
||||
}
|
||||
// Keep lock held for lifetime of this process. Clean up on exit.
|
||||
defer func() {
|
||||
_ = os.Remove(monitorPidPath(beadsDir))
|
||||
if monitorLock != nil {
|
||||
_ = lockfile.FlockUnlock(monitorLock)
|
||||
_ = monitorLock.Close()
|
||||
_ = os.Remove(monitorLockPath)
|
||||
}
|
||||
}()
|
||||
|
||||
// Write our PID now that we hold the lock
|
||||
_ = os.WriteFile(monitorPidPath(beadsDir), []byte(strconv.Itoa(os.Getpid())), 0600)
|
||||
|
||||
// Tracks when we stopped the server for idle timeout. Zero means we
|
||||
// haven't performed an idle shutdown (or the server was restarted since).
|
||||
var idleShutdownAt time.Time
|
||||
|
||||
// Remember the port the server was using before we stopped it, so we
|
||||
// can restore the port file before calling Start(). Without this,
|
||||
// stopServerProcess removes the port file, and Start() may fall back
|
||||
// to a hash-derived port that differs from the original (bd-xvg).
|
||||
var lastKnownPort int
|
||||
|
||||
for {
|
||||
time.Sleep(MonitorCheckInterval)
|
||||
|
||||
state, err := IsRunning(beadsDir)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
lastActivity := ReadActivityTime(beadsDir)
|
||||
idleDuration := time.Since(lastActivity)
|
||||
|
||||
if state.Running {
|
||||
idleShutdownAt = time.Time{} // server is up, clear idle-shutdown tracking
|
||||
lastKnownPort = state.Port // track port while server is up
|
||||
|
||||
// Server is running — check if idle
|
||||
if !lastActivity.IsZero() && idleDuration > idleTimeout {
|
||||
// Idle too long — stop the server but keep monitoring.
|
||||
// Use stopServerProcess (not Stop) to avoid killing ourselves.
|
||||
_ = stopServerProcess(beadsDir)
|
||||
idleShutdownAt = time.Now()
|
||||
}
|
||||
} else {
|
||||
// Server is NOT running
|
||||
if !idleShutdownAt.IsZero() {
|
||||
// We stopped it for idle timeout. Check for new activity
|
||||
// (e.g. EnsureRunning touched the activity file).
|
||||
if !lastActivity.IsZero() && lastActivity.After(idleShutdownAt) {
|
||||
// New activity since we stopped — restart on the same port.
|
||||
// Restore port file so Start()/DefaultConfig() picks it up.
|
||||
if lastKnownPort > 0 {
|
||||
_ = writePortFile(beadsDir, lastKnownPort)
|
||||
}
|
||||
_, _ = Start(beadsDir)
|
||||
idleShutdownAt = time.Time{}
|
||||
continue
|
||||
}
|
||||
// No new activity yet. If we've been waiting longer than
|
||||
// another full idle timeout since shutdown, give up and exit.
|
||||
if time.Since(idleShutdownAt) > idleTimeout {
|
||||
_ = os.Remove(monitorPidPath(beadsDir))
|
||||
return
|
||||
}
|
||||
// Keep waiting for new activity
|
||||
continue
|
||||
}
|
||||
|
||||
// Server is down but we didn't stop it (crash or external stop).
|
||||
if lastActivity.IsZero() || idleDuration > idleTimeout {
|
||||
// No recent activity — just exit
|
||||
_ = os.Remove(monitorPidPath(beadsDir))
|
||||
return
|
||||
}
|
||||
// Recent activity but server crashed — restart on the same port.
|
||||
if lastKnownPort > 0 {
|
||||
_ = writePortFile(beadsDir, lastKnownPort)
|
||||
}
|
||||
_, _ = Start(beadsDir)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,10 +5,8 @@ import (
|
|||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/steveyegge/beads/internal/config"
|
||||
)
|
||||
|
|
@ -481,27 +479,6 @@ func TestIsRunningReadsPortFile(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
// --- Activity tracking tests ---
|
||||
|
||||
func TestTouchAndReadActivity(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// No file yet
|
||||
if ts := ReadActivityTime(dir); !ts.IsZero() {
|
||||
t.Errorf("expected zero time for missing activity file, got %v", ts)
|
||||
}
|
||||
|
||||
// Touch and read
|
||||
touchActivity(dir)
|
||||
ts := ReadActivityTime(dir)
|
||||
if ts.IsZero() {
|
||||
t.Fatal("expected non-zero activity time after touch")
|
||||
}
|
||||
if time.Since(ts) > 5*time.Second {
|
||||
t.Errorf("activity timestamp too old: %v", ts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCleanupStateFiles(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
|
|
@ -509,7 +486,6 @@ func TestCleanupStateFiles(t *testing.T) {
|
|||
for _, path := range []string{
|
||||
pidPath(dir),
|
||||
portPath(dir),
|
||||
activityPath(dir),
|
||||
} {
|
||||
if err := os.WriteFile(path, []byte("test"), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
|
|
@ -521,7 +497,6 @@ func TestCleanupStateFiles(t *testing.T) {
|
|||
for _, path := range []string{
|
||||
pidPath(dir),
|
||||
portPath(dir),
|
||||
activityPath(dir),
|
||||
} {
|
||||
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
||||
t.Errorf("expected %s to be removed", filepath.Base(path))
|
||||
|
|
@ -529,25 +504,6 @@ func TestCleanupStateFiles(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
// --- Idle monitor tests ---
|
||||
|
||||
func TestRunIdleMonitorDisabled(t *testing.T) {
|
||||
// idleTimeout=0 should return immediately
|
||||
dir := t.TempDir()
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
RunIdleMonitor(dir, 0)
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
// good — returned immediately
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("RunIdleMonitor(0) should return immediately")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFlushWorkingSetUnreachable(t *testing.T) {
|
||||
// FlushWorkingSet should return an error when the server is not reachable.
|
||||
err := FlushWorkingSet("127.0.0.1", 19998)
|
||||
|
|
@ -559,35 +515,6 @@ func TestFlushWorkingSetUnreachable(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestMonitorPidLifecycle(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// No monitor running
|
||||
if isMonitorRunning(dir) {
|
||||
t.Error("expected no monitor running initially")
|
||||
}
|
||||
|
||||
// Write our own PID as monitor (we know we're alive)
|
||||
_ = os.WriteFile(monitorPidPath(dir), []byte(strconv.Itoa(os.Getpid())), 0600)
|
||||
if !isMonitorRunning(dir) {
|
||||
t.Error("expected monitor to be detected as running")
|
||||
}
|
||||
|
||||
// Don't call stopIdleMonitor with our own PID (it sends SIGTERM).
|
||||
// Instead test with a dead PID.
|
||||
_ = os.Remove(monitorPidPath(dir))
|
||||
_ = os.WriteFile(monitorPidPath(dir), []byte("99999999"), 0600)
|
||||
if isMonitorRunning(dir) {
|
||||
t.Error("expected dead PID to not be detected as running")
|
||||
}
|
||||
|
||||
// stopIdleMonitor should clean up the PID file
|
||||
stopIdleMonitor(dir)
|
||||
if _, err := os.Stat(monitorPidPath(dir)); !os.IsNotExist(err) {
|
||||
t.Error("expected monitor PID file to be removed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsDoltProcessDeadPID(t *testing.T) {
|
||||
// A non-existent PID should return false (ps will fail)
|
||||
if isDoltProcess(99999999) {
|
||||
|
|
@ -794,90 +721,3 @@ func TestEnsureDoltInit_WritesMarker(t *testing.T) {
|
|||
t.Error("expected .bd-dolt-ok marker to be written after successful dolt init")
|
||||
}
|
||||
}
|
||||
|
||||
// --- stopServerProcess tests ---
|
||||
|
||||
func TestStopServerProcessPreservesMonitorAndActivity(t *testing.T) {
|
||||
// stopServerProcess must leave the monitor PID file and activity file
|
||||
// intact. This is the core fix for GH#2324: the idle monitor calls
|
||||
// stopServerProcess (not Stop) to avoid killing itself via
|
||||
// cleanupStateFiles → stopIdleMonitor.
|
||||
dir := t.TempDir()
|
||||
t.Setenv("GT_ROOT", "")
|
||||
|
||||
// Write activity and monitor PID files
|
||||
touchActivity(dir)
|
||||
monitorPID := os.Getpid()
|
||||
_ = os.WriteFile(monitorPidPath(dir), []byte(strconv.Itoa(monitorPID)), 0600)
|
||||
|
||||
// No server PID file → stopServerProcess returns immediately (already stopped)
|
||||
if err := stopServerProcess(dir); err != nil {
|
||||
t.Fatalf("stopServerProcess: %v", err)
|
||||
}
|
||||
|
||||
// Activity file must be preserved
|
||||
if _, err := os.Stat(activityPath(dir)); os.IsNotExist(err) {
|
||||
t.Error("stopServerProcess must preserve activity file")
|
||||
}
|
||||
// Monitor PID file must be preserved
|
||||
if _, err := os.Stat(monitorPidPath(dir)); os.IsNotExist(err) {
|
||||
t.Error("stopServerProcess must preserve monitor PID file")
|
||||
}
|
||||
// Monitor PID should still contain our PID (not corrupted)
|
||||
data, err := os.ReadFile(monitorPidPath(dir))
|
||||
if err != nil {
|
||||
t.Fatalf("reading monitor PID file: %v", err)
|
||||
}
|
||||
if pid, _ := strconv.Atoi(strings.TrimSpace(string(data))); pid != monitorPID {
|
||||
t.Errorf("monitor PID file changed: want %d, got %d", monitorPID, pid)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStopServerProcessRemovesPidAndPort(t *testing.T) {
|
||||
// When the server is running (simulated with a stale PID that IsRunning
|
||||
// will clean up), stopServerProcess should remove PID and port files
|
||||
// but leave activity and monitor files intact.
|
||||
dir := t.TempDir()
|
||||
t.Setenv("GT_ROOT", "")
|
||||
|
||||
// Write all state files
|
||||
_ = os.WriteFile(pidPath(dir), []byte("99999999"), 0600) // dead PID
|
||||
_ = writePortFile(dir, 13500)
|
||||
touchActivity(dir)
|
||||
_ = os.WriteFile(monitorPidPath(dir), []byte(strconv.Itoa(os.Getpid())), 0600)
|
||||
|
||||
// stopServerProcess: IsRunning sees dead PID → returns Running=false →
|
||||
// stopServerProcess returns nil (already stopped).
|
||||
_ = stopServerProcess(dir)
|
||||
|
||||
// PID file was cleaned up by IsRunning (stale PID detection)
|
||||
if _, err := os.Stat(pidPath(dir)); !os.IsNotExist(err) {
|
||||
t.Error("expected server PID file to be removed")
|
||||
}
|
||||
|
||||
// Activity and monitor PID files must survive
|
||||
if _, err := os.Stat(activityPath(dir)); os.IsNotExist(err) {
|
||||
t.Error("stopServerProcess must preserve activity file")
|
||||
}
|
||||
if _, err := os.Stat(monitorPidPath(dir)); os.IsNotExist(err) {
|
||||
t.Error("stopServerProcess must preserve monitor PID file")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunIdleMonitorZeroTimeoutExitsImmediately(t *testing.T) {
|
||||
// With zero timeout, the monitor should exit immediately.
|
||||
dir := t.TempDir()
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
RunIdleMonitor(dir, 0)
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
// good — exited immediately with zero timeout
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("RunIdleMonitor should exit immediately with zero timeout")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue