20299792163

Committed 17 Dec 2025 10:32AM UTC coverage: 22.303% (-0.06%) from 22.359%

Build # 20299792163

Build Type

Pull #6010

github

Committed by

zbb88888

Commit Message

make sure all del queue refer to a new deepcopy object, the origin ptr refered object is not managed by kube-ovn-controller

Signed-off-by: zbb88888 <jmdxjsjgcxy@gmail.com>

Pull Request Pull Request #6010: Fix ip range

Coverage Stats

40 of 567 new or added lines in 23 files covered. (7.05%)

25 existing lines in 7 files now uncovered.

11820 of 52998 relevant lines covered (22.3%)

0.26 hits per line

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

0.0

/pkg/controller/external_vpc.go

package controller

import (
        "context"
        "slices"

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

        v1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
        "github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
        "github.com/kubeovn/kube-ovn/pkg/util"
)

// syncExternalVpc syncs the non kubeovn created ovn vpc, such as neutron ovn vpc
func (c *Controller) syncExternalVpc() {
        logicalRouters, err := c.getNonKubeovnRouterStatus()
        if err != nil {
                klog.Error("failed to list ovn logical routers", err)
                return
        }
        klog.V(3).Infof("sync external vpcs with ovn non kube-ovn created vpc")
        vpcs, err := c.vpcsLister.List(labels.SelectorFromSet(labels.Set{util.VpcExternalLabel: "true"}))
        if err != nil {
                klog.Errorf("failed to list vpc, %v", err)
                return
        }
        for _, cachedVpc := range vpcs {
                vpcName := cachedVpc.Name
                if _, ok := logicalRouters[vpcName]; ok {
                        // Get the latest VPC object before updating status to avoid conflicts
                        vpc, err := c.config.KubeOvnClient.KubeovnV1().Vpcs().Get(context.Background(), vpcName, metav1.GetOptions{})
                        if err != nil {
                                klog.Errorf("failed to get latest vpc %s: %v", vpcName, err)
                                continue
                        }

                        // update vpc status subnet list
                        vpc.Status.Subnets = []string{}
                        for _, ls := range logicalRouters[vpcName].LogicalSwitches {
                                vpc.Status.Subnets = append(vpc.Status.Subnets, ls.Name)
                        }
                        _, err = c.config.KubeOvnClient.KubeovnV1().Vpcs().UpdateStatus(context.Background(), vpc, metav1.UpdateOptions{})
                        if err != nil {
                                klog.Errorf("failed to update vpc %s status: %v", vpcName, err)
                                continue
                        }
                        delete(logicalRouters, vpcName)
                } else {
                        klog.Infof("external vpc %s has no ovn logical router, delete it", vpcName)
                        err = c.config.KubeOvnClient.KubeovnV1().Vpcs().Delete(context.Background(), vpcName, metav1.DeleteOptions{})
                        if err != nil {
                                klog.Errorf("failed to delete vpc %s: %v", vpcName, err)
                                continue
                        }
                }
        }
        if len(logicalRouters) != 0 {
                // routerName, logicalRouter
                for routerName, logicalRouter := range logicalRouters {
                        vpc := &v1.Vpc{}
                        vpc.Name = routerName
                        vpc.Labels = map[string]string{util.VpcExternalLabel: "true"}
                        vpc, err = c.config.KubeOvnClient.KubeovnV1().Vpcs().Create(context.Background(), vpc, metav1.CreateOptions{})
                        if err != nil {
                                klog.Errorf("failed init external vpc %s, %v", routerName, err)
                                return
                        }

                        for _, logicalSwitch := range logicalRouter.LogicalSwitches {
                                vpc.Status.Subnets = append(vpc.Status.Subnets, logicalSwitch.Name)
                        }
                        vpc.Status.Subnets = []string{}
                        vpc.Status.DefaultLogicalSwitch = ""
                        vpc.Status.Router = routerName
                        vpc.Status.Standby = true
                        vpc.Status.Default = false

                        _, err = c.config.KubeOvnClient.KubeovnV1().Vpcs().UpdateStatus(context.Background(), vpc, metav1.UpdateOptions{})
                        if err != nil {
                                klog.Errorf("failed to update vpc %s status, %v", routerName, err)
                                return
                        }
                        klog.V(4).Infof("added external vpc %s", routerName)
                }
        }
}

