Answer 504, not 408, when a request outlasts its time limit (closes #70)

The hand-written time limit middleware answered 408 and wrote that
answer from its own goroutine while the handler could still be writing.
It is replaced by chi's middleware.Timeout, placed after
JSONResponseMiddleware so its 504 is not lost behind a 200.

When a handler's database read or other lookup fails, it asks
deadlinePassed whether the request's time limit passed and, if so,
answers 504 instead of its 500 or 404. JSONValidationMiddleware answers
504 with the JSON error body when the limit has passed and the handler
wrote nothing. status.json and /api/v1/stats answer 504 when their
4-second database read runs out.

Model: opus-5-5

README.md

@@ -141,15 +141,11 @@ routewatch/
 - **Batched Writes**: All database operations are batched for performance
 - **Backpressure**: Probabilistic message dropping when queues exceed 50% capacity
 - **Graceful Shutdown**: 60-second timeout, flushes all pending batches
-- **Reconnection**: Any end of the stream other than shutdown, including RIS Live
+- **Reconnection**: Exponential backoff (5s-320s) with reset after 30s of stable connection
-  ending the response normally, marks the feed disconnected and reconnects with
-  exponential backoff (5s-320s). The backoff resets after a stream that lasted
-  more than 30s. A stream with no line for 60s is dropped and reconnected.
 - **IP Lookup**: the most specific live route is found by looking up the
   address's prefix at each mask length, longest first, in the prefix index
-  (at most 25 lookups for IPv4, 113 for IPv6); prefixes are stored in the
+  (at most 33 lookups for IPv4, 129 for IPv6); prefixes are stored in the
-  text form Go's `net/netip` prints. Routes shorter than /8 for IPv4 or /16
+  text form Go's `net/netip` prints
-  for IPv6, such as a default route, are not used.
 
 ### Database Schema
 

internal/database/counts_test.go

@@ -128,7 +128,7 @@ func TestLiveCountsTrackWritesInRealtime(t *testing.T) {
 
 	// A withdrawal removes one route.
 	if err := db.DeleteLiveRouteBatch([]LiveRouteDeletion{
-		{Prefix: "203.0.113.0/24", PeerIP: "192.0.2.1", IPVersion: ipVersionV4},
+		{Prefix: "203.0.113.0/24", OriginASN: 64501, PeerIP: "192.0.2.1", IPVersion: ipVersionV4},
 	}); err != nil {
 		t.Fatalf("DeleteLiveRouteBatch: %v", err)
 	}
@@ -327,11 +327,13 @@ func announceRoutes(db *Database, batch bool, routes []*LiveRoute) error {
 }
 
 // withdrawRoutes removes routes in one DeleteLiveRouteBatch, or with one
-// DeleteLiveRoute each.
+// DeleteLiveRoute each. It names each route by prefix and peer only, with no
+// origin ASN, as a withdrawal from the feed does when its message carries no AS
+// path.
 func withdrawRoutes(db *Database, batch bool, routes []*LiveRoute) error {
 	if !batch {
 		for _, route := range routes {
-			if err := db.DeleteLiveRoute(route.Prefix, route.PeerIP); err != nil {
+			if err := db.DeleteLiveRoute(route.Prefix, 0, route.PeerIP); err != nil {
 				return err
 			}
 		}

internal/database/database.go

@@ -37,14 +37,6 @@ const (
 	ipv6Bits       = 128
 )
 
-// The IP lookup does not use routes shorter than these mask lengths. A default
-// route or a route this short only says where a peer sends traffic it has no
-// better route for; it does not say who holds the address.
-const (
-	minLookupMaskLengthV4 = 8
-	minLookupMaskLengthV6 = 16
-)
-
 // SQLite memory tuning. cache_size and busy_timeout go in the DSN so every
 // pooled connection gets them; the heap limits are process-wide and set once.
 const (
@@ -228,22 +220,21 @@ func (d *Database) beginTx() (*loggingTx, error) {
 }
 
 // A live-route upsert is an UPDATE followed, only when no row matched, by an
-// INSERT. A live route is keyed by prefix and peer, so an announcement replaces
+// INSERT. The UPDATE's rows-affected count (1 for an existing key, 0 for a new
-// the peer's route for the prefix whatever its origin AS. The UPDATE's
+// one) is what lets the in-memory route counters stay exact without a COUNT(*).
-// rows-affected count (1 for an existing key, 0 for a new one) is what lets the
+// Callers hold the database write lock, so no other writer can insert the same
-// in-memory route counters stay exact without a COUNT(*). Callers hold the
+// key between the two statements. The id column is set only on INSERT, so an
-// database write lock, so no other writer can insert the same key between the
+// updated route keeps its original id, exactly as the previous ON CONFLICT
-// two statements. The id column is set only on INSERT, so an updated route
+// upsert did.
-// keeps its original id, exactly as the previous ON CONFLICT upsert did.
 const (
-	updateLiveRouteV4SQL = `UPDATE live_routes_v4 SET mask_length = ?, origin_asn = ?, as_path = ?,
+	updateLiveRouteV4SQL = `UPDATE live_routes_v4 SET mask_length = ?, as_path = ?, next_hop = ?,
-		next_hop = ?, last_updated = ? WHERE prefix = ? AND peer_ip = ?`
+		last_updated = ? WHERE prefix = ? AND origin_asn = ? AND peer_ip = ?`
 
 	insertLiveRouteV4SQL = `INSERT INTO live_routes_v4 (id, prefix, mask_length, origin_asn, peer_ip,
 		as_path, next_hop, last_updated) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
 
-	updateLiveRouteV6SQL = `UPDATE live_routes_v6 SET mask_length = ?, origin_asn = ?, as_path = ?,
+	updateLiveRouteV6SQL = `UPDATE live_routes_v6 SET mask_length = ?, as_path = ?, next_hop = ?,
-		next_hop = ?, last_updated = ? WHERE prefix = ? AND peer_ip = ?`
+		last_updated = ? WHERE prefix = ? AND origin_asn = ? AND peer_ip = ?`
 
 	insertLiveRouteV6SQL = `INSERT INTO live_routes_v6 (id, prefix, mask_length, origin_asn, peer_ip,
 		as_path, next_hop, last_updated) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
@@ -262,8 +253,8 @@ const (
 // live route for its prefix.
 func upsertRouteRowV4(upd, ins, has *sql.Stmt, route *LiveRoute, pathJSON string) (
 	inserted, newPrefix bool, err error) {
-	res, err := upd.Exec(route.MaskLength, route.OriginASN, pathJSON, route.NextHop, route.LastUpdated,
+	res, err := upd.Exec(route.MaskLength, pathJSON, route.NextHop, route.LastUpdated,
-		route.Prefix, route.PeerIP)
+		route.Prefix, route.OriginASN, route.PeerIP)
 	if err != nil {
 		return false, false, err
 	}
@@ -294,8 +285,8 @@ func upsertRouteRowV4(upd, ins, has *sql.Stmt, route *LiveRoute, pathJSON string
 // live route for its prefix.
 func upsertRouteRowV6(upd, ins, has *sql.Stmt, route *LiveRoute, pathJSON string) (
 	inserted, newPrefix bool, err error) {
-	res, err := upd.Exec(route.MaskLength, route.OriginASN, pathJSON, route.NextHop, route.LastUpdated,
+	res, err := upd.Exec(route.MaskLength, pathJSON, route.NextHop, route.LastUpdated,
-		route.Prefix, route.PeerIP)
+		route.Prefix, route.OriginASN, route.PeerIP)
 	if err != nil {
 		return false, false, err
 	}
@@ -442,18 +433,32 @@ func (d *Database) DeleteLiveRouteBatch(deletions []LiveRouteDeletion) error {
 		}
 	}()
 
-	// Prepare statements for both IPv4 and IPv6 tables
+	// No longer need to separate deletions since we handle them in the loop below
-	deleteV4, err := tx.Prepare(`DELETE FROM live_routes_v4 WHERE prefix = ? AND peer_ip = ?`)
-	if err != nil {
-		return fmt.Errorf("failed to prepare IPv4 delete statement: %w", err)
-	}
-	defer func() { _ = deleteV4.Close() }()
 
-	deleteV6, err := tx.Prepare(`DELETE FROM live_routes_v6 WHERE prefix = ? AND peer_ip = ?`)
+	// Prepare statements for both IPv4 and IPv6 tables
+	stmtV4WithOrigin, err := tx.Prepare(`DELETE FROM live_routes_v4 WHERE prefix = ? AND origin_asn = ? AND peer_ip = ?`)
 	if err != nil {
-		return fmt.Errorf("failed to prepare IPv6 delete statement: %w", err)
+		return fmt.Errorf("failed to prepare IPv4 delete with origin statement: %w", err)
 	}
-	defer func() { _ = deleteV6.Close() }()
+	defer func() { _ = stmtV4WithOrigin.Close() }()
+
+	stmtV4WithoutOrigin, err := tx.Prepare(`DELETE FROM live_routes_v4 WHERE prefix = ? AND peer_ip = ?`)
+	if err != nil {
+		return fmt.Errorf("failed to prepare IPv4 delete without origin statement: %w", err)
+	}
+	defer func() { _ = stmtV4WithoutOrigin.Close() }()
+
+	stmtV6WithOrigin, err := tx.Prepare(`DELETE FROM live_routes_v6 WHERE prefix = ? AND origin_asn = ? AND peer_ip = ?`)
+	if err != nil {
+		return fmt.Errorf("failed to prepare IPv6 delete with origin statement: %w", err)
+	}
+	defer func() { _ = stmtV6WithOrigin.Close() }()
+
+	stmtV6WithoutOrigin, err := tx.Prepare(`DELETE FROM live_routes_v6 WHERE prefix = ? AND peer_ip = ?`)
+	if err != nil {
+		return fmt.Errorf("failed to prepare IPv6 delete without origin statement: %w", err)
+	}
+	defer func() { _ = stmtV6WithoutOrigin.Close() }()
 
 	hasV4, err := tx.Prepare(prefixHasLiveRouteV4SQL)
 	if err != nil {
@@ -472,18 +477,38 @@ func (d *Database) DeleteLiveRouteBatch(deletions []LiveRouteDeletion) error {
 	// Mask lengths of the prefixes this batch leaves with no live route.
 	var gonePrefixMaskLengthsV4, gonePrefixMaskLengthsV6 []int
 	for _, del := range deletions {
-		stmt := deleteV4
+		var stmt *sql.Stmt
-		if del.IPVersion != ipVersionV4 {
+
-			stmt = deleteV6
+		// Select appropriate statement based on IP version and whether we have origin ASN
+		//nolint:nestif // Clear logic for selecting the right statement
+		if del.IPVersion == ipVersionV4 {
+			if del.OriginASN == 0 {
+				stmt = stmtV4WithoutOrigin
+			} else {
+				stmt = stmtV4WithOrigin
+			}
+		} else {
+			if del.OriginASN == 0 {
+				stmt = stmtV6WithoutOrigin
+			} else {
+				stmt = stmtV6WithOrigin
+			}
+		}
+
+		// Execute deletion
+		var res sql.Result
+		if del.OriginASN == 0 {
+			res, err = stmt.Exec(del.Prefix, del.PeerIP)
+		} else {
+			res, err = stmt.Exec(del.Prefix, del.OriginASN, del.PeerIP)
 		}
 
-		res, err := stmt.Exec(del.Prefix, del.PeerIP)
 		if err != nil {
 			return fmt.Errorf("failed to delete route %s: %w", del.Prefix, err)
 		}
 
-		// The feed often withdraws a route that is not live, which deletes
+		// A deletion with no origin ASN can remove several rows, so use the
-		// nothing, so the in-memory route counters use the rows-affected count.
+		// exact rows-affected count to keep the in-memory route counters right.
 		affected, err := res.RowsAffected()
 		if err != nil {
 			return fmt.Errorf("failed to count deleted route %s: %w", del.Prefix, err)
@@ -1249,8 +1274,9 @@ func (d *Database) UpsertLiveRoute(route *LiveRoute) error {
 	return nil
 }
 
-// DeleteLiveRoute deletes the live route the peer has for the prefix
+// DeleteLiveRoute deletes a live route
-func (d *Database) DeleteLiveRoute(prefix, peerIP string) error {
+// If originASN is 0, deletes all routes for the prefix/peer combination
+func (d *Database) DeleteLiveRoute(prefix string, originASN int, peerIP string) error {
 	d.lock("DeleteLiveRoute")
 	defer d.unlock()
 
@@ -1275,12 +1301,22 @@ func (d *Database) DeleteLiveRoute(prefix, peerIP string) error {
 	}()
 
 	// Literal per-table queries (rather than one formatted with the table name)
-	// so the delete carries no dynamically built SQL.
+	// so the delete carries no dynamically built SQL. A delete with no origin
+	// ASN can remove several rows.
 	var res sql.Result
-	if isV4 {
+	switch {
+	case isV4 && originASN == 0:
 		res, err = tx.Exec(`DELETE FROM live_routes_v4 WHERE prefix = ? AND peer_ip = ?`, prefix, peerIP)
-	} else {
+	case isV4:
+		res, err = tx.Exec(
+			`DELETE FROM live_routes_v4 WHERE prefix = ? AND origin_asn = ? AND peer_ip = ?`,
+			prefix, originASN, peerIP)
+	case originASN == 0:
 		res, err = tx.Exec(`DELETE FROM live_routes_v6 WHERE prefix = ? AND peer_ip = ?`, prefix, peerIP)
+	default:
+		res, err = tx.Exec(
+			`DELETE FROM live_routes_v6 WHERE prefix = ? AND origin_asn = ? AND peer_ip = ?`,
+			prefix, originASN, peerIP)
 	}
 	if err != nil {
 		return err
@@ -1588,17 +1624,16 @@ func (d *Database) GetASPeersContext(ctx context.Context, asn int) ([]ASPeer, er
 }
 
 // GetPrefixDetails returns detailed information about a prefix
-func (d *Database) GetPrefixDetails(prefix string) ([]LiveRoute, map[int]ASN, error) {
+func (d *Database) GetPrefixDetails(prefix string) ([]LiveRoute, error) {
 	return d.GetPrefixDetailsContext(context.Background(), prefix)
 }
 
-// GetPrefixDetailsContext returns the live routes for a prefix and, keyed by
+// GetPrefixDetailsContext returns detailed information about a prefix with context support
-// AS number, the handle and description of each AS that originates it.
+func (d *Database) GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, error) {
-func (d *Database) GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, map[int]ASN, error) {
 	// Determine if it's IPv4 or IPv6 by parsing the prefix
 	_, ipnet, err := net.ParseCIDR(prefix)
 	if err != nil {
-		return nil, nil, fmt.Errorf("invalid prefix format: %w", err)
+		return nil, fmt.Errorf("invalid prefix format: %w", err)
 	}
 
 	tableName := "live_routes_v4"
@@ -1620,12 +1655,11 @@ func (d *Database) GetPrefixDetailsContext(ctx context.Context, prefix string) (
 
 	rows, err := d.db.QueryContext(ctx, query, prefix)
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to query prefix details: %w", err)
+		return nil, fmt.Errorf("failed to query prefix details: %w", err)
 	}
 	defer func() { _ = rows.Close() }()
 
 	var routes []LiveRoute
-	origins := make(map[int]ASN)
 	for rows.Next() {
 		var route LiveRoute
 		var pathJSON string
@@ -1648,18 +1682,13 @@ func (d *Database) GetPrefixDetailsContext(ctx context.Context, prefix string) (
 		route.IPVersion = ipVersion
 		route.MaskLength, _ = ipnet.Mask.Size()
 		routes = append(routes, route)
-		origins[route.OriginASN] = ASN{
-			ASN:         route.OriginASN,
-			Handle:      handle.String,
-			Description: description.String,
-		}
 	}
 
 	if len(routes) == 0 {
-		return nil, nil, fmt.Errorf("%w: %s", ErrNoRoute, prefix)
+		return nil, fmt.Errorf("%w: %s", ErrNoRoute, prefix)
 	}
 
-	return routes, origins, nil
+	return routes, nil
 }
 
 // GetRandomPrefixesByLength returns a random sample of prefixes with the specified mask length
@@ -1847,12 +1876,11 @@ func (d *Database) GetIPInfo(ip string) (*IPInfo, error) {
 // GetIPInfoContext returns comprehensive IP information with context support.
 //
 // It finds the most specific live route for the address with point lookups on
-// the prefix index: for each mask length from the longest (32 or 128) down to
+// the prefix index: for each mask length from the longest (32 or 128) down to 0
-// minLookupMaskLengthV4 or minLookupMaskLengthV6 it looks up the address's
+// it looks up the address's network prefix at that length, and the first length
-// network prefix at that length, and the first length with a live route wins.
+// with a live route wins. That is at most 33 or 129 indexed lookups, however
-// That is at most 25 or 113 indexed lookups, however many routes are live. The
+// many routes are live. The prefix is looked up in the text form net/netip
-// prefix is looked up in the text form net/netip prints, which is the form the
+// prints, which is the form the prefix handler stores.
-// prefix handler stores.
 func (d *Database) GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, error) {
 	addr, err := netip.ParseAddr(ip)
 	if err != nil {
@@ -1863,11 +1891,9 @@ func (d *Database) GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, er
 
 	info := &IPInfo{IP: ip, IPVersion: ipVersionV6}
 	routesTable, prefixesTable := "live_routes_v6", "prefixes_v6"
-	minMaskLength := minLookupMaskLengthV6
 	if addr.Is4() {
 		info.IPVersion = ipVersionV4
 		routesTable, prefixesTable = "live_routes_v4", "prefixes_v4"
-		minMaskLength = minLookupMaskLengthV4
 	}
 
 	// Route info with peer count and prefix first_seen
@@ -1908,7 +1934,7 @@ func (d *Database) GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, er
 	var whoisUpdatedAt sql.NullTime
 
 	found := false
-	for bits := addr.BitLen(); bits >= minMaskLength; bits-- {
+	for bits := addr.BitLen(); bits >= 0; bits-- {
 		prefix := netip.PrefixFrom(addr, bits).Masked().String()
 		err := stmt.QueryRowContext(ctx, prefix).Scan(
 			&info.Netblock,

internal/database/database_test.go

@@ -13,7 +13,6 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/config"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"github.com/google/uuid"
-	"github.com/mattn/go-sqlite3"
 )
 
 // tempStoreMemory is the PRAGMA temp_store value meaning "hold temp B-trees in
@@ -123,8 +122,8 @@ func TestGetIPInfoFindsMostSpecificLiveRoute(t *testing.T) {
 	lookup("2001:db9::1", "")
 
 	err = db.DeleteLiveRouteBatch([]LiveRouteDeletion{
-		{Prefix: "10.1.2.0/24", PeerIP: testPeerIP, IPVersion: ipVersionV4},
+		{Prefix: "10.1.2.0/24", OriginASN: 64502, PeerIP: testPeerIP, IPVersion: ipVersionV4},
-		{Prefix: "2001:db8:1:2::/64", PeerIP: testPeerIP, IPVersion: ipVersionV6},
+		{Prefix: "2001:db8:1:2::/64", OriginASN: 64502, PeerIP: testPeerIP, IPVersion: ipVersionV6},
 	})
 	if err != nil {
 		t.Fatalf("DeleteLiveRouteBatch: %v", err)
@@ -134,112 +133,6 @@ func TestGetIPInfoFindsMostSpecificLiveRoute(t *testing.T) {
 	lookup("2001:db8:1:2::3", "2001:db8:1::/48")
 }
 
-// TestGetIPInfoIgnoresShortRoutes checks that the IP lookup does not report a
-// default route, or a route shorter than /8 for IPv4 or /16 for IPv6, as the
-// route for an address, and that a route of exactly /8 or /16, or longer, still
-// is. The prefixes are written out so that a wrong limit fails the test.
-func TestGetIPInfoIgnoresShortRoutes(t *testing.T) {
-	cfg := &config.Config{StateDir: t.TempDir()}
-
-	db, err := New(cfg, logger.New())
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer func() { _ = db.Close() }()
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	announce := func(prefix string, asn int) {
-		t.Helper()
-
-		err := db.UpsertLiveRouteBatch([]*LiveRoute{{
-			ID:          uuid.New(),
-			Prefix:      prefix,
-			MaskLength:  netip.MustParsePrefix(prefix).Bits(),
-			IPVersion:   detectIPVersion(prefix),
-			OriginASN:   asn,
-			PeerIP:      testPeerIP,
-			ASPath:      []int{asn},
-			NextHop:     testPeerIP,
-			LastUpdated: ts,
-		}})
-		if err != nil {
-			t.Fatalf("UpsertLiveRouteBatch(%s): %v", prefix, err)
-		}
-	}
-
-	// lookup checks that ip resolves to the live prefix netblock from asn.
-	lookup := func(ip, netblock string, asn int) {
-		t.Helper()
-
-		info, err := db.GetIPInfo(ip)
-		if err != nil {
-			t.Errorf("GetIPInfo(%s): %v", ip, err)
-
-			return
-		}
-		if info.Netblock != netblock || info.ASN != asn {
-			t.Errorf("GetIPInfo(%s) = %s AS%d, want %s AS%d", ip, info.Netblock, info.ASN, netblock, asn)
-		}
-	}
-
-	// Default and very short routes, and routes one bit shorter than each limit.
-	announce("2000::/3", 64500)
-	announce("0.0.0.0/0", 64500)
-	announce("2000::/15", 64500)
-	announce("192.0.0.0/7", 64500)
-
-	for _, ip := range []string{"2001:db8::1", "192.0.2.1"} {
-		if info, err := db.GetIPInfo(ip); !errors.Is(err, ErrNoRoute) {
-			t.Errorf("GetIPInfo(%s) with only short routes = %+v, %v; want ErrNoRoute", ip, info, err)
-		}
-	}
-
-	// Routes of exactly the minimum length are used.
-	announce("2001::/16", 64501)
-	announce("192.0.0.0/8", 64501)
-
-	lookup("2001:db8::1", "2001::/16", 64501)
-	lookup("192.0.2.1", "192.0.0.0/8", 64501)
-
-	announce("2001:db8::/32", 64502)
-
-	lookup("2001:db8::1", "2001:db8::/32", 64502)
-}
-
-// TestLiveRouteTablesHoldOneRoutePerPrefixAndPeer checks that each live route
-// table refuses a second route from a peer for a prefix, even with another
-// origin AS. An upsert updates the peer's route before it would insert one, so
-// only an insert straight into the table shows what the table allows.
-func TestLiveRouteTablesHoldOneRoutePerPrefixAndPeer(t *testing.T) {
-	db, err := New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer func() { _ = db.Close() }()
-
-	const otherOriginASN = 64501
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	for _, tt := range []struct {
-		route     *LiveRoute
-		insertSQL string
-	}{
-		{route: mkV4Route(t, "198.51.100.0/24", 64500, ts), insertSQL: insertLiveRouteV4SQL},
-		{route: mkV6Route("2001:db8::/32", 64500, ts), insertSQL: insertLiveRouteV6SQL},
-	} {
-		if err := db.UpsertLiveRoute(tt.route); err != nil {
-			t.Fatalf("UpsertLiveRoute(%s): %v", tt.route.Prefix, err)
-		}
-
-		_, err := db.db.Exec(tt.insertSQL, uuid.NewString(), tt.route.Prefix, tt.route.MaskLength,
-			otherOriginASN, tt.route.PeerIP, "[]", tt.route.NextHop, ts)
-		var sqliteErr sqlite3.Error
-		if !errors.As(err, &sqliteErr) || sqliteErr.ExtendedCode != sqlite3.ErrConstraintUnique {
-			t.Errorf("second route from peer %s for %s: error %v, want a UNIQUE constraint error",
-				tt.route.PeerIP, tt.route.Prefix, err)
-		}
-	}
-}
-
 // TestConnectionPoolPragmas holds several pooled connections open at once and
 // checks each one carries the per-connection settings from the DSN, plus the
 // process-wide hard heap limit, and sees the new file with auto_vacuum
@@ -341,6 +234,7 @@ func TestVacuumReturnsFreePages(t *testing.T) {
 		routes = append(routes, route)
 		deletions = append(deletions, LiveRouteDeletion{
 			Prefix:    route.Prefix,
+			OriginASN: asn,
 			PeerIP:    route.PeerIP,
 			IPVersion: ipVersionV4,
 		})

internal/database/interface.go

@@ -55,7 +55,7 @@ type Store interface {
 	// Live route operations
 	UpsertLiveRoute(route *LiveRoute) error
 	UpsertLiveRouteBatch(routes []*LiveRoute) error
-	DeleteLiveRoute(prefix, peerIP string) error
+	DeleteLiveRoute(prefix string, originASN int, peerIP string) error
 	DeleteLiveRouteBatch(deletions []LiveRouteDeletion) error
 	GetPrefixDistribution() (ipv4 []PrefixDistribution, ipv6 []PrefixDistribution, err error)
 	GetPrefixDistributionContext(ctx context.Context) (ipv4 []PrefixDistribution, ipv6 []PrefixDistribution, err error)
@@ -76,8 +76,8 @@ type Store interface {
 	GetASDetailsContext(ctx context.Context, asn int) (*ASN, []LiveRoute, error)
 	GetASPeers(asn int) ([]ASPeer, error)
 	GetASPeersContext(ctx context.Context, asn int) ([]ASPeer, error)
-	GetPrefixDetails(prefix string) ([]LiveRoute, map[int]ASN, error)
+	GetPrefixDetails(prefix string) ([]LiveRoute, error)
-	GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, map[int]ASN, error)
+	GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, error)
 	GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]LiveRoute, error)
 	GetRandomPrefixesByLengthContext(ctx context.Context, maskLength, ipVersion, limit int) ([]LiveRoute, error)
 

internal/database/models.go

@@ -114,6 +114,7 @@ type IPInfo struct {
 // LiveRouteDeletion represents parameters for deleting a live route
 type LiveRouteDeletion struct {
 	Prefix    string
+	OriginASN int
 	PeerIP    string
 	IPVersion int
 }

internal/database/schema.sql

@@ -107,7 +107,7 @@ CREATE TABLE IF NOT EXISTS live_routes_v4 (
 	as_path TEXT NOT NULL, -- JSON array
 	next_hop TEXT NOT NULL,
 	last_updated DATETIME NOT NULL,
-	UNIQUE(prefix, peer_ip) -- a peer has at most one route for a prefix
+	UNIQUE(prefix, origin_asn, peer_ip)
 );
 
 -- IPv6 routing table maintained by PrefixHandler
@@ -120,7 +120,7 @@ CREATE TABLE IF NOT EXISTS live_routes_v6 (
 	as_path TEXT NOT NULL, -- JSON array
 	next_hop TEXT NOT NULL,
 	last_updated DATETIME NOT NULL,
-	UNIQUE(prefix, peer_ip) -- a peer has at most one route for a prefix
+	UNIQUE(prefix, origin_asn, peer_ip)
 );
 
 -- Indexes for live_routes_v4 table

internal/routewatch/app_integration_test.go

@@ -205,7 +205,7 @@ func (m *mockStore) UpsertLiveRoute(route *database.LiveRoute) error {
 }
 
 // DeleteLiveRoute mock implementation
-func (m *mockStore) DeleteLiveRoute(prefix, peerIP string) error {
+func (m *mockStore) DeleteLiveRoute(prefix string, originASN int, peerIP string) error {
 	// Simple mock - just return nil
 	return nil
 }
@@ -252,15 +252,13 @@ func (m *mockStore) GetASDetailsContext(ctx context.Context, asn int) (*database
 }
 
 // GetPrefixDetails mock implementation
-func (m *mockStore) GetPrefixDetails(prefix string) ([]database.LiveRoute, map[int]database.ASN, error) {
+func (m *mockStore) GetPrefixDetails(prefix string) ([]database.LiveRoute, error) {
 	// Return empty routes for now
-	return []database.LiveRoute{}, map[int]database.ASN{}, nil
+	return []database.LiveRoute{}, nil
 }
 
 // GetPrefixDetailsContext mock implementation with context support
-func (m *mockStore) GetPrefixDetailsContext(
+func (m *mockStore) GetPrefixDetailsContext(ctx context.Context, prefix string) ([]database.LiveRoute, error) {
-	ctx context.Context, prefix string,
-) ([]database.LiveRoute, map[int]database.ASN, error) {
 	return m.GetPrefixDetails(prefix)
 }
 

internal/routewatch/cli.go

@@ -20,8 +20,6 @@ const (
 	debugInterval = 60 * time.Second
 	// bytesPerMB is bytes per megabyte
 	bytesPerMB = 1024 * 1024
-	// failureExitCode is the exit status when RouteWatch stops on an error
-	failureExitCode = 1
 )
 
 // logDebugStats logs goroutine count and memory usage
@@ -85,9 +83,6 @@ func CLIEntry() {
 					go func() {
 						if err := rw.Run(ctx); 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)
-							}
 						}
 					}()
 

internal/routewatch/prefixhandler.go

@@ -105,24 +105,7 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 	h.mu.Lock()
 	defer h.mu.Unlock()
 
-	// Withdrawals are queued before announcements, because the batch keeps
+	// Process announcements
-	// each peer's last update for a prefix: a message that lists a prefix as
-	// both withdrawn and announced keeps the route (RFC 4271 section 4.3).
-	// A withdrawal names only the prefix and peer: the message's AS path, and
-	// so its origin AS, belongs to the announced prefixes.
-	for _, prefix := range msg.Withdrawals {
-		h.batch = append(h.batch, prefixUpdate{
-			prefix:      canonicalPrefix(prefix),
-			peer:        msg.Peer,
-			messageType: "withdrawal",
-			timestamp:   timestamp,
-		})
-		// Record withdrawal in metrics
-		if h.metrics != nil {
-			h.metrics.RecordWithdrawal()
-		}
-	}
-
 	for _, announcement := range msg.Announcements {
 		for _, prefix := range announcement.Prefixes {
 			h.batch = append(h.batch, prefixUpdate{
@@ -140,6 +123,22 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 		}
 	}
 
+	// Process withdrawals
+	for _, prefix := range msg.Withdrawals {
+		h.batch = append(h.batch, prefixUpdate{
+			prefix:      canonicalPrefix(prefix),
+			originASN:   originASN, // Use the originASN from path if available
+			peer:        msg.Peer,
+			messageType: "withdrawal",
+			timestamp:   timestamp,
+			path:        msg.Path,
+		})
+		// Record withdrawal in metrics
+		if h.metrics != nil {
+			h.metrics.RecordWithdrawal()
+		}
+	}
+
 	// Check if we need to flush
 	if len(h.batch) >= prefixBatchSize {
 		h.flushBatchLocked()
@@ -180,14 +179,14 @@ func (h *PrefixHandler) flushBatchLocked() {
 	startTime := time.Now()
 	batchSize := len(h.batch)
 
-	// For each prefix and peer, keep only the last update the feed delivered.
+	// Group updates by prefix to deduplicate
-	// Updates from different peers for the same prefix are all kept. Arrival
+	// For each prefix, keep the latest update
-	// order decides, not the timestamp: timestamps are whole seconds, so
+	prefixMap := make(map[string]prefixUpdate)
-	// updates within one second carry the same one.
-	type prefixAndPeer struct{ prefix, peer string }
-	lastUpdates := make(map[prefixAndPeer]prefixUpdate)
 	for _, update := range h.batch {
-		lastUpdates[prefixAndPeer{update.prefix, update.peer}] = update
+		key := update.prefix
+		if existing, ok := prefixMap[key]; !ok || update.timestamp.After(existing.timestamp) {
+			prefixMap[key] = update
+		}
 	}
 
 	// Collect routes to upsert and delete
@@ -197,7 +196,7 @@ func (h *PrefixHandler) flushBatchLocked() {
 	// Collect unique prefixes to update
 	prefixesToUpdate := make(map[string]time.Time)
 
-	for _, update := range lastUpdates {
+	for _, update := range prefixMap {
 		// Track prefix for both announcements and withdrawals
 		if _, exists := prefixesToUpdate[update.prefix]; !exists || update.timestamp.After(prefixesToUpdate[update.prefix]) {
 			prefixesToUpdate[update.prefix] = update.timestamp
@@ -221,6 +220,7 @@ func (h *PrefixHandler) flushBatchLocked() {
 			// Create deletion record for batch delete
 			routesToDelete = append(routesToDelete, database.LiveRouteDeletion{
 				Prefix:    update.prefix,
+				OriginASN: update.originASN,
 				PeerIP:    update.peer,
 				IPVersion: ipVersion,
 			})
@@ -255,7 +255,7 @@ func (h *PrefixHandler) flushBatchLocked() {
 	elapsed := time.Since(startTime)
 	h.logger.Debug("Flushed prefix batch",
 		"batch_size", batchSize,
-		"unique_prefixes", len(prefixesToUpdate),
+		"unique_prefixes", len(prefixMap),
 		"success", successCount,
 		"duration_ms", elapsed.Milliseconds(),
 	)
@@ -424,25 +424,52 @@ func (h *PrefixHandler) processAnnouncementDirect(update prefixUpdate) {
 // 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 {
+	// For withdrawals, we need to delete the route from live_routes
+	if update.originASN > 0 {
+		if err := h.db.DeleteLiveRoute(update.prefix, update.originASN, update.peer); err != nil {
 			h.logger.Error("Failed to delete live route",
+				"prefix", update.prefix,
+				"origin_asn", update.originASN,
+				"peer", update.peer,
+				"error", err,
+			)
+		}
+	} else {
+		// If no origin ASN, just delete all routes for this prefix from this peer
+		if err := h.db.DeleteLiveRoute(update.prefix, 0, update.peer); err != nil {
+			h.logger.Error("Failed to delete live route (no origin ASN)",
 				"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 {
+	// For withdrawals, we need to delete the route from live_routes
+	// Since we have the origin ASN from the update, we can delete the specific route
+	if update.originASN > 0 {
+		if err := h.db.DeleteLiveRoute(update.prefix, update.originASN, update.peer); err != nil {
 			h.logger.Error("Failed to delete live route",
+				"prefix", update.prefix,
+				"origin_asn", update.originASN,
+				"peer", update.peer,
+				"error", err,
+			)
+		}
+	} else {
+		// If no origin ASN, just delete all routes for this prefix from this peer
+		if err := h.db.DeleteLiveRoute(update.prefix, 0, update.peer); err != nil {
+			h.logger.Error("Failed to delete live route (no origin ASN)",
 				"prefix", update.prefix,
 				"peer", update.peer,
 				"error", err,
 			)
 		}
+	}
 }
 
 // Stop gracefully stops the handler and flushes remaining batches

internal/routewatch/prefixhandler_test.go

@@ -1,10 +1,7 @@
 package routewatch
 
 import (
-	"context"
 	"errors"
-	"fmt"
-	"slices"
 	"testing"
 	"time"
 
@@ -75,263 +72,3 @@ func TestPrefixHandlerStoresPrefixesTheIPLookupFinds(t *testing.T) {
 		}
 	}
 }
-
-// TestPrefixHandlerAppliesEachPeersLastUpdateInABatch runs updates for one
-// prefix through the prefix handler into a real database. All updates carry the
-// same timestamp, as updates within one second of the feed do. Within a batch,
-// the last update each peer sent for the prefix decides whether that peer has a
-// 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) {
-	const (
-		prefix           = "198.51.100.0/24"
-		prefixMaskLength = 24
-		otherPeerIP      = "2001:db8:ffff::2"
-	)
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	announce := func(peer string) *ristypes.RISMessage {
-		return &ristypes.RISMessage{
-			Peer:            peer,
-			Path:            ristypes.ASPath{testASNA, testASNB},
-			ParsedTimestamp: ts,
-			Announcements:   []ristypes.RISAnnouncement{{NextHop: peer, Prefixes: []string{prefix}}},
-		}
-	}
-	withdraw := func(peer string) *ristypes.RISMessage {
-		return &ristypes.RISMessage{Peer: peer, ParsedTimestamp: ts, Withdrawals: []string{prefix}}
-	}
-	announceAndWithdraw := func(peer string) *ristypes.RISMessage {
-		msg := announce(peer)
-		msg.Withdrawals = []string{prefix}
-
-		return msg
-	}
-
-	tests := []struct {
-		name string
-		// Each inner list is handled and then flushed as one batch.
-		batches [][]*ristypes.RISMessage
-		// The peers left with a live route for the prefix, by peer IP.
-		wantPeers []string
-	}{
-		{
-			name:      "two peers announce the prefix",
-			batches:   [][]*ristypes.RISMessage{{announce(testPeerIP), announce(otherPeerIP)}},
-			wantPeers: []string{testPeerIP, otherPeerIP},
-		},
-		{
-			name: "two peers withdraw the prefix",
-			batches: [][]*ristypes.RISMessage{
-				{announce(testPeerIP)},
-				{announce(otherPeerIP)},
-				{withdraw(testPeerIP), withdraw(otherPeerIP)},
-			},
-		},
-		{
-			name:    "a peer announces and then withdraws the prefix",
-			batches: [][]*ristypes.RISMessage{{announce(testPeerIP), withdraw(testPeerIP)}},
-		},
-		{
-			name: "a peer withdraws and then re-announces the prefix",
-			batches: [][]*ristypes.RISMessage{
-				{announce(testPeerIP)},
-				{withdraw(testPeerIP), announce(testPeerIP)},
-			},
-			wantPeers: []string{testPeerIP},
-		},
-		{
-			// RFC 4271 section 4.3: the announcement counts, not the withdrawal.
-			name: "one message announces and withdraws the prefix",
-			batches: [][]*ristypes.RISMessage{
-				{announce(testPeerIP)},
-				{announceAndWithdraw(testPeerIP)},
-			},
-			wantPeers: []string{testPeerIP},
-		},
-	}
-
-	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() }()
-
-			// 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.mu.Lock()
-				h.flushBatchLocked()
-				h.mu.Unlock()
-			}
-
-			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)
-		})
-	}
-}
-
-// TestPrefixHandlerKeepsOneRoutePerPrefixAndPeer runs updates from one peer
-// through the prefix handler into a real database, flushing each message as its
-// own batch, once with IPv4 prefixes and once with IPv6 prefixes. A peer has at
-// most one route for a prefix: a later announcement replaces it whatever its
-// origin AS, and a withdrawal removes it whatever AS the message's AS path ends
-// in. The in-memory route count and prefix distribution must match the route
-// table.
-func TestPrefixHandlerKeepsOneRoutePerPrefixAndPeer(t *testing.T) {
-	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},
-	}
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	announce := func(path ristypes.ASPath, announced string) *ristypes.RISMessage {
-		return &ristypes.RISMessage{
-			Peer:            testPeerIP,
-			Path:            path,
-			ParsedTimestamp: ts,
-			Announcements:   []ristypes.RISAnnouncement{{NextHop: testPeerIP, Prefixes: []string{announced}}},
-		}
-	}
-
-	for _, family := range families {
-		prefix, otherPrefix := family.prefix, family.otherPrefix
-
-		// One message that announces otherPrefix with origin AS testASNB and
-		// withdraws prefix.
-		announceOtherAndWithdraw := announce(ristypes.ASPath{testASNA, testASNB}, otherPrefix)
-		announceOtherAndWithdraw.Withdrawals = []string{prefix}
-
-		tests := []struct {
-			name     string
-			messages []*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),
-				},
-				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,
-				},
-				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() }()
-
-				// 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.mu.Lock()
-					h.flushBatchLocked()
-					h.mu.Unlock()
-				}
-
-				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)
-					}
-				}
-
-				wantDistribution := []database.PrefixDistribution{
-					{MaskLength: family.maskLength, Count: len(tt.wantOrigins)},
-				}
-				assertCounts(t, db, family.ipVersion, len(tt.wantOrigins), wantDistribution)
-			})
-		}
-	}
-}
-
-// 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) {
-	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)
-	if err != nil {
-		t.Fatalf("GetPrefixDistributionContext: %v", err)
-	}
-
-	memoryRoutes, tableRoutes := stats.IPv4Routes, tableRoutesV4
-	memoryDistribution, queryDistribution := stats.IPv4PrefixDistribution, queryDistributionV4
-	if ipVersion == ipv6Version {
-		memoryRoutes, tableRoutes = stats.IPv6Routes, tableRoutesV6
-		memoryDistribution, queryDistribution = stats.IPv6PrefixDistribution, 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)
-	}
-}

internal/server/handlers.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"net"
 	"net/http"
-	"net/netip"
 	"runtime"
 	"sort"
 	"strconv"
@@ -725,17 +724,13 @@ func (s *Server) handleASDetailJSON() http.HandlerFunc {
 		}
 
 		asInfo, prefixes, err := s.db.GetASDetailsContext(r.Context(), asn)
-		// A read cut off by the time limit can return part of its rows, or
-		// none, without an error.
-		if deadlinePassed(r.Context()) {
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-
-			return
-		}
 		if err != nil {
-			if errors.Is(err, database.ErrNoRoute) {
+			switch {
+			case errors.Is(err, database.ErrNoRoute):
 				writeJSONError(w, http.StatusNotFound, err.Error())
-			} else {
+			case deadlinePassed(r.Context()):
+				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
+			default:
 				writeJSONError(w, http.StatusInternalServerError, err.Error())
 			}
 
@@ -779,28 +774,17 @@ func (s *Server) handlePrefixDetailJSON() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
+		// Combine prefix and length into CIDR notation
-		// tables store, so that any valid way of writing it finds the route.
+		prefix := prefixParam + "/" + lenParam
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
+
+		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
-			writeJSONError(w, http.StatusBadRequest, err.Error())
+			switch {
-
+			case errors.Is(err, database.ErrNoRoute):
-			return
-		}
-		prefix := parsed.Masked().String()
-
-		routes, _, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
-		// A read cut off by the time limit can return part of its rows, or
-		// none, without an error.
-		if deadlinePassed(r.Context()) {
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-
-			return
-		}
-		if err != nil {
-			if errors.Is(err, database.ErrNoRoute) {
 				writeJSONError(w, http.StatusNotFound, err.Error())
-			} else {
+			case deadlinePassed(r.Context()):
+				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
+			default:
 				writeJSONError(w, http.StatusInternalServerError, err.Error())
 			}
 
@@ -839,17 +823,13 @@ func (s *Server) handleASDetail() http.HandlerFunc {
 		}
 
 		asInfo, prefixes, err := s.db.GetASDetailsContext(r.Context(), asn)
-		// A read cut off by the time limit can return part of its rows, or
-		// none, without an error.
-		if deadlinePassed(r.Context()) {
-			http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-
-			return
-		}
 		if err != nil {
-			if errors.Is(err, database.ErrNoRoute) {
+			switch {
+			case errors.Is(err, database.ErrNoRoute):
 				http.Error(w, "AS not found", http.StatusNotFound)
-			} else {
+			case deadlinePassed(r.Context()):
+				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
+			default:
 				s.logger.Error("Failed to get AS details", "error", err)
 				http.Error(w, "Internal server error", http.StatusInternalServerError)
 			}
@@ -964,28 +944,17 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
+		// Combine prefix and length into CIDR notation
-		// tables store, so that any valid way of writing it finds the route.
+		prefix := prefixParam + "/" + lenParam
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
+
+		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
-			http.Error(w, "Invalid prefix", http.StatusBadRequest)
+			switch {
-
+			case errors.Is(err, database.ErrNoRoute):
-			return
-		}
-		prefix := parsed.Masked().String()
-
-		routes, originASNs, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
-		// A read cut off by the time limit can return part of its rows, or
-		// none, without an error.
-		if deadlinePassed(r.Context()) {
-			http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-
-			return
-		}
-		if err != nil {
-			if errors.Is(err, database.ErrNoRoute) {
 				http.Error(w, "Prefix not found", http.StatusNotFound)
-			} else {
+			case deadlinePassed(r.Context()):
+				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
+			default:
 				s.logger.Error("Failed to get prefix details", "error", err)
 				http.Error(w, "Internal server error", http.StatusInternalServerError)
 			}
@@ -1003,10 +972,18 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
 		originMap := make(map[int]*ASNInfo)
 		for _, route := range routes {
 			if _, exists := originMap[route.OriginASN]; !exists {
+				// Get AS info from database
+				asInfo, _, _ := s.db.GetASDetailsContext(r.Context(), route.OriginASN)
+				handle := ""
+				description := ""
+				if asInfo != nil {
+					handle = asInfo.Handle
+					description = asInfo.Description
+				}
 				originMap[route.OriginASN] = &ASNInfo{
 					ASN:         route.OriginASN,
-					Handle:      originASNs[route.OriginASN].Handle,
+					Handle:      handle,
-					Description: originASNs[route.OriginASN].Description,
+					Description: description,
 					PeerCount:   0,
 				}
 			}

internal/server/handlers_test.go

@@ -3,13 +3,10 @@ package server
 import (
 	"context"
 	"encoding/json"
-	"errors"
-	"html"
 	"net/http"
 	"net/http/httptest"
 	"runtime"
 	"slices"
-	"strings"
 	"testing"
 	"time"
 
@@ -18,7 +15,6 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
-	"git.eeqj.de/sneak/routewatch/pkg/asinfo"
 	"github.com/google/uuid"
 )
 
@@ -152,124 +148,6 @@ func TestStatsHandlersAnswerFromMemory(t *testing.T) {
 	}
 }
 
-// TestPrefixDetailHandlersParsePrefix checks that both prefix pages find a
-// stored route whatever valid text form the URL writes its prefix in, and
-// answer 400 for a prefix that does not parse. The tables store the form
-// net/netip prints. Before the fix the URL text was looked up as typed, so
-// "2001:DB8:0:0::/32" was not found although "2001:db8::/32" was stored, and
-// "foo/24" answered 500 (https://git.eeqj.de/sneak/routewatch/issues/71).
-func TestPrefixDetailHandlersParsePrefix(t *testing.T) {
-	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("database.New: %v", err)
-	}
-	t.Cleanup(func() { _ = db.Close() })
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	if err := db.UpsertLiveRouteBatch([]*database.LiveRoute{
-		{
-			ID: uuid.New(), Prefix: "192.0.2.0/24", MaskLength: 24, IPVersion: 4,
-			OriginASN: 64500, PeerIP: "198.51.100.1", ASPath: []int{64500}, NextHop: "198.51.100.1",
-			LastUpdated: ts,
-		},
-		{
-			ID: uuid.New(), Prefix: "2001:db8::/32", MaskLength: 32, IPVersion: 6,
-			OriginASN: 64501, PeerIP: "2001:db8::1", ASPath: []int{64501}, NextHop: "2001:db8::1",
-			LastUpdated: ts,
-		},
-	}); err != nil {
-		t.Fatalf("UpsertLiveRouteBatch: %v", err)
-	}
-
-	s := New(db, streamer.New(logger.New(), metrics.New()), logger.New(), &config.Config{})
-
-	tests := []struct {
-		path string
-		want int
-	}{
-		{"/api/v1/prefix/foo/24", http.StatusBadRequest},
-		{"/prefix/foo/24", http.StatusBadRequest},
-		{"/api/v1/prefix/2001:DB8:0:0::/32", http.StatusOK},
-		{"/prefix/2001:DB8:0:0::/32", http.StatusOK},
-		{"/api/v1/prefix/192.0.2.1/24", http.StatusOK},
-		{"/prefix/192.0.2.1/24", http.StatusOK},
-	}
-
-	for _, tt := range tests {
-		rec := httptest.NewRecorder()
-		s.router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, tt.path, nil))
-		if rec.Code != tt.want {
-			t.Errorf("%s: status %d, want %d; body %s", tt.path, rec.Code, tt.want, rec.Body)
-		}
-	}
-}
-
-// failingASDetailsDB wraps a real store and fails every AS details lookup.
-type failingASDetailsDB struct {
-	database.Store
-}
-
-func (failingASDetailsDB) GetASDetailsContext(_ context.Context, _ int) (*database.ASN, []database.LiveRoute, error) {
-	return nil, nil, errors.New("AS details lookup failed")
-}
-
-// TestPrefixDetailShowsOriginNames checks that the prefix page shows each
-// origin AS's handle and description without looking up the AS's details,
-// which also read every route the AS originates. Before the fix the page did
-// that lookup once per origin, so with it failing the names were missing
-// (https://git.eeqj.de/sneak/routewatch/issues/67). The AS path column shows
-// handles too, so the test looks for the origin list's "(handle)" form.
-func TestPrefixDetailShowsOriginNames(t *testing.T) {
-	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("database.New: %v", err)
-	}
-	t.Cleanup(func() { _ = db.Close() })
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	origins := []int{15169, 13335}
-	for _, asn := range origins {
-		if _, err := db.GetOrCreateASN(asn, ts); err != nil {
-			t.Fatalf("GetOrCreateASN(%d): %v", asn, err)
-		}
-	}
-	if err := db.UpsertLiveRouteBatch([]*database.LiveRoute{
-		{
-			ID: uuid.New(), Prefix: "192.0.2.0/24", MaskLength: 24, IPVersion: 4,
-			OriginASN: origins[0], PeerIP: "198.51.100.1", ASPath: []int{origins[0]}, NextHop: "198.51.100.1",
-			LastUpdated: ts,
-		},
-		{
-			ID: uuid.New(), Prefix: "192.0.2.0/24", MaskLength: 24, IPVersion: 4,
-			OriginASN: origins[1], PeerIP: "198.51.100.2", ASPath: []int{origins[1]}, NextHop: "198.51.100.2",
-			LastUpdated: ts,
-		},
-	}); err != nil {
-		t.Fatalf("UpsertLiveRouteBatch: %v", err)
-	}
-
-	s := New(failingASDetailsDB{db}, streamer.New(logger.New(), metrics.New()), logger.New(), &config.Config{})
-	rec := httptest.NewRecorder()
-	s.router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/prefix/192.0.2.0/24", nil))
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status %d, want %d; body %s", rec.Code, http.StatusOK, rec.Body)
-	}
-
-	page := rec.Body.String()
-	for _, asn := range origins {
-		info, ok := asinfo.Get(asn)
-		if !ok {
-			t.Fatalf("AS%d is not in the AS info data", asn)
-		}
-		if want := "(" + html.EscapeString(info.Handle) + ")"; !strings.Contains(page, want) {
-			t.Errorf("page does not show AS%d's handle %q", asn, want)
-		}
-		if want := html.EscapeString(info.Description); !strings.Contains(page, want) {
-			t.Errorf("page does not show AS%d's description %q", asn, want)
-		}
-	}
-}
-
 // shortRequestDeadline is the deadline the tests below give a request. The
 // server's 30-second limit and the stats handlers' 4-second limit inherit it,
 // so the tests do not wait for either.
@@ -345,11 +223,8 @@ func TestStatsHandlersAnswer504WhenDatabaseReadRunsOut(t *testing.T) {
 
 // slowDB embeds database.Store (left nil) and overrides the reads the routes
 // in TestRoutesAnswer504WhenDatabaseReadIsCutOff make. Each read waits until
-// its context ends and answers as the real store can when the time limit cuts
+// its context ends and returns the context's error, as a slow database read
-// its read off. The AS and prefix reads, cut off while reading their rows,
+// cut off by a time limit does.
-// give no error: the AS read answers with the AS and the prefixes read so far,
-// here none, and the prefix read answers that there is no route. The other
-// reads answer with the context's error.
 type slowDB struct {
 	database.Store
 }
@@ -366,16 +241,16 @@ func (slowDB) GetIPInfoContext(ctx context.Context, _ string) (*database.IPInfo,
 	return nil, ctx.Err()
 }
 
-func (slowDB) GetASDetailsContext(ctx context.Context, asn int) (*database.ASN, []database.LiveRoute, error) {
+func (slowDB) GetASDetailsContext(ctx context.Context, _ int) (*database.ASN, []database.LiveRoute, error) {
 	<-ctx.Done()
 
-	return &database.ASN{ASN: asn}, nil, nil
+	return nil, nil, ctx.Err()
 }
 
-func (slowDB) GetPrefixDetailsContext(ctx context.Context, _ string) ([]database.LiveRoute, map[int]database.ASN, error) {
+func (slowDB) GetPrefixDetailsContext(ctx context.Context, _ string) ([]database.LiveRoute, error) {
 	<-ctx.Done()
 
-	return nil, nil, database.ErrNoRoute
+	return nil, ctx.Err()
 }
 
 func (slowDB) GetRandomPrefixesByLengthContext(ctx context.Context, _, _, _ int) ([]database.LiveRoute, error) {
@@ -386,10 +261,9 @@ func (slowDB) GetRandomPrefixesByLengthContext(ctx context.Context, _, _, _ int)
 
 // TestRoutesAnswer504WhenDatabaseReadIsCutOff sends a request through the
 // server's router for each route that reads the database, with a store whose
-// reads are cut off when the request's time limit passes. Each route answers
+// reads fail when the request's time limit passes. Each route answers 504, the
-// 504, the JSON routes with the JSON error body. Before the fix they answered
+// JSON routes with the JSON error body. Before the fix they answered 408 or,
-// 408 or, when the handler wrote first, its own answer: 500, 404 on the IP
+// when the handler wrote first, its own error: 500, or 404 on the IP lookups.
-// lookups and the prefix routes, or 200 on /api/v1/as/{asn}.
 // The health check is left out: it answers 503 when its own 2-second ping runs
 // out.
 func TestRoutesAnswer504WhenDatabaseReadIsCutOff(t *testing.T) {

internal/server/middleware.go

@@ -113,10 +113,9 @@ func JSONResponseMiddleware(next http.Handler) http.Handler {
 // requestTimeoutMessage is the error message sent with 504 Gateway Timeout.
 const requestTimeoutMessage = "Request timeout"
 
-// deadlinePassed reports whether ctx ended because its deadline passed. A
+// deadlinePassed reports whether ctx ended because its deadline passed. When
-// handler checks it after a database read or other lookup, so that a request
+// a handler's database read or other lookup fails, it uses this to tell a
-// cut off by its time limit answers 504 instead of with the read's error or
+// request cut off by its time limit, which answers 504, from other failures.
-// its partial result.
 func deadlinePassed(ctx context.Context) bool {
 	return errors.Is(ctx.Err(), context.DeadlineExceeded)
 }

internal/server/server.go

@@ -3,8 +3,6 @@ package server
 
 import (
 	"context"
-	"fmt"
-	"net"
 	"net/http"
 	"strconv"
 	"time"
@@ -55,12 +53,9 @@ func New(db database.Store, streamer *streamer.Streamer, logger *logger.Logger,
 	return s
 }
 
-// Start listens on the configured port and serves HTTP in the background.
+// Start starts the HTTP server
-// It returns an error if it cannot listen, for example because the port is
-// already in use.
 func (s *Server) Start() error {
 	const (
-		network           = "tcp"
 		readHeaderTimeout = 40 * time.Second
 		readTimeout       = 60 * time.Second
 		writeTimeout      = 60 * time.Second
@@ -78,15 +73,10 @@ func (s *Server) Start() error {
 
 	s.logger.Info("Starting HTTP server", "port", s.port, "addr", s.srv.Addr)
 
-	listener, err := net.Listen(network, s.srv.Addr)
+	// Start in goroutine but log when actually listening
-	if err != nil {
-		return fmt.Errorf("starting HTTP server: %w", err)
-	}
-
-	s.logger.Info("HTTP server listening", "addr", listener.Addr().String())
-
 	go func() {
-		if err := s.srv.Serve(listener); err != nil && err != http.ErrServerClosed {
+		s.logger.Info("HTTP server listening", "addr", s.srv.Addr)
+		if err := s.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			s.logger.Error("HTTP server error", "error", err)
 		}
 	}()

internal/server/server_test.go

@@ -1,33 +0,0 @@
-package server
-
-import (
-	"context"
-	"net"
-	"testing"
-
-	"git.eeqj.de/sneak/routewatch/internal/config"
-	"git.eeqj.de/sneak/routewatch/internal/logger"
-	"git.eeqj.de/sneak/routewatch/internal/metrics"
-	"git.eeqj.de/sneak/routewatch/internal/streamer"
-)
-
-// TestStartFailsWhenPortIsHeld holds a port with a listener of its own and
-// checks that Start on that port returns an error. Before the fix Start
-// listened in a goroutine, only logged the failure and returned nil, so the
-// daemon kept running without its web server.
-func TestStartFailsWhenPortIsHeld(t *testing.T) {
-	held, err := net.Listen("tcp", ":0")
-	if err != nil {
-		t.Fatalf("failed to open the test listener: %v", err)
-	}
-	defer func() { _ = held.Close() }()
-
-	port := held.Addr().(*net.TCPAddr).Port
-	log := logger.New()
-	s := New(nil, streamer.New(log, metrics.New()), log, &config.Config{Port: port})
-	defer func() { _ = s.Stop(context.Background()) }()
-
-	if err := s.Start(); err == nil {
-		t.Fatalf("Start returned nil while port %d was held by another listener", port)
-	}
-}

internal/streamer/streamer.go

@@ -7,7 +7,6 @@ import (
 	"compress/gzip"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"math"
@@ -49,7 +48,6 @@ const (
 	metricsUpdateRate     = time.Second
 	minBackoffDelay       = 5 * time.Second
 	maxBackoffDelay       = 320 * time.Second
-	streamIdleTimeout     = 60 * time.Second // Reconnect when no line arrives for this long
 	metricsLogInterval    = 10 * time.Second
 	bytesPerKB            = 1024
 	bytesPerMB            = 1024 * 1024
@@ -60,9 +58,6 @@ const (
 	backpressureSlope     = 2.0 // Slope for linear drop probability increase
 )
 
-// errStreamEnded is returned by stream when RIS Live ends the response.
-var errStreamEnded = errors.New("RIS Live ended the stream")
-
 // MessageHandler defines the interface for processing RIS messages.
 // Implementations must specify which message types they want to receive,
 // how to process messages, and their desired queue capacity.
@@ -112,8 +107,6 @@ type Streamer struct {
 	logger       *logger.Logger
 	client       *http.Client
 	url          string
-	idleTimeout  time.Duration // Drop the connection when no line arrives for this long
-	minBackoff   time.Duration // First wait before reconnecting; doubles up to maxBackoffDelay
 	handlers     []*handlerInfo
 	rawHandler   RawMessageHandler
 	mu           sync.RWMutex
@@ -133,8 +126,6 @@ func New(logger *logger.Logger, metrics *metrics.Tracker) *Streamer {
 	return &Streamer{
 		logger: logger,
 		url:    risLiveURL,
-		idleTimeout: streamIdleTimeout,
-		minBackoff:  minBackoffDelay,
 		client: &http.Client{
 			Timeout: 0, // No timeout for streaming
 			Transport: &http.Transport{
@@ -414,7 +405,7 @@ func (s *Streamer) updateMetrics(messageBytes int) {
 
 // streamWithReconnect handles streaming with automatic reconnection and exponential backoff
 func (s *Streamer) streamWithReconnect(ctx context.Context) {
-	backoffDelay := s.minBackoff
+	backoffDelay := minBackoffDelay
 	consecutiveFailures := 0
 
 	for {
@@ -431,9 +422,8 @@ func (s *Streamer) streamWithReconnect(ctx context.Context) {
 		err := s.stream(ctx)
 		streamDuration := time.Since(startTime)
 
-		// Only Stop ends the streamer. A stream that ends any other way,
+		if err == nil {
-		// with or without an error, is a disconnect and is reconnected.
+			// Clean exit (context cancelled)
-		if ctx.Err() != nil {
 			return
 		}
 
@@ -444,13 +434,17 @@ func (s *Streamer) streamWithReconnect(ctx context.Context) {
 			"stream_duration", streamDuration)
 		s.metrics.SetConnected(false)
 
-		// A stream that lasted more than 30 seconds resets the backoff. That
+		// Check if context is cancelled
-		// includes a stream dropped after streamIdleTimeout with no line, so
+		if ctx.Err() != nil {
-		// a silent feed is retried after the first backoff delay every time.
+			return
+		}
+
+		// If we streamed for more than 30 seconds, reset the backoff
+		// This indicates we had a successful connection that received data
 		if streamDuration > 30*time.Second {
 			s.logger.Info("Resetting backoff delay due to successful connection",
 				"stream_duration", streamDuration)
-			backoffDelay = s.minBackoff
+			backoffDelay = minBackoffDelay
 			consecutiveFailures = 0
 		} else {
 			// Increment consecutive failures
@@ -483,13 +477,7 @@ func (s *Streamer) stream(ctx context.Context) error {
 	connCtx, connCancel := context.WithCancel(ctx)
 	defer connCancel()
 
-	// The idle timer drops the connection, by cancelling connCtx, when no
+	req, err := http.NewRequestWithContext(ctx, "GET", s.url, nil)
-	// line arrives for s.idleTimeout. Each line read starts it over. It
-	// also covers the wait for the server to answer.
-	idleTimer := time.AfterFunc(s.idleTimeout, connCancel)
-	defer idleTimer.Stop()
-
-	req, err := http.NewRequestWithContext(connCtx, "GET", s.url, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
@@ -571,8 +559,6 @@ func (s *Streamer) stream(ctx context.Context) error {
 	scanner := bufio.NewScanner(reader)
 
 	for scanner.Scan() {
-		idleTimer.Reset(s.idleTimeout)
-
 		select {
 		case <-ctx.Done():
 			s.logger.Info("Stream stopped by context")
@@ -721,19 +707,11 @@ func (s *Streamer) stream(ctx context.Context) error {
 		s.mu.RUnlock()
 	}
 
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	if connCtx.Err() != nil {
-		return fmt.Errorf("no line received for %s", s.idleTimeout)
-	}
-
 	if err := scanner.Err(); err != nil {
 		return fmt.Errorf("scanner error: %w", err)
 	}
 
-	return errStreamEnded
+	return nil
 }
 
 // shouldDropForBackpressure determines if a message should be dropped based on queue utilization

internal/streamer/streamer_test.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"runtime"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -40,14 +39,6 @@ func TestNewStreamer(t *testing.T) {
 	if s.metrics != metricsTracker {
 		t.Error("metrics tracker not set correctly")
 	}
-
-	if s.idleTimeout != streamIdleTimeout {
-		t.Errorf("idleTimeout = %s, want %s", s.idleTimeout, streamIdleTimeout)
-	}
-
-	if s.minBackoff != minBackoffDelay {
-		t.Errorf("minBackoff = %s, want %s", s.minBackoff, minBackoffDelay)
-	}
 }
 
 // TestStreamDoesNotLeakTickersAcrossReconnects drives many short-lived
@@ -66,8 +57,8 @@ func TestStreamDoesNotLeakTickersAcrossReconnects(t *testing.T) {
 
 	// One warm-up connection so any persistent HTTP transport goroutine exists
 	// before we take the baseline.
-	if err := s.stream(context.Background()); !errors.Is(err, errStreamEnded) {
+	if err := s.stream(context.Background()); err != nil {
-		t.Fatalf("warm-up stream returned %v, want %v", err, errStreamEnded)
+		t.Fatalf("warm-up stream returned error: %v", err)
 	}
 	s.client.CloseIdleConnections()
 
@@ -75,8 +66,8 @@ func TestStreamDoesNotLeakTickersAcrossReconnects(t *testing.T) {
 
 	const reconnects = 20
 	for range reconnects {
-		if err := s.stream(context.Background()); !errors.Is(err, errStreamEnded) {
+		if err := s.stream(context.Background()); err != nil {
-			t.Fatalf("stream returned %v, want %v", err, errStreamEnded)
+			t.Fatalf("stream returned error: %v", err)
 		}
 	}
 	s.client.CloseIdleConnections()
@@ -87,35 +78,23 @@ func TestStreamDoesNotLeakTickersAcrossReconnects(t *testing.T) {
 	}
 }
 
-// updateLine is one UPDATE message as RIS Live sends it.
+// updateHandler wants UPDATE messages and does nothing with them.
-const updateLine = `{"type":"ris_message","data":{"type":"UPDATE","peer":"192.0.2.1",` +
+type updateHandler struct{}
-	`"peer_asn":"64496","timestamp":1700000000}}` + "\n"
-
-// updateHandler wants UPDATE messages. For each one it handles it sends on
-// handled if there is room, and otherwise does nothing; a nil handled is
-// never sent on.
-type updateHandler struct {
-	handled chan struct{}
-}
 
 func (updateHandler) WantsMessage(messageType string) bool { return messageType == "UPDATE" }
+func (updateHandler) HandleMessage(*ristypes.RISMessage)   {}
 func (updateHandler) QueueCapacity() int                   { return 10 }
 
-func (h updateHandler) HandleMessage(*ristypes.RISMessage) {
-	select {
-	case h.handled <- struct{}{}:
-	default:
-	}
-}
-
 // TestStopBeforeMessageReachesQueues stops the streamer after the read loop
 // has checked for cancellation but before it hands the message to the handler
 // queues. That is the gap a stop from another goroutine can land in, and it
 // used to end in "send on closed channel". The raw handler runs in that gap on
 // the read loop itself, so calling Stop from it hits the gap every time.
 func TestStopBeforeMessageReachesQueues(t *testing.T) {
+	const line = `{"type":"ris_message","data":{"type":"UPDATE","peer":"192.0.2.1",` +
+		`"peer_asn":"64496","timestamp":1700000000}}` + "\n"
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = io.WriteString(w, updateLine)
+		_, _ = io.WriteString(w, line)
 	}))
 	defer srv.Close()
 
@@ -138,117 +117,6 @@ func TestStopBeforeMessageReachesQueues(t *testing.T) {
 	s.Stop()
 }
 
-// TestReconnectWhenStreamEnds has the server end the first response
-// normally, as when RIS Live restarts. The streamer must treat that as a
-// disconnect and connect again.
-func TestReconnectWhenStreamEnds(t *testing.T) {
-	endResponse := func(http.ResponseWriter, *http.Request) {}
-	checkReconnect(t, endResponse, streamIdleTimeout)
-}
-
-// TestReconnectWhenStreamGoesIdle has the server hold the first response
-// open without sending anything. The streamer must drop it once the idle
-// timeout passes and connect again.
-func TestReconnectWhenStreamGoesIdle(t *testing.T) {
-	const idleTimeout = 50 * time.Millisecond
-	holdResponse := func(w http.ResponseWriter, r *http.Request) {
-		w.(http.Flusher).Flush()
-		<-r.Context().Done()
-	}
-	checkReconnect(t, holdResponse, idleTimeout)
-}
-
-// TestReconnectWhenServerNeverAnswers has the server accept the first
-// request and never answer it, not even with headers. The streamer must give
-// up on it once the idle timeout passes and connect again.
-func TestReconnectWhenServerNeverAnswers(t *testing.T) {
-	const idleTimeout = 50 * time.Millisecond
-	neverAnswer := func(_ http.ResponseWriter, r *http.Request) {
-		<-r.Context().Done()
-	}
-	checkReconnect(t, neverAnswer, idleTimeout)
-}
-
-// TestStreamNotDroppedWhileLinesArrive has the server send lines well within
-// the idle timeout for several times the timeout, then end the response. Each
-// line must start the idle timeout over, so the stream lasts until the server
-// ends it instead of being dropped as idle.
-func TestStreamNotDroppedWhileLinesArrive(t *testing.T) {
-	const (
-		idleTimeout  = 100 * time.Millisecond
-		lineInterval = idleTimeout / 10
-		sendFor      = 5 * idleTimeout
-	)
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		deadline := time.Now().Add(sendFor)
-		for time.Now().Before(deadline) {
-			_, _ = io.WriteString(w, updateLine)
-			w.(http.Flusher).Flush()
-			time.Sleep(lineInterval)
-		}
-	}))
-	defer srv.Close()
-
-	s := New(logger.New(), metrics.New())
-	s.url = srv.URL
-	s.idleTimeout = idleTimeout
-
-	if err := s.stream(context.Background()); !errors.Is(err, errStreamEnded) {
-		t.Fatalf("stream returned %v, want %v", err, errStreamEnded)
-	}
-}
-
-// checkReconnect runs a streamer against a fake RIS Live server. The first
-// response is served by firstResponse; every later one carries one UPDATE
-// line and then stays open. The streamer must come back for a second
-// response, must not be marked connected when it does, and must handle the
-// UPDATE in it.
-func checkReconnect(t *testing.T, firstResponse http.HandlerFunc, idleTimeout time.Duration) {
-	t.Helper()
-
-	const maxWait = 5 * time.Second
-
-	tracker := metrics.New()
-	connectedAtReconnect := make(chan bool, 1)
-	var requests atomic.Int32
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if requests.Add(1) == 1 {
-			firstResponse(w, r)
-
-			return
-		}
-		select {
-		case connectedAtReconnect <- tracker.IsConnected():
-		default:
-		}
-		_, _ = io.WriteString(w, updateLine)
-		w.(http.Flusher).Flush()
-		<-r.Context().Done()
-	}))
-	defer srv.Close()
-
-	s := New(logger.New(), tracker)
-	s.url = srv.URL
-	s.idleTimeout = idleTimeout
-	s.minBackoff = time.Millisecond
-	handler := updateHandler{handled: make(chan struct{}, 1)}
-	s.RegisterHandler(handler)
-	if err := s.Start(); err != nil {
-		t.Fatalf("Start returned error: %v", err)
-	}
-	defer s.Stop()
-
-	select {
-	case <-handler.handled:
-	case <-time.After(maxWait):
-		t.Fatalf("no message from a second response handled within %s", maxWait)
-	}
-
-	if <-connectedAtReconnect {
-		t.Error("streamer was still marked connected when it came back for a second response")
-	}
-}
-
 // settledGoroutineCount lets transient goroutines finish, then reports the
 // current count.
 func settledGoroutineCount() int {

internal/templates/prefix_detail.html

@@ -283,7 +283,6 @@
                 <div class="origin-item">
                     <a href="/as/{{.ASN}}" class="as-link">AS{{.ASN}}</a>
                     {{if .Handle}} ({{.Handle}}){{end}}
-                    {{if .Description}} {{.Description}}{{end}}
                     <span style="color: #7f8c8d; margin-left: 10px;">{{.PeerCount}} peer{{if ne .PeerCount 1}}s{{end}}</span>
                 </div>
                 {{end}}