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

Takes .golangci.yml, .dockerignore, .gitignore, .editorconfig, the
workflow and REPO_POLICIES.md from sneak/prompts dd4027b, keeping this
repository's own entries after the shared content. Lint (golangci-lint
v2.14.0) and test become Dockerfile phases that script/lint and
script/test build alone and uncached; the image build depends on both,
and script/cibuild bootstraps, runs script/check, then builds the image.
The agent guidance file moves to AGENTS.md. The Go code is fixed for
what the new configuration finds; reads that iterate rows now also
report an iteration error.

Model: opus-5-5

README.md

@@ -144,9 +144,8 @@ routewatch/
 - **Reconnection**: Exponential backoff (5s-320s) with reset after 30s of stable connection
 - **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
-  text form Go's `net/netip` prints. Routes shorter than /8 for IPv4 or /16
-  for IPv6, such as a default route, are not used.
+  (at most 33 lookups for IPv4, 129 for IPv6); prefixes are stored in the
+  text form Go's `net/netip` prints
 
 ### Database Schema
 

internal/database/database.go

@@ -43,14 +43,6 @@ const (
 	ipv6Family = "IPv6"
 )
 
-// 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 (
@@ -1693,21 +1685,19 @@ func (d *Database) GetASPeersContext(
 }
 
 // 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
-// AS number, the handle and description of each AS that originates it.
+// GetPrefixDetailsContext returns detailed information about a prefix with
+// context support
 func (d *Database) GetPrefixDetailsContext(
 	ctx context.Context, prefix string,
-) ([]LiveRoute, map[int]ASN, error) {
+) ([]LiveRoute, 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 := tableLiveRoutesV4
@@ -1729,14 +1719,12 @@ func (d *Database) GetPrefixDetailsContext(
 
 	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
@@ -1762,23 +1750,18 @@ func (d *Database) GetPrefixDetailsContext(
 		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,
-		}
 	}
 
 	err = rows.Err()
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to read prefix details: %w", err)
+		return nil, fmt.Errorf("failed to read prefix details: %w", err)
 	}
 
 	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