func (c *Controller) getNonKubeovnRouterStatus() (logicalRouters map[string]util.LogicalRouter, err error) {
        logicalRouters = make(map[string]util.LogicalRouter)
        nonKubeovnRouters, err := c.OVNNbClient.ListLogicalRouter(false, func(lr *ovnnb.LogicalRouter) bool {
                return len(lr.ExternalIDs) == 0 || lr.ExternalIDs["vendor"] != util.CniTypeName
        })
        if err != nil {
                klog.Errorf("failed to list non kubeovn logical router, %v", err)
                return logicalRouters, err
        }
        if len(nonKubeovnRouters) == 0 {
                klog.V(4).Info("no non kubeovn logical router")
                return logicalRouters, nil
        }

        for _, router := range nonKubeovnRouters {
                lr := util.LogicalRouter{
                        Name:  router.Name,
                        Ports: make([]util.Port, 0, len(router.Ports)),
                }
                for _, uuid := range router.Ports {
                        lrp, err := c.OVNNbClient.GetLogicalRouterPortByUUID(uuid)
                        if err != nil {
                                klog.Warningf("failed to get LRP by UUID %s: %v", uuid, err)
                                continue
                        }
                        lr.Ports = append(lr.Ports, util.Port{Name: lrp.Name})
                }
                logicalRouters[lr.Name] = lr
        }
        for routerName, logicalRouter := range logicalRouters {
                tmpRouter := logicalRouter
                for _, port := range logicalRouter.Ports {
                        peerPorts, err := c.OVNNbClient.ListLogicalSwitchPorts(false, nil, func(lsp *ovnnb.LogicalSwitchPort) bool {
                                return len(lsp.Options) != 0 && lsp.Options["router-port"] == port.Name
                        })
                        if err != nil || len(peerPorts) > 1 {
                                klog.Errorf("failed to list peer port of %s, %v", port, err)
                                continue
                        }
                        if len(peerPorts) == 0 {
                                continue
                        }
                        lsp := peerPorts[0]
                        switches, err := c.OVNNbClient.ListLogicalSwitch(false, func(ls *ovnnb.LogicalSwitch) bool {
                                return slices.Contains(ls.Ports, lsp.UUID)
                        })
                        if err != nil || len(switches) > 1 {
                                klog.Errorf("failed to get logical switch of LSP %s: %v", lsp.Name, err)
                                continue
                        }
                        var aLogicalSwitch util.LogicalSwitch
                        aLogicalSwitch.Name = switches[0].Name
                        tmpRouter.LogicalSwitches = append(tmpRouter.LogicalSwitches, aLogicalSwitch)
                }
                logicalRouters[routerName] = tmpRouter
        }
        return logicalRouters, nil
}

