15277293151

Committed 27 May 2025 01:57PM UTC coverage: 21.827% (-0.02%) from 21.847%

Build # 15277293151

Build Type

push

github

Committed by

web-flow

Commit Message

base: add CAP_NET_ADMIN to traceroute (#5275)

Signed-off-by: zhangzujian <zhangzujian.7@gmail.com>

Run Details

10367 of 47497 relevant lines covered (21.83%)

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"

        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 err = c.checkVlanConflict(vlan); 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) error {
        if vlan.Spec.ID == 0 {
                // no conflict if vlan id is 0
                return nil
        }
        // todo: check if vlan conflict in webhook
        vlans, err := c.vlansLister.List(labels.Everything())
        if err != nil {
                klog.Errorf("failed to list vlans: %v", err)
                return err
        }
        // check if new vlan conflict with old vlan
        for _, v := range vlans {
                if vlan.Spec.ID == v.Spec.ID && vlan.Name != v.Name {
                        conflictErr := fmt.Errorf("new vlan %s conflict with old vlan %s", vlan.Name, v.Name)
                        klog.Error(conflictErr)

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

kubeovn / kube-ovn / 15277293151

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