Add expiry of old gone entries. in case of dup process, exit the oldest one. fixed some -race issues. Improvement to Sync map: sorted concurrent safe iteration (#12)

ldemailly · web-flow · commit 3689374a0f99 · 2025-10-16T14:43:26.000-07:00
* Add expiry of old gone entries. in case of dup process, exit the oldest one. fixed some -race issues

* Add sorting

* Add NaturalSort even if we can't use it

* linters

* Somewhat useful overlord comments for once

* more ai nits

* more lint

* reuse the AllSorted instead of copy-pasta
diff --git a/main.go b/main.go
@@ -111,14 +111,17 @@ func Main() int {
 	err = ap.FPSTicks(func() bool {
 		// Only refresh if we had (log) output or something changed, so cursor blinks (!).
 		logHadOutput := ap.FlushLogger()
+		if srv.Stopped() {
+			return false
+		}
 		curVersion := version.Load()
 		// log.Debugf("Have %d peers (prev %d), logHadOutput=%v", numPeers, prev, logHadOutput)
 		if logHadOutput || curVersion != prev {
 			if !logHadOutput {
 				ap.StartSyncMode()
 			}
 			prev = curVersion
-			for peer, peerData := range srv.Peers.All() {
+			for peer, peerData := range srv.Peers.AllSorted(tsnet.PeerSort) {
 				fmt.Fprintf(&buf, "\n%s", PeerString(peer, peerData))
 			}
 			ap.WriteBoxed(1, "%s\n🔗%s", ourLine, buf.String())
diff --git a/smap/smap.go b/smap/smap.go
@@ -2,7 +2,9 @@
 package smap
 
 import (
+	"cmp"
 	"iter"
+	"sort"
 	"sync"
 )
 
@@ -138,3 +140,64 @@ func (s *Map[K, V]) Keys() iter.Seq[K] {
 		}
 	}
 }
+
+// KeysSorted returns an iterator over keys sorted using the provided comparison function.
+// The map snapshot occurs under a read lock, then sorting happens without holding the lock.
+func (s *Map[K, V]) KeysSorted(less func(a, b K) bool) iter.Seq[K] {
+	return func(yield func(K) bool) {
+		s.mu.RLock()
+		keys := make([]K, 0, len(s.m))
+		for k := range s.m {
+			keys = append(keys, k)
+		}
+		s.mu.RUnlock()
+
+		sort.Slice(keys, func(i, j int) bool {
+			return less(keys[i], keys[j])
+		})
+
+		for _, k := range keys {
+			if !yield(k) {
+				return
+			}
+		}
+	}
+}
+
+// AllSorted returns an iterator over key-value pairs where keys are visited in the order defined by less.
+// The keys snapshot occurs under a read lock, then sorting and value lookups happen without holding it.
+// Because of that, by the time a key is revisited later, it may have been deleted; such entries are skipped.
+func (s *Map[K, V]) AllSorted(less func(a, b K) bool) iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		s.mu.RLock()
+		keys := make([]K, 0, len(s.m))
+		for k := range s.m {
+			keys = append(keys, k)
+		}
+		s.mu.RUnlock()
+
+		sort.Slice(keys, func(i, j int) bool {
+			return less(keys[i], keys[j])
+		})
+
+		for _, k := range keys {
+			s.mu.RLock()
+			v, ok := s.m[k]
+			s.mu.RUnlock()
+			if !ok {
+				continue
+			}
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+}
+
+// NaturalSort returns an iterator that visits key-value pairs in the natural order of Q (using <).
+// This requires Q (K from the Map[Q, V]) to be an ordered type.
+func NaturalSort[Q cmp.Ordered, V any](s *Map[Q, V]) iter.Seq2[Q, V] {
+	return s.AllSorted(func(a, b Q) bool {
+		return a < b
+	})
+}
diff --git a/smap/smap_test.go b/smap/smap_test.go
@@ -308,6 +308,126 @@ func TestKeysEarlyTermination(t *testing.T) {
 	}
 }
 
+func TestKeysSorted(t *testing.T) {
+	m := New[string, int]()
+	m.Set("c", 3)
+	m.Set("a", 1)
+	m.Set("b", 2)
+
+	expected := []string{"a", "b", "c"}
+	idx := 0
+	for k := range m.KeysSorted(func(a, b string) bool { return a < b }) {
+		if idx >= len(expected) {
+			t.Fatalf("received more keys than expected; extra key %q", k)
+		}
+		if k != expected[idx] {
+			t.Fatalf("expected key %q at position %d, got %q", expected[idx], idx, k)
+		}
+		idx++
+	}
+	if idx != len(expected) {
+		t.Fatalf("expected %d keys, got %d", len(expected), idx)
+	}
+
+	t.Run("earlyTermination", func(t *testing.T) {
+		seqMap := New[string, int]()
+		seqMap.Set("y", 2)
+		seqMap.Set("x", 1)
+		seq := seqMap.KeysSorted(func(a, b string) bool { return a < b })
+		calls := 0
+		seq(func(string) bool {
+			calls++
+			return false
+		})
+		if calls != 1 {
+			t.Fatalf("expected to stop after 1 iteration, got %d", calls)
+		}
+	})
+
+	t.Run("structKeyCustomSort", func(t *testing.T) {
+		type compoundKey struct {
+			label    string
+			priority int
+		}
+
+		s := New[compoundKey, int]()
+		s.Set(compoundKey{label: "gamma", priority: 2}, 20)
+		s.Set(compoundKey{label: "alpha", priority: 3}, 30)
+		s.Set(compoundKey{label: "omega", priority: 1}, 10)
+
+		less := func(a, b compoundKey) bool {
+			return a.priority < b.priority
+		}
+
+		order := make([]compoundKey, 0, 3)
+		for k := range s.KeysSorted(less) {
+			order = append(order, k)
+		}
+
+		expectedOrder := []compoundKey{
+			{label: "omega", priority: 1},
+			{label: "gamma", priority: 2},
+			{label: "alpha", priority: 3},
+		}
+
+		if len(order) != len(expectedOrder) {
+			t.Fatalf("expected %d keys, got %d", len(expectedOrder), len(order))
+		}
+
+		for i, got := range order {
+			want := expectedOrder[i]
+			if got != want {
+				t.Fatalf("at position %d expected %v, got %v", i, want, got)
+			}
+		}
+	})
+}
+
+func TestAllSorted(t *testing.T) {
+	m := New[int, string]()
+	m.Set(3, "three")
+	m.Set(1, "one")
+	m.Set(2, "two")
+
+	visited := make([]KV[int, string], 0, 3)
+	for k, v := range m.AllSorted(func(a, b int) bool { return a < b }) {
+		visited = append(visited, KV[int, string]{Key: k, Value: v})
+		if k == 1 {
+			m.Delete(2)
+		}
+	}
+
+	expected := []KV[int, string]{
+		{Key: 1, Value: "one"},
+		{Key: 3, Value: "three"},
+	}
+
+	if len(visited) != len(expected) {
+		t.Fatalf("expected %d key/value pairs, got %d", len(expected), len(visited))
+	}
+
+	for i, kv := range expected {
+		if visited[i] != kv {
+			t.Fatalf("expected pair %v at position %d, got %v", kv, i, visited[i])
+		}
+	}
+
+	t.Run("earlyTermination", func(t *testing.T) {
+		seqMap := New[int, string]()
+		seqMap.Set(2, "two")
+		seqMap.Set(1, "one")
+		seq := seqMap.AllSorted(func(a, b int) bool { return a < b })
+		calls := 0
+		seq(func(int, string) bool {
+			calls++
+			return false
+		})
+		if calls != 1 {
+			t.Fatalf("expected to stop after 1 iteration, got %d", calls)
+		}
+	})
+}
+
 func TestIteratorWithDifferentTypes(t *testing.T) {
 	// Test with different types
 	m := New[int, string]()
@@ -629,3 +749,121 @@ func DeleteDuringIterationDeadlock(t *testing.T) {
 	wg.Wait()
 	t.Errorf("Unexpected no hang")
 }
+
+func TestAllNaturalSort(t *testing.T) { //nolint:gocognit // it's a test!
+	t.Run("int", func(t *testing.T) {
+		m := New[int, string]()
+		m.Set(3, "three")
+		m.Set(1, "one")
+		m.Set(2, "two")
+
+		expected := []int{1, 2, 3}
+		i := 0
+		for k, v := range NaturalSort(m) {
+			if k != expected[i] {
+				t.Errorf("Expected key %d, got %d", expected[i], k)
+			}
+			if i == 0 && v != "one" {
+				t.Errorf("Expected value 'one', got '%s'", v)
+			}
+			i++
+		}
+		if i != 3 {
+			t.Errorf("Expected 3 iterations, got %d", i)
+		}
+	})
+
+	t.Run("string", func(t *testing.T) {
+		m := New[string, int]()
+		m.Set("charlie", 3)
+		m.Set("alice", 1)
+		m.Set("bob", 2)
+
+		expected := []string{"alice", "bob", "charlie"}
+		i := 0
+		for k, v := range NaturalSort(m) {
+			if k != expected[i] {
+				t.Errorf("Expected key %s, got %s", expected[i], k)
+			}
+			if i == 0 && v != 1 {
+				t.Errorf("Expected value 1, got %d", v)
+			}
+			i++
+		}
+		if i != 3 {
+			t.Errorf("Expected 3 iterations, got %d", i)
+		}
+	})
+
+	t.Run("keyDeletedDuringIteration", func(t *testing.T) {
+		m := New[int, string]()
+		m.Set(3, "three")
+		m.Set(1, "one")
+		m.Set(2, "two")
+		m.Set(4, "four")
+
+		visited := make([]KV[int, string], 0, 4)
+		for k, v := range NaturalSort(m) {
+			visited = append(visited, KV[int, string]{Key: k, Value: v})
+			// Delete key 2 after visiting key 1
+			if k == 1 {
+				m.Delete(2)
+			}
+		}
+
+		// Expected: 1, 3, 4 (key 2 should be skipped because it was deleted)
+		expected := []KV[int, string]{
+			{Key: 1, Value: "one"},
+			{Key: 3, Value: "three"},
+			{Key: 4, Value: "four"},
+		}
+
+		if len(visited) != len(expected) {
+			t.Fatalf("expected %d key/value pairs, got %d", len(expected), len(visited))
+		}
+
+		for i, kv := range expected {
+			if visited[i] != kv {
+				t.Fatalf("expected pair %v at position %d, got %v", kv, i, visited[i])
+			}
+		}
+	})
+
+	t.Run("earlyTermination", func(t *testing.T) {
+		m := New[int, string]()
+		m.Set(3, "three")
+		m.Set(1, "one")
+		m.Set(2, "two")
+		m.Set(4, "four")
+
+		calls := 0
+		for range NaturalSort(m) {
+			calls++
+			if calls == 2 {
+				break
+			}
+		}
+
+		if calls != 2 {
+			t.Fatalf("expected to stop after 2 iterations, got %d", calls)
+		}
+	})
+
+	t.Run("earlyTerminationViaYield", func(t *testing.T) {
+		m := New[int, string]()
+		m.Set(5, "five")
+		m.Set(1, "one")
+		m.Set(3, "three")
+
+		seq := NaturalSort(m)
+		calls := 0
+		seq(func(int, string) bool {
+			calls++
+			return false // Stop immediately
+		})
+
+		if calls != 1 {
+			t.Fatalf("expected to stop after 1 iteration when yield returns false, got %d", calls)
+		}
+	})
+}
diff --git a/tsnet/tsnet.go b/tsnet/tsnet.go
