Skip to content

Commit 8c7b72d

Browse files
TMHSDigitalclaude
andcommitted
Probe -dry-run pool resolvers concurrently (#399)
Pool.Probe looked domain up on every member one after another, so each dead resolver cost a full timeout and a few hundred -r resolvers made a dry run take minutes per target. Probe now takes a worker count and runs up to min(-t, pool size) members at once, writing each result to its index so the output keeps pool order. Per-member rate caps and the -rate limiter still apply. A test with six stalled members checks the probe takes well under the serial time and keeps order. Fixes #399 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1 parent 49786cf commit 8c7b72d

3 files changed

Lines changed: 71 additions & 12 deletions

File tree

‎internal/cli/dryrun.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ func (s *session) dryRun() int {
123123
p.PreflightOK = preflightOK(outcome)
124124
failed = failed || !p.PreflightOK
125125
if s.in.pool != nil {
126-
for _, r := range s.in.pool.Probe(ctx, lookup, target) {
126+
for _, r := range s.in.pool.Probe(ctx, lookup, target, f.concurrency) {
127127
p.PoolPreflight = append(p.PoolPreflight, dryRunResolver{Addr: r.Addr, Preflight: r.Outcome.String(), OK: preflightOK(r.Outcome)})
128128
}
129129
}

‎internal/dns/pool.go‎

Lines changed: 26 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -488,18 +488,33 @@ type ProbeResult struct {
488488
Outcome Outcome
489489
}
490490

491-
// Probe looks domain up once on every member, in pool order, outside the
492-
// rotation and its accounting. Each lookup takes its slots of the member's
493-
// rate cap. -dry-run uses it as a per-resolver preflight (#376).
494-
func (p *Pool) Probe(ctx context.Context, l Lookup, domain string) []ProbeResult {
495-
out := make([]ProbeResult, 0, len(p.members))
496-
for _, m := range p.members {
497-
outcome := OutcomeCanceled
498-
if p.reserve(ctx, m, QueriesFor(l.Types)) == nil {
499-
_, outcome = m.lookup(l).Resolve(ctx, domain)
500-
}
501-
out = append(out, ProbeResult{Addr: m.Addr, Outcome: outcome})
491+
// Probe looks domain up once on every member, outside the rotation and its
492+
// accounting, and returns the results in pool order. Each lookup takes its
493+
// slots of the member's rate cap. Up to workers members are probed at once,
494+
// so dead members cost about one timeout in all rather than one each (#399).
495+
// -dry-run uses it as a per-resolver preflight (#376).
496+
func (p *Pool) Probe(ctx context.Context, l Lookup, domain string, workers int) []ProbeResult {
497+
out := make([]ProbeResult, len(p.members))
498+
workers = max(min(workers, len(p.members)), 1)
499+
next := make(chan int)
500+
var wg sync.WaitGroup
501+
for range workers {
502+
wg.Go(func() {
503+
for i := range next {
504+
m := p.members[i]
505+
outcome := OutcomeCanceled
506+
if p.reserve(ctx, m, QueriesFor(l.Types)) == nil {
507+
_, outcome = m.lookup(l).Resolve(ctx, domain)
508+
}
509+
out[i] = ProbeResult{Addr: m.Addr, Outcome: outcome}
510+
}
511+
})
512+
}
513+
for i := range p.members {
514+
next <- i
502515
}
516+
close(next)
517+
wg.Wait()
503518
return out
504519
}
505520

‎internal/dns/pool_test.go‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -163,6 +163,50 @@ func TestPoolReservesWireQueries(t *testing.T) {
163163
}
164164
}
165165

166+
// TestPoolProbeRunsMembersConcurrently covers #399: stalled members are
167+
// probed side by side, so a probe costs about one timeout rather than one
168+
// per dead member, and the results stay in pool order.
169+
func TestPoolProbeRunsMembersConcurrently(t *testing.T) {
170+
srv := startTestDNS(t, map[string]testReply{"example.com": {A: "192.0.2.10"}})
171+
const dead = 6
172+
addrs := make([]string, 0, dead+1)
173+
for range dead {
174+
addrs = append(addrs, startBlackHole(t))
175+
}
176+
addrs = append(addrs, srv.addr)
177+
timeout := time.Second
178+
p := NewPool(addrs, timeout)
179+
defer p.CloseIdleConnections()
180+
181+
start := time.Now()
182+
got := p.Probe(context.Background(), Lookup{Timeout: timeout, Attempts: 1, Types: []string{"A"}}, "example.com", len(addrs))
183+
// Serially the dead members alone would take dead*timeout (6s).
184+
if elapsed := time.Since(start); elapsed > dead*timeout/2 {
185+
t.Fatalf("probe took %v; members were not probed concurrently", elapsed)
186+
}
187+
if len(got) != len(addrs) {
188+
t.Fatalf("got %d results, want %d", len(got), len(addrs))
189+
}
190+
for i, r := range got {
191+
want := OutcomeTimeout
192+
if i == dead {
193+
want = OutcomeFound
194+
}
195+
if r.Addr != addrs[i] || r.Outcome != want {
196+
t.Errorf("result %d = %s %v, want %s %v", i, r.Addr, r.Outcome, addrs[i], want)
197+
}
198+
}
199+
200+
// One worker still probes every member, in order.
201+
one := NewPool([]string{srv.addr, srv.addr}, timeout)
202+
defer one.CloseIdleConnections()
203+
for i, r := range one.Probe(context.Background(), Lookup{Timeout: timeout, Attempts: 1, Types: []string{"A"}}, "example.com", 0) {
204+
if r.Outcome != OutcomeFound {
205+
t.Errorf("single-worker result %d = %v, want found", i, r.Outcome)
206+
}
207+
}
208+
}
209+
166210
// TestPoolRatePerResolver drives the per-resolver cap (#196) on a fake clock:
167211
// lookups go to members with room first, wait for the one that frees up
168212
// soonest when every cap is spent, and count each spent cap as throttled.

0 commit comments

Comments
 (0)