16043382967

Committed 03 Jul 2025 06:37AM UTC coverage: 21.561% (-0.001%) from 21.562%

Build # 16043382967

Build Type

Pull #5423

github

Committed by

zhangzujian

Commit Message

fix parsing resolv.conf when systemd-resolved is running on the host

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

Pull Request Pull Request #5423: fix parsing resolv.conf when systemd-resolved is running on the host

Run Details

0 of 3 new or added lines in 1 file covered. (0.0%)

3 existing lines in 2 files now uncovered.

10512 of 48754 relevant lines covered (21.56%)

0.25 hits per line

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

0.0

/pkg/daemon/exporter_metric.go

package daemon

import (
        "os"
        "os/exec"
        "strconv"
        "strings"

        "k8s.io/klog/v2"

        "github.com/docker/docker/libnetwork/resolvconf"
)

func (c *Controller) setIPLocalPortRangeMetric() {
        output, err := os.ReadFile("/proc/sys/net/ipv4/ip_local_port_range")
        if err != nil {
                klog.Errorf("failed to get value of ip_local_port_range, err %v", err)
                return
        }

        values := strings.Fields(string(output))
        if len(values) != 2 {
                klog.Errorf("unexpected ip_local_port_range value: %q", string(output))
                return
        }
        metricIPLocalPortRange.WithLabelValues(c.config.NodeName, values[0], values[1]).Set(1)
}

func (c *Controller) setCheckSumErrMetric() {
        cmdstr := "netstat -us"
        cmd := exec.Command("sh", "-c", cmdstr)
        output, err := cmd.CombinedOutput()
        if err != nil {
                klog.Errorf("failed to exec cmd 'netstat -us', err %v", err)
                return
        }

        found := false
        lines := strings.SplitSeq(string(output), "\n")
        for line := range lines {
                line = strings.TrimSpace(line)
                if line == "" {
                        continue
                }

                if strings.Contains(line, "InCsumErrors") {
                        values := strings.Split(line, ":")
                        if len(values) == 2 {
                                val, _ := strconv.Atoi(strings.TrimSpace(values[1]))
                                metricCheckSumErr.WithLabelValues(c.config.NodeName).Set(float64(val))
                                found = true
                        }
                }
        }
        if !found {
                metricCheckSumErr.WithLabelValues(c.config.NodeName).Set(float64(0))
        }
}

func (c *Controller) setDNSSearchMetric() {
        file, err := resolvconf.GetSpecific("/etc/resolv.conf")
        if err != nil {
                klog.Errorf("failed to get /etc/resolv.conf content: %v", err)
                return
        }
        domains := resolvconf.GetSearchDomains(file.Content)

        found := false
        for _, domain := range domains {
                if domain == "." {
                        // Ignore the root domain
                        continue
                }

                found = true
                metricDNSSearch.WithLabelValues(c.config.NodeName, domain).Set(1)
        }
        if !found {
                metricDNSSearch.WithLabelValues(c.config.NodeName, "no additional search domain").Set(1)
        }
}

func (c *Controller) setTCPTwRecycleMetric() {
        output, err := os.ReadFile("/proc/sys/net/ipv4/tcp_tw_recycle")
        if err != nil {
                if os.IsNotExist(err) {
                        return
                }
                klog.Errorf("failed to get value of tcp_tw_recycle, err %v", err)
                return
        }

        val, _ := strconv.Atoi(strings.TrimSpace(string(output)))
        metricTCPTwRecycle.WithLabelValues(c.config.NodeName).Set(float64(val))
}

func (c *Controller) setTCPMtuProbingMetric() {
        output, err := os.ReadFile("/proc/sys/net/ipv4/tcp_mtu_probing")
        if err != nil {
                if os.IsNotExist(err) {
                        return
                }
                klog.Errorf("failed to get value of tcp_mtu_probing, err %v", err)
                return
        }

        val, _ := strconv.Atoi(strings.TrimSpace(string(output)))
        metricTCPMtuProbing.WithLabelValues(c.config.NodeName).Set(float64(val))
}

