intel / multus-cni / 364

Committed 30 Aug 2018 11:15AM UTC coverage: 45.0% (+0.9%) from 44.121%

Build # 364

Build Type

push

travis-ci

Committed by

s1061123

Commit Message

<a href="https://github.com/intel/multus-cni/commit/<a class=hub.com/intel/multus-cni/commit/<a class="double-link" href="https://git"><a class=hub.com/intel/multus-cni/commit/517f2d4b7af32eb87ddeb09d47f542dda1fb31fb">517f2d4b7<a href="https://github.com/intel/multus-cni/commit/517f2d4b7af32eb87ddeb09d47f542dda1fb31fb">&lt;a href=&quot;https://github.com/intel/multus-cni/commit/517f2d4b7af32eb87ddeb09d47f542dda1fb31fb">&quot;&gt;Revert &amp;quot;Merge branch &amp;#39;dev/k8s-deviceid-model&amp;#39; into master&amp;quot;

This reverts commit &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/intel/multus-cni/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/intel/multus-cni/commit/194c27fadfacd52b4ebf06885d0950599b9f0e36">194c27fad</a>">194c27fad</a><a href="https://github.com/intel/multus-cni/commit/517f2d4b7af32eb87ddeb09d47f542dda1fb31fb">, reversing
changes made to </a><a class="double-link" href="https://github.com/intel/multus-cni/commit/<a class="double-link" href="https://github.com/intel/multus-cni/commit/96d4d79d1f88d38771d52d543a3ea0cdfcc11d38">96d4d79d1">96d4d79d1.

Run Details

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

351 of 780 relevant lines covered (45.0%)

2.22 hits per line

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

50.78

/k8sclient/k8sclient.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.

package k8sclient

import (
        "encoding/json"
        "fmt"
        "os"
        "regexp"
        "strings"

        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/rest"
        "k8s.io/client-go/tools/clientcmd"
        "k8s.io/client-go/util/retry"

        "github.com/containernetworking/cni/libcni"
        "github.com/containernetworking/cni/pkg/skel"
        cnitypes "github.com/containernetworking/cni/pkg/types"
        "github.com/intel/multus-cni/logging"
        "github.com/intel/multus-cni/types"
)

// NoK8sNetworkError indicates error, no network in kubernetes
type NoK8sNetworkError struct {
        message string
}

type clientInfo struct {
        Client       KubeClient
        Podnamespace string
        Podname      string
}

func (e *NoK8sNetworkError) Error() string { return string(e.message) }

type defaultKubeClient struct {
        client kubernetes.Interface
}

// defaultKubeClient implements KubeClient
var _ KubeClient = &defaultKubeClient{}

func (d *defaultKubeClient) GetRawWithPath(path string) ([]byte, error) {
        return d.client.ExtensionsV1beta1().RESTClient().Get().AbsPath(path).DoRaw()
}

func (d *defaultKubeClient) GetPod(namespace, name string) (*v1.Pod, error) {
        return d.client.Core().Pods(namespace).Get(name, metav1.GetOptions{})
}

func (d *defaultKubeClient) UpdatePodStatus(pod *v1.Pod) (*v1.Pod, error) {
        return d.client.Core().Pods(pod.Namespace).UpdateStatus(pod)
}

func setKubeClientInfo(c *clientInfo, client KubeClient, k8sArgs *types.K8sArgs) {
        logging.Debugf("setKubeClientInfo: %v, %v, %v", c, client, k8sArgs)
        c.Client = client
        c.Podnamespace = string(k8sArgs.K8S_POD_NAMESPACE)
        c.Podname = string(k8sArgs.K8S_POD_NAME)
}

func SetNetworkStatus(k *clientInfo, netStatus []*types.NetworkStatus) error {

        logging.Debugf("SetNetworkStatus: %v, %v", k, netStatus)
        pod, err := k.Client.GetPod(k.Podnamespace, k.Podname)
        if err != nil {
                return logging.Errorf("SetNetworkStatus: failed to query the pod %v in out of cluster comm: %v", k.Podname, err)
        }

        var ns string
        if netStatus != nil {
                var networkStatus []string
                for _, nets := range netStatus {
                        data, err := json.MarshalIndent(nets, "", "    ")
                        if err != nil {
                                return logging.Errorf("SetNetworkStatus: error with Marshal Indent: %v", err)
                        }
                        networkStatus = append(networkStatus, string(data))
                }

                ns = fmt.Sprintf("[%s]", strings.Join(networkStatus, ","))
        }
        _, err = setPodNetworkAnnotation(k.Client, k.Podnamespace, pod, ns)
        if err != nil {
                return logging.Errorf("SetNetworkStatus: failed to update the pod %v in out of cluster comm: %v", k.Podname, err)
        }

        return nil
}

