14547474456

Committed 19 Apr 2025 08:37AM UTC coverage: 21.73% (-0.007%) from 21.737%

Build # 14547474456

Build Type

push

github

Committed by

web-flow

Commit Message

modernize: simplify code by using modern constructs (#5163)

Signed-off-by: Mengxin Liu <liumengxinfly@gmail.com>

Coverage Stats

87 of 376 new or added lines in 94 files covered. (23.14%)

1 existing line in 1 file now uncovered.

10251 of 47175 relevant lines covered (21.73%)

0.25 hits per line

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

0.0

/pkg/controller/vlan.go

package controller

import (
        "context"
        "slices"

        k8serrors "k8s.io/apimachinery/pkg/api/errors"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/client-go/tools/cache"
        "k8s.io/klog/v2"

        kubeovnv1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
        "github.com/kubeovn/kube-ovn/pkg/ovs"
        "github.com/kubeovn/kube-ovn/pkg/util"
)

func (c *Controller) enqueueAddVlan(obj any) {
        key := cache.MetaObjectToName(obj.(*kubeovnv1.Vlan)).String()
        klog.V(3).Infof("enqueue add vlan %s", key)
        c.addVlanQueue.Add(key)
}

func (c *Controller) enqueueUpdateVlan(_, newObj any) {
        key := cache.MetaObjectToName(newObj.(*kubeovnv1.Vlan)).String()
        klog.V(3).Infof("enqueue update vlan %s", key)
        c.updateVlanQueue.Add(key)
}

func (c *Controller) enqueueDelVlan(obj any) {
        key := cache.MetaObjectToName(obj.(*kubeovnv1.Vlan)).String()
        klog.V(3).Infof("enqueue delete vlan %s", key)
        c.delVlanQueue.Add(key)
}

func (c *Controller) handleAddVlan(key string) error {
        c.vlanKeyMutex.LockKey(key)
        defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()
        klog.Infof("handle add vlan %s", key)

        cachedVlan, err := c.vlansLister.Get(key)
        if err != nil {
                if k8serrors.IsNotFound(err) {
                        return nil
                }
                klog.Error(err)
                return err
        }

        vlan := cachedVlan.DeepCopy()
        if vlan.Spec.Provider == "" {
                vlan.Spec.Provider = c.config.DefaultProviderName
                if vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().Update(context.Background(), vlan, metav1.UpdateOptions{}); err != nil {
                        klog.Errorf("failed to update vlan %s, %v", vlan.Name, err)
                        return err
                }
        }

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

        var needUpdate bool
        for _, subnet := range subnets {
                if subnet.Spec.Vlan == vlan.Name && !slices.Contains(vlan.Status.Subnets, subnet.Name) {
                        vlan.Status.Subnets = append(vlan.Status.Subnets, subnet.Name)
                        needUpdate = true
                }
        }

        if needUpdate {
                vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{})
                if err != nil {
                        klog.Errorf("failed to update status of vlan %s: %v", vlan.Name, err)
                        return err
                }
        }

        pn, err := c.providerNetworksLister.Get(vlan.Spec.Provider)
        if err != nil {
                klog.Errorf("failed to get provider network %s: %v", vlan.Spec.Provider, err)
                return err
        }

        if !slices.Contains(pn.Status.Vlans, vlan.Name) {
                newPn := pn.DeepCopy()
                newPn.Status.Vlans = append(newPn.Status.Vlans, vlan.Name)
                _, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})
                if err != nil {
                        klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)
                        return err
                }
        }

        return nil
}

func (c *Controller) handleUpdateVlan(key string) error {
        c.vlanKeyMutex.LockKey(key)
        defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()
        klog.Infof("handle update vlan %s", key)

        vlan, err := c.vlansLister.Get(key)
        if err != nil {
                if k8serrors.IsNotFound(err) {
                        return nil
                }
                klog.Error(err)
                return err
        }

        if vlan.Spec.Provider == "" {
                newVlan := vlan.DeepCopy()
                newVlan.Spec.Provider = c.config.DefaultProviderName
                if _, err = c.config.KubeOvnClient.KubeovnV1().Vlans().Update(context.Background(), newVlan, metav1.UpdateOptions{}); err != nil {
                        klog.Errorf("failed to update vlan %s: %v", vlan.Name, err)
                        return err
                }
        }

        subnets, err := c.subnetsLister.List(labels.Everything())
        if err != nil {
                klog.Errorf("failed to list subnets: %v", err)
                return err
        }
        for _, subnet := range subnets {
                if subnet.Spec.Vlan == vlan.Name {
                        if err = c.setLocalnetTag(subnet.Name, vlan.Spec.ID); err != nil {
                                klog.Error(err)
                                return err
                        }
                }
        }

        return nil
}

