The settings page now reads apply status beside each resource: every known process with the version it applied, its error if it rejected the edit, and whether it is still reporting at all. It re-reads after each save, so the page reflects what the processes did with an edit rather than what was stored. The server derives liveness only, because it knows whether a record went stale but not which version the page is showing. The client compares against the resource it is rendering, which is what turns a live record on an older version into a pending restart. A process that stopped re-stamping and one that never reported are separate rows with separate wording, and neither is an error: the setting may be fine and the process simply absent, which an operator acts on differently. A failed apply-status read leaves the previous rows rather than taking the settings page down with it. state-store-contract.md gains the pair in its inventory and its count moves from 45 to 47, with the note that this read is a list rather than the config-snapshot pair's found=false singleton. Closes archie-core-pskb.
174 lines
7.5 KiB
Go
174 lines
7.5 KiB
Go
package archieui
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"time"
|
|
|
|
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/health"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/captureintake"
|
|
"github.com/samcharles93/archie-core/internal/webhookguard"
|
|
"github.com/samcharles93/archie-core/internal/webui"
|
|
)
|
|
|
|
// deps are the resolved inputs the dashboard is built from: two remote
|
|
// contracts, the process's own logger and options, and the readiness registry
|
|
// assembled over those same contracts.
|
|
type deps struct {
|
|
Options Options
|
|
Log *slog.Logger
|
|
Store storecontract.TaskStore
|
|
Chat messaging.ChatContract
|
|
Health *health.Registry
|
|
ControlPlane controlpb.ControlPlaneServiceClient
|
|
Identities identity.Repository
|
|
}
|
|
|
|
// compose builds the dashboard server for the UI process. It sets exactly the
|
|
// fields a contract already carries plus this process's own settings, and
|
|
// leaves every remaining field at its zero value on purpose: each one is a
|
|
// daemon-local runtime handle with no contract behind it, and the handlers
|
|
// already degrade to a documented 501/503/empty response rather than panicking
|
|
// (docs/prds/ui-service-boundary.md:130-131).
|
|
//
|
|
// What is deliberately absent, and which bead fills it:
|
|
//
|
|
// - Cfg, LastReload, UpdateConfig, ConfigOverrides, ResetConfig,
|
|
// UpdateRepoField: the configuration owner stays the daemon. The read
|
|
// crosses as the snapshot ConfigSource renders; the write routes answer
|
|
// 503 and the page hides their controls (archie-core-ymut).
|
|
// - LogFeed, Events, Channels, ReloadChannel, Curators, Memory,
|
|
// Workflows, WorkRequests, RunningVersions, Chat.Updates,
|
|
// UpdateReportPath: no contract exists for these yet.
|
|
// Defining one amends the owning service's contract first
|
|
// (docs/prds/ui-service-boundary.md:205-207); the route migration is
|
|
// archie-core-8cda.5.3.
|
|
// - TaskLogs: wired below from the store client's TaskLogStore contract.
|
|
// Task log files live in the state directory the State Store owns, so this
|
|
// process reads one attempt's log over that contract rather than opening
|
|
// the file itself -- which would only work on a single host and is exactly
|
|
// what the boundary forbids (archie-core-iaqx).
|
|
// - Captures, CaptureIntake, CaptureMaxEvents: wired below. From the
|
|
// cutover change (archie-core-8cda.5.4) this process is the only
|
|
// listener serving POST /webhooks/capture/{source}: the receiver is a
|
|
// persistence shim over the State Store contract, and the daemon's
|
|
// binding-dispatch loop keeps consuming captures from the same store,
|
|
// so the HTTP front door moved here without moving the owner of work
|
|
// intake. Mounting it before the daemon's listener was gone would have
|
|
// given two listeners the same intake authority, which the PRD forbids
|
|
// (docs/prds/ui-service-boundary.md:30-33).
|
|
func compose(d deps) *webui.Server {
|
|
srv := &webui.Server{
|
|
Store: d.Store,
|
|
Log: d.Log,
|
|
Token: d.Options.Token,
|
|
TrustForwardedHeaders: d.Options.trustForwardedHeaders(),
|
|
Health: d.Health,
|
|
ControlPlane: d.ControlPlane,
|
|
Identities: d.Identities,
|
|
}
|
|
if snapshots, ok := d.Store.(storecontract.ConfigSnapshotStore); ok {
|
|
srv.ConfigSource = webui.RemoteConfigView(snapshots)
|
|
}
|
|
// Mappings and bindings are ratified State Store contracts, and the same
|
|
// client already carries them: withholding them would degrade two pages
|
|
// that have an owner, which is a different thing from the intake surfaces
|
|
// below.
|
|
if applyStatus, ok := d.Store.(storecontract.ApplyStatusStore); ok {
|
|
srv.ApplyStatus = applyStatus
|
|
}
|
|
if mappings, ok := d.Store.(storecontract.MappingStore); ok {
|
|
srv.Mappings = mappings
|
|
}
|
|
if bindings, ok := d.Store.(storecontract.BindingStore); ok {
|
|
srv.Bindings = bindings
|
|
}
|
|
if d.Chat != nil {
|
|
srv.Chat = &webui.ChatService{Contract: d.Chat}
|
|
}
|
|
// The task-log read crosses the State Store contract: the files live in
|
|
// the state directory that process owns, so this one asks for the log
|
|
// rather than opening a path (docs/prds/ui-service-boundary.md). Withholding
|
|
// it would degrade a page that has an owner, and would leave the dashboard
|
|
// claiming task logging was not enabled -- see wireTaskLogs.
|
|
wireTaskLogs(d, srv)
|
|
wireCaptureSurfaces(d, srv)
|
|
return srv
|
|
}
|
|
|
|
// wireTaskLogs attaches the task-log read when the store client carries the
|
|
// contract, and logs the absence when it does not: a store without it leaves
|
|
// the page reporting that this process cannot read logs, which is true, rather
|
|
// than that the attempt has none, which it cannot know.
|
|
func wireTaskLogs(d deps, srv *webui.Server) {
|
|
logs, ok := d.Store.(storecontract.TaskLogStore)
|
|
if !ok {
|
|
if d.Store != nil {
|
|
d.Log.Warn("task logs unavailable: state store does not implement TaskLogStore")
|
|
}
|
|
return
|
|
}
|
|
srv.TaskLogs = logs
|
|
}
|
|
|
|
// wireCaptureSurfaces attaches the capture read and the intake receiver.
|
|
// Both resolve from d.Store's contracts: CaptureStore backs the inspector's
|
|
// list and the mapping preview's scan window, BindingDispatcher resolves the
|
|
// armed binding whose secret HMAC-verifies a source. A store that does not
|
|
// implement one degrades that half with a warning rather than aborting the
|
|
// process, mirroring the daemon's own adapter selection.
|
|
func wireCaptureSurfaces(d deps, srv *webui.Server) {
|
|
captures, hasCaptures := d.Store.(storecontract.CaptureStore)
|
|
bindings, hasBindings := d.Store.(storecontract.BindingDispatcher)
|
|
if !hasCaptures {
|
|
d.Log.Warn("capture storage unavailable: state store does not implement CaptureStore")
|
|
return
|
|
}
|
|
if !hasBindings {
|
|
d.Log.Warn("binding dispatcher unavailable: state store does not implement BindingDispatcher")
|
|
}
|
|
|
|
capture := d.Options.Capture.withDefaults()
|
|
srv.Captures = captures
|
|
srv.CaptureMaxEvents = capture.MaxEvents
|
|
srv.CaptureIntake = &captureintake.Receiver{
|
|
Captures: captures,
|
|
Limiter: webhookguard.NewRateLimiter(capture.RatePerSecond, capture.RateBurst, time.Now),
|
|
Bindings: bindings,
|
|
Retention: capture.Retention,
|
|
MaxEvents: capture.MaxEvents,
|
|
MaxBodyBytes: int64(capture.MaxBodyBytes),
|
|
Publish: captureArrivalPublisher(d),
|
|
Log: d.Log,
|
|
}
|
|
}
|
|
|
|
// captureArrivalPublisher persists a capture's arrival event through the
|
|
// State Store, where the daemon's bus drain persists every other activity
|
|
// event; the event pump then delivers it to every connected browser. A nil
|
|
// store records captures without announcing them (compose's test-only
|
|
// shape); an insert failure is logged, not surfaced -- the capture row is
|
|
// already durable, and the inspector refetches on its next view.
|
|
func captureArrivalPublisher(d deps) func(context.Context, events.Event) {
|
|
if d.Store == nil {
|
|
return nil
|
|
}
|
|
return func(ctx context.Context, e events.Event) {
|
|
ctx, cancel := context.WithTimeout(ctx, captureEventTimeout)
|
|
defer cancel()
|
|
if _, err := d.Store.InsertEvent(ctx, e); err != nil {
|
|
d.Log.Warn("capture arrival event not published", "err", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// captureEventTimeout bounds the synchronous announce of one capture
|
|
// arrival. A capture POST already paid the rate limiter and a store insert;
|
|
// a hung State Store must not hold the sender's webhook past this.
|
|
const captureEventTimeout = 5 * time.Second
|