Re-vendor the shared files from sneak/prompts at 0653579 (closes #52)

Takes .golangci.yml, .dockerignore, .gitignore, .editorconfig, the
workflow and REPO_POLICIES.md from sneak/prompts 0653579, with this
repository's own entries after the shared content. Lint (golangci-lint
v2.14.0) and test are Dockerfile phases that script/lint and script/test
build alone with a new CACHEBUST value, keeping Go's and golangci-lint's
caches; the image build depends on both. make fmt and make fmt-check also
format the markdown with prettier, pinned in yarn.lock. The agent
guidance moves to AGENTS.md. The Go code is fixed for what the new
configuration finds, and the AS and prefix detail reads now return the
rows' error after their loops.

Model: opus-5-5

internal/routewatch/app.go

@@ -1,10 +1,13 @@
-// Package routewatch contains the primary RouteWatch type that represents a running instance
-// of the application and contains pointers to its core dependencies, and is responsible for initialization.
+// Package routewatch contains the primary RouteWatch type that represents a
+// running instance of the application and contains pointers to its core
+// dependencies, and is responsible for initialization. It also contains the
+// ASN WHOIS fetcher for background updates and the database maintainer for
+// background maintenance tasks.
 package routewatch
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"sync"
 	"time"
 
@@ -18,6 +21,10 @@ import (
 	"go.uber.org/fx"
 )
 
+// errNonBatchedNotImplemented is returned by Run when batched database writes
+// are disabled, since only the batched handlers exist.
+var errNonBatchedNotImplemented = errors.New("non-batched handlers not implemented")
+
 // Dependencies contains all dependencies for RouteWatch
 type Dependencies struct {
 	fx.In
@@ -68,8 +75,10 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 	// Apply runtime limit if specified
 	if rw.maxRuntime > 0 {
 		var cancel context.CancelFunc
+
 		ctx, cancel = context.WithTimeout(ctx, rw.maxRuntime)
 		defer cancel()
+
 		rw.logger.Info("Running with time limit", "max_runtime", rw.maxRuntime)
 	}
 
@@ -96,29 +105,31 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 		// Non-batched handlers not implemented yet
 		rw.logger.Error("Non-batched handlers not implemented")
 
-		return fmt.Errorf("non-batched handlers not implemented")
+		return errNonBatchedNotImplemented
 	}
 
 	// No longer need routing table handler - PrefixHandler maintains live_routes table
 
 	// Start streaming
