Files
kandev/apps/backend/internal/system/restart/supervisor.go
T
2026-06-15 13:33:45 +01:00

133 lines
3.5 KiB
Go

package restart
import (
"bufio"
"context"
"encoding/json"
"fmt"
"net"
"os"
"runtime"
"time"
)
const (
EnvSupervisorSocket = "KANDEV_SUPERVISOR_SOCKET"
EnvSupervisorManifest = "KANDEV_SUPERVISOR_MANIFEST"
EnvRestartAdapter = "KANDEV_RESTART_ADAPTER"
controlTimeout = 2 * time.Second
)
type SupervisorManager struct {
SocketPath string
Manifest string
Dial func(ctx context.Context, network, address string) (net.Conn, error)
}
func NewManagerFromEnv() Manager {
adapter := os.Getenv(EnvRestartAdapter)
socket := os.Getenv(EnvSupervisorSocket)
if adapter == AdapterSupervisor && socket == "" {
return NewUnsupportedManager(fmt.Sprintf("%s is required when %s=%s.", EnvSupervisorSocket, EnvRestartAdapter, AdapterSupervisor))
}
if adapter == AdapterSupervisor || socket != "" {
return NewSupervisorManager(socket, os.Getenv(EnvSupervisorManifest))
}
return NewUnsupportedManager("")
}
func NewSupervisorManager(socketPath, manifest string) *SupervisorManager {
return &SupervisorManager{
SocketPath: socketPath,
Manifest: manifest,
Dial: (&net.Dialer{
Timeout: controlTimeout,
}).DialContext,
}
}
func (m *SupervisorManager) Capability(ctx context.Context) Capability {
if runtime.GOOS == "windows" {
return m.unsupported("Supervisor restart is not available on Windows yet.")
}
if m.SocketPath == "" {
return m.unsupported("Supervisor restart is not configured for this launch mode.")
}
if err := m.probe(ctx); err != nil {
return m.unsupported("Supervisor restart is configured but unavailable: " + err.Error())
}
return Capability{
Supported: true,
Mode: ModeSupervisor,
Adapter: AdapterSupervisor,
Details: map[string]interface{}{
"restart_requires_ui_poll": true,
},
}
}
func (m *SupervisorManager) RequestRestart(ctx context.Context) (RestartResponse, error) {
if cap := m.Capability(ctx); !cap.Supported {
return RestartResponse{Accepted: false, Message: cap.Reason}, ErrUnsupported
}
resp, err := m.send(ctx, map[string]string{"action": "restart"})
if err != nil {
return RestartResponse{}, err
}
if !resp.Accepted {
return RestartResponse{Accepted: false, Message: resp.Message}, fmt.Errorf("supervisor rejected restart: %s", resp.Message)
}
return RestartResponse{Accepted: true, Message: "Restart requested. Kandev will be unavailable briefly."}, nil
}
func (m *SupervisorManager) probe(ctx context.Context) error {
conn, err := m.dial(ctx)
if err != nil {
return err
}
return conn.Close()
}
func (m *SupervisorManager) send(ctx context.Context, req map[string]string) (RestartResponse, error) {
conn, err := m.dial(ctx)
if err != nil {
return RestartResponse{}, err
}
defer func() { _ = conn.Close() }()
if deadline, ok := ctx.Deadline(); ok {
_ = conn.SetDeadline(deadline)
} else {
_ = conn.SetDeadline(time.Now().Add(controlTimeout))
}
if err := json.NewEncoder(conn).Encode(req); err != nil {
return RestartResponse{}, err
}
line, err := bufio.NewReader(conn).ReadBytes('\n')
if err != nil {
return RestartResponse{}, err
}
var resp RestartResponse
if err := json.Unmarshal(line, &resp); err != nil {
return RestartResponse{}, err
}
return resp, nil
}
func (m *SupervisorManager) dial(ctx context.Context) (net.Conn, error) {
dial := m.Dial
if dial == nil {
dial = (&net.Dialer{Timeout: controlTimeout}).DialContext
}
return dial(ctx, "unix", m.SocketPath)
}
func (m *SupervisorManager) unsupported(reason string) Capability {
return Capability{
Supported: false,
Mode: ModeManual,
Adapter: AdapterUnsupported,
Reason: reason,
}
}