Archie runs its own agent loop only. Removes Kit resolution and launch, the harness runner and adapters, the setup terminal and sandbox view, harness secrets and OAuth capture (table dropped in migration 0075), the task-tools contract that only Kit containers reached, and the sandbox-kit-spec dependency. Agent profiles carry image and tools only. The egress proxy keeps the model-session path; the sandbox relay code stays for #1867.
116 lines
3.9 KiB
Go
116 lines
3.9 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
// Service contexts. The context decides which addresses a service must end up
|
|
// with: a process that owns a service needs a listen address, and a process
|
|
// that dials one needs a target.
|
|
const (
|
|
// ServiceClient is dialled but not hosted by this repository.
|
|
ServiceClient = "client"
|
|
// ServiceServer is hosted but not dialled.
|
|
ServiceServer = "server"
|
|
// ServiceBoth is hosted by one of our processes and dialled by others.
|
|
ServiceBoth = "both"
|
|
)
|
|
|
|
// ServiceSpec declares one service: name and default addresses.
|
|
type ServiceSpec struct {
|
|
// Context is ServiceClient, ServiceServer, or ServiceBoth.
|
|
Context string
|
|
// Name is the [services.<name>] section and the key callers look up.
|
|
Name string
|
|
// Target is the default dial address. Empty means there is no default
|
|
// and the operator must supply one, which is how "services.state.target
|
|
// is required" is stated without a branch that names the service.
|
|
Target string
|
|
// Listen is the default bind address for the process that owns the
|
|
// service. It is never empty for a hosted service: an empty address
|
|
// reaches net.Listen as "any free port", silently moving the service
|
|
// off the address its clients dial.
|
|
Listen string
|
|
}
|
|
|
|
// Registered service names. They live beside the registrations below so the
|
|
// spelling a consumer looks up and the spelling that was registered are the
|
|
// same token, not two string literals that a typo can separate.
|
|
const (
|
|
ServiceNameGateway = "gateway"
|
|
ServiceNameState = "state"
|
|
ServiceNameMessaging = "messaging"
|
|
ServiceNameDaemon = "daemon"
|
|
)
|
|
|
|
var (
|
|
serviceRegistryMu sync.RWMutex
|
|
serviceRegistry = map[string]ServiceSpec{}
|
|
)
|
|
|
|
// RegisterService declares one service, replacing any existing spec of that
|
|
// name. It panics on an invalid registration.
|
|
func RegisterService(context, name, target, listen string) {
|
|
switch context {
|
|
case ServiceClient, ServiceServer, ServiceBoth:
|
|
default:
|
|
panic(fmt.Sprintf(
|
|
"config.RegisterService(%q): unknown context %q, want %q, %q or %q",
|
|
name, context, ServiceClient, ServiceServer, ServiceBoth,
|
|
))
|
|
}
|
|
if context != ServiceClient && strings.TrimSpace(listen) == "" {
|
|
panic(fmt.Sprintf(
|
|
"config.RegisterService(%q): a %q service needs a default listen address; "+
|
|
"an empty one reaches net.Listen as \"any free port\"",
|
|
name, context,
|
|
))
|
|
}
|
|
serviceRegistryMu.Lock()
|
|
defer serviceRegistryMu.Unlock()
|
|
serviceRegistry[name] = ServiceSpec{
|
|
Context: context,
|
|
Name: name,
|
|
Target: target,
|
|
Listen: listen,
|
|
}
|
|
}
|
|
|
|
// LookupService returns the spec registered for name. The registry is the
|
|
// authority on which service names exist, which is what lets the loader still
|
|
// report a typo'd [services.gatway] once Services is a map that would
|
|
// otherwise decode any section at all.
|
|
func LookupService(name string) (ServiceSpec, bool) {
|
|
serviceRegistryMu.RLock()
|
|
defer serviceRegistryMu.RUnlock()
|
|
spec, ok := serviceRegistry[name]
|
|
return spec, ok
|
|
}
|
|
|
|
// RegisteredServices returns every spec, ordered by name so defaulting and
|
|
// validation run in a stable order regardless of map iteration.
|
|
func RegisteredServices() []ServiceSpec {
|
|
serviceRegistryMu.RLock()
|
|
defer serviceRegistryMu.RUnlock()
|
|
out := make([]ServiceSpec, 0, len(serviceRegistry))
|
|
for _, spec := range serviceRegistry {
|
|
out = append(out, spec)
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
|
|
return out
|
|
}
|
|
|
|
func init() {
|
|
// The services this repository ships. Everything that differs
|
|
// between them is an argument here, not a branch somewhere else: the
|
|
// gateway's target is defaulted while the State Store's is supplied by
|
|
// the operator.
|
|
RegisterService(ServiceBoth, ServiceNameGateway, "127.0.0.1:8585", "127.0.0.1:8585")
|
|
RegisterService(ServiceClient, ServiceNameState, "", "127.0.0.1:9090")
|
|
RegisterService(ServiceBoth, ServiceNameMessaging, "127.0.0.1:8586", "127.0.0.1:8586")
|
|
RegisterService(ServiceBoth, ServiceNameDaemon, "127.0.0.1:8587", "127.0.0.1:8587")
|
|
}
|