func setPodNetworkAnnotation(client KubeClient, namespace string, pod *v1.Pod, networkstatus string) (*v1.Pod, error) {
        logging.Debugf("setPodNetworkAnnotation: %v, %s, %v, %s", client, namespace, pod, networkstatus)
        //if pod annotations is empty, make sure it allocatable
        if len(pod.Annotations) == 0 {
                pod.Annotations = make(map[string]string)
        }

        pod.Annotations["k8s.v1.cni.cncf.io/networks-status"] = networkstatus

        pod = pod.DeepCopy()
        var err error
        if resultErr := retry.RetryOnConflict(retry.DefaultBackoff, func() error {
                if err != nil {
                        // Re-get the pod unless it's the first attempt to update
                        pod, err = client.GetPod(pod.Namespace, pod.Name)
                        if err != nil {
                                return err
                        }
                }

                pod, err = client.UpdatePodStatus(pod)
                return err
        }); resultErr != nil {
                return nil, logging.Errorf("status update failed for pod %s/%s: %v", pod.Namespace, pod.Name, resultErr)
        }
        return pod, nil
}

func getPodNetworkAnnotation(client KubeClient, k8sArgs *types.K8sArgs) (string, string, error) {
        var err error

        logging.Debugf("getPodNetworkAnnotation: %v, %v", client, k8sArgs)
        pod, err := client.GetPod(string(k8sArgs.K8S_POD_NAMESPACE), string(k8sArgs.K8S_POD_NAME))
        if err != nil {
                return "", "", logging.Errorf("getPodNetworkAnnotation: failed to query the pod %v in out of cluster comm: %v", string(k8sArgs.K8S_POD_NAME), err)
        }

        return pod.Annotations["k8s.v1.cni.cncf.io/networks"], pod.ObjectMeta.Namespace, nil
}

func parsePodNetworkObjectName(podnetwork string) (string, string, string, error) {
        var netNsName string
        var netIfName string
        var networkName string

        logging.Debugf("parsePodNetworkObjectName: %s", podnetwork)
        slashItems := strings.Split(podnetwork, "/")
        if len(slashItems) == 2 {
                netNsName = strings.TrimSpace(slashItems[0])
                networkName = slashItems[1]
        } else if len(slashItems) == 1 {
                networkName = slashItems[0]
        } else {
                return "", "", "", logging.Errorf("Invalid network object (failed at '/')")
        }

        atItems := strings.Split(networkName, "@")
        networkName = strings.TrimSpace(atItems[0])
        if len(atItems) == 2 {
                netIfName = strings.TrimSpace(atItems[1])
        } else if len(atItems) != 1 {
                return "", "", "", logging.Errorf("Invalid network object (failed at '@')")
        }

        // Check and see if each item matches the specification for valid attachment name.
        // "Valid attachment names must be comprised of units of the DNS-1123 label format"
        // [a-z0-9]([-a-z0-9]*[a-z0-9])?
        // And we allow at (@), and forward slash (/) (units separated by commas)
        // It must start and end alphanumerically.
        allItems := []string{netNsName, networkName, netIfName}
        for i := range allItems {
                matched, _ := regexp.MatchString("^[a-z0-9]([-a-z0-9]*[a-z0-9])?$", allItems[i])
                if !matched && len([]rune(allItems[i])) > 0 {
                        return "", "", "", logging.Errorf(fmt.Sprintf("Failed to parse: one or more items did not match comma-delimited format (must consist of lower case alphanumeric characters). Must start and end with an alphanumeric character), mismatch @ '%v'", allItems[i]))
                }
        }

        logging.Debugf("parsePodNetworkObjectName: parsed: %s, %s, %s", netNsName, networkName, netIfName)
        return netNsName, networkName, netIfName, nil
}

func parsePodNetworkAnnotation(podNetworks, defaultNamespace string) ([]*types.NetworkSelectionElement, error) {
        var networks []*types.NetworkSelectionElement

        logging.Debugf("parsePodNetworkAnnotation: %s, %s", podNetworks, defaultNamespace)
        if podNetworks == "" {
                return nil, logging.Errorf("parsePodNetworkAnnotation: pod annotation not having \"network\" as key, refer Multus README.md for the usage guide")
        }

        if strings.IndexAny(podNetworks, "[{\"") >= 0 {
                if err := json.Unmarshal([]byte(podNetworks), &networks); err != nil {
                        return nil, logging.Errorf("parsePodNetworkAnnotation: failed to parse pod Network Attachment Selection Annotation JSON format: %v", err)
                }
        } else {
                // Comma-delimited list of network attachment object names
                for _, item := range strings.Split(podNetworks, ",") {
                        // Remove leading and trailing whitespace.
                        item = strings.TrimSpace(item)

                        // Parse network name (i.e. <namespace>/<network name>@<ifname>)
                        netNsName, networkName, netIfName, err := parsePodNetworkObjectName(item)
                        if err != nil {
                                return nil, logging.Errorf("parsePodNetworkAnnotation: %v", err)
                        }

                        networks = append(networks, &types.NetworkSelectionElement{
                                Name:             networkName,
                                Namespace:        netNsName,
                                InterfaceRequest: netIfName,
                        })
                }
        }

        for _, net := range networks {
                if net.Namespace == "" {
                        net.Namespace = defaultNamespace
                }
        }

        return networks, nil
}

