intel / multus-cni / 546

Committed 13 Dec 2018 11:47AM UTC coverage: 52.463% (+0.04%) from 52.424%

Build # 546

Build Type

Pull #212

travis-ci

Committed by

web-flow

Commit Message

skip LoadNetworkStatus errors on empty Result

This fixes the issue described in #211 where LoadNetworkStatus is
throwing in errors if a delegate plugin returns empty Result that
contains in IPAM information.

This change will allow ignoreing the errors propagated from parsing
an empty Result and continue with next one.

Change-Id: Ife4b6103d

Pull Request Pull Request #212: skip LoadNetworkStatus errors on empty Result

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

639 of 1218 relevant lines covered (52.46%)

2.91 hits per line

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

54.61

/multus/multus.go

// Copyright (c) 2017 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// This is a "Multi-plugin".The delegate concept refered from CNI project
// It reads other plugin netconf, and then invoke them, e.g.
// flannel or sriov plugin.

package main

import (
        "encoding/json"
        "fmt"
        "io/ioutil"
        "net"
        "os"
        "path/filepath"
        "strings"
        "time"

        "github.com/containernetworking/cni/libcni"
        "github.com/containernetworking/cni/pkg/invoke"
        "github.com/containernetworking/cni/pkg/skel"
        cnitypes "github.com/containernetworking/cni/pkg/types"
        "github.com/containernetworking/cni/pkg/version"
        "github.com/containernetworking/plugins/pkg/ns"
        k8s "github.com/intel/multus-cni/k8sclient"
        "github.com/intel/multus-cni/logging"
        "github.com/intel/multus-cni/types"
        "github.com/vishvananda/netlink"
        "k8s.io/apimachinery/pkg/util/wait"
)

var defaultReadinessBackoff = wait.Backoff{
        Steps:    4,
        Duration: 250 * time.Millisecond,
        Factor:   4.0,
        Jitter:   0.1,
}

func saveScratchNetConf(containerID, dataDir string, netconf []byte) error {
        logging.Debugf("saveScratchNetConf: %s, %s, %s", containerID, dataDir, string(netconf))
        if err := os.MkdirAll(dataDir, 0700); err != nil {
                return logging.Errorf("failed to create the multus data directory(%q): %v", dataDir, err)
        }

        path := filepath.Join(dataDir, containerID)

        err := ioutil.WriteFile(path, netconf, 0600)
        if err != nil {
                return logging.Errorf("failed to write container data in the path(%q): %v", path, err)
        }

        return err
}

func consumeScratchNetConf(containerID, dataDir string) ([]byte, error) {
        logging.Debugf("consumeScratchNetConf: %s, %s", containerID, dataDir)
        path := filepath.Join(dataDir, containerID)
        defer os.Remove(path)

        return ioutil.ReadFile(path)
}

func getIfname(delegate *types.DelegateNetConf, argif string, idx int) string {
        logging.Debugf("getIfname: %v, %s, %d", delegate, argif, idx)
        if delegate.IfnameRequest != "" {
                return delegate.IfnameRequest
        }
        if delegate.MasterPlugin {
                // master plugin always uses the CNI-provided interface name
                return argif
        }

        // Otherwise construct a unique interface name from the delegate's
        // position in the delegate list
        return fmt.Sprintf("net%d", idx)
}

func saveDelegates(containerID, dataDir string, delegates []*types.DelegateNetConf) error {
        logging.Debugf("saveDelegates: %s, %s, %v", containerID, dataDir, delegates)
        delegatesBytes, err := json.Marshal(delegates)
        if err != nil {
                return logging.Errorf("error serializing delegate netconf: %v", err)
        }

        if err = saveScratchNetConf(containerID, dataDir, delegatesBytes); err != nil {
                return logging.Errorf("error in saving the  delegates : %v", err)
        }

        return err
}

func validateIfName(nsname string, ifname string) error {
        logging.Debugf("validateIfName: %s, %s", nsname, ifname)
        podNs, err := ns.GetNS(nsname)
        if err != nil {
                return logging.Errorf("no netns: %v", err)
        }

        err = podNs.Do(func(_ ns.NetNS) error {
                _, err := netlink.LinkByName(ifname)
                if err != nil {
                        if err.Error() == "Link not found" {
                                return nil
                        }
                        return err
                }
                return logging.Errorf("ifname %s is already exist", ifname)
        })

        return err
}

func conflistAdd(rt *libcni.RuntimeConf, rawnetconflist []byte, binDir string, exec invoke.Exec) (cnitypes.Result, error) {
        logging.Debugf("conflistAdd: %v, %s, %s", rt, string(rawnetconflist), binDir)
        // In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go
        binDirs := filepath.SplitList(os.Getenv("CNI_PATH"))
        binDirs = append(binDirs, binDir)
        cniNet := libcni.NewCNIConfig(binDirs, exec)

        confList, err := libcni.ConfListFromBytes(rawnetconflist)
        if err != nil {
                return nil, logging.Errorf("error in converting the raw bytes to conflist: %v", err)
        }

        result, err := cniNet.AddNetworkList(confList, rt)
        if err != nil {
                return nil, logging.Errorf("error in getting result from AddNetworkList: %v", err)
        }

        return result, nil
}

