14967332477

Committed 12 May 2025 08:20AM UTC coverage: 21.616% (-0.1%) from 21.714%

Build # 14967332477

Build Type

Pull #5110

github

Committed by

zbb88888

Commit Message

use provider network default interface

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

Pull Request Pull Request #5110: enable check vlan conflict

Run Details

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

218 existing lines in 9 files now uncovered.

10254 of 47436 relevant lines covered (21.62%)

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"
        "strings"

        "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
                }
        }

        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 c.config.EnableCheckVlanConflict {
                err := c.checkVlanConflict(vlan, pn.Spec.DefaultInterface)
                if err != nil {
                        klog.Errorf("failed to check vlan %s: %v", vlan.Name, 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) checkVlanConflict(vlan *kubeovnv1.Vlan, vlanInterface string) error {
        // todo: check if vlan conflict in webhook
        // 1. 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
        }
        var conflictErr error
        nodeTunnVlanIDs := strset.New()
        conflict := false
        myVlanID := strconv.Itoa(vlan.Spec.ID)
        for _, node := range nodes {
                tunnelIF := node.Labels[util.TunnelIFLabel]
                tunnelIFs := strings.Split(tunnelIF, ".")
                if len(tunnelIFs) != 2 {
                        klog.Errorf("invalid tunnel interface %s on node %s", tunnelIF, node.Name)
                        continue
                }
                tunnelIFMaster := tunnelIFs[0]
                id := tunnelIFs[1]
                if id == "" {
                        continue
                }
                nodeTunnVlanIDs.Add(id)
                // conflict with tunnel interface: same if master nic and same vlan id
                if tunnelIFMaster != vlanInterface {
                        continue
                }
                if id != "" {
                        if id == myVlanID {
                                conflict = true
                                conflictErr := fmt.Errorf("vlan %s id %s conflict with tunnel nic %s vlan on node %s", vlan.Name, myVlanID, tunnelIF, node.Name)
                                klog.Error(conflictErr)
                        }
                }
        }
        if nodeTunnVlanIDs.Size() > 1 {
                klog.Warningf("cluster nodes tunnel nic span multi vlan ids: %v", nodeTunnVlanIDs.List())
        }

        // 2. 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 _, v := range vlans {
                if v.Spec.ID == vlan.Spec.ID && v.Name != vlan.Name {
                        conflict = true
                        conflictErr := fmt.Errorf("new vlan %s conflict with exist vlan %s", v.Name, v.Name)
                        klog.Error(conflictErr)
                }
        }
        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 conflictErr
}

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

kubeovn / kube-ovn / 14967332477

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