clawbot
bef9986542
All checks were successful
check / check (push) Successful in 3m3s
fx defaults to a 15s stop timeout and the Dockerfile sets no grace override, so Docker SIGKILLed at 10s and the bounded shutdown #130 built — including the log line that tells an operator a component is wedged — was unreachable in the image this repo produces. Sets fx.StopTimeout to 5s, and lowers the HTTP drain to 3s so a full-length drain no longer exhausts the whole sequence budget and skip every later hook, database close included. The Sentry flush, which runs in the same hook and honours no context, is clamped to the remaining stop budget less a 2s tail reserve, so a stalled flush drops Sentry events rather than the database close. Also fixes a latent coin flip in the shared stop-hook waiter, which reported "shutdown timed out" about half the time for a component that drained cleanly against an already-expired context. Independently reviewed three times. The final reviewer derived a stronger invariant than the implementation claims — the server hook's absolute end is bounded at stopTimeout minus the reserve regardless of drain length or of time consumed by preceding hooks — and confirmed the guard's 10ms sweep cannot step over the maximum, since both breakpoints land on its grid. Both Sentry probe arms, the docker stop demo and every mutation were reproduced independently. Known residual, filed separately: the HTTP drain itself is not clamped by the reserve, so slow preceding hooks can still jointly exhaust the budget. Demonstrated with a 2.2s sweeper delay.
114 lines
2.7 KiB
Go
114 lines
2.7 KiB
Go
package lifecycle_test
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"sneak.berlin/go/webhooker/internal/lifecycle"
|
|
)
|
|
|
|
// waitTimeout is the stop budget the timeout case gives a
|
|
// goroutine that never returns. The test's own patience is the
|
|
// go test deadline, so the only thing this value affects is how
|
|
// long the case takes.
|
|
const waitTimeout = 100 * time.Millisecond
|
|
|
|
func discardLogger() *slog.Logger {
|
|
return slog.New(slog.DiscardHandler)
|
|
}
|
|
|
|
func TestWaitForShutdown_DrainedGroup(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
wg.Go(func() {})
|
|
|
|
require.NoError(
|
|
t,
|
|
lifecycle.WaitForShutdown(
|
|
context.Background(), discardLogger(),
|
|
"test component", &wg,
|
|
),
|
|
)
|
|
}
|
|
|
|
// racePasses is how many times the both-cases-ready race is run.
|
|
// Without the preamble each pass is an independent coin flip, so
|
|
// the probability of the whole loop passing by luck is 2^-N: at
|
|
// this N the test is deterministic in practice, and it involves no
|
|
// wall-clock waiting at all.
|
|
const racePasses = 1000
|
|
|
|
// TestWaitDone_DrainedBeforeExpiredContext covers the case where a
|
|
// component drained cleanly but the stop context had already
|
|
// expired. Both select cases are ready, and Go chooses among ready
|
|
// cases uniformly at random, so the drained case must be settled by
|
|
// the preamble before the bounded select ever runs.
|
|
func TestWaitDone_DrainedBeforeExpiredContext(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
done := make(chan struct{})
|
|
close(done)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
|
|
for pass := range racePasses {
|
|
require.NoErrorf(
|
|
t,
|
|
lifecycle.WaitDone(
|
|
ctx, discardLogger(), "test component", done,
|
|
),
|
|
"pass %d reported a timeout for a drained component",
|
|
pass,
|
|
)
|
|
}
|
|
}
|
|
|
|
// TestWaitDone_ExpiredContext pins the other side of the preamble:
|
|
// an expired context with a component that has not drained is still
|
|
// a timeout.
|
|
func TestWaitDone_ExpiredContext(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
|
|
err := lifecycle.WaitDone(
|
|
ctx, discardLogger(), "test component",
|
|
make(chan struct{}),
|
|
)
|
|
|
|
require.ErrorIs(t, err, context.Canceled)
|
|
require.ErrorContains(t, err, "test component")
|
|
}
|
|
|
|
func TestWaitForShutdown_ContextExpires(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
release := make(chan struct{})
|
|
|
|
t.Cleanup(func() { close(release) })
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
wg.Go(func() { <-release })
|
|
|
|
ctx, cancel := context.WithTimeout(
|
|
context.Background(), waitTimeout,
|
|
)
|
|
defer cancel()
|
|
|
|
err := lifecycle.WaitForShutdown(
|
|
ctx, discardLogger(), "test component", &wg,
|
|
)
|
|
|
|
require.ErrorIs(t, err, context.DeadlineExceeded)
|
|
require.ErrorContains(t, err, "test component")
|
|
}
|