func conflistDel(rt *libcni.RuntimeConf, rawnetconflist []byte, binDir string, exec invoke.Exec) error {
        logging.Debugf("conflistDel: %v, %s, %s", rt, string(rawnetconflist), binDir)
        // In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go
        binDirs := filepath.SplitList(os.Getenv("CNI_PATH"))
        binDirs = append(binDirs, binDir)
        cniNet := libcni.NewCNIConfig(binDirs, exec)

        confList, err := libcni.ConfListFromBytes(rawnetconflist)
        if err != nil {
                return logging.Errorf("error in converting the raw bytes to conflist: %v", err)
        }

        err = cniNet.DelNetworkList(confList, rt)
        if err != nil {
                return logging.Errorf("error in getting result from DelNetworkList: %v", err)
        }

        return err
}

func delegateAdd(exec invoke.Exec, ifName string, delegate *types.DelegateNetConf, rt *libcni.RuntimeConf, binDir string, cniArgs string) (cnitypes.Result, error) {
        logging.Debugf("delegateAdd: %v, %s, %v, %v, %s", exec, ifName, delegate, rt, binDir)
        if os.Setenv("CNI_IFNAME", ifName) != nil {
                return nil, logging.Errorf("Multus: error in setting CNI_IFNAME")
        }

        if err := validateIfName(os.Getenv("CNI_NETNS"), ifName); err != nil {
                return nil, logging.Errorf("cannot set %q ifname to %q: %v", delegate.Conf.Type, ifName, err)
        }

        if delegate.MacRequest != "" || delegate.IPRequest != "" {
                if cniArgs != "" {
                        cniArgs = fmt.Sprintf("%s;IgnoreUnknown=true", cniArgs)
                } else {
                        cniArgs = "IgnoreUnknown=true"
                }
                if delegate.MacRequest != "" {
                        // validate Mac address
                        _, err := net.ParseMAC(delegate.MacRequest)
                        if err != nil {
                                return nil, logging.Errorf("failed to parse mac address %q", delegate.MacRequest)
                        }

                        cniArgs = fmt.Sprintf("%s;MAC=%s", cniArgs, delegate.MacRequest)
                        logging.Debugf("Set MAC address %q to %q", delegate.MacRequest, ifName)
                }

                if delegate.IPRequest != "" {
                        // validate IP address
                        if strings.Contains(delegate.IPRequest, "/") {
                                _, _, err := net.ParseCIDR(delegate.IPRequest)
                                if err != nil {
                                        return nil, logging.Errorf("failed to parse CIDR %q", delegate.MacRequest)
                                }
                        } else if net.ParseIP(delegate.IPRequest) == nil {
                                return nil, logging.Errorf("failed to parse IP address %q", delegate.IPRequest)
                        }

                        cniArgs = fmt.Sprintf("%s;IP=%s", cniArgs, delegate.IPRequest)
                        logging.Debugf("Set IP address %q to %q", delegate.IPRequest, ifName)
                }
                if os.Setenv("CNI_ARGS", cniArgs) != nil {
                        return nil, logging.Errorf("cannot set %q mac to %q and ip to %q", delegate.Conf.Type, delegate.MacRequest, delegate.IPRequest)
                }
        }

        if delegate.ConfListPlugin != false {
                result, err := conflistAdd(rt, delegate.Bytes, binDir, exec)
                if err != nil {
                        return nil, logging.Errorf("Multus: error in invoke Conflist add - %q: %v", delegate.ConfList.Name, err)
                }

                return result, nil
        }

        result, err := invoke.DelegateAdd(delegate.Conf.Type, delegate.Bytes, exec)
        if err != nil {
                return nil, logging.Errorf("Multus: error in invoke Delegate add - %q: %v", delegate.Conf.Type, err)
        }

        return result, nil
}

func delegateDel(exec invoke.Exec, ifName string, delegateConf *types.DelegateNetConf, rt *libcni.RuntimeConf, binDir string) error {
        logging.Debugf("delegateDel: %v, %s, %v, %v, %s", exec, ifName, delegateConf, rt, binDir)
        if os.Setenv("CNI_IFNAME", ifName) != nil {
                return logging.Errorf("Multus: error in setting CNI_IFNAME")
        }

        if delegateConf.ConfListPlugin != false {
                err := conflistDel(rt, delegateConf.Bytes, binDir, exec)
                if err != nil {
                        return logging.Errorf("Multus: error in invoke Conflist Del - %q: %v", delegateConf.ConfList.Name, err)
                }

                return err
        }

        if err := invoke.DelegateDel(delegateConf.Conf.Type, delegateConf.Bytes, exec); err != nil {
                return logging.Errorf("Multus: error in invoke Delegate del - %q: %v", delegateConf.Conf.Type, err)
        }

        return nil
}

