Merge pull request #872 from samcharles93/feat/service-registry

feat(config): key services by name through a registry
This commit is contained in:
sam authored and GitHub committed 2026-09-19 01:53:00 +10:00
commit 4c4cdcbc37
23 files changed
+749 -131

No files matched your search

+16
View File
@@ -529,3 +529,19 @@ config DTO translation will land, so it unblocks the dissolution above.
per area when the decisions are already dictated by
`dependencies-and-contracts.md`. That is the ceremony pattern this project
deliberately avoids.
## OPEN — `[chat.*]` config section naming
`configuration.md:160` already states the position: `ChatConfig` holds "separate
channel instance settings... there is no chat-wide settings owner". The config
section name has not followed, so a settings block named for a product surface
owns what the architecture calls channel state.
Two candidates, neither settled: `[channel.*]` and `[messaging.channel.*]`. The
second reads as a domain path, and no config section in this repo is currently
named after a domain package, so adopting it sets a precedent for every other
section rather than fixing one name.
Blocked on a maintainer decision, not on evidence. This is a rename with an
operator-visible TOML break, so it should land with the `internal/config`
dissolution recorded above rather than on its own.
+112
View File
@@ -0,0 +1,112 @@
# Service registry — one declaration per service
**Status:** Design, pre-implementation. Supersedes `state-store-contract.md` §10's
`State ServiceConnection` struct-field instruction (revised to rev. 2d in the same change).
**Base:** the `listen` field, `internal/app/archied/listen.go`, and the listen defaults cited
below exist on `feat/attempt-attribution`, not on `main`. This design therefore lands on top of
that branch: `RegisterService`'s `listen` argument has nothing to carry without it.
## Problem
A service is already one Go type, `config.ServiceConnection`. What is duplicated is its
**name**, in three layers:
| Layer | Location | What is hard-coded |
|---|---|---|
| Declaration | `internal/config/services.go:4-14` | `Gateway` and `State` as struct fields |
| Defaulting | `internal/infrastructure/configuration/defaults.go:74-82` | three `if cfg.Services.X.Y == ""` branches |
| Consumption | `internal/app/archied/{bootstrap.go,state_store.go,gateway.go}`, `internal/app/archieui/config.go:80-81` | `cfg.Services.State` / `cfg.Services.Gateway` field access |
Adding a service means editing all three. The drift this permits is already visible:
`stateStoreResolvedToken` (`state_store_client.go:17-23`) and `gatewayResolvedToken`
(`chat_service.go:20-26`) are byte-identical apart from the env var name, and
`gateway.Target` is defaulted while `state.Target` is a startup error, with nothing
stating that asymmetry in one place.
`resolveServiceListen(service, flagValue, configured)` (`listen.go:24-34`) is already
name-parameterised. It is the shape the rest should follow.
## Decision
**Key services by name, and carry per-service asymmetry as registration data.**
### 1. Declaration collapses to a map
```go
// internal/config/services.go
type Services map[string]ServiceConnection
```
`ServiceConnection` is unchanged. The TOML shape is unchanged, so no deployment profile,
`config.example.toml`, or `install.sh` edit is required. An unrecognised `[services.foo]`
decodes without a code edit, satisfying criterion 5.
### 2. Registration is the single entry point
```go
// internal/config/servicespec.go
func RegisterService(context, name, target, listen, tokenEnv string)
```
registered once per service, at package init in `internal/config`:
```go
RegisterService("both", "gateway", "127.0.0.1:8585", "127.0.0.1:8585", "GATEWAY_TOKEN")
RegisterService("client", "state", "", "127.0.0.1:9090", "STATE_STORE_TOKEN")
```
Positional, five strings, as the story specifies. Each argument is data the current code
states in prose or in a branch:
- `context` is `client`, `server`, or `both`, and decides which fields must resolve
non-empty. `RegisterService` enforces it: an unknown context, or a hosted service with
no default `listen`, panics at registration. Registrations come from this repository's
own `init()`, never from operator input, so an invalid one is a programming error with
no caller positioned to handle an error return. A documented-but-unread `Context` would
be worse than no field at all.
- `target` is the **default**, and an empty default means the operator must supply one.
That single convention replaces the `state.target` required / `gateway.target` defaulted
asymmetry with no branch: `state` registers `""`, `gateway` registers an address.
- `listen` is the default listen address, feeding the existing
flag → `[services.<name>].listen` → default precedence unchanged.
- `tokenEnv` names the fallback env var, replacing the two copied resolvers with one.
### 3. Defaulting and consumption become loops and lookups
`applyDefaults` iterates the registry instead of naming services. Consumers read
`cfg.Services.Get("state")`, returning a `ServiceConnection` plus the spec, so
`stateStoreResolvedToken` and `gatewayResolvedToken` collapse into
`Services.ResolvedToken(name, secrets)`.
## Criteria satisfied
1. Declared once, in the `RegisterService` call.
2. No second location can contradict it; the map has no per-service fields to disagree with.
3. Registration is the entry point, with the five fields a service has.
4. A new service is one `RegisterService` line: no field, no default branch, no consumer edit.
5. The set of services is registry data, not a struct definition.
## Scope and risk
- `state-store-contract.md` §10 must be revised in the same change, or the tree contradicts
its own ratified authority. Its summary (`:7`) already says `[services.<name>]`.
- A typo'd `[services.gatway]` is **reported today** (`UnknownKeys = [services.gatway,
services.gatway.target]`), because the struct form leaves it in `toml.MetaData.Undecoded()`.
A map decodes any section, so preserving that is a requirement, not an optional extra:
`unregisteredServiceKeys` asks the registry which names exist. This costs nothing in
extensibility, because the answer comes from registration data rather than a fixed list.
(An earlier draft of this document claimed the typo was silently ignored either way. It
was not; the behaviour was measured.)
- Existing tests reference `cfg.Services.State` directly (`state_store_client_test.go:82`,
`setup_test.go:278`, and others). They move to `Get`, mechanically.
- No wire contract, no RPC, and no persisted format is touched. The 42-RPC State Store
contract is unaffected.
## Acceptance
- Adding a third service is a one-line diff plus its consumer, proven by a test that
registers a throwaway service and asserts its defaults and token fallback resolve.
- `grep -rn 'Services\.\(State\|Gateway\)' --include='*.go'` returns nothing.
- The existing `services_test.go` default and precedence assertions pass unchanged in
behaviour, rewritten only to the new accessor.
+13 -9
View File
@@ -1,6 +1,9 @@
# State Store — contract boundary & transport (ratification)
**Status:** Ratified (rev. 2c). Rev. 1 was marked *conditionally ratified*; the three
**Status:** Ratified (rev. 2d). Rev. 2d revises §10 only: the `State ServiceConnection`
struct-field instruction is withdrawn in favour of name-keyed services
(`docs/prds/service-registry.md`). The contract, its 42 RPCs, and the listener topology are
unchanged. Rev. 1 was marked *conditionally ratified*; the three
reviewer conditions it raised are resolved (rev. 2), and the two third-pass findings are
resolved here: (a) the stale Q3 migration wording in `service-decomposition.md`
(`store.WorkflowStore`, `mode = "inproc" | "remote"`) now matches the ratified ownership split
@@ -535,16 +538,17 @@ an explicit operator decision.
**Follow the gateway's presence-based `target` seam, not the NATS `mode` enum.**
- `internal/config/services.go` gains a `State ServiceConnection` field:
- **Revised (rev. 2d).** This section previously instructed that
`internal/config/services.go` gain a `State ServiceConnection` *struct field*. That
instruction is withdrawn: naming each service as a field is the duplication
`docs/prds/service-registry.md` removes, and this document's own summary (`:7`) already
describes the seam as `[services.<name>]`. Services are keyed by name:
```go
type Services struct {
Gateway ServiceConnection `toml:"gateway" yaml:"gateway"`
State ServiceConnection `toml:"state" yaml:"state"`
}
type ServiceConnection struct {
Target string `toml:"target" yaml:"target"`
}
type Services map[string]ServiceConnection
```
registered once via `RegisterService(context, name, target, listen, tokenEnv)`. The TOML
shape below is unchanged, so nothing else in this section is affected; read
`cfg.Services.Get("state")` wherever it says `cfg.Services.State`.
- **Empty `Target` → local** `*store.Store` adapter (the default; State Store not yet
extracted). **Set `Target` → dial gRPC** and use `*staterpc.Client`. This differs from the
gateway, where `Target` is always defaulted to `127.0.0.1:8585` because the gateway is already
+5 -5
View File
@@ -345,18 +345,18 @@ func (b *boot) openStores(ctx context.Context) error {
// the STATE_STORE_TOKEN secret (§10). It runs after openStores has resolved
// b.secrets, and before setupObservability / buildDaemon wire consumers.
func (b *boot) openStateStoreAdapter() error {
target := strings.TrimSpace(b.cfg.Services.State.Target)
target := strings.TrimSpace(b.cfg.Services.Get(config.ServiceNameState).Target)
if target == "" {
return fmt.Errorf("services.state.target is required: archied/archie-gateway no longer own archie.db; the standalone archie-state-store process owns it (docs/prds/state-store-contract.md §12 step 7)")
}
client, cleanup, err := composeStateStoreClient(b.cfg.Services.State, b.secrets)
client, cleanup, err := composeStateStoreClient(b.cfg.Services, b.secrets)
if err != nil {
b.log.Error("state store adapter", "err", err)
return err
}
b.stateStore = client
b.stateStoreGrants = &staterpc.GrantIssuer{Client: client}
b.stateStoreToken = stateStoreResolvedToken(b.cfg.Services.State, b.secrets)
b.stateStoreToken = b.cfg.Services.ResolvedToken(config.ServiceNameState, b.secrets.Getenv)
b.addCleanup(cleanup)
return nil
}
@@ -578,7 +578,7 @@ func (b *boot) setupLLMAndChat() error {
b.setupChatRuntime(cfg)
b.setupEmbeddings(cfg, log)
contract, cleanup, err := composeChatContract(cfg.Services.Gateway, b.secrets)
contract, cleanup, err := composeChatContract(cfg.Services, b.secrets)
if err != nil {
return err
}
@@ -1356,7 +1356,7 @@ func (b *boot) buildDaemon() {
b.d = &daemon.Daemon{
Cfg: b.cfgHolder,
ConnectedNATS: daemon.NATSEndpoint{URL: b.natsURL, Token: b.natsToken},
ConnectedStateStore: daemon.StateStoreEndpoint{URL: strings.TrimSpace(b.cfg.Services.State.Target), Token: b.stateStoreToken},
ConnectedStateStore: daemon.StateStoreEndpoint{URL: strings.TrimSpace(b.cfg.Services.Get(config.ServiceNameState).Target), Token: b.stateStoreToken},
Store: b.stateStore,
Bus: b.bus,
Forge: b.forgeClient,
+5 -20
View File
@@ -1,9 +1,6 @@
package archied
import (
"fmt"
"strings"
"google.golang.org/grpc"
"github.com/samcharles93/archie-core/internal/config"
@@ -12,32 +9,20 @@ import (
"github.com/samcharles93/archie-core/internal/secret"
)
// gatewayResolvedToken returns the Bearer [REDACTED] a Gateway client
// presents: the explicit [services.gateway].target_token key, then the
// GATEWAY_TOKEN secret/env. The server side (RunGateway) resolves the same
// value, so a distributed consumer and the gateway agree without sharing
// any other configuration.
func gatewayResolvedToken(settings config.ServiceConnection, secrets *secret.Registry) string {
token := settings.TargetToken
if token == "" {
token = secrets.Getenv("GATEWAY_TOKEN")
}
return token
}
// composeChatContract dials the standalone archie-gateway, the sole owner of
// ChatContract, from the daemon's own configuration key. Token resolution is
// the daemon's (it owns the config keys and the secret registry); the dial
// itself and the fail-closed non-loopback rule belong to the transport, so
// they come from gatewayrpc.Dial.
func composeChatContract(settings config.ServiceConnection, secrets *secret.Registry, options ...grpc.DialOption) (gateway.ChatContract, func(), error) {
if strings.TrimSpace(settings.Target) == "" {
return nil, nil, fmt.Errorf("services.gateway.target is required")
func composeChatContract(services config.Services, secrets *secret.Registry, options ...grpc.DialOption) (gateway.ChatContract, func(), error) {
target, err := services.RequireTarget(config.ServiceNameGateway)
if err != nil {
return nil, nil, err
}
// Assigned through a typed variable rather than returned directly: a
// direct forward would hand a failed dial's nil *Client back as a
// non-nil ChatContract interface.
client, cleanup, err := gatewayrpc.Dial(settings.Target, gatewayResolvedToken(settings, secrets), options...)
client, cleanup, err := gatewayrpc.Dial(target, services.ResolvedToken(config.ServiceNameGateway, secrets.Getenv), options...)
if err != nil {
return nil, nil, err
}
+15 -11
View File
@@ -19,10 +19,10 @@ import (
func TestComposeChatContractRejectsInvalidSettings(t *testing.T) {
for _, tt := range []struct {
name string
settings config.ServiceConnection
settings config.Services
}{
{name: "missing target", settings: config.ServiceConnection{}},
{name: "blank target", settings: config.ServiceConnection{Target: " \t\n"}},
{name: "missing target", settings: config.Services{}},
{name: "blank target", settings: config.Services{config.ServiceNameGateway: {Target: " \t\n"}}},
} {
t.Run(tt.name, func(t *testing.T) {
chat, cleanup, err := composeChatContract(tt.settings, &secret.Registry{})
@@ -41,7 +41,7 @@ func TestComposeChatContractRejectsInvalidSettings(t *testing.T) {
func TestComposeChatContractNonLoopbackFailsClosed(t *testing.T) {
_, _, err := composeChatContract(
config.ServiceConnection{Target: "gateway.example.com:8585"},
config.Services{config.ServiceNameGateway: {Target: "gateway.example.com:8585"}},
&secret.Registry{},
)
if err == nil {
@@ -67,7 +67,7 @@ func TestComposeChatContractRemoteAndCleanup(t *testing.T) {
})
chat, cleanup, err := composeChatContract(
config.ServiceConnection{Target: listener.Addr().String()},
config.Services{config.ServiceNameGateway: {Target: listener.Addr().String()}},
&secret.Registry{},
)
if err != nil {
@@ -95,18 +95,22 @@ func TestComposeChatContractRemoteAndCleanup(t *testing.T) {
}
}
// TestGatewayResolvedToken pins the daemon-side wiring rather than the
// precedence rule itself: config.Services.ResolvedToken owns the rule and is
// tested there, but only this level proves the gateway reads it through the
// secret registry and lands on the env var its registration names.
func TestGatewayResolvedToken(t *testing.T) {
if got := gatewayResolvedToken(config.ServiceConnection{TargetToken: "file-token"}, &secret.Registry{}); got != "file-token" {
secrets := &secret.Registry{}
explicit := config.Services{config.ServiceNameGateway: {TargetToken: "file-token"}}
if got := explicit.ResolvedToken(config.ServiceNameGateway, secrets.Getenv); got != "file-token" {
t.Fatalf("resolved token = %q, want file-token", got)
}
t.Setenv("GATEWAY_TOKEN", "environment-token")
if got := gatewayResolvedToken(config.ServiceConnection{}, &secret.Registry{}); got != "environment-token" {
empty := config.Services{config.ServiceNameGateway: {}}
if got := empty.ResolvedToken(config.ServiceNameGateway, secrets.Getenv); got != "environment-token" {
t.Fatalf("resolved token = %q, want environment-token", got)
}
if got := gatewayResolvedToken(
config.ServiceConnection{TargetToken: "file-token"},
&secret.Registry{},
); got != "file-token" {
if got := explicit.ResolvedToken(config.ServiceNameGateway, secrets.Getenv); got != "file-token" {
t.Fatalf("explicit target_token should win over the environment, got %q", got)
}
}
@@ -11,8 +11,10 @@ import (
)
func TestRemoteChatCompositionPreservesChannelTurnLedger(t *testing.T) {
cfg := config.Config{DBPath: filepath.Join(t.TempDir(), "tasks.db")}
cfg.Services.Gateway.Target = "127.0.0.1:1"
cfg := config.Config{
DBPath: filepath.Join(t.TempDir(), "tasks.db"),
Services: config.Services{config.ServiceNameGateway: {Target: "127.0.0.1:1"}},
}
st, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "state-store.db"))
if err != nil {
t.Fatal(err)
+2 -2
View File
@@ -36,13 +36,13 @@ type GatewayOptions struct {
// 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.Gateway.Listen)
listen, err = resolveServiceListen("gateway", options.Listen, b.cfg.Services.Get(config.ServiceNameGateway).Listen)
if err != nil {
return "", "", err
}
token = options.Token
if token == "" {
token = gatewayResolvedToken(b.cfg.Services.Gateway, b.secrets)
token = b.cfg.Services.ResolvedToken(config.ServiceNameGateway, b.secrets.Getenv)
}
return listen, token, nil
}
+1 -1
View File
@@ -275,7 +275,7 @@ func TestRunSetup_GeneratedConfigSatisfiesDaemonRequirements(t *testing.T) {
}
// openStateStoreAdapter refuses an empty target, so this is the difference
// between a config that boots and one that does not.
if doc.Config.Services.State.Target == "" {
if doc.Config.Services.Get(config.ServiceNameState).Target == "" {
t.Error("generated config leaves services.state.target empty; the daemon would not boot")
}
if doc.Config.BotUser == "" {
+3 -2
View File
@@ -19,6 +19,7 @@ import (
"google.golang.org/grpc"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/health"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/readiness"
@@ -56,7 +57,7 @@ func RunStateStore(ctx context.Context, options StateStoreOptions) error {
if err := b.loadConfig(ctx, options.Config, options.Overlay, false); err != nil {
return err
}
listen, err := resolveServiceListen("state", options.Listen, b.cfg.Services.State.Listen)
listen, err := resolveServiceListen("state", options.Listen, b.cfg.Services.Get(config.ServiceNameState).Listen)
if err != nil {
return err
}
@@ -67,7 +68,7 @@ func RunStateStore(ctx context.Context, options StateStoreOptions) error {
token := options.Token
if token == "" {
token = stateStoreResolvedToken(b.cfg.Services.State, b.secrets)
token = b.cfg.Services.ResolvedToken(config.ServiceNameState, b.secrets.Getenv)
}
grants := &staterpc.TaskGrants{}
//nolint:contextcheck // grpc.StreamServerInterceptor has no context.Context parameter; TaskGrants.StreamInterceptor derives its context from stream.Context() instead
+5 -21
View File
@@ -1,36 +1,20 @@
package archied
import (
"fmt"
"strings"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/secret"
)
// stateStoreResolvedToken returns the bearer token a State Store client
// presents: the explicit [services.state].target_token key, then the
// STATE_STORE_TOKEN secret/env. The daemon injects the same token into agent
// containers as STATE_STORE_TOKEN so the agent authenticates to the same
// remote store the daemon dials.
func stateStoreResolvedToken(settings config.ServiceConnection, secrets *secret.Registry) string {
token := settings.TargetToken
if token == "" {
token = secrets.Getenv("STATE_STORE_TOKEN")
}
return token
}
// composeStateStoreClient dials the State Store gRPC service the daemon's own
// capture/mapping/binding consumers call. Token resolution is the daemon's
// (it owns the config keys and the secret registry); the dial itself and the
// fail-closed non-loopback rule (§9) belong to the transport, so they come
// from staterpc.Dial.
func composeStateStoreClient(settings config.ServiceConnection, secrets *secret.Registry) (*staterpc.Client, func(), error) {
target := strings.TrimSpace(settings.Target)
if target == "" {
return nil, nil, fmt.Errorf("services.state.target is required")
func composeStateStoreClient(services config.Services, secrets *secret.Registry) (*staterpc.Client, func(), error) {
target, err := services.RequireTarget(config.ServiceNameState)
if err != nil {
return nil, nil, err
}
return staterpc.Dial(target, stateStoreResolvedToken(settings, secrets))
return staterpc.Dial(target, services.ResolvedToken(config.ServiceNameState, secrets.Getenv))
}
@@ -9,7 +9,7 @@ import (
)
func TestComposeStateStoreClientRequiresTarget(t *testing.T) {
_, _, err := composeStateStoreClient(config.ServiceConnection{}, &secret.Registry{})
_, _, err := composeStateStoreClient(config.Services{}, &secret.Registry{})
if err == nil {
t.Fatal("empty target should error")
}
@@ -29,7 +29,7 @@ func TestComposeStateStoreClientNonLoopbackFailsClosed(t *testing.T) {
{name: "hostname without token", target: "store.example.com:9090"},
} {
t.Run(tt.name, func(t *testing.T) {
_, _, err := composeStateStoreClient(config.ServiceConnection{Target: tt.target}, &secret.Registry{})
_, _, err := composeStateStoreClient(config.Services{config.ServiceNameState: {Target: tt.target}}, &secret.Registry{})
if err == nil {
t.Fatalf("non-loopback %q without a token should fail closed (docs/prds/state-store-contract.md §9)", tt.target)
}
@@ -38,7 +38,7 @@ func TestComposeStateStoreClientNonLoopbackFailsClosed(t *testing.T) {
}
func TestComposeStateStoreClientLoopbackSucceeds(t *testing.T) {
st, cleanup, err := composeStateStoreClient(config.ServiceConnection{Target: "127.0.0.1:9090"}, &secret.Registry{})
st, cleanup, err := composeStateStoreClient(config.Services{config.ServiceNameState: {Target: "127.0.0.1:9090"}}, &secret.Registry{})
if err != nil {
t.Fatalf("loopback without token should succeed: %v", err)
}
@@ -54,7 +54,7 @@ func TestComposeStateStoreClientLoopbackSucceeds(t *testing.T) {
func TestComposeStateStoreClientTokenFromTargetToken(t *testing.T) {
// Non-loopback with a configured token must not fail closed; the interceptor
// is what carries it, so the client is dialable.
st, _, err := composeStateStoreClient(config.ServiceConnection{Target: "0.0.0.0:9090", TargetToken: "secret"}, &secret.Registry{})
st, _, err := composeStateStoreClient(config.Services{config.ServiceNameState: {Target: "0.0.0.0:9090", TargetToken: "secret"}}, &secret.Registry{})
if err != nil {
t.Fatalf("non-loopback with a token should succeed: %v", err)
}
@@ -79,7 +79,7 @@ func TestOpenStateStoreAdapterRemoteFailsClosed(t *testing.T) {
t.Setenv("STATE_STORE_TOKEN", "")
b := newBootstrap()
b.secrets = &secret.Registry{}
b.cfg.Services.State = config.ServiceConnection{Target: "0.0.0.0:9090"}
b.cfg.Services = config.Services{config.ServiceNameState: {Target: "0.0.0.0:9090"}}
if err := b.openStateStoreAdapter(); err == nil {
t.Fatal("non-loopback without a token should fail closed")
}
@@ -44,7 +44,7 @@ func TestExternalServicesDoNotRequireBridgeNetwork(t *testing.T) {
cfg := config.Config{}
cfg.NATS.Mode = config.NATSModeExternal
cfg.Containers.Network = "host"
cfg.Services.State.Target = "state.example.test:9090"
cfg.Services = config.Services{config.ServiceNameState: {Target: "state.example.test:9090"}}
pool, _, cleanup := startContainers(t.Context(), cfg, slog.New(slog.DiscardHandler))
defer cleanup()
if pool == nil {
+2 -2
View File
@@ -77,8 +77,8 @@ func project(cfg config.Config) projection {
return projection{
listen: cfg.Web.Listen,
trustForwardedHeaders: cfg.Web.TrustForwardedHeaders,
gateway: ServiceTarget{Target: cfg.Services.Gateway.Target, Token: cfg.Services.Gateway.TargetToken},
state: ServiceTarget{Target: cfg.Services.State.Target, Token: cfg.Services.State.TargetToken},
gateway: ServiceTarget{Target: cfg.Services.Get(config.ServiceNameGateway).Target, Token: cfg.Services.Get(config.ServiceNameGateway).TargetToken},
state: ServiceTarget{Target: cfg.Services.Get(config.ServiceNameState).Target, Token: cfg.Services.Get(config.ServiceNameState).TargetToken},
capture: CaptureOptions{
Retention: cfg.Capture.Retention.Std(),
MaxEvents: cfg.Capture.MaxEvents,
+1 -1
View File
@@ -47,7 +47,7 @@ target_token = "state-token"
// TestResolveReadsOnlyTheAllowlistedConfigProjection pins the maintainer's
// decision for this bead: the UI process does read config.toml, but only
// Services.Gateway.{Target,TargetToken}, Services.State.{Target,TargetToken}
// Services.Get("gateway").{Target,TargetToken} and the same for "state"
// and Web.{Listen,TrustForwardedHeaders}. Options has no field that could
// carry anything else, so this asserts the six values arrive and the daemon's
// own settings have nowhere to land.
+63 -19
View File
@@ -1,30 +1,74 @@
package config
// Services selects contract adapters at application composition time.
type Services struct {
Gateway ServiceConnection `toml:"gateway" yaml:"gateway"`
// State selects the State Store contract adapter. The State Store is its
// own process (cmd/archie-state-store) and owns archie.db; an empty Target
// is a startup error in archied/archie-gateway, which no longer serve a
// local store (docs/prds/state-store-contract.md §12 step 7). The daemon
// and agent dial the remote StateStoreService and present target_token
// when the target is non-loopback. Token resolution mirrors the daemon's:
// the explicit key, then the STATE_STORE_TOKEN secret/env var.
State ServiceConnection `toml:"state" yaml:"state"`
import (
"fmt"
"strings"
)
// Services maps a registered service name to its connection settings, keyed by
// the [services.<name>] section it was decoded from.
//
// It was a struct with one field per service. That stated each service's name
// three times over -- here, in the loader's defaulting branches, and at every
// consumer's field access -- so a new service meant editing all three and
// nothing prevented them disagreeing. Which names are legitimate now comes
// from RegisterService; see ServiceSpec.
type Services map[string]ServiceConnection
// Get returns the connection configured for name, or the zero value when the
// configuration carries no section for it. A registered service always has an
// entry once defaults have been applied.
func (s Services) Get(name string) ServiceConnection {
return s[name]
}
// ServiceConnection is a contract adapter's gRPC address plus the bearer
// token a client presents when the target is non-loopback. A client reads only
// Target and TargetToken; Listen belongs to the process that owns the service.
// The struct does not itself register services or start listeners. Changes
// require a daemon restart.
// ResolvedToken is the bearer token a client presents when dialling name: the
// explicit target_token if set, otherwise the environment variable the service
// registered. getenv is passed in rather than read directly so this stays free
// of internal/secret, which imports this package.
//
// This replaces two resolvers that were identical apart from the variable name
// each hard-coded.
func (s Services) ResolvedToken(name string, getenv func(string) string) string {
if token := s[name].TargetToken; token != "" {
return token
}
spec, ok := LookupService(name)
if !ok || spec.TokenEnv == "" {
return ""
}
return getenv(spec.TokenEnv)
}
// RequireTarget returns the dial address for name, or an error naming the
// config key when the operator has not supplied one.
//
// A service registered with an empty default target is one the operator must
// configure, so this is the registry's own contract rather than a consumer's
// private rule. It stays a lazy check at composition time, not a load-time
// validation: a process that never dials a given service must still be able to
// load a configuration that omits it.
func (s Services) RequireTarget(name string) (string, error) {
target := strings.TrimSpace(s[name].Target)
if target == "" {
return "", fmt.Errorf("services.%s.target is required", name)
}
return target, nil
}
// ServiceConnection is a service's gRPC addresses plus the bearer token a
// client presents when the target is non-loopback. A client reads only Target
// and TargetToken; Listen belongs to the process that owns the service. The
// struct does not itself register services or start listeners. Changes require
// a daemon restart.
type ServiceConnection struct {
Target string `toml:"target" yaml:"target"`
// Listen is the address the process that OWNS this service binds
// (archie-state-store, archie-gateway). It is read only by that process;
// every client ignores it. Defaulted, so a loaded config is never empty
// here -- an empty address reaches net.Listen as "any free port", which
// would silently move the service off the address its clients dial.
// every client ignores it. Defaulted from the service's registration, so
// a loaded config is never empty here -- an empty address reaches
// net.Listen as "any free port", which would silently move the service
// off the address its clients dial.
Listen string `toml:"listen" yaml:"listen"`
// TargetToken is the bearer token a client (daemon or agent) presents
// when dialing a non-loopback service target, and the standalone
+225
View File
@@ -0,0 +1,225 @@
package config_test
import (
"fmt"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/config"
)
// TestRegisterServiceIsTheSingleDeclaration pins criterion 3 of
// docs/prds/service-registry.md: a service is declared by one call carrying the
// five fields it actually has, and every later layer reads that declaration
// rather than restating the name.
func TestRegisterServiceIsTheSingleDeclaration(t *testing.T) {
config.RegisterService(config.ServiceBoth, "widget", "127.0.0.1:7001", "127.0.0.1:7002", "WIDGET_TOKEN")
spec, ok := config.LookupService("widget")
if !ok {
t.Fatal("LookupService(widget) = false, want the service just registered")
}
if spec.Context != config.ServiceBoth {
t.Errorf("Context = %q, want %q", spec.Context, config.ServiceBoth)
}
if spec.Target != "127.0.0.1:7001" {
t.Errorf("Target = %q, want the registered default", spec.Target)
}
if spec.Listen != "127.0.0.1:7002" {
t.Errorf("Listen = %q, want the registered default", spec.Listen)
}
if spec.TokenEnv != "WIDGET_TOKEN" {
t.Errorf("TokenEnv = %q, want the registered env var", spec.TokenEnv)
}
}
// TestBuiltInServicesAreRegistered pins that the two services the daemon ships
// are declared through the same entry point as any other, with the asymmetry
// the old struct form left unstated: state has no default target, so the
// operator must supply one, while gateway does.
func TestBuiltInServicesAreRegistered(t *testing.T) {
state, ok := config.LookupService("state")
if !ok {
t.Fatal("LookupService(state) = false, want the State Store registered")
}
if state.Target != "" {
t.Errorf("state Target default = %q, want empty: services.state.target is operator-supplied", state.Target)
}
if state.Listen == "" {
t.Error("state Listen default is empty, want an address: an empty listen reaches net.Listen as any free port")
}
if state.TokenEnv != "STATE_STORE_TOKEN" {
t.Errorf("state TokenEnv = %q, want STATE_STORE_TOKEN", state.TokenEnv)
}
gateway, ok := config.LookupService("gateway")
if !ok {
t.Fatal("LookupService(gateway) = false, want the Gateway registered")
}
if gateway.Target == "" {
t.Error("gateway Target default is empty, want an address: the gateway target is defaulted, not operator-supplied")
}
if gateway.TokenEnv != "GATEWAY_TOKEN" {
t.Errorf("gateway TokenEnv = %q, want GATEWAY_TOKEN", gateway.TokenEnv)
}
}
// TestUnregisteredServiceIsNotFound keeps the registry the authority on which
// names exist, which is what lets the loader report a typo'd [services.gatway]
// as an unknown key once Services is a map that would otherwise swallow it.
func TestUnregisteredServiceIsNotFound(t *testing.T) {
if _, ok := config.LookupService("gatway"); ok {
t.Error("LookupService(gatway) = true, want false for an unregistered name")
}
}
// TestServicesGetReturnsTheNamedConnection pins lookup by name, which replaced
// per-service struct field access, so adding a service needs no new field.
func TestServicesGetReturnsTheNamedConnection(t *testing.T) {
services := config.Services{
"state": {Target: "10.0.0.1:9090", Listen: "0.0.0.0:9090", TargetToken: "explicit"},
}
got := services.Get("state")
if got.Target != "10.0.0.1:9090" {
t.Errorf("Get(state).Target = %q, want the configured target", got.Target)
}
if services.Get("absent") != (config.ServiceConnection{}) {
t.Error("Get(absent) returned a non-zero connection, want the zero value")
}
}
// TestResolvedTokenPrefersTheExplicitKey pins the precedence the two
// hand-copied resolvers used: the config key wins, and the registered env var
// is only a fallback.
func TestResolvedTokenPrefersTheExplicitKey(t *testing.T) {
config.RegisterService(config.ServiceClient, "widget-explicit", "", "127.0.0.1:7003", "WIDGET_EXPLICIT_TOKEN")
services := config.Services{"widget-explicit": {TargetToken: "from-config"}}
getenv := func(string) string { return "from-env" }
if got := services.ResolvedToken("widget-explicit", getenv); got != "from-config" {
t.Errorf("ResolvedToken = %q, want the explicit target_token to win", got)
}
}
// TestResolvedTokenFallsBackToTheRegisteredEnvVar is the half that the old
// stateStoreResolvedToken and gatewayResolvedToken duplicated, differing only
// in the env var name they hard-coded.
func TestResolvedTokenFallsBackToTheRegisteredEnvVar(t *testing.T) {
config.RegisterService(config.ServiceClient, "widget-env", "", "127.0.0.1:7004", "WIDGET_ENV_TOKEN")
services := config.Services{"widget-env": {}}
var asked string
getenv := func(name string) string {
asked = name
return "from-env"
}
if got := services.ResolvedToken("widget-env", getenv); got != "from-env" {
t.Errorf("ResolvedToken = %q, want the env fallback", got)
}
if asked != "WIDGET_ENV_TOKEN" {
t.Errorf("read env var %q, want the name from the registration", asked)
}
}
// TestResolvedTokenOfUnregisteredServiceHasNoEnvFallback keeps an unknown name
// from reaching os.Getenv("") and returning something surprising.
func TestResolvedTokenOfUnregisteredServiceHasNoEnvFallback(t *testing.T) {
services := config.Services{"gatway": {}}
getenv := func(string) string {
t.Error("getenv called for an unregistered service, want no env fallback")
return "leaked"
}
if got := services.ResolvedToken("gatway", getenv); got != "" {
t.Errorf("ResolvedToken = %q, want empty", got)
}
}
// mustPanic runs fn and returns the recovered value, or fails if fn returned
// normally. Registration errors are programming errors in this repository's
// own init(), not operator input, so they abort the process rather than
// returning an error nobody is positioned to handle.
func mustPanic(t *testing.T, fn func()) (recovered any) {
t.Helper()
defer func() { recovered = recover() }()
fn()
t.Fatal("RegisterService returned normally, want a panic")
return nil
}
// TestRegisterServiceRejectsAnUnknownContext makes Context load-bearing. It
// documented which addresses a service must end up with, but nothing read it,
// so a typo'd context was accepted and silently meant nothing.
func TestRegisterServiceRejectsAnUnknownContext(t *testing.T) {
got := mustPanic(t, func() {
config.RegisterService("clientt", "widget-badcontext", "", "127.0.0.1:7005", "T")
})
if !strings.Contains(fmt.Sprint(got), "clientt") {
t.Errorf("panic = %v, want it to name the invalid context", got)
}
}
// TestRegisterServiceRejectsAHostedServiceWithNoListen pins the requirement
// Context exists to express: a service this repository hosts must have a
// default bind address, because an empty one reaches net.Listen as "any free
// port".
func TestRegisterServiceRejectsAHostedServiceWithNoListen(t *testing.T) {
for _, hosted := range []string{config.ServiceServer, config.ServiceBoth} {
t.Run(hosted, func(t *testing.T) {
got := mustPanic(t, func() {
config.RegisterService(hosted, "widget-nolisten-"+hosted, "127.0.0.1:1", "", "T")
})
if !strings.Contains(fmt.Sprint(got), "listen") {
t.Errorf("panic = %v, want it to name the missing listen address", got)
}
})
}
}
// TestRegisterServiceAcceptsAClientWithNoTargetDefault keeps the State Store's
// own shape legal: a dialled-only service may register an empty target, which
// is how "the operator must supply this" is stated.
func TestRegisterServiceAcceptsAClientWithNoTargetDefault(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Fatalf("RegisterService panicked on a legal client registration: %v", r)
}
}()
config.RegisterService(config.ServiceClient, "widget-clientok", "", "127.0.0.1:7006", "T")
}
// TestRequireTargetReportsAnAbsentOperatorSuppliedTarget moves the "target is
// required" check off two hand-written consumer copies and onto the registry,
// which is what declared the target operator-supplied in the first place.
func TestRequireTargetReportsAnAbsentOperatorSuppliedTarget(t *testing.T) {
for _, tt := range []struct {
name string
target string
want string
wantErr bool
}{
{name: "absent", wantErr: true},
{name: "blank", target: " \t\n", wantErr: true},
{name: "set", target: "10.0.0.1:9090", want: "10.0.0.1:9090"},
{name: "set with padding", target: " 10.0.0.1:9090 ", want: "10.0.0.1:9090"},
} {
t.Run(tt.name, func(t *testing.T) {
services := config.Services{config.ServiceNameState: {Target: tt.target}}
got, err := services.RequireTarget(config.ServiceNameState)
if tt.wantErr {
if err == nil {
t.Fatal("RequireTarget returned no error for an empty target")
}
if !strings.Contains(err.Error(), "services.state.target") {
t.Errorf("error = %v, want it to name the config key", err)
}
return
}
if err != nil {
t.Fatalf("RequireTarget: %v", err)
}
if got != tt.want {
t.Errorf("RequireTarget = %q, want %q", got, tt.want)
}
})
}
}
+130
View File
@@ -0,0 +1,130 @@
package config
import (
"fmt"
"sort"
"strings"
"sync"
)
// Service contexts. The context decides which addresses a service must end up
// with: a process that owns a service needs a listen address, and a process
// that dials one needs a target.
const (
// ServiceClient is dialled but not hosted by this repository.
ServiceClient = "client"
// ServiceServer is hosted but not dialled.
ServiceServer = "server"
// ServiceBoth is hosted by one of our processes and dialled by others.
ServiceBoth = "both"
)
// ServiceSpec is everything the codebase knows about one service that is not
// operator input. It exists so a service is declared once: the name, its
// defaults, and the environment variable its token falls back to were
// previously a struct field, a defaulting branch, and a hand-copied resolver
// in three separate packages, with nothing keeping them in step.
type ServiceSpec struct {
// Context is ServiceClient, ServiceServer, or ServiceBoth.
Context string
// Name is the [services.<name>] section and the key callers look up.
Name string
// Target is the default dial address. Empty means there is no default
// and the operator must supply one, which is how "services.state.target
// is required" is stated without a branch that names the service.
Target string
// Listen is the default bind address for the process that owns the
// service. It is never empty for a hosted service: an empty address
// reaches net.Listen as "any free port", silently moving the service
// off the address its clients dial.
Listen string
// TokenEnv names the environment variable a client falls back to when
// [services.<name>].target_token is empty.
TokenEnv string
}
// Registered service names. They live beside the registrations below so the
// spelling a consumer looks up and the spelling that was registered are the
// same token, not two string literals that a typo can separate.
const (
ServiceNameGateway = "gateway"
ServiceNameState = "state"
)
var (
serviceRegistryMu sync.RWMutex
serviceRegistry = map[string]ServiceSpec{}
)
// RegisterService declares one service. It is the single entry point the
// design calls for: adding a service is this call plus its consumer, with no
// new struct field, defaulting branch, or accessor anywhere else.
//
// Re-registering a name replaces the previous spec, so a test can install a
// throwaway service without disturbing the built-ins.
//
// It panics on a registration that cannot be honoured. Registrations come from
// this repository's own init(), never from operator input, so an invalid one is
// a programming error: there is no caller positioned to handle an error return,
// and failing at process start is better than a service that binds somewhere
// nobody dials. Context is enforced here rather than merely documented, so
// "hosted" genuinely implies a bind address.
func RegisterService(context, name, target, listen, tokenEnv string) {
switch context {
case ServiceClient, ServiceServer, ServiceBoth:
default:
panic(fmt.Sprintf(
"config.RegisterService(%q): unknown context %q, want %q, %q or %q",
name, context, ServiceClient, ServiceServer, ServiceBoth,
))
}
if context != ServiceClient && strings.TrimSpace(listen) == "" {
panic(fmt.Sprintf(
"config.RegisterService(%q): a %q service needs a default listen address; "+
"an empty one reaches net.Listen as \"any free port\"",
name, context,
))
}
serviceRegistryMu.Lock()
defer serviceRegistryMu.Unlock()
serviceRegistry[name] = ServiceSpec{
Context: context,
Name: name,
Target: target,
Listen: listen,
TokenEnv: tokenEnv,
}
}
// LookupService returns the spec registered for name. The registry is the
// authority on which service names exist, which is what lets the loader still
// report a typo'd [services.gatway] once Services is a map that would
// otherwise decode any section at all.
func LookupService(name string) (ServiceSpec, bool) {
serviceRegistryMu.RLock()
defer serviceRegistryMu.RUnlock()
spec, ok := serviceRegistry[name]
return spec, ok
}
// RegisteredServices returns every spec, ordered by name so defaulting and
// validation run in a stable order regardless of map iteration.
func RegisteredServices() []ServiceSpec {
serviceRegistryMu.RLock()
defer serviceRegistryMu.RUnlock()
out := make([]ServiceSpec, 0, len(serviceRegistry))
for _, spec := range serviceRegistry {
out = append(out, spec)
}
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
return out
}
func init() {
// The two services this repository ships. Everything that differs
// between them is an argument here, not a branch somewhere else: the
// gateway's target is defaulted while the State Store's is supplied by
// the operator, and each falls back to its own token variable.
RegisterService(ServiceBoth, ServiceNameGateway, "127.0.0.1:8585", "127.0.0.1:8585", "GATEWAY_TOKEN")
RegisterService(ServiceClient, ServiceNameState, "", "127.0.0.1:9090", "STATE_STORE_TOKEN")
}
+1 -1
View File
@@ -1666,7 +1666,7 @@ func configWithCanarySecrets() config.Config {
Tools: config.ToolsConfig{Policy: config.ToolPolicy{MaxResultChars: 12000, SpillDir: "/tmp/spill"}},
NATS: config.NATSConfig{Mode: "external", URL: "nats://127.0.0.1:4222", TokenEnv: canaryNATSTokenEnv},
Chat: config.ChatConfig{Operator: "sam", Telegram: config.TelegramConfig{TokenEnv: "TELEGRAM_TOKEN", Token: secret.SecretRef{Engine: "bws", Key: canaryTelegramToken}}},
Services: config.Services{State: config.ServiceConnection{Target: "127.0.0.1:50051", TargetToken: canaryStateStoreToken}},
Services: config.Services{config.ServiceNameState: {Target: "127.0.0.1:50051", TargetToken: canaryStateStoreToken}},
ModelLimits: map[string]config.ModelLimits{
"openai/gpt-4": {ContextWindow: 128000, MaxOutputTokens: 4096},
},
@@ -12,18 +12,9 @@ import (
// Defaults applied to absent input. Named so a reader can find the value
// without reading the code that applies it.
const (
defaultPollInterval = 60 * time.Second
defaultDiffCapLines = 400
defaultWebListen = "127.0.0.1:8484" // "off" disables
// defaultGatewayAddr is where archie-gateway binds and, by default, where
// clients look for it. One constant for both so a default deployment's
// client and server cannot drift onto different ports.
defaultGatewayAddr = "127.0.0.1:8585"
// defaultStateListen is the state store's bind address. There is
// deliberately no default for [services.state].target: an empty target is
// a startup error in the daemon and the gateway, which no longer serve a
// local store (docs/prds/state-store-contract.md).
defaultStateListen = "127.0.0.1:9090"
defaultPollInterval = 60 * time.Second
defaultDiffCapLines = 400
defaultWebListen = "127.0.0.1:8484" // "off" disables
defaultMaxRetries = 3
defaultForgeType = "github"
defaultForgeHost = "https://github.com"
@@ -71,15 +62,7 @@ const (
// input was to not call them. Splitting them means defaults can be applied,
// inspected, and reasoned about independently of whether the result is valid.
func (l *Loader) applyDefaults(cfg *config.Config) {
if cfg.Services.Gateway.Target == "" {
cfg.Services.Gateway.Target = defaultGatewayAddr
}
if cfg.Services.Gateway.Listen == "" {
cfg.Services.Gateway.Listen = defaultGatewayAddr
}
if cfg.Services.State.Listen == "" {
cfg.Services.State.Listen = defaultStateListen
}
applyServiceDefaults(cfg)
if cfg.Health.Listen == "" {
cfg.Health.Listen = defaultHealthListen
}
@@ -94,6 +77,31 @@ func (l *Loader) applyDefaults(cfg *config.Config) {
applyMemoryDefaults(cfg)
}
// applyServiceDefaults fills each registered service's absent addresses from
// its registration. It iterates the registry rather than naming services, so a
// new service needs no branch here -- only its RegisterService call.
//
// A registered service always ends with an entry, so later code can read
// cfg.Services.Get(name) without distinguishing "absent section" from
// "section with every field defaulted". An empty registered Target is a
// service whose target the operator must supply, and stays empty for
// validation to reject rather than being defaulted to something dialable.
func applyServiceDefaults(cfg *config.Config) {
if cfg.Services == nil {
cfg.Services = config.Services{}
}
for _, spec := range config.RegisteredServices() {
conn := cfg.Services[spec.Name]
if conn.Target == "" {
conn.Target = spec.Target
}
if conn.Listen == "" {
conn.Listen = spec.Listen
}
cfg.Services[spec.Name] = conn
}
}
// applyMemoryDefaults fills an absent engine choice with the builtin
// engine, so "nothing configured" and "explicitly builtin" are the same
// resolved state everywhere after this point -- validateMemory and every
@@ -210,6 +210,23 @@ func unknownKeys(a, b []string) []string {
return out
}
// unregisteredServiceKeys reports [services.<name>] sections naming a service
// nobody registered.
//
// Undecoded() cannot see these. Services is a map, so TOML decodes any section
// under [services] into it successfully, and a typo'd [services.gatway] would
// load clean where the previous struct form reported it. The registry is the
// authority on which names exist, so ask it.
func unregisteredServiceKeys(services config.Services) []string {
var out []string
for name := range services {
if _, ok := config.LookupService(name); !ok {
out = append(out, "services."+name)
}
}
return out
}
// sortedUnique returns keys sorted and de-duplicated, so Document.UnknownKeys
// is deterministic across a base+overlay load that happens to name the same
// stray key in both files.
@@ -322,7 +339,7 @@ func (l *Loader) decodeMain(doc *Document, path string, isYAMLFile bool) error {
// judges the effective configuration, including values the operator never
// wrote.
func (l *Loader) finalize(doc *Document) (*Document, error) {
doc.UnknownKeys = sortedUnique(doc.UnknownKeys)
doc.UnknownKeys = sortedUnique(append(doc.UnknownKeys, unregisteredServiceKeys(doc.Config.Services)...))
l.applyDefaults(&doc.Config)
if err := Validate(&doc.Config); err != nil {
return nil, err
@@ -3,7 +3,11 @@ package configuration
import (
"os"
"path/filepath"
"slices"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/config"
)
func TestLoadGatewayServiceTarget(t *testing.T) {
@@ -22,8 +26,8 @@ func TestLoadGatewayServiceTarget(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if cfg.Services.Gateway.Target != tt.wantTarget {
t.Fatalf("target = %q, want %q", cfg.Services.Gateway.Target, tt.wantTarget)
if cfg.Services.Get(config.ServiceNameGateway).Target != tt.wantTarget {
t.Fatalf("target = %q, want %q", cfg.Services.Get(config.ServiceNameGateway).Target, tt.wantTarget)
}
})
}
@@ -61,11 +65,11 @@ func TestLoadServiceListens(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if cfg.Services.State.Listen != tt.wantState {
t.Fatalf("state listen = %q, want %q", cfg.Services.State.Listen, tt.wantState)
if cfg.Services.Get(config.ServiceNameState).Listen != tt.wantState {
t.Fatalf("state listen = %q, want %q", cfg.Services.Get(config.ServiceNameState).Listen, tt.wantState)
}
if cfg.Services.Gateway.Listen != tt.wantGateway {
t.Fatalf("gateway listen = %q, want %q", cfg.Services.Gateway.Listen, tt.wantGateway)
if cfg.Services.Get(config.ServiceNameGateway).Listen != tt.wantGateway {
t.Fatalf("gateway listen = %q, want %q", cfg.Services.Get(config.ServiceNameGateway).Listen, tt.wantGateway)
}
})
}
@@ -98,3 +102,85 @@ func TestLoadHealthListen(t *testing.T) {
})
}
}
// TestRegisteredServiceDefaultsNeedNoLoaderEdit pins criterion 4 of
// docs/prds/service-registry.md. A service registered anywhere gets its
// defaults applied here without this package naming it, which is the whole
// point of iterating the registry instead of writing one branch per service.
func TestRegisteredServiceDefaultsNeedNoLoaderEdit(t *testing.T) {
config.RegisterService(config.ServiceBoth, "loadertest", "127.0.0.1:7101", "127.0.0.1:7102", "LOADERTEST_TOKEN")
path := filepath.Join(t.TempDir(), "config.toml")
if err := os.WriteFile(path, []byte("bot_user = 'widget'\n"), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
got := cfg.Services.Get("loadertest")
if got.Target != "127.0.0.1:7101" {
t.Errorf("target = %q, want the registered default", got.Target)
}
if got.Listen != "127.0.0.1:7102" {
t.Errorf("listen = %q, want the registered default", got.Listen)
}
}
// TestStateTargetIsNotDefaulted keeps the asymmetry the registry now carries as
// data: the gateway's target is defaulted, the State Store's is operator
// input, and defaulting it to something dialable would turn a missing
// required value into a connection attempt against the wrong host.
func TestStateTargetIsNotDefaulted(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
if err := os.WriteFile(path, []byte("bot_user = 'widget'\n"), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if got := cfg.Services.Get(config.ServiceNameState).Target; got != "" {
t.Errorf("state target = %q, want empty", got)
}
}
// TestUnregisteredServiceSectionIsReported is the regression this change had to
// avoid introducing. Services was a struct, so [services.gatway] landed in
// Undecoded() and was reported. As a map it decodes cleanly, so without the
// registry check a typo'd service section would load silently and the daemon
// would dial the default instead.
func TestUnregisteredServiceSectionIsReported(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
src := minimalValidConfigTOML + "[services.gatway]\ntarget = '127.0.0.1:1'\n"
if err := os.WriteFile(path, []byte(src), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatalf("File: %v (an unknown key must not fail the load)", err)
}
if !slices.Contains(doc.UnknownKeys, "services.gatway") {
t.Errorf("UnknownKeys = %v, want it to contain %q", doc.UnknownKeys, "services.gatway")
}
}
// TestRegisteredServiceSectionIsNotReported is the other half: a real service
// section must not be flagged just because the map would accept anything.
func TestRegisteredServiceSectionIsNotReported(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
src := minimalValidConfigTOML + "[services.state]\ntarget = '127.0.0.1:9090'\n"
if err := os.WriteFile(path, []byte(src), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatal(err)
}
for _, k := range doc.UnknownKeys {
if strings.HasPrefix(k, "services.") {
t.Errorf("UnknownKeys = %v, want no services.* entry for a registered service", doc.UnknownKeys)
break
}
}
}
@@ -27,7 +27,7 @@ func minimalValidConfig() config.Config {
Image: "ghcr.io/samcharles93/archie-agent:latest",
},
Services: config.Services{
Gateway: config.ServiceConnection{Target: "127.0.0.1:8585"},
config.ServiceNameGateway: {Target: "127.0.0.1:8585"},
},
}
}