26870502843

Committed 03 Jun 2026 07:34AM UTC coverage: 25.64% (+0.004%) from 25.636%

Build # 26870502843

Build Type

push

github

Committed by

web-flow

Commit Message

chore(deps): update golang to v1.26.4 (#6810)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Coverage Stats

14781 of 57648 relevant lines covered (25.64%)

0.3 hits per line

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

0.0

/pkg/controller/provider_network.go

package controller

import (
        "context"
        "fmt"

        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/klog/v2"

        "github.com/kubeovn/kube-ovn/pkg/util"
)

func (c *Controller) resyncProviderNetworkStatus() {
        klog.V(3).Infof("start to sync ProviderNetwork status")
        pns, err := c.providerNetworksLister.List(labels.Everything())
        if err != nil {
                klog.Errorf("failed to list provider network: %v", err)
                return
        }

        nodes, err := c.nodesLister.List(labels.Everything())
        if err != nil {
                klog.Errorf("failed to list nodes: %v", err)
                return
        }

        pods, err := c.podsLister.Pods(c.config.PodNamespace).List(labels.Set{"app": "kube-ovn-cni"}.AsSelector())
        if err != nil {
                klog.Errorf("failed to list kube-ovn-cni pods: %v", err)
                return
        }

        podMap := make(map[string]*corev1.Pod, len(pods))
        for _, pod := range pods {
                podMap[pod.Spec.NodeName] = pod
        }

        for _, cachedPn := range pns {
                pn := cachedPn.DeepCopy()
                var readyNodes, notReadyNodes, expectNodes []string
                pnReadyAnnotation := fmt.Sprintf(util.ProviderNetworkReadyTemplate, pn.Name)
                pnErrMsgAnnotation := fmt.Sprintf(util.ProviderNetworkErrMessageTemplate, pn.Name)

                var conditionsUpdated bool
                for _, node := range nodes {
                        excluded, err := util.IsNodeExcludedFromProviderNetwork(node, pn)
                        if err != nil {
                                klog.Errorf("failed to check if node %s is excluded from provider network %s: %v", node.Name, pn.Name, err)
                                continue
                        }
                        if excluded {
                                if pn.Status.RemoveNodeConditions(node.Name) {
                                        conditionsUpdated = true
                                }
                                continue
                        }
                        if node.Labels[pnReadyAnnotation] == "true" {
                                if pn.Status.SetNodeReady(node.Name, "InitOVSBridgeSucceeded", "") {
                                        conditionsUpdated = true
                                }
                                readyNodes = append(readyNodes, node.Name)
                        } else {
                                var errMsg string
                                if pod := podMap[node.Name]; pod == nil {
                                        errMsg = fmt.Sprintf("kube-ovn-cni pod on node %s not found", node.Name)
                                        klog.Error(errMsg)
                                } else {
                                        if len(pod.Annotations) != 0 {
                                                errMsg = pod.Annotations[pnErrMsgAnnotation]
                                        }
                                        if errMsg == "" {
                                                errMsg = "unknown error"
                                        }
                                }

                                if pn.Status.SetNodeNotReady(node.Name, "InitOVSBridgeFailed", errMsg) {
                                        conditionsUpdated = true
                                }
                                notReadyNodes = append(notReadyNodes, node.Name)
                        }
                }

                expectNodes = append(readyNodes, notReadyNodes...)
                expectNodeSet := make(map[string]struct{}, len(expectNodes))
                for _, n := range expectNodes {
                        expectNodeSet[n] = struct{}{}
                }
                for _, c := range pn.Status.Conditions {
                        if _, ok := expectNodeSet[c.Node]; !ok {
                                if pn.Status.RemoveNodeConditions(c.Node) {
                                        conditionsUpdated = true
                                }
                        }
                }

                if conditionsUpdated || len(util.DiffStringSlice(pn.Status.ReadyNodes, readyNodes)) != 0 ||
                        len(util.DiffStringSlice(pn.Status.NotReadyNodes, notReadyNodes)) != 0 {
                        pn.Status.ReadyNodes = readyNodes
                        pn.Status.NotReadyNodes = notReadyNodes
                        pn.Status.Ready = (len(notReadyNodes) == 0)
                        if _, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), pn, metav1.UpdateOptions{}); err != nil {
                                klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)
                        }
                }
        }
}