1	package controller
2
3	import (
4	"context"
5	"slices"
6
7	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
8	"k8s.io/apimachinery/pkg/labels"
9	"k8s.io/klog/v2"
10
11	v1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
12	"github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
13	"github.com/kubeovn/kube-ovn/pkg/util"
14	)
15
16	// syncExternalVpc syncs the non kubeovn created ovn vpc, such as neutron ovn vpc
17	func (c *Controller) syncExternalVpc() {	×
18	logicalRouters, err := c.getNonKubeovnRouterStatus()	×
19	if err != nil {	×
20	klog.Error("failed to list ovn logical routers", err)	×
21	return	×
22	}	×
23	klog.V(3).Infof("sync external vpcs with ovn non kube-ovn created vpc")	×
24	vpcs, err := c.vpcsLister.List(labels.SelectorFromSet(labels.Set{util.VpcExternalLabel: "true"}))	×
25	if err != nil {	×
26	klog.Errorf("failed to list vpc, %v", err)	×
27	return	×
28	}	×
29	for _, cachedVpc := range vpcs {	×
NEW 30	vpcName := cachedVpc.Name	×
NEW 31	if _, ok := logicalRouters[vpcName]; ok {	×
NEW 32	// Get the latest VPC object before updating status to avoid conflicts	×
NEW 33	vpc, err := c.config.KubeOvnClient.KubeovnV1().Vpcs().Get(context.Background(), vpcName, metav1.GetOptions{})	×
NEW 34	if err != nil {	×
NEW 35	klog.Errorf("failed to get latest vpc %s: %v", vpcName, err)	×
NEW 36	continue	×
37	}
38
39	// update vpc status subnet list
40	vpc.Status.Subnets = []string{}	×
NEW 41	for _, ls := range logicalRouters[vpcName].LogicalSwitches {	×
42	vpc.Status.Subnets = append(vpc.Status.Subnets, ls.Name)	×
43	}	×
44	_, err = c.config.KubeOvnClient.KubeovnV1().Vpcs().UpdateStatus(context.Background(), vpc, metav1.UpdateOptions{})	×
45	if err != nil {	×
NEW 46	klog.Errorf("failed to update vpc %s status: %v", vpcName, err)	×
47	continue	×
48	}
NEW 49	delete(logicalRouters, vpcName)	×
50	} else {	×
NEW 51	klog.Infof("external vpc %s has no ovn logical router, delete it", vpcName)	×
NEW 52	err = c.config.KubeOvnClient.KubeovnV1().Vpcs().Delete(context.Background(), vpcName, metav1.DeleteOptions{})	×
53	if err != nil {	×
NEW 54	klog.Errorf("failed to delete vpc %s: %v", vpcName, err)	×
55	continue	×
56	}
57	}
58	}
59	if len(logicalRouters) != 0 {	×
60	// routerName, logicalRouter	×
61	for routerName, logicalRouter := range logicalRouters {	×
62	vpc := &v1.Vpc{}	×
63	vpc.Name = routerName	×
64	vpc.Labels = map[string]string{util.VpcExternalLabel: "true"}	×
65	vpc, err = c.config.KubeOvnClient.KubeovnV1().Vpcs().Create(context.Background(), vpc, metav1.CreateOptions{})	×
66	if err != nil {	×
67	klog.Errorf("failed init external vpc %s, %v", routerName, err)	×
68	return	×
69	}	×
70
71	for _, logicalSwitch := range logicalRouter.LogicalSwitches {	×
72	vpc.Status.Subnets = append(vpc.Status.Subnets, logicalSwitch.Name)	×
73	}	×
74	vpc.Status.Subnets = []string{}	×
75	vpc.Status.DefaultLogicalSwitch = ""	×
76	vpc.Status.Router = routerName	×
77	vpc.Status.Standby = true	×
78	vpc.Status.Default = false	×
79		×
80	_, err = c.config.KubeOvnClient.KubeovnV1().Vpcs().UpdateStatus(context.Background(), vpc, metav1.UpdateOptions{})	×
81	if err != nil {	×
82	klog.Errorf("failed to update vpc %s status, %v", routerName, err)	×
83	return	×
84	}	×
85	klog.V(4).Infof("added external vpc %s", routerName)	×
86	}
87	}
88	}
89
90	func (c *Controller) getNonKubeovnRouterStatus() (logicalRouters map[string]util.LogicalRouter, err error) {	×
91	logicalRouters = make(map[string]util.LogicalRouter)	×
92	nonKubeovnRouters, err := c.OVNNbClient.ListLogicalRouter(false, func(lr *ovnnb.LogicalRouter) bool {	×
93	return len(lr.ExternalIDs) == 0 \|\| lr.ExternalIDs["vendor"] != util.CniTypeName	×
94	})	×
95	if err != nil {	×
96	klog.Errorf("failed to list non kubeovn logical router, %v", err)	×
97	return logicalRouters, err	×
98	}	×
99	if len(nonKubeovnRouters) == 0 {	×
100	klog.V(4).Info("no non kubeovn logical router")	×
101	return logicalRouters, nil	×
102	}	×
103
104	for _, router := range nonKubeovnRouters {	×
105	lr := util.LogicalRouter{	×
106	Name: router.Name,	×
107	Ports: make([]util.Port, 0, len(router.Ports)),	×
108	}	×
109	for _, uuid := range router.Ports {	×
110	lrp, err := c.OVNNbClient.GetLogicalRouterPortByUUID(uuid)	×
111	if err != nil {	×
112	klog.Warningf("failed to get LRP by UUID %s: %v", uuid, err)	×
113	continue	×
114	}
115	lr.Ports = append(lr.Ports, util.Port{Name: lrp.Name})	×
116	}
117	logicalRouters[lr.Name] = lr	×
118	}
119	for routerName, logicalRouter := range logicalRouters {	×
120	tmpRouter := logicalRouter	×
121	for _, port := range logicalRouter.Ports {	×
122	peerPorts, err := c.OVNNbClient.ListLogicalSwitchPorts(false, nil, func(lsp *ovnnb.LogicalSwitchPort) bool {	×
123	return len(lsp.Options) != 0 && lsp.Options["router-port"] == port.Name	×
124	})	×
125	if err != nil \|\| len(peerPorts) > 1 {	×
126	klog.Errorf("failed to list peer port of %s, %v", port, err)	×
127	continue	×
128	}
129	if len(peerPorts) == 0 {	×
130	continue	×
131	}
132	lsp := peerPorts[0]	×
133	switches, err := c.OVNNbClient.ListLogicalSwitch(false, func(ls *ovnnb.LogicalSwitch) bool {	×
134	return slices.Contains(ls.Ports, lsp.UUID)	×
135	})	×
136	if err != nil \|\| len(switches) > 1 {	×
137	klog.Errorf("failed to get logical switch of LSP %s: %v", lsp.Name, err)	×
138	continue	×
139	}
140	var aLogicalSwitch util.LogicalSwitch	×
141	aLogicalSwitch.Name = switches[0].Name	×
142	tmpRouter.LogicalSwitches = append(tmpRouter.LogicalSwitches, aLogicalSwitch)	×
143	}
144	logicalRouters[routerName] = tmpRouter	×
145	}
146	return logicalRouters, nil	×
147	}

kubeovn / kube-ovn / 20299792163

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