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

71.88

/pkg/controller/dns/cluster_external_dns.go

package dns

import (
        "context"
        "errors"
        "fmt"

        "github.com/Azure/aks-app-routing-operator/api/v1alpha1"
        "github.com/Azure/aks-app-routing-operator/pkg/config"
        "github.com/Azure/aks-app-routing-operator/pkg/controller/controllername"
        "github.com/Azure/aks-app-routing-operator/pkg/controller/metrics"
        "github.com/Azure/aks-app-routing-operator/pkg/util"
        "github.com/go-logr/logr"
        appsv1 "k8s.io/api/apps/v1"
        corev1 "k8s.io/api/core/v1"
        k8serrors "k8s.io/apimachinery/pkg/api/errors"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/client-go/tools/record"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
)

var ClusterExternalDNSControllerName = controllername.New("cluster", "externaldns", "crd")

func NewClusterExternalDNSController(mgr ctrl.Manager, config *config.Config) error {
        return ClusterExternalDNSControllerName.AddToController(
                ctrl.NewControllerManagedBy(mgr).
                        For(&v1alpha1.ClusterExternalDNS{}).
                        Owns(&appsv1.Deployment{}), mgr.GetLogger()).Complete(
                &ClusterExternalDNSController{
                        config: config,
                        client: mgr.GetClient(),
                        events: mgr.GetEventRecorderFor("aks-app-routing-operator"),
                })

}

type ClusterExternalDNSController struct {
        config *config.Config
        client client.Client
        events record.EventRecorder
}

func (c *ClusterExternalDNSController) Reconcile(ctx context.Context, req ctrl.Request) (res ctrl.Result, err error) {
        // set up metrics
        defer func() {
                metrics.HandleControllerReconcileMetrics(ClusterExternalDNSControllerName, res, err)
        }()

        // set up logger
        logger, err := logr.FromContext(ctx)
        if err != nil {
                return ctrl.Result{}, fmt.Errorf("setting up logger: %s", err)
        }

        logger = ClusterExternalDNSControllerName.AddToLogger(logger).WithValues("namespace", req.Namespace, "name", req.Name)

        // get the ClusterExternalDNS object
        obj := &v1alpha1.ClusterExternalDNS{}
        if err = c.client.Get(ctx, req.NamespacedName, obj); err != nil {
                if k8serrors.IsNotFound(err) {
                        logger.Info("ClusterExternalDNS object not found, will ignore not found error")
                        return ctrl.Result{}, nil
                }
                return ctrl.Result{}, fmt.Errorf("getting ClusterExternalDNS object: %w", err)
        }

        // verify serviceaccount
        if _, err = util.GetServiceAccountAndVerifyWorkloadIdentity(ctx, c.client, obj.GetInputServiceAccount(), obj.GetResourceNamespace()); err != nil {
                var userErr util.UserError
                if errors.As(err, &userErr) {
                        logger.Info("failed to verify service account due to user error, sending warning event: " + userErr.UserError())
                        c.events.Eventf(obj, corev1.EventTypeWarning, "FailedUpdateOrCreateExternalDNSResources", "failed serviceaccount verification: %s", userErr.UserError())
                        return ctrl.Result{}, nil
                }
                logger.Error(err, "failed to verify service account")
                return ctrl.Result{}, err
        }

        manifestsConf, err := generateManifestsConf(c.config, obj)
        if err != nil {
                var userErr util.UserError
                if errors.As(err, &userErr) {
                        logger.Info("failed to generate manifests config due to user error, sending warning event: " + userErr.UserError())
                        c.events.Eventf(obj, corev1.EventTypeWarning, "FailedUpdateOrCreateExternalDNSResources", userErr.UserError())
                        return ctrl.Result{}, nil
                }
                logger.Error(err, "failed to generate manifests config")
                return ctrl.Result{}, err
        }

        err = deployExternalDNSResources(ctx, c.client, manifestsConf, []metav1.OwnerReference{{
                APIVersion: obj.APIVersion,
                Controller: util.ToPtr(true),
                Kind:       obj.Kind,
                Name:       obj.Name,
                UID:        obj.UID,
        }})

        if err != nil {
                logger.Error(err, "failed to upsert externaldns resources")
                c.events.Eventf(obj, corev1.EventTypeWarning, "FailedUpdateOrCreateExternalDNSResources", "failed to deploy external DNS resources: %s", err.Error())
                return ctrl.Result{}, err
        }

        return ctrl.Result{}, nil
}

