* refactor(state-store): delete NATS storerpc; agent store is gRPC-only (archie-core-8cda.4.6) The agent is fully on the gRPC State Store contract, so the legacy NATS storerpc path is dead (docs/prds/state-store-contract.md §12 step 4): - delete internal/storerpc (Server, Client, subjects) and its tests - drop the storerpc registration from registerTaskRPCServers and the now-unused store param - make the agent transport's State Store URL required and Store() return only the gRPC staterpc.Client (no NATS fallback) - rework agentworker/agent transport tests to back the store with a real gRPC State Store server instead of the deleted NATS storerpc server The agent binary now fails fast when STATE_STORE_URL is absent. Agent store calls (workflow.Store) go over gRPC to the archie-state-store service. * refactor(state-store): delete daemon/gateway in-process store ownership (archie-core-8cda.4.6) The daemon and gateway no longer open archie.db in-process: the single SQLite file is owned by the standalone archie-state-store process, and both consumers dial its gRPC State StateStore contract (docs/prds/state-store-contract.md §12 step 7, no dual-store ownership). - openStores no longer opens the production task store or seeds b.st; it only wires secrets/forge and the gateway conversation store - openStateStoreAdapter now requires [services.state].target (the old local default is deleted) and resolves b.stateStore as the remote *staterpc.Client - delete the in-process startStateStoreServer (the multiplexed gRPC server and its per-task bearer-token registry) from the daemon composition - RunGateway now resolves the same remote State Store adapter; its session SQLite stays Gateway-owned and untouched - daemon.ConnectedStateStore carries the configured target plus the resolved bearer token, which containerEnv injects as STATE_STORE_URL / STATE_STORE_TOKEN so archie-agent authenticates to the same remote service - readiness store probe reads b.stateStore PRD-consistent choice (noted): with the in-process server gone, per-task token generation is removed; the daemon/gateway/agent all present the single [services.state].target_token (or STATE_STORE_TOKEN secret) that the standalone store validates. * docs(webui): require [services.state].target in config and deployment templates (archie-core-8cda.4.6) After the in-process store path is deleted, archied and archie-gateway dial the standalone archie-state-store gRPC service via [services.state].target and never open archie.db themselves (docs/prds/state-store-contract.md §12 step 7). - config.example.toml documents [services.state].target as required, with the loopback vs Docker-bridge gateway + target_token rule - deployment templates set [services.state] per topology: bridge gateway + token for container-mode agents, loopback for host-only - deployments/README.md and systemd-user-service.md describe start commands for both topologies and drop the stale "not yet consumed by the daemon" note * style: gofumpt alignment for State Store daemon literal; appease noctx/staticcheck (archie-core-8cda.4.6) * docs(state-store): refresh stale in-process references post-cutover (archie-core-8cda.4.6)
143 lines
4.4 KiB
Go
143 lines
4.4 KiB
Go
// Package natsrpc holds the request/reply plumbing shared by
|
|
// archie-core's core-NATS RPC surfaces (worktreerpc, forgerpc,
|
|
// taskactions): a timeout-bounded client call, multi-subject server
|
|
// registration with rollback on partial failure, and a JSON error
|
|
// envelope so handlers don't each reimplement "marshal error, log
|
|
// encode/respond failures."
|
|
package natsrpc
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"time"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
)
|
|
|
|
// Envelope is the error half of an RPC response. Embed it in a
|
|
// response type (it flattens into the same JSON object via
|
|
// encoding/json's anonymous-field promotion) to get Err/NewEnvelope for
|
|
// free instead of hand-rolling an `Error string` field and its checks.
|
|
type Envelope struct {
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// NewEnvelope builds an Envelope from err, leaving Error empty on nil.
|
|
func NewEnvelope(err error) Envelope {
|
|
if err == nil {
|
|
return Envelope{}
|
|
}
|
|
return Envelope{Error: err.Error()}
|
|
}
|
|
|
|
// Err converts a populated Error string back into an error, or nil.
|
|
func (e Envelope) Err() error {
|
|
if e.Error == "" {
|
|
return nil
|
|
}
|
|
return errors.New(e.Error)
|
|
}
|
|
|
|
// Client sends timeout-bounded NATS request/reply calls.
|
|
type Client struct {
|
|
Conn *nats.Conn
|
|
// Timeout bounds each call when ctx has no deadline of its own.
|
|
Timeout time.Duration
|
|
}
|
|
|
|
// Request sends data to subject and returns the reply payload.
|
|
func (c *Client) Request(ctx context.Context, subject string, data []byte) ([]byte, error) {
|
|
if _, hasDeadline := ctx.Deadline(); !hasDeadline && c.Timeout > 0 {
|
|
var cancel context.CancelFunc
|
|
ctx, cancel = context.WithTimeout(ctx, c.Timeout)
|
|
defer cancel()
|
|
}
|
|
reply, err := c.Conn.RequestWithContext(ctx, subject, data)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s: %w", subject, err)
|
|
}
|
|
return reply.Data, nil
|
|
}
|
|
|
|
// Call marshals req, sends it to subject, and unmarshals the reply
|
|
// into a Resp. It does not inspect Resp's error envelope -- callers
|
|
// that embed Envelope should check Err() themselves, since natsrpc
|
|
// has no way to know a bare Resp type embeds one.
|
|
func Call[Resp any](ctx context.Context, c *Client, subject string, req any) (Resp, error) {
|
|
var zero Resp
|
|
data, err := json.Marshal(req)
|
|
if err != nil {
|
|
return zero, fmt.Errorf("encode %s request: %w", subject, err)
|
|
}
|
|
reply, err := c.Request(ctx, subject, data)
|
|
if err != nil {
|
|
return zero, err
|
|
}
|
|
var resp Resp
|
|
if err := json.Unmarshal(reply, &resp); err != nil {
|
|
return zero, fmt.Errorf("%s: decode response: %w", subject, err)
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// Registration pairs a subject with its handler for RegisterAll.
|
|
type Registration struct {
|
|
Subject string
|
|
Handler nats.MsgHandler
|
|
}
|
|
|
|
// RegisterAll subscribes every registration on nc and waits for the server
|
|
// to acknowledge them. If any step fails, every subscription made so far is
|
|
// unsubscribed before returning the error -- a server never ends up
|
|
// half-registered. The returned func unsubscribes all of them.
|
|
//
|
|
// The flush is what makes a successful return meaningful. Subscribe only
|
|
// queues the SUB frame on the client, so without it a caller that registers
|
|
// and immediately requests can beat its own subscription to the server and
|
|
// get nats.ErrNoResponders from a responder that is, by then, listening.
|
|
func RegisterAll(nc *nats.Conn, regs []Registration) (unsubscribe func(), err error) {
|
|
subs := make([]*nats.Subscription, 0, len(regs))
|
|
unsubscribeAll := func() {
|
|
for _, s := range subs {
|
|
_ = s.Unsubscribe()
|
|
}
|
|
}
|
|
|
|
for _, r := range regs {
|
|
sub, subErr := nc.Subscribe(r.Subject, r.Handler)
|
|
if subErr != nil {
|
|
unsubscribeAll()
|
|
return nil, fmt.Errorf("subscribe %s: %w", r.Subject, subErr)
|
|
}
|
|
subs = append(subs, sub)
|
|
}
|
|
|
|
if err := nc.Flush(); err != nil {
|
|
unsubscribeAll()
|
|
return nil, fmt.Errorf("flush subscriptions: %w", err)
|
|
}
|
|
|
|
return unsubscribeAll, nil
|
|
}
|
|
|
|
// Respond marshals v and replies to msg, logging (rather than
|
|
// returning) any encode or transport failure -- a handler has no
|
|
// meaningful way to retry or propagate a respond failure to its caller.
|
|
// pkg prefixes the log message (e.g. "forgerpc") to identify the
|
|
// surface a failure came from.
|
|
func Respond(msg *nats.Msg, log *slog.Logger, pkg string, v any) {
|
|
data, err := json.Marshal(v)
|
|
if err != nil {
|
|
if log != nil {
|
|
log.Error(pkg+": encode response failed", "err", err)
|
|
}
|
|
return
|
|
}
|
|
if err := msg.Respond(data); err != nil && log != nil {
|
|
log.Error(pkg+": respond failed", "err", err)
|
|
}
|
|
}
|