func getCNIConfigFromFile(name string, confdir string) ([]byte, error) {
        logging.Debugf("getCNIConfigFromFile: %s, %s", name, confdir)

        // In the absence of valid keys in a Spec, the runtime (or
        // meta-plugin) should load and execute a CNI .configlist
        // or .config (in that order) file on-disk whose JSON
        // “name” key matches this Network object’s name.

        // In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go#getDefaultCNINetwork
        files, err := libcni.ConfFiles(confdir, []string{".conf", ".json", ".conflist"})
        switch {
        case err != nil:
                return nil, logging.Errorf("No networks found in %s", confdir)
        case len(files) == 0:
                return nil, logging.Errorf("No networks found in %s", confdir)
        }

        for _, confFile := range files {
                var confList *libcni.NetworkConfigList
                if strings.HasSuffix(confFile, ".conflist") {
                        confList, err = libcni.ConfListFromFile(confFile)
                        if err != nil {
                                return nil, logging.Errorf("Error loading CNI conflist file %s: %v", confFile, err)
                        }

                        if confList.Name == name {
                                return confList.Bytes, nil
                        }

                } else {
                        conf, err := libcni.ConfFromFile(confFile)
                        if err != nil {
                                return nil, logging.Errorf("Error loading CNI config file %s: %v", confFile, err)
                        }

                        if conf.Network.Name == name {
                                // Ensure the config has a "type" so we know what plugin to run.
                                // Also catches the case where somebody put a conflist into a conf file.
                                if conf.Network.Type == "" {
                                        return nil, logging.Errorf("Error loading CNI config file %s: no 'type'; perhaps this is a .conflist?", confFile)
                                }
                                return conf.Bytes, nil
                        }
                }
        }

        return nil, logging.Errorf("no network available in the name %s in cni dir %s", name, confdir)
}

// getCNIConfigFromSpec reads a CNI JSON configuration from the NetworkAttachmentDefinition
// object's Spec.Config field and fills in any missing details like the network name
func getCNIConfigFromSpec(configData, netName string) ([]byte, error) {
        var rawConfig map[string]interface{}
        var err error

        logging.Debugf("getCNIConfigFromSpec: %s, %s", configData, netName)
        configBytes := []byte(configData)
        err = json.Unmarshal(configBytes, &rawConfig)
        if err != nil {
                return nil, logging.Errorf("getCNIConfigFromSpec: failed to unmarshal Spec.Config: %v", err)
        }

        // Inject network name if missing from Config for the thick plugin case
        if n, ok := rawConfig["name"]; !ok || n == "" {
                rawConfig["name"] = netName
                configBytes, err = json.Marshal(rawConfig)
                if err != nil {
                        return nil, logging.Errorf("getCNIConfigFromSpec: failed to re-marshal Spec.Config: %v", err)
                }
        }

        return configBytes, nil
}

func cniConfigFromNetworkResource(customResource *types.NetworkAttachmentDefinition, confdir string) ([]byte, error) {
        var config []byte
        var err error

        logging.Debugf("cniConfigFromNetworkResource: %v, %s", customResource, confdir)
        emptySpec := types.NetworkAttachmentDefinitionSpec{}
        if customResource.Spec == emptySpec {
                // Network Spec empty; generate delegate from CNI JSON config
                // from the configuration directory that has the same network
                // name as the custom resource
                config, err = getCNIConfigFromFile(customResource.Metadata.Name, confdir)
                if err != nil {
                        return nil, logging.Errorf("cniConfigFromNetworkResource: err in getCNIConfigFromFile: %v", err)
                }
        } else {
                // Config contains a standard JSON-encoded CNI configuration
                // or configuration list which defines the plugin chain to
                // execute.
                config, err = getCNIConfigFromSpec(customResource.Spec.Config, customResource.Metadata.Name)
                if err != nil {
                        return nil, logging.Errorf("cniConfigFromNetworkResource: err in getCNIConfigFromSpec: %v", err)
                }
        }

        return config, nil
}

func getKubernetesDelegate(client KubeClient, net *types.NetworkSelectionElement, confdir string) (*types.DelegateNetConf, error) {
        logging.Debugf("getKubernetesDelegate: %v, %v, %s", client, net, confdir)
        rawPath := fmt.Sprintf("/apis/k8s.cni.cncf.io/v1/namespaces/%s/network-attachment-definitions/%s", net.Namespace, net.Name)
        netData, err := client.GetRawWithPath(rawPath)
        if err != nil {
                return nil, logging.Errorf("getKubernetesDelegate: failed to get network resource, refer Multus README.md for the usage guide: %v", err)
        }

        customResource := &types.NetworkAttachmentDefinition{}
        if err := json.Unmarshal(netData, customResource); err != nil {
                return nil, logging.Errorf("getKubernetesDelegate: failed to get the netplugin data: %v", err)
        }

        configBytes, err := cniConfigFromNetworkResource(customResource, confdir)
        if err != nil {
                return nil, err
        }

        delegate, err := types.LoadDelegateNetConf(configBytes, net.InterfaceRequest)
        if err != nil {
                return nil, err
        }

        return delegate, nil
}

type KubeClient interface {
        GetRawWithPath(path string) ([]byte, error)
        GetPod(namespace, name string) (*v1.Pod, error)
        UpdatePodStatus(pod *v1.Pod) (*v1.Pod, error)
}

func GetK8sArgs(args *skel.CmdArgs) (*types.K8sArgs, error) {
        k8sArgs := &types.K8sArgs{}

        logging.Debugf("GetK8sNetwork: %v", args)
        err := cnitypes.LoadArgs(args.Args, k8sArgs)
        if err != nil {
                return nil, err
        }

        return k8sArgs, nil
}

