Never move last seen back or first seen forward (closes #162)

Some RIS collectors send updates days old while they catch up on a
backlog. Every update to a stored AS, peering or peer set last_seen to
the update's time, even an older one, and never lowered first_seen. An
AS page could then list a peer first seen after it was last seen.

The update statements for asns, peerings and bgp_peers now keep the
earlier of the stored and new first_seen and the later of the stored
and new last_seen, with MIN and MAX in the SQL. The batch and the
single-row writes share each statement. GetOrCreateASN returns the
times the row now holds. Route times are unchanged.

Model: opus-5-5

internal/database/database_internal_test.go

@@ -1961,26 +1961,29 @@ func TestUpdatePeerBatchStoresTheEarliestAndLatestTimesOfANewPeer(
 	}
 }
 
-// backlogAge is how much older one write is than the other in the tests of
+// backlogAge is how much older the second write is than the first in the tests
-// first_seen and last_seen, as when a collector catches up on a backlog.
+// of first_seen and last_seen, as when a collector catches up on a backlog.
 const backlogAge = 24 * time.Hour
 
 // batchSpan is how much earlier a batch's First is than its Last in the tests
 // of first_seen and last_seen.
 const batchSpan = time.Hour
 
-// TestWritesKeepEarliestFirstSeenAndLatestLastSeen writes a row of each of
+// TestOlderWriteKeepsLastSeenAndLowersFirstSeen writes a row of each of asns,
-// asns, peerings and bgp_peers through each function that writes one, at a
+// peerings and bgp_peers through each function that writes one: first at a
-// newer time and at an older one. Each row takes the older write's First as
+// newer time, then at an older one. Each row keeps the newer last_seen and
-// first_seen and the newer write's Last as last_seen. The test writes in both
+// takes the older first_seen. Each function writes a row of its own. A batch
-// orders, each in a database of its own. Newer then older is a collector
+// write's First is batchSpan before its Last, so the test catches the two
-// catching up on a backlog; older then newer is a feed that arrives in order.
+// swapped. A single-row write takes one time.
-// Each function writes a row of its own. A batch write's First is batchSpan
+func TestOlderWriteKeepsLastSeenAndLowersFirstSeen(t *testing.T) {
-// before its Last, so the test catches the two swapped. A single-row write
-// takes one time.
-func TestWritesKeepEarliestFirstSeenAndLatestLastSeen(t *testing.T) {
 	t.Parallel()
 
+	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 (
 		batchASN, singleASN = 64500, 64501
 		peerASN             = 64502
@@ -1991,58 +1994,42 @@ func TestWritesKeepEarliestFirstSeenAndLatestLastSeen(t *testing.T) {
 			"WHERE peer_ip = ?"
 	)
 
-	for name, olderFirst := range map[string]bool{
+	checkOlderWrite(t, db, func(seen SeenTimes) error {
-		"newer then older": false,
+		return db.GetOrCreateASNBatch(map[int]SeenTimes{batchASN: seen})
-		"older then newer": true,
+	}, batchSpan, asnQuery, batchASN)
-	} {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
 
-			db, err := New(&config.Config{StateDir: t.TempDir()}, logger.New())
+	checkOlderWrite(t, db, func(seen SeenTimes) error {
-			if err != nil {
+		_, err := db.GetOrCreateASN(singleASN, seen.Last)
-				t.Fatalf("failed to create database: %v", err)
-			}
-			defer func() { _ = db.Close() }()
 
-			checkSeenTimes(t, db, olderFirst, func(seen SeenTimes) error {
+		return err
-				return db.GetOrCreateASNBatch(map[int]SeenTimes{batchASN: seen})
+	}, 0, asnQuery, singleASN)
-			}, batchSpan, asnQuery, batchASN)
 
-			checkSeenTimes(t, db, olderFirst, func(seen SeenTimes) error {
+	checkOlderWrite(t, db, func(seen SeenTimes) error {
-				_, err := db.GetOrCreateASN(singleASN, seen.Last)
+		return db.RecordPeering(batchASN, singleASN, seen)
+	}, batchSpan, peeringQuery, batchASN, singleASN)
 
-				return err
+	checkOlderWrite(t, db, func(seen SeenTimes) error {
-			}, 0, asnQuery, singleASN)
+		return db.UpdatePeerBatch(map[string]PeerUpdate{
-
+			testV4PeerIP: {
-			checkSeenTimes(t, db, olderFirst, func(seen SeenTimes) error {
+				PeerIP: testV4PeerIP, PeerASN: peerASN,
-				return db.RecordPeering(batchASN, singleASN, seen)
+				MessageType: ristypes.MessageTypeUpdate,
-			}, batchSpan, peeringQuery, batchASN, singleASN)
+				Seen:        seen,
-
+			},
-			checkSeenTimes(t, db, olderFirst, func(seen SeenTimes) error {
-				return db.UpdatePeerBatch(map[string]PeerUpdate{
-					testV4PeerIP: {
-						PeerIP: testV4PeerIP, PeerASN: peerASN,
-						MessageType: ristypes.MessageTypeUpdate,
-						Seen:        seen,
-					},
-				})
-			}, batchSpan, peerQuery, testV4PeerIP)
-
-			checkSeenTimes(t, db, olderFirst, func(seen SeenTimes) error {
-				return db.UpdatePeer(testPeerIP, peerASN,
-					ristypes.MessageTypeUpdate, seen.Last)
-			}, 0, peerQuery, testPeerIP)
 		})
-	}
+	}, batchSpan, peerQuery, testV4PeerIP)
+
+	checkOlderWrite(t, db, func(seen SeenTimes) error {
+		return db.UpdatePeer(testPeerIP, peerASN, ristypes.MessageTypeUpdate,
+			seen.Last)
+	}, 0, peerQuery, testPeerIP)
 }
 
-// checkSeenTimes calls write twice, each time with First span before Last: at
+// checkOlderWrite calls write twice, each time with First span before Last:
-// newer times and at times backlogAge older. It writes the older times first
+// first at newer times, then at times backlogAge older. It checks that query,
-// when olderFirst is true. It checks that query, given args, reads the older
+// given args, reads the older write's First as first_seen and the newer write's
-// write's First as first_seen and the newer write's Last as last_seen.
+// Last as last_seen.
-func checkSeenTimes(
+func checkOlderWrite(
-	t *testing.T, db *Database, olderFirst bool,
+	t *testing.T, db *Database, write func(seen SeenTimes) error,
-	write func(seen SeenTimes) error,
 	span time.Duration, query string, args ...any,
 ) {
 	t.Helper()
@@ -2054,12 +2041,7 @@ func checkSeenTimes(
 		Last:  newer.Last.Add(-backlogAge),
 	}
 
-	writes := []SeenTimes{newer, older}
+	for _, seen := range []SeenTimes{newer, older} {
-	if olderFirst {
-		writes = []SeenTimes{older, newer}
-	}
-
-	for _, seen := range writes {
 		err := write(seen)
 		if err != nil {
 			t.Fatalf("writing first %s, last %s: %v", seen.First, seen.Last, err)