func (c *Controller) handleDelVlan(key string) error {
        c.vlanKeyMutex.LockKey(key)
        defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()
        klog.Infof("handle delete vlan %s", key)

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

        for _, s := range subnet {
                if s.Spec.Vlan == key {
                        c.addOrUpdateSubnetQueue.Add(s.Name)
                }
        }

        providerNetworks, err := c.providerNetworksLister.List(labels.Everything())
        if err != nil && !k8serrors.IsNotFound(err) {
                klog.Errorf("failed to list provider networks: %v", err)
                return err
        }

        for _, pn := range providerNetworks {
                if err = c.updateProviderNetworkStatusForVlanDeletion(pn, key); err != nil {
                        klog.Error(err)
                        return err
                }
        }

        return nil
}

func (c *Controller) updateProviderNetworkStatusForVlanDeletion(pn *kubeovnv1.ProviderNetwork, vlan string) error {
        if !slices.Contains(pn.Status.Vlans, vlan) {
                return nil
        }

        newPn := pn.DeepCopy()
        newPn.Status.Vlans = util.RemoveString(newPn.Status.Vlans, vlan)
        _, err := c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})
        if err != nil {
                klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)
                return err
        }
        return nil
}

func (c *Controller) setLocalnetTag(subnet string, vlanID int) error {
        localnetPort := ovs.GetLocalnetName(subnet)
        if err := c.OVNNbClient.SetLogicalSwitchPortVlanTag(localnetPort, vlanID); err != nil {
                klog.Errorf("set localnet port %s vlan tag %d: %v", localnetPort, vlanID, err)
                return err
        }

        return nil
}

func (c *Controller) delLocalnet(subnet string) error {
        localnetPort := ovs.GetLocalnetName(subnet)
        if err := c.OVNNbClient.DeleteLogicalSwitchPort(localnetPort); err != nil {
                klog.Errorf("delete localnet port %s: %v", localnetPort, err)
                return err
        }

        return nil
}

