package pipeline import ( "fmt" "os" "path/filepath" "golang.org/x/sys/unix" ) // AcquireRunnerLock must precede recovery: a second server must never interrupt // the first server's live sessions. The kernel releases the advisory lock on // process exit; the sidecar is deliberately never unlinked (avoiding inode races). // The store must stay open until all runner goroutines have stopped. func (s *Store) AcquireRunnerLock() error { s.mu.Lock() defer s.mu.Unlock() if s.runnerClaimed { return fmt.Errorf("a runner already owns this store") } if err := s.acquireServerLock(); err != nil { return err } s.runnerClaimed = true return nil } // AcquireServerLock lets the executable fail before attaching chat or serving // requests. newRunner also claims it, protecting embedded handler callers. func (s *Store) AcquireServerLock() error { s.mu.Lock() defer s.mu.Unlock() return s.acquireServerLock() } func (s *Store) acquireServerLock() error { if s.runnerLock != nil { return nil } path, err := filepath.EvalSymlinks(s.path) if err != nil { return fmt.Errorf("resolve server database: %w", err) } file, err := os.OpenFile(path+".server.lock", os.O_CREATE|os.O_RDWR, 0600) if err != nil { return err } if err := unix.Flock(int(file.Fd()), unix.LOCK_EX|unix.LOCK_NB); err != nil { file.Close() return fmt.Errorf("another server owns database %s: %w", path, err) } s.runnerLock = file return nil }