func (c *Controller) setConntrackTCPLiberalMetric() {
        output, err := os.ReadFile("/proc/sys/net/netfilter/nf_conntrack_tcp_be_liberal")
        if err != nil {
                if os.IsNotExist(err) {
                        return
                }
                klog.Errorf("failed to get value of nf_conntrack_tcp_be_liberal, err %v", err)
                return
        }

        val, _ := strconv.Atoi(strings.TrimSpace(string(output)))
        metricConntrackTCPLiberal.WithLabelValues(c.config.NodeName).Set(float64(val))
}

func (c *Controller) setBridgeNfCallIptablesMetric() {
        output, err := os.ReadFile("/proc/sys/net/bridge/bridge-nf-call-iptables")
        if err != nil {
                if os.IsNotExist(err) {
                        return
                }
                klog.Errorf("failed to get value of bridge-nf-call-iptables, err %v", err)
                return
        }

        val, _ := strconv.Atoi(strings.TrimSpace(string(output)))
        metricBridgeNfCallIptables.WithLabelValues(c.config.NodeName).Set(float64(val))
}

func (c *Controller) setIPv6RouteMaxsizeMetric() {
        output, err := os.ReadFile("/proc/sys/net/ipv6/route/max_size")
        if err != nil {
                klog.Errorf("failed to get value of  ipv6 route max_size, err %v", err)
                return
        }

        val, _ := strconv.Atoi(strings.TrimSpace(string(output)))
        metricIPv6RouteMaxsize.WithLabelValues(c.config.NodeName).Set(float64(val))
}

func (c *Controller) setTCPMemMetric() {
        output, err := os.ReadFile("/proc/sys/net/ipv4/tcp_mem")
        if err != nil {
                if os.IsNotExist(err) {
                        return
                }
                klog.Errorf("failed to get value of ipv4 tcp_mem, err %v", err)
                return
        }

        values := strings.Fields(string(output))
        if len(values) != 3 {
                klog.Errorf("unexpected tcp_mem value: %q", string(output))
                return
        }
        metricTCPMem.WithLabelValues(c.config.NodeName, values[0], values[1], values[2]).Set(1)
}