// Attempts to load Kubernetes-defined delegates and add them to the Multus config.
// Returns the number of Kubernetes-defined delegates added or an error.
func TryLoadK8sDelegates(k8sArgs *types.K8sArgs, conf *types.NetConf, kubeClient KubeClient) (int, *clientInfo, error) {
        var err error
        clientInfo := &clientInfo{}

        logging.Debugf("TryLoadK8sDelegates: %v, %v, %v", k8sArgs, conf, kubeClient)
        kubeClient, err = GetK8sClient(conf.Kubeconfig, kubeClient)
        if err != nil {
                return 0, nil, err
        }

        if kubeClient == nil {
                if len(conf.Delegates) == 0 {
                        // No available kube client and no delegates, we can't do anything
                        return 0, nil, logging.Errorf("must have either Kubernetes config or delegates, refer Multus README.md for the usage guide")
                }
                return 0, nil, nil
        }

        setKubeClientInfo(clientInfo, kubeClient, k8sArgs)
        delegates, err := GetK8sNetwork(kubeClient, k8sArgs, conf.ConfDir)
        if err != nil {
                if _, ok := err.(*NoK8sNetworkError); ok {
                        return 0, clientInfo, nil
                }
                return 0, nil, logging.Errorf("Multus: Err in getting k8s network from pod: %v", err)
        }

        if err = conf.AddDelegates(delegates); err != nil {
                return 0, nil, err
        }

        return len(delegates), clientInfo, nil
}

func GetK8sClient(kubeconfig string, kubeClient KubeClient) (KubeClient, error) {
        logging.Debugf("GetK8sClient: %s, %v", kubeconfig, kubeClient)
        // If we get a valid kubeClient (eg from testcases) just return that
        // one.
        if kubeClient != nil {
                return kubeClient, nil
        }

        var err error
        var config *rest.Config

        // Otherwise try to create a kubeClient from a given kubeConfig
        if kubeconfig != "" {
                // uses the current context in kubeconfig
                config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)
                if err != nil {
                        return nil, logging.Errorf("GetK8sClient: failed to get context for the kubeconfig %v, refer Multus README.md for the usage guide: %v", kubeconfig, err)
                }
        } else if os.Getenv("KUBERNETES_SERVICE_HOST") != "" && os.Getenv("KUBERNETES_SERVICE_PORT") != "" {
                // Try in-cluster config where multus might be running in a kubernetes pod
                config, err = rest.InClusterConfig()
                if err != nil {
                        return nil, logging.Errorf("createK8sClient: failed to get context for in-cluster kube config, refer Multus README.md for the usage guide: %v", err)
                }
        } else {
                // No kubernetes config; assume we shouldn't talk to Kube at all
                return nil, nil
        }

        // creates the clientset
        client, err := kubernetes.NewForConfig(config)
        if err != nil {
                return nil, err
        }

        return &defaultKubeClient{client: client}, nil
}

