16996039066

Committed 15 Aug 2025 05:54PM UTC coverage: 81.595% (+0.4%) from 81.213%

Build # 16996039066

Build Type

push

github

Committed by

OliverMKing

Commit Message

bump externaldns to 0.17.0

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

71 existing lines in 8 files now uncovered.

3795 of 4651 relevant lines covered (81.6%)

22.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.17

/pkg/controller/dns/external_dns.go

package dns

import (
        "fmt"
        "time"

        "github.com/Azure/aks-app-routing-operator/pkg/config"
        "github.com/Azure/aks-app-routing-operator/pkg/controller/common"
        "github.com/Azure/aks-app-routing-operator/pkg/controller/controllername"
        "github.com/Azure/aks-app-routing-operator/pkg/manifests"
        "github.com/Azure/aks-app-routing-operator/pkg/util"
        "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
)

const (
        reconcileInterval = time.Minute * 3
)

// addExternalDnsReconciler creates a reconciler that manages external dns resources
func addExternalDnsReconciler(manager ctrl.Manager, resources []client.Object) error {
        return common.NewResourceReconciler(manager, controllername.New("external", "dns", "reconciler"), resources, reconcileInterval)
}

func addExternalDnsCleaner(manager ctrl.Manager, instances []instance) error {
        return nil // disable cleaner until we have better test coverage

        objs := cleanObjs(instances)
        retriever := common.RetrieverEmpty()
        for _, obj := range objs {
                retriever = retriever.Add(common.RetrieverFromObjs(obj.resources, obj.labels)) // clean up entire unused external dns applications
        }
        for _, instance := range instances {
                labels := util.MergeMaps(instance.config.Labels(), manifests.GetTopLevelLabels())
                retriever = retriever.Add(common.RetrieverFromGk(labels, manifests.OldExternalDnsGks...)) // clean up unused types from previous versions of app routing
        }

        retriever = retriever.Remove(common.RetrieverFromGk(
                nil, // our compare strat is ignore labels
                schema.GroupKind{
                        Group: corev1.GroupName,
                        Kind:  "Namespace",
                }),
                common.RemoveOpt{
                        CompareStrat: common.IgnoreLabels, // ignore labels, we never want to clean namespaces
                })

        return common.NewCleaner(manager, controllername.New("external", "dns", "cleaner"), retriever)
}

// NewExternalDns starts all resources required for external dns
func NewExternalDns(manager ctrl.Manager, conf *config.Config) error {
        instances, err := instances(conf)
        if err != nil {
                return fmt.Errorf("failed to create instances: %w", err)
        }

        deployInstances := filterAction(instances, deploy)
        deployRes := getResources(deployInstances)
        if err := addExternalDnsReconciler(manager, deployRes); err != nil {
                return err
        }

        if err := addExternalDnsCleaner(manager, instances); err != nil {
                return err
        }

        return nil
}

func instances(conf *config.Config) ([]instance, error) {
        // public
        publicCfg, err := publicConfigForIngress(conf)
        if err != nil {
                return nil, err
        }

        publicAction := actionFromConfig(publicCfg)
        publicResources := publicCfg.Resources()

        // private
        privateCfg, err := privateConfigForIngress(conf)
        if err != nil {
                return nil, err
        }

        privateAction := actionFromConfig(privateCfg)
        privateResources := privateCfg.Resources()

        return []instance{
                {
                        config:    publicCfg,
                        resources: publicResources,
                        action:    publicAction,
                },
                {
                        config:    privateCfg,
                        resources: privateResources,
                        action:    privateAction,
                },
        }, nil
}

func publicConfigForIngress(conf *config.Config) (*manifests.ExternalDnsConfig, error) {
        publicconfig, err := manifests.NewExternalDNSConfig(
                conf,
                manifests.InputExternalDNSConfig{
                        TenantId:           conf.TenantID,
                        ClientId:           conf.MSIClientID,
                        Namespace:          conf.NS,
                        IdentityType:       manifests.IdentityTypeMSI,
                        ResourceTypes:      map[manifests.ResourceType]struct{}{manifests.ResourceTypeIngress: struct{}{}},
                        DnsZoneresourceIDs: util.Keys(conf.PublicZoneConfig.ZoneIds),
                        Provider:           to.Ptr(manifests.PublicProvider),
                })

        if err != nil {
                return nil, err
        }
        return publicconfig, nil
}

func privateConfigForIngress(conf *config.Config) (*manifests.ExternalDnsConfig, error) {
        privateconfig, err := manifests.NewExternalDNSConfig(
                conf,
                manifests.InputExternalDNSConfig{
                        TenantId:           conf.TenantID,
                        ClientId:           conf.MSIClientID,
                        Namespace:          conf.NS,
                        IdentityType:       manifests.IdentityTypeMSI,
                        ResourceTypes:      map[manifests.ResourceType]struct{}{manifests.ResourceTypeIngress: struct{}{}},
                        DnsZoneresourceIDs: util.Keys(conf.PrivateZoneConfig.ZoneIds),
                        Provider:           to.Ptr(manifests.PrivateProvider),
                },
        )

        if err != nil {
                return nil, err
        }
        return privateconfig, nil
}

