14856757101

Committed 06 May 2025 09:54AM UTC coverage: 61.527% (-0.06%) from 61.584%

Build # 14856757101

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #891 from SchSeba/use_context_to_annotate

Use context to annotate the node object

Run Details

5 of 7 new or added lines in 1 file covered. (71.43%)

8 existing lines in 2 files now uncovered.

8511 of 13833 relevant lines covered (61.53%)

0.68 hits per line

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

74.38

/controllers/generic_network_controller.go

/*
Copyright 2021.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package controllers

import (
        "context"
        "reflect"

        netattdefv1 "github.com/k8snetworkplumbingwg/network-attachment-definition-client/pkg/apis/k8s.cni.cncf.io/v1"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/errors"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        uns "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/types"
        "k8s.io/client-go/util/workqueue"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/event"
        "sigs.k8s.io/controller-runtime/pkg/handler"
        "sigs.k8s.io/controller-runtime/pkg/log"
        "sigs.k8s.io/controller-runtime/pkg/reconcile"

        sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
)

type NetworkCRInstance interface {
        client.Object
        // renders NetAttDef from the network instance
        RenderNetAttDef() (*uns.Unstructured, error)
        // return name of the target namespace for the network
        NetworkNamespace() string
}

// interface which controller should implement to be compatible with genericNetworkReconciler
type networkController interface {
        reconcile.Reconciler
        // GetObject should return CR type which implements networkCRInstance
        // interface
        GetObject() NetworkCRInstance
        // should return CR list type
        GetObjectList() client.ObjectList
        // should return name of the controller
        Name() string
}

func newGenericNetworkReconciler(c client.Client, s *runtime.Scheme, controller networkController) *genericNetworkReconciler {
        return &genericNetworkReconciler{Client: c, Scheme: s, controller: controller}
}

// genericNetworkReconciler provide common code for all network controllers
type genericNetworkReconciler struct {
        client.Client
        Scheme     *runtime.Scheme
        controller networkController
}

func (r *genericNetworkReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
        req.Namespace = vars.Namespace
        reqLogger := log.FromContext(ctx).WithValues(r.controller.Name(), req.NamespacedName)

        reqLogger.Info("Reconciling " + r.controller.Name())
        var err error

        // Fetch instance of the network object
        instance := r.controller.GetObject()
        err = r.Get(ctx, req.NamespacedName, instance)
        if err != nil {
                if errors.IsNotFound(err) {
                        // Request object not found, could have been deleted after reconcile request.
                        // Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
                        // Return and don't requeue
                        return reconcile.Result{}, nil
                }
                // Error reading the object - requeue the request.
                return reconcile.Result{}, err
        }
        instanceFinalizers := instance.GetFinalizers()
        // examine DeletionTimestamp to determine if object is under deletion
        if instance.GetDeletionTimestamp().IsZero() {
                // The object is not being deleted, so if it does not have our finalizer,
                // then lets add the finalizer and update the object. This is equivalent
                // registering our finalizer.
                if !sriovnetworkv1.StringInArray(sriovnetworkv1.NETATTDEFFINALIZERNAME, instanceFinalizers) {
                        instance.SetFinalizers(append(instanceFinalizers, sriovnetworkv1.NETATTDEFFINALIZERNAME))
                        if err := r.Update(ctx, instance); err != nil {
                                return reconcile.Result{}, err
                        }
                }
        } else {
                // The object is being deleted
                if sriovnetworkv1.StringInArray(sriovnetworkv1.NETATTDEFFINALIZERNAME, instanceFinalizers) {
                        // our finalizer is present, so lets handle any external dependency
                        reqLogger.Info("delete NetworkAttachmentDefinition CR", "Namespace", instance.NetworkNamespace(), "Name", instance.GetName())
                        if err := r.deleteNetAttDef(ctx, instance); err != nil {
                                // if fail to delete the external dependency here, return with error
                                // so that it can be retried
                                return reconcile.Result{}, err
                        }
                        // remove our finalizer from the list and update it.
                        newFinalizers, found := sriovnetworkv1.RemoveString(sriovnetworkv1.NETATTDEFFINALIZERNAME, instanceFinalizers)
                        if found {
                                instance.SetFinalizers(newFinalizers)
                                if err := r.Update(ctx, instance); err != nil {
                                        return reconcile.Result{}, err
                                }
                        }
                }
                return reconcile.Result{}, err
        }
        raw, err := instance.RenderNetAttDef()
        if err != nil {
                return reconcile.Result{}, err
        }
        netAttDef := &netattdefv1.NetworkAttachmentDefinition{}
        err = r.Scheme.Convert(raw, netAttDef, nil)
        if err != nil {
                return reconcile.Result{}, err
        }
        // format CNI config json in CR for easier readability
        netAttDef.Spec.Config, err = formatJSON(netAttDef.Spec.Config)
        if err != nil {
                reqLogger.Error(err, "Couldn't process rendered NetworkAttachmentDefinition config", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)
                return reconcile.Result{}, err
        }
        if lnns, ok := instance.GetAnnotations()[sriovnetworkv1.LASTNETWORKNAMESPACE]; ok && netAttDef.GetNamespace() != lnns {
                err = r.Delete(ctx, &netattdefv1.NetworkAttachmentDefinition{
                        ObjectMeta: metav1.ObjectMeta{
                                Name:      instance.GetName(),
                                Namespace: lnns,
                        },
                })
                if err != nil {
                        reqLogger.Error(err, "Couldn't delete NetworkAttachmentDefinition CR", "Namespace", instance.GetName(), "Name", lnns)
                        return reconcile.Result{}, err
                }
        }
        // Check if this NetworkAttachmentDefinition already exists
        found := &netattdefv1.NetworkAttachmentDefinition{}
        err = r.Get(ctx, types.NamespacedName{Name: netAttDef.Name, Namespace: netAttDef.Namespace}, found)
        if err != nil {
                if errors.IsNotFound(err) {
                        targetNamespace := &corev1.Namespace{}
                        err = r.Get(ctx, types.NamespacedName{Name: netAttDef.Namespace}, targetNamespace)
                        if errors.IsNotFound(err) {
                                reqLogger.Info("Target namespace doesn't exist, NetworkAttachmentDefinition will be created when namespace is available", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)
                                return reconcile.Result{}, nil
                        }

                        reqLogger.Info("NetworkAttachmentDefinition CR not exist, creating")
                        err = r.Create(ctx, netAttDef)
                        if err != nil {
                                reqLogger.Error(err, "Couldn't create NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)
                                return reconcile.Result{}, err
                        }

                        err = utils.AnnotateObject(ctx, instance, sriovnetworkv1.LASTNETWORKNAMESPACE, netAttDef.Namespace, r.Client)
                        if err != nil {
                                return reconcile.Result{}, err
                        }
                } else {
                        reqLogger.Error(err, "Couldn't get NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)
                        return reconcile.Result{}, err
                }
        } else {
                reqLogger.Info("NetworkAttachmentDefinition CR already exist")
                if !reflect.DeepEqual(found.Spec, netAttDef.Spec) || !reflect.DeepEqual(found.GetAnnotations(), netAttDef.GetAnnotations()) {
                        reqLogger.Info("Update NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)
                        netAttDef.SetResourceVersion(found.GetResourceVersion())
                        err = r.Update(ctx, netAttDef)
                        if err != nil {
                                reqLogger.Error(err, "Couldn't update NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)
                                return reconcile.Result{}, err
                        }
                }
        }

        return ctrl.Result{}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *genericNetworkReconciler) SetupWithManager(mgr ctrl.Manager) error {
        // Reconcile when the target namespace is created after the network object.
        namespaceHandler := handler.Funcs{
                CreateFunc: r.namespaceHandlerCreate,
        }
        return ctrl.NewControllerManagedBy(mgr).
                For(r.controller.GetObject()).
                Watches(&netattdefv1.NetworkAttachmentDefinition{}, &handler.EnqueueRequestForObject{}).
                Watches(&corev1.Namespace{}, &namespaceHandler).
                Complete(r.controller)
}

func (r *genericNetworkReconciler) namespaceHandlerCreate(ctx context.Context, e event.TypedCreateEvent[client.Object], w workqueue.TypedRateLimitingInterface[reconcile.Request]) {
        networkList := r.controller.GetObjectList()
        err := r.List(ctx,
                networkList,
                client.MatchingFields{"spec.networkNamespace": e.Object.GetName()},
        )
        logger := log.Log.WithName(r.controller.Name() + " reconciler")
        if err != nil {
                logger.Info("Can't list networks for namespace", "resource", e.Object.GetName(), "error", err)
                return
        }
        unsContent, err := runtime.DefaultUnstructuredConverter.ToUnstructured(networkList)
        if err != nil {
                logger.Info("Can't convert network list to unstructured object", "resource", e.Object.GetName(), "error", err)
                return
        }
        unsList := &uns.Unstructured{}
        unsList.SetUnstructuredContent(unsContent)
        _ = unsList.EachListItem(func(o runtime.Object) error {
                unsObj := o.(*uns.Unstructured)
                w.Add(reconcile.Request{NamespacedName: types.NamespacedName{
                        Namespace: unsObj.GetNamespace(),
                        Name:      unsObj.GetName(),
                }})
                return nil
        })
}

// deleteNetAttDef deletes the generated net-att-def CR
func (r *genericNetworkReconciler) deleteNetAttDef(ctx context.Context, cr NetworkCRInstance) error {
        // Fetch the NetworkAttachmentDefinition instance
        namespace := cr.NetworkNamespace()
        if namespace == "" {
                namespace = cr.GetNamespace()
        }
        instance := &netattdefv1.NetworkAttachmentDefinition{ObjectMeta: metav1.ObjectMeta{Name: cr.GetName(), Namespace: namespace}}
        err := r.Delete(ctx, instance)
        if err != nil {
                if errors.IsNotFound(err) {
                        return nil
                }
                return err
        }
        return nil
}

1	/*
2	Copyright 2021.
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package controllers
18
19	import (
20	"context"
21	"reflect"
22
23	netattdefv1 "github.com/k8snetworkplumbingwg/network-attachment-definition-client/pkg/apis/k8s.cni.cncf.io/v1"
24	corev1 "k8s.io/api/core/v1"
25	"k8s.io/apimachinery/pkg/api/errors"
26	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
27	uns "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
28	"k8s.io/apimachinery/pkg/runtime"
29	"k8s.io/apimachinery/pkg/types"
30	"k8s.io/client-go/util/workqueue"
31	ctrl "sigs.k8s.io/controller-runtime"
32	"sigs.k8s.io/controller-runtime/pkg/client"
33	"sigs.k8s.io/controller-runtime/pkg/event"
34	"sigs.k8s.io/controller-runtime/pkg/handler"
35	"sigs.k8s.io/controller-runtime/pkg/log"
36	"sigs.k8s.io/controller-runtime/pkg/reconcile"
37
38	sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
39	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
40	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
41	)
42
43	type NetworkCRInstance interface {
44	client.Object
45	// renders NetAttDef from the network instance
46	RenderNetAttDef() (*uns.Unstructured, error)
47	// return name of the target namespace for the network
48	NetworkNamespace() string
49	}
50
51	// interface which controller should implement to be compatible with genericNetworkReconciler
52	type networkController interface {
53	reconcile.Reconciler
54	// GetObject should return CR type which implements networkCRInstance
55	// interface
56	GetObject() NetworkCRInstance
57	// should return CR list type
58	GetObjectList() client.ObjectList
59	// should return name of the controller
60	Name() string
61	}
62
63	func newGenericNetworkReconciler(c client.Client, s runtime.Scheme, controller networkController) genericNetworkReconciler {	1✔
64	return &genericNetworkReconciler{Client: c, Scheme: s, controller: controller}	1✔
65	}	1✔
66
67	// genericNetworkReconciler provide common code for all network controllers
68	type genericNetworkReconciler struct {
69	client.Client
70	Scheme *runtime.Scheme
71	controller networkController
72	}
73
74	func (r *genericNetworkReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	1✔
75	req.Namespace = vars.Namespace	1✔
76	reqLogger := log.FromContext(ctx).WithValues(r.controller.Name(), req.NamespacedName)	1✔
77		1✔
78	reqLogger.Info("Reconciling " + r.controller.Name())	1✔
79	var err error	1✔
80		1✔
81	// Fetch instance of the network object	1✔
82	instance := r.controller.GetObject()	1✔
83	err = r.Get(ctx, req.NamespacedName, instance)	1✔
84	if err != nil {	2✔
85	if errors.IsNotFound(err) {	2✔
86	// Request object not found, could have been deleted after reconcile request.	1✔
87	// Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.	1✔
88	// Return and don't requeue	1✔
89	return reconcile.Result{}, nil	1✔
90	}	1✔
91	// Error reading the object - requeue the request.
92	return reconcile.Result{}, err	×
93	}
94	instanceFinalizers := instance.GetFinalizers()	1✔
95	// examine DeletionTimestamp to determine if object is under deletion	1✔
96	if instance.GetDeletionTimestamp().IsZero() {	2✔
97	// The object is not being deleted, so if it does not have our finalizer,	1✔
98	// then lets add the finalizer and update the object. This is equivalent	1✔
99	// registering our finalizer.	1✔
100	if !sriovnetworkv1.StringInArray(sriovnetworkv1.NETATTDEFFINALIZERNAME, instanceFinalizers) {	2✔
101	instance.SetFinalizers(append(instanceFinalizers, sriovnetworkv1.NETATTDEFFINALIZERNAME))	1✔
102	if err := r.Update(ctx, instance); err != nil {	2✔
103	return reconcile.Result{}, err	1✔
104	}	1✔
105	}
106	} else {	1✔
107	// The object is being deleted	1✔
108	if sriovnetworkv1.StringInArray(sriovnetworkv1.NETATTDEFFINALIZERNAME, instanceFinalizers) {	2✔
109	// our finalizer is present, so lets handle any external dependency	1✔
110	reqLogger.Info("delete NetworkAttachmentDefinition CR", "Namespace", instance.NetworkNamespace(), "Name", instance.GetName())	1✔
111	if err := r.deleteNetAttDef(ctx, instance); err != nil {	1✔
UNCOV 112	// if fail to delete the external dependency here, return with error	×
UNCOV 113	// so that it can be retried	×
UNCOV 114	return reconcile.Result{}, err	×
UNCOV 115	}	×
116	// remove our finalizer from the list and update it.
117	newFinalizers, found := sriovnetworkv1.RemoveString(sriovnetworkv1.NETATTDEFFINALIZERNAME, instanceFinalizers)	1✔
118	if found {	2✔
119	instance.SetFinalizers(newFinalizers)	1✔
120	if err := r.Update(ctx, instance); err != nil {	2✔
121	return reconcile.Result{}, err	1✔
122	}	1✔
123	}
124	}
125	return reconcile.Result{}, err	1✔
126	}
127	raw, err := instance.RenderNetAttDef()	1✔
128	if err != nil {	1✔
129	return reconcile.Result{}, err	×
130	}	×
131	netAttDef := &netattdefv1.NetworkAttachmentDefinition{}	1✔
132	err = r.Scheme.Convert(raw, netAttDef, nil)	1✔
133	if err != nil {	1✔
134	return reconcile.Result{}, err	×
135	}	×
136	// format CNI config json in CR for easier readability
137	netAttDef.Spec.Config, err = formatJSON(netAttDef.Spec.Config)	1✔
138	if err != nil {	1✔
139	reqLogger.Error(err, "Couldn't process rendered NetworkAttachmentDefinition config", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)	×
140	return reconcile.Result{}, err	×
141	}	×
142	if lnns, ok := instance.GetAnnotations()[sriovnetworkv1.LASTNETWORKNAMESPACE]; ok && netAttDef.GetNamespace() != lnns {	1✔
143	err = r.Delete(ctx, &netattdefv1.NetworkAttachmentDefinition{	×
144	ObjectMeta: metav1.ObjectMeta{	×
145	Name: instance.GetName(),	×
146	Namespace: lnns,	×
147	},	×
148	})	×
149	if err != nil {	×
150	reqLogger.Error(err, "Couldn't delete NetworkAttachmentDefinition CR", "Namespace", instance.GetName(), "Name", lnns)	×
151	return reconcile.Result{}, err	×
152	}	×
153	}
154	// Check if this NetworkAttachmentDefinition already exists
155	found := &netattdefv1.NetworkAttachmentDefinition{}	1✔
156	err = r.Get(ctx, types.NamespacedName{Name: netAttDef.Name, Namespace: netAttDef.Namespace}, found)	1✔
157	if err != nil {	2✔
158	if errors.IsNotFound(err) {	2✔
159	targetNamespace := &corev1.Namespace{}	1✔
160	err = r.Get(ctx, types.NamespacedName{Name: netAttDef.Namespace}, targetNamespace)	1✔
161	if errors.IsNotFound(err) {	2✔
162	reqLogger.Info("Target namespace doesn't exist, NetworkAttachmentDefinition will be created when namespace is available", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)	1✔
163	return reconcile.Result{}, nil	1✔
164	}	1✔
165
166	reqLogger.Info("NetworkAttachmentDefinition CR not exist, creating")	1✔
167	err = r.Create(ctx, netAttDef)	1✔
168	if err != nil {	1✔
169	reqLogger.Error(err, "Couldn't create NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)	×
170	return reconcile.Result{}, err	×
171	}	×
172
173	err = utils.AnnotateObject(ctx, instance, sriovnetworkv1.LASTNETWORKNAMESPACE, netAttDef.Namespace, r.Client)	1✔
174	if err != nil {	1✔
175	return reconcile.Result{}, err	×
176	}	×
177	} else {	×
178	reqLogger.Error(err, "Couldn't get NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)	×
179	return reconcile.Result{}, err	×
180	}	×
181	} else {	1✔
182	reqLogger.Info("NetworkAttachmentDefinition CR already exist")	1✔
183	if !reflect.DeepEqual(found.Spec, netAttDef.Spec) \|\| !reflect.DeepEqual(found.GetAnnotations(), netAttDef.GetAnnotations()) {	2✔
184	reqLogger.Info("Update NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)	1✔
185	netAttDef.SetResourceVersion(found.GetResourceVersion())	1✔
186	err = r.Update(ctx, netAttDef)	1✔
187	if err != nil {	1✔
188	reqLogger.Error(err, "Couldn't update NetworkAttachmentDefinition CR", "Namespace", netAttDef.Namespace, "Name", netAttDef.Name)	×
189	return reconcile.Result{}, err	×
190	}	×
191	}
192	}
193
194	return ctrl.Result{}, nil	1✔
195	}
196
197	// SetupWithManager sets up the controller with the Manager.
198	func (r *genericNetworkReconciler) SetupWithManager(mgr ctrl.Manager) error {	1✔
199	// Reconcile when the target namespace is created after the network object.	1✔
200	namespaceHandler := handler.Funcs{	1✔
201	CreateFunc: r.namespaceHandlerCreate,	1✔
202	}	1✔
203	return ctrl.NewControllerManagedBy(mgr).	1✔
204	For(r.controller.GetObject()).	1✔
205	Watches(&netattdefv1.NetworkAttachmentDefinition{}, &handler.EnqueueRequestForObject{}).	1✔
206	Watches(&corev1.Namespace{}, &namespaceHandler).	1✔
207	Complete(r.controller)	1✔
208	}	1✔
209
210	func (r *genericNetworkReconciler) namespaceHandlerCreate(ctx context.Context, e event.TypedCreateEvent[client.Object], w workqueue.TypedRateLimitingInterface[reconcile.Request]) {	1✔
211	networkList := r.controller.GetObjectList()	1✔
212	err := r.List(ctx,	1✔
213	networkList,	1✔
214	client.MatchingFields{"spec.networkNamespace": e.Object.GetName()},	1✔
215	)	1✔
216	logger := log.Log.WithName(r.controller.Name() + " reconciler")	1✔
217	if err != nil {	1✔
218	logger.Info("Can't list networks for namespace", "resource", e.Object.GetName(), "error", err)	×
219	return	×
220	}	×
221	unsContent, err := runtime.DefaultUnstructuredConverter.ToUnstructured(networkList)	1✔
222	if err != nil {	1✔
223	logger.Info("Can't convert network list to unstructured object", "resource", e.Object.GetName(), "error", err)	×
224	return	×
225	}	×
226	unsList := &uns.Unstructured{}	1✔
227	unsList.SetUnstructuredContent(unsContent)	1✔
228	_ = unsList.EachListItem(func(o runtime.Object) error {	2✔
229	unsObj := o.(*uns.Unstructured)	1✔
230	w.Add(reconcile.Request{NamespacedName: types.NamespacedName{	1✔
231	Namespace: unsObj.GetNamespace(),	1✔
232	Name: unsObj.GetName(),	1✔
233	}})	1✔
234	return nil	1✔
235	})	1✔
236	}
237
238	// deleteNetAttDef deletes the generated net-att-def CR
239	func (r *genericNetworkReconciler) deleteNetAttDef(ctx context.Context, cr NetworkCRInstance) error {	1✔
240	// Fetch the NetworkAttachmentDefinition instance	1✔
241	namespace := cr.NetworkNamespace()	1✔
242	if namespace == "" {	2✔
243	namespace = cr.GetNamespace()	1✔
244	}	1✔
245	instance := &netattdefv1.NetworkAttachmentDefinition{ObjectMeta: metav1.ObjectMeta{Name: cr.GetName(), Namespace: namespace}}	1✔
246	err := r.Delete(ctx, instance)	1✔
247	if err != nil {	2✔
248	if errors.IsNotFound(err) {	2✔
249	return nil	1✔
250	}	1✔
UNCOV 251	return err	×
252	}
253	return nil	1✔
254	}

k8snetworkplumbingwg / sriov-network-operator / 14856757101

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