1	package daemon
2
3	import (
4	"os"
5	"os/exec"
6	"strconv"
7	"strings"
8
9	"k8s.io/klog/v2"
10
11	"github.com/docker/docker/libnetwork/resolvconf"
12	)
13
14	func (c *Controller) setIPLocalPortRangeMetric() {	×
15	output, err := os.ReadFile("/proc/sys/net/ipv4/ip_local_port_range")	×
16	if err != nil {	×
17	klog.Errorf("failed to get value of ip_local_port_range, err %v", err)	×
18	return	×
19	}	×
20
21	values := strings.Fields(string(output))	×
22	if len(values) != 2 {	×
23	klog.Errorf("unexpected ip_local_port_range value: %q", string(output))	×
24	return	×
25	}	×
26	metricIPLocalPortRange.WithLabelValues(c.config.NodeName, values[0], values[1]).Set(1)	×
27	}
28
29	func (c *Controller) setCheckSumErrMetric() {	×
30	cmdstr := "netstat -us"	×
31	cmd := exec.Command("sh", "-c", cmdstr)	×
32	output, err := cmd.CombinedOutput()	×
33	if err != nil {	×
34	klog.Errorf("failed to exec cmd 'netstat -us', err %v", err)	×
35	return	×
36	}	×
37
38	found := false	×
39	lines := strings.SplitSeq(string(output), "\n")	×
40	for line := range lines {	×
41	line = strings.TrimSpace(line)	×
42	if line == "" {	×
43	continue	×
44	}
45
46	if strings.Contains(line, "InCsumErrors") {	×
47	values := strings.Split(line, ":")	×
48	if len(values) == 2 {	×
49	val, _ := strconv.Atoi(strings.TrimSpace(values[1]))	×
50	metricCheckSumErr.WithLabelValues(c.config.NodeName).Set(float64(val))	×
51	found = true	×
52	}	×
53	}
54	}
55	if !found {	×
56	metricCheckSumErr.WithLabelValues(c.config.NodeName).Set(float64(0))	×
57	}	×
58	}
59
60	func (c *Controller) setDNSSearchMetric() {	×
NEW 61	file, err := resolvconf.GetSpecific("/etc/resolv.conf")	×
62	if err != nil {	×
63	klog.Errorf("failed to get /etc/resolv.conf content: %v", err)	×
64	return	×
65	}	×
66	domains := resolvconf.GetSearchDomains(file.Content)	×
67		×
68	found := false	×
69	for _, domain := range domains {	×
NEW 70	if domain == "." {	×
NEW 71	// Ignore the root domain	×
UNCOV 72	continue	×
73	}
74
75	found = true	×
76	metricDNSSearch.WithLabelValues(c.config.NodeName, domain).Set(1)	×
77	}
78	if !found {	×
79	metricDNSSearch.WithLabelValues(c.config.NodeName, "no additional search domain").Set(1)	×
80	}	×
81	}
82
83	func (c *Controller) setTCPTwRecycleMetric() {	×
84	output, err := os.ReadFile("/proc/sys/net/ipv4/tcp_tw_recycle")	×
85	if err != nil {	×
86	if os.IsNotExist(err) {	×
87	return	×
88	}	×
89	klog.Errorf("failed to get value of tcp_tw_recycle, err %v", err)	×
90	return	×
91	}
92
93	val, _ := strconv.Atoi(strings.TrimSpace(string(output)))	×
94	metricTCPTwRecycle.WithLabelValues(c.config.NodeName).Set(float64(val))	×
95	}
96
97	func (c *Controller) setTCPMtuProbingMetric() {	×
98	output, err := os.ReadFile("/proc/sys/net/ipv4/tcp_mtu_probing")	×
99	if err != nil {	×
100	if os.IsNotExist(err) {	×
101	return	×
102	}	×
103	klog.Errorf("failed to get value of tcp_mtu_probing, err %v", err)	×
104	return	×
105	}
106
107	val, _ := strconv.Atoi(strings.TrimSpace(string(output)))	×
108	metricTCPMtuProbing.WithLabelValues(c.config.NodeName).Set(float64(val))	×
109	}
110
111	func (c *Controller) setConntrackTCPLiberalMetric() {	×
112	output, err := os.ReadFile("/proc/sys/net/netfilter/nf_conntrack_tcp_be_liberal")	×
113	if err != nil {	×
114	if os.IsNotExist(err) {	×
115	return	×
116	}	×
117	klog.Errorf("failed to get value of nf_conntrack_tcp_be_liberal, err %v", err)	×
118	return	×
119	}
120
121	val, _ := strconv.Atoi(strings.TrimSpace(string(output)))	×
122	metricConntrackTCPLiberal.WithLabelValues(c.config.NodeName).Set(float64(val))	×
123	}
124
125	func (c *Controller) setBridgeNfCallIptablesMetric() {	×
126	output, err := os.ReadFile("/proc/sys/net/bridge/bridge-nf-call-iptables")	×
127	if err != nil {	×
128	if os.IsNotExist(err) {	×
129	return	×
130	}	×
131	klog.Errorf("failed to get value of bridge-nf-call-iptables, err %v", err)	×
132	return	×
133	}
134
135	val, _ := strconv.Atoi(strings.TrimSpace(string(output)))	×
136	metricBridgeNfCallIptables.WithLabelValues(c.config.NodeName).Set(float64(val))	×
137	}
138
139	func (c *Controller) setIPv6RouteMaxsizeMetric() {	×
140	output, err := os.ReadFile("/proc/sys/net/ipv6/route/max_size")	×
141	if err != nil {	×
142	klog.Errorf("failed to get value of ipv6 route max_size, err %v", err)	×
143	return	×
144	}	×
145
146	val, _ := strconv.Atoi(strings.TrimSpace(string(output)))	×
147	metricIPv6RouteMaxsize.WithLabelValues(c.config.NodeName).Set(float64(val))	×
148	}
149
150	func (c *Controller) setTCPMemMetric() {	×
151	output, err := os.ReadFile("/proc/sys/net/ipv4/tcp_mem")	×
152	if err != nil {	×
153	if os.IsNotExist(err) {	×
154	return	×
155	}	×
156	klog.Errorf("failed to get value of ipv4 tcp_mem, err %v", err)	×
157	return	×
158	}
159
160	values := strings.Fields(string(output))	×
161	if len(values) != 3 {	×
162	klog.Errorf("unexpected tcp_mem value: %q", string(output))	×
163	return	×
164	}	×
165	metricTCPMem.WithLabelValues(c.config.NodeName, values[0], values[1], values[2]).Set(1)	×
166	}

kubeovn / kube-ovn / 16043382967

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