intel / multus-cni / 413

Committed 10 Oct 2018 10:52AM UTC coverage: 46.084% (-0.5%) from 46.565%

Build # 413

Build Type

push

travis-ci

Committed by

rkamudhan

Commit Message

<a href="https://github.com/intel/multus-cni/commit/68da5dfb0">fixed some typos in comments

Change-Id: I</a><a class="double-link" href="https://github.com/intel/multus-cni/commit/eb650479b">eb650479b</a>

Run Details

406 of 881 relevant lines covered (46.08%)

2.19 hits per line

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

48.86

/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/checkpoint"
        "github.com/intel/multus-cni/logging"
        "github.com/intel/multus-cni/types"
)

const (
        resourceNameAnnot = "k8s.v1.cni.cncf.io/resourceName"
)

// 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, 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, string(pod.UID), 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, podID string, resourceMap map[string]*types.ResourceInfo) (*types.DelegateNetConf, map[string]*types.ResourceInfo, 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, resourceMap, 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, resourceMap, logging.Errorf("getKubernetesDelegate: failed to get the netplugin data: %v", err)
        }

        // Get resourceName annotation from NetworkAttachmentDefinition
        deviceID := ""
        resourceName, ok := customResource.Metadata.Annotations[resourceNameAnnot]
        if ok && podID != "" {
                // ResourceName annotation is found; try to get device info from resourceMap
                logging.Debugf("getKubernetesDelegate: found resourceName annotation : %s", resourceName)

                if resourceMap == nil {
                        checkpoint, err := checkpoint.GetCheckpoint()
                        if err != nil {
                                return nil, resourceMap, logging.Errorf("getKubernetesDelegate: failed to get a checkpoint instance: %v", err)
                        }
                        resourceMap, err = checkpoint.GetComputeDeviceMap(podID)
                        if err != nil {
                                return nil, resourceMap, logging.Errorf("getKubernetesDelegate: failed to get resourceMap from kubelet checkpoint file: %v", err)
                        }
                        logging.Debugf("getKubernetesDelegate(): resourceMap instance: %+v", resourceMap)
                }

                entry, ok := resourceMap[resourceName]
                if ok {
                        if idCount := len(entry.DeviceIDs); idCount > 0 && idCount > entry.Index {
                                deviceID = entry.DeviceIDs[entry.Index]
                                logging.Debugf("getKubernetesDelegate: podID: %s deviceID: %s", podID, deviceID)
                                entry.Index++ // increment Index for next delegate
                        }
                }
        }

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

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

        return delegate, resourceMap, 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, podID, err := getPodNetworkAnnotation(k8sclient, k8sArgs)
        if err != nil {
                return nil, err
        }

        if err != nil {
                return nil, logging.Errorf("GetK8sNetwork: failed to get resourceMap for PodUID: %v %v", podID, err)
        }

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

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

        // resourceMap holds Pod device allocation information; only initizized if CRD contains 'resourceName' annotation.
        // This will only be initialized once and all delegate objects can reference this to look up device info.
        var resourceMap map[string]*types.ResourceInfo

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

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

intel / multus-cni / 413

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