-	if err := rw.streamer.Start(); err != nil {
+	err := rw.streamer.Start(ctx)
+	if err != nil {
 		return err
 	}
 
 	// Start HTTP server
-	if err := rw.server.Start(); err != nil {
+	err = rw.server.Start(ctx)
+	if err != nil {
 		return err
 	}
 
 	// Start ASN WHOIS fetcher for background updates
 	rw.asnFetcher = NewASNFetcher(rw.db, rw.logger.Logger)
-	rw.asnFetcher.Start()
+	rw.asnFetcher.Start(ctx)
 	rw.server.SetASNFetcher(rw.asnFetcher)
 
 	// Start database maintenance goroutine
 	rw.dbMaintainer = NewDBMaintainer(rw.db, rw.logger.Logger)
-	rw.dbMaintainer.Start()
+	rw.dbMaintainer.Start(ctx)
 
 	// Wait for context cancellation
 	<-ctx.Done()
@@ -127,13 +138,14 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 }
 
 // Shutdown performs graceful shutdown of all services
-func (rw *RouteWatch) Shutdown() {
+func (rw *RouteWatch) Shutdown(ctx context.Context) {
 	rw.mu.Lock()
 	if rw.shutdown {
 		rw.mu.Unlock()
 
 		return
 	}
+
 	rw.shutdown = true
 	rw.mu.Unlock()
 
@@ -142,14 +154,17 @@ func (rw *RouteWatch) Shutdown() {
 		rw.logger.Info("Flushing database handler")
 		rw.dbHandler.Stop()
 	}
+
 	if rw.peerHandler != nil {
 		rw.logger.Info("Flushing peer handler")
 		rw.peerHandler.Stop()
 	}
+
 	if rw.prefixHandler != nil {
 		rw.logger.Info("Flushing prefix handler")
 		rw.prefixHandler.Stop()
 	}
+
 	if rw.peeringHandler != nil {
 		rw.logger.Info("Flushing peering handler")
 		rw.peeringHandler.Stop()
@@ -168,11 +183,15 @@ func (rw *RouteWatch) Shutdown() {
 	// Stop services
 	rw.streamer.Stop()
 
-	// Stop HTTP server with a timeout
+	// Stop HTTP server with a timeout of its own, however much of ctx is left
 	const serverStopTimeout = 5 * time.Second
-	stopCtx, cancel := context.WithTimeout(context.Background(), serverStopTimeout)
+
+	stopCtx, cancel := context.WithTimeout(
+		context.WithoutCancel(ctx), serverStopTimeout)
 	defer cancel()
-	if err := rw.server.Stop(stopCtx); err != nil {
+
+	err := rw.server.Stop(stopCtx)
+	if err != nil {
 		rw.logger.Error("Failed to stop HTTP server gracefully", "error", err)
 	}
 
@@ -185,12 +204,11 @@ func (rw *RouteWatch) Shutdown() {
 		"bits_per_sec", metrics.BitsPerSec,
 		"duration", time.Since(metrics.ConnectedSince),
 	)
-
 }
 
 // getModule provides all fx dependencies
-func getModule() fx.Option {
-	return fx.Options(
+func getModule() []fx.Option {
+	return []fx.Option{
 		fx.Provide(
 			logger.New,
 			config.New,
@@ -203,5 +221,5 @@ func getModule() fx.Option {
 			server.New,
 			New,
 		),
-	)
+	}
 }

internal/routewatch/app_integration_internal_test.go

@@ -50,7 +50,9 @@ func newMockStore() *mockStore {
 }
 
 // GetOrCreateASN mock implementation
-func (m *mockStore) GetOrCreateASN(number int, timestamp time.Time) (*database.ASN, error) {
+func (m *mockStore) GetOrCreateASN(
+	number int, timestamp time.Time,
+) (*database.ASN, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -99,11 +101,14 @@ func (m *mockStore) UpdatePrefixesBatch(prefixes map[string]time.Time) error {
 			}
 		}
 	}
+
 	return nil
 }
 
 // GetOrCreatePrefix mock implementation
-func (m *mockStore) GetOrCreatePrefix(prefix string, timestamp time.Time) (*database.Prefix, error) {
+func (m *mockStore) GetOrCreatePrefix(
+	prefix string, timestamp time.Time,
+) (*database.Prefix, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -168,7 +173,7 @@ func (m *mockStore) RecordPeering(asA, asB int, _ time.Time) error {
 }
 
 // UpdatePeer mock implementation
-func (m *mockStore) UpdatePeer(peerIP string, peerASN int, messageType string, timestamp time.Time) error {
+func (m *mockStore) UpdatePeer(_ string, _ int, _ string, _ time.Time) error {
 	// Simple mock - just return nil
 	return nil
 }
@@ -194,41 +199,45 @@ func (m *mockStore) GetStats() (database.Stats, error) {
 }
 
 // GetStatsContext returns statistics about the mock store with context support
-func (m *mockStore) GetStatsContext(ctx context.Context) (database.Stats, error) {
+func (m *mockStore) GetStatsContext(_ context.Context) (database.Stats, error) {
 	return m.GetStats()
 }
 
 // UpsertLiveRoute mock implementation
-func (m *mockStore) UpsertLiveRoute(route *database.LiveRoute) error {
+func (m *mockStore) UpsertLiveRoute(_ *database.LiveRoute) error {
 	// Simple mock - just return nil
 	return nil
 }
 
 // DeleteLiveRoute mock implementation
-func (m *mockStore) DeleteLiveRoute(prefix, peerIP string) error {
+func (m *mockStore) DeleteLiveRoute(_, _ string) error {
 	// Simple mock - just return nil
 	return nil
 }
 
 // GetPrefixDistribution mock implementation
-func (m *mockStore) GetPrefixDistribution() (ipv4 []database.PrefixDistribution, ipv6 []database.PrefixDistribution, err error) {
+func (m *mockStore) GetPrefixDistribution() (
+	[]database.PrefixDistribution, []database.PrefixDistribution, error,
+) {
 	// Return empty distributions for now
 	return nil, nil, nil
 }
 
 // GetPrefixDistributionContext mock implementation with context support
-func (m *mockStore) GetPrefixDistributionContext(ctx context.Context) (ipv4 []database.PrefixDistribution, ipv6 []database.PrefixDistribution, err error) {
+func (m *mockStore) GetPrefixDistributionContext(_ context.Context) (
+	[]database.PrefixDistribution, []database.PrefixDistribution, error,
+) {
 	return m.GetPrefixDistribution()
 }
 
 // GetLiveRouteCounts mock implementation
-func (m *mockStore) GetLiveRouteCounts() (ipv4Count, ipv6Count int, err error) {
+func (m *mockStore) GetLiveRouteCounts() (int, int, error) {
 	// Return mock counts
 	return m.RouteCount / 2, m.RouteCount / 2, nil
 }
 
 // GetLiveRouteCountsContext mock implementation with context support
-func (m *mockStore) GetLiveRouteCountsContext(ctx context.Context) (ipv4Count, ipv6Count int, err error) {
+func (m *mockStore) GetLiveRouteCountsContext(_ context.Context) (int, int, error) {
 	return m.GetLiveRouteCounts()
 }
 
@@ -247,41 +256,51 @@ func (m *mockStore) GetASDetails(asn int) (*database.ASN, []database.LiveRoute,
 }
 
 // GetASDetailsContext mock implementation with context support
-func (m *mockStore) GetASDetailsContext(ctx context.Context, asn int) (*database.ASN, []database.LiveRoute, error) {
+func (m *mockStore) GetASDetailsContext(
+	_ context.Context, asn int,
+) (*database.ASN, []database.LiveRoute, error) {
 	return m.GetASDetails(asn)
 }
 
 // GetPrefixDetails mock implementation
-func (m *mockStore) GetPrefixDetails(prefix string) ([]database.LiveRoute, map[int]database.ASN, error) {
+func (m *mockStore) GetPrefixDetails(
+	_ string,
+) ([]database.LiveRoute, map[int]database.ASN, error) {
 	// Return empty routes for now
 	return []database.LiveRoute{}, map[int]database.ASN{}, nil
 }
 
 // GetPrefixDetailsContext mock implementation with context support
 func (m *mockStore) GetPrefixDetailsContext(
-	ctx context.Context, prefix string,
+	_ context.Context, prefix string,
 ) ([]database.LiveRoute, map[int]database.ASN, error) {
 	return m.GetPrefixDetails(prefix)
 }
 
-func (m *mockStore) GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]database.LiveRoute, error) {
+func (m *mockStore) GetRandomPrefixesByLength(
+	_, _, _ int,
+) ([]database.LiveRoute, error) {
 	// Return empty routes for now
 	return []database.LiveRoute{}, nil
 }
 
 // GetRandomPrefixesByLengthContext mock implementation with context support
-func (m *mockStore) GetRandomPrefixesByLengthContext(ctx context.Context, maskLength, ipVersion, limit int) ([]database.LiveRoute, error) {
+func (m *mockStore) GetRandomPrefixesByLengthContext(
+	_ context.Context, maskLength, ipVersion, limit int,
+) ([]database.LiveRoute, error) {
 	return m.GetRandomPrefixesByLength(maskLength, ipVersion, limit)
 }
 
 // GetASPeers mock implementation
-func (m *mockStore) GetASPeers(asn int) ([]database.ASPeer, error) {
+func (m *mockStore) GetASPeers(_ int) ([]database.ASPeer, error) {
 	// Return empty peers for now
 	return []database.ASPeer{}, nil
 }
 
 // GetASPeersContext mock implementation with context support
-func (m *mockStore) GetASPeersContext(ctx context.Context, asn int) ([]database.ASPeer, error) {
+func (m *mockStore) GetASPeersContext(
+	_ context.Context, asn int,
+) ([]database.ASPeer, error) {
 	return m.GetASPeers(asn)
 }
 
@@ -291,8 +310,11 @@ func (m *mockStore) GetIPInfo(ip string) (*database.IPInfo, error) {
 }
 
 // GetIPInfoContext mock implementation with context support
-func (m *mockStore) GetIPInfoContext(ctx context.Context, ip string) (*database.IPInfo, error) {
+func (m *mockStore) GetIPInfoContext(
+	_ context.Context, ip string,
+) (*database.IPInfo, error) {
 	now := time.Now()
+
 	return &database.IPInfo{
 		IP:          ip,
 		Netblock:    "8.8.8.0/24",
@@ -309,17 +331,21 @@ func (m *mockStore) GetIPInfoContext(ctx context.Context, ip string) (*database.
 }
 
 // GetNextStaleASN mock implementation
-func (m *mockStore) GetNextStaleASN(ctx context.Context, staleThreshold time.Duration) (int, error) {
+func (m *mockStore) GetNextStaleASN(_ context.Context, _ time.Duration) (int, error) {
 	return 0, database.ErrNoStaleASN
 }
 
 // UpdateASNWHOIS mock implementation
-func (m *mockStore) UpdateASNWHOIS(ctx context.Context, update *database.ASNWHOISUpdate) error {
+func (m *mockStore) UpdateASNWHOIS(
+	_ context.Context, _ *database.ASNWHOISUpdate,
+) error {
 	return nil
 }
 
 // GetWHOISStats mock implementation
-func (m *mockStore) GetWHOISStats(ctx context.Context, staleThreshold time.Duration) (*database.WHOISStats, error) {
+func (m *mockStore) GetWHOISStats(
+	_ context.Context, _ time.Duration,
+) (*database.WHOISStats, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -347,25 +373,28 @@ func (m *mockStore) UpsertLiveRouteBatch(routes []*database.LiveRoute) error {
 				LastSeen:  route.LastUpdated,
 			}
 			m.PrefixCount++
+
 			if route.IPVersion == 4 {
 				m.IPv4Prefixes++
 			} else {
 				m.IPv6Prefixes++
 			}
 		}
+
 		m.RouteCount++
 	}
+
 	return nil
 }
 
 // DeleteLiveRouteBatch mock implementation
-func (m *mockStore) DeleteLiveRouteBatch(deletions []database.LiveRouteDeletion) error {
+func (m *mockStore) DeleteLiveRouteBatch(_ []database.LiveRouteDeletion) error {
 	// Simple mock - just return nil
 	return nil
 }
 
 // DeleteLiveRoutesOfPeer mock implementation
-func (m *mockStore) DeleteLiveRoutesOfPeer(peerIP string) (int, error) {
+func (m *mockStore) DeleteLiveRoutesOfPeer(_ string) (int, error) {
 	// Simple mock - deletes nothing
 	return 0, nil
 }
@@ -385,43 +414,53 @@ func (m *mockStore) GetOrCreateASNBatch(asns map[int]time.Time) error {
 			m.ASNCount++
 		}
 	}
+
 	return nil
 }
 
 // UpdatePeerBatch mock implementation
-func (m *mockStore) UpdatePeerBatch(peers map[string]database.PeerUpdate) error {
+func (m *mockStore) UpdatePeerBatch(_ map[string]database.PeerUpdate) error {
 	// Simple mock - just return nil
 	return nil
 }
 
 // Vacuum mock implementation
-func (m *mockStore) Vacuum(ctx context.Context) error {
+func (m *mockStore) Vacuum(_ context.Context) error {
 	return nil
 }
 
 // Analyze mock implementation
-func (m *mockStore) Analyze(ctx context.Context) error {
+func (m *mockStore) Analyze(_ context.Context) error {
 	return nil
 }
 
 // Checkpoint mock implementation
-func (m *mockStore) Checkpoint(ctx context.Context) error {
+func (m *mockStore) Checkpoint(_ context.Context) error {
 	return nil
 }
 
 // Ping mock implementation
-func (m *mockStore) Ping(ctx context.Context) error {
+func (m *mockStore) Ping(_ context.Context) error {
 	return nil
 }
 
 func TestRouteWatchLiveFeed(t *testing.T) {
+	t.Parallel()
+
 	if testing.Short() {
-		t.Skip("skipping live RIPE RIS network feed test in short mode; run without -short to include it")
+		t.Skip("skipping live RIPE RIS network feed test in short mode; " +
+			"run without -short to include it")
 	}
 
 	// Create mock database
 	mockDB := newMockStore()
-	defer mockDB.Close()
+
+	defer func() {
+		err := mockDB.Close()
+		if err != nil {
+			t.Errorf("failed to close mock database: %v", err)
+		}
+	}()
 
 	logger := logger.New()
 
@@ -474,16 +513,19 @@ func TestRouteWatchLiveFeed(t *testing.T) {
 	if stats.ASNs == 0 {
 		t.Error("Expected to receive some ASNs from live feed")
 	}
+
 	t.Logf("Received %d unique ASNs in 5 seconds", stats.ASNs)
 
 	if stats.Prefixes == 0 {
 		t.Error("Expected to receive some prefixes from live feed")
 	}
-	t.Logf("Received %d unique prefixes (%d IPv4, %d IPv6) in 5 seconds", stats.Prefixes, stats.IPv4Prefixes, stats.IPv6Prefixes)
+
+	t.Logf("Received %d unique prefixes (%d IPv4, %d IPv6) in 5 seconds",
+		stats.Prefixes, stats.IPv4Prefixes, stats.IPv6Prefixes)
 
 	if stats.Peerings == 0 {
 		t.Error("Expected to receive some peerings from live feed")
 	}
-	t.Logf("Recorded %d AS peering relationships in 5 seconds", stats.Peerings)
 
+	t.Logf("Recorded %d AS peering relationships in 5 seconds", stats.Peerings)
 }

internal/routewatch/app_test.go

@@ -1,3 +1,3 @@
-package routewatch
+package routewatch_test
 
-// Tests for routewatch package are in app_integration_test.go
+// Tests for routewatch package are in app_integration_internal_test.go

internal/routewatch/ashandler.go

@@ -41,9 +41,11 @@ type ASHandler struct {
 	// Batching. mu guards batch only: the flush goroutine takes the batch
 	// under mu and writes it after releasing mu, so HandleMessage waits for
 	// a database write only while batch is at asnBatchMaxSize.
-	mu          sync.Mutex
-	batch       []asnOp
-	batchTaken  sync.Cond     // signalled when the flush goroutine takes batch; its L is &mu
+	mu    sync.Mutex
+	batch []asnOp
+	// batchTaken is signalled when the flush goroutine takes batch; its L is
+	// &mu.
+	batchTaken  sync.Cond
 	batchFullCh chan struct{} // wakes the flush goroutine when batch is full
 	lastFlush   time.Time     // used only by the flush goroutine
 	stopCh      chan struct{}
@@ -83,7 +85,7 @@ func NewASHandler(db database.Store, logger *logger.Logger) *ASHandler {
 // the AS path information needed to track autonomous systems.
 func (h *ASHandler) WantsMessage(messageType string) bool {
 	// We only care about UPDATE messages for the database
-	return messageType == "UPDATE"
+	return messageType == ristypes.MessageTypeUpdate
 }
 
 // QueueCapacity returns the recommended message queue size for this handler.
@@ -148,10 +150,21 @@ func (h *ASHandler) HandleMessage(msg *ristypes.RISMessage) {
 	}
 }
 
+// Stop gracefully shuts down the ASHandler by signaling the background flush
+// goroutine to terminate and waiting for it to complete. Any pending ASN
+// operations in the current batch are flushed to the database before Stop
+// returns. This method should be called during application shutdown to ensure
+// no data is lost.
+func (h *ASHandler) Stop() {
+	close(h.stopCh)
+	h.wg.Wait()
+}
+
 // flushLoop runs in a goroutine, the only one that writes the batch: it
 // flushes when the batch is full, periodically, and once more on Stop.
 func (h *ASHandler) flushLoop() {
 	defer h.wg.Done()
+
 	ticker := time.NewTicker(asnBatchTimeout)
 	defer ticker.Stop()
 
@@ -181,6 +194,7 @@ func (h *ASHandler) takeBatch() []asnOp {
 	if len(h.batch) == 0 {
 		return nil
 	}
+
 	batch := h.batch
 	h.batch = make([]asnOp, 0, asnBatchSize)
 	h.batchTaken.Broadcast()
@@ -205,19 +219,11 @@ func (h *ASHandler) flushBatch() {
 	}
 
 	// Process all ASNs in a single batch transaction
-	if err := h.db.GetOrCreateASNBatch(asnMap); err != nil {
-		h.logger.Error("Failed to process ASN batch", "error", err, "count", len(asnMap))
+	err := h.db.GetOrCreateASNBatch(asnMap)
+	if err != nil {
+		h.logger.Error("Failed to process ASN batch",
+			"error", err, "count", len(asnMap))
 	}
 
 	h.lastFlush = time.Now()
 }
-
-// Stop gracefully shuts down the ASHandler by signaling the background flush
-// goroutine to terminate and waiting for it to complete. Any pending ASN
-// operations in the current batch are flushed to the database before Stop
-// returns. This method should be called during application shutdown to ensure
-// no data is lost.
-func (h *ASHandler) Stop() {
-	close(h.stopCh)
-	h.wg.Wait()
-}

internal/routewatch/asnfetcher.go

@@ -1,8 +1,8 @@
-// Package routewatch contains the ASN WHOIS fetcher for background updates.
 package routewatch
 
 import (
 	"context"
+	"errors"
 	"log/slog"
 	"sync"
 	"time"
@@ -73,10 +73,13 @@ func NewASNFetcher(db database.Store, logger *slog.Logger) *ASNFetcher {
 	}
 }
 
-// Start begins the background ASN fetcher goroutine.
-func (f *ASNFetcher) Start() {
+// Start begins the background ASN fetcher goroutine. It runs until Stop:
+// the end of ctx does not stop it.
+func (f *ASNFetcher) Start(ctx context.Context) {
 	f.wg.Add(1)
-	go f.run()
+
+	go f.run(context.WithoutCancel(ctx))
+
 	f.logger.Info("ASN fetcher started",
 		"base_interval", baseInterval,
 		"min_interval", minInterval,
@@ -151,10 +154,7 @@ func (f *ASNFetcher) recordSuccess() {
 	f.consecutiveFails = 0
 
 	// Decrease interval by half, but not below minimum
-	newInterval := f.currentInterval / backoffMultiplier
-	if newInterval < minInterval {
-		newInterval = minInterval
-	}
+	newInterval := max(f.currentInterval/backoffMultiplier, minInterval)
 
 	if newInterval != f.currentInterval {
 		f.logger.Debug("Decreased fetch interval",
@@ -177,10 +177,7 @@ func (f *ASNFetcher) recordFailure() {
 	f.consecutiveFails++
 
 	// Exponential backoff: multiply by 2, capped at max
-	newInterval := f.currentInterval * backoffMultiplier
-	if newInterval > maxInterval {
-		newInterval = maxInterval
-	}
+	newInterval := min(f.currentInterval*backoffMultiplier, maxInterval)
 
 	if newInterval != f.currentInterval {
 		f.logger.Debug("Increased fetch interval due to failure",
@@ -199,7 +196,7 @@ func (f *ASNFetcher) recordFailure() {
 }
 
 // run is the main background loop.
-func (f *ASNFetcher) run() {
+func (f *ASNFetcher) run(ctx context.Context) {
 	defer f.wg.Done()
 
 	timer := time.NewTimer(f.getInterval())
@@ -212,13 +209,13 @@ func (f *ASNFetcher) run() {
 
 		case asn := <-f.immediateQueue:
 			// Process immediate request (respects lock)
-			f.tryFetch(asn)
+			f.tryFetch(ctx, asn)
 			// Reset timer after immediate fetch
 			timer.Reset(f.getInterval())
 
 		case <-timer.C:
 			// Background fetch of stale/missing ASN
-			f.fetchNextStale()
+			f.fetchNextStale(ctx)
 			// Reset timer with potentially updated interval
 			timer.Reset(f.getInterval())
 		}
@@ -227,7 +224,7 @@ func (f *ASNFetcher) run() {
 
 // tryFetch attempts to fetch and update an ASN, respecting the fetch lock.
 // Returns true if fetch was successful.
-func (f *ASNFetcher) tryFetch(asn int) bool {
+func (f *ASNFetcher) tryFetch(ctx context.Context, asn int) bool {
 	// Try to acquire lock, skip if another fetch is running
 	if !f.fetchMu.TryLock() {
 		f.logger.Debug("Skipping fetch, another fetch in progress", "asn", asn)
@@ -236,11 +233,11 @@ func (f *ASNFetcher) tryFetch(asn int) bool {
 	}
 	defer f.fetchMu.Unlock()
 
-	return f.fetchAndUpdate(asn)
+	return f.fetchAndUpdate(ctx, asn)
 }
 
 // fetchNextStale finds and fetches the next ASN needing WHOIS data.
-func (f *ASNFetcher) fetchNextStale() {
+func (f *ASNFetcher) fetchNextStale(ctx context.Context) {
 	// Try to acquire lock, skip if another fetch is running
 	if !f.fetchMu.TryLock() {
 		f.logger.Debug("Skipping stale fetch, another fetch in progress")
@@ -249,12 +246,12 @@ func (f *ASNFetcher) fetchNextStale() {
 	}
 	defer f.fetchMu.Unlock()
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	lookupCtx, cancel := context.WithTimeout(ctx, time.Minute)
 	defer cancel()
 
-	asn, err := f.db.GetNextStaleASN(ctx, whoisStaleThreshold)
+	asn, err := f.db.GetNextStaleASN(lookupCtx, whoisStaleThreshold)
 	if err != nil {
-		if err != database.ErrNoStaleASN {
+		if !errors.Is(err, database.ErrNoStaleASN) {
 			f.logger.Error("Failed to get stale ASN", "error", err)
 			f.recordFailure()
 		}
@@ -263,13 +260,13 @@ func (f *ASNFetcher) fetchNextStale() {
 		return
 	}
 
-	f.fetchAndUpdate(asn)
+	f.fetchAndUpdate(ctx, asn)
 }
 
 // fetchAndUpdate performs a WHOIS lookup and updates the database.
 // Returns true if successful.
-func (f *ASNFetcher) fetchAndUpdate(asn int) bool {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+func (f *ASNFetcher) fetchAndUpdate(ctx context.Context, asn int) bool {
+	ctx, cancel := context.WithTimeout(ctx, time.Minute)
 	defer cancel()
 
 	f.logger.Info("Fetching WHOIS data", "asn", asn)

internal/routewatch/batchwrite_internal_test.go

@@ -49,21 +49,11 @@ func newBlockingStore() *blockingStore {
 	}
 }
 
-func (s *blockingStore) waitForRelease() {
-	s.startOnce.Do(func() { close(s.writeStarted) })
-	<-s.release
-}
-
-// releaseWrites lets the held writes, and all later ones, finish. A second call
-// does nothing.
-func (s *blockingStore) releaseWrites() {
-	s.releaseOnce.Do(func() { close(s.release) })
-}
-
 func (s *blockingStore) UpsertLiveRouteBatch(routes []*database.LiveRoute) error {
 	s.waitForRelease()
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
 	for _, route := range routes {
 		s.prefixes[route.Prefix] = true
 	}
@@ -75,6 +65,7 @@ func (s *blockingStore) GetOrCreateASNBatch(asns map[int]time.Time) error {
 	s.waitForRelease()
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
 	for asn := range asns {
 		s.asns[asn] = true
 	}
@@ -86,6 +77,7 @@ func (s *blockingStore) UpdatePeerBatch(peers map[string]database.PeerUpdate) er
 	s.waitForRelease()
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
 	for peerIP := range peers {
 		s.peers[peerIP] = true
 	}
@@ -93,9 +85,21 @@ func (s *blockingStore) UpdatePeerBatch(peers map[string]database.PeerUpdate) er
 	return nil
 }
 
+func (s *blockingStore) waitForRelease() {
+	s.startOnce.Do(func() { close(s.writeStarted) })
+	<-s.release
+}
+
+// releaseWrites lets the held writes, and all later ones, finish. A second call
+// does nothing.
+func (s *blockingStore) releaseWrites() {
+	s.releaseOnce.Do(func() { close(s.release) })
+}
+
 // returnsInTime reports whether f returns within handleMessageTimeout.
 func returnsInTime(f func()) bool {
 	done := make(chan struct{})
+
 	go func() {
 		f()
 		close(done)
@@ -115,7 +119,9 @@ func returnsInTime(f func()) bool {
 func startBlockedWrite(
 	t *testing.T,
 	store *blockingStore,
-	h interface{ HandleMessage(*ristypes.RISMessage) },
+	h interface {
+		HandleMessage(msg *ristypes.RISMessage)
+	},
 	fill []*ristypes.RISMessage,
 ) {
 	t.Helper()
@@ -125,7 +131,8 @@ func startBlockedWrite(
 			h.HandleMessage(msg)
 		}
 	}) {
-		t.Fatal("HandleMessage did not return after filling the batch: it waits for the database write")
+		t.Fatal("HandleMessage did not return after filling the batch: " +
+			"it waits for the database write")
 	}
 
 	select {
@@ -143,13 +150,14 @@ func handleWhileAWriteIsBlocked(
 	t *testing.T,
 	store *blockingStore,
 	h interface {
-		HandleMessage(*ristypes.RISMessage)
+		HandleMessage(msg *ristypes.RISMessage)
 		Stop()
 	},
 	fill []*ristypes.RISMessage,
 	extra *ristypes.RISMessage,
 ) {
 	t.Helper()
+
 	defer h.Stop()
 	defer store.releaseWrites()
 
@@ -169,22 +177,25 @@ func handleAtMaxBatchSize(
 	t *testing.T,
 	store *blockingStore,
 	h interface {
-		HandleMessage(*ristypes.RISMessage)
+		HandleMessage(msg *ristypes.RISMessage)
 		Stop()
 	},
 	fill, toMax []*ristypes.RISMessage,
 	extra *ristypes.RISMessage,
 ) {
 	t.Helper()
+
 	defer h.Stop()
 	defer store.releaseWrites()
 
 	startBlockedWrite(t, store, h, fill)
+
 	for _, msg := range toMax {
 		h.HandleMessage(msg)
 	}
 
 	returned := make(chan struct{})
+
 	go func() {
 		h.HandleMessage(extra)
 		close(returned)
@@ -192,11 +203,13 @@ func handleAtMaxBatchSize(
 
 	select {
 	case <-returned:
-		t.Fatal("HandleMessage returned while the batch was at its maximum size and a write was blocked")
+		t.Fatal("HandleMessage returned while the batch was at its maximum " +
+			"size and a write was blocked")
 	case <-time.After(stillWaitingAfter):
 	}
 
 	store.releaseWrites()
+
 	select {
 	case <-returned:
 	case <-time.After(handleMessageTimeout):
@@ -208,46 +221,57 @@ func handleAtMaxBatchSize(
 // with origin AS testASNA.
 func prefixAnnouncement(prefixes []string) *ristypes.RISMessage {
 	return &ristypes.RISMessage{
-		Peer:          testPeerIP,
-		Path:          ristypes.ASPath{testASNA},
-		Announcements: []ristypes.RISAnnouncement{{NextHop: testPeerIP, Prefixes: prefixes}},
+		Peer: testPeerIP,
+		Path: ristypes.ASPath{testASNA},
+		Announcements: []ristypes.RISAnnouncement{
+			{NextHop: testPeerIP, Prefixes: prefixes},
+		},
 	}
 }
 
 func TestPrefixHandlerHandlesMessagesWhileAWriteIsBlocked(t *testing.T) {
-	const (
-		fillPrefix  = "192.0.2.0/24"
-		extraPrefix = "198.51.100.0/24"
-	)
+	t.Parallel()
+
+	const extraPrefix = "198.51.100.0/24"
 
 	store := newBlockingStore()
 	h := NewPrefixHandler(store, logger.New())
+	fill := slices.Repeat([]string{testV4Prefix}, prefixBatchSize)
 	handleWhileAWriteIsBlocked(t, store, h,
-		[]*ristypes.RISMessage{prefixAnnouncement(slices.Repeat([]string{fillPrefix}, prefixBatchSize))},
+		[]*ristypes.RISMessage{prefixAnnouncement(fill)},
 		prefixAnnouncement([]string{extraPrefix}))
 
 	store.mu.Lock()
 	defer store.mu.Unlock()
+
 	if !store.prefixes[extraPrefix] {
-		t.Errorf("Stop did not write %s, handled while a write was blocked", extraPrefix)
+		t.Errorf("Stop did not write %s, handled while a write was blocked",
+			extraPrefix)
 	}
 }
 
 func TestASHandlerHandlesMessagesWhileAWriteIsBlocked(t *testing.T) {
+	t.Parallel()
+
 	store := newBlockingStore()
 	h := NewASHandler(store, logger.New())
+	fill := slices.Repeat(ristypes.ASPath{testASNA}, asnBatchSize)
 	handleWhileAWriteIsBlocked(t, store, h,
-		[]*ristypes.RISMessage{{Path: slices.Repeat(ristypes.ASPath{testASNA}, asnBatchSize)}},
+		[]*ristypes.RISMessage{{Path: fill}},
 		&ristypes.RISMessage{Path: ristypes.ASPath{testASNB}})
 
 	store.mu.Lock()
 	defer store.mu.Unlock()
+
 	if !store.asns[testASNB] {
-		t.Errorf("Stop did not write AS%d, handled while a write was blocked", testASNB)
+		t.Errorf("Stop did not write AS%d, handled while a write was blocked",
+			testASNB)
 	}
 }
 
 func TestPeerHandlerHandlesMessagesWhileAWriteIsBlocked(t *testing.T) {
+	t.Parallel()
+
 	const otherPeerIP = "2001:db8:ffff::2"
 
 	store := newBlockingStore()
@@ -258,60 +282,76 @@ func TestPeerHandlerHandlesMessagesWhileAWriteIsBlocked(t *testing.T) {
 
 	store.mu.Lock()
 	defer store.mu.Unlock()
+
 	if !store.peers[otherPeerIP] {
-		t.Errorf("Stop did not write peer %s, handled while a write was blocked", otherPeerIP)
+		t.Errorf("Stop did not write peer %s, handled while a write was blocked",
+			otherPeerIP)
 	}
 }
 
 func TestPrefixHandlerWaitsAtTheMaximumBatchSize(t *testing.T) {
-	const (
-		fillPrefix  = "192.0.2.0/24"
-		extraPrefix = "198.51.100.0/24"
-	)
+	t.Parallel()
+
+	const extraPrefix = "198.51.100.0/24"
 
 	store := newBlockingStore()
 	h := NewPrefixHandler(store, logger.New())
+	fill := slices.Repeat([]string{testV4Prefix}, prefixBatchSize)
+	toMax := slices.Repeat([]string{testV4Prefix}, prefixBatchMaxSize)
 	handleAtMaxBatchSize(t, store, h,
-		[]*ristypes.RISMessage{prefixAnnouncement(slices.Repeat([]string{fillPrefix}, prefixBatchSize))},
-		[]*ristypes.RISMessage{prefixAnnouncement(slices.Repeat([]string{fillPrefix}, prefixBatchMaxSize))},
+		[]*ristypes.RISMessage{prefixAnnouncement(fill)},
+		[]*ristypes.RISMessage{prefixAnnouncement(toMax)},
 		prefixAnnouncement([]string{extraPrefix}))
 
 	store.mu.Lock()
 	defer store.mu.Unlock()
+
 	if !store.prefixes[extraPrefix] {
-		t.Errorf("Stop did not write %s, handled after the batch reached its maximum size", extraPrefix)
+		t.Errorf("Stop did not write %s, handled after the batch reached its "+
+			"maximum size", extraPrefix)
 	}
 }
 
 func TestASHandlerWaitsAtTheMaximumBatchSize(t *testing.T) {
+	t.Parallel()
+
 	store := newBlockingStore()
 	h := NewASHandler(store, logger.New())
+	fill := slices.Repeat(ristypes.ASPath{testASNA}, asnBatchSize)
+	toMax := slices.Repeat(ristypes.ASPath{testASNA}, asnBatchMaxSize)
 	handleAtMaxBatchSize(t, store, h,
-		[]*ristypes.RISMessage{{Path: slices.Repeat(ristypes.ASPath{testASNA}, asnBatchSize)}},
-		[]*ristypes.RISMessage{{Path: slices.Repeat(ristypes.ASPath{testASNA}, asnBatchMaxSize)}},
+		[]*ristypes.RISMessage{{Path: fill}},
+		[]*ristypes.RISMessage{{Path: toMax}},
 		&ristypes.RISMessage{Path: ristypes.ASPath{testASNB}})
 
 	store.mu.Lock()
 	defer store.mu.Unlock()
+
 	if !store.asns[testASNB] {
-		t.Errorf("Stop did not write AS%d, handled after the batch reached its maximum size", testASNB)
+		t.Errorf("Stop did not write AS%d, handled after the batch reached its "+
+			"maximum size", testASNB)
 	}
 }
 
 func TestPeerHandlerWaitsAtTheMaximumBatchSize(t *testing.T) {
+	t.Parallel()
+
 	const otherPeerIP = "2001:db8:ffff::2"
 
 	store := newBlockingStore()
 	h := NewPeerHandler(store, logger.New())
+	message := []*ristypes.RISMessage{{Peer: testPeerIP}}
 	handleAtMaxBatchSize(t, store, h,
-		slices.Repeat([]*ristypes.RISMessage{{Peer: testPeerIP}}, peerBatchSize),
-		slices.Repeat([]*ristypes.RISMessage{{Peer: testPeerIP}}, peerBatchMaxSize),
+		slices.Repeat(message, peerBatchSize),
+		slices.Repeat(message, peerBatchMaxSize),
 		&ristypes.RISMessage{Peer: otherPeerIP})
 
 	store.mu.Lock()
 	defer store.mu.Unlock()
+
 	if !store.peers[otherPeerIP] {
-		t.Errorf("Stop did not write peer %s, handled after the batch reached its maximum size", otherPeerIP)
+		t.Errorf("Stop did not write peer %s, handled after the batch reached "+
+			"its maximum size", otherPeerIP)
 	}
 }
 
@@ -320,6 +360,8 @@ func TestPeerHandlerWaitsAtTheMaximumBatchSize(t *testing.T) {
 // of a full batch, and a second one exactly a full batch. Only the full batch
 // leaves a wake-up in batchFullCh.
 func TestHandlersWakeTheFlushGoroutineWhenTheBatchIsFull(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name      string
 		batchSize int
@@ -331,7 +373,8 @@ func TestHandlersWakeTheFlushGoroutineWhenTheBatchIsFull(t *testing.T) {
 			batchSize: prefixBatchSize,
 			handle: func(n int) chan struct{} {
 				h := &PrefixHandler{batchFullCh: make(chan struct{}, 1)}
-				h.HandleMessage(prefixAnnouncement(slices.Repeat([]string{"192.0.2.0/24"}, n)))
+				h.HandleMessage(prefixAnnouncement(
+					slices.Repeat([]string{testV4Prefix}, n)))
 
 				return h.batchFullCh
 			},
@@ -342,7 +385,9 @@ func TestHandlersWakeTheFlushGoroutineWhenTheBatchIsFull(t *testing.T) {
 			handle: func(n int) chan struct{} {
 				h := &ASHandler{batchFullCh: make(chan struct{}, 1)}
 				// The origin AS and each AS in the path are one update each.
-				h.HandleMessage(&ristypes.RISMessage{Path: slices.Repeat(ristypes.ASPath{testASNA}, n-1)})
+				h.HandleMessage(&ristypes.RISMessage{
+					Path: slices.Repeat(ristypes.ASPath{testASNA}, n-1),
+				})
 
 				return h.batchFullCh
 			},
@@ -363,10 +408,16 @@ func TestHandlersWakeTheFlushGoroutineWhenTheBatchIsFull(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := len(tt.handle(tt.batchSize - 1)); got != 0 {
-				t.Errorf("one update short of a full batch left %d wake-ups, want none", got)
+			t.Parallel()
+
+			got := len(tt.handle(tt.batchSize - 1))
+			if got != 0 {
+				t.Errorf("one update short of a full batch left %d wake-ups, "+
+					"want none", got)
 			}
-			if got := len(tt.handle(tt.batchSize)); got != 1 {
+
+			got = len(tt.handle(tt.batchSize))
+			if got != 1 {
 				t.Errorf("a full batch left %d wake-ups, want 1", got)
 			}
 		})

internal/routewatch/cli.go

@@ -57,14 +57,19 @@ func logDebugStats(logger *logger.Logger) {
 
 // CLIEntry is the main entry point for the routewatch command-line interface.
 // It initializes the application using the fx dependency injection framework,
-// sets up signal handling for graceful shutdown, and starts the RouteWatch service.
-// This function blocks until the application receives a shutdown signal or encounters
-// a fatal error.
+// sets up signal handling for graceful shutdown, and starts the RouteWatch
+// service. This function blocks until the application receives a shutdown
+// signal or encounters a fatal error.
 func CLIEntry() {
 	app := fx.New(
-		getModule(),
+		fx.Options(getModule()...),
 		fx.StopTimeout(shutdownTimeout), // Allow 60 seconds for graceful shutdown
-		fx.Invoke(func(lc fx.Lifecycle, rw *RouteWatch, logger *logger.Logger, shutdowner fx.Shutdowner) {
+		fx.Invoke(func(
+			lc fx.Lifecycle,
+			rw *RouteWatch,
+			logger *logger.Logger,
+			shutdowner fx.Shutdowner,
+		) {
 			lc.Append(fx.Hook{
 				OnStart: func(ctx context.Context) error {
 					// Start debug stats logging
@@ -77,25 +82,31 @@ func CLIEntry() {
 					go func() {
 						<-sigCh
 						logger.Info("Received shutdown signal")
-						if err := shutdowner.Shutdown(); err != nil {
+
+						err := shutdowner.Shutdown()
+						if err != nil {
 							logger.Error("Failed to shutdown gracefully", "error", err)
 						}
 					}()
 
 					go func() {
-						if err := rw.Run(ctx); err != nil {
+						err := rw.Run(ctx)
+						if err != nil {
 							logger.Error("RouteWatch error", "error", err)
-							if err := shutdowner.Shutdown(fx.ExitCode(failureExitCode)); err != nil {
-								logger.Error("Failed to shutdown gracefully", "error", err)
+
+							err = shutdowner.Shutdown(fx.ExitCode(failureExitCode))
+							if err != nil {
+								logger.Error("Failed to shutdown gracefully",
+									"error", err)
 							}
 						}
 					}()
 
 					return nil
 				},
-				OnStop: func(_ context.Context) error {
+				OnStop: func(ctx context.Context) error {
 					logger.Info("Shutting down RouteWatch")
-					rw.Shutdown()
+					rw.Shutdown(ctx)
 
 					return nil
 				},

internal/routewatch/dbmaintainer.go

@@ -1,4 +1,3 @@
-// Package routewatch contains the database maintainer for background maintenance tasks.
 package routewatch
 
 import (
@@ -64,10 +63,13 @@ func NewDBMaintainer(db database.Store, logger *slog.Logger) *DBMaintainer {
 	}
 }
 
-// Start begins the background maintenance goroutine.
-func (m *DBMaintainer) Start() {
+// Start begins the background maintenance goroutine. It runs until Stop:
+// the end of ctx does not stop it.
+func (m *DBMaintainer) Start(ctx context.Context) {
 	m.wg.Add(1)
-	go m.run()
+
+	go m.run(context.WithoutCancel(ctx))
+
 	m.logger.Info("Database maintainer started",
 		"checkpoint_interval", checkpointInterval,
 		"vacuum_interval", vacuumInterval,
@@ -83,15 +85,17 @@ func (m *DBMaintainer) Stop() {
 }
 
 // run is the main background loop.
-func (m *DBMaintainer) run() {
+func (m *DBMaintainer) run(ctx context.Context) {
 	defer m.wg.Done()
 
 	// Use different timers for each task
 	checkpointTimer := time.NewTimer(checkpointInterval)
-	vacuumTimer := time.NewTimer(vacuumInterval)
-	analyzeTimer := time.NewTimer(analyzeInterval)
 	defer checkpointTimer.Stop()
+
+	vacuumTimer := time.NewTimer(vacuumInterval)
 	defer vacuumTimer.Stop()
+
+	analyzeTimer := time.NewTimer(analyzeInterval)
 	defer analyzeTimer.Stop()
 
 	for {
@@ -100,90 +104,88 @@ func (m *DBMaintainer) run() {
 			return
 
 		case <-checkpointTimer.C:
-			m.runCheckpoint()
+			m.runCheckpoint(ctx)
 			checkpointTimer.Reset(checkpointInterval)
 
 		case <-vacuumTimer.C:
-			m.runVacuum()
+			m.runVacuum(ctx)
 			vacuumTimer.Reset(vacuumInterval)
 
 		case <-analyzeTimer.C:
-			m.runAnalyze()
+			m.runAnalyze(ctx)
 			analyzeTimer.Reset(analyzeInterval)
 		}
 	}
 }
 
 // runCheckpoint performs a WAL checkpoint to keep the WAL file small.
-func (m *DBMaintainer) runCheckpoint() {
-	ctx, cancel := context.WithTimeout(context.Background(), checkpointTimeout)
-	defer cancel()
-
-	startTime := time.Now()
-
-	err := m.db.Checkpoint(ctx)
-
-	m.statsMu.Lock()
-	m.lastCheckpoint = time.Now()
-	m.lastCheckpointError = err
-	if err == nil {
-		m.checkpointCount++
-	}
-	m.statsMu.Unlock()
+func (m *DBMaintainer) runCheckpoint(ctx context.Context) {
+	duration, err := runWithTimeout(ctx, checkpointTimeout, m.db.Checkpoint)
+	m.recordResult(&m.lastCheckpoint, &m.lastCheckpointError, &m.checkpointCount, err)
 
 	if err != nil {
-		m.logger.Error("WAL checkpoint failed", "error", err, "duration", time.Since(startTime))
+		m.logger.Error("WAL checkpoint failed", "error", err, "duration", duration)
 	} else {
-		m.logger.Debug("WAL checkpoint completed", "duration", time.Since(startTime))
+		m.logger.Debug("WAL checkpoint completed", "duration", duration)
 	}
 }
 
 // runVacuum performs an incremental vacuum operation on the database.
-func (m *DBMaintainer) runVacuum() {
-	ctx, cancel := context.WithTimeout(context.Background(), vacuumTimeout)
-	defer cancel()
-
+func (m *DBMaintainer) runVacuum(ctx context.Context) {
 	m.logger.Debug("Running incremental vacuum")
-	startTime := time.Now()
 
-	err := m.db.Vacuum(ctx)
-
-	m.statsMu.Lock()
-	m.lastVacuum = time.Now()
-	m.lastVacuumError = err
-	if err == nil {
-		m.vacuumCount++
-	}
-	m.statsMu.Unlock()
+	duration, err := runWithTimeout(ctx, vacuumTimeout, m.db.Vacuum)
+	m.recordResult(&m.lastVacuum, &m.lastVacuumError, &m.vacuumCount, err)
 
 	if err != nil {
-		m.logger.Error("Incremental vacuum failed", "error", err, "duration", time.Since(startTime))
+		m.logger.Error("Incremental vacuum failed", "error", err, "duration", duration)
 	} else {
-		m.logger.Debug("Incremental vacuum completed", "duration", time.Since(startTime))
+		m.logger.Debug("Incremental vacuum completed", "duration", duration)
 	}
 }
 
 // runAnalyze performs an ANALYZE operation on the database.
-func (m *DBMaintainer) runAnalyze() {
-	ctx, cancel := context.WithTimeout(context.Background(), analyzeTimeout)
-	defer cancel()
-
+func (m *DBMaintainer) runAnalyze(ctx context.Context) {
 	m.logger.Info("Starting database ANALYZE")
-	startTime := time.Now()
 
-	err := m.db.Analyze(ctx)
-
-	m.statsMu.Lock()
-	m.lastAnalyze = time.Now()
-	m.lastAnalyzeError = err
-	if err == nil {
-		m.analyzeCount++
-	}
-	m.statsMu.Unlock()
+	duration, err := runWithTimeout(ctx, analyzeTimeout, m.db.Analyze)
+	m.recordResult(&m.lastAnalyze, &m.lastAnalyzeError, &m.analyzeCount, err)
 
 	if err != nil {
-		m.logger.Error("ANALYZE failed", "error", err, "duration", time.Since(startTime))
+		m.logger.Error("ANALYZE failed", "error", err, "duration", duration)
 	} else {
-		m.logger.Info("ANALYZE completed", "duration", time.Since(startTime))
+		m.logger.Info("ANALYZE completed", "duration", duration)
+	}
+}
+
+// runWithTimeout runs operation with a context that ends after timeout and
+// returns how long it took and its error.
+func runWithTimeout(
+	ctx context.Context,
+	timeout time.Duration,
+	operation func(context.Context) error,
+) (time.Duration, error) {
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	startTime := time.Now()
+	err := operation(ctx)
+
+	return time.Since(startTime), err
+}
+
+// recordResult stores when a maintenance task last ran and its error, and
+// counts it when it succeeded.
+func (m *DBMaintainer) recordResult(
+	lastRun *time.Time, lastErr *error, successCount *int, err error,
+) {
+	m.statsMu.Lock()
+	defer m.statsMu.Unlock()
+
+	*lastRun = time.Now()
+	*lastErr = err
+
+	if err == nil {
+		*successCount++
 	}
 }

internal/routewatch/handler.go

@@ -1,6 +1,8 @@
 package routewatch
 
 import (
+	"slices"
+
 	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 )
@@ -15,10 +17,11 @@ type SimpleHandler struct {
 	callback     func(*ristypes.RISMessage)
 }
 
-// NewSimpleHandler creates a new SimpleHandler that accepts specific message types.
-// The messageTypes parameter specifies which RIS message types this handler will process.
-// If messageTypes is empty, the handler will accept all message types.
-// The callback function is invoked for each message that passes the type filter.
+// NewSimpleHandler creates a new SimpleHandler that accepts specific message
+// types. The messageTypes parameter specifies which RIS message types this
+// handler will process. If messageTypes is empty, the handler will accept all
+// message types. The callback function is invoked for each message that
+// passes the type filter.
 func NewSimpleHandler(
 	logger *logger.Logger,
 	messageTypes []string,
@@ -31,22 +34,17 @@ func NewSimpleHandler(
 	}
 }
 
-// WantsMessage returns true if this handler wants to process messages of the given type.
-// It checks whether messageType is in the handler's configured list of accepted types.
-// If no specific types were configured (empty messageTypes slice), it returns true for all types.
+// WantsMessage returns true if this handler wants to process messages of the
+// given type. It checks whether messageType is in the handler's configured
+// list of accepted types. If no specific types were configured (empty
+// messageTypes slice), it returns true for all types.
 func (h *SimpleHandler) WantsMessage(messageType string) bool {
 	// If no specific types are set, accept all messages
 	if len(h.messageTypes) == 0 {
 		return true
 	}
 
-	for _, t := range h.messageTypes {
-		if t == messageType {
-			return true
-		}
-	}
-
-	return false
+	return slices.Contains(h.messageTypes, messageType)
 }
 
 // HandleMessage processes a RIS message by invoking the configured callback function.

internal/routewatch/peerhandler.go

@@ -1,7 +1,8 @@
 package routewatch
 
-// peerhandler.go provides batched peer tracking functionality for BGP route monitoring.
-// It tracks BGP peers from incoming UPDATE messages and maintains peer state in the database.
+// peerhandler.go provides batched peer tracking functionality for BGP route
+// monitoring. It tracks BGP peers from incoming UPDATE messages and maintains
+// peer state in the database.
 
 import (
 	"strconv"
@@ -44,9 +45,11 @@ type PeerHandler struct {
 	// Batching. mu guards peerBatch only: the flush goroutine takes the batch
 	// under mu and writes it after releasing mu, so HandleMessage waits for
 	// a database write only while peerBatch is at peerBatchMaxSize.
-	mu          sync.Mutex
-	peerBatch   []peerUpdate
-	batchTaken  sync.Cond     // signalled when the flush goroutine takes peerBatch; its L is &mu
+	mu        sync.Mutex
+	peerBatch []peerUpdate
+	// batchTaken is signalled when the flush goroutine takes peerBatch; its L
+	// is &mu.
+	batchTaken  sync.Cond
 	batchFullCh chan struct{} // wakes the flush goroutine when peerBatch is full
 	lastFlush   time.Time     // used only by the flush goroutine
 	stopCh      chan struct{}
@@ -104,8 +107,10 @@ func (h *PeerHandler) QueueCapacity() int {
 func (h *PeerHandler) HandleMessage(msg *ristypes.RISMessage) {
 	// Parse peer ASN from string
 	peerASN := 0
+
 	if msg.PeerASN != "" {
-		if asn, err := strconv.Atoi(msg.PeerASN); err == nil {
+		asn, err := strconv.Atoi(msg.PeerASN)
+		if err == nil {
 			peerASN = asn
 		}
 	}
@@ -139,10 +144,17 @@ func (h *PeerHandler) HandleMessage(msg *ristypes.RISMessage) {
 	}
 }
 
+// Stop gracefully stops the handler and flushes remaining batches
+func (h *PeerHandler) Stop() {
+	close(h.stopCh)
+	h.wg.Wait()
+}
+
 // flushLoop runs in a goroutine, the only one that writes the batch: it
 // flushes when the batch is full, periodically, and once more on Stop.
 func (h *PeerHandler) flushLoop() {
 	defer h.wg.Done()
+
 	ticker := time.NewTicker(peerBatchTimeout)
 	defer ticker.Stop()
 
@@ -172,6 +184,7 @@ func (h *PeerHandler) takeBatch() []peerUpdate {
 	if len(h.peerBatch) == 0 {
 		return nil
 	}
+
 	batch := h.peerBatch
 	h.peerBatch = make([]peerUpdate, 0, peerBatchSize)
 	h.batchTaken.Broadcast()
@@ -190,7 +203,8 @@ func (h *PeerHandler) flushBatch() {
 	// Deduplicate by peer IP, keeping the latest update for each peer
 	peerMap := make(map[string]peerUpdate)
 	for _, update := range batch {
-		if existing, ok := peerMap[update.peerIP]; !ok || update.timestamp.After(existing.timestamp) {
+		existing, ok := peerMap[update.peerIP]
+		if !ok || update.timestamp.After(existing.timestamp) {
 			peerMap[update.peerIP] = update
 		}
 	}
@@ -207,15 +221,11 @@ func (h *PeerHandler) flushBatch() {
 	}
 
 	// Process all peers in a single batch transaction
-	if err := h.db.UpdatePeerBatch(dbPeerMap); err != nil {
-		h.logger.Error("Failed to process peer batch", "error", err, "count", len(dbPeerMap))
+	err := h.db.UpdatePeerBatch(dbPeerMap)
+	if err != nil {
+		h.logger.Error("Failed to process peer batch",
+			"error", err, "count", len(dbPeerMap))
 	}
 
 	h.lastFlush = time.Now()
 }
-
-// Stop gracefully stops the handler and flushes remaining batches
-func (h *PeerHandler) Stop() {
-	close(h.stopCh)
-	h.wg.Wait()
-}

internal/routewatch/peeringhandler.go

@@ -72,7 +72,7 @@ func NewPeeringHandler(db database.Store, logger *logger.Logger) *PeeringHandler
 // the AS path information needed to extract peering relationships.
 func (h *PeeringHandler) WantsMessage(messageType string) bool {
 	// We only care about UPDATE messages that have AS paths
-	return messageType == "UPDATE"
+	return messageType == ristypes.MessageTypeUpdate
 }
 
 // QueueCapacity returns the buffer size for the handler's message queue.
@@ -101,6 +101,7 @@ func (h *PeeringHandler) HandleMessage(msg *ristypes.RISMessage) {
 
 		return
 	}
+
 	key := string(pathJSON)
 
 	h.mu.Lock()
@@ -116,6 +117,23 @@ func (h *PeeringHandler) HandleMessage(msg *ristypes.RISMessage) {
 	h.mu.Unlock()
 }
 
+// ProcessPeeringsNow triggers immediate processing of all accumulated AS
+// paths into peering records. This bypasses the normal periodic processing
+// schedule and is primarily intended for testing purposes.
+func (h *PeeringHandler) ProcessPeeringsNow() {
+	h.processPeerings()
+}
+
+// Stop gracefully shuts down the handler by signaling the background
+// goroutine to stop and performing a final synchronous processing of
+// any remaining AS paths. This ensures no peering data is lost during
+// shutdown.
+func (h *PeeringHandler) Stop() {
+	close(h.stopCh)
+	// Process any remaining peerings synchronously
+	h.processPeerings()
+}
+
 // processLoop runs periodically to process AS paths into peerings
 func (h *PeeringHandler) processLoop() {
 	ticker := time.NewTicker(peeringProcessInterval)
@@ -134,13 +152,6 @@ func (h *PeeringHandler) processLoop() {
 	}
 }
 
-// ProcessPeeringsNow triggers immediate processing of all accumulated AS
-// paths into peering records. This bypasses the normal periodic processing
-// schedule and is primarily intended for testing purposes.
-func (h *PeeringHandler) ProcessPeeringsNow() {
-	h.processPeerings()
-}
-
 // processPeerings extracts peerings from AS paths and writes to database
 func (h *PeeringHandler) processPeerings() {
 	// Take the accumulated paths and replace the map with a fresh empty one
@@ -160,11 +171,14 @@ func (h *PeeringHandler) processPeerings() {
 	type peeringKey struct {
 		low, high int
 	}
+
 	peerings := make(map[peeringKey]time.Time)
 
 	for pathJSON, timestamp := range paths {
 		var path []int
-		if err := json.Unmarshal([]byte(pathJSON), &path); err != nil {
+
+		err := json.Unmarshal([]byte(pathJSON), &path)
+		if err != nil {
 			h.logger.Error("Failed to decode AS path", "error", err)
 
 			continue
@@ -197,6 +211,7 @@ func (h *PeeringHandler) processPeerings() {
 	// Record peerings in database
 	start := time.Now()
 	successCount := 0
+
 	for key, ts := range peerings {
 		err := h.db.RecordPeering(key.low, key.high, ts)
 		if err != nil {
@@ -218,13 +233,3 @@ func (h *PeeringHandler) processPeerings() {
 		"duration", time.Since(start),
 	)
 }
-
-// Stop gracefully shuts down the handler by signaling the background
-// goroutine to stop and performing a final synchronous processing of
-// any remaining AS paths. This ensures no peering data is lost during
-// shutdown.
-func (h *PeeringHandler) Stop() {
-	close(h.stopCh)
-	// Process any remaining peerings synchronously
-	h.processPeerings()
-}

internal/routewatch/peeringhandler_internal_test.go

@@ -53,7 +53,8 @@ func newTestHandler(db database.Store) *PeeringHandler {
 	}
 }
 
-func snapshot(h *PeeringHandler) (tracked, dropped int) {
+// snapshot returns how many paths the handler tracks and how many it dropped.
+func snapshot(h *PeeringHandler) (int, int) {
 	h.mu.Lock()
 	defer h.mu.Unlock()
 
@@ -82,6 +83,8 @@ func handle(h *PeeringHandler, ts time.Time, asns ...int) {
 // empties the path map (the swap) and that a path seen again after a run is
 // recorded in the next run too.
 func TestPeeringHandlerProcessesEachRunAndEmpties(t *testing.T) {
+	t.Parallel()
+
 	store := &recordingStore{mockStore: newMockStore()}
 	h := newTestHandler(store)
 
@@ -94,6 +97,7 @@ func TestPeeringHandlerProcessesEachRunAndEmpties(t *testing.T) {
 	if tracked, _ := snapshot(h); tracked != 0 {
 		t.Fatalf("map not empty after first run: %d paths remain", tracked)
 	}
+
 	if got := store.callCount(); got != 1 {
 		t.Fatalf("want 1 RecordPeering call after first run, got %d", got)
 	}
@@ -105,6 +109,7 @@ func TestPeeringHandlerProcessesEachRunAndEmpties(t *testing.T) {
 	if tracked, _ := snapshot(h); tracked != 0 {
 		t.Fatalf("map not empty after second run: %d paths remain", tracked)
 	}
+
 	if got := store.callCount(); got != 2 {
 		t.Fatalf("want 2 RecordPeering calls after second run, got %d", got)
 	}
@@ -114,6 +119,8 @@ func TestPeeringHandlerProcessesEachRunAndEmpties(t *testing.T) {
 // and counts them, while a path already tracked is refreshed rather than
 // dropped.
 func TestPeeringHandlerCapDropsAndCounts(t *testing.T) {
+	t.Parallel()
+
 	store := &recordingStore{mockStore: newMockStore()}
 	h := newTestHandler(store)
 
@@ -126,6 +133,7 @@ func TestPeeringHandlerCapDropsAndCounts(t *testing.T) {
 
 	h.mu.Lock()
 	h.asPaths[existing] = now
+
 	for i := 0; len(h.asPaths) < maxTrackedPaths; i++ {
 		h.asPaths[strconv.Itoa(i)] = now
 	}
@@ -138,6 +146,7 @@ func TestPeeringHandlerCapDropsAndCounts(t *testing.T) {
 	if tracked != maxTrackedPaths {
 		t.Fatalf("want map size %d after drop, got %d", maxTrackedPaths, tracked)
 	}
+
 	if dropped != 1 {
 		t.Fatalf("want dropped count 1, got %d", dropped)
 	}
@@ -150,6 +159,7 @@ func TestPeeringHandlerCapDropsAndCounts(t *testing.T) {
 	if tracked != maxTrackedPaths {
 		t.Fatalf("want map size %d after refresh, got %d", maxTrackedPaths, tracked)
 	}
+
 	if dropped != 1 {
 		t.Fatalf("want dropped count still 1 after refresh, got %d", dropped)
 	}
@@ -157,7 +167,9 @@ func TestPeeringHandlerCapDropsAndCounts(t *testing.T) {
 	h.mu.Lock()
 	gotTS := h.asPaths[existing]
 	h.mu.Unlock()
+
 	if !gotTS.Equal(refreshed) {
-		t.Fatalf("existing path timestamp not refreshed: want %v, got %v", refreshed, gotTS)
+		t.Fatalf("existing path timestamp not refreshed: want %v, got %v",
+			refreshed, gotTS)
 	}
 }

internal/routewatch/prefixhandler.go

@@ -41,9 +41,9 @@ const (
 	ipv6Version = 6
 )
 
-// PrefixHandler tracks BGP prefixes and maintains a live routing table in the database.
-// Routes are added on announcement and deleted on withdrawal, and all routes of
-// a peer are deleted when its BGP session goes down.
+// PrefixHandler tracks BGP prefixes and maintains a live routing table in the
+// database. Routes are added on announcement and deleted on withdrawal, and all
+// routes of a peer are deleted when its BGP session goes down.
 type PrefixHandler struct {
 	db      database.Store
 	logger  *logger.Logger
@@ -52,10 +52,14 @@ type PrefixHandler struct {
 	// Batching. mu guards batch and peersDown only: the flush goroutine takes
 	// both under mu and writes them after releasing mu, so HandleMessage
 	// waits for a database write only while batch is at prefixBatchMaxSize.
-	mu          sync.Mutex
-	batch       []prefixUpdate
-	peersDown   []string      // peers whose BGP session went down since the batch was taken
-	batchTaken  sync.Cond     // signalled when the flush goroutine takes batch; its L is &mu
+	mu    sync.Mutex
+	batch []prefixUpdate
+	// peersDown holds the peers whose BGP session went down since the batch
+	// was taken.
+	peersDown []string
+	// batchTaken is signalled when the flush goroutine takes batch; its L is
+	// &mu.
+	batchTaken  sync.Cond
 	batchFullCh chan struct{} // wakes the flush goroutine when batch is full
 	lastFlush   time.Time     // used only by the flush goroutine
 	stopCh      chan struct{}
@@ -95,11 +99,13 @@ func (h *PrefixHandler) SetMetricsTracker(metrics *metrics.Tracker) {
 	h.metrics = metrics
 }
 
-// WantsMessage returns true if this handler wants to process messages of the given type
+// WantsMessage returns true if this handler wants to process messages of the
+// given type
 func (h *PrefixHandler) WantsMessage(messageType string) bool {
 	// UPDATE messages change routes; a STATE message can say a peer's
 	// session went down, which removes all of its routes.
-	return messageType == ristypes.MessageTypeUpdate || messageType == ristypes.MessageTypeState
+	return messageType == ristypes.MessageTypeUpdate ||
+		messageType == ristypes.MessageTypeState
 }
 
 // QueueCapacity returns the desired queue capacity for this handler
@@ -183,6 +189,12 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 	}
 }
 
+// Stop gracefully stops the handler and flushes remaining batches
+func (h *PrefixHandler) Stop() {
+	close(h.stopCh)
+	h.wg.Wait()
+}
+
 // peerSessionDown notes that the peer's BGP session went down, so that the next
 // flush deletes all of the peer's live routes before it writes the batch. The
 // peer's updates still in the batch came before the down, which replaces them,
@@ -192,7 +204,9 @@ func (h *PrefixHandler) peerSessionDown(peer string) {
 	h.mu.Lock()
 	defer h.mu.Unlock()
 
-	h.batch = slices.DeleteFunc(h.batch, func(update prefixUpdate) bool { return update.peer == peer })
+	h.batch = slices.DeleteFunc(h.batch, func(update prefixUpdate) bool {
+		return update.peer == peer
+	})
 	h.peersDown = append(h.peersDown, peer)
 }
 
@@ -200,6 +214,7 @@ func (h *PrefixHandler) peerSessionDown(peer string) {
 // flushes when the batch is full, periodically, and once more on Stop.
 func (h *PrefixHandler) flushLoop() {
 	defer h.wg.Done()
+
 	ticker := time.NewTicker(prefixBatchTimeout)
 	defer ticker.Stop()
 
@@ -230,6 +245,7 @@ func (h *PrefixHandler) takeBatch() ([]prefixUpdate, []string) {
 	if len(h.batch) == 0 && len(h.peersDown) == 0 {
 		return nil, nil
 	}
+
 	batch, peersDown := h.batch, h.peersDown
 	h.batch = make([]prefixUpdate, 0, prefixBatchSize)
 	h.peersDown = nil
@@ -250,43 +266,34 @@ func (h *PrefixHandler) flushBatch() {
 	batchSize := len(batch)
 
 	// The routes of a peer whose session went down are deleted first: the
-	// batch holds only the updates the peer sent after the down. Most downs
-	// come from peers that have no routes, so only a delete that removed
-	// routes is logged.
-	for _, peer := range peersDown {
-		deleted, err := h.db.DeleteLiveRoutesOfPeer(peer)
-		if err != nil {
-			h.logger.Error("Failed to delete the live routes of a peer whose session went down",
-				"peer", peer, "error", err)
-
-			continue
-		}
-		if deleted > 0 {
-			h.logger.Info("Deleted the live routes of a peer whose session went down",
-				"peer", peer, "routes", deleted)
-		}
-	}
+	// batch holds only the updates the peer sent after the down.
+	h.deleteLiveRoutesOfPeers(peersDown)
 
 	// For each prefix and peer, keep only the last update the feed delivered.
 	// Updates from different peers for the same prefix are all kept. Arrival
 	// order decides, not the timestamp: timestamps are whole seconds, so
 	// updates within one second carry the same one.
 	type prefixAndPeer struct{ prefix, peer string }
+
 	lastUpdates := make(map[prefixAndPeer]prefixUpdate)
+
 	for _, update := range batch {
 		lastUpdates[prefixAndPeer{update.prefix, update.peer}] = update
 	}
 
 	// Collect routes to upsert and delete
-	var routesToUpsert []*database.LiveRoute
-	var routesToDelete []database.LiveRouteDeletion
+	var (
+		routesToUpsert []*database.LiveRoute
+		routesToDelete []database.LiveRouteDeletion
+	)
 
 	// Collect unique prefixes to update
 	prefixesToUpdate := make(map[string]time.Time)
 
 	for _, update := range lastUpdates {
 		// Track prefix for both announcements and withdrawals
-		if _, exists := prefixesToUpdate[update.prefix]; !exists || update.timestamp.After(prefixesToUpdate[update.prefix]) {
+		seen, exists := prefixesToUpdate[update.prefix]
+		if !exists || update.timestamp.After(seen) {
 			prefixesToUpdate[update.prefix] = update.timestamp
 		}
 
@@ -300,7 +307,8 @@ func (h *PrefixHandler) flushBatch() {
 			// Parse CIDR to get IP version
 			_, ipVersion, err := parseCIDR(update.prefix)
 			if err != nil {
-				h.logger.Error("Failed to parse CIDR for withdrawal", "prefix", update.prefix, "error", err)
+				h.logger.Error("Failed to parse CIDR for withdrawal",
+					"prefix", update.prefix, "error", err)
 
 				continue
 			}
@@ -314,30 +322,7 @@ func (h *PrefixHandler) flushBatch() {
 		}
 	}
 
-	// Process batch operations
-	successCount := 0
-	if len(routesToUpsert) > 0 {
-		if err := h.db.UpsertLiveRouteBatch(routesToUpsert); err != nil {
-			h.logger.Error("Failed to upsert route batch", "error", err, "count", len(routesToUpsert))
-		} else {
-			successCount += len(routesToUpsert)
-		}
-	}
-
-	if len(routesToDelete) > 0 {
-		if err := h.db.DeleteLiveRouteBatch(routesToDelete); err != nil {
-			h.logger.Error("Failed to delete route batch", "error", err, "count", len(routesToDelete))
-		} else {
-			successCount += len(routesToDelete)
-		}
-	}
-
-	// Update prefix tables
-	if len(prefixesToUpdate) > 0 {
-		if err := h.db.UpdatePrefixesBatch(prefixesToUpdate); err != nil {
-			h.logger.Error("Failed to update prefix batch", "error", err, "count", len(prefixesToUpdate))
-		}
-	}
+	successCount := h.writeBatch(routesToUpsert, routesToDelete, prefixesToUpdate)
 
 	elapsed := time.Since(startTime)
 	h.logger.Debug("Flushed prefix batch",
@@ -351,6 +336,69 @@ func (h *PrefixHandler) flushBatch() {
 	h.lastFlush = time.Now()
 }
 
+// deleteLiveRoutesOfPeers deletes all live routes of each of peers, the peers
+// whose BGP session went down. Most downs come from peers that have no routes,
+// so only a delete that removed routes is logged.
+func (h *PrefixHandler) deleteLiveRoutesOfPeers(peers []string) {
+	for _, peer := range peers {
+		deleted, err := h.db.DeleteLiveRoutesOfPeer(peer)
+		if err != nil {
+			h.logger.Error(
+				"Failed to delete the live routes of a peer whose session went down",
+				"peer", peer, "error", err)
+
+			continue
+		}
+
+		if deleted > 0 {
+			h.logger.Info(
+				"Deleted the live routes of a peer whose session went down",
+				"peer", peer, "routes", deleted)
+		}
+	}
+}
+
+// writeBatch writes the collected route upserts, route deletions and prefix
+// updates to the database and returns how many routes it wrote.
+func (h *PrefixHandler) writeBatch(
+	routesToUpsert []*database.LiveRoute,
+	routesToDelete []database.LiveRouteDeletion,
+	prefixesToUpdate map[string]time.Time,
+) int {
+	successCount := 0
+
+	if len(routesToUpsert) > 0 {
+		err := h.db.UpsertLiveRouteBatch(routesToUpsert)
+		if err != nil {
+			h.logger.Error("Failed to upsert route batch",
+				"error", err, "count", len(routesToUpsert))
+		} else {
+			successCount += len(routesToUpsert)
+		}
+	}
+
+	if len(routesToDelete) > 0 {
+		err := h.db.DeleteLiveRouteBatch(routesToDelete)
+		if err != nil {
+			h.logger.Error("Failed to delete route batch",
+				"error", err, "count", len(routesToDelete))
+		} else {
+			successCount += len(routesToDelete)
+		}
+	}
+
+	// Update prefix tables
+	if len(prefixesToUpdate) > 0 {
+		err := h.db.UpdatePrefixesBatch(prefixesToUpdate)
+		if err != nil {
+			h.logger.Error("Failed to update prefix batch",
+				"error", err, "count", len(prefixesToUpdate))
+		}
+	}
+
+	return successCount
+}
+
 // canonicalPrefix returns prefix in the text form net/netip prints, the form
 // the IP lookup builds when it looks a prefix up. The feed sends IPv6
 // announcements compressed ("2001:db8::/32") but IPv6 withdrawals uncompressed
@@ -366,8 +414,8 @@ func canonicalPrefix(prefix string) string {
 	return p.Masked().String()
 }
 
-// parseCIDR extracts the mask length and IP version from a prefix string
-func parseCIDR(prefix string) (maskLength int, ipVersion int, err error) {
+// parseCIDR returns the mask length and the IP version of a prefix string
+func parseCIDR(prefix string) (int, int, error) {
 	_, ipNet, err := net.ParseCIDR(prefix)
 	if err != nil {
 		return 0, 0, err
@@ -381,50 +429,6 @@ func parseCIDR(prefix string) (maskLength int, ipVersion int, err error) {
 	return ones, ipv4Version, nil
 }
 
-// processAnnouncement handles storing an announcement in the database
-// nolint:unused // kept for potential future use
-func (h *PrefixHandler) processAnnouncement(_ *database.Prefix, update prefixUpdate) {
-	// Parse CIDR to get mask length
-	maskLength, ipVersion, err := parseCIDR(update.prefix)
-	if err != nil {
-		h.logger.Error("Failed to parse CIDR",
-			"prefix", update.prefix,
-			"error", err,
-		)
-
-		return
-	}
-
-	// Track route update metrics
-	if h.metrics != nil {
-		if ipVersion == ipv4Version {
-			h.metrics.RecordIPv4Update()
-		} else {
-			h.metrics.RecordIPv6Update()
-		}
-	}
-
-	// Create live route record
-	liveRoute := &database.LiveRoute{
-		ID:          uuid.New(),
-		Prefix:      update.prefix,
-		MaskLength:  maskLength,
-		IPVersion:   ipVersion,
-		OriginASN:   update.originASN,
-		PeerIP:      update.peer,
-		ASPath:      update.path,
-		NextHop:     update.peer, // Using peer as next hop
-		LastUpdated: update.timestamp,
-	}
-
-	if err := h.db.UpsertLiveRoute(liveRoute); err != nil {
-		h.logger.Error("Failed to upsert live route",
-			"prefix", update.prefix,
-			"error", err,
-		)
-	}
-}
-
 // createLiveRoute creates a LiveRoute from a prefix update
 func (h *PrefixHandler) createLiveRoute(update prefixUpdate) *database.LiveRoute {
 	// Parse CIDR to get mask length
@@ -462,77 +466,3 @@ func (h *PrefixHandler) createLiveRoute(update prefixUpdate) *database.LiveRoute
 
 	return liveRoute
 }
-
-// processAnnouncementDirect handles storing an announcement directly without prefix table
-// nolint:unused // kept for potential future use
-func (h *PrefixHandler) processAnnouncementDirect(update prefixUpdate) {
-	// Parse CIDR to get mask length
-	maskLength, ipVersion, err := parseCIDR(update.prefix)
-	if err != nil {
-		h.logger.Error("Failed to parse CIDR",
-			"prefix", update.prefix,
-			"error", err,
-		)
-
-		return
-	}
-
-	// Track route update metrics
-	if h.metrics != nil {
-		if ipVersion == ipv4Version {
-			h.metrics.RecordIPv4Update()
-		} else {
-			h.metrics.RecordIPv6Update()
-		}
-	}
-
-	// Create live route record
-	liveRoute := &database.LiveRoute{
-		ID:          uuid.New(),
-		Prefix:      update.prefix,
-		MaskLength:  maskLength,
-		IPVersion:   ipVersion,
-		OriginASN:   update.originASN,
-		PeerIP:      update.peer,
-		ASPath:      update.path,
-		NextHop:     update.peer, // Using peer as next hop
-		LastUpdated: update.timestamp,
-	}
-
-	if err := h.db.UpsertLiveRoute(liveRoute); err != nil {
-		h.logger.Error("Failed to upsert live route",
-			"prefix", update.prefix,
-			"error", err,
-		)
-	}
-}
-
-// processWithdrawalDirect handles removing a route directly without prefix table
-// nolint:unused // kept for potential future use
-func (h *PrefixHandler) processWithdrawalDirect(update prefixUpdate) {
-	if err := h.db.DeleteLiveRoute(update.prefix, update.peer); err != nil {
-		h.logger.Error("Failed to delete live route",
-			"prefix", update.prefix,
-			"peer", update.peer,
-			"error", err,
-		)
-	}
-}
-
-// processWithdrawal handles removing a route from the live routing table
-// nolint:unused // kept for potential future use
-func (h *PrefixHandler) processWithdrawal(_ *database.Prefix, update prefixUpdate) {
-	if err := h.db.DeleteLiveRoute(update.prefix, update.peer); err != nil {
-		h.logger.Error("Failed to delete live route",
-			"prefix", update.prefix,
-			"peer", update.peer,
-			"error", err,
-		)
-	}
-}
-
-// Stop gracefully stops the handler and flushes remaining batches
-func (h *PrefixHandler) Stop() {
-	close(h.stopCh)
-	h.wg.Wait()
-}

internal/routewatch/prefixhandler_internal_test.go

@@ -17,6 +17,12 @@ import (
 
 const testPeerIP = "2001:db8:ffff::1"
 
+// An IPv4 and an IPv6 prefix the tests announce.
+const (
+	testV4Prefix = "192.0.2.0/24"
+	testV6Prefix = "2001:db8:1::/48"
+)
+
 // TestPrefixHandlerStoresPrefixesTheIPLookupFinds runs announcements and
 // withdrawals through the prefix handler into a real database and looks the
 // addresses up. The prefixes are written the way the feed sends them: IPv6
@@ -24,11 +30,9 @@ const testPeerIP = "2001:db8:ffff::1"
 // remove the route the announcement stored, and the IP lookup must find the
 // stored prefix.
 func TestPrefixHandlerStoresPrefixesTheIPLookupFinds(t *testing.T) {
-	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer func() { _ = db.Close() }()
+	t.Parallel()
+
+	db := newTestDatabase(t)
 
 	// Built without NewPrefixHandler's flush timer, so the test flushes itself.
 	h := &PrefixHandler{db: db, logger: logger.New()}
@@ -40,34 +44,38 @@ func TestPrefixHandlerStoresPrefixesTheIPLookupFinds(t *testing.T) {
 		ParsedTimestamp: ts,
 		Announcements: []ristypes.RISAnnouncement{{
 			NextHop:  testPeerIP,
-			Prefixes: []string{"2001:db8:1::/48", "192.0.2.0/24"},
+			Prefixes: []string{testV6Prefix, testV4Prefix},
 		}},
 	})
 	h.flushBatch()
 
 	for ip, want := range map[string]string{
-		"2001:db8:1::1": "2001:db8:1::/48",
-		"192.0.2.1":     "192.0.2.0/24",
+		"2001:db8:1::1": testV6Prefix,
+		"192.0.2.1":     testV4Prefix,
 	} {
 		info, err := db.GetIPInfo(ip)
 		if err != nil {
 			t.Fatalf("GetIPInfo(%s) after announcement: %v", ip, err)
 		}
+
 		if info.Netblock != want || info.ASN != testASNB {
-			t.Errorf("GetIPInfo(%s) = %s AS%d, want %s AS%d", ip, info.Netblock, info.ASN, want, testASNB)
+			t.Errorf("GetIPInfo(%s) = %s AS%d, want %s AS%d",
+				ip, info.Netblock, info.ASN, want, testASNB)
 		}
 	}
 
 	h.HandleMessage(&ristypes.RISMessage{
 		Peer:            testPeerIP,
 		ParsedTimestamp: ts.Add(time.Minute),
-		Withdrawals:     []string{"2001:db8:1:0:0:0:0:0/48", "192.0.2.0/24"},
+		Withdrawals:     []string{"2001:db8:1:0:0:0:0:0/48", testV4Prefix},
 	})
 	h.flushBatch()
 
 	for _, ip := range []string{"2001:db8:1::1", "192.0.2.1"} {
-		if info, err := db.GetIPInfo(ip); !errors.Is(err, database.ErrNoRoute) {
-			t.Errorf("GetIPInfo(%s) after withdrawal = %+v, %v; want ErrNoRoute", ip, info, err)
+		info, err := db.GetIPInfo(ip)
+		if !errors.Is(err, database.ErrNoRoute) {
+			t.Errorf("GetIPInfo(%s) after withdrawal = %+v, %v; want ErrNoRoute",
+				ip, info, err)
 		}
 	}
 }
@@ -79,6 +87,8 @@ func TestPrefixHandlerStoresPrefixesTheIPLookupFinds(t *testing.T) {
 // live route for it, and updates from different peers are all applied. The
 // in-memory route count and prefix distribution must match the route table.
 func TestPrefixHandlerAppliesEachPeersLastUpdateInABatch(t *testing.T) {
+	t.Parallel()
+
 	const (
 		prefix           = "198.51.100.0/24"
 		prefixMaskLength = 24
@@ -91,11 +101,14 @@ func TestPrefixHandlerAppliesEachPeersLastUpdateInABatch(t *testing.T) {
 			Peer:            peer,
 			Path:            ristypes.ASPath{testASNA, testASNB},
 			ParsedTimestamp: ts,
-			Announcements:   []ristypes.RISAnnouncement{{NextHop: peer, Prefixes: []string{prefix}}},
+			Announcements: []ristypes.RISAnnouncement{
+				{NextHop: peer, Prefixes: []string{prefix}},
+			},
 		}
 	}
 	withdraw := func(peer string) *ristypes.RISMessage {
-		return &ristypes.RISMessage{Peer: peer, ParsedTimestamp: ts, Withdrawals: []string{prefix}}
+		return &ristypes.RISMessage{Peer: peer, ParsedTimestamp: ts,
+			Withdrawals: []string{prefix}}
 	}
 	announceAndWithdraw := func(peer string) *ristypes.RISMessage {
 		msg := announce(peer)
@@ -112,8 +125,10 @@ func TestPrefixHandlerAppliesEachPeersLastUpdateInABatch(t *testing.T) {
 		wantPeers []string
 	}{
 		{
-			name:      "two peers announce the prefix",
-			batches:   [][]*ristypes.RISMessage{{announce(testPeerIP), announce(otherPeerIP)}},
+			name: "two peers announce the prefix",
+			batches: [][]*ristypes.RISMessage{
+				{announce(testPeerIP), announce(otherPeerIP)},
+			},
 			wantPeers: []string{testPeerIP, otherPeerIP},
 		},
 		{
@@ -149,39 +164,10 @@ func TestPrefixHandlerAppliesEachPeersLastUpdateInABatch(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-			if err != nil {
-				t.Fatalf("failed to create database: %v", err)
-			}
-			defer func() { _ = db.Close() }()
+			t.Parallel()
 
-			// Built without NewPrefixHandler's flush timer, so the test flushes itself.
-			h := &PrefixHandler{db: db, logger: logger.New()}
-			for _, batch := range tt.batches {
-				for _, msg := range batch {
-					h.HandleMessage(msg)
-				}
-				h.flushBatch()
-			}
-
-			ctx := context.Background()
-			routes, _, err := db.GetPrefixDetailsContext(ctx, prefix)
-			if err != nil && !errors.Is(err, database.ErrNoRoute) {
-				t.Fatalf("GetPrefixDetailsContext: %v", err)
-			}
-			var gotPeers []string
-			for _, route := range routes {
-				gotPeers = append(gotPeers, route.PeerIP)
-			}
-			if !slices.Equal(gotPeers, tt.wantPeers) {
-				t.Errorf("peers with a live route for %s = %v, want %v", prefix, gotPeers, tt.wantPeers)
-			}
-
-			var wantDistribution []database.PrefixDistribution
-			if len(tt.wantPeers) > 0 {
-				wantDistribution = []database.PrefixDistribution{{MaskLength: prefixMaskLength, Count: 1}}
-			}
-			assertCounts(t, db, ipv4Version, len(tt.wantPeers), wantDistribution)
+			db := handleBatches(t, tt.batches)
+			checkLivePeers(t, db, prefix, prefixMaskLength, tt.wantPeers)
 		})
 	}
 }
@@ -194,14 +180,22 @@ func TestPrefixHandlerAppliesEachPeersLastUpdateInABatch(t *testing.T) {
 // in. The in-memory route count and prefix distribution must match the route
 // table.
 func TestPrefixHandlerKeepsOneRoutePerPrefixAndPeer(t *testing.T) {
+	t.Parallel()
+
 	families := []struct {
 		ipVersion           int
 		prefix, otherPrefix string
 		// The mask length of both prefixes.
 		maskLength int
 	}{
-		{ipVersion: ipv4Version, prefix: "198.51.100.0/24", otherPrefix: "203.0.113.0/24", maskLength: 24},
-		{ipVersion: ipv6Version, prefix: "2001:db8:1::/48", otherPrefix: "2001:db8:2::/48", maskLength: 48},
+		{
+			ipVersion: ipv4Version, maskLength: 24,
+			prefix: "198.51.100.0/24", otherPrefix: "203.0.113.0/24",
+		},
+		{
+			ipVersion: ipv6Version, maskLength: 48,
+			prefix: testV6Prefix, otherPrefix: "2001:db8:2::/48",
+		},
 	}
 
 	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
@@ -210,7 +204,9 @@ func TestPrefixHandlerKeepsOneRoutePerPrefixAndPeer(t *testing.T) {
 			Peer:            testPeerIP,
 			Path:            path,
 			ParsedTimestamp: ts,
-			Announcements:   []ristypes.RISAnnouncement{{NextHop: testPeerIP, Prefixes: []string{announced}}},
+			Announcements: []ristypes.RISAnnouncement{
+				{NextHop: testPeerIP, Prefixes: []string{announced}},
+			},
 		}
 	}
 
@@ -219,71 +215,50 @@ func TestPrefixHandlerKeepsOneRoutePerPrefixAndPeer(t *testing.T) {
 
 		// One message that announces otherPrefix with origin AS testASNB and
 		// withdraws prefix.
-		announceOtherAndWithdraw := announce(ristypes.ASPath{testASNA, testASNB}, otherPrefix)
+		announceOtherAndWithdraw := announce(
+			ristypes.ASPath{testASNA, testASNB}, otherPrefix)
 		announceOtherAndWithdraw.Withdrawals = []string{prefix}
 
 		tests := []struct {
-			name     string
-			messages []*ristypes.RISMessage
+			name string
+			// Each message is handled and then flushed as its own batch.
+			batches [][]*ristypes.RISMessage
 			// The origin AS of the peer's live route for each prefix. A prefix
 			// left out must have no live route.
 			wantOrigins map[string]int
 		}{
 			{
 				name: "the peer announces the prefix with a new origin AS",
-				messages: []*ristypes.RISMessage{
-					announce(ristypes.ASPath{testASNA}, prefix),
-					announce(ristypes.ASPath{testASNA, testASNB}, prefix),
+				batches: [][]*ristypes.RISMessage{
+					{announce(ristypes.ASPath{testASNA}, prefix)},
+					{announce(ristypes.ASPath{testASNA, testASNB}, prefix)},
 				},
 				wantOrigins: map[string]int{prefix: testASNB},
 			},
 			{
-				name: "one message announces a prefix with another origin AS and withdraws the prefix",
-				messages: []*ristypes.RISMessage{
-					announce(ristypes.ASPath{testASNA}, prefix),
-					announceOtherAndWithdraw,
+				name: "one message announces a prefix with another origin AS " +
+					"and withdraws the prefix",
+				batches: [][]*ristypes.RISMessage{
+					{announce(ristypes.ASPath{testASNA}, prefix)},
+					{announceOtherAndWithdraw},
 				},
 				wantOrigins: map[string]int{otherPrefix: testASNB},
 			},
 		}
 
 		for _, tt := range tests {
-			t.Run(fmt.Sprintf("IPv%d %s", family.ipVersion, tt.name), func(t *testing.T) {
-				db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-				if err != nil {
-					t.Fatalf("failed to create database: %v", err)
-				}
-				defer func() { _ = db.Close() }()
+			name := fmt.Sprintf("IPv%d %s", family.ipVersion, tt.name)
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
 
-				// Built without NewPrefixHandler's flush timer, so the test flushes itself.
-				h := &PrefixHandler{db: db, logger: logger.New()}
-				for _, msg := range tt.messages {
-					h.HandleMessage(msg)
-					h.flushBatch()
-				}
-
-				for _, p := range []string{prefix, otherPrefix} {
-					routes, _, err := db.GetPrefixDetailsContext(context.Background(), p)
-					if err != nil && !errors.Is(err, database.ErrNoRoute) {
-						t.Fatalf("GetPrefixDetailsContext(%s): %v", p, err)
-					}
-					var gotOrigins []int
-					for _, route := range routes {
-						gotOrigins = append(gotOrigins, route.OriginASN)
-					}
-					var wantOrigins []int
-					if origin, ok := tt.wantOrigins[p]; ok {
-						wantOrigins = []int{origin}
-					}
-					if !slices.Equal(gotOrigins, wantOrigins) {
-						t.Errorf("origin ASes of the live routes for %s = %v, want %v", p, gotOrigins, wantOrigins)
-					}
-				}
+				db := handleBatches(t, tt.batches)
+				checkLiveOrigins(t, db, tt.wantOrigins, prefix, otherPrefix)
 
 				wantDistribution := []database.PrefixDistribution{
 					{MaskLength: family.maskLength, Count: len(tt.wantOrigins)},
 				}
-				assertCounts(t, db, family.ipVersion, len(tt.wantOrigins), wantDistribution)
+				assertCounts(t, db, family.ipVersion, len(tt.wantOrigins),
+					wantDistribution)
 			})
 		}
 	}
@@ -293,12 +268,16 @@ func TestPrefixHandlerKeepsOneRoutePerPrefixAndPeer(t *testing.T) {
 // messages go to the prefix handler, which acts on a down, and not to the peer
 // handler, which would record a peer whose session never comes up as active.
 func TestStateMessagesGoToThePrefixHandlerNotThePeerHandler(t *testing.T) {
+	t.Parallel()
+
 	if !(&PrefixHandler{}).WantsMessage(ristypes.MessageTypeState) {
 		t.Error("the prefix handler does not want STATE messages")
 	}
+
 	if (&PeerHandler{}).WantsMessage(ristypes.MessageTypeState) {
 		t.Error("the peer handler wants STATE messages")
 	}
+
 	if !(&PeerHandler{}).WantsMessage(ristypes.MessageTypeUpdate) {
 		t.Error("the peer handler does not want UPDATE messages")
 	}
@@ -313,6 +292,8 @@ func TestStateMessagesGoToThePrefixHandlerNotThePeerHandler(t *testing.T) {
 // in the same batch, is kept. The in-memory route counts and prefix
 // distribution must match the route tables.
 func TestPrefixHandlerDeletesAPeersRoutesWhenItsSessionGoesDown(t *testing.T) {
+	t.Parallel()
+
 	const (
 		otherPeerIP = "2001:db8:ffff::2"
 		// Both peers announce the shared prefixes, only testPeerIP the others.
@@ -335,14 +316,17 @@ func TestPrefixHandlerDeletesAPeersRoutesWhenItsSessionGoesDown(t *testing.T) {
 		wantAfterDown bool
 	}{
 		{
-			name:  "the down ends the batch",
-			batch: []*ristypes.RISMessage{peerAnnouncement(testPeerIP, beforeDown), sessionDown(testPeerIP)},
+			name: "the down ends the batch",
+			batch: []*ristypes.RISMessage{
+				peerAnnouncement(testPeerIP, beforeDown),
+				sessionDown(),
+			},
 		},
 		{
 			name: "the peer announces a prefix after the down",
 			batch: []*ristypes.RISMessage{
 				peerAnnouncement(testPeerIP, beforeDown),
-				sessionDown(testPeerIP),
+				sessionDown(),
 				peerAnnouncement(testPeerIP, afterDown),
 			},
 			wantAfterDown: true,
@@ -351,21 +335,16 @@ func TestPrefixHandlerDeletesAPeersRoutesWhenItsSessionGoesDown(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-			if err != nil {
-				t.Fatalf("failed to create database: %v", err)
-			}
-			defer func() { _ = db.Close() }()
+			t.Parallel()
 
-			// Built without NewPrefixHandler's flush timer, so the test flushes itself.
-			h := &PrefixHandler{db: db, logger: logger.New()}
-			h.HandleMessage(peerAnnouncement(testPeerIP, sharedV4, sharedV6, onlyV4, onlyV6))
-			h.HandleMessage(peerAnnouncement(otherPeerIP, sharedV4, sharedV6))
-			h.flushBatch()
-			for _, msg := range tt.batch {
-				h.HandleMessage(msg)
-			}
-			h.flushBatch()
+			db := handleBatches(t, [][]*ristypes.RISMessage{
+				{
+					peerAnnouncement(testPeerIP,
+						sharedV4, sharedV6, onlyV4, onlyV6),
+					peerAnnouncement(otherPeerIP, sharedV4, sharedV6),
+				},
+				tt.batch,
+			})
 
 			// The peers left with a live route for each prefix.
 			wantPeers := map[string][]string{
@@ -377,16 +356,20 @@ func TestPrefixHandlerDeletesAPeersRoutesWhenItsSessionGoesDown(t *testing.T) {
 				afterDown:  nil,
 			}
 			wantRoutesV6 := 1
+
 			if tt.wantAfterDown {
 				wantPeers[afterDown] = []string{testPeerIP}
 				wantRoutesV6++
 			}
 
 			assertPeers(t, db, wantPeers)
-			assertCounts(t, db, ipv4Version, 1,
-				[]database.PrefixDistribution{{MaskLength: maskLengthV4, Count: 1}})
+			assertCounts(t, db, ipv4Version, 1, []database.PrefixDistribution{
+				{MaskLength: maskLengthV4, Count: 1},
+			})
 			assertCounts(t, db, ipv6Version, wantRoutesV6,
-				[]database.PrefixDistribution{{MaskLength: maskLengthV6, Count: wantRoutesV6}})
+				[]database.PrefixDistribution{
+					{MaskLength: maskLengthV6, Count: wantRoutesV6},
+				})
 		})
 	}
 }
@@ -398,6 +381,8 @@ func TestPrefixHandlerDeletesAPeersRoutesWhenItsSessionGoesDown(t *testing.T) {
 // that handles it and on no later flush, so the route the peer announced after
 // it is kept.
 func TestPrefixHandlerKeepsWhatAPeerAnnouncesAfterTheFlushOfItsDown(t *testing.T) {
+	t.Parallel()
+
 	const (
 		otherPeerIP = "2001:db8:ffff::2"
 		beforeDown  = "192.0.2.0/24"
@@ -406,30 +391,22 @@ func TestPrefixHandlerKeepsWhatAPeerAnnouncesAfterTheFlushOfItsDown(t *testing.T
 		maskLength  = 24
 	)
 
-	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer func() { _ = db.Close() }()
-
-	// Built without NewPrefixHandler's flush timer, so the test flushes itself.
-	h := &PrefixHandler{db: db, logger: logger.New()}
-	for _, msg := range []*ristypes.RISMessage{
-		peerAnnouncement(testPeerIP, beforeDown),
-		sessionDown(testPeerIP),
-		peerAnnouncement(testPeerIP, afterDown),
-		peerAnnouncement(otherPeerIP, otherPeers),
-	} {
-		h.HandleMessage(msg)
-		h.flushBatch()
-	}
+	// Each message is handled and then flushed as its own batch.
+	db := handleBatches(t, [][]*ristypes.RISMessage{
+		{peerAnnouncement(testPeerIP, beforeDown)},
+		{sessionDown()},
+		{peerAnnouncement(testPeerIP, afterDown)},
+		{peerAnnouncement(otherPeerIP, otherPeers)},
+	})
 
 	assertPeers(t, db, map[string][]string{
 		beforeDown: nil,
 		afterDown:  {testPeerIP},
 		otherPeers: {otherPeerIP},
 	})
-	assertCounts(t, db, ipv4Version, 2, []database.PrefixDistribution{{MaskLength: maskLength, Count: 2}})
+	assertCounts(t, db, ipv4Version, 2, []database.PrefixDistribution{
+		{MaskLength: maskLength, Count: 2},
+	})
 }
 
 // firstWriteHeldStore is a real database whose first live route batch write
@@ -442,7 +419,11 @@ type firstWriteHeldStore struct {
 	once         sync.Once
 }
 
-func (s *firstWriteHeldStore) UpsertLiveRouteBatch(routes []*database.LiveRoute) error {
+// UpsertLiveRouteBatch holds the first call until release is closed, then
+// writes routes to the database.
+func (s *firstWriteHeldStore) UpsertLiveRouteBatch(
+	routes []*database.LiveRoute,
+) error {
 	s.once.Do(func() {
 		close(s.writeStarted)
 		<-s.release
@@ -457,27 +438,32 @@ func (s *firstWriteHeldStore) UpsertLiveRouteBatch(routes []*database.LiveRoute)
 // must delete the route the held write stored and keep the one announced after
 // the down.
 func TestPrefixHandlerHandlesADownWhileAFlushWrites(t *testing.T) {
+	t.Parallel()
+
 	const (
 		beforeDown = "192.0.2.0/24"
 		afterDown  = "198.51.100.0/24"
 		maskLength = 24
 	)
 
-	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
+	db := newTestDatabase(t)
+	store := &firstWriteHeldStore{
+		Database:     db,
+		writeStarted: make(chan struct{}),
+		release:      make(chan struct{}),
 	}
-	defer func() { _ = db.Close() }()
-	store := &firstWriteHeldStore{Database: db, writeStarted: make(chan struct{}), release: make(chan struct{})}
 
 	// Built without NewPrefixHandler's flush timer, so the test flushes itself.
 	h := &PrefixHandler{db: store, logger: logger.New()}
 	h.HandleMessage(peerAnnouncement(testPeerIP, beforeDown))
+
 	flushed := make(chan struct{})
+
 	go func() {
 		h.flushBatch()
 		close(flushed)
 	}()
+
 	select {
 	case <-store.writeStarted:
 	case <-time.After(handleMessageTimeout):
@@ -485,21 +471,67 @@ func TestPrefixHandlerHandlesADownWhileAFlushWrites(t *testing.T) {
 	}
 
 	if !returnsInTime(func() {
-		h.HandleMessage(sessionDown(testPeerIP))
+		h.HandleMessage(sessionDown())
 		h.HandleMessage(peerAnnouncement(testPeerIP, afterDown))
 	}) {
 		t.Fatal("HandleMessage did not return while a database write was held")
 	}
+
 	close(store.release)
+
 	select {
 	case <-flushed:
 	case <-time.After(handleMessageTimeout):
 		t.Fatal("the flush did not finish after its write was let go")
 	}
+
 	h.flushBatch()
 
-	assertPeers(t, db, map[string][]string{beforeDown: nil, afterDown: {testPeerIP}})
-	assertCounts(t, db, ipv4Version, 1, []database.PrefixDistribution{{MaskLength: maskLength, Count: 1}})
+	assertPeers(t, db, map[string][]string{
+		beforeDown: nil,
+		afterDown:  {testPeerIP},
+	})
+	assertCounts(t, db, ipv4Version, 1, []database.PrefixDistribution{
+		{MaskLength: maskLength, Count: 1},
+	})
+}
+
+// newTestDatabase opens a database in a new temporary directory. It is closed
+// when the test ends.
+func newTestDatabase(t *testing.T) *database.Database {
+	t.Helper()
+
+	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
+	if err != nil {
+		t.Fatalf("failed to create database: %v", err)
+	}
+
+	t.Cleanup(func() { _ = db.Close() })
+
+	return db
+}
+
+// handleBatches runs each batch of messages through a prefix handler into a
+// new database, flushing after each batch, and returns the database.
+func handleBatches(
+	t *testing.T, batches [][]*ristypes.RISMessage,
+) *database.Database {
+	t.Helper()
+
+	db := newTestDatabase(t)
+
+	// Built without NewPrefixHandler's flush timer, so the test flushes itself.
+	h := &PrefixHandler{db: db, logger: logger.New()}
+
+	for _, batch := range batches {
+		for _, msg := range batch {
+			h.HandleMessage(msg)
+		}
+
+		h.flushBatch()
+	}
+
+	return db
 }
 
 // peerAnnouncement returns an UPDATE message in which peer announces prefixes
@@ -510,18 +542,48 @@ func peerAnnouncement(peer string, prefixes ...string) *ristypes.RISMessage {
 		Peer:            peer,
 		Path:            ristypes.ASPath{testASNA, testASNB},
 		ParsedTimestamp: time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC),
-		Announcements:   []ristypes.RISAnnouncement{{NextHop: peer, Prefixes: prefixes}},
+		Announcements: []ristypes.RISAnnouncement{
+			{NextHop: peer, Prefixes: prefixes},
+		},
 	}
 }
 
-// sessionDown returns the STATE message that says peer's BGP session went down.
-func sessionDown(peer string) *ristypes.RISMessage {
-	return &ristypes.RISMessage{Type: ristypes.MessageTypeState, Peer: peer, State: ristypes.StateDown}
+// sessionDown returns the STATE message that says the BGP session of the peer
+// testPeerIP went down.
+func sessionDown() *ristypes.RISMessage {
+	return &ristypes.RISMessage{
+		Type:  ristypes.MessageTypeState,
+		Peer:  testPeerIP,
+		State: ristypes.StateDown,
+	}
+}
+
+// checkLivePeers checks that exactly wantPeers have a live route for the IPv4
+// prefix, and that the in-memory route count and prefix distribution match
+// the route table.
+func checkLivePeers(
+	t *testing.T, db *database.Database, prefix string, maskLength int,
+	wantPeers []string,
+) {
+	t.Helper()
+
+	assertPeers(t, db, map[string][]string{prefix: wantPeers})
+
+	var wantDistribution []database.PrefixDistribution
+	if len(wantPeers) > 0 {
+		wantDistribution = []database.PrefixDistribution{
+			{MaskLength: maskLength, Count: 1},
+		}
+	}
+
+	assertCounts(t, db, ipv4Version, len(wantPeers), wantDistribution)
 }
 
 // assertPeers checks, for each prefix in wantPeers, that the peers with a live
 // route for it are the ones listed, in peer IP order; nil means none.
-func assertPeers(t *testing.T, db *database.Database, wantPeers map[string][]string) {
+func assertPeers(
+	t *testing.T, db *database.Database, wantPeers map[string][]string,
+) {
 	t.Helper()
 
 	for prefix, want := range wantPeers {
@@ -529,12 +591,46 @@ func assertPeers(t *testing.T, db *database.Database, wantPeers map[string][]str
 		if err != nil && !errors.Is(err, database.ErrNoRoute) {
 			t.Fatalf("GetPrefixDetailsContext(%s): %v", prefix, err)
 		}
-		var got []string
+
+		got := make([]string, 0, len(routes))
 		for _, route := range routes {
 			got = append(got, route.PeerIP)
 		}
+
 		if !slices.Equal(got, want) {
-			t.Errorf("peers with a live route for %s = %v, want %v", prefix, got, want)
+			t.Errorf("peers with a live route for %s = %v, want %v",
+				prefix, got, want)
+		}
+	}
+}
+
+// checkLiveOrigins checks that each of prefixes has one live route, with the
+// origin AS wantOrigins gives for it, or none when wantOrigins leaves it out.
+func checkLiveOrigins(
+	t *testing.T, db *database.Database, wantOrigins map[string]int,
+	prefixes ...string,
+) {
+	t.Helper()
+
+	for _, prefix := range prefixes {
+		routes, _, err := db.GetPrefixDetailsContext(context.Background(), prefix)
+		if err != nil && !errors.Is(err, database.ErrNoRoute) {
+			t.Fatalf("GetPrefixDetailsContext(%s): %v", prefix, err)
+		}
+
+		gotOrigins := make([]int, 0, len(routes))
+		for _, route := range routes {
+			gotOrigins = append(gotOrigins, route.OriginASN)
+		}
+
+		var want []int
+		if origin, ok := wantOrigins[prefix]; ok {
+			want = []int{origin}
+		}
+
+		if !slices.Equal(gotOrigins, want) {
+			t.Errorf("origin ASes of the live routes for %s = %v, want %v",
+				prefix, gotOrigins, want)
 		}
 	}
 }
@@ -542,38 +638,49 @@ func assertPeers(t *testing.T, db *database.Database, wantPeers map[string][]str
 // assertCounts checks that the live route count and prefix distribution of one
 // IP version are wantRoutes and wantDistribution, both as held in memory and as
 // read from the route table.
-func assertCounts(t *testing.T, db *database.Database, ipVersion, wantRoutes int,
-	wantDistribution []database.PrefixDistribution) {
+func assertCounts(
+	t *testing.T, db *database.Database, ipVersion, wantRoutes int,
+	wantDistribution []database.PrefixDistribution,
+) {
 	t.Helper()
 
 	ctx := context.Background()
+
 	stats, err := db.GetStatsContext(ctx)
 	if err != nil {
 		t.Fatalf("GetStatsContext: %v", err)
 	}
+
 	tableRoutesV4, tableRoutesV6, err := db.GetLiveRouteCountsContext(ctx)
 	if err != nil {
 		t.Fatalf("GetLiveRouteCountsContext: %v", err)
 	}
-	queryDistributionV4, queryDistributionV6, err := db.GetPrefixDistributionContext(ctx)
+
+	queryDistributionV4, queryDistributionV6, err :=
+		db.GetPrefixDistributionContext(ctx)
 	if err != nil {
 		t.Fatalf("GetPrefixDistributionContext: %v", err)
 	}
 
 	memoryRoutes, tableRoutes := stats.IPv4Routes, tableRoutesV4
-	memoryDistribution, queryDistribution := stats.IPv4PrefixDistribution, queryDistributionV4
+	memoryDistribution := stats.IPv4PrefixDistribution
+	queryDistribution := queryDistributionV4
+
 	if ipVersion == ipv6Version {
 		memoryRoutes, tableRoutes = stats.IPv6Routes, tableRoutesV6
-		memoryDistribution, queryDistribution = stats.IPv6PrefixDistribution, queryDistributionV6
+		memoryDistribution = stats.IPv6PrefixDistribution
+		queryDistribution = queryDistributionV6
 	}
 
 	if memoryRoutes != wantRoutes || tableRoutes != wantRoutes {
 		t.Errorf("IPv%d live routes: %d in memory, %d in the table, want %d",
 			ipVersion, memoryRoutes, tableRoutes, wantRoutes)
 	}
+
 	if !slices.Equal(memoryDistribution, wantDistribution) ||
 		!slices.Equal(queryDistribution, wantDistribution) {
-		t.Errorf("IPv%d prefix distribution: %v in memory, %v from the table, want %v",
-			ipVersion, memoryDistribution, queryDistribution, wantDistribution)
+		t.Errorf("IPv%d prefix distribution: %v in memory, %v from the table, "+
+			"want %v", ipVersion, memoryDistribution, queryDistribution,
+			wantDistribution)
 	}
 }