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/handler_linux.go

package daemon

import (
        "errors"
        "fmt"
        "io/fs"
        "os"
        "strings"
        "syscall"

        "github.com/moby/sys/mountinfo"
        "golang.org/x/sys/unix"
        v1 "k8s.io/api/core/v1"
        "k8s.io/klog/v2"

        "github.com/kubeovn/kube-ovn/pkg/request"
        "github.com/kubeovn/kube-ovn/pkg/util"
)

func (csh cniServerHandler) validatePodRequest(_ *request.CniRequest) error {
        // nothing to do on linux
        return nil
}

func createShortSharedDir(pod *v1.Pod, volumeName, socketConsumption, kubeletDir string) (err error) {
        var volume *v1.Volume
        for index, v := range pod.Spec.Volumes {
                if v.Name == volumeName {
                        volume = &pod.Spec.Volumes[index]
                        break
                }
        }
        if volume == nil {
                return fmt.Errorf("cannot find volume %s in pod %s", volumeName, pod.Name)
        }
        if volume.EmptyDir == nil {
                return fmt.Errorf("volume %s is not empty dir", volume.Name)
        }
        originSharedDir := fmt.Sprintf("%s/pods/%s/volumes/kubernetes.io~empty-dir/%s", kubeletDir, pod.UID, volumeName)
        newSharedDir := getShortSharedDir(pod.UID, volumeName)
        // set vhostuser dir 777 for qemu has the permission to create sock
        mask := syscall.Umask(0)
        defer syscall.Umask(mask)
        if _, err = os.Stat(newSharedDir); err != nil {
                if os.IsNotExist(err) {
                        err = os.MkdirAll(newSharedDir, 0o777) // #nosec G301
                        if err != nil {
                                klog.Error(err)
                                return fmt.Errorf("createShortSharedDir: Failed to create dir (%s): %w", newSharedDir, err)
                        }

                        if strings.Contains(newSharedDir, util.DefaultHostVhostuserBaseDir) {
                                klog.Infof("createShortSharedDir: Mount from %s to %s", originSharedDir, newSharedDir)
                                err = unix.Mount(originSharedDir, newSharedDir, "", unix.MS_BIND, "")
                                if err != nil {
                                        return fmt.Errorf("createShortSharedDir: Failed to bind mount: %w", err)
                                }
                        }
                        return nil
                }
                klog.Error(err)
                return err
        }

        if socketConsumption != util.ConsumptionKubevirt {
                return fmt.Errorf("createShortSharedDir: volume %s already exists", volumeName)
        }

        return nil
}

func removeShortSharedDir(pod *v1.Pod, volumeName, socketConsumption string) (err error) {
        sharedDir := getShortSharedDir(pod.UID, volumeName)
        if _, err = os.Stat(sharedDir); os.IsNotExist(err) {
                klog.Infof("shared directory %s does not exist to unmount, %s", sharedDir, err)
                return nil
        }

        // keep mount util dpdk sock not used by kubevirt
        if socketConsumption == util.ConsumptionKubevirt {
                files, err := os.ReadDir(sharedDir)
                if err != nil {
                        return fmt.Errorf("read file from dpdk share dir error: %w", err)
                }
                if len(files) != 0 {
                        return nil
                }
        }

        foundMount, err := mountinfo.Mounted(sharedDir)
        if errors.Is(err, fs.ErrNotExist) || (err == nil && !foundMount) {
                klog.Infof("volume: %s not mounted, no need to unmount", sharedDir)
                return nil
        }
        err = unix.Unmount(sharedDir, 0)
        if err != nil {
                klog.Errorf("Failed to unmount dir: %v", err)
                return err
        }
        err = os.Remove(sharedDir)
        if err != nil {
                klog.Errorf("Failed to remove dir: %v", err)
                return err
        }

        return nil
}

