Files
archie/internal/app/archieui/run.go
T
sam 3944f544e8 feat(controlplane): runtime administration over the State Store's gRPC server
The Web UI and messaging channels now read and write Archie's runtime
settings through one versioned, audited control-plane API hosted on the
State Store's existing gRPC server: catalog, query, command, watch. Each
feature owns its resource, validation and commands; storage only writes
versions and audit records.

Workflows move with it. Definitions become portable YAML compiled through
a closed, typed step registry and stored as a control-plane resource, so
the yaegi interpretation paths (internal/gate, wfeval, wfextract,
gateeval, gateextract, skillbuild) are deleted rather than carried.

The UI process reads definitions as data: the JSON projection lives in
internal/domain/workflow/task so a dashboard decodes the stored
collection without linking the workflow engine, which cmd/archie-ui's
deletion gate forbids. Shipped definitions ride the catalog descriptor
rather than a bespoke REST route, keeping the API to its four operations.

archie-messaging gains -state-store-target/-state-store-token and reads
channel settings from the database, failing closed when the State Store
is unreachable: the database is authoritative for those settings.
2026-09-21 08:17:42 +10:00

112 lines
3.5 KiB
Go

package archieui
import (
"context"
"errors"
"fmt"
"log/slog"
"net"
"net/http"
"os"
"slices"
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/webui"
)
// Run serves the dashboard until ctx is cancelled. It resolves its own
// options, dials the Gateway and State Store contracts itself, composes the
// HTTP surface over them, and unwinds listener then clients in reverse order
// on shutdown.
func Run(ctx context.Context, options Options) error {
log := slog.New(slog.NewJSONHandler(os.Stderr, nil)).With("component", "ui")
opts, err := Resolve(options, log)
if err != nil {
return err
}
var cleanups []func()
defer func() {
for _, cleanup := range slices.Backward(cleanups) {
cleanup()
}
}()
tasks, closeState, err := staterpc.Dial(opts.State.Target, opts.State.Token)
if err != nil {
return err
}
cleanups = append(cleanups, closeState)
chat, closeGateway, err := gatewayrpc.Dial(opts.Gateway.Target, opts.Gateway.Token)
if err != nil {
return err
}
cleanups = append(cleanups, closeGateway)
srv := compose(deps{
Options: opts,
Log: log,
Store: tasks,
Chat: chat,
Health: newReadinessRegistry(opts, tasks, chat),
ControlPlane: tasks.ControlPlane(),
Identities: tasks,
})
// Live activity has no in-process bus in this process: the pump reads
// events back out of the State Store over the same cursor SSE catch-up
// uses. Backgrounded so priming past a large events table cannot delay
// the listener (docs/architecture/migration-decisions.md, "Dashboard
// live event delivery").
go func() {
if err := srv.PumpEvents(ctx, opts.EventPollInterval); err != nil {
log.Error("event pump stopped; the activity feed will only show history", "err", err)
}
}()
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", opts.Listen)
if err != nil {
return fmt.Errorf("listen for ui: %w", err)
}
cleanups = append(cleanups, func() { _ = listener.Close() })
log.Info(
"archie-ui running",
"addr", listener.Addr().String(),
"open", webui.DashboardURL(listener.Addr().String(), opts.Token),
"gateway", opts.Gateway.Target,
"state", opts.State.Target,
)
return serve(ctx, listener, srv.Handler(), opts)
}
// serve runs handler on listener until ctx ends, then shuts the HTTP server
// down within ShutdownTimeout so in-flight dashboard requests finish before
// the contract clients close. A graceful shutdown that overruns its deadline
// is a normal shutdown under load, not a process failure: the remaining
// connections are force-closed and serve reports clean.
func serve(ctx context.Context, listener net.Listener, handler http.Handler, opts Options) error {
server := &http.Server{Handler: handler, ReadHeaderTimeout: opts.ReadHeaderTimeout}
serveErr := make(chan error, 1)
go func() { serveErr <- server.Serve(listener) }()
select {
case <-ctx.Done():
shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), opts.ShutdownTimeout)
defer cancel()
if err := server.Shutdown(shutdownCtx); err != nil {
// Shutdown returned once the drain deadline elapsed with a request
// still in flight. Force-close what is left so shutdown finishes
// and the process exits cleanly rather than carrying a deadline
// error to the operator as a fatal exit (archie-core-u4xu).
_ = server.Close()
}
return nil
case err := <-serveErr:
if errors.Is(err, http.ErrServerClosed) {
return nil
}
return err
}
}