167 lines
7.0 KiB
Go
167 lines
7.0 KiB
Go
package archiemessaging
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"google.golang.org/grpc"
|
|
|
|
"github.com/samcharles93/archie-core/internal/app/servicekit"
|
|
"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/presence"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/messagingrpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/rpctls"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/secretengine"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
"github.com/samcharles93/archie-core/internal/releaseupdate"
|
|
"github.com/samcharles93/archie-core/internal/secret"
|
|
)
|
|
|
|
// resolveTraced resolves the configuration and starts trace export from it.
|
|
func resolveLogged(ctx context.Context, o Options) (ResolvedConfig, *slog.Logger, *logging.Feed, func(), error) {
|
|
cfg, err := Resolve(o, slog.New(slog.NewJSONHandler(os.Stderr, nil)))
|
|
if err != nil {
|
|
return ResolvedConfig{}, nil, nil, nil, fmt.Errorf("resolve messaging options: %w", err)
|
|
}
|
|
logs, err := servicekit.Logging(ctx, cfg.Logging, "messaging")
|
|
if err != nil {
|
|
return ResolvedConfig{}, nil, nil, nil, err
|
|
}
|
|
return cfg, logs.Log.With("service", "archie-messaging"), logs.Feed, func() { _ = logs.Closer.Close() }, nil
|
|
}
|
|
|
|
// Run runs the standalone Messaging Service process until ctx is cancelled.
|
|
func Run(ctx context.Context, o Options) error {
|
|
cfg, log, feed, closeLogs, err := resolveLogged(ctx, o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closeLogs()
|
|
|
|
chat, closeGateway, err := gatewayrpc.Dial(cfg.Options.Gateway.Target, cfg.Identity)
|
|
if err != nil {
|
|
return fmt.Errorf("dial gateway (%s): %w", cfg.Options.Gateway.Target, err)
|
|
}
|
|
defer closeGateway()
|
|
|
|
secrets := secret.NewRegistry()
|
|
health := newReadinessRegistry(cfg.Options, chat)
|
|
var settings *messaging.SettingsCommand
|
|
// 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
|
|
var presenceStore storecontract.PresenceStore
|
|
// settingsSource and applyReporter are the live channel-settings path: the
|
|
// control-plane client to re-read the resource, and the record of what this
|
|
// process applied. Both stay nil without a State Store, which leaves the
|
|
// service with no live path.
|
|
var settingsSource chatSettingsSource
|
|
var applyReporter *applystatus.Reporter
|
|
var appliedVersion int64
|
|
var updates *releaseupdate.Service
|
|
var extensionChannels []*channelInstance
|
|
if cfg.Options.StateStore.Target != "" {
|
|
stateStore, closeClient, dialErr := staterpc.Dial(cfg.Options.StateStore.Target, presence.Messaging, cfg.Identity, staterpc.WaitForPeer)
|
|
if dialErr != nil {
|
|
return fmt.Errorf("dial state store control plane (%s): %w", cfg.Options.StateStore.Target, dialErr)
|
|
}
|
|
defer closeClient()
|
|
controlPlaneClient := controlplanerpc.NewRPCClient(stateStore.ControlPlane())
|
|
reporter := applystatus.New(applystatus.Messaging, stateStore, log)
|
|
extensions := extension.Source{Query: controlPlaneClient, Packages: stateStore}
|
|
defer superviseSecretEngines(ctx, extensions, secrets, reporter, log)()
|
|
chatSettings, channelVersion, settingsErr := controlPlaneClient.RuntimeChatConfig(ctx, config.ChatConfig{
|
|
Telegram: cfg.Telegram, ShowToolCalls: cfg.ShowToolCalls,
|
|
})
|
|
if settingsErr != nil {
|
|
return fmt.Errorf("load channel settings: %w", settingsErr)
|
|
}
|
|
reporter.Report(ctx, controlplanerpc.ChannelSettingsKind, channelVersion, nil)
|
|
go reporter.Run(ctx)
|
|
go presence.Run(ctx, presence.Messaging, servicekit.Build(), stateStore, health, log)
|
|
cfg.Telegram, cfg.ShowToolCalls = chatSettings.Telegram, chatSettings.ShowToolCalls
|
|
cfg.TelegramToken, settingsErr = resolveTelegramToken(chatSettings.Telegram, secrets)
|
|
if settingsErr != nil {
|
|
return fmt.Errorf("resolve database telegram token: %w", settingsErr)
|
|
}
|
|
extensionChannels = openExtensionChannels(ctx, extensions, secrets, log)
|
|
settings = messaging.NewSettingsCommand(controlplanerpc.NewSettingsClient(stateStore.ControlPlane())).WithIdentities(stateStore)
|
|
channelStatusStore, presenceStore = stateStore, stateStore
|
|
settingsSource, applyReporter, appliedVersion = controlPlaneClient, reporter, channelVersion
|
|
updates = controlplanerpc.UpdateService(controlPlaneClient, filepath.Join(cfg.WorkDir, "telegram-update-deferrals.json"))
|
|
}
|
|
|
|
if cfg.Options.StateStore.Target == "" {
|
|
if err := cfg.resolveTokens(secrets); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
srv, err := compose(ctx, deps{
|
|
Secrets: secrets,
|
|
ChannelStatus: channelStatusStore,
|
|
Presence: presenceStore,
|
|
Config: cfg,
|
|
ExtensionChannels: extensionChannels,
|
|
Log: log,
|
|
Chat: chat,
|
|
Settings: settings,
|
|
SettingsSource: settingsSource,
|
|
ApplyReporter: applyReporter,
|
|
AppliedVersion: appliedVersion,
|
|
Updates: updates,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return serve(ctx, cfg.Options.Listen, cfg.Identity, srv, log, feed)
|
|
}
|
|
|
|
// serve runs srv and serves MessagingService over it until ctx is cancelled.
|
|
func serve(ctx context.Context, listen string, id *rpctls.Identity, srv *Service, log *slog.Logger, feed *logging.Feed) error {
|
|
opts, err := messagingrpc.ServerOptions(listen, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", listen)
|
|
if err != nil {
|
|
return fmt.Errorf("listen messaging (%s): %w", listen, err)
|
|
}
|
|
server := grpc.NewServer(append(servicekit.ServerLimits(), opts...)...)
|
|
messagingrpc.RegisterServer(server, srv, feed)
|
|
ctx, cancel := context.WithCancel(ctx)
|
|
defer cancel()
|
|
// A dead listener stops the channels too: the process exits and its
|
|
// supervisor restarts it, rather than it running on without Deliver.
|
|
serveErr := make(chan error, 1)
|
|
go func() {
|
|
serveErr <- servicekit.Serve(ctx, server, listener)
|
|
cancel()
|
|
}()
|
|
log.InfoContext(ctx, "messaging service listening", "listen", listen)
|
|
startErr := srv.Start(ctx)
|
|
cancel()
|
|
if err := <-serveErr; err != nil {
|
|
return fmt.Errorf("serve messaging: %w", err)
|
|
}
|
|
return startErr
|
|
}
|
|
|
|
// superviseSecretEngines runs the secret-engine extensions and reports their
|
|
// settings outcome; the returned function stops them.
|
|
func superviseSecretEngines(ctx context.Context, source extension.Source, secrets *secret.Registry, reporter *applystatus.Reporter, log *slog.Logger) func() {
|
|
return secretengine.Supervise(ctx, secrets, source, applystatus.Messaging, func(ctx context.Context, version int64, err error) {
|
|
reporter.Report(ctx, controlplanerpc.ExtensionSettingsKind, version, err)
|
|
}, log).Close
|
|
}
|