1	package controller
2
3	import (
4	"context"
5	"slices"
6
7	k8serrors "k8s.io/apimachinery/pkg/api/errors"
8	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
9	"k8s.io/apimachinery/pkg/labels"
10	"k8s.io/client-go/tools/cache"
11	"k8s.io/klog/v2"
12
13	kubeovnv1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
14	"github.com/kubeovn/kube-ovn/pkg/ovs"
15	"github.com/kubeovn/kube-ovn/pkg/util"
16	)
17
NEW 18	func (c *Controller) enqueueAddVlan(obj any) {	×
19	key := cache.MetaObjectToName(obj.(*kubeovnv1.Vlan)).String()	×
20	klog.V(3).Infof("enqueue add vlan %s", key)	×
21	c.addVlanQueue.Add(key)	×
22	}	×
23
NEW 24	func (c *Controller) enqueueUpdateVlan(_, newObj any) {	×
25	key := cache.MetaObjectToName(newObj.(*kubeovnv1.Vlan)).String()	×
26	klog.V(3).Infof("enqueue update vlan %s", key)	×
27	c.updateVlanQueue.Add(key)	×
28	}	×
29
NEW 30	func (c *Controller) enqueueDelVlan(obj any) {	×
31	key := cache.MetaObjectToName(obj.(*kubeovnv1.Vlan)).String()	×
32	klog.V(3).Infof("enqueue delete vlan %s", key)	×
33	c.delVlanQueue.Add(key)	×
34	}	×
35
36	func (c *Controller) handleAddVlan(key string) error {	×
37	c.vlanKeyMutex.LockKey(key)	×
38	defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()	×
39	klog.Infof("handle add vlan %s", key)	×
40		×
41	cachedVlan, err := c.vlansLister.Get(key)	×
42	if err != nil {	×
43	if k8serrors.IsNotFound(err) {	×
44	return nil	×
45	}	×
46	klog.Error(err)	×
47	return err	×
48	}
49
50	vlan := cachedVlan.DeepCopy()	×
51	if vlan.Spec.Provider == "" {	×
52	vlan.Spec.Provider = c.config.DefaultProviderName	×
53	if vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().Update(context.Background(), vlan, metav1.UpdateOptions{}); err != nil {	×
54	klog.Errorf("failed to update vlan %s, %v", vlan.Name, err)	×
55	return err	×
56	}	×
57	}
58
59	subnets, err := c.subnetsLister.List(labels.Everything())	×
60	if err != nil {	×
61	klog.Errorf("failed to list subnets: %v", err)	×
62	return err	×
63	}	×
64
65	var needUpdate bool	×
66	for _, subnet := range subnets {	×
67	if subnet.Spec.Vlan == vlan.Name && !slices.Contains(vlan.Status.Subnets, subnet.Name) {	×
68	vlan.Status.Subnets = append(vlan.Status.Subnets, subnet.Name)	×
69	needUpdate = true	×
70	}	×
71	}
72
73	if needUpdate {	×
74	vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{})	×
75	if err != nil {	×
76	klog.Errorf("failed to update status of vlan %s: %v", vlan.Name, err)	×
77	return err	×
78	}	×
79	}
80
81	pn, err := c.providerNetworksLister.Get(vlan.Spec.Provider)	×
82	if err != nil {	×
83	klog.Errorf("failed to get provider network %s: %v", vlan.Spec.Provider, err)	×
84	return err	×
85	}	×
86
87	if !slices.Contains(pn.Status.Vlans, vlan.Name) {	×
88	newPn := pn.DeepCopy()	×
89	newPn.Status.Vlans = append(newPn.Status.Vlans, vlan.Name)	×
90	_, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})	×
91	if err != nil {	×
92	klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)	×
93	return err	×
94	}	×
95	}
96
97	return nil	×
98	}
99
100	func (c *Controller) handleUpdateVlan(key string) error {	×
101	c.vlanKeyMutex.LockKey(key)	×
102	defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()	×
103	klog.Infof("handle update vlan %s", key)	×
104		×
105	vlan, err := c.vlansLister.Get(key)	×
106	if err != nil {	×
107	if k8serrors.IsNotFound(err) {	×
108	return nil	×
109	}	×
110	klog.Error(err)	×
111	return err	×
112	}
113
114	if vlan.Spec.Provider == "" {	×
115	newVlan := vlan.DeepCopy()	×
116	newVlan.Spec.Provider = c.config.DefaultProviderName	×
117	if _, err = c.config.KubeOvnClient.KubeovnV1().Vlans().Update(context.Background(), newVlan, metav1.UpdateOptions{}); err != nil {	×
118	klog.Errorf("failed to update vlan %s: %v", vlan.Name, err)	×
119	return err	×
120	}	×
121	}
122
123	subnets, err := c.subnetsLister.List(labels.Everything())	×
124	if err != nil {	×
125	klog.Errorf("failed to list subnets: %v", err)	×
126	return err	×
127	}	×
128	for _, subnet := range subnets {	×
129	if subnet.Spec.Vlan == vlan.Name {	×
130	if err = c.setLocalnetTag(subnet.Name, vlan.Spec.ID); err != nil {	×
131	klog.Error(err)	×
132	return err	×
133	}	×
134	}
135	}
136
137	return nil	×
138	}
139
140	func (c *Controller) handleDelVlan(key string) error {	×
141	c.vlanKeyMutex.LockKey(key)	×
142	defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()	×
143	klog.Infof("handle delete vlan %s", key)	×
144		×
145	subnet, err := c.subnetsLister.List(labels.Everything())	×
146	if err != nil {	×
147	klog.Errorf("failed to list subnets: %v", err)	×
148	return err	×
149	}	×
150
151	for _, s := range subnet {	×
152	if s.Spec.Vlan == key {	×
153	c.addOrUpdateSubnetQueue.Add(s.Name)	×
154	}	×
155	}
156
157	providerNetworks, err := c.providerNetworksLister.List(labels.Everything())	×
158	if err != nil && !k8serrors.IsNotFound(err) {	×
159	klog.Errorf("failed to list provider networks: %v", err)	×
160	return err	×
161	}	×
162
163	for _, pn := range providerNetworks {	×
164	if err = c.updateProviderNetworkStatusForVlanDeletion(pn, key); err != nil {	×
165	klog.Error(err)	×
166	return err	×
167	}	×
168	}
169
170	return nil	×
171	}
172
173	func (c Controller) updateProviderNetworkStatusForVlanDeletion(pn kubeovnv1.ProviderNetwork, vlan string) error {	×
174	if !slices.Contains(pn.Status.Vlans, vlan) {	×
175	return nil	×
176	}	×
177
178	newPn := pn.DeepCopy()	×
179	newPn.Status.Vlans = util.RemoveString(newPn.Status.Vlans, vlan)	×
180	_, err := c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})	×
181	if err != nil {	×
182	klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)	×
183	return err	×
184	}	×
185	return nil	×
186	}
187
188	func (c *Controller) setLocalnetTag(subnet string, vlanID int) error {	×
189	localnetPort := ovs.GetLocalnetName(subnet)	×
190	if err := c.OVNNbClient.SetLogicalSwitchPortVlanTag(localnetPort, vlanID); err != nil {	×
191	klog.Errorf("set localnet port %s vlan tag %d: %v", localnetPort, vlanID, err)	×
192	return err	×
193	}	×
194
195	return nil	×
196	}
197
198	func (c *Controller) delLocalnet(subnet string) error {	×
199	localnetPort := ovs.GetLocalnetName(subnet)	×
200	if err := c.OVNNbClient.DeleteLogicalSwitchPort(localnetPort); err != nil {	×
201	klog.Errorf("delete localnet port %s: %v", localnetPort, err)	×
202	return err	×
203	}	×
204
205	return nil	×
206	}

kubeovn / kube-ovn / 14547474456

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