1	package dns
2
3	import (
4	"context"
5	"errors"
6	"fmt"
7
8	"github.com/Azure/aks-app-routing-operator/api/v1alpha1"
9	"github.com/Azure/aks-app-routing-operator/pkg/config"
10	"github.com/Azure/aks-app-routing-operator/pkg/controller/controllername"
11	"github.com/Azure/aks-app-routing-operator/pkg/controller/metrics"
12	"github.com/Azure/aks-app-routing-operator/pkg/util"
13	"github.com/go-logr/logr"
14	appsv1 "k8s.io/api/apps/v1"
15	corev1 "k8s.io/api/core/v1"
16	k8serrors "k8s.io/apimachinery/pkg/api/errors"
17	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
18	"k8s.io/client-go/tools/record"
19	ctrl "sigs.k8s.io/controller-runtime"
20	"sigs.k8s.io/controller-runtime/pkg/client"
21	)
22
23	var ClusterExternalDNSControllerName = controllername.New("cluster", "externaldns", "crd")
24
25	func NewClusterExternalDNSController(mgr ctrl.Manager, config *config.Config) error {	×
26	return ClusterExternalDNSControllerName.AddToController(	×
27	ctrl.NewControllerManagedBy(mgr).	×
28	For(&v1alpha1.ClusterExternalDNS{}).	×
29	Owns(&appsv1.Deployment{}), mgr.GetLogger()).Complete(	×
30	&ClusterExternalDNSController{	×
31	config: config,	×
32	client: mgr.GetClient(),	×
33	events: mgr.GetEventRecorderFor("aks-app-routing-operator"),	×
34	})	×
35		×
UNCOV 36	}	×
37
38	type ClusterExternalDNSController struct {
39	config *config.Config
40	client client.Client
41	events record.EventRecorder
42	}
43
44	func (c *ClusterExternalDNSController) Reconcile(ctx context.Context, req ctrl.Request) (res ctrl.Result, err error) {	10✔
45	// set up metrics	10✔
46	defer func() {	20✔
47	metrics.HandleControllerReconcileMetrics(ClusterExternalDNSControllerName, res, err)	10✔
48	}()	10✔
49
50	// set up logger
51	logger, err := logr.FromContext(ctx)	10✔
52	if err != nil {	10✔
53	return ctrl.Result{}, fmt.Errorf("setting up logger: %s", err)	×
UNCOV 54	}	×
55
56	logger = ClusterExternalDNSControllerName.AddToLogger(logger).WithValues("namespace", req.Namespace, "name", req.Name)	10✔
57		10✔
58	// get the ClusterExternalDNS object	10✔
59	obj := &v1alpha1.ClusterExternalDNS{}	10✔
60	if err = c.client.Get(ctx, req.NamespacedName, obj); err != nil {	12✔
61	if k8serrors.IsNotFound(err) {	3✔
62	logger.Info("ClusterExternalDNS object not found, will ignore not found error")	1✔
63	return ctrl.Result{}, nil	1✔
64	}	1✔
65	return ctrl.Result{}, fmt.Errorf("getting ClusterExternalDNS object: %w", err)	1✔
66	}
67
68	// verify serviceaccount
69	if _, err = util.GetServiceAccountAndVerifyWorkloadIdentity(ctx, c.client, obj.GetInputServiceAccount(), obj.GetResourceNamespace()); err != nil {	10✔
70	var userErr util.UserError	2✔
71	if errors.As(err, &userErr) {	4✔
72	logger.Info("failed to verify service account due to user error, sending warning event: " + userErr.UserError())	2✔
73	c.events.Eventf(obj, corev1.EventTypeWarning, "FailedUpdateOrCreateExternalDNSResources", "failed serviceaccount verification: %s", userErr.UserError())	2✔
74	return ctrl.Result{}, nil	2✔
75	}	2✔
76	logger.Error(err, "failed to verify service account")	×
UNCOV 77	return ctrl.Result{}, err	×
78	}
79
80	manifestsConf, err := generateManifestsConf(c.config, obj)	6✔
81	if err != nil {	7✔
82	var userErr util.UserError	1✔
83	if errors.As(err, &userErr) {	2✔
84	logger.Info("failed to generate manifests config due to user error, sending warning event: " + userErr.UserError())	1✔
85	c.events.Eventf(obj, corev1.EventTypeWarning, "FailedUpdateOrCreateExternalDNSResources", userErr.UserError())	1✔
86	return ctrl.Result{}, nil	1✔
87	}	1✔
88	logger.Error(err, "failed to generate manifests config")	×
UNCOV 89	return ctrl.Result{}, err	×
90	}
91
92	err = deployExternalDNSResources(ctx, c.client, manifestsConf, []metav1.OwnerReference{{	5✔
93	APIVersion: obj.APIVersion,	5✔
94	Controller: util.ToPtr(true),	5✔
95	Kind: obj.Kind,	5✔
96	Name: obj.Name,	5✔
97	UID: obj.UID,	5✔
98	}})	5✔
99		5✔
100	if err != nil {	6✔
101	logger.Error(err, "failed to upsert externaldns resources")	1✔
102	c.events.Eventf(obj, corev1.EventTypeWarning, "FailedUpdateOrCreateExternalDNSResources", "failed to deploy external DNS resources: %s", err.Error())	1✔
103	return ctrl.Result{}, err	1✔
104	}	1✔
105
106	return ctrl.Result{}, nil	4✔
107	}

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