chore(domainfilter): use pointer receivers for DomainFilter (kubernetes-sigs#5546)

* refactor(domainfilter): use pointer receivers for DomainFilter

* refactor(domainfilter): complete pointer type consistency across providers

Author: u-kai

controller/controller_test.go

@@ -45,7 +45,7 @@ type mockProvider struct {
 
 type filteredMockProvider struct {
 	provider.BaseProvider
-	domainFilter      endpoint.DomainFilter
+	domainFilter      *endpoint.DomainFilter
 	RecordsStore      []*endpoint.Endpoint
 	RecordsCallCount  int
 	ApplyChangesCalls []*plan.Changes
@@ -328,7 +328,7 @@ func TestShouldRunOnce(t *testing.T) {
 	assert.True(t, ctrl.ShouldRunOnce(now))
 }
 
-func testControllerFiltersDomains(t *testing.T, configuredEndpoints []*endpoint.Endpoint, domainFilter endpoint.DomainFilter, providerEndpoints []*endpoint.Endpoint, expectedChanges []*plan.Changes) {
+func testControllerFiltersDomains(t *testing.T, configuredEndpoints []*endpoint.Endpoint, domainFilter *endpoint.DomainFilter, providerEndpoints []*endpoint.Endpoint, expectedChanges []*plan.Changes) {
 	t.Helper()
 	cfg := externaldns.NewConfig()
 	cfg.ManagedDNSRecordTypes = []string{endpoint.RecordTypeA, endpoint.RecordTypeAAAA, endpoint.RecordTypeCNAME}
@@ -402,7 +402,7 @@ func TestWhenNoFilterControllerConsidersAllComain(t *testing.T) {
 				Targets:    endpoint.Targets{"8.8.8.8"},
 			},
 		},
-		endpoint.DomainFilter{},
+		&endpoint.DomainFilter{},
 		[]*endpoint.Endpoint{
 			{
 				DNSName:    "some-record.used.tld",

controller/execute.go

@@ -145,7 +145,7 @@ func Execute() {
 func buildProvider(
 	ctx context.Context,
 	cfg *externaldns.Config,
-	domainFilter endpoint.DomainFilter,
+	domainFilter *endpoint.DomainFilter,
 ) (provider.Provider, error) {
 	var p provider.Provider
 	var err error
@@ -339,7 +339,7 @@ func buildProvider(
 	return p, err
 }
 
-func buildController(cfg *externaldns.Config, src source.Source, p provider.Provider, filter endpoint.DomainFilter) (*Controller, error) {
+func buildController(cfg *externaldns.Config, src source.Source, p provider.Provider, filter *endpoint.DomainFilter) (*Controller, error) {
 	policy, ok := plan.Policies[cfg.Policy]
 	if !ok {
 		return nil, fmt.Errorf("unknown policy: %s", cfg.Policy)
@@ -429,7 +429,7 @@ func buildSource(ctx context.Context, cfg *externaldns.Config) (source.Source, e
 }
 
 // RegexDomainFilter overrides DomainFilter
-func createDomainFilter(cfg *externaldns.Config) endpoint.DomainFilter {
+func createDomainFilter(cfg *externaldns.Config) *endpoint.DomainFilter {
 	if cfg.RegexDomainFilter != nil && cfg.RegexDomainFilter.String() != "" {
 		return endpoint.NewRegexDomainFilter(cfg.RegexDomainFilter, cfg.RegexDomainExclusion)
 	} else {

controller/execute_test.go

@@ -134,7 +134,7 @@ func TestCreateDomainFilter(t *testing.T) {
 	tests := []struct {
 		name                 string
 		cfg                  *externaldns.Config
-		expectedDomainFilter endpoint.DomainFilter
+		expectedDomainFilter *endpoint.DomainFilter
 		isConfigured         bool
 	}{
 		{

endpoint/domain_filter.go

@@ -80,23 +80,26 @@ func prepareFilters(filters []string) []string {
 }
 
 // NewDomainFilterWithExclusions returns a new DomainFilter, given a list of matches and exclusions
-func NewDomainFilterWithExclusions(domainFilters []string, excludeDomains []string) DomainFilter {
-	return DomainFilter{Filters: prepareFilters(domainFilters), exclude: prepareFilters(excludeDomains)}
+func NewDomainFilterWithExclusions(domainFilters []string, excludeDomains []string) *DomainFilter {
+	return &DomainFilter{Filters: prepareFilters(domainFilters), exclude: prepareFilters(excludeDomains)}
 }
 
 // NewDomainFilter returns a new DomainFilter given a comma separated list of domains
-func NewDomainFilter(domainFilters []string) DomainFilter {
-	return DomainFilter{Filters: prepareFilters(domainFilters)}
+func NewDomainFilter(domainFilters []string) *DomainFilter {
+	return &DomainFilter{Filters: prepareFilters(domainFilters)}
 }
 
 // NewRegexDomainFilter returns a new DomainFilter given a regular expression
-func NewRegexDomainFilter(regexDomainFilter *regexp.Regexp, regexDomainExclusion *regexp.Regexp) DomainFilter {
-	return DomainFilter{regex: regexDomainFilter, regexExclusion: regexDomainExclusion}
+func NewRegexDomainFilter(regexDomainFilter *regexp.Regexp, regexDomainExclusion *regexp.Regexp) *DomainFilter {
+	return &DomainFilter{regex: regexDomainFilter, regexExclusion: regexDomainExclusion}
 }
 
 // Match checks whether a domain can be found in the DomainFilter.
 // RegexFilter takes precedence over Filters
-func (df DomainFilter) Match(domain string) bool {
+func (df *DomainFilter) Match(domain string) bool {
+	if df == nil {
+		return true // nil filter matches everything
+	}
 	if df.regex != nil && df.regex.String() != "" || df.regexExclusion != nil && df.regexExclusion.String() != "" {
 		return matchRegex(df.regex, df.regexExclusion, domain)
 	}
@@ -145,7 +148,10 @@ func matchRegex(regex *regexp.Regexp, negativeRegex *regexp.Regexp, domain strin
 }
 
 // IsConfigured returns true if any inclusion or exclusion rules have been specified.
-func (df DomainFilter) IsConfigured() bool {
+func (df *DomainFilter) IsConfigured() bool {
+	if df == nil {
+		return false // nil filter is not configured
+	}
 	if df.regex != nil && df.regex.String() != "" {
 		return true
 	} else if df.regexExclusion != nil && df.regexExclusion.String() != "" {
@@ -154,7 +160,14 @@ func (df DomainFilter) IsConfigured() bool {
 	return len(df.Filters) > 0 || len(df.exclude) > 0
 }
 
-func (df DomainFilter) MarshalJSON() ([]byte, error) {
+func (df *DomainFilter) MarshalJSON() ([]byte, error) {
+	if df == nil {
+		// compatibility with nil DomainFilter
+		return json.Marshal(domainFilterSerde{
+			Include: nil,
+			Exclude: nil,
+		})
+	}
 	if df.regex != nil || df.regexExclusion != nil {
 		var include, exclude string
 		if df.regex != nil {
@@ -184,7 +197,7 @@ func (df *DomainFilter) UnmarshalJSON(b []byte) error {
 	}
 
 	if deserialized.RegexInclude == "" && deserialized.RegexExclude == "" {
-		*df = NewDomainFilterWithExclusions(deserialized.Include, deserialized.Exclude)
+		*df = *NewDomainFilterWithExclusions(deserialized.Include, deserialized.Exclude)
 		return nil
 	}
 
@@ -205,11 +218,14 @@ func (df *DomainFilter) UnmarshalJSON(b []byte) error {
 			return fmt.Errorf("invalid regexExclude: %w", err)
 		}
 	}
-	*df = NewRegexDomainFilter(include, exclude)
+	*df = *NewRegexDomainFilter(include, exclude)
 	return nil
 }
 
-func (df DomainFilter) MatchParent(domain string) bool {
+func (df *DomainFilter) MatchParent(domain string) bool {
+	if df == nil {
+		return true // nil filter matches everything
+	}
 	if matchFilter(df.exclude, domain, false) {
 		return false
 	}

endpoint/domain_filter_test.go

@@ -701,22 +701,22 @@ func TestDomainFilterDeserializeError(t *testing.T) {
 	}
 }
 
-func assertSerializes[T any](t *testing.T, domainFilter DomainFilter, expectedSerialization map[string]T) {
+func assertSerializes[T any](t *testing.T, domainFilter *DomainFilter, expectedSerialization map[string]T) {
 	serialized, err := json.Marshal(domainFilter)
 	assert.NoError(t, err, "serializing")
 	expected, err := json.Marshal(expectedSerialization)
 	require.NoError(t, err)
 	assert.JSONEq(t, string(expected), string(serialized), "json serialization")
 }
 
-func deserialize[T any](t *testing.T, serialized map[string]T) DomainFilter {
+func deserialize[T any](t *testing.T, serialized map[string]T) *DomainFilter {
 	inJson, err := json.Marshal(serialized)
 	require.NoError(t, err)
 	var deserialized DomainFilter
 	err = json.Unmarshal(inJson, &deserialized)
 	assert.NoError(t, err, "deserializing")
 
-	return deserialized
+	return &deserialized
 }
 
 func TestDomainFilterMatchParent(t *testing.T) {

plan/plan_test.go

@@ -902,7 +902,7 @@ func (suite *PlanTestSuite) TestDomainFiltersInitial() {
 		Policies:       []Policy{&SyncPolicy{}},
 		Current:        current,
 		Desired:        desired,
-		DomainFilter:   endpoint.MatchAllDomainFilters{&domainFilter},
+		DomainFilter:   endpoint.MatchAllDomainFilters{domainFilter},
 		ManagedRecords: []string{endpoint.RecordTypeA, endpoint.RecordTypeCNAME},
 	}
 
@@ -926,7 +926,7 @@ func (suite *PlanTestSuite) TestDomainFiltersUpdate() {
 		Policies:       []Policy{&SyncPolicy{}},
 		Current:        current,
 		Desired:        desired,
-		DomainFilter:   endpoint.MatchAllDomainFilters{&domainFilter},
+		DomainFilter:   endpoint.MatchAllDomainFilters{domainFilter},
 		ManagedRecords: []string{endpoint.RecordTypeA, endpoint.RecordTypeCNAME},
 	}
 

provider/akamai/akamai.go

@@ -51,7 +51,7 @@ type AkamaiDNSService interface {
 }
 
 type AkamaiConfig struct {
-	DomainFilter          endpoint.DomainFilter
+	DomainFilter          *endpoint.DomainFilter
 	ZoneIDFilter          provider.ZoneIDFilter
 	ServiceConsumerDomain string
 	ClientToken           string
@@ -68,7 +68,7 @@ type AkamaiConfig struct {
 type AkamaiProvider struct {
 	provider.BaseProvider
 	// Edgedns zones to filter on
-	domainFilter endpoint.DomainFilter
+	domainFilter *endpoint.DomainFilter
 	// Contract Ids to filter on
 	zoneIDFilter provider.ZoneIDFilter
 	// Edgegrid library configuration

provider/akamai/akamai_test.go

@@ -49,7 +49,7 @@ func newStub() *edgednsStub {
 	}
 }
 
-func createAkamaiStubProvider(stub *edgednsStub, domfilter endpoint.DomainFilter, idfilter provider.ZoneIDFilter) (*AkamaiProvider, error) {
+func createAkamaiStubProvider(stub *edgednsStub, domfilter *endpoint.DomainFilter, idfilter provider.ZoneIDFilter) (*AkamaiProvider, error) {
 	akamaiConfig := AkamaiConfig{
 		DomainFilter:          domfilter,
 		ZoneIDFilter:          idfilter,
@@ -153,7 +153,7 @@ func (r *edgednsStub) UpdateRecord(record *dns.RecordBody, zone string, recLock
 // Test FetchZones
 func TestFetchZonesZoneIDFilter(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.NewZoneIDFilter([]string{"Test"})
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	assert.NoError(t, err)
@@ -186,7 +186,7 @@ func TestFetchZonesEmpty(t *testing.T) {
 // TestAkamaiRecords tests record endpoint
 func TestAkamaiRecords(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	require.NoError(t, err)
@@ -221,7 +221,7 @@ func TestAkamaiRecords(t *testing.T) {
 
 func TestAkamaiRecordsEmpty(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.NewZoneIDFilter([]string{"Nonexistent"})
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	require.NoError(t, err)
@@ -265,7 +265,7 @@ func TestAkamaiRecordsFilters(t *testing.T) {
 // (p AkamaiProvider) createRecordsets(zoneNameIDMapper provider.ZoneIDName, endpoints []*endpoint.Endpoint) error
 func TestCreateRecords(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	assert.NoError(t, err)
@@ -281,7 +281,7 @@ func TestCreateRecords(t *testing.T) {
 
 func TestCreateRecordsDomainFilter(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	assert.NoError(t, err)
@@ -299,7 +299,7 @@ func TestCreateRecordsDomainFilter(t *testing.T) {
 // TestDeleteRecords validate delete
 func TestDeleteRecords(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	assert.NoError(t, err)
@@ -333,7 +333,7 @@ func TestDeleteRecordsDomainFilter(t *testing.T) {
 // Test record update func
 func TestUpdateRecords(t *testing.T) {
 	stub := newStub()
-	domfilter := endpoint.DomainFilter{}
+	domfilter := &endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
 	require.NoError(t, err)

provider/alibabacloud/alibaba_cloud.go

@@ -70,7 +70,7 @@ type AlibabaCloudPrivateZoneAPI interface {
 // AlibabaCloudProvider implements the DNS provider for Alibaba Cloud.
 type AlibabaCloudProvider struct {
 	provider.BaseProvider
-	domainFilter         endpoint.DomainFilter
+	domainFilter         *endpoint.DomainFilter
 	zoneIDFilter         provider.ZoneIDFilter // Private Zone only
 	MaxChangeCount       int
 	EvaluateTargetHealth bool
@@ -97,7 +97,7 @@ type alibabaCloudConfig struct {
 // NewAlibabaCloudProvider creates a new Alibaba Cloud provider.
 //
 // Returns the provider or an error if a provider could not be created.
-func NewAlibabaCloudProvider(configFile string, domainFilter endpoint.DomainFilter, zoneIDFileter provider.ZoneIDFilter, zoneType string, dryRun bool) (*AlibabaCloudProvider, error) {
+func NewAlibabaCloudProvider(configFile string, domainFilter *endpoint.DomainFilter, zoneIDFileter provider.ZoneIDFilter, zoneType string, dryRun bool) (*AlibabaCloudProvider, error) {
 	cfg := alibabaCloudConfig{}
 	if configFile != "" {
 		contents, err := os.ReadFile(configFile)

provider/aws/aws.go

@@ -279,7 +279,7 @@ type AWSProvider struct {
 	batchChangeInterval   time.Duration
 	evaluateTargetHealth  bool
 	// only consider hosted zones managing domains ending in this suffix
-	domainFilter endpoint.DomainFilter
+	domainFilter *endpoint.DomainFilter
 	// filter hosted zones by id
 	zoneIDFilter provider.ZoneIDFilter
 	// filter hosted zones by type (e.g. private or public)
@@ -296,7 +296,7 @@ type AWSProvider struct {
 
 // AWSConfig contains configuration to create a new AWS provider.
 type AWSConfig struct {
-	DomainFilter          endpoint.DomainFilter
+	DomainFilter          *endpoint.DomainFilter
 	ZoneIDFilter          provider.ZoneIDFilter
 	ZoneTypeFilter        provider.ZoneTypeFilter
 	ZoneTagFilter         provider.ZoneTagFilter
@@ -624,7 +624,7 @@ func (p *AWSProvider) GetDomainFilter() endpoint.DomainFilterInterface {
 	zones, err := p.Zones(context.Background())
 	if err != nil {
 		log.Errorf("failed to list zones: %v", err)
-		return endpoint.DomainFilter{}
+		return &endpoint.DomainFilter{}
 	}
 	zoneNames := []string(nil)
 	for _, z := range zones {