From 080707df48e0e7757d43a1a5bcbcae6cdd195ff4 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sat, 19 Sep 2026 02:00:23 +1000 Subject: [PATCH] fix(daemon): sweep the root forge alongside every identity The per-identity sweep skipped the root forge and root repo list whenever [[identities]] was configured, on the reasoning that Run never polls them there. Polling is not the only way a task reaches a repo: dispatchBinding enqueues with an empty identity, resolveBindingRepo falls back to the root repo list, and forgeFor/repoFor resolve an empty identity to the root forge and root repos. Root targets stay reachable in multi-identity mode, so they stay worth verifying at boot. Collapse both sweeps into one sweepAccess path over the root plus every identity. Each forge is swept in its own goroutine under its own deadline: Startup gates the gateways and the run loop and a forge client carries no request deadline, so warning on a failed sweep isolated a failing sibling but not a stalled one. Test is table-driven over single-identity, multi-identity, and an identity with no repos. --- internal/daemon/daemon.go | 80 ++++++++++------- internal/daemon/daemon_test.go | 153 +++++++++++++++++++++------------ 2 files changed, 149 insertions(+), 84 deletions(-) diff --git a/internal/daemon/daemon.go b/internal/daemon/daemon.go index 5c1853539..6ac79c1dc 100644 --- a/internal/daemon/daemon.go +++ b/internal/daemon/daemon.go @@ -260,42 +260,60 @@ func (d *Daemon) Startup(ctx context.Context) error { d.Log.Info("re-queued tasks left running by a previous daemon", "count", n) } - // Multi-identity mode sweeps each identity's own forge and repo list: - // Run takes runIdentities there and never polls the root forge/repos, so - // verifying the root repo list would warn about repos no task can target. - // Failures are isolated per identity (logged as warnings, never aborting - // a sibling's sweep), matching Run's failure-isolation intent. - if len(d.Identities) > 0 { - for _, id := range d.Identities { - d.sweepIdentity(ctx, id) - } - return nil - } - - if err := d.Forge.AcceptInvitations(ctx); err != nil { - d.Log.Warn("invitation sweep failed", "err", err) - } - for _, r := range d.Cfg.Get().Repos { - if err := d.Forge.VerifyPush(ctx, r.Owner, r.Name); err != nil { - d.Log.Warn("repo not pushable -- tasks from it will fail", "repo", r.FullName(), "err", err) - } - } + d.sweepAccess(ctx) return nil } -// sweepIdentity runs the boot-time invitation sweep and push verification -// for one identity's own forge and repo list. Failures are logged as -// warnings and never propagate, so one identity's forge outage cannot stop -// another identity's boot sweep. -func (d *Daemon) sweepIdentity(ctx context.Context, id *IdentityRunner) { - if err := id.Forge.AcceptInvitations(ctx); err != nil { - d.Log.Warn("invitation sweep failed", "identity", id.Name, "err", err) - } - for _, r := range id.Repos { - if err := id.Forge.VerifyPush(ctx, r.Owner, r.Name); err != nil { - d.Log.Warn("repo not pushable -- tasks from it will fail", "identity", id.Name, "repo", r.FullName(), "err", err) +// sweepTimeout bounds one forge's boot sweep. Startup gates the gateways and +// the run loop, and a forge client carries no request deadline of its own, so +// an unreachable host would otherwise hold boot open indefinitely. +const sweepTimeout = 2 * time.Minute + +// sweepAccess accepts pending invitations and verifies push access for the +// root forge and for every configured identity's forge. +// +// The root is swept even in multi-identity mode. Run takes runIdentities +// there and never polls the root repo list, but polling is not the only way a +// task reaches a repo: dispatchBinding enqueues with an empty identity and +// resolveBindingRepo falls back to the root repo list, and forgeFor/repoFor +// resolve an empty identity to the root forge and root repos. Root targets +// stay reachable, so they stay worth verifying; a deployment with no root +// forge configured gets the noop client, whose sweep is silent. +// +// Each forge is swept in its own goroutine under its own deadline, mirroring +// Run's goroutine-per-identity isolation. Warnings alone isolate a failing +// sibling; they do not isolate a stalled one. +func (d *Daemon) sweepAccess(ctx context.Context) { + sweep := func(identity string, fg forge.Forge, repos []config.Repo) { + log := d.Log + if identity != "" { + log = log.With("identity", identity) + } + ctx, cancel := context.WithTimeout(ctx, sweepTimeout) + defer cancel() + if err := fg.AcceptInvitations(ctx); err != nil { + log.Warn("invitation sweep failed", "err", err) + } + for _, r := range repos { + if err := fg.VerifyPush(ctx, r.Owner, r.Name); err != nil { + log.Warn("repo not pushable -- tasks from it will fail", "repo", r.FullName(), "err", err) + } } } + + var wg sync.WaitGroup + wg.Add(1 + len(d.Identities)) + go func() { + defer wg.Done() + sweep("", d.Forge, d.Cfg.Get().Repos) + }() + for _, id := range d.Identities { + go func() { + defer wg.Done() + sweep(id.Name, id.Forge, id.Repos) + }() + } + wg.Wait() } // Run polls until the context ends. When Identities is non-empty, each diff --git a/internal/daemon/daemon_test.go b/internal/daemon/daemon_test.go index 0c81b58bb..2ce250463 100644 --- a/internal/daemon/daemon_test.go +++ b/internal/daemon/daemon_test.go @@ -8,6 +8,7 @@ import ( "os" "slices" "strings" + "sync" "sync/atomic" "testing" "time" @@ -1337,84 +1338,130 @@ func TestRepoForPrefersOwningIdentityRepoList(t *testing.T) { } // sweepForge records invitation sweeps and push verifications so a test can -// assert Startup sweeps each identity's own forge and repos. It embeds -// testForge for the rest of the forge.Forge surface; those methods are -// unreachable from Startup. +// assert which forges Startup swept. It embeds testForge for the rest of the +// forge.Forge surface; those methods are unreachable from Startup. Startup +// sweeps every forge concurrently, so the recorders are mutex-guarded. type sweepForge struct { testForge + mu sync.Mutex invitations int verifiedRepos []string } func (f *sweepForge) AcceptInvitations(context.Context) error { + f.mu.Lock() + defer f.mu.Unlock() f.invitations++ return nil } func (f *sweepForge) VerifyPush(_ context.Context, owner, repo string) error { + f.mu.Lock() + defer f.mu.Unlock() f.verifiedRepos = append(f.verifiedRepos, owner+"/"+repo) return nil } -// TestStartupSweepsEveryIdentityForgeAndRepos pins the boot-time invitation -// sweep and push verification in multi-identity mode. Startup used to sweep -// only d.Forge and d.Cfg.Get().Repos, so per-identity invites were never -// accepted and per-identity repos never push-verified: a task from one of -// those repos would fail at dispatch instead of warning at boot. In -// multi-identity mode Run takes runIdentities and never polls the root repo -// list, so Startup must sweep each identity's own forge/repos and leave the -// root forge/repos alone (single-identity mode keeps the original root sweep). -func TestStartupSweepsEveryIdentityForgeAndRepos(t *testing.T) { - rootFg := &sweepForge{} - oneFg := &sweepForge{} - twoFg := &sweepForge{} +func (f *sweepForge) snapshot() (int, []string) { + f.mu.Lock() + defer f.mu.Unlock() + return f.invitations, slices.Clone(f.verifiedRepos) +} - d := &Daemon{ - Cfg: config.NewHolder(config.Config{ - Repos: []config.Repo{{Owner: "root", Name: "repo"}}, - }), - Store: store.OpenTest(t), - Forge: rootFg, - Log: slog.New(slog.DiscardHandler), - Identities: []*IdentityRunner{ - { - Name: "one", - Forge: oneFg, - Repos: []config.Repo{{Owner: "one", Name: "a"}}, +// TestStartupSweepsEveryConfiguredForge pins the boot-time invitation sweep +// and push verification. Startup used to sweep only d.Forge and +// d.Cfg.Get().Repos, so in multi-identity mode per-identity invites were +// never accepted and per-identity repos never push-verified: a task from one +// of those repos failed at dispatch instead of warning at boot. +// +// The root forge is swept in both modes. Run never polls the root repo list +// in multi-identity mode, but dispatchBinding enqueues with an empty identity +// against resolveBindingRepo's root-repo fallback, and forgeFor/repoFor +// resolve an empty identity to the root forge and root repos, so root targets +// stay reachable there. +func TestStartupSweepsEveryConfiguredForge(t *testing.T) { + type want struct { + invitations int + repos []string + } + tests := []struct { + name string + rootRepos []config.Repo + identities []config.Repo // one identity per entry, keyed by owner + wantRoot want + wantIDs []want + }{ + { + name: "single identity sweeps the root forge", + rootRepos: []config.Repo{{Owner: "root", Name: "repo"}}, + wantRoot: want{invitations: 1, repos: []string{"root/repo"}}, + }, + { + name: "multi identity sweeps the root forge and every identity", + rootRepos: []config.Repo{{Owner: "root", Name: "repo"}}, + identities: []config.Repo{ + {Owner: "one", Name: "a"}, + {Owner: "two", Name: "b"}, }, - { - Name: "two", - Forge: twoFg, - Repos: []config.Repo{{Owner: "two", Name: "b"}, {Owner: "two", Name: "c"}}, + wantRoot: want{invitations: 1, repos: []string{"root/repo"}}, + wantIDs: []want{ + {invitations: 1, repos: []string{"one/a"}}, + {invitations: 1, repos: []string{"two/b"}}, }, }, + { + name: "identity with no repos still gets its invitations swept", + rootRepos: nil, + identities: []config.Repo{ + {Owner: "one", Name: ""}, + }, + wantRoot: want{invitations: 1}, + wantIDs: []want{{invitations: 1}}, + }, } - if err := d.Startup(context.Background()); err != nil { - t.Fatalf("Startup: %v", err) - } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + rootFg := &sweepForge{} + idForges := make([]*sweepForge, len(tc.identities)) + runners := make([]*IdentityRunner, len(tc.identities)) + for i, r := range tc.identities { + idForges[i] = &sweepForge{} + runner := &IdentityRunner{Name: r.Owner, Forge: idForges[i]} + if r.Name != "" { + runner.Repos = []config.Repo{r} + } + runners[i] = runner + } - if oneFg.invitations != 1 { - t.Errorf("identity one AcceptInvitations = %d, want 1", oneFg.invitations) - } - if twoFg.invitations != 1 { - t.Errorf("identity two AcceptInvitations = %d, want 1", twoFg.invitations) - } - if got := oneFg.verifiedRepos; !slices.Equal(got, []string{"one/a"}) { - t.Errorf("identity one verified repos = %v, want [one/a]", got) - } - if got := twoFg.verifiedRepos; !slices.Equal(got, []string{"two/b", "two/c"}) { - t.Errorf("identity two verified repos = %v, want [two/b two/c]", got) - } + d := &Daemon{ + Cfg: config.NewHolder(config.Config{Repos: tc.rootRepos}), + Store: store.OpenTest(t), + Forge: rootFg, + Log: slog.New(slog.DiscardHandler), + Identities: runners, + } - // The root forge/repo list must not be swept in multi-identity mode: - // Run never polls it there, so verifying it would warn about repos no - // task can target. - if rootFg.invitations != 0 { - t.Errorf("root AcceptInvitations = %d, want 0 (root forge is not polled in multi-identity mode)", rootFg.invitations) + if err := d.Startup(context.Background()); err != nil { + t.Fatalf("Startup: %v", err) + } + + assertSwept(t, "root", rootFg, tc.wantRoot.invitations, tc.wantRoot.repos) + for i, w := range tc.wantIDs { + assertSwept(t, runners[i].Name, idForges[i], w.invitations, w.repos) + } + }) } - if len(rootFg.verifiedRepos) != 0 { - t.Errorf("root verified repos = %v, want none (root repo list is not polled in multi-identity mode)", rootFg.verifiedRepos) +} + +func assertSwept(t *testing.T, name string, fg *sweepForge, wantInvitations int, wantRepos []string) { + t.Helper() + invitations, repos := fg.snapshot() + if invitations != wantInvitations { + t.Errorf("%s AcceptInvitations = %d, want %d", name, invitations, wantInvitations) + } + if !slices.Equal(repos, wantRepos) { + t.Errorf("%s verified repos = %v, want %v", name, repos, wantRepos) } }