From bcc72f833dacaecce5696be82d184002cecec23d Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Thu, 8 Oct 2026 01:34:55 +1100 Subject: [PATCH] fix(gateway): providers resolve again when a secret engine starts after boot --- internal/app/archiegateway/server.go | 12 ++++++++- .../infrastructure/secretengine/runner.go | 26 +++++++++++++++++++ .../secretengine/runner_test.go | 19 ++++++++++++++ 3 files changed, 56 insertions(+), 1 deletion(-) diff --git a/internal/app/archiegateway/server.go b/internal/app/archiegateway/server.go index 2279e55fb..e617ccd84 100644 --- a/internal/app/archiegateway/server.go +++ b/internal/app/archiegateway/server.go @@ -64,6 +64,7 @@ type server struct { taskLogs *logging.TaskRegistry secrets *secret.Registry + engines *secretengine.Runner stateStore *staterpc.Client controlPlane *controlplane.Client applyStatus *applystatus.Reporter @@ -191,7 +192,8 @@ func (b *server) openState(ctx context.Context) error { report := func(ctx context.Context, version int64, err error) { b.applyStatus.Report(ctx, controlplanerpc.ExtensionSettingsKind, version, err) } - b.addCleanup(secretengine.Supervise(ctx, b.secrets, source, applystatus.Gateway, report, b.log).Close) + b.engines = secretengine.Supervise(ctx, b.secrets, source, applystatus.Gateway, report, b.log) + b.addCleanup(b.engines.Close) cfg, versions, err := b.runtimeConfig(ctx, b.cfg) if err != nil { return fmt.Errorf("load runtime settings: %w", err) @@ -286,6 +288,14 @@ var gatewayRuntimeKinds = []string{ } func (b *server) startRuntimeWatches(ctx context.Context) error { + // An engine that starts after boot answers references that failed then, so + // the providers resolve again. + b.engines.OnChange(func() { + base := b.cfgHolder.Get() + catalog, _ := b.catalogState() + modelcatalog.Apply(&base, catalog) + _ = b.relayer(ctx, base, controlplane.ProviderSettingsKind) + }) for _, kind := range gatewayRuntimeKinds { updates, err := b.controlPlane.WatchResource(ctx, kind, b.runtimeVersions[kind]) if err != nil { diff --git a/internal/infrastructure/secretengine/runner.go b/internal/infrastructure/secretengine/runner.go index 9e86d3385..c606e9d7a 100644 --- a/internal/infrastructure/secretengine/runner.go +++ b/internal/infrastructure/secretengine/runner.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "log/slog" + "maps" "os" "path/filepath" "slices" @@ -39,10 +40,21 @@ type Runner struct { // 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 @@ -96,6 +108,12 @@ func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc. } 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) @@ -121,6 +139,14 @@ func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc. 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 { diff --git a/internal/infrastructure/secretengine/runner_test.go b/internal/infrastructure/secretengine/runner_test.go index f7c92cb1a..0f84b2614 100644 --- a/internal/infrastructure/secretengine/runner_test.go +++ b/internal/infrastructure/secretengine/runner_test.go @@ -259,6 +259,16 @@ func TestRunnerRunsOnlyWhatIsAcceptedAndEnabled(t *testing.T) { runner := NewRunner(host, registry, Source{Query: source, Packages: source}, t.TempDir(), slog.New(slog.DiscardHandler)) t.Cleanup(runner.Close) ctx := context.Background() + changes := make(chan struct{}, 4) + runner.OnChange(func() { changes <- struct{}{} }) + changed := func() bool { + select { + case <-changes: + return true + case <-time.After(time.Second): + return false + } + } registered := func() bool { _, ok := registry.Get("echo"); return ok } sync := func() { @@ -273,6 +283,9 @@ func TestRunnerRunsOnlyWhatIsAcceptedAndEnabled(t *testing.T) { if registered() { t.Fatal("an extension whose authority was never accepted must not run") } + if len(changes) > 0 { + t.Fatal("a sync that started nothing must not report a change") + } source.pkg.AcceptedAuthority = &storepkg.Authority{} sync() @@ -280,10 +293,16 @@ func TestRunnerRunsOnlyWhatIsAcceptedAndEnabled(t *testing.T) { if err != nil || got != "v" { t.Fatalf("accepted and enabled: Resolve = %q, %v; want v", got, err) } + if !changed() { + t.Fatal("starting an engine must report a change, so references resolve again") + } source.settings.Extensions[0].Enabled = false sync() if registered() || host.Alive("echo") { t.Fatal("a disabled extension must be unregistered and its process stopped") } + if !changed() { + t.Fatal("stopping an engine must report a change") + } }