remove sortFunc in favor of compareFunc; Find() has to take ResourceId

Author: conradhanson

contrib/pkg/sets/sets.go

@@ -28,7 +28,6 @@ func TypedKey(id ezkube.ResourceId) string {
 type ResourceSet interface {
 	Keys() sets.String
 	List(filterResource ...func(ezkube.ResourceId) bool) []ezkube.ResourceId
-	UnsortedList(filterResource ...func(ezkube.ResourceId) bool) []ezkube.ResourceId
 	Map() Resources
 	Insert(resource ...ezkube.ResourceId)
 	Equal(set ResourceSet) bool
@@ -81,12 +80,6 @@ func (t *threadSafeResourceSet) List(filterResource ...func(ezkube.ResourceId) b
 	return t.set.List(filterResource...)
 }
 
-func (t *threadSafeResourceSet) UnsortedList(filterResource ...func(ezkube.ResourceId) bool) []ezkube.ResourceId {
-	t.lock.RLock()
-	defer t.lock.RUnlock()
-	return t.set.UnsortedList(filterResource...)
-}
-
 func (t *threadSafeResourceSet) Map() Resources {
 	t.lock.RLock()
 	defer t.lock.RUnlock()

contrib/pkg/sets/sets_bench_test.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"reflect"
 	"sort"
-	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -32,19 +31,25 @@ func BenchmarkResourcesSet100000(b *testing.B) { benchmarkResourcesSet(100000, b
 func benchmarkResourcesSet(count int, b *testing.B) {
 	resources := make([]*things_test_io_v1.Paint, count)
 	for i := 0; i < count; i++ {
+		clusterName := ""
+		if i%3 == 0 {
+			clusterName = "cluster-2"
+		} else {
+			clusterName = "cluster-1"
+		}
 		resources[i] = &things_test_io_v1.Paint{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              fmt.Sprintf("name-%d", i),
 				Namespace:         fmt.Sprintf("namespace-%d", i),
-				Annotations:       map[string]string{ezkube.ClusterAnnotation: "random-cluster"},
+				Annotations:       map[string]string{ezkube.ClusterAnnotation: clusterName},
 				CreationTimestamp: metav1.Time{Time: metav1.Now().Time.Add(time.Duration(i))},
 			},
 		}
 	}
 
 	for n := 0; n < b.N; n++ {
 		// s := v1sets.NewPaintSet(ezkube.CreationTimestampAscending, ezkube.CreationTimestampsCompare)
-		s := v2sets.NewResourceSet[*things_test_io_v1.Paint](ezkube.ObjectsAscending, ezkube.CompareObjects)
+		s := v2sets.NewResourceSet[*things_test_io_v1.Paint](ezkube.ResourceIdsCompare)
 		s.Insert(resources...)
 
 		// SortByCreationTime(l) // only for map implementation
@@ -68,8 +73,12 @@ const filterAfter = 19999
 
 // skip iterating resources > 20001
 func filterResource(resource *things_test_io_v1.Paint) bool {
-	i, _ := strconv.Atoi(strings.Split(resource.GetName(), "-")[1])
-	return i > filterAfter
+	// i, _ := strconv.Atoi(strings.Split(resource.GetName(), "-")[1])
+	// return i > filterAfter
+	if ezkube.GetClusterName(resource) == "cluster-1" {
+		return false
+	}
+	return true
 }
 
 // SortByCreationTime accepts a slice of client.Object instances and sorts it by creation timestamp in ascending order.

contrib/pkg/sets/sets_internal.go

@@ -134,17 +134,13 @@ func (r Resources) Map() map[string]ezkube.ResourceId {
 // The set is sorted based on the sortFunc. If sortFunc is nil, the set will be unsorted.
 func (r *Resources) Insert(resources ...ezkube.ResourceId) {
 	for _, resource := range resources {
-		insertIndex := sort.Search(r.Length(), func(i int) bool { return r.sortFunc(resource, r.set[i]) })
+		insertIndex := sort.Search(r.Length(), func(i int) bool { return r.compareFunc(resource, r.set[i]) < 0 })
 
 		// if the resource is already in the set, replace it
 		if insertIndex < len(r.set) && r.compareFunc(resource, r.set[insertIndex]) == 0 {
 			r.set[insertIndex] = resource
 			return
 		}
-		if r.sortFunc == nil {
-			r.set = append(r.set, resource)
-			return
-		}
 
 		// insert the resource at the determined index
 		r.set = slices.Insert(r.set, insertIndex, resource)
@@ -263,7 +259,7 @@ func (r1 Resources) Intersection(r2 Resources) Resources {
 // Has returns true if and only if item is contained in the set.
 func (r *Resources) Has(item ezkube.ResourceId) bool {
 	i := sort.Search(r.Length(), func(i int) bool {
-		return ezkube.CompareResourceIds(r.set[i], item) >= 0
+		return r.compareFunc(r.set[i], item) >= 0
 	})
 	return i < r.Length() && r.compareFunc(r.set[i], item) == 0
 }

contrib/pkg/sets/v2/sets.go

@@ -16,17 +16,18 @@ import (
 type ResourceSet[T client.Object] interface {
 	// Get the set stored keys
 	Keys() sets.Set[string]
-	// List of resources stored in the set. Pass an optional filter function to filter on the list.
+	// List returns an iterator for the set.
+	// Pass an optional filter function to skip iteration on specific entries; Note: index will still progress.
 	List(filterResource ...func(T) bool) iter.Seq2[int, T]
 	// Return the Set as a map of key to resource.
 	Map() map[string]T
 	// Insert a resource into the set.
 	Insert(resource ...T)
 	// Compare the equality of the keys in two sets (not the resources themselves)
 	Equal(set ResourceSet[T]) bool
-	// Check if the set contains a key matching the resource (not the resource itself)
+	// Check if the set contains the resource. Uses the compare func to determine equality.
 	Has(resource T) bool
-	// Delete the key matching the resource
+	// Delete the matching resource. Uses the compare func to determine equality.
 	Delete(resource T)
 	// Return the union with the provided set
 	Union(set ResourceSet[T]) ResourceSet[T]
@@ -35,15 +36,17 @@ type ResourceSet[T client.Object] interface {
 	// Return the intersection with the provided set
 	Intersection(set ResourceSet[T]) ResourceSet[T]
 	// Find the resource with the given ID
-	Find(id T) (T, error)
+	Find(resource ezkube.ResourceId) (T, error)
 	// Get the length of the set
-	Length() int
+	Len() int
 	// returns the generic implementation of the set
 	Generic() sk_sets.ResourceSet
 	// returns the delta between this and and another ResourceSet[T]
 	Delta(newSet ResourceSet[T]) sk_sets.ResourceDelta
 	// Clone returns a deep copy of the set
 	Clone() ResourceSet[T]
+	// Get the compare function used by the set
+	GetCompareFunc() func(a, b client.Object) int
 }
 
 // ResourceDelta represents the set of changes between two ResourceSets.
@@ -64,18 +67,15 @@ func (r *ResourceDelta[T]) DeltaV1() sk_sets.ResourceDelta {
 type resourceSet[T client.Object] struct {
 	lock        sync.RWMutex
 	set         []T
-	sortFunc    func(toInsert, existing client.Object) bool
 	compareFunc func(a, b client.Object) int
 }
 
 func NewResourceSet[T client.Object](
-	sortFunc func(toInsert, existing client.Object) bool,
 	compareFunc func(a, b client.Object) int,
 	resources ...T,
 ) ResourceSet[T] {
 	rs := &resourceSet[T]{
 		set:         []T{},
-		sortFunc:    sortFunc,
 		compareFunc: compareFunc,
 	}
 	rs.Insert(resources...)
@@ -122,22 +122,18 @@ func (s *resourceSet[T]) Map() map[string]T {
 
 // Insert adds items to the set.
 // If an item is already in the set, it is overwritten.
-// The set is sorted based on the sortFunc. If sortFunc is nil, the set will be unsorted.
+// The set is sorted based on the compare func.
 func (s *resourceSet[T]) Insert(resources ...T) {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 	for _, resource := range resources {
-		insertIndex := sort.Search(len(s.set), func(i int) bool { return s.sortFunc(resource, s.set[i]) })
+		insertIndex := sort.Search(len(s.set), func(i int) bool { return s.compareFunc(resource, s.set[i]) < 0 })
 
 		// if the resource is already in the set, replace it
 		if insertIndex < len(s.set) && s.compareFunc(resource, s.set[insertIndex]) == 0 {
 			s.set[insertIndex] = resource
 			return
 		}
-		if s.sortFunc == nil {
-			s.set = append(s.set, resource)
-			return
-		}
 
 		// insert the resource at the determined index
 		s.set = slices.Insert(s.set, insertIndex, resource)
@@ -148,7 +144,7 @@ func (s *resourceSet[T]) Has(resource T) bool {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 	i := sort.Search(len(s.set), func(i int) bool {
-		return ezkube.CompareResourceIds(s.set[i], resource) >= 0
+		return s.compareFunc(s.set[i], resource) >= 0
 	})
 	return i < len(s.set) && s.compareFunc(s.set[i], resource) == 0
 }
@@ -167,11 +163,9 @@ func (s *resourceSet[T]) Delete(resource T) {
 	i := sort.Search(len(s.set), func(i int) bool {
 		return s.compareFunc(s.set[i], resource) >= 0
 	})
-	if found := i < len(s.set) && s.compareFunc(s.set[i], resource) == 0; !found {
-		return
+	if i != len(s.set) && s.compareFunc(s.set[i], resource) == 0 {
+		s.set = slices.Delete(s.set, i, i+1)
 	}
-
-	s.set = slices.Delete(s.set, i, i+1)
 }
 
 func (s *resourceSet[T]) Union(set ResourceSet[T]) ResourceSet[T] {
@@ -180,7 +174,6 @@ func (s *resourceSet[T]) Union(set ResourceSet[T]) ResourceSet[T] {
 		list = append(list, resource.(T))
 	}
 	return NewResourceSet[T](
-		s.sortFunc,
 		s.compareFunc,
 		list...,
 	)
@@ -189,7 +182,7 @@ func (s *resourceSet[T]) Union(set ResourceSet[T]) ResourceSet[T] {
 func (s *resourceSet[T]) Difference(set ResourceSet[T]) ResourceSet[T] {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
-	result := NewResourceSet[T](s.sortFunc, s.compareFunc)
+	result := NewResourceSet[T](s.compareFunc)
 	for _, resource := range s.set {
 		if !set.Has(resource) {
 			result.Insert(resource)
@@ -202,13 +195,13 @@ func (s *resourceSet[T]) Intersection(set ResourceSet[T]) ResourceSet[T] {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 	var walk, other ResourceSet[T]
-	result := NewResourceSet[T](s.sortFunc, s.compareFunc)
-	if len(s.set) < set.Length() {
-		walk = NewResourceSet(s.sortFunc, s.compareFunc, s.set...)
+	result := NewResourceSet[T](s.compareFunc)
+	if len(s.set) < set.Len() {
+		walk = NewResourceSet(s.compareFunc, s.set...)
 		other = set
 	} else {
 		walk = set
-		other = NewResourceSet(s.sortFunc, s.compareFunc, s.set...)
+		other = NewResourceSet(s.compareFunc, s.set...)
 	}
 	for _, key := range walk.List() {
 		if other.Has(key) {
@@ -218,33 +211,31 @@ func (s *resourceSet[T]) Intersection(set ResourceSet[T]) ResourceSet[T] {
 	return result
 }
 
-func (s *resourceSet[T]) Find(id T) (T, error) {
+// this is only possible when the compare func is ezkube.ResourceIdsCompare
+// otherwise the set won't be sorted to allow for binary search
+func (s *resourceSet[T]) Find(resource ezkube.ResourceId) (T, error) {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
-	key := sk_sets.Key(id)
+	desired_key := sk_sets.Key(resource)
 	i := sort.Search(len(s.set), func(i int) bool {
-		return key <= sk_sets.Key(s.set[i])
+		return sk_sets.Key(s.set[i]) >= desired_key
 	})
-	var resource T
-	if i < len(s.set) {
-		resource = s.set[i]
-	}
-	if i != len(s.set) && sk_sets.Key(resource) == key {
-		return resource, nil
+	var found T
+	if i < len(s.set) && sk_sets.Key(s.set[i]) == desired_key {
+		return s.set[i], nil
 	}
-
-	return resource, sk_sets.NotFoundErr(resource, id)
+	return found, sk_sets.NotFoundErr(found, resource)
 }
 
-func (s *resourceSet[T]) Length() int {
+func (s *resourceSet[T]) Len() int {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 	return len(s.set)
 }
 
 // note that this function will currently panic if called for a ResourceSet[T] containing non-runtime.Objects
 func (oldSet *resourceSet[T]) Delta(newSet ResourceSet[T]) sk_sets.ResourceDelta {
-	updated, removed := NewResourceSet[T](oldSet.sortFunc, oldSet.compareFunc), NewResourceSet[T](oldSet.sortFunc, oldSet.compareFunc)
+	updated, removed := NewResourceSet[T](oldSet.compareFunc), NewResourceSet[T](oldSet.compareFunc)
 
 	// find objects updated or removed
 	for _, resource := range oldSet.set {
@@ -279,25 +270,26 @@ func (oldSet *resourceSet[T]) Delta(newSet ResourceSet[T]) sk_sets.ResourceDelta
 // Create a clone of the current set
 // note that this function will currently panic if called for a ResourceSet[T] containing non-runtime.Objects
 func (oldSet *resourceSet[T]) Clone() ResourceSet[T] {
-	new := NewResourceSet[T](oldSet.sortFunc, oldSet.compareFunc)
-	oldSet.List(func(oldObj T) bool {
+	new := NewResourceSet[T](oldSet.compareFunc)
+
+	for _, oldObj := range oldSet.List() {
 		copy := oldObj.DeepCopyObject().(T)
 		new.Insert(copy)
-		return true
-	})
+	}
 	return new
 }
 
 func (s *resourceSet[T]) Generic() sk_sets.ResourceSet {
-	genericSortFunc := func(toInsert, existing interface{}) bool {
-		return s.sortFunc(toInsert.(T), existing.(T))
-	}
 	genericCompareFunc := func(a, b interface{}) int {
 		return s.compareFunc(a.(T), b.(T))
 	}
-	set := sk_sets.NewResourceSet(genericSortFunc, genericCompareFunc)
+	set := sk_sets.NewResourceSet(nil, genericCompareFunc)
 	for _, v := range s.List() {
 		set.Insert(v)
 	}
 	return set
 }
+
+func (s *resourceSet[T]) GetCompareFunc() func(a, b client.Object) int {
+	return s.compareFunc
+}