archie-core-8cda.6.8's carrier. The service now records channel lifecycle and has nowhere to put it: /api/channels answered with nothing because webui.Server.Channels had no production source, and reload answered 501 for the same reason. This adds the surface the register decided on, following the split archie-core-ymut established for config snapshots -- a pair of administrative RPCs whose writer is one process and whose reader is the UI -- and wires both ends. Wire and store: PutChannelStatus / ListChannelStatus, with ChannelStatus carrying id, name, state, detail, configured, reload_supported and observed_at. The store holds one row per channel and replaces the reported set, so a channel the reporter no longer mentions is deleted rather than left standing as a stale "running"; an empty report clears the table, because hosting no channels is a fact worth reporting. A row without an id is refused: it could never be replaced or removed by a later report. Writer: the service publishes on every lifecycle transition through a coalescing signal -- a burst of transitions is one write, since a reader only wants the latest state of every channel -- plus a start-up report and a final report after shutdown, so a stopped service leaves the store honest. A failed write is logged and retried on the next signal; the dashboard losing channel state is worth a warning and never worth failing a channel start over. Reader: webui.Server.Channels becomes a source rather than a concrete manager, and webui.RemoteChannelStatus reads the store the way RemoteConfigView reads the config snapshot. A store it cannot reach reports nothing rather than a stale "running", and a state the reader does not recognise is carried through rather than dropped. The contract's own index gains the group in the same change that adds the RPCs -- a surface the grouped table does not list is one nobody finds -- and the count moves to 51. The register records why the surface is the State Store rather than a resource kind, and why reload gets its own surface rather than a field here: reading status must not be able to retrigger an action, a transient request is not distinguishable from state once anything polls it, and it would invert the writer/reader relationship the precedent establishes. Verified: task check exit 0. New coverage: the store's replace-the-set semantics and its refusal of an id-less row, the reader's mapping including an unknown state, and the publisher's start-up, transition and final reports.
83 lines
3.3 KiB
Go
83 lines
3.3 KiB
Go
package archiemessaging
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/applystatus"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
|
|
"github.com/samcharles93/archie-core/internal/secret"
|
|
)
|
|
|
|
// Run runs the standalone Messaging Service process until ctx is cancelled.
|
|
func Run(ctx context.Context, o Options) error {
|
|
log := slog.Default().With("service", "archie-messaging")
|
|
|
|
cfg, err := Resolve(o, log)
|
|
if err != nil {
|
|
return fmt.Errorf("resolve messaging options: %w", err)
|
|
}
|
|
|
|
chat, closeGateway, err := gatewayrpc.Dial(cfg.Options.Gateway.Target, cfg.Options.Gateway.Token)
|
|
if err != nil {
|
|
return fmt.Errorf("dial gateway (%s): %w", cfg.Options.Gateway.Target, err)
|
|
}
|
|
defer closeGateway()
|
|
|
|
health := newReadinessRegistry(cfg.Options, chat)
|
|
var settings *messaging.SettingsCommand
|
|
var closeStateStore func()
|
|
// channelStatusStore is the same client, held where compose can reach it: the
|
|
// channel report is published to the store this process already dials.
|
|
var channelStatusStore storecontract.ChannelStatusStore
|
|
if cfg.Options.StateStore.Target != "" {
|
|
stateStore, closeClient, dialErr := staterpc.Dial(cfg.Options.StateStore.Target, cfg.Options.StateStore.Token)
|
|
if dialErr != nil {
|
|
return fmt.Errorf("dial state store control plane (%s): %w", cfg.Options.StateStore.Target, dialErr)
|
|
}
|
|
closeStateStore = closeClient
|
|
defer closeStateStore()
|
|
chatSettings, channelVersion, settingsErr := controlplanerpc.NewRPCClient(stateStore.ControlPlane()).RuntimeChatConfig(ctx, config.ChatConfig{
|
|
Telegram: cfg.Telegram, Email: cfg.Email, Webhook: cfg.Webhook, WebhookAddr: cfg.WebhookAddr, ShowToolCalls: cfg.ShowToolCalls,
|
|
})
|
|
if settingsErr != nil {
|
|
return fmt.Errorf("load channel settings: %w", settingsErr)
|
|
}
|
|
reporter := applystatus.New(applystatus.Messaging, stateStore, log)
|
|
reporter.Report(ctx, controlplanerpc.ChannelSettingsKind, channelVersion, nil)
|
|
go reporter.Run(ctx)
|
|
secrets := secret.NewRegistry()
|
|
cfg.Telegram, cfg.Email, cfg.Webhook, cfg.WebhookAddr, cfg.ShowToolCalls = chatSettings.Telegram, chatSettings.Email, chatSettings.Webhook, chatSettings.WebhookAddr, chatSettings.ShowToolCalls
|
|
cfg.TelegramToken, settingsErr = resolveTelegramToken(chatSettings.Telegram, secrets)
|
|
if settingsErr != nil {
|
|
return fmt.Errorf("resolve database telegram token: %w", settingsErr)
|
|
}
|
|
cfg.WebhookSecret, settingsErr = resolveWebhookSecret(chatSettings.Webhook, secrets)
|
|
if settingsErr != nil {
|
|
return fmt.Errorf("resolve database webhook secret: %w", settingsErr)
|
|
}
|
|
settings = messaging.NewSettingsCommand(messagingControlPlane{client: stateStore.ControlPlane()}).WithIdentities(stateStore)
|
|
channelStatusStore = stateStore
|
|
}
|
|
|
|
srv, err := compose(ctx, deps{
|
|
ChannelStatus: channelStatusStore,
|
|
Config: cfg,
|
|
Log: log,
|
|
Chat: chat,
|
|
Health: health,
|
|
Settings: settings,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return srv.Start(ctx)
|
|
}
|