Files
archie/internal/app/controlplane/runtime_config.go
T

239 lines
10 KiB
Go

package controlplane
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
)
// resourceReader is the one read the layering performs: a resource kind's value
// and the version it came from, or nothing at all when the store holds no value
// for that kind. The gRPC client and the in-process server both provide it, so
// "what the database covers in the running config" has exactly one
// implementation. The offline validate runs the same code as boot, which is the
// only way its verdict can be boot's verdict.
//
// found is false only for the reader that dials a live State Store: a kind with
// no stored value leaves the file document's value in effect instead of failing
// the process, which is the state a seed ImportConfig refused leaves behind
// (controlplane.Server.ImportConfig skips it) and the state of a database the
// migration has not reached yet. storeReader never reports absent -- it answers
// with the seed the State Store would write -- so the offline verdict stays
// boot's.
// RuntimeConfig applies restart-scoped database resources over bootstrap
// configuration. Values intentionally absent from a control-plane projection,
// such as secret-bearing MCP headers and channel update commands, remain
// bootstrap-owned.
//
// It also returns the version of each kind it read, so the process that
// layers them in can report which version it is running
// (docs/prds/control-plane-apply-status.md).
func (c *Client) RuntimeConfig(ctx context.Context, base config.Config) (config.Config, map[string]int64, error) {
return runtimeConfigFrom(ctx, c, base)
}
// RuntimeChatConfig layers the stored channel settings over the file document's
// chat section.
// StoredRuntimeConfig is RuntimeConfig's layering over the store this server
// owns, for a caller holding the database file rather than a connection to it.
// Boot layers the stored settings onto the file config and then runs
// configuration.Validate, so an offline check of that database has to make the
// same first move with the same implementation; called with the config the
// daemon would load, the result is the document boot decides on.
//
// A kind the store does not hold is read as the seed the State Store would
// write for it from base (see storeReader.query), because that store seeds
// every kind before it serves.
func (s *Server) StoredRuntimeConfig(ctx context.Context, base config.Config) (config.Config, map[string]int64, error) {
seeds, err := s.seededValues(base)
if err != nil {
return config.Config{}, nil, err
}
return runtimeConfigFrom(ctx, storeReader{resources: s.store, seeds: seeds}, base)
}
// storeReader reads the server's own store. It mirrors what the gRPC read
// answers -- a kind that is stored is the value and version it holds -- with
// one difference: a kind the store does not hold yet is the value the State
// Store seeds for it, since the daemon dials a store that has already run
// ImportConfig over the same config.
type storeReader struct {
resources ResourceStore
seeds map[string][]byte
}
func (r storeReader) Query(ctx context.Context, kind string, decode func([]byte) error) (int64, bool, error) {
resource, err := r.resources.Resource(ctx, kind)
if errors.Is(err, storecontract.ErrResourceNotFound) {
seed, ok := r.seeds[kind]
if !ok {
return 0, false, fmt.Errorf("read %s: %w", kind, storecontract.ErrResourceNotFound)
}
if err := decode(seed); err != nil {
return 0, false, fmt.Errorf("decode %s seed: %w", kind, err)
}
// No version: nothing has been stored for this kind, so nothing has
// been applied either. It is still a value to layer in -- the seed --
// which is why this reader never reports the kind absent.
return 0, true, nil
}
if err != nil {
return 0, false, fmt.Errorf("read %s: %w", kind, err)
}
if err := decode(resource.Value); err != nil {
return 0, false, fmt.Errorf("decode %s: %w", kind, err)
}
return resource.Version, true, nil
}
func runtimeConfigFrom(ctx context.Context, reader controlplanerpc.ResourceReader, base config.Config) (config.Config, map[string]int64, error) {
out := base.Clone()
versions := map[string]int64{}
if err := layerResource(ctx, reader, versions, ProviderSettingsKind, func(value []byte) error {
var providers map[string]providerDocument
if err := json.Unmarshal(value, &providers); err != nil {
return err
}
out.Providers = make(map[string]config.Provider, len(providers))
for name, provider := range providers {
if err := rejectBootDerivedProviderEnv(name, provider); err != nil {
return err
}
out.Providers[name] = config.Provider{Class: provider.Class, APIKeyEnv: provider.APIKeyEnv, APIKey: provider.APIKey, BaseURL: provider.BaseURL}
}
return nil
}); err != nil {
return config.Config{}, nil, err
}
if err := layerResourceJSON(ctx, reader, versions, ModelRoleAssignmentsKind, &out.Models); err != nil {
return config.Config{}, nil, err
}
if err := layerResourceJSON(ctx, reader, versions, RepositoryPoliciesKind, &out.Repos); err != nil {
return config.Config{}, nil, err
}
chat, chatVersion, err := controlplanerpc.RuntimeChatConfigFrom(ctx, reader, out.Chat)
if err != nil {
return config.Config{}, nil, err
}
out.Chat, versions[ChannelSettingsKind] = chat, chatVersion
if err := layerResource(ctx, reader, versions, SchedulingPolicyKind, func(value []byte) error {
var policy schedulingPolicy
if err := json.Unmarshal(value, &policy); err != nil {
return err
}
interval, err := time.ParseDuration(policy.PollInterval)
if err != nil {
return err
}
out.PollInterval, out.MaxRetries, out.Dispatch = config.Duration(interval), policy.MaxRetries, policy.Dispatch
// The label pairs with the trigger and layers with it: once the store
// carries one, it owns it, and the file can no longer drop the label a
// stored label-requiring trigger depends on. A policy stored before
// the field existed -- the nil the seed never produces -- leaves the
// file document's label in force, and boot's gate judges the pairing
// either way.
if policy.Label != nil {
out.Label = *policy.Label
}
return nil
}); err != nil {
return config.Config{}, nil, err
}
return runtimeToolConfigFrom(ctx, reader, versions, out)
}
func runtimeToolConfigFrom(ctx context.Context, reader controlplanerpc.ResourceReader, versions map[string]int64, out config.Config) (config.Config, map[string]int64, error) {
if err := layerResource(ctx, reader, versions, ToolSettingsKind, func(value []byte) error {
var settings toolSettings
if err := json.Unmarshal(value, &settings); err != nil {
return err
}
headers := make(map[string]map[string]string, len(out.Tools.MCPServers))
for _, server := range out.Tools.MCPServers {
headers[server.Name] = server.Headers
}
servers := make([]config.MCPServer, 0, len(settings.MCPServers))
for _, server := range settings.MCPServers {
servers = append(servers, config.MCPServer{
Name: server.Name,
Transport: server.Transport,
Command: server.Command,
Args: server.Args,
WorkDir: server.WorkDir,
URL: server.URL,
Headers: headers[server.Name],
SSEEndpoint: server.SSEEndpoint,
MessageEndpoint: server.MessageEndpoint,
ParallelToolCalls: server.ParallelToolCalls,
})
}
out.Tools = config.ToolsConfig{MCPServers: servers, Policy: settings.Policy, WebFetch: settings.WebFetch, Minimax: config.MinimaxConfig{Enabled: settings.Minimax.Enabled, APIKey: settings.Minimax.APIKey, BaseURL: settings.Minimax.BaseURL}}
return nil
}); err != nil {
return config.Config{}, nil, err
}
if err := layerResource(ctx, reader, versions, PluginSettingsKind, func(value []byte) error {
var settings pluginSettings
if err := json.Unmarshal(value, &settings); err != nil {
return err
}
out.PluginDir, out.ModuleDir, out.SecretEngineDir, out.SkillsDir = settings.PluginDir, settings.ModuleDir, settings.SecretEngineDir, settings.SkillsDir
return nil
}); err != nil {
return config.Config{}, nil, err
}
if err := layerResource(ctx, reader, versions, ContainerRuntimePoliciesKind, func(value []byte) error {
// A document that omits Profiles (one stored before they existed)
// inherits the file's. One that carries them replaces the file's:
// json.Unmarshal merges into an existing map, so without clearing it a
// profile deleted from the store would come back from the file.
var keys map[string]json.RawMessage
if err := json.Unmarshal(value, &keys); err != nil {
return err
}
if _, stored := keys["Profiles"]; stored {
out.Containers.Profiles = nil
}
return json.Unmarshal(value, &out.Containers)
}); err != nil {
return config.Config{}, nil, err
}
return out, versions, nil
}
// layerResource decodes a resource and records the version it came from, so the
// layering ends up holding the version of every kind it applied.
//
// A kind with no stored value is not an error and records no version: the file
// document's value stays in effect. That is the state a seed the resource
// validator refused leaves behind (controlplane.Server.ImportConfig skips it),
// and failing here instead would stop the process with a database-named error
// that editing config.toml cannot clear.
func layerResource(ctx context.Context, reader controlplanerpc.ResourceReader, versions map[string]int64, kind string, decode func([]byte) error) error {
version, found, err := reader.Query(ctx, kind, decode)
if err != nil {
return err
}
if found {
versions[kind] = version
}
return nil
}
func layerResourceJSON(ctx context.Context, reader controlplanerpc.ResourceReader, versions map[string]int64, kind string, target any) error {
return layerResource(ctx, reader, versions, kind, func(value []byte) error { return json.Unmarshal(value, target) })
}
// query returns the version of the resource it decoded, so callers that layer
// a resource in can report the version they applied. A kind the store holds no
// value for is reported as not found rather than as an error: the caller leaves
// the file document's value in effect (see resourceReader).