refact: use Set structs instead of map[]struct{}

Author: vflaux

controller/metrics.go

@@ -18,6 +18,7 @@ package controller
 
 import (
 	"github.com/prometheus/client_golang/prometheus"
+	"k8s.io/apimachinery/pkg/util/sets"
 
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/pkg/metrics"
@@ -151,14 +152,14 @@ type dnsKey struct {
 func countMatchingAddressRecords(endpoints []*endpoint.Endpoint, registryRecords []*endpoint.Endpoint, metric metrics.GaugeVecMetric) {
 	metric.Gauge.Reset()
 
-	registry := make(map[dnsKey]struct{}, len(registryRecords))
+	registry := make(sets.Set[dnsKey], len(registryRecords))
 	for _, r := range registryRecords {
-		registry[dnsKey{r.DNSName, r.RecordType}] = struct{}{}
+		registry.Insert(dnsKey{r.DNSName, r.RecordType})
 	}
 
 	counts := make(map[string]float64)
 	for _, ep := range endpoints {
-		if _, found := registry[dnsKey{ep.DNSName, ep.RecordType}]; found {
+		if registry.Has(dnsKey{ep.DNSName, ep.RecordType}) {
 			counts[ep.RecordType]++
 		}
 	}

endpoint/endpoint.go

@@ -27,6 +27,7 @@ import (
 
 	"github.com/miekg/dns"
 	log "github.com/sirupsen/logrus"
+	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/utils/set"
 
 	"sigs.k8s.io/external-dns/pkg/events"
@@ -508,15 +509,15 @@ func FilterEndpointsByOwnerID(ownerID string, eps []*Endpoint) []*Endpoint {
 // This function doesn't contemplate the Targets of an Endpoint
 // as part of the primary Key
 func RemoveDuplicates(endpoints []*Endpoint) []*Endpoint {
-	visited := make(map[EndpointKey]struct{})
+	visited := make(sets.Set[EndpointKey], len(endpoints))
 	result := []*Endpoint{}
 
 	for _, ep := range endpoints {
 		key := ep.Key()
 
-		if _, found := visited[key]; !found {
+		if !visited.Has(key) {
 			result = append(result, ep)
-			visited[key] = struct{}{}
+			visited.Insert(key)
 		} else {
 			log.Debugf(`Skipping duplicated endpoint: %v`, ep)
 		}

provider/awssd/aws_sd.go

@@ -28,13 +28,13 @@ import (
 	sd "github.com/aws/aws-sdk-go-v2/service/servicediscovery"
 	sdtypes "github.com/aws/aws-sdk-go-v2/service/servicediscovery/types"
 	log "github.com/sirupsen/logrus"
-
-	"sigs.k8s.io/external-dns/pkg/apis/externaldns"
-	extdnsaws "sigs.k8s.io/external-dns/provider/aws"
+	"k8s.io/apimachinery/pkg/util/sets"
 
 	"sigs.k8s.io/external-dns/endpoint"
+	"sigs.k8s.io/external-dns/pkg/apis/externaldns"
 	"sigs.k8s.io/external-dns/plan"
 	"sigs.k8s.io/external-dns/provider"
+	extdnsaws "sigs.k8s.io/external-dns/provider/aws"
 )
 
 const (
@@ -276,15 +276,12 @@ func (p *AWSSDProvider) updatesToCreates(changes *plan.Changes) ([]*endpoint.End
 		current := updateNewMap[old.DNSName]
 
 		if !old.Targets.Same(current.Targets) {
-			currentTargetsMap := make(map[string]struct{}, len(current.Targets))
-			for _, newTarget := range current.Targets {
-				currentTargetsMap[newTarget] = struct{}{}
-			}
+			currentTargetsSet := sets.New(current.Targets...)
 
 			// If targets changed, only deregister removed targets (i.e. in `UpdateOld` but not in `UpdateNew`)
 			targetsToRemove := make(endpoint.Targets, 0)
 			for _, oldTarget := range old.Targets {
-				if _, found := currentTargetsMap[oldTarget]; !found {
+				if !currentTargetsSet.Has(oldTarget) {
 					targetsToRemove = append(targetsToRemove, oldTarget)
 				}
 			}

provider/provider.go

@@ -23,6 +23,8 @@ import (
 	"net"
 	"strings"
 
+	"k8s.io/apimachinery/pkg/util/sets"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 )
@@ -95,18 +97,14 @@ func EnsureTrailingDot(hostname string) string {
 // added, removed, or left untouched for "current" to be transformed to "desired"
 func Difference(current, desired []string) ([]string, []string, []string) {
 	add, remove, leave := []string{}, []string{}, []string{}
-	index := make(map[string]struct{}, len(current))
-	for _, x := range current {
-		index[x] = struct{}{}
-	}
+	index := sets.New(current...)
 	for _, x := range desired {
-		if _, found := index[x]; found {
+		if index.Has(x) {
 			leave = append(leave, x)
-			delete(index, x)
 		} else {
 			add = append(add, x)
-			delete(index, x)
 		}
+		index.Delete(x)
 	}
 	for x := range index {
 		remove = append(remove, x)

registry/txt/registry.go

@@ -18,23 +18,21 @@ package txt
 
 import (
 	"context"
+	b64 "encoding/base64"
 	"errors"
 	"maps"
-
 	"strings"
 	"time"
 
-	b64 "encoding/base64"
-
 	log "github.com/sirupsen/logrus"
-
-	"sigs.k8s.io/external-dns/pkg/apis/externaldns"
-	"sigs.k8s.io/external-dns/registry"
-	"sigs.k8s.io/external-dns/registry/mapper"
+	"k8s.io/apimachinery/pkg/util/sets"
 
 	"sigs.k8s.io/external-dns/endpoint"
+	"sigs.k8s.io/external-dns/pkg/apis/externaldns"
 	"sigs.k8s.io/external-dns/plan"
 	"sigs.k8s.io/external-dns/provider"
+	"sigs.k8s.io/external-dns/registry"
+	"sigs.k8s.io/external-dns/registry/mapper"
 )
 
 const (
@@ -76,7 +74,7 @@ type TXTRegistry struct {
 // It relies on the fact that Records() is always called **before** ApplyChanges()
 // within a single reconciliation cycle.
 type existingTXTs struct {
-	entries map[recordKey]struct{}
+	entries sets.Set[recordKey]
 }
 
 type recordKey struct {
@@ -86,7 +84,7 @@ type recordKey struct {
 
 func newExistingTXTs() *existingTXTs {
 	return &existingTXTs{
-		entries: make(map[recordKey]struct{}),
+		entries: make(sets.Set[recordKey]),
 	}
 }
 
@@ -95,7 +93,7 @@ func (im *existingTXTs) add(r *endpoint.Endpoint) {
 		dnsName:       r.DNSName,
 		setIdentifier: r.SetIdentifier,
 	}
-	im.entries[key] = struct{}{}
+	im.entries.Insert(key)
 }
 
 // isAbsent returns true when there is no entry for the given name in the store.
@@ -105,14 +103,13 @@ func (im *existingTXTs) isAbsent(ep *endpoint.Endpoint) bool {
 		dnsName:       ep.DNSName,
 		setIdentifier: ep.SetIdentifier,
 	}
-	_, ok := im.entries[key]
-	return !ok
+	return !im.entries.Has(key)
 }
 
 func (im *existingTXTs) reset() {
 	// Reset the existing TXT records for the next reconciliation loop.
 	// This is necessary because the existing TXT records are only relevant for the current reconciliation cycle.
-	im.entries = make(map[recordKey]struct{})
+	im.entries = make(sets.Set[recordKey])
 }
 
 // New creates a TXTRegistry from the given configuration.
@@ -203,7 +200,7 @@ func (im *TXTRegistry) Records(ctx context.Context) ([]*endpoint.Endpoint, error
 	endpoints := []*endpoint.Endpoint{}
 
 	labelMap := map[endpoint.EndpointKey]endpoint.Labels{}
-	txtRecordsMap := map[string]struct{}{}
+	txtRecordsSet := make(sets.Set[string], len(records))
 
 	for _, record := range records {
 		if record.RecordType != endpoint.RecordTypeTXT {
@@ -232,7 +229,7 @@ func (im *TXTRegistry) Records(ctx context.Context) ([]*endpoint.Endpoint, error
 			SetIdentifier: record.SetIdentifier,
 		}
 		labelMap[key] = labels
-		txtRecordsMap[record.DNSName] = struct{}{}
+		txtRecordsSet.Insert(record.DNSName)
 		im.existingTXTs.add(record)
 	}
 
@@ -274,12 +271,12 @@ func (im *TXTRegistry) Records(ctx context.Context) ([]*endpoint.Endpoint, error
 		// TODO: remove this migration logic in some future release
 		// Handle the migration of TXT records created before the new format (introduced in v0.12.0).
 		// The migration is done for the TXT records owned by this instance only.
-		if len(txtRecordsMap) > 0 && ep.Labels[endpoint.OwnerLabelKey] == im.ownerID {
+		if len(txtRecordsSet) > 0 && ep.Labels[endpoint.OwnerLabelKey] == im.ownerID {
 			if plan.IsManagedRecord(ep.RecordType, im.managedRecordTypes, im.excludeRecordTypes) {
 				// Get desired TXT records and detect the missing ones
 				desiredTXTs := im.generateTXTRecord(ep)
 				for _, desiredTXT := range desiredTXTs {
-					if _, exists := txtRecordsMap[desiredTXT.DNSName]; !exists {
+					if !txtRecordsSet.Has(desiredTXT.DNSName) {
 						ep.WithProviderSpecific(providerSpecificForceUpdate, "true")
 					}
 				}

source/service.go

@@ -29,6 +29,7 @@ import (
 	v1 "k8s.io/api/core/v1"
 	discoveryv1 "k8s.io/api/discovery/v1"
 	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/sets"
 	kubeinformers "k8s.io/client-go/informers"
 	coreinformers "k8s.io/client-go/informers/core/v1"
 	discoveryinformers "k8s.io/client-go/informers/discovery/v1"
@@ -455,13 +456,13 @@ func buildHeadlessEndpoints(svc *v1.Service, targetsByHeadlessDomainAndType map[
 	for _, headlessKey := range headlessKeys {
 		allTargets := targetsByHeadlessDomainAndType[headlessKey]
 		targets := []string{}
-		deduppedTargets := map[string]struct{}{}
+		deduppedTargets := make(sets.Set[string], len(allTargets))
 		for _, target := range allTargets {
-			if _, ok := deduppedTargets[target]; ok {
+			if deduppedTargets.Has(target) {
 				log.Debugf("Removing duplicate target %s", target)
 				continue
 			}
-			deduppedTargets[target] = struct{}{}
+			deduppedTargets.Insert(target)
 			targets = append(targets, target)
 		}
 		var ep *endpoint.Endpoint

source/template/engine.go

@@ -19,16 +19,15 @@ package template
 import (
 	"bytes"
 	"fmt"
-	"maps"
 	"reflect"
-	"slices"
 	"strings"
 	"text/template"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/utils/set"
 
 	"sigs.k8s.io/external-dns/endpoint"
 )
@@ -175,13 +174,13 @@ func execTemplate(tmpl *template.Template, obj kubeObject) ([]string, error) {
 		return nil, fmt.Errorf("failed to apply template on %s %s/%s: %w", kind, obj.GetNamespace(), obj.GetName(), err)
 	}
 	hosts := strings.Split(buf.String(), ",")
-	hostnames := make(map[string]struct{}, len(hosts))
+	hostnames := make(set.Set[string], len(hosts))
 	for _, name := range hosts {
 		name = strings.TrimSpace(name)
 		name = strings.TrimSuffix(name, ".")
 		if name != "" {
-			hostnames[name] = struct{}{}
+			hostnames.Insert(name)
 		}
 	}
-	return slices.Sorted(maps.Keys(hostnames)), nil
+	return hostnames.SortedList(), nil
 }

source/template/engine_test.go

@@ -315,7 +315,7 @@ func TestExecFQDN(t *testing.T) {
 					Name: "test",
 				},
 			},
-			want: nil,
+			want: []string{},
 		},
 		{
 			name: "ignore trailing comma output",

source/unstructured.go

@@ -34,6 +34,7 @@ import (
 	"k8s.io/client-go/dynamic/dynamicinformer"
 	kubeinformers "k8s.io/client-go/informers"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/utils/set"
 
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/pkg/events"
@@ -353,20 +354,17 @@ func EndpointsForHostsAndTargets(hostnames, targets []string) []*endpoint.Endpoi
 	}
 
 	// Deduplicate hostnames
-	hostSet := make(map[string]struct{}, len(hostnames))
-	for _, h := range hostnames {
-		hostSet[h] = struct{}{}
-	}
-	sortedHosts := slices.Sorted(maps.Keys(hostSet))
+	sortedHosts := set.New(hostnames...).SortedList()
 
 	// Group and deduplicate targets by record type
-	targetsByType := make(map[string]map[string]struct{})
+	targetsByType := make(map[string]set.Set[string])
 	for _, target := range targets {
 		recordType := endpoint.SuitableType(target)
 		if targetsByType[recordType] == nil {
-			targetsByType[recordType] = make(map[string]struct{})
+			targetsByType[recordType] = set.New(target)
+		} else {
+			targetsByType[recordType].Insert(target)
 		}
-		targetsByType[recordType][target] = struct{}{}
 	}
 
 	// Resolve to sorted slices once

source/wrappers/dedupsource.go

@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	log "github.com/sirupsen/logrus"
+	"k8s.io/apimachinery/pkg/util/sets"
 
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/source"
@@ -40,14 +41,15 @@ func NewDedupSource(source source.Source) source.Source {
 func (ms *dedupSource) Endpoints(ctx context.Context) ([]*endpoint.Endpoint, error) {
 	log.Debug("dedupSource: collecting endpoints and removing duplicates")
 	resetMetrics()
-	result := make([]*endpoint.Endpoint, 0)
-	collected := make(map[string]struct{})
 
 	endpoints, err := ms.source.Endpoints(ctx)
 	if err != nil {
 		return nil, err
 	}
 
+	result := make([]*endpoint.Endpoint, 0, len(endpoints))
+	collected := make(sets.Set[string], len(endpoints))
+
 	for _, ep := range endpoints {
 		if ep == nil {
 			continue
@@ -66,13 +68,13 @@ func (ms *dedupSource) Endpoints(ctx context.Context) ([]*endpoint.Endpoint, err
 
 		identifier := strings.Join([]string{ep.RecordType, ep.DNSName, ep.SetIdentifier, ep.Targets.String()}, "/")
 
-		if _, ok := collected[identifier]; ok {
+		if collected.Has(identifier) {
 			log.Debugf("Removing duplicate endpoint %s", ep)
 			deduplicatedEndpoints.AddWithLabels(1, ep.RecordType, endpointSource(ep))
 			continue
 		}
 
-		collected[identifier] = struct{}{}
+		collected.Insert(identifier)
 		result = append(result, ep)
 	}