14372473322

Committed 10 Apr 2025 04:42AM UTC coverage: 21.704% (-0.3%) from 22.009%

Build # 14372473322

Build Type

Pull #5110

github

Committed by

zbb88888

Commit Message

fix fmt

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

Pull Request Pull Request #5110: enable check vlan conflict

Run Details

0 of 178 new or added lines in 6 files covered. (0.0%)

1053 existing lines in 9 files now uncovered.

10263 of 47286 relevant lines covered (21.7%)

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"
        "fmt"
        "slices"
        "strconv"

        "github.com/scylladb/go-set/strset"
        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 interface{}) {
        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 interface{}) {
        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 interface{}) {
        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
                }
        }

        if c.config.EnableCheckVlanConflict {
                // todo: check if vlan conflict in webhook
                conflict := false
                // check if vlan conflict with node tunnel vlan
                nodes, err := c.nodesLister.List(labels.SelectorFromSet(labels.Set{util.TunnelUseVlanLabel: "true"}))
                if err != nil {
                        klog.Errorf("failed to list nodes: %v", err)
                        return err
                }
                nodeTunVlanIDs := strset.New()
                for _, node := range nodes {
                        id := node.Labels[util.TunnelVlanIDLabel]
                        nodeTunVlanIDs.Add(id)
                        if id == strconv.Itoa(vlan.Spec.ID) {
                                conflict = true
                                err = fmt.Errorf("vlan %s id %s conflict with node %s tunnel nic vlan", vlan.Name, id, node.Name)
                                klog.Error(err)
                        }
                }

                if nodeTunVlanIDs.Size() > 1 {
                        klog.Warningf("cluster nodes tunnel nic span multi vlan ids: %v", nodeTunVlanIDs.List())
                }
                // check if new vlan conflict with other vlans
                vlans, err := c.vlansLister.List(labels.Everything())
                if err != nil {
                        klog.Errorf("failed to list vlans: %v", err)
                        return err
                }
                for _, vlan := range vlans {
                        if vlan.Spec.ID == cachedVlan.Spec.ID && vlan.Name != cachedVlan.Name {
                                conflict = true
                                err = fmt.Errorf("new vlan %s conflict with vlan %s", cachedVlan.Name, vlan.Name)
                                klog.Error(err)
                                continue
                        }
                }
                if conflict {
                        vlan.Status.Conflict = true
                        vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{})
                        if err != nil {
                                klog.Errorf("failed to update conflict status of vlan %s: %v", vlan.Name, err)
                                return 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	"fmt"
6	"slices"
7	"strconv"
8
9	"github.com/scylladb/go-set/strset"
10	k8serrors "k8s.io/apimachinery/pkg/api/errors"
11	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
12	"k8s.io/apimachinery/pkg/labels"
13	"k8s.io/client-go/tools/cache"
14	"k8s.io/klog/v2"
15
16	kubeovnv1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
17	"github.com/kubeovn/kube-ovn/pkg/ovs"
18	"github.com/kubeovn/kube-ovn/pkg/util"
19	)
20
21	func (c *Controller) enqueueAddVlan(obj interface{}) {	×
22	key := cache.MetaObjectToName(obj.(*kubeovnv1.Vlan)).String()	×
23	klog.V(3).Infof("enqueue add vlan %s", key)	×
24	c.addVlanQueue.Add(key)	×
25	}	×
26
27	func (c *Controller) enqueueUpdateVlan(_, newObj interface{}) {	×
28	key := cache.MetaObjectToName(newObj.(*kubeovnv1.Vlan)).String()	×
29	klog.V(3).Infof("enqueue update vlan %s", key)	×
30	c.updateVlanQueue.Add(key)	×
31	}	×
32
33	func (c *Controller) enqueueDelVlan(obj interface{}) {	×
34	key := cache.MetaObjectToName(obj.(*kubeovnv1.Vlan)).String()	×
35	klog.V(3).Infof("enqueue delete vlan %s", key)	×
36	c.delVlanQueue.Add(key)	×
37	}	×
38
39	func (c *Controller) handleAddVlan(key string) error {	×
40	c.vlanKeyMutex.LockKey(key)	×
41	defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()	×
42	klog.Infof("handle add vlan %s", key)	×
43		×
44	cachedVlan, err := c.vlansLister.Get(key)	×
45	if err != nil {	×
46	if k8serrors.IsNotFound(err) {	×
47	return nil	×
48	}	×
49	klog.Error(err)	×
50	return err	×
51	}
52
53	vlan := cachedVlan.DeepCopy()	×
54	if vlan.Spec.Provider == "" {	×
55	vlan.Spec.Provider = c.config.DefaultProviderName	×
56	if vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().Update(context.Background(), vlan, metav1.UpdateOptions{}); err != nil {	×
57	klog.Errorf("failed to update vlan %s, %v", vlan.Name, err)	×
58	return err	×
59	}	×
60	}
61
NEW 62	if c.config.EnableCheckVlanConflict {	×
NEW 63	// todo: check if vlan conflict in webhook	×
NEW 64	conflict := false	×
NEW 65	// check if vlan conflict with node tunnel vlan	×
NEW 66	nodes, err := c.nodesLister.List(labels.SelectorFromSet(labels.Set{util.TunnelUseVlanLabel: "true"}))	×
NEW 67	if err != nil {	×
NEW 68	klog.Errorf("failed to list nodes: %v", err)	×
NEW 69	return err	×
NEW 70	}	×
NEW 71	nodeTunVlanIDs := strset.New()	×
NEW 72	for _, node := range nodes {	×
NEW 73	id := node.Labels[util.TunnelVlanIDLabel]	×
NEW 74	nodeTunVlanIDs.Add(id)	×
NEW 75	if id == strconv.Itoa(vlan.Spec.ID) {	×
NEW 76	conflict = true	×
NEW 77	err = fmt.Errorf("vlan %s id %s conflict with node %s tunnel nic vlan", vlan.Name, id, node.Name)	×
NEW 78	klog.Error(err)	×
NEW 79	}	×
80	}
81
NEW 82	if nodeTunVlanIDs.Size() > 1 {	×
NEW 83	klog.Warningf("cluster nodes tunnel nic span multi vlan ids: %v", nodeTunVlanIDs.List())	×
NEW 84	}	×
85	// check if new vlan conflict with other vlans
NEW 86	vlans, err := c.vlansLister.List(labels.Everything())	×
NEW 87	if err != nil {	×
NEW 88	klog.Errorf("failed to list vlans: %v", err)	×
NEW 89	return err	×
NEW 90	}	×
NEW 91	for _, vlan := range vlans {	×
NEW 92	if vlan.Spec.ID == cachedVlan.Spec.ID && vlan.Name != cachedVlan.Name {	×
NEW 93	conflict = true	×
NEW 94	err = fmt.Errorf("new vlan %s conflict with vlan %s", cachedVlan.Name, vlan.Name)	×
NEW 95	klog.Error(err)	×
NEW 96	continue	×
97	}
98	}
NEW 99	if conflict {	×
NEW 100	vlan.Status.Conflict = true	×
NEW 101	vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{})	×
NEW 102	if err != nil {	×
NEW 103	klog.Errorf("failed to update conflict status of vlan %s: %v", vlan.Name, err)	×
NEW 104	return err	×
NEW 105	}	×
NEW 106	return err	×
107	}
108	}
109
110	subnets, err := c.subnetsLister.List(labels.Everything())	×
111	if err != nil {	×
112	klog.Errorf("failed to list subnets: %v", err)	×
113	return err	×
114	}	×
115
116	var needUpdate bool	×
117	for _, subnet := range subnets {	×
118	if subnet.Spec.Vlan == vlan.Name && !slices.Contains(vlan.Status.Subnets, subnet.Name) {	×
119	vlan.Status.Subnets = append(vlan.Status.Subnets, subnet.Name)	×
120	needUpdate = true	×
121	}	×
122	}
123
124	if needUpdate {	×
125	vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{})	×
126	if err != nil {	×
127	klog.Errorf("failed to update status of vlan %s: %v", vlan.Name, err)	×
128	return err	×
129	}	×
130	}
131
132	pn, err := c.providerNetworksLister.Get(vlan.Spec.Provider)	×
133	if err != nil {	×
134	klog.Errorf("failed to get provider network %s: %v", vlan.Spec.Provider, err)	×
135	return err	×
136	}	×
137
138	if !slices.Contains(pn.Status.Vlans, vlan.Name) {	×
139	newPn := pn.DeepCopy()	×
140	newPn.Status.Vlans = append(newPn.Status.Vlans, vlan.Name)	×
141	_, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})	×
142	if err != nil {	×
143	klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)	×
144	return err	×
145	}	×
146	}
147
148	return nil	×
149	}
150
151	func (c *Controller) handleUpdateVlan(key string) error {	×
152	c.vlanKeyMutex.LockKey(key)	×
153	defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()	×
154	klog.Infof("handle update vlan %s", key)	×
155		×
156	vlan, err := c.vlansLister.Get(key)	×
157	if err != nil {	×
158	if k8serrors.IsNotFound(err) {	×
159	return nil	×
160	}	×
161	klog.Error(err)	×
162	return err	×
163	}
164
165	if vlan.Spec.Provider == "" {	×
166	newVlan := vlan.DeepCopy()	×
167	newVlan.Spec.Provider = c.config.DefaultProviderName	×
168	if _, err = c.config.KubeOvnClient.KubeovnV1().Vlans().Update(context.Background(), newVlan, metav1.UpdateOptions{}); err != nil {	×
169	klog.Errorf("failed to update vlan %s: %v", vlan.Name, err)	×
170	return err	×
171	}	×
172	}
173
174	subnets, err := c.subnetsLister.List(labels.Everything())	×
175	if err != nil {	×
176	klog.Errorf("failed to list subnets: %v", err)	×
177	return err	×
178	}	×
179	for _, subnet := range subnets {	×
180	if subnet.Spec.Vlan == vlan.Name {	×
181	if err = c.setLocalnetTag(subnet.Name, vlan.Spec.ID); err != nil {	×
182	klog.Error(err)	×
183	return err	×
184	}	×
185	}
186	}
187
188	return nil	×
189	}
190
191	func (c *Controller) handleDelVlan(key string) error {	×
192	c.vlanKeyMutex.LockKey(key)	×
193	defer func() { _ = c.vlanKeyMutex.UnlockKey(key) }()	×
194	klog.Infof("handle delete vlan %s", key)	×
195		×
196	subnet, err := c.subnetsLister.List(labels.Everything())	×
197	if err != nil {	×
198	klog.Errorf("failed to list subnets: %v", err)	×
199	return err	×
200	}	×
201
202	for _, s := range subnet {	×
203	if s.Spec.Vlan == key {	×
204	c.addOrUpdateSubnetQueue.Add(s.Name)	×
205	}	×
206	}
207
208	providerNetworks, err := c.providerNetworksLister.List(labels.Everything())	×
209	if err != nil && !k8serrors.IsNotFound(err) {	×
210	klog.Errorf("failed to list provider networks: %v", err)	×
211	return err	×
212	}	×
213
214	for _, pn := range providerNetworks {	×
215	if err = c.updateProviderNetworkStatusForVlanDeletion(pn, key); err != nil {	×
216	klog.Error(err)	×
217	return err	×
218	}	×
219	}
220
221	return nil	×
222	}
223
224	func (c Controller) updateProviderNetworkStatusForVlanDeletion(pn kubeovnv1.ProviderNetwork, vlan string) error {	×
225	if !slices.Contains(pn.Status.Vlans, vlan) {	×
226	return nil	×
227	}	×
228
229	newPn := pn.DeepCopy()	×
230	newPn.Status.Vlans = util.RemoveString(newPn.Status.Vlans, vlan)	×
231	_, err := c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})	×
232	if err != nil {	×
233	klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)	×
234	return err	×
235	}	×
236	return nil	×
237	}
238
239	func (c *Controller) setLocalnetTag(subnet string, vlanID int) error {	×
240	localnetPort := ovs.GetLocalnetName(subnet)	×
241	if err := c.OVNNbClient.SetLogicalSwitchPortVlanTag(localnetPort, vlanID); err != nil {	×
242	klog.Errorf("set localnet port %s vlan tag %d: %v", localnetPort, vlanID, err)	×
243	return err	×
244	}	×
245
246	return nil	×
247	}
248
249	func (c *Controller) delLocalnet(subnet string) error {	×
250	localnetPort := ovs.GetLocalnetName(subnet)	×
251	if err := c.OVNNbClient.DeleteLogicalSwitchPort(localnetPort); err != nil {	×
252	klog.Errorf("delete localnet port %s: %v", localnetPort, err)	×
253	return err	×
254	}	×
255
256	return nil	×
257	}

kubeovn / kube-ovn / 14372473322

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