Flip provider-settings, model-role-assignments, repository-policies and scheduling-policy to ApplyMode live, and give the daemon a watch per kind (keepWatch's reconnection and backoff rules): on a new stored version the watch re-runs boot.runtimeConfig over the published snapshot and republishes through config.Holder, keeping last-known-good when the layered document fails to validate and reporting through apply status. The stored model-role assignments now own cfg.Models entirely (the map merge would resurrect a role the store deleted on every re-layering), and a provider or role update rebuilds the gateway chat runtime's provider set (swapped runtime, read per turn) and the chat model manager's offered list.
266 lines
11 KiB
Go
266 lines
11 KiB
Go
package controlplane
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
|
|
"google.golang.org/grpc"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/agent"
|
|
"github.com/samcharles93/archie-core/internal/domain/scheduling"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
|
)
|
|
|
|
// Client is the control-plane client for every resource that does not resolve
|
|
// a workflow step type: catalog, history, settings, personas, schedules. It
|
|
// carries no step vocabulary, so a process that never reads or writes a
|
|
// workflow definition -- archie-messaging, which only loads channel settings,
|
|
// and archie-gateway, which reads catalog, runtime settings and personas --
|
|
// needs no provider set and cannot be failed by one.
|
|
// Client is the control-plane client a process that serves the store uses. It
|
|
// embeds the Messaging Service's client -- the generic resource read path and
|
|
// the channel-settings projection -- and adds the resource-specific reads and
|
|
// watches, which need the workflow and scheduling engines that such a process
|
|
// already links (archie-core-1ng1).
|
|
type Client struct {
|
|
*controlplanerpc.Client
|
|
rpc pb.ControlPlaneServiceClient
|
|
}
|
|
|
|
// NewClient dials the control plane over an existing connection.
|
|
func NewClient(conn grpc.ClientConnInterface) *Client {
|
|
return &Client{rpc: pb.NewControlPlaneServiceClient(conn)}
|
|
}
|
|
|
|
// NewRPCClient wraps an already-constructed generated client.
|
|
func NewRPCClient(client pb.ControlPlaneServiceClient) *Client {
|
|
return &Client{Client: controlplanerpc.NewRPCClient(client), rpc: client}
|
|
}
|
|
|
|
// WorkflowDefinitionsClient reads and replaces the workflow-definitions
|
|
// resource, the one control-plane surface whose stored values name workflow
|
|
// step types. Resolving those names needs the step vocabulary the process
|
|
// registered at its composition root, so the vocabulary is a constructor
|
|
// dependency of this surface and of no other: a caller that cannot reach
|
|
// workflow definitions cannot ask for one.
|
|
type WorkflowDefinitionsClient struct {
|
|
rpc pb.ControlPlaneServiceClient
|
|
steps workflow.StepRegistry
|
|
}
|
|
|
|
func NewWorkflowDefinitionsClient(client pb.ControlPlaneServiceClient, steps *workflow.Manager) (*WorkflowDefinitionsClient, error) {
|
|
registry, err := stepRegistry(steps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &WorkflowDefinitionsClient{rpc: client, steps: registry}, nil
|
|
}
|
|
|
|
func (c *Client) Catalog(ctx context.Context) ([]*pb.ResourceDescriptor, error) {
|
|
response, err := c.rpc.Catalog(ctx, &pb.CatalogRequest{})
|
|
if err != nil {
|
|
return nil, controlplanerpc.ClientError(err)
|
|
}
|
|
return response.Resources, nil
|
|
}
|
|
|
|
func (c *WorkflowDefinitionsClient) WorkflowDefinitions(ctx context.Context) (workflow.WorkflowDefinitionCollection, int64, error) {
|
|
response, err := c.rpc.Query(ctx, &pb.QueryRequest{Kind: WorkflowDefinitionsKind})
|
|
if err != nil {
|
|
return workflow.WorkflowDefinitionCollection{}, 0, controlplanerpc.ClientError(err)
|
|
}
|
|
definitions, err := workflow.DecodeDefinitionCollection(response.Resource.ValueJson, c.steps)
|
|
return definitions, response.Resource.Version, err
|
|
}
|
|
|
|
// ReplaceWorkflowDefinitions replaces the collection. Passing
|
|
// workflow.ShippedDefinitions() restores all shipped definitions while keeping
|
|
// the previous override in resource history.
|
|
//
|
|
// No production process calls it today: the daemon's only consumer of this
|
|
// surface reads (internal/daemon's WorkflowDefinitions interface), so this half
|
|
// is reached by tests until a writer exists.
|
|
func (c *WorkflowDefinitionsClient) ReplaceWorkflowDefinitions(ctx context.Context, definitions workflow.WorkflowDefinitionCollection, expectedVersion int64, actor, source, requestID string) (int64, error) {
|
|
value, err := encodeWorkflowDefinitions(definitions, c.steps)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
response, err := c.rpc.Command(ctx, &pb.CommandRequest{Kind: WorkflowDefinitionsKind, Command: "replace", ValueJson: value, ExpectedVersion: expectedVersion, Actor: actor, Source: source, RequestId: requestID})
|
|
if err != nil {
|
|
return 0, controlplanerpc.ClientError(err)
|
|
}
|
|
return response.Resource.Version, nil
|
|
}
|
|
|
|
func (c *Client) WorkflowExecutionSettings(ctx context.Context) (workflow.ExecutionSettings, int64, error) {
|
|
response, err := c.rpc.Query(ctx, &pb.QueryRequest{Kind: WorkflowExecutionSettingsKind})
|
|
if err != nil {
|
|
return workflow.ExecutionSettings{}, 0, controlplanerpc.ClientError(err)
|
|
}
|
|
settings, err := decodeSettings(response.Resource.ValueJson)
|
|
return settings, response.Resource.Version, err
|
|
}
|
|
|
|
func (c *Client) ReplaceWorkflowExecutionSettings(ctx context.Context, settings workflow.ExecutionSettings, expectedVersion int64, actor, source, requestID string) (int64, error) {
|
|
if err := settings.Validate(); err != nil {
|
|
return 0, fmt.Errorf("%w: %w", ErrValidation, err)
|
|
}
|
|
value, err := encodeSettings(settings)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
response, err := c.rpc.Command(ctx, &pb.CommandRequest{Kind: WorkflowExecutionSettingsKind, Command: "replace", ValueJson: value, ExpectedVersion: expectedVersion, Actor: actor, Source: source, RequestId: requestID})
|
|
if err != nil {
|
|
return 0, controlplanerpc.ClientError(err)
|
|
}
|
|
return response.Resource.Version, nil
|
|
}
|
|
|
|
func (c *Client) WatchWorkflowExecutionSettings(ctx context.Context, afterVersion int64) (<-chan AppliedSettings, error) {
|
|
stream, err := c.rpc.Watch(ctx, &pb.WatchRequest{Kind: WorkflowExecutionSettingsKind, AfterVersion: afterVersion})
|
|
if err != nil {
|
|
return nil, controlplanerpc.ClientError(err)
|
|
}
|
|
return watchUpdates(ctx, stream,
|
|
func(resource *pb.Resource) AppliedSettings {
|
|
settings, err := decodeSettings(resource.ValueJson)
|
|
return AppliedSettings{Settings: settings, Version: resource.Version, Err: err}
|
|
},
|
|
func(err error) AppliedSettings { return AppliedSettings{Err: err} }), nil
|
|
}
|
|
|
|
// AppliedResource carries a watched resource's version only, without its
|
|
// document. The kinds applied with it are applied by re-running the whole
|
|
// layering, which reads every kind back from the store, so the document the
|
|
// stream carries would be decoded and then thrown away; a stored value this
|
|
// build cannot read is reported by the layering that refuses it (with
|
|
// last-known-good kept), not by the watch.
|
|
type AppliedResource struct {
|
|
Version int64
|
|
Err error
|
|
}
|
|
|
|
// WatchResource streams version updates for any resource kind without
|
|
// decoding the document. It is the shape the runtime-resource watches read
|
|
// (archie-core-zfb0.1): keepWatch reconnects on it exactly as it does on a
|
|
// typed stream, and the resume point still moves past a document the client
|
|
// refused to decode -- the store answered with that version, and resuming
|
|
// before it would re-offer it on every reconnect.
|
|
func (c *Client) WatchResource(ctx context.Context, kind string, afterVersion int64) (<-chan AppliedResource, error) {
|
|
stream, err := c.rpc.Watch(ctx, &pb.WatchRequest{Kind: kind, AfterVersion: afterVersion})
|
|
if err != nil {
|
|
return nil, controlplanerpc.ClientError(err)
|
|
}
|
|
return watchUpdates(ctx, stream,
|
|
func(resource *pb.Resource) AppliedResource { return AppliedResource{Version: resource.Version} },
|
|
func(err error) AppliedResource { return AppliedResource{Err: err} }), nil
|
|
}
|
|
|
|
type AppliedSettings struct {
|
|
Settings workflow.ExecutionSettings
|
|
Version int64
|
|
Err error
|
|
}
|
|
|
|
func (c *Client) Personas(ctx context.Context) (agent.PersonaCollection, int64, error) {
|
|
response, err := c.rpc.Query(ctx, &pb.QueryRequest{Kind: PersonasKind})
|
|
if err != nil {
|
|
return agent.PersonaCollection{}, 0, controlplanerpc.ClientError(err)
|
|
}
|
|
collection, err := decodePersonas(response.Resource.ValueJson)
|
|
return collection, response.Resource.Version, err
|
|
}
|
|
|
|
type AppliedPersonas struct {
|
|
Collection agent.PersonaCollection
|
|
Version int64
|
|
Err error
|
|
}
|
|
|
|
func (c *Client) WatchPersonas(ctx context.Context, afterVersion int64) (<-chan AppliedPersonas, error) {
|
|
stream, err := c.rpc.Watch(ctx, &pb.WatchRequest{Kind: PersonasKind, AfterVersion: afterVersion})
|
|
if err != nil {
|
|
return nil, controlplanerpc.ClientError(err)
|
|
}
|
|
return watchUpdates(ctx, stream,
|
|
func(resource *pb.Resource) AppliedPersonas {
|
|
collection, err := decodePersonas(resource.ValueJson)
|
|
return AppliedPersonas{Collection: collection, Version: resource.Version, Err: err}
|
|
},
|
|
func(err error) AppliedPersonas { return AppliedPersonas{Err: err} }), nil
|
|
}
|
|
|
|
// watchUpdates turns one Watch stream into the channel a watch loop reads: every
|
|
// document the stream carries, decoded, and then a single update carrying the
|
|
// error that ended it -- unless the stream ended cleanly or the context did, in
|
|
// which case the channel just closes.
|
|
func watchUpdates[T any](
|
|
ctx context.Context,
|
|
stream grpc.ServerStreamingClient[pb.WatchResponse],
|
|
update func(resource *pb.Resource) T,
|
|
failed func(err error) T,
|
|
) <-chan T {
|
|
out := make(chan T)
|
|
go func() {
|
|
defer close(out)
|
|
for {
|
|
response, err := stream.Recv()
|
|
if err != nil {
|
|
if !errors.Is(err, io.EOF) && ctx.Err() == nil {
|
|
sendUpdate(ctx, out, failed(controlplanerpc.ClientError(err)))
|
|
}
|
|
return
|
|
}
|
|
if !sendUpdate(ctx, out, update(response.Resource)) {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return out
|
|
}
|
|
|
|
// sendUpdate hands update to the reader of one Watch stream, reporting false
|
|
// when ctx ended first. A reader leaves without draining what is left for it:
|
|
// the watch that reads these streams returns on cancellation, so a bare send
|
|
// parks this producer -- and the stream it holds -- for the rest of the
|
|
// process's life, one goroutine and one channel per kind at every exit. That
|
|
// coupling is load-bearing: the reader's prompt shutdown rests on this side
|
|
// stopping on the same context, and neither half is safe alone.
|
|
func sendUpdate[T any](ctx context.Context, out chan<- T, update T) bool {
|
|
select {
|
|
case out <- update:
|
|
return true
|
|
case <-ctx.Done():
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (c *Client) Schedules(ctx context.Context) ([]scheduling.JobSpec, int64, error) {
|
|
response, err := c.rpc.Query(ctx, &pb.QueryRequest{Kind: SchedulesKind})
|
|
if err != nil {
|
|
return nil, 0, controlplanerpc.ClientError(err)
|
|
}
|
|
var jobs []scheduling.JobSpec
|
|
if err := json.Unmarshal(response.Resource.ValueJson, &jobs); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return jobs, response.Resource.Version, nil
|
|
}
|
|
|
|
func (c *Client) ReplaceSchedules(ctx context.Context, jobs []scheduling.JobSpec, expectedVersion int64, actor, source, requestID string) (int64, error) {
|
|
value, err := json.Marshal(jobs)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
response, err := c.rpc.Command(ctx, &pb.CommandRequest{Kind: SchedulesKind, Command: "replace", ValueJson: value, ExpectedVersion: expectedVersion, Actor: actor, Source: source, RequestId: requestID})
|
|
if err != nil {
|
|
return 0, controlplanerpc.ClientError(err)
|
|
}
|
|
return response.Resource.Version, nil
|
|
}
|