func GetK8sNetwork(k8sclient KubeClient, k8sArgs *types.K8sArgs, confdir string) ([]*types.DelegateNetConf, error) {
        logging.Debugf("GetK8sNetwork: %v, %v, %v", k8sclient, k8sArgs, confdir)

        netAnnot, defaultNamespace, err := getPodNetworkAnnotation(k8sclient, k8sArgs)
        if err != nil {
                return nil, err
        }

        if len(netAnnot) == 0 {
                return nil, &NoK8sNetworkError{"no kubernetes network found"}
        }

        networks, err := parsePodNetworkAnnotation(netAnnot, defaultNamespace)
        if err != nil {
                return nil, err
        }

        // Read all network objects referenced by 'networks'
        var delegates []*types.DelegateNetConf
        for _, net := range networks {
                delegate, err := getKubernetesDelegate(k8sclient, net, confdir)
                if err != nil {
                        return nil, logging.Errorf("GetK8sNetwork: failed getting the delegate: %v", err)
                }
                delegates = append(delegates, delegate)
        }

        return delegates, nil
}

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	package k8sclient
16
17	import (
18	"encoding/json"
19	"fmt"
20	"os"
21	"regexp"
22	"strings"
23
24	v1 "k8s.io/api/core/v1"
25	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
26	"k8s.io/client-go/kubernetes"
27	"k8s.io/client-go/rest"
28	"k8s.io/client-go/tools/clientcmd"
29	"k8s.io/client-go/util/retry"
30
31	"github.com/containernetworking/cni/libcni"
32	"github.com/containernetworking/cni/pkg/skel"
33	cnitypes "github.com/containernetworking/cni/pkg/types"
34	"github.com/intel/multus-cni/logging"
35	"github.com/intel/multus-cni/types"
36	)
37
38	// NoK8sNetworkError indicates error, no network in kubernetes
39	type NoK8sNetworkError struct {
40	message string
41	}
42
43	type clientInfo struct {
44	Client KubeClient
45	Podnamespace string
46	Podname string
47	}
48
49	func (e *NoK8sNetworkError) Error() string { return string(e.message) }	×
50
51	type defaultKubeClient struct {
52	client kubernetes.Interface
53	}
54
55	// defaultKubeClient implements KubeClient
56	var _ KubeClient = &defaultKubeClient{}
57
58	func (d *defaultKubeClient) GetRawWithPath(path string) ([]byte, error) {	×
59	return d.client.ExtensionsV1beta1().RESTClient().Get().AbsPath(path).DoRaw()	×
60	}	×
61
62	func (d defaultKubeClient) GetPod(namespace, name string) (v1.Pod, error) {	×
63	return d.client.Core().Pods(namespace).Get(name, metav1.GetOptions{})	×
64	}	×
65
66	func (d defaultKubeClient) UpdatePodStatus(pod v1.Pod) (*v1.Pod, error) {	×
67	return d.client.Core().Pods(pod.Namespace).UpdateStatus(pod)	×
68	}	×
69
70	func setKubeClientInfo(c clientInfo, client KubeClient, k8sArgs types.K8sArgs) {	×
71	logging.Debugf("setKubeClientInfo: %v, %v, %v", c, client, k8sArgs)	×
72	c.Client = client	×
73	c.Podnamespace = string(k8sArgs.K8S_POD_NAMESPACE)	×
74	c.Podname = string(k8sArgs.K8S_POD_NAME)	×
75	}	×
76
77	func SetNetworkStatus(k clientInfo, netStatus []types.NetworkStatus) error {	×
78		×
79	logging.Debugf("SetNetworkStatus: %v, %v", k, netStatus)	×
80	pod, err := k.Client.GetPod(k.Podnamespace, k.Podname)	×
81	if err != nil {	×
82	return logging.Errorf("SetNetworkStatus: failed to query the pod %v in out of cluster comm: %v", k.Podname, err)	×
83	}	×
84
85	var ns string	×
86	if netStatus != nil {	×
87	var networkStatus []string	×
88	for _, nets := range netStatus {	×
89	data, err := json.MarshalIndent(nets, "", " ")	×
90	if err != nil {	×
91	return logging.Errorf("SetNetworkStatus: error with Marshal Indent: %v", err)	×
92	}	×
93	networkStatus = append(networkStatus, string(data))	×
94	}
95
96	ns = fmt.Sprintf("[%s]", strings.Join(networkStatus, ","))	×
97	}
98	_, err = setPodNetworkAnnotation(k.Client, k.Podnamespace, pod, ns)	×
99	if err != nil {	×
100	return logging.Errorf("SetNetworkStatus: failed to update the pod %v in out of cluster comm: %v", k.Podname, err)	×
101	}	×
102
103	return nil	×
104	}
105
106	func setPodNetworkAnnotation(client KubeClient, namespace string, pod v1.Pod, networkstatus string) (v1.Pod, error) {	×
107	logging.Debugf("setPodNetworkAnnotation: %v, %s, %v, %s", client, namespace, pod, networkstatus)	×
108	//if pod annotations is empty, make sure it allocatable	×
109	if len(pod.Annotations) == 0 {	×
110	pod.Annotations = make(map[string]string)	×
111	}	×
112
113	pod.Annotations["k8s.v1.cni.cncf.io/networks-status"] = networkstatus	×
114		×
115	pod = pod.DeepCopy()	×
116	var err error	×
117	if resultErr := retry.RetryOnConflict(retry.DefaultBackoff, func() error {	×
118	if err != nil {	×
119	// Re-get the pod unless it's the first attempt to update	×
120	pod, err = client.GetPod(pod.Namespace, pod.Name)	×
121	if err != nil {	×
122	return err	×
123	}	×
124	}
125
126	pod, err = client.UpdatePodStatus(pod)	×
127	return err	×
128	}); resultErr != nil {	×
129	return nil, logging.Errorf("status update failed for pod %s/%s: %v", pod.Namespace, pod.Name, resultErr)	×
130	}	×
131	return pod, nil	×
132	}
133
134	func getPodNetworkAnnotation(client KubeClient, k8sArgs *types.K8sArgs) (string, string, error) {	7✔
135	var err error	7✔
136		7✔
137	logging.Debugf("getPodNetworkAnnotation: %v, %v", client, k8sArgs)	7✔
138	pod, err := client.GetPod(string(k8sArgs.K8S_POD_NAMESPACE), string(k8sArgs.K8S_POD_NAME))	7✔
139	if err != nil {	7✔
140	return "", "", logging.Errorf("getPodNetworkAnnotation: failed to query the pod %v in out of cluster comm: %v", string(k8sArgs.K8S_POD_NAME), err)	×
141	}	×
142
143	return pod.Annotations["k8s.v1.cni.cncf.io/networks"], pod.ObjectMeta.Namespace, nil	7✔
144	}
145
146	func parsePodNetworkObjectName(podnetwork string) (string, string, string, error) {	9✔
147	var netNsName string	9✔
148	var netIfName string	9✔
149	var networkName string	9✔
150		9✔
151	logging.Debugf("parsePodNetworkObjectName: %s", podnetwork)	9✔
152	slashItems := strings.Split(podnetwork, "/")	9✔
153	if len(slashItems) == 2 {	9✔
154	netNsName = strings.TrimSpace(slashItems[0])	×
155	networkName = slashItems[1]	×
156	} else if len(slashItems) == 1 {	18✔
157	networkName = slashItems[0]	9✔
158	} else {	9✔
159	return "", "", "", logging.Errorf("Invalid network object (failed at '/')")	×
160	}	×
161
162	atItems := strings.Split(networkName, "@")	9✔
163	networkName = strings.TrimSpace(atItems[0])	9✔
164	if len(atItems) == 2 {	9✔
165	netIfName = strings.TrimSpace(atItems[1])	×
166	} else if len(atItems) != 1 {	9✔
167	return "", "", "", logging.Errorf("Invalid network object (failed at '@')")	×
168	}	×
169
170	// Check and see if each item matches the specification for valid attachment name.
171	// "Valid attachment names must be comprised of units of the DNS-1123 label format"
172	// [a-z0-9]([-a-z0-9]*[a-z0-9])?
173	// And we allow at (@), and forward slash (/) (units separated by commas)
174	// It must start and end alphanumerically.
175	allItems := []string{netNsName, networkName, netIfName}	9✔
176	for i := range allItems {	36✔
177	matched, _ := regexp.MatchString("^[a-z0-9]([-a-z0-9]*[a-z0-9])?$", allItems[i])	27✔
178	if !matched && len([]rune(allItems[i])) > 0 {	27✔
179	return "", "", "", logging.Errorf(fmt.Sprintf("Failed to parse: one or more items did not match comma-delimited format (must consist of lower case alphanumeric characters). Must start and end with an alphanumeric character), mismatch @ '%v'", allItems[i]))	×
180	}	×
181	}
182
183	logging.Debugf("parsePodNetworkObjectName: parsed: %s, %s, %s", netNsName, networkName, netIfName)	9✔
184	return netNsName, networkName, netIfName, nil	9✔
185	}
186
187	func parsePodNetworkAnnotation(podNetworks, defaultNamespace string) ([]*types.NetworkSelectionElement, error) {	7✔
188	var networks []*types.NetworkSelectionElement	7✔
189		7✔
190	logging.Debugf("parsePodNetworkAnnotation: %s, %s", podNetworks, defaultNamespace)	7✔
191	if podNetworks == "" {	7✔
192	return nil, logging.Errorf("parsePodNetworkAnnotation: pod annotation not having \"network\" as key, refer Multus README.md for the usage guide")	×
193	}	×
194
195	if strings.IndexAny(podNetworks, "[{\"") >= 0 {	9✔
196	if err := json.Unmarshal([]byte(podNetworks), &networks); err != nil {	3✔
197	return nil, logging.Errorf("parsePodNetworkAnnotation: failed to parse pod Network Attachment Selection Annotation JSON format: %v", err)	1✔
198	}	1✔
199	} else {	5✔
200	// Comma-delimited list of network attachment object names	5✔
201	for _, item := range strings.Split(podNetworks, ",") {	14✔
202	// Remove leading and trailing whitespace.	9✔
203	item = strings.TrimSpace(item)	9✔
204		9✔
205	// Parse network name (i.e. <namespace>/<network name>@<ifname>)	9✔
206	netNsName, networkName, netIfName, err := parsePodNetworkObjectName(item)	9✔
207	if err != nil {	9✔
208	return nil, logging.Errorf("parsePodNetworkAnnotation: %v", err)	×
209	}	×
210
211	networks = append(networks, &types.NetworkSelectionElement{	9✔
212	Name: networkName,	9✔
213	Namespace: netNsName,	9✔
214	InterfaceRequest: netIfName,	9✔
215	})	9✔
216	}
217	}
218
219	for _, net := range networks {	18✔
220	if net.Namespace == "" {	23✔
221	net.Namespace = defaultNamespace	11✔
222	}	11✔
223	}
224
225	return networks, nil	6✔
226	}
227
228	func getCNIConfigFromFile(name string, confdir string) ([]byte, error) {	4✔
229	logging.Debugf("getCNIConfigFromFile: %s, %s", name, confdir)	4✔
230		4✔
231	// In the absence of valid keys in a Spec, the runtime (or	4✔
232	// meta-plugin) should load and execute a CNI .configlist	4✔
233	// or .config (in that order) file on-disk whose JSON	4✔
234	// “name” key matches this Network object’s name.	4✔
235		4✔
236	// In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go#getDefaultCNINetwork	4✔
237	files, err := libcni.ConfFiles(confdir, []string{".conf", ".json", ".conflist"})	4✔
238	switch {	4✔
239	case err != nil:	×
240	return nil, logging.Errorf("No networks found in %s", confdir)	×
241	case len(files) == 0:	×
242	return nil, logging.Errorf("No networks found in %s", confdir)	×
243	}
244
245	for _, confFile := range files {	10✔
246	var confList *libcni.NetworkConfigList	6✔
247	if strings.HasSuffix(confFile, ".conflist") {	6✔
248	confList, err = libcni.ConfListFromFile(confFile)	×
249	if err != nil {	×
250	return nil, logging.Errorf("Error loading CNI conflist file %s: %v", confFile, err)	×
251	}	×
252
253	if confList.Name == name {	×
254	return confList.Bytes, nil	×
255	}	×
256
257	} else {	6✔
258	conf, err := libcni.ConfFromFile(confFile)	6✔
259	if err != nil {	7✔
260	return nil, logging.Errorf("Error loading CNI config file %s: %v", confFile, err)	1✔
261	}	1✔
262
263	if conf.Network.Name == name {	8✔
264	// Ensure the config has a "type" so we know what plugin to run.	3✔
265	// Also catches the case where somebody put a conflist into a conf file.	3✔
266	if conf.Network.Type == "" {	3✔
267	return nil, logging.Errorf("Error loading CNI config file %s: no 'type'; perhaps this is a .conflist?", confFile)	×
268	}	×
269	return conf.Bytes, nil	3✔
270	}
271	}
272	}
273
274	return nil, logging.Errorf("no network available in the name %s in cni dir %s", name, confdir)	×
275	}
276
277	// getCNIConfigFromSpec reads a CNI JSON configuration from the NetworkAttachmentDefinition
278	// object's Spec.Config field and fills in any missing details like the network name
279	func getCNIConfigFromSpec(configData, netName string) ([]byte, error) {	6✔
280	var rawConfig map[string]interface{}	6✔
281	var err error	6✔
282		6✔
283	logging.Debugf("getCNIConfigFromSpec: %s, %s", configData, netName)	6✔
284	configBytes := []byte(configData)	6✔
285	err = json.Unmarshal(configBytes, &rawConfig)	6✔
286	if err != nil {	6✔
287	return nil, logging.Errorf("getCNIConfigFromSpec: failed to unmarshal Spec.Config: %v", err)	×
288	}	×
289
290	// Inject network name if missing from Config for the thick plugin case
291	if n, ok := rawConfig["name"]; !ok \|\| n == "" {	7✔
292	rawConfig["name"] = netName	1✔
293	configBytes, err = json.Marshal(rawConfig)	1✔
294	if err != nil {	1✔
295	return nil, logging.Errorf("getCNIConfigFromSpec: failed to re-marshal Spec.Config: %v", err)	×
296	}	×
297	}
298
299	return configBytes, nil	6✔
300	}
301
302	func cniConfigFromNetworkResource(customResource *types.NetworkAttachmentDefinition, confdir string) ([]byte, error) {	10✔
303	var config []byte	10✔
304	var err error	10✔
305		10✔
306	logging.Debugf("cniConfigFromNetworkResource: %v, %s", customResource, confdir)	10✔
307	emptySpec := types.NetworkAttachmentDefinitionSpec{}	10✔
308	if customResource.Spec == emptySpec {	14✔
309	// Network Spec empty; generate delegate from CNI JSON config	4✔
310	// from the configuration directory that has the same network	4✔
311	// name as the custom resource	4✔
312	config, err = getCNIConfigFromFile(customResource.Metadata.Name, confdir)	4✔
313	if err != nil {	5✔
314	return nil, logging.Errorf("cniConfigFromNetworkResource: err in getCNIConfigFromFile: %v", err)	1✔
315	}	1✔
316	} else {	6✔
317	// Config contains a standard JSON-encoded CNI configuration	6✔
318	// or configuration list which defines the plugin chain to	6✔
319	// execute.	6✔
320	config, err = getCNIConfigFromSpec(customResource.Spec.Config, customResource.Metadata.Name)	6✔
321	if err != nil {	6✔
322	return nil, logging.Errorf("cniConfigFromNetworkResource: err in getCNIConfigFromSpec: %v", err)	×
323	}	×
324	}
325
326	return config, nil	9✔
327	}
328
329	func getKubernetesDelegate(client KubeClient, net types.NetworkSelectionElement, confdir string) (types.DelegateNetConf, error) {	11✔
330	logging.Debugf("getKubernetesDelegate: %v, %v, %s", client, net, confdir)	11✔
331	rawPath := fmt.Sprintf("/apis/k8s.cni.cncf.io/v1/namespaces/%s/network-attachment-definitions/%s", net.Namespace, net.Name)	11✔
332	netData, err := client.GetRawWithPath(rawPath)	11✔
333	if err != nil {	12✔
334	return nil, logging.Errorf("getKubernetesDelegate: failed to get network resource, refer Multus README.md for the usage guide: %v", err)	1✔
335	}	1✔
336
337	customResource := &types.NetworkAttachmentDefinition{}	10✔
338	if err := json.Unmarshal(netData, customResource); err != nil {	10✔
339	return nil, logging.Errorf("getKubernetesDelegate: failed to get the netplugin data: %v", err)	×
340	}	×
341
342	configBytes, err := cniConfigFromNetworkResource(customResource, confdir)	10✔
343	if err != nil {	11✔
344	return nil, err	1✔
345	}	1✔
346
347	delegate, err := types.LoadDelegateNetConf(configBytes, net.InterfaceRequest)	9✔
348	if err != nil {	9✔
349	return nil, err	×
350	}	×
351
352	return delegate, nil	9✔
353	}
354
355	type KubeClient interface {
356	GetRawWithPath(path string) ([]byte, error)
357	GetPod(namespace, name string) (*v1.Pod, error)
358	UpdatePodStatus(pod v1.Pod) (v1.Pod, error)
359	}
360
361	func GetK8sArgs(args skel.CmdArgs) (types.K8sArgs, error) {	7✔
362	k8sArgs := &types.K8sArgs{}	7✔
363		7✔
364	logging.Debugf("GetK8sNetwork: %v", args)	7✔
365	err := cnitypes.LoadArgs(args.Args, k8sArgs)	7✔
366	if err != nil {	7✔
367	return nil, err	×
368	}	×
369
370	return k8sArgs, nil	7✔
371	}
372
373	// Attempts to load Kubernetes-defined delegates and add them to the Multus config.
374	// Returns the number of Kubernetes-defined delegates added or an error.
375	func TryLoadK8sDelegates(k8sArgs types.K8sArgs, conf types.NetConf, kubeClient KubeClient) (int, *clientInfo, error) {	×
376	var err error	×
377	clientInfo := &clientInfo{}	×
378		×
379	logging.Debugf("TryLoadK8sDelegates: %v, %v, %v", k8sArgs, conf, kubeClient)	×
380	kubeClient, err = GetK8sClient(conf.Kubeconfig, kubeClient)	×
381	if err != nil {	×
382	return 0, nil, err	×
383	}	×
384
385	if kubeClient == nil {	×
386	if len(conf.Delegates) == 0 {	×
387	// No available kube client and no delegates, we can't do anything	×
388	return 0, nil, logging.Errorf("must have either Kubernetes config or delegates, refer Multus README.md for the usage guide")	×
389	}	×
390	return 0, nil, nil	×
391	}
392
393	setKubeClientInfo(clientInfo, kubeClient, k8sArgs)	×
394	delegates, err := GetK8sNetwork(kubeClient, k8sArgs, conf.ConfDir)	×
395	if err != nil {	×
396	if _, ok := err.(*NoK8sNetworkError); ok {	×
397	return 0, clientInfo, nil	×
398	}	×
399	return 0, nil, logging.Errorf("Multus: Err in getting k8s network from pod: %v", err)	×
400	}
401
402	if err = conf.AddDelegates(delegates); err != nil {	×
403	return 0, nil, err	×
404	}	×
405
406	return len(delegates), clientInfo, nil	×
407	}
408
409	func GetK8sClient(kubeconfig string, kubeClient KubeClient) (KubeClient, error) {	7✔
410	logging.Debugf("GetK8sClient: %s, %v", kubeconfig, kubeClient)	7✔
411	// If we get a valid kubeClient (eg from testcases) just return that	7✔
412	// one.	7✔
413	if kubeClient != nil {	14✔
414	return kubeClient, nil	7✔
415	}	7✔
416
417	var err error	×
418	var config *rest.Config	×
419		×
420	// Otherwise try to create a kubeClient from a given kubeConfig	×
421	if kubeconfig != "" {	×
422	// uses the current context in kubeconfig	×
423	config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)	×
424	if err != nil {	×
425	return nil, logging.Errorf("GetK8sClient: failed to get context for the kubeconfig %v, refer Multus README.md for the usage guide: %v", kubeconfig, err)	×
426	}	×
427	} else if os.Getenv("KUBERNETES_SERVICE_HOST") != "" && os.Getenv("KUBERNETES_SERVICE_PORT") != "" {	×
428	// Try in-cluster config where multus might be running in a kubernetes pod	×
429	config, err = rest.InClusterConfig()	×
430	if err != nil {	×
431	return nil, logging.Errorf("createK8sClient: failed to get context for in-cluster kube config, refer Multus README.md for the usage guide: %v", err)	×
432	}	×
433	} else {	×
434	// No kubernetes config; assume we shouldn't talk to Kube at all	×
435	return nil, nil	×
436	}	×
437
438	// creates the clientset
439	client, err := kubernetes.NewForConfig(config)	×
440	if err != nil {	×
441	return nil, err	×
442	}	×
443
444	return &defaultKubeClient{client: client}, nil	×
445	}
446
447	func GetK8sNetwork(k8sclient KubeClient, k8sArgs types.K8sArgs, confdir string) ([]types.DelegateNetConf, error) {	7✔
448	logging.Debugf("GetK8sNetwork: %v, %v, %v", k8sclient, k8sArgs, confdir)	7✔
449		7✔
450	netAnnot, defaultNamespace, err := getPodNetworkAnnotation(k8sclient, k8sArgs)	7✔
451	if err != nil {	7✔
452	return nil, err	×
453	}	×
454
455	if len(netAnnot) == 0 {	7✔
456	return nil, &NoK8sNetworkError{"no kubernetes network found"}	×
457	}	×
458
459	networks, err := parsePodNetworkAnnotation(netAnnot, defaultNamespace)	7✔
460	if err != nil {	8✔
461	return nil, err	1✔
462	}	1✔
463
464	// Read all network objects referenced by 'networks'
465	var delegates []*types.DelegateNetConf	6✔
466	for _, net := range networks {	17✔
467	delegate, err := getKubernetesDelegate(k8sclient, net, confdir)	11✔
468	if err != nil {	13✔
469	return nil, logging.Errorf("GetK8sNetwork: failed getting the delegate: %v", err)	2✔
470	}	2✔
471	delegates = append(delegates, delegate)	9✔
472	}
473
474	return delegates, nil	4✔
475	}

intel / multus-cni / 364

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