Files
archie/internal/config/holder_test.go
T
sam f544dd0978 feat(config): SIGHUP-triggered reload with requires-restart warnings
The daemon can now re-read its configuration on SIGHUP (or on a
future in-process trigger) and republish it through the Holder,
closing the first half of issue #348: 'config can change at runtime,
safely, and can't brick the daemon.'

Reload path:
- cmd/archied/reload.go: ReloadController re-runs loader.Resolve on
  the same paths main.go passed at startup (Resolve is pure -- no
  reload state added to the loader). apply is called only with a
  Document that passed validation; a failed reload records the error
  and its timestamp and leaves the running config untouched. That
  Set-not-called-on-error property is the safety core and is pinned
  by TestReloadValidationFailureDoesNotApply.
- SIGHUP listener in main.go runs reloadLoop(ctx, ch, controller, log);
  the loop is extracted as a testable seam (syscall.SIGHUP is Unix-only,
  fine given the Linux target).

PollInterval is genuinely reloadable now, not just re-read:
the three ticker sites (Run, per-identity goroutine, shared
maintenance loop) re-read the interval each tick and Reset the ticker
on change. A reloaded poll_interval takes effect on the next cycle.

Diff-and-warn so an operator never has to read the source to know
whether an edit took effect: changedNonReloadableFields compares the
old and new snapshots against an allowlist of re-read fields
(PollInterval, Repos, DiffCapLines, Budgets, Dispatch, and the
Containers sub-fields VolumeTTL + MaxConcurrency). Anything else that
changed logs Warn 'requires a restart'; a fully-applied reload logs
Info. The allowlist is deliberate: a field added to Config later
defaults to requires-restart, the safe direction.

NATS split-brain closed: containerEnv now hands containers the
endpoint the daemon's own client connected with at startup
(Daemon.ConnectedNATS, captured at construction) instead of the live
config, so a reloaded nats.url cannot point new containers at a
server the daemon is not publishing on. A nats change is therefore
classified requires-restart, and CLAUDE.md's 'hands its own nats.url
verbatim' note is updated to the meaning it now has (same today,
deliberately different after a reload).

Validation guard: poll_interval <= 0 is rejected in validate.go
beside the VolumeTTL guard. applyDefaults fills zero with 60s, so
this fires on an explicit negative -- which would panic
time.NewTicker/Reset at boot and, after the per-iteration reset,
on a SIGHUP mid-run.

Observability: config.ReloadStatus (last_error, last_error_at,
last_reload_at) is recorded by the controller and surfaced in
/api/config via Server.LastReload, so a stale running config is
visible in the dashboard, not just the logs. Rendering waits for the
UI step.

Recovery hatch: --no-config-overlay flag plus ARCHIE_SKIP_CONFIG_OVERLAY=1
(configuration.SkipOverlay), logged at startup. No overlay source
exists yet; the flag is the documented escape hatch the DB overlay
(step 3 of #348) will consult.

webui.Server.ConfigProvenance becomes atomic.Pointer so a reload can
swap it via SetProvenance independently of Cfg; the accepted skew
(new config alongside old provenance) is documented on the field.

Verified: task check clean; -race on daemon, webui, cmd/archied,
config, infrastructure/configuration.
2026-08-10 00:19:46 +10:00

79 lines
2.1 KiB
Go

package config
import (
"sync"
"testing"
)
func TestHolderGetReturnsConstructorValue(t *testing.T) {
c := Config{BotUser: "archie", PollInterval: Duration(1)}
h := NewHolder(c)
if got := h.Get(); got.BotUser != "archie" || got.PollInterval != Duration(1) {
t.Fatalf("Get() = %+v, want BotUser=archie PollInterval=1", got)
}
}
func TestHolderSetReplaces(t *testing.T) {
h := NewHolder(Config{BotUser: "old"})
h.Set(Config{BotUser: "new"})
if got := h.Get(); got.BotUser != "new" {
t.Fatalf("after Set, Get().BotUser = %q, want \"new\"", got.BotUser)
}
}
func TestHolderConcurrentGetSetIsRaceFree(t *testing.T) {
// The actual contract is that Get never tears: under -race, no data
// race, and every observed Config is a value some Set wrote. We do
// not assert "Get after my Set returns my value" because with N
// concurrent writers that property is not what Get guarantees -- a
// later Set can land between this writer's Set and this writer's
// Get. The race detector is the real check.
h := NewHolder(Config{BotUser: "v0"})
const writers = 8
const iters = 1000
var wg sync.WaitGroup
for range writers {
wg.Add(2)
go func() {
defer wg.Done()
for range iters {
h.Set(Config{BotUser: "w"})
}
}()
go func() {
defer wg.Done()
for range iters {
_ = h.Get()
}
}()
}
wg.Wait()
}
func TestHolderGetPanicsOnNil(t *testing.T) {
defer func() {
if r := recover(); r == nil {
t.Fatalf("Get on nil Holder did not panic")
}
}()
var h *Holder
_ = h.Get()
}
func TestHolderSharedReferenceField(t *testing.T) {
// Documents the immutability invariant: maps inside the snapshot
// are shared with all Get callers. Mutating one is visible to all
// others -- the contract forbids this, but the test pins the
// current behaviour so any future change (e.g. copying maps) is
// a deliberate decision.
original := Config{Models: map[string]string{"builder": "anthropic/claude"}}
h := NewHolder(original)
snapshot := h.Get()
snapshot.Models["builder"] = "mutated"
if got := h.Get().Models["builder"]; got != "mutated" {
t.Fatalf("expected Get to see mutation through shared map, got %q", got)
}
}