@@ -2025,12 +2008,11 @@ const ipInfoQuery = `
 // 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
-// minLookupMaskLengthV4 or minLookupMaskLengthV6 it looks up the address's
-// network prefix at that length, and the first length with a live route wins.
-// That is at most 25 or 113 indexed lookups, however many routes are live. The
-// prefix is looked up in the text form net/netip prints, which is the form the
-// prefix handler stores.
+// the prefix index: for each mask length from the longest (32 or 128) down to 0
+// it looks up the address's network prefix at that length, and the first length
+// with a live route wins. That is at most 33 or 129 indexed lookups, however
+// many routes are live. The prefix is looked up in the text form net/netip
+// prints, which is the form the prefix handler stores.
 func (d *Database) GetIPInfoContext(
 	ctx context.Context, ip string,
 ) (*IPInfo, error) {
@@ -2044,11 +2026,8 @@ func (d *Database) GetIPInfoContext(
 	info := &IPInfo{IP: ip, IPVersion: ipVersionV6}
 
 	routesTable, prefixesTable := tableLiveRoutesV6, "prefixes_v6"
-	minMaskLength := minLookupMaskLengthV6
-
 	if addr.Is4() {
 		routesTable, prefixesTable = tableLiveRoutesV4, "prefixes_v4"
-		minMaskLength = minLookupMaskLengthV4
 		info.IPVersion = ipVersionV4
 	}
 
@@ -2069,7 +2048,7 @@ func (d *Database) GetIPInfoContext(
 
 	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(

internal/database/database_internal_test.go

@@ -126,71 +126,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) {
-	t.Parallel()
-
-	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() }()
-
-	// announce writes one live route for prefix, originated by asn.
-	announce := func(prefix string, asn int) {
-		t.Helper()
-
-		writeOriginRoutes(t, db, map[string]int{prefix: asn})
-	}
-
-	// 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"} {
-		info, err := db.GetIPInfo(ip)
-		if !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)
-}
-
 // writeOriginRoutes writes one live route from testPeerIP for each prefix in
 // origins, originated by the AS it maps to.
 func writeOriginRoutes(t *testing.T, db *Database, origins map[string]int) {

internal/database/interface.go

@@ -80,8 +80,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)
-	GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, map[int]ASN, error)
+	GetPrefixDetails(prefix string) ([]LiveRoute, error)
+	GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, error)
 	GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]LiveRoute, error)
 	GetRandomPrefixesByLengthContext(
 		ctx context.Context, maskLength, ipVersion, limit int,

internal/routewatch/app.go

@@ -115,7 +115,7 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 	}
 
 	// Start HTTP server
-	err = rw.server.Start(ctx)
+	err = rw.server.Start()
 	if err != nil {
 		return err
 	}

internal/routewatch/app_integration_internal_test.go

@@ -263,17 +263,15 @@ func (m *mockStore) GetASDetailsContext(
 }
 
 // GetPrefixDetails mock implementation
-func (m *mockStore) GetPrefixDetails(
-	_ string,
-) ([]database.LiveRoute, map[int]database.ASN, error) {
+func (m *mockStore) GetPrefixDetails(_ 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(
 	_ context.Context, prefix string,
-) ([]database.LiveRoute, map[int]database.ASN, error) {
+) ([]database.LiveRoute, 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
@@ -93,12 +91,6 @@ func CLIEntry() {
 						err := rw.Run(ctx)
 						if err != nil {
 							logger.Error("RouteWatch error", "error", err)
-
-							err = shutdowner.Shutdown(fx.ExitCode(failureExitCode))
-							if err != nil {
-								logger.Error("Failed to shutdown gracefully",
-									"error", err)
-							}
 						}
 					}()
 

internal/routewatch/prefixhandler_internal_test.go

@@ -218,7 +218,7 @@ func checkPrefixRoutes(
 
 	ctx := context.Background()
 
-	routes, _, err := db.GetPrefixDetailsContext(ctx, prefix)
+	routes, err := db.GetPrefixDetailsContext(ctx, prefix)
 	if err != nil && !errors.Is(err, database.ErrNoRoute) {
 		t.Fatalf("GetPrefixDetailsContext: %v", err)
 	}

internal/server/handlers.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"net"
 	"net/http"
-	"net/netip"
 	"runtime"
 	"sort"
 	"strconv"
@@ -865,17 +864,10 @@ func (s *Server) handlePrefixDetailJSON() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
-		// tables store, so that any valid way of writing it finds the route.
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
-		if err != nil {
-			writeJSONError(w, http.StatusBadRequest, err.Error())
+		// Combine prefix and length into CIDR notation
+		prefix := prefixParam + "/" + lenParam
 
-			return
-		}
-		prefix := parsed.Masked().String()
-
-		routes, _, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
+		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
 			if errors.Is(err, database.ErrNoRoute) {
 				s.writeJSONError(w, http.StatusNotFound, err.Error())
@@ -1000,17 +992,10 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
-		// tables store, so that any valid way of writing it finds the route.
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
-		if err != nil {
-			http.Error(w, "Invalid prefix", http.StatusBadRequest)
+		// Combine prefix and length into CIDR notation
+		prefix := prefixParam + "/" + lenParam
 
-			return
-		}
-		prefix := parsed.Masked().String()
-
-		routes, originNames, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
+		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
 			if errors.Is(err, database.ErrNoRoute) {
 				http.Error(w, "Prefix not found", http.StatusNotFound)
@@ -1023,7 +1008,7 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
 		}
 
 		// Group by origin AS and collect unique AS info
-		originMap := originASNs(routes, originNames)
+		originMap := s.originASNs(r.Context(), routes)
 
 		// Get the first route to extract some common info
 		var maskLength, ipVersion int
@@ -1088,20 +1073,29 @@ type ASNInfo struct {
 }
 
 // originASNs groups routes by origin AS, with each AS's handle and description
-// from names, as the prefix query returned them, and the number of routes it
-// originates.
-func originASNs(
+// from the database and the number of routes it originates.
+func (s *Server) originASNs(
+	ctx context.Context,
 	routes []database.LiveRoute,
-	names map[int]database.ASN,
 ) map[int]*ASNInfo {
 	originMap := make(map[int]*ASNInfo)
 
 	for _, route := range routes {
 		if _, exists := originMap[route.OriginASN]; !exists {
+			// Get AS info from database
+			asInfo, _, _ := s.db.GetASDetailsContext(ctx, route.OriginASN)
+			handle := ""
+			description := ""
+
+			if asInfo != nil {
+				handle = asInfo.Handle
+				description = asInfo.Description
+			}
+
 			originMap[route.OriginASN] = &ASNInfo{
 				ASN:         route.OriginASN,
-				Handle:      names[route.OriginASN].Handle,
-				Description: names[route.OriginASN].Description,
+				Handle:      handle,
+				Description: description,
 				PeerCount:   0,
 			}
 		}

internal/server/handlers_internal_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"
 )
 
@@ -171,124 +167,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)
-		}
-	}
-}
-
 // settledGoroutineCount lets transient goroutines finish, then reports the
 // current count.
 func settledGoroutineCount() int {

internal/server/server.go

@@ -4,8 +4,6 @@ package server
 import (
 	"context"
 	"errors"
-	"fmt"
-	"net"
 	"net/http"
 	"strconv"
 	"time"
@@ -61,12 +59,9 @@ func New(
 	return s
 }
 
-// Start listens on the configured port and serves HTTP in the background.
-// It returns an error if it cannot listen, for example because the port is
-// already in use. ctx bounds only opening the port, not serving.
-func (s *Server) Start(ctx context.Context) error {
+// Start starts the HTTP server
+func (s *Server) Start() error {
 	const (
-		network           = "tcp"
 		readHeaderTimeout = 40 * time.Second
 		readTimeout       = 60 * time.Second
 		writeTimeout      = 60 * time.Second
@@ -84,17 +79,11 @@ func (s *Server) Start(ctx context.Context) error {
 
 	s.logger.Info("Starting HTTP server", "port", s.port, "addr", s.srv.Addr)
 
-	var listenConfig net.ListenConfig
-
-	listener, err := listenConfig.Listen(ctx, network, s.srv.Addr)
-	if err != nil {
-		return fmt.Errorf("starting HTTP server: %w", err)
-	}
-
-	s.logger.Info("HTTP server listening", "addr", listener.Addr().String())
-
+	// Start in goroutine but log when actually listening
 	go func() {
-		err := s.srv.Serve(listener)
+		s.logger.Info("HTTP server listening", "addr", s.srv.Addr)
+
+		err := s.srv.ListenAndServe()
 		if err != nil && !errors.Is(err, http.ErrServerClosed) {
 			s.logger.Error("HTTP server error", "error", err)
 		}

internal/server/server_test.go

@@ -1,46 +0,0 @@
-package server_test
-
-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/server"
-	"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) {
-	t.Parallel()
-
-	var listenConfig net.ListenConfig
-
-	held, err := listenConfig.Listen(t.Context(), "tcp", ":0")
-	if err != nil {
-		t.Fatalf("failed to open the test listener: %v", err)
-	}
-	defer func() { _ = held.Close() }()
-
-	addr, ok := held.Addr().(*net.TCPAddr)
-	if !ok {
-		t.Fatalf("test listener address %v is not a TCP address", held.Addr())
-	}
-
-	port := addr.Port
-	log := logger.New()
-	s := server.New(nil, streamer.New(log, metrics.New()), log,
-		&config.Config{Port: port})
-	defer func() { _ = s.Stop(context.Background()) }()
-
-	err = s.Start(t.Context())
-	if err == nil {
-		t.Fatalf("Start returned nil while port %d was held by another listener",
-			port)
-	}
-}

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}}