func filterAction(instances []instance, action action) []instance {
        var ret []instance
        for _, i := range instances {
                if i.action == action {
                        ret = append(ret, i)
                }
        }

        return ret
}

func getResources(instances []instance) []client.Object {
        var ret []client.Object
        for _, i := range instances {
                ret = append(ret, i.resources...)
        }
        return ret
}

func getLabels(instances ...instance) map[string]string {
        l := map[string]string{}
        for k, v := range manifests.GetTopLevelLabels() {
                l[k] = v
        }

        for _, i := range instances {
                for k, v := range i.config.Labels() {
                        l[k] = v
                }
        }

        return l
}

func cleanObjs(instances []instance) []cleanObj {
        var cleanObjs []cleanObj
        for _, instance := range filterAction(instances, clean) {
                obj := cleanObj{
                        resources: instance.resources,
                        labels:    getLabels(instance),
                }
                cleanObjs = append(cleanObjs, obj)
        }

        return cleanObjs
}

func actionFromConfig(conf *manifests.ExternalDnsConfig) action {
        if len(conf.DnsZoneResourceIds()) == 0 {
                return clean
        }

        return deploy
}

1	package dns
2
3	import (
4	"fmt"
5	"time"
6
7	"github.com/Azure/aks-app-routing-operator/pkg/config"
8	"github.com/Azure/aks-app-routing-operator/pkg/controller/common"
9	"github.com/Azure/aks-app-routing-operator/pkg/controller/controllername"
10	"github.com/Azure/aks-app-routing-operator/pkg/manifests"
11	"github.com/Azure/aks-app-routing-operator/pkg/util"
12	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
13	corev1 "k8s.io/api/core/v1"
14	"k8s.io/apimachinery/pkg/runtime/schema"
15	ctrl "sigs.k8s.io/controller-runtime"
16	"sigs.k8s.io/controller-runtime/pkg/client"
17	)
18
19	const (
20	reconcileInterval = time.Minute * 3
21	)
22
23	// addExternalDnsReconciler creates a reconciler that manages external dns resources
24	func addExternalDnsReconciler(manager ctrl.Manager, resources []client.Object) error {	2✔
25	return common.NewResourceReconciler(manager, controllername.New("external", "dns", "reconciler"), resources, reconcileInterval)	2✔
26	}	2✔
27
28	func addExternalDnsCleaner(manager ctrl.Manager, instances []instance) error {	2✔
29	return nil // disable cleaner until we have better test coverage	2✔
30		2✔
31	objs := cleanObjs(instances)	2✔
32	retriever := common.RetrieverEmpty()	2✔
33	for _, obj := range objs {	2✔
34	retriever = retriever.Add(common.RetrieverFromObjs(obj.resources, obj.labels)) // clean up entire unused external dns applications	×
35	}	×
36	for _, instance := range instances {	×
37	labels := util.MergeMaps(instance.config.Labels(), manifests.GetTopLevelLabels())	×
38	retriever = retriever.Add(common.RetrieverFromGk(labels, manifests.OldExternalDnsGks...)) // clean up unused types from previous versions of app routing	×
39	}	×
40
41	retriever = retriever.Remove(common.RetrieverFromGk(	×
42	nil, // our compare strat is ignore labels	×
43	schema.GroupKind{	×
44	Group: corev1.GroupName,	×
45	Kind: "Namespace",	×
46	}),	×
47	common.RemoveOpt{	×
48	CompareStrat: common.IgnoreLabels, // ignore labels, we never want to clean namespaces	×
49	})	×
50		×
51	return common.NewCleaner(manager, controllername.New("external", "dns", "cleaner"), retriever)	×
52	}
53
54	// NewExternalDns starts all resources required for external dns
55	func NewExternalDns(manager ctrl.Manager, conf *config.Config) error {	1✔
56	instances, err := instances(conf)	1✔
57	if err != nil {	1✔
58	return fmt.Errorf("failed to create instances: %w", err)	×
59	}	×
60
61	deployInstances := filterAction(instances, deploy)	1✔
62	deployRes := getResources(deployInstances)	1✔
63	if err := addExternalDnsReconciler(manager, deployRes); err != nil {	1✔
64	return err	×
65	}	×
66
67	if err := addExternalDnsCleaner(manager, instances); err != nil {	1✔
68	return err	×
69	}	×
70
71	return nil	1✔
72	}
73
74	func instances(conf *config.Config) ([]instance, error) {	17✔
75	// public	17✔
76	publicCfg, err := publicConfigForIngress(conf)	17✔
77	if err != nil {	17✔
UNCOV 78	return nil, err	×
UNCOV 79	}	×
80
81	publicAction := actionFromConfig(publicCfg)	17✔
82	publicResources := publicCfg.Resources()	17✔
83		17✔
84	// private	17✔
85	privateCfg, err := privateConfigForIngress(conf)	17✔
86	if err != nil {	17✔
UNCOV 87	return nil, err	×
UNCOV 88	}	×
89
90	privateAction := actionFromConfig(privateCfg)	17✔
91	privateResources := privateCfg.Resources()	17✔
92		17✔
93	return []instance{	17✔
94	{	17✔
95	config: publicCfg,	17✔
96	resources: publicResources,	17✔
97	action: publicAction,	17✔
98	},	17✔
99	{	17✔
100	config: privateCfg,	17✔
101	resources: privateResources,	17✔
102	action: privateAction,	17✔
103	},	17✔
104	}, nil	17✔
105	}
106
107	func publicConfigForIngress(conf config.Config) (manifests.ExternalDnsConfig, error) {	19✔
108	publicconfig, err := manifests.NewExternalDNSConfig(	19✔
109	conf,	19✔
110	manifests.InputExternalDNSConfig{	19✔
111	TenantId: conf.TenantID,	19✔
112	ClientId: conf.MSIClientID,	19✔
113	Namespace: conf.NS,	19✔
114	IdentityType: manifests.IdentityTypeMSI,	19✔
115	ResourceTypes: map[manifests.ResourceType]struct{}{manifests.ResourceTypeIngress: struct{}{}},	19✔
116	DnsZoneresourceIDs: util.Keys(conf.PublicZoneConfig.ZoneIds),	19✔
117	Provider: to.Ptr(manifests.PublicProvider),	19✔
118	})	19✔
119		19✔
120	if err != nil {	19✔
UNCOV 121	return nil, err	×
UNCOV 122	}	×
123	return publicconfig, nil	19✔
124	}
125
126	func privateConfigForIngress(conf config.Config) (manifests.ExternalDnsConfig, error) {	19✔
127	privateconfig, err := manifests.NewExternalDNSConfig(	19✔
128	conf,	19✔
129	manifests.InputExternalDNSConfig{	19✔
130	TenantId: conf.TenantID,	19✔
131	ClientId: conf.MSIClientID,	19✔
132	Namespace: conf.NS,	19✔
133	IdentityType: manifests.IdentityTypeMSI,	19✔
134	ResourceTypes: map[manifests.ResourceType]struct{}{manifests.ResourceTypeIngress: struct{}{}},	19✔
135	DnsZoneresourceIDs: util.Keys(conf.PrivateZoneConfig.ZoneIds),	19✔
136	Provider: to.Ptr(manifests.PrivateProvider),	19✔
137	},	19✔
138	)	19✔
139		19✔
140	if err != nil {	19✔
UNCOV 141	return nil, err	×
UNCOV 142	}	×
143	return privateconfig, nil	19✔
144	}
145
146	func filterAction(instances []instance, action action) []instance {	13✔
147	var ret []instance	13✔
148	for _, i := range instances {	39✔
149	if i.action == action {	38✔
150	ret = append(ret, i)	12✔
151	}	12✔
152	}
153
154	return ret	13✔
155	}
156
157	func getResources(instances []instance) []client.Object {	4✔
158	var ret []client.Object	4✔
159	for _, i := range instances {	6✔
160	ret = append(ret, i.resources...)	2✔
161	}	2✔
162	return ret	4✔
163	}
164
165	func getLabels(instances ...instance) map[string]string {	8✔
166	l := map[string]string{}	8✔
167	for k, v := range manifests.GetTopLevelLabels() {	24✔
168	l[k] = v	16✔
169	}	16✔
170
171	for _, i := range instances {	16✔
172	for k, v := range i.config.Labels() {	16✔
173	l[k] = v	8✔
174	}	8✔
175	}
176
177	return l	8✔
178	}
179
180	func cleanObjs(instances []instance) []cleanObj {	4✔
181	var cleanObjs []cleanObj	4✔
182	for _, instance := range filterAction(instances, clean) {	8✔
183	obj := cleanObj{	4✔
184	resources: instance.resources,	4✔
185	labels: getLabels(instance),	4✔
186	}	4✔
187	cleanObjs = append(cleanObjs, obj)	4✔
188	}	4✔
189
190	return cleanObjs	4✔
191	}
192
193	func actionFromConfig(conf *manifests.ExternalDnsConfig) action {	37✔
194	if len(conf.DnsZoneResourceIds()) == 0 {	57✔
195	return clean	20✔
196	}	20✔
197
198	return deploy	17✔
199	}

Azure / aks-app-routing-operator / 16996039066

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous