2fcc32d8 gave archied sd_notify: one READY=1 when the run loop starts serving. RunGateway and RunStateStore serve contracts and health surfaces of their own -- the State Store even takes -ready-addr for a readiness HTTP listener -- but told systemd nothing, so run as Type=notify either would hang until TimeoutStartSec and be killed in a restart loop while perfectly healthy (archie-core-1174). Both now announce at the moment each declares itself serving, the same notion archied's runLoop announces beside healthSurface.markServing -- no second definition of started. The Gateway announces from its serving tail (serveGatewayListener, extracted from RunGateway), after the listener is bound; the State Store announces after its optional surfaces have started, because a readiness surface that fails to bind fails the boot and READY must not precede it, and before serveStateStore, which begins accepting the moment it is called. No unit file changes Type=notify for them; the helper already lives in package archied beside both entry points, so no move was needed. Tests follow the notify pattern the daemon's announcement already has: the Gateway test drives its serving tail over a bound loopback listener with a stub contract and judges READY against a real Snapshot RPC on the same socket; the State Store test drives the real RunStateStore boot over a pgtest database and waits for the datagram. Both failed red before the announcement existed -- no datagram within the window -- and pass after.
233 lines
8.7 KiB
Go
233 lines
8.7 KiB
Go
package archied
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"time"
|
|
|
|
natsio "github.com/nats-io/nats.go"
|
|
"google.golang.org/grpc"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/applystatus"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/gateway"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/taskactions"
|
|
"github.com/samcharles93/archie-core/internal/plugin"
|
|
)
|
|
|
|
// GatewayOptions contains process inputs for the standalone Gateway.
|
|
type GatewayOptions struct {
|
|
Config string
|
|
Overlay string
|
|
Listen string
|
|
// Token is the Bearer [REDACTED] the Gateway server validates for a
|
|
// non-loopback listener. Empty falls back to
|
|
// [services.gateway].target_token.
|
|
Token string
|
|
}
|
|
|
|
// gatewayListenAndToken resolves the two per-listener inputs RunGateway needs:
|
|
// the address it binds and the bearer token a non-loopback bind validates.
|
|
//
|
|
// Both are flag-first and config-second, and both fail closed rather than
|
|
// inventing a value -- resolveServiceListen explains why an empty address is an
|
|
// error rather than a default.
|
|
func gatewayListenAndToken(b *boot, options GatewayOptions) (listen, token string, err error) {
|
|
listen, err = resolveServiceListen("gateway", options.Listen, b.cfg.Services.Get(config.ServiceNameGateway).Listen)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
token = options.Token
|
|
if token == "" {
|
|
token = b.cfg.Services.ResolvedToken(config.ServiceNameGateway, b.secrets.Getenv)
|
|
}
|
|
return listen, token, nil
|
|
}
|
|
|
|
// RunGateway owns conversation persistence, model runtime and tool-provider
|
|
// lifecycles. Task-store adapters access the State Store contract (remote
|
|
// *staterpc.Client via [services.state].target). The Gateway serves the
|
|
// conversation store from database_url and holds the Gateway serve claim for
|
|
// its whole life.
|
|
func RunGateway(ctx context.Context, options GatewayOptions) error {
|
|
b := newBootstrap()
|
|
b.processName = applystatus.Gateway
|
|
defer b.cleanup()
|
|
if err := b.loadConfig(ctx, options.Config, options.Overlay); err != nil {
|
|
return err
|
|
}
|
|
b.log = b.log.With("component", "gateway")
|
|
if err := b.openStores(ctx); err != nil {
|
|
return err
|
|
}
|
|
// The Gateway also no longer opens archie.db directly: it consumes the
|
|
// same remote State Store contract the daemon does via
|
|
// [services.state].target (docs/prds/state-store-contract.md §12 step 7).
|
|
if err := b.openGatewayState(ctx); err != nil {
|
|
return err
|
|
}
|
|
b.loadCatalog(ctx, options.Config)
|
|
url, token := b.cfg.NATS.URL, ""
|
|
var nc *natsio.Conn
|
|
var err error
|
|
if b.cfg.NATS.Mode == config.NATSModeExternal { //nolint:nestif // external and embedded transports have distinct credential and discovery flows
|
|
token, err = configuredNATSToken(b.cfg.NATS, os.Getenv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
nc, err = natsio.Connect(url, natsio.Token(token))
|
|
} else {
|
|
var endpoint embeddedNATSEndpoint
|
|
endpoint, err = readEmbeddedNATSEndpoint(b.cfg.StateDir)
|
|
if err == nil {
|
|
url, token = endpoint.URL, endpoint.Token
|
|
nc, err = natsio.Connect(url, natsio.Token(token))
|
|
}
|
|
if nc == nil || err != nil {
|
|
url, token, err = b.startEmbeddedNATS(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
nc, err = natsio.Connect(url, natsio.Token(token))
|
|
}
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("connect gateway task actions: %w", err)
|
|
}
|
|
b.addCleanup(nc.Close)
|
|
// Held so /status can report this process's own broker connection: the
|
|
// health source reads it through boot rather than dialling.
|
|
b.taskActionsConn = nc
|
|
contract, err := b.startGatewayRuntime(ctx, taskactions.Client{Conn: nc, Timeout: 30 * time.Second})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
listen, gatewayToken, err := gatewayListenAndToken(b, options)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
//nolint:contextcheck // grpc.StreamServerInterceptor has no context.Context parameter; gatewayrpc.StreamServerInterceptor derives its context from stream.Context() instead
|
|
opts, loopback, err := gatewayServerOpts(listen, gatewayToken)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", listen)
|
|
if err != nil {
|
|
return fmt.Errorf("listen for gateway: %w", err)
|
|
}
|
|
return b.serveGatewayListener(ctx, listener, loopback, contract, opts)
|
|
}
|
|
|
|
// serveGatewayListener is the serving tail of RunGateway: the listener is
|
|
// bound, the process declares itself serving, and the chat contract answers
|
|
// until ctx ends.
|
|
func (b *boot) serveGatewayListener(ctx context.Context, listener net.Listener, loopback bool, contract gateway.ChatContract, opts []grpc.ServerOption) error {
|
|
defer listener.Close()
|
|
b.log.Info("archie-gateway running", "addr", listener.Addr().String(), "token_required", !loopback)
|
|
// Boot is over and this listener is about to accept: the same fact
|
|
// systemd's READY=1 asserts, so the announcement goes out here rather than
|
|
// from a second notion of "started" (archie-core-1174). Not later: Serve
|
|
// begins accepting the moment it is called, and a unit whose
|
|
// TimeoutStartSec expires first would restart a healthy process.
|
|
b.announceReady()
|
|
return serveGateway(ctx, listener, contract, b.chatSessionStore, opts)
|
|
}
|
|
|
|
func (b *boot) openGatewayState(ctx context.Context) error {
|
|
if err := b.claimGatewayOwnership(ctx); err != nil {
|
|
return err
|
|
}
|
|
if err := b.openStateStoreAdapter(); err != nil {
|
|
return err
|
|
}
|
|
if err := b.loadRuntimeConfig(ctx); err != nil {
|
|
return fmt.Errorf("load runtime settings: %w", err)
|
|
}
|
|
go b.applyStatus.Run(ctx)
|
|
return nil
|
|
}
|
|
|
|
func (b *boot) startGatewayRuntime(ctx context.Context, actor gateway.ChatTaskActor) (gateway.ChatContract, error) {
|
|
b.bus = events.NewBus()
|
|
b.addCleanup(b.bus.Close)
|
|
b.capabilityHost = plugin.NewHost()
|
|
b.startRateLimiter(ctx, b.cfg.Chat.RateLimit)
|
|
// The Gateway owns PR review (docs/prds/operator-pr-review.md §4), so it
|
|
// composes the process-wide worktree manager before setupGatewayChat
|
|
// resolves boot.prReviewer: prReviewer returns nil without a manager, and
|
|
// a nil reviewer omits review_pr from every channel's tool set. The
|
|
// manager is the only part of the daemon's tree composition the Gateway
|
|
// takes -- it must not own identity runners, so it does not call
|
|
// buildTreesAndIdentities.
|
|
b.buildWorktreeManager()
|
|
// setupMemoryEngine must run before setupGatewayChat: setupGatewayChat
|
|
// constructs the turn runner, which captures b.memEngines at
|
|
// construction time (see the identical ordering note in main.go's Run).
|
|
if err := b.setupMemoryEngine(); err != nil { //nolint:contextcheck // setupMemoryEngine owns its own lifecycle context, matching the daemon's setupMemoryEngine
|
|
return nil, err
|
|
}
|
|
contract, err := b.setupGatewayChat(ctx, actor)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := b.registerTools(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
b.registerStandaloneTools()
|
|
b.addCleanup(shutdownCapabilityHost(b.capabilityHost, b.log))
|
|
if err := b.capabilityHost.Start(ctx); err != nil {
|
|
return nil, fmt.Errorf("start gateway tool providers: %w", err)
|
|
}
|
|
for _, skipped := range b.providerRegistry.Skipped() {
|
|
b.log.Warn("gateway tool provider unavailable", "provider", skipped.ID, "err", skipped.Err)
|
|
}
|
|
return contract, nil
|
|
}
|
|
|
|
// gatewayServerOpts applies the transport security boundary: a loopback
|
|
// listener is served insecure with no token; any non-loopback address
|
|
// requires a Bearer [REDACTED], else the process fails closed. It mirrors
|
|
// stateStoreServerOpts, minus the State Store's task-scoped grants: the
|
|
// Gateway has one administrative token for all callers.
|
|
func gatewayServerOpts(listen, token string) (opts []grpc.ServerOption, loopback bool, err error) {
|
|
loopback, err = gatewayrpc.TargetIsLoopback(listen)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
if loopback {
|
|
return nil, true, nil
|
|
}
|
|
if token == "" {
|
|
return nil, false, fmt.Errorf(
|
|
"gateway listen address %q is non-loopback; non-loopback exposure requires a Bearer [REDACTED] (--token / [services.gateway].target_token) or TLS",
|
|
listen,
|
|
)
|
|
}
|
|
return []grpc.ServerOption{
|
|
grpc.ChainUnaryInterceptor(gatewayrpc.UnaryServerInterceptor(token)),
|
|
grpc.ChainStreamInterceptor(gatewayrpc.StreamServerInterceptor(token)),
|
|
}, false, nil
|
|
}
|
|
|
|
func serveGateway(ctx context.Context, listener net.Listener, contract gateway.ChatContract, sessions gateway.SessionStore, opts []grpc.ServerOption) error {
|
|
server := grpc.NewServer(opts...)
|
|
gatewayrpc.RegisterServer(server, contract, sessions)
|
|
serveErr := make(chan error, 1)
|
|
go func() { serveErr <- server.Serve(listener) }()
|
|
select {
|
|
case <-ctx.Done():
|
|
// A client can keep a streaming RPC open indefinitely. Allow draining,
|
|
// then force cancellation before closing the session store and tools.
|
|
timer := time.AfterFunc(10*time.Second, server.Stop)
|
|
server.GracefulStop()
|
|
timer.Stop()
|
|
return nil
|
|
case err := <-serveErr:
|
|
return err
|
|
}
|
|
}
|