1	package daemon
2
3	import (
4	"errors"
5	"fmt"
6	"io/fs"
7	"os"
8	"strings"
9	"syscall"
10
11	"github.com/moby/sys/mountinfo"
12	"golang.org/x/sys/unix"
13	v1 "k8s.io/api/core/v1"
14	"k8s.io/klog/v2"
15
16	"github.com/kubeovn/kube-ovn/pkg/request"
17	"github.com/kubeovn/kube-ovn/pkg/util"
18	)
19
20	func (csh cniServerHandler) validatePodRequest(_ *request.CniRequest) error {	×
21	// nothing to do on linux	×
22	return nil	×
23	}	×
24
25	func createShortSharedDir(pod *v1.Pod, volumeName, socketConsumption, kubeletDir string) (err error) {	×
26	var volume *v1.Volume	×
27	for index, v := range pod.Spec.Volumes {	×
28	if v.Name == volumeName {	×
29	volume = &pod.Spec.Volumes[index]	×
30	break	×
31	}
32	}
33	if volume == nil {	×
NEW 34	return fmt.Errorf("cannot find volume %s in pod %s", volumeName, pod.Name)	×
35	}	×
36	if volume.EmptyDir == nil {	×
37	return fmt.Errorf("volume %s is not empty dir", volume.Name)	×
38	}	×
39	originSharedDir := fmt.Sprintf("%s/pods/%s/volumes/kubernetes.io~empty-dir/%s", kubeletDir, pod.UID, volumeName)	×
40	newSharedDir := getShortSharedDir(pod.UID, volumeName)	×
41	// set vhostuser dir 777 for qemu has the permission to create sock	×
42	mask := syscall.Umask(0)	×
43	defer syscall.Umask(mask)	×
44	if _, err = os.Stat(newSharedDir); err != nil {	×
45	if os.IsNotExist(err) {	×
46	err = os.MkdirAll(newSharedDir, 0o777) // #nosec G301	×
47	if err != nil {	×
48	klog.Error(err)	×
49	return fmt.Errorf("createShortSharedDir: Failed to create dir (%s): %w", newSharedDir, err)	×
50	}	×
51
52	if strings.Contains(newSharedDir, util.DefaultHostVhostuserBaseDir) {	×
53	klog.Infof("createShortSharedDir: Mount from %s to %s", originSharedDir, newSharedDir)	×
54	err = unix.Mount(originSharedDir, newSharedDir, "", unix.MS_BIND, "")	×
55	if err != nil {	×
56	return fmt.Errorf("createShortSharedDir: Failed to bind mount: %w", err)	×
57	}	×
58	}
59	return nil	×
60	}
61	klog.Error(err)	×
62	return err	×
63	}
64
65	if socketConsumption != util.ConsumptionKubevirt {	×
NEW 66	return fmt.Errorf("createShortSharedDir: volume %s already exists", volumeName)	×
67	}	×
68
69	return nil	×
70	}
71
72	func removeShortSharedDir(pod *v1.Pod, volumeName, socketConsumption string) (err error) {	×
73	sharedDir := getShortSharedDir(pod.UID, volumeName)	×
74	if _, err = os.Stat(sharedDir); os.IsNotExist(err) {	×
75	klog.Infof("shared directory %s does not exist to unmount, %s", sharedDir, err)	×
76	return nil	×
77	}	×
78
79	// keep mount util dpdk sock not used by kubevirt
80	if socketConsumption == util.ConsumptionKubevirt {	×
81	files, err := os.ReadDir(sharedDir)	×
82	if err != nil {	×
83	return fmt.Errorf("read file from dpdk share dir error: %w", err)	×
84	}	×
85	if len(files) != 0 {	×
86	return nil	×
87	}	×
88	}
89
90	foundMount, err := mountinfo.Mounted(sharedDir)	×
91	if errors.Is(err, fs.ErrNotExist) \|\| (err == nil && !foundMount) {	×
92	klog.Infof("volume: %s not mounted, no need to unmount", sharedDir)	×
93	return nil	×
94	}	×
95	err = unix.Unmount(sharedDir, 0)	×
96	if err != nil {	×
97	klog.Errorf("Failed to unmount dir: %v", err)	×
98	return err	×
99	}	×
100	err = os.Remove(sharedDir)	×
101	if err != nil {	×
102	klog.Errorf("Failed to remove dir: %v", err)	×
103	return err	×
104	}	×
105
106	return nil	×
107	}

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