87 lines
2.3 KiB
Go
87 lines
2.3 KiB
Go
package codexhost
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
// Paths identifies a single upstream connection within one server scope.
|
|
func Paths(dir, upstream string) (socket, lock string) {
|
|
absolute, err := filepath.Abs(upstream)
|
|
if err == nil {
|
|
upstream = absolute
|
|
}
|
|
sum := sha256.Sum256([]byte(upstream))
|
|
key := hex.EncodeToString(sum[:8])
|
|
return filepath.Join(dir, key+".sock"), filepath.Join(dir, key+".lock")
|
|
}
|
|
func reachable(socket string) bool {
|
|
conn, err := net.DialTimeout("unix", socket, 100*time.Millisecond)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
conn.Close()
|
|
return true
|
|
}
|
|
|
|
// Ensure starts only the private bridge, never Codex itself, when no bridge is
|
|
// already serving this upstream/scope. The detached helper survives its parent.
|
|
func Ensure(ctx context.Context, binary, dir, upstream string) (string, error) {
|
|
if err := EnsureDir(dir); err != nil {
|
|
return "", err
|
|
}
|
|
socket, _ := Paths(dir, upstream)
|
|
if reachable(socket) {
|
|
return socket, nil
|
|
}
|
|
logPath := strings.TrimSuffix(socket, ".sock") + ".log"
|
|
logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer logFile.Close()
|
|
cmd := exec.Command(binary, "-dir", dir, "-upstream", upstream)
|
|
cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
|
|
cmd.Stderr = logFile
|
|
stdout, err := cmd.StdoutPipe()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if err := cmd.Start(); err != nil {
|
|
return "", err
|
|
}
|
|
result := make(chan string, 1)
|
|
go func() { line, _ := bufio.NewReader(stdout).ReadString('\n'); result <- strings.TrimSpace(line) }()
|
|
timer := time.NewTimer(15 * time.Second)
|
|
defer timer.Stop()
|
|
failed := func(err error) (string, error) { _ = cmd.Process.Kill(); _ = cmd.Wait(); return "", err }
|
|
select {
|
|
case <-ctx.Done():
|
|
return failed(ctx.Err())
|
|
case <-timer.C:
|
|
return failed(errors.New("Codex host start timed out"))
|
|
case line := <-result:
|
|
if line == "ready "+socket {
|
|
go func() { _ = cmd.Wait() }()
|
|
return socket, nil
|
|
}
|
|
// A racing server may have won the singleton lock and started the host.
|
|
_ = cmd.Wait()
|
|
if reachable(socket) {
|
|
return socket, nil
|
|
}
|
|
return "", fmt.Errorf("Codex host did not start (%s); log: %s", line, logPath)
|
|
}
|
|
}
|