TaskConfig now carries the daemon's ToolPolicy (MaxResultChars/SpillDir) via ForTask/ToConfig, and runTask applies it to the constructed LoopRunner. Previously the worker always built the agent loop with a zero-value ToolLimits, so tool results in every task's agent stage were never capped or spilled despite the configured 50k default (agentexec-1, tools-core-11).
234 lines
9.1 KiB
Go
234 lines
9.1 KiB
Go
package archied
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"os"
|
|
"reflect"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
|
)
|
|
|
|
// ReloadController re-runs the configuration load on demand and
|
|
// publishes the result through apply. A failed reload never publishes:
|
|
// apply is called only with a Document that passed validation, and the
|
|
// running config is left untouched on error. That "Set is not called on
|
|
// the error path" property is the safety core of the reload feature --
|
|
// a bad file must leave the daemon running on the previous config.
|
|
type ReloadController struct {
|
|
loader *configuration.Loader
|
|
base string
|
|
overlay string
|
|
|
|
// apply receives a freshly loaded, validated Document. It is the
|
|
// composition root's job to wire this to whatever owns the running
|
|
// config (the daemon's Holder, the dashboard's provenance). Must be
|
|
// non-nil; newReloadController requires it.
|
|
apply func(*configuration.Document)
|
|
|
|
// overlayValues, when non-nil, returns the runtime config overlay
|
|
// (dotted keys -> typed values) to layer over the file config before
|
|
// publishing. A failed overlay read or validation aborts the reload
|
|
// exactly like a bad file.
|
|
overlayValues func() (map[string]any, error)
|
|
|
|
status atomic.Pointer[config.ReloadStatus]
|
|
}
|
|
|
|
func newReloadController(loader *configuration.Loader, base, overlay string, apply func(*configuration.Document)) *ReloadController {
|
|
c := &ReloadController{loader: loader, base: base, overlay: overlay, apply: apply}
|
|
c.status.Store(&config.ReloadStatus{})
|
|
return c
|
|
}
|
|
|
|
// Reload re-runs the configuration load. On validation failure it
|
|
// records the error in Status and returns it; apply is not called and
|
|
// the running configuration is unchanged. On success it calls apply
|
|
// with the fresh Document and records the reload time.
|
|
func (c *ReloadController) Reload() error {
|
|
doc, err := c.loader.Resolve(c.base, c.overlay)
|
|
if err != nil {
|
|
c.status.Store(&config.ReloadStatus{
|
|
LastError: err.Error(),
|
|
LastErrorAt: time.Now().UTC().Format(time.RFC3339),
|
|
})
|
|
return err
|
|
}
|
|
if c.overlayValues != nil {
|
|
values, err := c.overlayValues()
|
|
if err != nil {
|
|
c.status.Store(&config.ReloadStatus{
|
|
LastError: err.Error(),
|
|
LastErrorAt: time.Now().UTC().Format(time.RFC3339),
|
|
})
|
|
return err
|
|
}
|
|
if len(values) > 0 {
|
|
// ApplyOverlay never mutates its input: on failure the
|
|
// resolved document (and the running config) is untouched.
|
|
if doc, err = c.loader.ApplyOverlay(doc, values); err != nil {
|
|
c.status.Store(&config.ReloadStatus{
|
|
LastError: err.Error(),
|
|
LastErrorAt: time.Now().UTC().Format(time.RFC3339),
|
|
})
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
c.apply(doc)
|
|
c.status.Store(&config.ReloadStatus{
|
|
LastReloadAt: time.Now().UTC().Format(time.RFC3339),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
// WithOverlay attaches the runtime config overlay source. Optional: a
|
|
// controller without it publishes the file config alone.
|
|
func (c *ReloadController) WithOverlay(fn func() (map[string]any, error)) *ReloadController {
|
|
c.overlayValues = fn
|
|
return c
|
|
}
|
|
|
|
// Status returns the most recent reload outcome.
|
|
func (c *ReloadController) Status() config.ReloadStatus {
|
|
if p := c.status.Load(); p != nil {
|
|
return *p
|
|
}
|
|
return config.ReloadStatus{}
|
|
}
|
|
|
|
// reloadLoop waits for a reload signal on ch and re-loads the config
|
|
// each time, until ctx is cancelled. A failed reload is logged and the
|
|
// running config is left untouched (see ReloadController.Reload).
|
|
func reloadLoop(ctx context.Context, ch <-chan os.Signal, c *ReloadController, log *slog.Logger) {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ch:
|
|
if err := c.Reload(); err != nil {
|
|
log.Error("config reload failed; keeping running config", "err", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// reloadableFields are the Config fields a reload takes effect on
|
|
// without a restart. The criterion: a field is reloadable when EVERY
|
|
// consumer re-reads it. That question read as "what does the daemon
|
|
// re-read" while the daemon owned the only Holder; it stopped being
|
|
// sufficient when webui began sharing that Holder, because webui
|
|
// handlers re-read on every request. MaxRetries is the worked example:
|
|
// its only consumer is api_tasks.go:380,383, reading per-request
|
|
// s.Cfg.Get(), and nothing in the daemon reads it -- so it reloads.
|
|
// Chat.Telegram.TokenEnv is the counter-example: webui reads it per
|
|
// request AND a telegram bot built at startup consumes it, so it is
|
|
// NOT reloadable, and treating "webui reads it" as sufficient would
|
|
// display a new token while the bot uses the old one.
|
|
//
|
|
// This is deliberately an allowlist: a field added to Config later
|
|
// defaults to requires-restart, which is the safe direction and forces
|
|
// whoever adds it to decide deliberately.
|
|
var reloadableFields = map[string]bool{
|
|
// Tickers reset on change (daemon.go Run / runIdentities).
|
|
"PollInterval": true,
|
|
// Poll loops re-read per cycle (daemon.go poll / pollForIdentity).
|
|
"Repos": true,
|
|
// Per-task snapshot: ForTask carries these into every dispatched
|
|
// TaskContext (config.go ForTask), built fresh from d.Cfg.Get() at
|
|
// dispatch. Pinned by TestReloadableFieldsCoverForTaskSnapshot so a
|
|
// field added to ForTask cannot silently drift out of this list.
|
|
"DiffCapLines": true,
|
|
"Budgets": true,
|
|
"Dispatch": true,
|
|
"Models": true,
|
|
"ModelLimits": true,
|
|
"Notify": true,
|
|
// BotUser/BotEmail used to be poll-path only; ForTask now carries both
|
|
// into the task snapshot as well, because the sandboxed worker builds
|
|
// its own worktree.Manager and signs its own commits (agentworker
|
|
// task_execution.go, config.go ForTask). The commit identity is
|
|
// therefore per-dispatch and does reload. The startup-built daemon
|
|
// trees (bootstrap.go:654) still capture both, but only to record
|
|
// user.name/user.email in the clone's own .git/config
|
|
// (worktree.go setIdentity) -- cosmetic, not the signature go-git
|
|
// commits with -- so a reload applies where it counts and this stays
|
|
// reloadable rather than requires-restart.
|
|
"BotEmail": true,
|
|
// cfg.Label additionally feeds IssuesWithLabel per poll cycle
|
|
// (daemon.go:359,390) and cfg.BotUser feeds AssignedIssues (:364,377).
|
|
// Label is not carried by ForTask, so it is pinned by hand in
|
|
// TestReloadableFieldsCoverForTaskSnapshot.
|
|
"Label": true,
|
|
"BotUser": true,
|
|
// Worked example of the every-consumer criterion above: the sole
|
|
// consumer is the webui maxRetriesFor handler (api_tasks.go:380,383),
|
|
// which re-reads per request; the daemon never reads MaxRetries. The
|
|
// per-task half of this list is pinned mechanically; this webui-only
|
|
// entry is pinned by TestChangedNonReloadableFields.
|
|
"MaxRetries": true,
|
|
// [agent] is a decode-only compatibility shim; changes have no runtime
|
|
// consumer and therefore require neither reload nor restart.
|
|
"LegacyAgent": true,
|
|
// Tools.Policy (MaxResultChars/SpillDir) is carried into TaskConfig by
|
|
// ForTask (config.go) and applied fresh per dispatch via
|
|
// agentworker.applyToolLimits. See reloadableSubFields["Tools"].
|
|
"ToolPolicy": true,
|
|
}
|
|
|
|
// reloadableSubFields are sub-fields of structs that are otherwise
|
|
// startup-built. VolumeTTL is re-read per cycle in cleanupExpiredStorage;
|
|
// everything else in Containers (Image, MaxConcurrency,
|
|
// MaxUptime, PullPolicy, Network) is frozen in the startup-built
|
|
// container pool -- the dispatchers re-read MaxConcurrency but the pool
|
|
// captures it at construction (container/pool.go:94,163), so a change
|
|
// only partially applies and must warn requires-restart. Forge.Host is
|
|
// carried into TaskContext by ForTask (display/link building only); the
|
|
// forge client itself is startup-built, so Type/Token/TokenEnv stay
|
|
// requires-restart.
|
|
var reloadableSubFields = map[string]map[string]bool{
|
|
"Containers": {"LegacyEnabled": true, "VolumeTTL": true},
|
|
"Forge": {"Host": true},
|
|
// Policy is carried into TaskConfig by ForTask (config.go); MCPServers,
|
|
// WebFetch and Minimax are not and stay requires-restart.
|
|
"Tools": {"Policy": true},
|
|
}
|
|
|
|
// changedNonReloadableFields compares old and new and returns the
|
|
// dotted names of top-level Config fields whose values differ and are
|
|
// not re-read per cycle. The reload log warns about these so the
|
|
// operator knows their edit did not take effect until a restart --
|
|
// the alternative is an operator who believes a reloaded poll interval
|
|
// changed the forge token, and burns an hour discovering it did not.
|
|
func changedNonReloadableFields(old, next config.Config) []string {
|
|
var changed []string
|
|
ov, nv := reflect.ValueOf(old), reflect.ValueOf(next)
|
|
ot := reflect.TypeFor[config.Config]()
|
|
for i := 0; i < ot.NumField(); i++ {
|
|
f := ot.Field(i)
|
|
name := f.Name
|
|
if reloadableFields[name] {
|
|
continue
|
|
}
|
|
if subs, ok := reloadableSubFields[name]; ok && f.Type.Kind() == reflect.Struct {
|
|
for j := 0; j < f.Type.NumField(); j++ {
|
|
sub := f.Type.Field(j).Name
|
|
if subs[sub] {
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(ov.Field(i).Field(j).Interface(), nv.Field(i).Field(j).Interface()) {
|
|
changed = append(changed, name+"."+sub)
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(ov.Field(i).Interface(), nv.Field(i).Interface()) {
|
|
changed = append(changed, name)
|
|
}
|
|
}
|
|
return changed
|
|
}
|