21623048013

Committed 03 Feb 2026 08:37AM UTC coverage: 23.043%. Remained the same

Build # 21623048013

Build Type

push

github

Committed by

web-flow

Commit Message

fix typo (#6253)

Signed-off-by: Mengxin Liu <liumengxinfly@gmail.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Run Details

12 of 152 new or added lines in 51 files covered. (7.89%)

1 existing line in 1 file now uncovered.

12411 of 53860 relevant lines covered (23.04%)

0.27 hits per line

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

0.0

/pkg/daemon/init_linux.go

package daemon

import (
        "slices"
        "time"

        "github.com/vishvananda/netlink"
        "k8s.io/klog/v2"
)

var routeScopeOrders = [...]netlink.Scope{
        netlink.SCOPE_HOST,
        netlink.SCOPE_LINK,
        netlink.SCOPE_SITE,
        netlink.SCOPE_UNIVERSE,
}

// wait systemd-networkd to finish interface configuration
func waitNetworkdConfiguration(linkIndex int) {
        done := make(chan struct{})
        ch := make(chan netlink.RouteUpdate)
        if err := netlink.RouteSubscribe(ch, done); err != nil {
                klog.Warningf("failed to subscribe route update events: %v", err)
                klog.Info("Waiting 100ms ...")
                time.Sleep(100 * time.Millisecond)
                return
        }

        // wait route event on the link for 50ms
        timer := time.NewTimer(50 * time.Millisecond)
        for {
                select {
                case <-timer.C:
                        // timeout, interface configuration is expected to be completed
                        done <- struct{}{}
                        return
                case event := <-ch:
                        if event.LinkIndex == linkIndex {
                                // received a route event on the link
                                // stop the timer
                                if !timer.Stop() {
                                        <-timer.C
                                }
                                // reset the timer, wait for another 50ms
                                timer.Reset(50 * time.Millisecond)
                        }
                }
        }
}

func (c *Controller) changeProviderNicName(current, target string) (bool, error) {
        link, err := netlink.LinkByName(current)
        if err != nil {
                if _, ok := err.(netlink.LinkNotFoundError); ok {
                        klog.Infof("link %s not found, skip", current)
                        return false, nil
                }
                klog.Errorf("failed to get link %s: %v", current, err)
                return false, err
        }
        if link.Type() == "openvswitch" {
                klog.V(3).Infof("%s is an openvswitch interface, skip", current)
                return true, nil
        }

        addresses, err := netlink.AddrList(link, netlink.FAMILY_ALL)
        if err != nil {
                klog.Errorf("failed to list addresses of link %s: %v", current, err)
                return false, err
        }
        routes, err := netlink.RouteList(link, netlink.FAMILY_ALL)
        if err != nil {
                klog.Errorf("failed to list routes of link %s: %v", current, err)
                return false, err
        }

        // set link unmanaged by NetworkManager
        if err = c.nmSyncer.SetManaged(current, false); err != nil {
                klog.Errorf("failed to set device %s unmanaged by NetworkManager: %v", current, err)
                return false, err
        }

        klog.Infof("renaming link %s as %s", current, target)
        if err = netlink.LinkSetDown(link); err != nil {
                klog.Errorf("failed to set link %s down: %v", current, err)
                return false, err
        }
        if err = netlink.LinkSetName(link, target); err != nil {
                klog.Errorf("failed to set name of link %s to %s: %v", current, target, err)
                return false, err
        }
        if err = netlink.LinkSetUp(link); err != nil {
                klog.Errorf("failed to set link %s up: %v", target, err)
                return false, err
        }
        klog.Infof("link %s has been renamed as %s", current, target)

        waitNetworkdConfiguration(link.Attrs().Index)

        for _, addr := range addresses {
                if addr.IP.IsLinkLocalUnicast() {
                        continue
                }
                addr.Label = ""
                if err = netlink.AddrReplace(link, &addr); err != nil {
                        klog.Errorf("failed to replace address %q: %v", addr.String(), err)
                        return false, err
                }
                klog.Infof("address %q has been added/replaced to link %s", addr.String(), target)
        }

        for _, scope := range routeScopeOrders {
                for _, route := range routes {
                        if route.Gw == nil && route.Dst != nil && route.Dst.IP.IsLinkLocalUnicast() {
                                continue
                        }
                        if route.Scope == scope {
                                if err = netlink.RouteReplace(&route); err != nil {
                                        klog.Errorf("failed to replace route %q to %s: %v", route.String(), target, err)
                                        return false, err
                                }
                                klog.Infof("route %q has been added/replaced to link %s", route.String(), target)
                        }
                }
        }

        index := link.Attrs().Index
        if link, err = netlink.LinkByIndex(index); err != nil {
                klog.Errorf("failed to get link %s by index %d: %v", target, index, err)
                return false, err
        }

        if slices.Contains(link.Attrs().AltNames, current) {
                if err = netlink.LinkDelAltName(link, current); err != nil {
                        klog.Errorf("failed to delete alternative name %s from link %s: %v", current, link.Attrs().Name, err)
                        return false, err
                }
        }

        return true, nil
}

1	package daemon
2
3	import (
4	"slices"
5	"time"
6
7	"github.com/vishvananda/netlink"
8	"k8s.io/klog/v2"
9	)
10
11	var routeScopeOrders = [...]netlink.Scope{
12	netlink.SCOPE_HOST,
13	netlink.SCOPE_LINK,
14	netlink.SCOPE_SITE,
15	netlink.SCOPE_UNIVERSE,
16	}
17
18	// wait systemd-networkd to finish interface configuration
19	func waitNetworkdConfiguration(linkIndex int) {	×
20	done := make(chan struct{})	×
21	ch := make(chan netlink.RouteUpdate)	×
22	if err := netlink.RouteSubscribe(ch, done); err != nil {	×
23	klog.Warningf("failed to subscribe route update events: %v", err)	×
24	klog.Info("Waiting 100ms ...")	×
25	time.Sleep(100 * time.Millisecond)	×
26	return	×
27	}	×
28
29	// wait route event on the link for 50ms
30	timer := time.NewTimer(50 * time.Millisecond)	×
31	for {	×
32	select {	×
33	case <-timer.C:	×
34	// timeout, interface configuration is expected to be completed	×
35	done <- struct{}{}	×
36	return	×
37	case event := <-ch:	×
38	if event.LinkIndex == linkIndex {	×
39	// received a route event on the link	×
40	// stop the timer	×
41	if !timer.Stop() {	×
42	<-timer.C	×
43	}	×
44	// reset the timer, wait for another 50ms
45	timer.Reset(50 * time.Millisecond)	×
46	}
47	}
48	}
49	}
50
NEW 51	func (c *Controller) changeProviderNicName(current, target string) (bool, error) {	×
52	link, err := netlink.LinkByName(current)	×
53	if err != nil {	×
54	if _, ok := err.(netlink.LinkNotFoundError); ok {	×
55	klog.Infof("link %s not found, skip", current)	×
56	return false, nil	×
57	}	×
58	klog.Errorf("failed to get link %s: %v", current, err)	×
59	return false, err	×
60	}
61	if link.Type() == "openvswitch" {	×
62	klog.V(3).Infof("%s is an openvswitch interface, skip", current)	×
63	return true, nil	×
64	}	×
65
66	addresses, err := netlink.AddrList(link, netlink.FAMILY_ALL)	×
67	if err != nil {	×
68	klog.Errorf("failed to list addresses of link %s: %v", current, err)	×
69	return false, err	×
70	}	×
71	routes, err := netlink.RouteList(link, netlink.FAMILY_ALL)	×
72	if err != nil {	×
73	klog.Errorf("failed to list routes of link %s: %v", current, err)	×
74	return false, err	×
75	}	×
76
77	// set link unmanaged by NetworkManager
78	if err = c.nmSyncer.SetManaged(current, false); err != nil {	×
79	klog.Errorf("failed to set device %s unmanaged by NetworkManager: %v", current, err)	×
80	return false, err	×
81	}	×
82
83	klog.Infof("renaming link %s as %s", current, target)	×
84	if err = netlink.LinkSetDown(link); err != nil {	×
85	klog.Errorf("failed to set link %s down: %v", current, err)	×
86	return false, err	×
87	}	×
88	if err = netlink.LinkSetName(link, target); err != nil {	×
89	klog.Errorf("failed to set name of link %s to %s: %v", current, target, err)	×
90	return false, err	×
91	}	×
92	if err = netlink.LinkSetUp(link); err != nil {	×
93	klog.Errorf("failed to set link %s up: %v", target, err)	×
94	return false, err	×
95	}	×
96	klog.Infof("link %s has been renamed as %s", current, target)	×
97		×
98	waitNetworkdConfiguration(link.Attrs().Index)	×
99		×
100	for _, addr := range addresses {	×
101	if addr.IP.IsLinkLocalUnicast() {	×
102	continue	×
103	}
104	addr.Label = ""	×
105	if err = netlink.AddrReplace(link, &addr); err != nil {	×
106	klog.Errorf("failed to replace address %q: %v", addr.String(), err)	×
107	return false, err	×
108	}	×
109	klog.Infof("address %q has been added/replaced to link %s", addr.String(), target)	×
110	}
111
112	for _, scope := range routeScopeOrders {	×
113	for _, route := range routes {	×
114	if route.Gw == nil && route.Dst != nil && route.Dst.IP.IsLinkLocalUnicast() {	×
115	continue	×
116	}
117	if route.Scope == scope {	×
118	if err = netlink.RouteReplace(&route); err != nil {	×
119	klog.Errorf("failed to replace route %q to %s: %v", route.String(), target, err)	×
120	return false, err	×
121	}	×
122	klog.Infof("route %q has been added/replaced to link %s", route.String(), target)	×
123	}
124	}
125	}
126
127	index := link.Attrs().Index	×
128	if link, err = netlink.LinkByIndex(index); err != nil {	×
129	klog.Errorf("failed to get link %s by index %d: %v", target, index, err)	×
130	return false, err	×
131	}	×
132
133	if slices.Contains(link.Attrs().AltNames, current) {	×
134	if err = netlink.LinkDelAltName(link, current); err != nil {	×
135	klog.Errorf("failed to delete alternative name %s from link %s: %v", current, link.Attrs().Name, err)	×
136	return false, err	×
137	}	×
138	}
139
140	return true, nil	×
141	}

kubeovn / kube-ovn / 21623048013

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