func delPlugins(exec invoke.Exec, argIfname string, delegates []*types.DelegateNetConf, lastIdx int, rt *libcni.RuntimeConf, binDir string) error {
        logging.Debugf("delPlugins: %v, %s, %v, %d, %v, %s", exec, argIfname, delegates, lastIdx, rt, binDir)
        if os.Setenv("CNI_COMMAND", "DEL") != nil {
                return logging.Errorf("Multus: error in setting CNI_COMMAND to DEL")
        }

        var errorstrings []string
        for idx := lastIdx; idx >= 0; idx-- {
                ifName := getIfname(delegates[idx], argIfname, idx)
                rt.IfName = ifName
                // Attempt to delete all but do not error out, instead, collect all errors.
                if err := delegateDel(exec, ifName, delegates[idx], rt, binDir); err != nil {
                        errorstrings = append(errorstrings, err.Error())
                }
        }

        // Check if we had any errors, and send them all back.
        if len(errorstrings) > 0 {
                return fmt.Errorf(strings.Join(errorstrings, " / "))
        }

        return nil
}

func cmdAdd(args *skel.CmdArgs, exec invoke.Exec, kubeClient k8s.KubeClient) (cnitypes.Result, error) {
        logging.Debugf("cmdAdd: %v, %v, %v", args, exec, kubeClient)
        n, err := types.LoadNetConf(args.StdinData)
        if err != nil {
                return nil, logging.Errorf("err in loading netconf: %v", err)
        }

        k8sArgs, err := k8s.GetK8sArgs(args)
        if err != nil {
                return nil, logging.Errorf("Multus: Err in getting k8s args: %v", err)
        }

        wait.ExponentialBackoff(defaultReadinessBackoff, func() (bool, error) {
                _, err := os.Stat(n.ReadinessIndicatorFile)
                switch {
                case err == nil:
                        return true, nil
                default:
                        return false, nil
                }
        })

        if n.ClusterNetwork != "" {
                err = k8s.GetDefaultNetworks(k8sArgs, n, kubeClient)
                if err != nil {
                        return nil, logging.Errorf("Multus: Failed to get clusterNetwork/defaultNetworks: %v", err)
                }
                // First delegate is always the master plugin
                n.Delegates[0].MasterPlugin = true
        }

        numK8sDelegates, kc, err := k8s.TryLoadPodDelegates(k8sArgs, n, kubeClient)
        if err != nil {
                return nil, logging.Errorf("Multus: Err in loading K8s Delegates k8s args: %v", err)
        }

        if numK8sDelegates == 0 {
                // cache the multus config if we have only Multus delegates
                if err := saveDelegates(args.ContainerID, n.CNIDir, n.Delegates); err != nil {
                        return nil, logging.Errorf("Multus: Err in saving the delegates: %v", err)
                }
        }

        var result, tmpResult cnitypes.Result
        var netStatus []*types.NetworkStatus
        var rt *libcni.RuntimeConf
        lastIdx := 0
        cniArgs := os.Getenv("CNI_ARGS")
        for idx, delegate := range n.Delegates {
                lastIdx = idx
                ifName := getIfname(delegate, args.IfName, idx)
                rt, _ = types.LoadCNIRuntimeConf(args, k8sArgs, ifName, n.RuntimeConfig)
                tmpResult, err = delegateAdd(exec, ifName, delegate, rt, n.BinDir, cniArgs)
                if err != nil {
                        break
                }

                // Master plugin result is always used if present
                if delegate.MasterPlugin || result == nil {
                        result = tmpResult
                }

                //create the network status, only in case Multus as kubeconfig
                if n.Kubeconfig != "" && kc != nil {
                        if kc.Podnamespace != "kube-system" {
                                delegateNetStatus, err := types.LoadNetworkStatus(tmpResult, delegate.Conf.Name, delegate.MasterPlugin)
                                if err == nil {
                                        netStatus = append(netStatus, delegateNetStatus)
                                } else {
                                        logging.Debugf("Multus: unable to load networks status from delegate plugin %s: %v", delegate.Conf.Name, err)
                                }
                        }
                }
        }

        if err != nil {
                // Ignore errors; DEL must be idempotent anyway
                _ = delPlugins(exec, args.IfName, n.Delegates, lastIdx, rt, n.BinDir)
                return nil, logging.Errorf("Multus: Err in tearing down failed plugins: %v", err)
        }

        //set the network status annotation in apiserver, only in case Multus as kubeconfig
        if n.Kubeconfig != "" && kc != nil {
                if kc.Podnamespace != "kube-system" {
                        err = k8s.SetNetworkStatus(kc, netStatus)
                        if err != nil {
                                return nil, logging.Errorf("Multus: Err set the networks status: %v", err)
                        }
                }
        }

        return result, nil
}

