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.
79 lines
2.1 KiB
Go
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)
|
|
}
|
|
}
|