211 lines
6.6 KiB
Go
211 lines
6.6 KiB
Go
package secretengine
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"maps"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/applystatus"
|
|
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
|
|
"github.com/samcharles93/archie-core/internal/secret"
|
|
)
|
|
|
|
// Source is what the runner reads.
|
|
type Source = extension.Source
|
|
|
|
// Runner keeps the enabled secret-engine extensions running and registered.
|
|
// An extension runs when its package is installed, its authority is accepted
|
|
// and the extension-settings resource enables it; the process sees only the
|
|
// environment variables the accepted authority names.
|
|
type Runner struct {
|
|
host *extension.Host
|
|
registry *secret.Registry
|
|
source Source
|
|
cacheDir string
|
|
log *slog.Logger
|
|
|
|
// report records the extension-settings version a sync applied, with its
|
|
// outcome. Nil reports nothing.
|
|
report func(ctx context.Context, version int64, err error)
|
|
|
|
// changed runs after a sync starts or stops an engine, so a service can
|
|
// resolve again the references that engine answers. Nil does nothing.
|
|
changed func()
|
|
|
|
mu sync.Mutex
|
|
running map[string]runningEngine
|
|
}
|
|
|
|
// OnChange makes every sync that starts or stops an engine call changed.
|
|
func (r *Runner) OnChange(changed func()) {
|
|
r.mu.Lock()
|
|
r.changed = changed
|
|
r.mu.Unlock()
|
|
}
|
|
|
|
type runningEngine struct {
|
|
digest string
|
|
settings string
|
|
}
|
|
|
|
// NewRunner returns a Runner that registers engines into registry and keeps
|
|
// extracted binaries under cacheDir.
|
|
func NewRunner(host *extension.Host, registry *secret.Registry, source Source, cacheDir string, log *slog.Logger) *Runner {
|
|
return &Runner{host: host, registry: registry, source: source, cacheDir: cacheDir, log: log, running: make(map[string]runningEngine)}
|
|
}
|
|
|
|
// ReportTo makes every sync record its outcome through report.
|
|
func (r *Runner) ReportTo(report func(ctx context.Context, version int64, err error)) {
|
|
r.report = report
|
|
}
|
|
|
|
// Run syncs every interval until ctx ends.
|
|
func (r *Runner) Run(ctx context.Context, interval time.Duration) {
|
|
ticker := time.NewTicker(interval)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
if err := r.Sync(ctx); err != nil {
|
|
r.log.WarnContext(ctx, "secret engine sync", "err", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sync starts the engines that should run and are not, restarts those whose
|
|
// package, settings or process changed, and stops the rest. It returns the
|
|
// problems it met; a failed engine does not stop the others.
|
|
func (r *Runner) Sync(ctx context.Context) error {
|
|
settings, version, err := r.source.Enabled(ctx)
|
|
if err == nil {
|
|
err = r.apply(ctx, settings)
|
|
}
|
|
if r.report != nil && version > 0 {
|
|
r.report(ctx, version, err)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc.ExtensionSetting) error {
|
|
installed, err := r.source.Packages.ListInstalled(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("list installed packages: %w", err)
|
|
}
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
before := r.runningDigests()
|
|
defer func() {
|
|
if r.changed != nil && !maps.Equal(before, r.runningDigests()) {
|
|
go r.changed()
|
|
}
|
|
}()
|
|
|
|
var problems []error
|
|
want := make(map[string]bool)
|
|
for _, pkg := range installed {
|
|
setting, ok := settings[pkg.Name]
|
|
if !ok || !setting.Enabled || pkg.AcceptedAuthority == nil || len(secretEngines(pkg.Descriptor)) == 0 {
|
|
continue
|
|
}
|
|
want[pkg.Name] = true
|
|
if err := r.ensure(ctx, pkg, setting); err != nil {
|
|
problems = append(problems, fmt.Errorf("secret engine %q: %w", pkg.Name, err))
|
|
}
|
|
}
|
|
for name := range r.running {
|
|
if want[name] {
|
|
continue
|
|
}
|
|
r.host.Stop(name)
|
|
r.registry.Unregister(name)
|
|
delete(r.running, name)
|
|
_ = os.RemoveAll(filepath.Join(r.cacheDir, name))
|
|
}
|
|
return errors.Join(problems...)
|
|
}
|
|
|
|
func (r *Runner) runningDigests() map[string]string {
|
|
out := make(map[string]string, len(r.running))
|
|
for name, engine := range r.running {
|
|
out[name] = engine.digest
|
|
}
|
|
return out
|
|
}
|
|
|
|
func secretEngines(d storepkg.Descriptor) []storepkg.Extension {
|
|
var out []storepkg.Extension
|
|
for _, extension := range d.Contributes.Extensions {
|
|
if extension.Surface == storepkg.SurfaceSecretEngine {
|
|
out = append(out, extension)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (r *Runner) ensure(ctx context.Context, pkg storepkg.Installed, setting controlplanerpc.ExtensionSetting) error {
|
|
encoded, err := json.Marshal(setting.Settings)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
have, running := r.running[pkg.Name]
|
|
current := running && have.digest == pkg.Digest && have.settings == string(encoded) && r.host.Alive(pkg.Name)
|
|
if current {
|
|
return nil
|
|
}
|
|
engines := secretEngines(pkg.Descriptor)
|
|
if len(engines) != 1 {
|
|
return fmt.Errorf("a package serves one secret engine, this one declares %d", len(engines))
|
|
}
|
|
binary, sum, err := extension.Materialize(ctx, r.source.Packages, r.cacheDir, pkg, engines[0].Path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
spec := extension.Spec{Name: pkg.Name, Path: binary, SHA256: sum, Env: slices.Clone(pkg.AcceptedAuthority.Env), Egress: slices.Clone(pkg.AcceptedAuthority.EgressHosts)}
|
|
engine, err := Start(ctx, r.host, spec, setting.Settings)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
engine.version = pkg.Descriptor.Version
|
|
r.registry.Register(engine)
|
|
r.running[pkg.Name] = runningEngine{digest: pkg.Digest, settings: string(encoded)}
|
|
return nil
|
|
}
|
|
|
|
// Close stops every running engine.
|
|
func (r *Runner) Close() { r.host.Close() }
|
|
|
|
// Supervise starts a Runner for process, runs its first sync before returning
|
|
// so the caller's next resolution can see the engines, and keeps syncing until
|
|
// ctx ends. A failed sync degrades references naming an extension engine and
|
|
// is retried each tick; it never stops the caller. The returned Runner's Close
|
|
// stops the engines.
|
|
func Supervise(ctx context.Context, registry *secret.Registry, source Source, process string, report func(ctx context.Context, version int64, err error), log *slog.Logger) *Runner {
|
|
cache, err := configuration.DefaultCacheDir()
|
|
if err != nil {
|
|
log.WarnContext(ctx, "secret engines unavailable: no cache directory", "err", err)
|
|
return &Runner{host: extension.NewHost(slog.New(slog.DiscardHandler))}
|
|
}
|
|
host := extension.NewHost(log)
|
|
runner := NewRunner(host, registry, source, filepath.Join(cache, "extensions", process), log)
|
|
runner.ReportTo(report)
|
|
if err := runner.Sync(ctx); err != nil {
|
|
log.WarnContext(ctx, "secret engines", "err", err)
|
|
}
|
|
go runner.Run(ctx, applystatus.RestampInterval)
|
|
return runner
|
|
}
|