func cmdGet(args *skel.CmdArgs, exec invoke.Exec, kubeClient k8s.KubeClient) (cnitypes.Result, error) {
        logging.Debugf("cmdGet: %v, %v, %v", args, exec, kubeClient)
        in, err := types.LoadNetConf(args.StdinData)
        if err != nil {
                return nil, err
        }

        // FIXME: call all delegates

        return in.PrevResult, nil
}

func cmdDel(args *skel.CmdArgs, exec invoke.Exec, kubeClient k8s.KubeClient) error {
        logging.Debugf("cmdDel: %v, %v, %v", args, exec, kubeClient)
        in, err := types.LoadNetConf(args.StdinData)
        if err != nil {
                return err
        }

        if args.Netns == "" {
                return nil
        }
        netns, err := ns.GetNS(args.Netns)
        if err != nil {
                //  if NetNs is passed down by the Cloud Orchestration Engine, or if it called multiple times
                // so don't return an error if the device is already removed.
                // https://github.com/kubernetes/kubernetes/issues/43014#issuecomment-287164444
                _, ok := err.(ns.NSPathNotExistErr)
                if ok {
                        return nil
                }
                return fmt.Errorf("failed to open netns %q: %v", netns, err)
        }
        defer netns.Close()

        k8sArgs, err := k8s.GetK8sArgs(args)
        if err != nil {
                return logging.Errorf("Multus: Err in getting k8s args: %v", err)
        }

        numK8sDelegates, kc, err := k8s.TryLoadPodDelegates(k8sArgs, in, kubeClient)
        if err != nil {
                return err
        }

        if numK8sDelegates == 0 {
                // re-read the scratch multus config if we have only Multus delegates
                netconfBytes, err := consumeScratchNetConf(args.ContainerID, in.CNIDir)
                if err != nil {
                        if os.IsNotExist(err) {
                                // Per spec should ignore error if resources are missing / already removed
                                return nil
                        }
                        return logging.Errorf("Multus: Err in  reading the delegates: %v", err)
                }

                if err := json.Unmarshal(netconfBytes, &in.Delegates); err != nil {
                        return logging.Errorf("Multus: failed to load netconf: %v", err)
                }
        }

        //unset the network status annotation in apiserver, only in case Multus as kubeconfig
        if in.Kubeconfig != "" && kc != nil {
                if kc.Podnamespace != "kube-system" {
                        err := k8s.SetNetworkStatus(kc, nil)
                        if err != nil {
                                return logging.Errorf("Multus: Err unset the networks status: %v", err)
                        }
                }
        }

        rt, _ := types.LoadCNIRuntimeConf(args, k8sArgs, "", in.RuntimeConfig)
        return delPlugins(exec, args.IfName, in.Delegates, len(in.Delegates)-1, rt, in.BinDir)
}

func main() {
        skel.PluginMain(
                func(args *skel.CmdArgs) error {
                        result, err := cmdAdd(args, nil, nil)
                        if err != nil {
                                return err
                        }
                        return result.Print()
                },
                func(args *skel.CmdArgs) error {
                        result, err := cmdGet(args, nil, nil)
                        if err != nil {
                                return err
                        }
                        return result.Print()
                },
                func(args *skel.CmdArgs) error { return cmdDel(args, nil, nil) },
                version.All, "meta-plugin that delegates to other CNI plugins")
}