1	package controller
2
3	import (
4	"context"
5	"fmt"
6
7	corev1 "k8s.io/api/core/v1"
8	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
9	"k8s.io/apimachinery/pkg/labels"
10	"k8s.io/klog/v2"
11
12	"github.com/kubeovn/kube-ovn/pkg/util"
13	)
14
15	func (c *Controller) resyncProviderNetworkStatus() {	×
16	klog.V(3).Infof("start to sync ProviderNetwork status")	×
17	pns, err := c.providerNetworksLister.List(labels.Everything())	×
18	if err != nil {	×
19	klog.Errorf("failed to list provider network: %v", err)	×
20	return	×
21	}	×
22
23	nodes, err := c.nodesLister.List(labels.Everything())	×
24	if err != nil {	×
25	klog.Errorf("failed to list nodes: %v", err)	×
26	return	×
27	}	×
28
29	pods, err := c.podsLister.Pods(c.config.PodNamespace).List(labels.Set{"app": "kube-ovn-cni"}.AsSelector())	×
30	if err != nil {	×
31	klog.Errorf("failed to list kube-ovn-cni pods: %v", err)	×
32	return	×
33	}	×
34
35	podMap := make(map[string]*corev1.Pod, len(pods))	×
36	for _, pod := range pods {	×
37	podMap[pod.Spec.NodeName] = pod	×
38	}	×
39
40	for _, cachedPn := range pns {	×
41	pn := cachedPn.DeepCopy()	×
42	var readyNodes, notReadyNodes, expectNodes []string	×
43	pnReadyAnnotation := fmt.Sprintf(util.ProviderNetworkReadyTemplate, pn.Name)	×
44	pnErrMsgAnnotation := fmt.Sprintf(util.ProviderNetworkErrMessageTemplate, pn.Name)	×
45		×
46	var conditionsUpdated bool	×
47	for _, node := range nodes {	×
48	excluded, err := util.IsNodeExcludedFromProviderNetwork(node, pn)	×
49	if err != nil {	×
50	klog.Errorf("failed to check if node %s is excluded from provider network %s: %v", node.Name, pn.Name, err)	×
51	continue	×
52	}
53	if excluded {	×
54	if pn.Status.RemoveNodeConditions(node.Name) {	×
55	conditionsUpdated = true	×
56	}	×
57	continue	×
58	}
59	if node.Labels[pnReadyAnnotation] == "true" {	×
60	if pn.Status.SetNodeReady(node.Name, "InitOVSBridgeSucceeded", "") {	×
61	conditionsUpdated = true	×
62	}	×
63	readyNodes = append(readyNodes, node.Name)	×
64	} else {	×
65	var errMsg string	×
66	if pod := podMap[node.Name]; pod == nil {	×
67	errMsg = fmt.Sprintf("kube-ovn-cni pod on node %s not found", node.Name)	×
68	klog.Error(errMsg)	×
69	} else {	×
70	if len(pod.Annotations) != 0 {	×
71	errMsg = pod.Annotations[pnErrMsgAnnotation]	×
72	}	×
73	if errMsg == "" {	×
74	errMsg = "unknown error"	×
75	}	×
76	}
77
78	if pn.Status.SetNodeNotReady(node.Name, "InitOVSBridgeFailed", errMsg) {	×
79	conditionsUpdated = true	×
80	}	×
81	notReadyNodes = append(notReadyNodes, node.Name)	×
82	}
83	}
84
85	expectNodes = append(readyNodes, notReadyNodes...)	×
86	expectNodeSet := make(map[string]struct{}, len(expectNodes))	×
87	for _, n := range expectNodes {	×
88	expectNodeSet[n] = struct{}{}	×
89	}	×
90	for _, c := range pn.Status.Conditions {	×
91	if _, ok := expectNodeSet[c.Node]; !ok {	×
92	if pn.Status.RemoveNodeConditions(c.Node) {	×
93	conditionsUpdated = true	×
94	}	×
95	}
96	}
97
98	if conditionsUpdated \|\| len(util.DiffStringSlice(pn.Status.ReadyNodes, readyNodes)) != 0 \|\|	×
99	len(util.DiffStringSlice(pn.Status.NotReadyNodes, notReadyNodes)) != 0 {	×
100	pn.Status.ReadyNodes = readyNodes	×
101	pn.Status.NotReadyNodes = notReadyNodes	×
102	pn.Status.Ready = (len(notReadyNodes) == 0)	×
103	if _, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), pn, metav1.UpdateOptions{}); err != nil {	×
104	klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)	×
105	}	×
106	}
107	}
108	}

kubeovn / kube-ovn / 26870502843

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