fix: a claim's recorded subnet follows the class

A claim keeps its slot for the life of the node pair, and the link
addresses are derived from the class subnet and that slot every pass,
never read back from the claim. Changing a class's subnet therefore left
the recorded text naming a /31 nothing carried, so the status described a
link that did not exist while routing was correct.

gcClaims already rewrites existing claims to set and clear UnusedSince,
so the correction goes there: when the /31 the class and slot now yield
differs from the recorded one, the claim is rewritten with it. The slot is
untouched, since only the text was ever wrong.

A claim that already reads correctly produces no update, so a pass over a
settled class still writes nothing.

Author: Spiritreader

internal/reconcile/links.go

@@ -285,23 +285,44 @@ func sortedPair(a, b string) [2]string {
 // sets it once to now; a pair unused for more than 24h is dropped. Any selecting
 // agent may run this; the write conflicts sort themselves out.
 func gcClaims(class *v1alpha1.PortMapClass, needed map[string]neededPair, now metav1.Time) (updates []v1alpha1.LinkAllocation, drops []string) {
+	subnet, subnetErr := parseClassSubnet(class)
+
 	for i := range class.Status.Links {
 		la := class.Status.Links[i]
 		_, isNeeded := needed[la.Key]
+
+		if !isNeeded && la.UnusedSince != nil && now.Sub(la.UnusedSince.Time) > 24*time.Hour {
+			drops = append(drops, la.Key)
+			continue
+		}
+
+		cp := la
+		changed := false
+
 		switch {
-		case isNeeded:
-			if la.UnusedSince != nil {
-				cp := la
-				cp.UnusedSince = nil
-				updates = append(updates, cp)
-			}
-		case la.UnusedSince == nil:
-			cp := la
+		case isNeeded && la.UnusedSince != nil:
+			cp.UnusedSince = nil
+			changed = true
+		case !isNeeded && la.UnusedSince == nil:
 			t := now
 			cp.UnusedSince = &t
+			changed = true
+		}
+
+		// A link's addresses are derived from the class subnet and the slot
+		// every pass, never read back from here, so changing the subnet leaves
+		// this field naming a /31 nothing carries. A claim keeps its slot, so
+		// correcting the text is the whole repair.
+		if subnetErr == nil && int(la.Slot) >= 0 && int(la.Slot) < slotCount(subnet) {
+			lo, _ := nthSlash31(subnet, int(la.Slot))
+			if want := netip.PrefixFrom(lo, 31).String(); want != cp.Subnet {
+				cp.Subnet = want
+				changed = true
+			}
+		}
+
+		if changed {
 			updates = append(updates, cp)
-		case now.Sub(la.UnusedSince.Time) > 24*time.Hour:
-			drops = append(drops, la.Key)
 		}
 	}
 	sort.Slice(updates, func(i, j int) bool { return updates[i].Key < updates[j].Key })

internal/reconcile/links_test.go

@@ -193,4 +193,49 @@ func TestLinkNameIsPerClass(t *testing.T) {
 	}
 }
 
+// TestGCClaimsCorrectsStaleSubnet: a claim keeps its slot for the life of the
+// pair, and the link addresses are derived from the class subnet and that slot
+// every pass. Changing the subnet therefore leaves the recorded text naming a
+// /31 nothing carries, which reads as a link that does not exist.
+func TestGCClaimsCorrectsStaleSubnet(t *testing.T) {
+	cls := class("public", []string{"node-a"},
+		withSubnet("169.254.79.0/24"),
+		withLinks(claim("node-a", "node-b", 1)), // claim() records 169.254.77.0/31
+	)
+	needed := map[string]neededPair{
+		pairKey("node-a", "node-b"): {key: pairKey("node-a", "node-b")},
+	}
+
+	updates, drops := gcClaims(cls, needed, metav1.NewTime(baseTime))
+	if len(drops) != 0 {
+		t.Fatalf("drops = %v, want none for a needed pair", drops)
+	}
+	if len(updates) != 1 {
+		t.Fatalf("updates = %+v, want the claim rewritten", updates)
+	}
+	// Slot 1 of 169.254.79.0/24 is the second /31.
+	if got, want := updates[0].Subnet, "169.254.79.2/31"; got != want {
+		t.Errorf("subnet = %s, want %s", got, want)
+	}
+	if updates[0].Slot != 1 {
+		t.Errorf("slot = %d, want 1 kept; only the text was wrong", updates[0].Slot)
+	}
+}
+
+// TestGCClaimsLeavesACorrectSubnetAlone keeps the pass idempotent: rewriting a
+// claim that already reads correctly would write to the API every reconcile.
+func TestGCClaimsLeavesACorrectSubnetAlone(t *testing.T) {
+	cls := class("public", []string{"node-a"},
+		withLinks(claim("node-a", "node-b", 0)), // 169.254.77.0/31, the default subnet's slot 0
+	)
+	needed := map[string]neededPair{
+		pairKey("node-a", "node-b"): {key: pairKey("node-a", "node-b")},
+	}
+
+	updates, _ := gcClaims(cls, needed, metav1.NewTime(baseTime))
+	if len(updates) != 0 {
+		t.Errorf("updates = %+v, want none when nothing changed", updates)
+	}
+}
+
 var in0now = metav1.NewTime(baseTime)