1	// Copyright (c) 2017 Intel Corporation
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	// This is a "Multi-plugin".The delegate concept refered from CNI project
16	// It reads other plugin netconf, and then invoke them, e.g.
17	// flannel or sriov plugin.
18
19	package main
20
21	import (
22	"encoding/json"
23	"fmt"
24	"io/ioutil"
25	"net"
26	"os"
27	"path/filepath"
28	"strings"
29	"time"
30
31	"github.com/containernetworking/cni/libcni"
32	"github.com/containernetworking/cni/pkg/invoke"
33	"github.com/containernetworking/cni/pkg/skel"
34	cnitypes "github.com/containernetworking/cni/pkg/types"
35	"github.com/containernetworking/cni/pkg/version"
36	"github.com/containernetworking/plugins/pkg/ns"
37	k8s "github.com/intel/multus-cni/k8sclient"
38	"github.com/intel/multus-cni/logging"
39	"github.com/intel/multus-cni/types"
40	"github.com/vishvananda/netlink"
41	"k8s.io/apimachinery/pkg/util/wait"
42	)
43
44	var defaultReadinessBackoff = wait.Backoff{
45	Steps: 4,
46	Duration: 250 * time.Millisecond,
47	Factor: 4.0,
48	Jitter: 0.1,
49	}
50
51	func saveScratchNetConf(containerID, dataDir string, netconf []byte) error {	2✔
52	logging.Debugf("saveScratchNetConf: %s, %s, %s", containerID, dataDir, string(netconf))	2✔
53	if err := os.MkdirAll(dataDir, 0700); err != nil {	2✔
54	return logging.Errorf("failed to create the multus data directory(%q): %v", dataDir, err)	×
55	}	×
56
57	path := filepath.Join(dataDir, containerID)	2✔
58		2✔
59	err := ioutil.WriteFile(path, netconf, 0600)	2✔
60	if err != nil {	2✔
61	return logging.Errorf("failed to write container data in the path(%q): %v", path, err)	×
62	}	×
63
64	return err	2✔
65	}
66
67	func consumeScratchNetConf(containerID, dataDir string) ([]byte, error) {	1✔
68	logging.Debugf("consumeScratchNetConf: %s, %s", containerID, dataDir)	1✔
69	path := filepath.Join(dataDir, containerID)	1✔
70	defer os.Remove(path)	1✔
71		1✔
72	return ioutil.ReadFile(path)	1✔
73	}	1✔
74
75	func getIfname(delegate *types.DelegateNetConf, argif string, idx int) string {	11✔
76	logging.Debugf("getIfname: %v, %s, %d", delegate, argif, idx)	11✔
77	if delegate.IfnameRequest != "" {	12✔
78	return delegate.IfnameRequest	1✔
79	}	1✔
80	if delegate.MasterPlugin {	15✔
81	// master plugin always uses the CNI-provided interface name	5✔
82	return argif	5✔
83	}	5✔
84
85	// Otherwise construct a unique interface name from the delegate's
86	// position in the delegate list
87	return fmt.Sprintf("net%d", idx)	5✔
88	}
89
90	func saveDelegates(containerID, dataDir string, delegates []*types.DelegateNetConf) error {	2✔
91	logging.Debugf("saveDelegates: %s, %s, %v", containerID, dataDir, delegates)	2✔
92	delegatesBytes, err := json.Marshal(delegates)	2✔
93	if err != nil {	2✔
94	return logging.Errorf("error serializing delegate netconf: %v", err)	×
95	}	×
96
97	if err = saveScratchNetConf(containerID, dataDir, delegatesBytes); err != nil {	2✔
98	return logging.Errorf("error in saving the delegates : %v", err)	×
99	}	×
100
101	return err	2✔
102	}
103
104	func validateIfName(nsname string, ifname string) error {	9✔
105	logging.Debugf("validateIfName: %s, %s", nsname, ifname)	9✔
106	podNs, err := ns.GetNS(nsname)	9✔
107	if err != nil {	9✔
108	return logging.Errorf("no netns: %v", err)	×
109	}	×
110
111	err = podNs.Do(func(_ ns.NetNS) error {	18✔
112	_, err := netlink.LinkByName(ifname)	9✔
113	if err != nil {	18✔
114	if err.Error() == "Link not found" {	18✔
115	return nil	9✔
116	}	9✔
117	return err	×
118	}
119	return logging.Errorf("ifname %s is already exist", ifname)	×
120	})
121
122	return err	9✔
123	}
124
125	func conflistAdd(rt *libcni.RuntimeConf, rawnetconflist []byte, binDir string, exec invoke.Exec) (cnitypes.Result, error) {	1✔
126	logging.Debugf("conflistAdd: %v, %s, %s", rt, string(rawnetconflist), binDir)	1✔
127	// In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go	1✔
128	binDirs := filepath.SplitList(os.Getenv("CNI_PATH"))	1✔
129	binDirs = append(binDirs, binDir)	1✔
130	cniNet := libcni.NewCNIConfig(binDirs, exec)	1✔
131		1✔
132	confList, err := libcni.ConfListFromBytes(rawnetconflist)	1✔
133	if err != nil {	1✔
134	return nil, logging.Errorf("error in converting the raw bytes to conflist: %v", err)	×
135	}	×
136
137	result, err := cniNet.AddNetworkList(confList, rt)	1✔
138	if err != nil {	1✔
139	return nil, logging.Errorf("error in getting result from AddNetworkList: %v", err)	×
140	}	×
141
142	return result, nil	1✔
143	}
144
145	func conflistDel(rt *libcni.RuntimeConf, rawnetconflist []byte, binDir string, exec invoke.Exec) error {	×
146	logging.Debugf("conflistDel: %v, %s, %s", rt, string(rawnetconflist), binDir)	×
147	// In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go	×
148	binDirs := filepath.SplitList(os.Getenv("CNI_PATH"))	×
149	binDirs = append(binDirs, binDir)	×
150	cniNet := libcni.NewCNIConfig(binDirs, exec)	×
151		×
152	confList, err := libcni.ConfListFromBytes(rawnetconflist)	×
153	if err != nil {	×
154	return logging.Errorf("error in converting the raw bytes to conflist: %v", err)	×
155	}	×
156
157	err = cniNet.DelNetworkList(confList, rt)	×
158	if err != nil {	×
159	return logging.Errorf("error in getting result from DelNetworkList: %v", err)	×
160	}	×
161
162	return err	×
163	}
164
165	func delegateAdd(exec invoke.Exec, ifName string, delegate types.DelegateNetConf, rt libcni.RuntimeConf, binDir string, cniArgs string) (cnitypes.Result, error) {	9✔
166	logging.Debugf("delegateAdd: %v, %s, %v, %v, %s", exec, ifName, delegate, rt, binDir)	9✔
167	if os.Setenv("CNI_IFNAME", ifName) != nil {	9✔
168	return nil, logging.Errorf("Multus: error in setting CNI_IFNAME")	×
169	}	×
170
171	if err := validateIfName(os.Getenv("CNI_NETNS"), ifName); err != nil {	9✔
172	return nil, logging.Errorf("cannot set %q ifname to %q: %v", delegate.Conf.Type, ifName, err)	×
173	}	×
174
175	if delegate.MacRequest != "" \|\| delegate.IPRequest != "" {	11✔
176	if cniArgs != "" {	2✔
177	cniArgs = fmt.Sprintf("%s;IgnoreUnknown=true", cniArgs)	×
178	} else {	2✔
179	cniArgs = "IgnoreUnknown=true"	2✔
180	}	2✔
181	if delegate.MacRequest != "" {	3✔
182	// validate Mac address	1✔
183	_, err := net.ParseMAC(delegate.MacRequest)	1✔
184	if err != nil {	1✔
185	return nil, logging.Errorf("failed to parse mac address %q", delegate.MacRequest)	×
186	}	×
187
188	cniArgs = fmt.Sprintf("%s;MAC=%s", cniArgs, delegate.MacRequest)	1✔
189	logging.Debugf("Set MAC address %q to %q", delegate.MacRequest, ifName)	1✔
190	}
191
192	if delegate.IPRequest != "" {	4✔
193	// validate IP address	2✔
194	if strings.Contains(delegate.IPRequest, "/") {	3✔
195	_, _, err := net.ParseCIDR(delegate.IPRequest)	1✔
196	if err != nil {	1✔
197	return nil, logging.Errorf("failed to parse CIDR %q", delegate.MacRequest)	×
198	}	×
199	} else if net.ParseIP(delegate.IPRequest) == nil {	1✔
200	return nil, logging.Errorf("failed to parse IP address %q", delegate.IPRequest)	×
201	}	×
202
203	cniArgs = fmt.Sprintf("%s;IP=%s", cniArgs, delegate.IPRequest)	2✔
204	logging.Debugf("Set IP address %q to %q", delegate.IPRequest, ifName)	2✔
205	}
206	if os.Setenv("CNI_ARGS", cniArgs) != nil {	2✔
207	return nil, logging.Errorf("cannot set %q mac to %q and ip to %q", delegate.Conf.Type, delegate.MacRequest, delegate.IPRequest)	×
208	}	×
209	}
210
211	if delegate.ConfListPlugin != false {	10✔
212	result, err := conflistAdd(rt, delegate.Bytes, binDir, exec)	1✔
213	if err != nil {	1✔
214	return nil, logging.Errorf("Multus: error in invoke Conflist add - %q: %v", delegate.ConfList.Name, err)	×
215	}	×
216
217	return result, nil	1✔
218	}
219
220	result, err := invoke.DelegateAdd(delegate.Conf.Type, delegate.Bytes, exec)	8✔
221	if err != nil {	8✔
222	return nil, logging.Errorf("Multus: error in invoke Delegate add - %q: %v", delegate.Conf.Type, err)	×
223	}	×
224
225	return result, nil	8✔
226	}
227
228	func delegateDel(exec invoke.Exec, ifName string, delegateConf types.DelegateNetConf, rt libcni.RuntimeConf, binDir string) error {	2✔
229	logging.Debugf("delegateDel: %v, %s, %v, %v, %s", exec, ifName, delegateConf, rt, binDir)	2✔
230	if os.Setenv("CNI_IFNAME", ifName) != nil {	2✔
231	return logging.Errorf("Multus: error in setting CNI_IFNAME")	×
232	}	×
233
234	if delegateConf.ConfListPlugin != false {	2✔
235	err := conflistDel(rt, delegateConf.Bytes, binDir, exec)	×
236	if err != nil {	×
237	return logging.Errorf("Multus: error in invoke Conflist Del - %q: %v", delegateConf.ConfList.Name, err)	×
238	}	×
239
240	return err	×
241	}
242
243	if err := invoke.DelegateDel(delegateConf.Conf.Type, delegateConf.Bytes, exec); err != nil {	2✔
244	return logging.Errorf("Multus: error in invoke Delegate del - %q: %v", delegateConf.Conf.Type, err)	×
245	}	×
246
247	return nil	2✔
248	}
249
250	func delPlugins(exec invoke.Exec, argIfname string, delegates []types.DelegateNetConf, lastIdx int, rt libcni.RuntimeConf, binDir string) error {	1✔
251	logging.Debugf("delPlugins: %v, %s, %v, %d, %v, %s", exec, argIfname, delegates, lastIdx, rt, binDir)	1✔
252	if os.Setenv("CNI_COMMAND", "DEL") != nil {	1✔
253	return logging.Errorf("Multus: error in setting CNI_COMMAND to DEL")	×
254	}	×
255
256	var errorstrings []string	1✔
257	for idx := lastIdx; idx >= 0; idx-- {	3✔
258	ifName := getIfname(delegates[idx], argIfname, idx)	2✔
259	rt.IfName = ifName	2✔
260	// Attempt to delete all but do not error out, instead, collect all errors.	2✔
261	if err := delegateDel(exec, ifName, delegates[idx], rt, binDir); err != nil {	2✔
262	errorstrings = append(errorstrings, err.Error())	×
263	}	×
264	}
265
266	// Check if we had any errors, and send them all back.
267	if len(errorstrings) > 0 {	1✔
268	return fmt.Errorf(strings.Join(errorstrings, " / "))	×
269	}	×
270
271	return nil	1✔
272	}
273
274	func cmdAdd(args *skel.CmdArgs, exec invoke.Exec, kubeClient k8s.KubeClient) (cnitypes.Result, error) {	4✔
275	logging.Debugf("cmdAdd: %v, %v, %v", args, exec, kubeClient)	4✔
276	n, err := types.LoadNetConf(args.StdinData)	4✔
277	if err != nil {	4✔
278	return nil, logging.Errorf("err in loading netconf: %v", err)	×
279	}	×
280
281	k8sArgs, err := k8s.GetK8sArgs(args)	4✔
282	if err != nil {	4✔
283	return nil, logging.Errorf("Multus: Err in getting k8s args: %v", err)	×
284	}	×
285
286	wait.ExponentialBackoff(defaultReadinessBackoff, func() (bool, error) {	20✔
287	_, err := os.Stat(n.ReadinessIndicatorFile)	16✔
288	switch {	16✔
289	case err == nil:	×
290	return true, nil	×
291	default:	16✔
292	return false, nil	16✔
293	}
294	})
295
296	if n.ClusterNetwork != "" {	4✔
297	err = k8s.GetDefaultNetworks(k8sArgs, n, kubeClient)	×
298	if err != nil {	×
299	return nil, logging.Errorf("Multus: Failed to get clusterNetwork/defaultNetworks: %v", err)	×
300	}	×
301	// First delegate is always the master plugin
302	n.Delegates[0].MasterPlugin = true	×
303	}
304
305	numK8sDelegates, kc, err := k8s.TryLoadPodDelegates(k8sArgs, n, kubeClient)	4✔
306	if err != nil {	4✔
307	return nil, logging.Errorf("Multus: Err in loading K8s Delegates k8s args: %v", err)	×
308	}	×
309
310	if numK8sDelegates == 0 {	6✔
311	// cache the multus config if we have only Multus delegates	2✔
312	if err := saveDelegates(args.ContainerID, n.CNIDir, n.Delegates); err != nil {	2✔
313	return nil, logging.Errorf("Multus: Err in saving the delegates: %v", err)	×
314	}	×
315	}
316
317	var result, tmpResult cnitypes.Result	4✔
318	var netStatus []*types.NetworkStatus	4✔
319	var rt *libcni.RuntimeConf	4✔
320	lastIdx := 0	4✔
321	cniArgs := os.Getenv("CNI_ARGS")	4✔
322	for idx, delegate := range n.Delegates {	13✔
323	lastIdx = idx	9✔
324	ifName := getIfname(delegate, args.IfName, idx)	9✔
325	rt, _ = types.LoadCNIRuntimeConf(args, k8sArgs, ifName, n.RuntimeConfig)	9✔
326	tmpResult, err = delegateAdd(exec, ifName, delegate, rt, n.BinDir, cniArgs)	9✔
327	if err != nil {	9✔
328	break	×
329	}
330
331	// Master plugin result is always used if present
332	if delegate.MasterPlugin \|\| result == nil {	13✔
333	result = tmpResult	4✔
334	}	4✔
335
336	//create the network status, only in case Multus as kubeconfig
337	if n.Kubeconfig != "" && kc != nil {	15✔
338	if kc.Podnamespace != "kube-system" {	12✔
339	delegateNetStatus, err := types.LoadNetworkStatus(tmpResult, delegate.Conf.Name, delegate.MasterPlugin)	6✔
340	if err == nil {	12✔
341	netStatus = append(netStatus, delegateNetStatus)	6✔
342	} else {	6✔
343	logging.Debugf("Multus: unable to load networks status from delegate plugin %s: %v", delegate.Conf.Name, err)	×
344	}	×
345	}
346	}
347	}
348
349	if err != nil {	4✔
350	// Ignore errors; DEL must be idempotent anyway	×
351	_ = delPlugins(exec, args.IfName, n.Delegates, lastIdx, rt, n.BinDir)	×
352	return nil, logging.Errorf("Multus: Err in tearing down failed plugins: %v", err)	×
353	}	×
354
355	//set the network status annotation in apiserver, only in case Multus as kubeconfig
356	if n.Kubeconfig != "" && kc != nil {	6✔
357	if kc.Podnamespace != "kube-system" {	4✔
358	err = k8s.SetNetworkStatus(kc, netStatus)	2✔
359	if err != nil {	2✔
360	return nil, logging.Errorf("Multus: Err set the networks status: %v", err)	×
361	}	×
362	}
363	}
364
365	return result, nil	4✔
366	}
367
368	func cmdGet(args *skel.CmdArgs, exec invoke.Exec, kubeClient k8s.KubeClient) (cnitypes.Result, error) {	×
369	logging.Debugf("cmdGet: %v, %v, %v", args, exec, kubeClient)	×
370	in, err := types.LoadNetConf(args.StdinData)	×
371	if err != nil {	×
372	return nil, err	×
373	}	×
374
375	// FIXME: call all delegates
376
377	return in.PrevResult, nil	×
378	}
379
380	func cmdDel(args *skel.CmdArgs, exec invoke.Exec, kubeClient k8s.KubeClient) error {	1✔
381	logging.Debugf("cmdDel: %v, %v, %v", args, exec, kubeClient)	1✔
382	in, err := types.LoadNetConf(args.StdinData)	1✔
383	if err != nil {	1✔
384	return err	×
385	}	×
386
387	if args.Netns == "" {	1✔
388	return nil	×
389	}	×
390	netns, err := ns.GetNS(args.Netns)	1✔
391	if err != nil {	1✔
392	// if NetNs is passed down by the Cloud Orchestration Engine, or if it called multiple times	×
393	// so don't return an error if the device is already removed.	×
394	// https://github.com/kubernetes/kubernetes/issues/43014#issuecomment-287164444	×
395	_, ok := err.(ns.NSPathNotExistErr)	×
396	if ok {	×
397	return nil	×
398	}	×
399	return fmt.Errorf("failed to open netns %q: %v", netns, err)	×
400	}
401	defer netns.Close()	1✔
402		1✔
403	k8sArgs, err := k8s.GetK8sArgs(args)	1✔
404	if err != nil {	1✔
405	return logging.Errorf("Multus: Err in getting k8s args: %v", err)	×
406	}	×
407
408	numK8sDelegates, kc, err := k8s.TryLoadPodDelegates(k8sArgs, in, kubeClient)	1✔
409	if err != nil {	1✔
410	return err	×
411	}	×
412
413	if numK8sDelegates == 0 {	2✔
414	// re-read the scratch multus config if we have only Multus delegates	1✔
415	netconfBytes, err := consumeScratchNetConf(args.ContainerID, in.CNIDir)	1✔
416	if err != nil {	1✔
417	if os.IsNotExist(err) {	×
418	// Per spec should ignore error if resources are missing / already removed	×
419	return nil	×
420	}	×
421	return logging.Errorf("Multus: Err in reading the delegates: %v", err)	×
422	}
423
424	if err := json.Unmarshal(netconfBytes, &in.Delegates); err != nil {	1✔
425	return logging.Errorf("Multus: failed to load netconf: %v", err)	×
426	}	×
427	}
428
429	//unset the network status annotation in apiserver, only in case Multus as kubeconfig
430	if in.Kubeconfig != "" && kc != nil {	1✔
431	if kc.Podnamespace != "kube-system" {	×
432	err := k8s.SetNetworkStatus(kc, nil)	×
433	if err != nil {	×
434	return logging.Errorf("Multus: Err unset the networks status: %v", err)	×
435	}	×
436	}
437	}
438
439	rt, _ := types.LoadCNIRuntimeConf(args, k8sArgs, "", in.RuntimeConfig)	1✔
440	return delPlugins(exec, args.IfName, in.Delegates, len(in.Delegates)-1, rt, in.BinDir)	1✔
441	}
442
443	func main() {	×
444	skel.PluginMain(	×
445	func(args *skel.CmdArgs) error {	×
446	result, err := cmdAdd(args, nil, nil)	×
447	if err != nil {	×
448	return err	×
449	}	×
450	return result.Print()	×
451	},
452	func(args *skel.CmdArgs) error {	×
453	result, err := cmdGet(args, nil, nil)	×
454	if err != nil {	×
455	return err	×
456	}	×
457	return result.Print()	×
458	},
459	func(args *skel.CmdArgs) error { return cmdDel(args, nil, nil) },	×
460	version.All, "meta-plugin that delegates to other CNI plugins")
461	}

intel / multus-cni / 546

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