Files
archie/internal/natsrpc/natsrpc.go
T
sam d80401d595 feat: add config overlay and shared RPC/Yaegi packages
- Introduce `-config-overlay` flag and `config.LoadOverlay()` to merge a base config with an overlay file, only overriding fields the overlay sets. This enables docker-compose to mount the base config from the host and apply only deployment-specific overrides.
- Create `internal/natsrpc` package with reusable NATS request/reply primitives (Envelope, Client, Call, RegisterAll, Respond). Migrate storerpc, worktreerpc, and forgerpc to use it, eliminating duplicated marshal/unmarshal and error handling.
- Create `internal/yaegiutil` package with shared interpreter construction (stdlib + extra symbols), generic export resolution (Resolve), and panic recovery (Safe). Migrate all Yaegi-based surfaces (gate scripts, daemon plugins, skill plugins, workflow stages, skill scripts) to use it, reducing boilerplate and centralizing panic safety.
- Simplify `config.docker.toml` to contain only overlay fields (paths, container config) and remove the duplicated repos list – the base config is now the single source of truth.
- Update docker-compose.yml to pass both -config and -config-overlay flags and mount the base config from the host.
- Add tests for LoadOverlay, DockerConfigOverlaysExampleConfig, Envelope, and yaegiutil utilities.
2026-07-24 12:57:10 +10:00

132 lines
3.9 KiB
Go

// Package natsrpc holds the request/reply plumbing shared by
// archie-core's three core-NATS RPC surfaces (storerpc, worktreerpc,
// forgerpc): 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. If any subscribe
// call 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.
func RegisterAll(nc *nats.Conn, regs []Registration) (unsubscribe func(), err error) {
subs := make([]*nats.Subscription, 0, len(regs))
for _, r := range regs {
sub, err := nc.Subscribe(r.Subject, r.Handler)
if err != nil {
for _, s := range subs {
s.Unsubscribe()
}
return nil, fmt.Errorf("subscribe %s: %w", r.Subject, err)
}
subs = append(subs, sub)
}
return func() {
for _, s := range subs {
s.Unsubscribe()
}
}, 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. "storerpc") 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)
}
}