intel / multus-cni / 385

Committed 18 Sep 2018 12:45PM UTC coverage: 43.879% (-1.1%) from 45.0%

Build # 385

Build Type

Pull #151

travis-ci

Committed by

web-flow

Commit Message

only create resourceMap on demand

making resourceMap a singleton object and only initialize it once
if one or more CRDs have a resourceName annotation in them.

Added copyright header for checkpoint/checkpoint.go.
Replaced fmt.Errorf with logging.

Change-Id: I54628d693

Pull Request Pull Request #151: parse kubelet checkpoint file for pod devices

Run Details

59 of 59 new or added lines in 2 files covered. (100.0%)

362 of 825 relevant lines covered (43.88%)

2.19 hits per line

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

27.22

/types/conf.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 types

import (
        "encoding/json"

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

const (
        defaultCNIDir  = "/var/lib/cni/multus"
        defaultConfDir = "/etc/cni/multus/net.d"
        defaultBinDir  = "/opt/cni/bin"
)

func LoadDelegateNetConfList(bytes []byte, delegateConf *DelegateNetConf) error {

        logging.Debugf("LoadDelegateNetConfList: %s, %v", string(bytes), delegateConf)
        if err := json.Unmarshal(bytes, &delegateConf.ConfList); err != nil {
                return logging.Errorf("err in unmarshalling delegate conflist: %v", err)
        }

        if delegateConf.ConfList.Plugins == nil {
                return logging.Errorf("delegate must have the 'type'or 'Plugin' field")
        }
        if delegateConf.ConfList.Plugins[0].Type == "" {
                return logging.Errorf("a plugin delegate must have the 'type' field")
        }
        delegateConf.ConfListPlugin = true
        return nil
}

// Convert raw CNI JSON into a DelegateNetConf structure
func LoadDelegateNetConf(bytes []byte, ifnameRequest, deviceID string) (*DelegateNetConf, error) {
        // If deviceID is present, inject this into delegate config
        if deviceID != "" {
                if updatedBytes, err := delegateAddDeviceID(bytes, deviceID); err != nil {
                        return nil, logging.Errorf("error in LoadDelegateNetConf - delegateAddDeviceID unable to update delegate config: %v", err)
                } else {
                        bytes = updatedBytes
                }
        }

        delegateConf := &DelegateNetConf{}
        logging.Debugf("LoadDelegateNetConf: %s, %s", string(bytes), ifnameRequest)
        if err := json.Unmarshal(bytes, &delegateConf.Conf); err != nil {
                return nil, logging.Errorf("error in LoadDelegateNetConf - unmarshalling delegate config: %v", err)
        }

        // Do some minimal validation
        if delegateConf.Conf.Type == "" {
                if err := LoadDelegateNetConfList(bytes, delegateConf); err != nil {
                        return nil, logging.Errorf("error in LoadDelegateNetConf: %v", err)
                }
        }

        if ifnameRequest != "" {
                delegateConf.IfnameRequest = ifnameRequest
        }

        delegateConf.Bytes = bytes

        return delegateConf, nil
}

func LoadCNIRuntimeConf(args *skel.CmdArgs, k8sArgs *K8sArgs, ifName string) (*libcni.RuntimeConf, error) {

        logging.Debugf("LoadCNIRuntimeConf: %v, %v, %s", args, k8sArgs, ifName)
        // In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go#buildCNIRuntimeConf
        // Todo
        // ingress, egress and bandwidth capability features as same as kubelet.
        rt := &libcni.RuntimeConf{
                ContainerID: args.ContainerID,
                NetNS:       args.Netns,
                IfName:      ifName,
                Args: [][2]string{
                        {"IgnoreUnknown", "1"},
                        {"K8S_POD_NAMESPACE", string(k8sArgs.K8S_POD_NAMESPACE)},
                        {"K8S_POD_NAME", string(k8sArgs.K8S_POD_NAME)},
                        {"K8S_POD_INFRA_CONTAINER_ID", string(k8sArgs.K8S_POD_INFRA_CONTAINER_ID)},
                },
        }
        return rt, nil
}

func LoadNetworkStatus(r types.Result, netName string, defaultNet bool) (*NetworkStatus, error) {
        logging.Debugf("LoadNetworkStatus: %v, %s, %s", r, netName, defaultNet)

        // Convert whatever the IPAM result was into the current Result type
        result, err := current.NewResultFromResult(r)
        if err != nil {
                return nil, logging.Errorf("error convert the type.Result to current.Result: %v", err)
        }

        netstatus := &NetworkStatus{}
        netstatus.Name = netName
        netstatus.Default = defaultNet

        for _, ifs := range result.Interfaces {
                //Only pod interfaces can have sandbox information
                if ifs.Sandbox != "" {
                        netstatus.Interface = ifs.Name
                        netstatus.Mac = ifs.Mac
                }
        }

        for _, ipconfig := range result.IPs {
                if ipconfig.Version == "4" && ipconfig.Address.IP.To4() != nil {
                        netstatus.IPs = append(netstatus.IPs, ipconfig.Address.IP.String())
                }

                if ipconfig.Version == "6" && ipconfig.Address.IP.To16() != nil {
                        netstatus.IPs = append(netstatus.IPs, ipconfig.Address.IP.String())
                }
        }

        netstatus.DNS = result.DNS

        return netstatus, nil

}

func LoadNetConf(bytes []byte) (*NetConf, error) {
        netconf := &NetConf{}

        logging.Debugf("LoadNetConf: %s", string(bytes))
        if err := json.Unmarshal(bytes, netconf); err != nil {
                return nil, logging.Errorf("failed to load netconf: %v", err)
        }

        // Logging
        if netconf.LogFile != "" {
                logging.SetLogFile(netconf.LogFile)
        }
        if netconf.LogLevel != "" {
                logging.SetLogLevel(netconf.LogLevel)
        }

        // Parse previous result
        if netconf.RawPrevResult != nil {
                resultBytes, err := json.Marshal(netconf.RawPrevResult)
                if err != nil {
                        return nil, logging.Errorf("could not serialize prevResult: %v", err)
                }
                res, err := version.NewResult(netconf.CNIVersion, resultBytes)
                if err != nil {
                        return nil, logging.Errorf("could not parse prevResult: %v", err)
                }
                netconf.RawPrevResult = nil
                netconf.PrevResult, err = current.NewResultFromResult(res)
                if err != nil {
                        return nil, logging.Errorf("could not convert result to current version: %v", err)
                }
        }

        // Delegates must always be set. If no kubeconfig is present, the
        // delegates are executed in-order.  If a kubeconfig is present,
        // at least one delegate must be present and the first delegate is
        // the master plugin. Kubernetes CRD delegates are then appended to
        // the existing delegate list and all delegates executed in-order.

        if len(netconf.RawDelegates) == 0 {
                return nil, logging.Errorf("at least one delegate must be specified")
        }

        if netconf.CNIDir == "" {
                netconf.CNIDir = defaultCNIDir
        }

        if netconf.ConfDir == "" {
                netconf.ConfDir = defaultConfDir
        }

        if netconf.BinDir == "" {
                netconf.BinDir = defaultBinDir
        }

        for idx, rawConf := range netconf.RawDelegates {
                bytes, err := json.Marshal(rawConf)
                if err != nil {
                        return nil, logging.Errorf("error marshalling delegate %d config: %v", idx, err)
                }
                delegateConf, err := LoadDelegateNetConf(bytes, "", "")
                if err != nil {
                        return nil, logging.Errorf("failed to load delegate %d config: %v", idx, err)
                }
                netconf.Delegates = append(netconf.Delegates, delegateConf)
        }
        netconf.RawDelegates = nil

        // First delegate is always the master plugin
        netconf.Delegates[0].MasterPlugin = true

        return netconf, nil
}

// AddDelegates appends the new delegates to the delegates list
func (n *NetConf) AddDelegates(newDelegates []*DelegateNetConf) error {
        logging.Debugf("AddDelegates: %v", newDelegates)
        n.Delegates = append(n.Delegates, newDelegates...)
        return nil
}

// delegateAddDeviceID injects deviceID information in delegate bytes
func delegateAddDeviceID(inBytes []byte, deviceID string) ([]byte, error) {
        var rawConfig map[string]interface{}
        var err error

        err = json.Unmarshal(inBytes, &rawConfig)
        if err != nil {
                return nil, logging.Errorf("delegateAddDeviceID: failed to unmarshal inBytes: %v", err)
        }
        // Inject deviceID
        rawConfig["deviceID"] = deviceID
        configBytes, err := json.Marshal(rawConfig)
        if err != nil {
                return nil, logging.Errorf("delegateAddDeviceID: failed to re-marshal Spec.Config: %v", err)
        }
        return configBytes, 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
16	package types
17
18	import (
19	"encoding/json"
20
21	"github.com/containernetworking/cni/libcni"
22	"github.com/containernetworking/cni/pkg/skel"
23	"github.com/containernetworking/cni/pkg/types"
24	"github.com/containernetworking/cni/pkg/types/current"
25	"github.com/containernetworking/cni/pkg/version"
26	"github.com/intel/multus-cni/logging"
27	)
28
29	const (
30	defaultCNIDir = "/var/lib/cni/multus"
31	defaultConfDir = "/etc/cni/multus/net.d"
32	defaultBinDir = "/opt/cni/bin"
33	)
34
35	func LoadDelegateNetConfList(bytes []byte, delegateConf *DelegateNetConf) error {	×
36		×
37	logging.Debugf("LoadDelegateNetConfList: %s, %v", string(bytes), delegateConf)	×
38	if err := json.Unmarshal(bytes, &delegateConf.ConfList); err != nil {	×
39	return logging.Errorf("err in unmarshalling delegate conflist: %v", err)	×
40	}	×
41
42	if delegateConf.ConfList.Plugins == nil {	×
43	return logging.Errorf("delegate must have the 'type'or 'Plugin' field")	×
44	}	×
45	if delegateConf.ConfList.Plugins[0].Type == "" {	×
46	return logging.Errorf("a plugin delegate must have the 'type' field")	×
47	}	×
48	delegateConf.ConfListPlugin = true	×
49	return nil	×
50	}
51
52	// Convert raw CNI JSON into a DelegateNetConf structure
53	func LoadDelegateNetConf(bytes []byte, ifnameRequest, deviceID string) (*DelegateNetConf, error) {	3✔
54	// If deviceID is present, inject this into delegate config	3✔
55	if deviceID != "" {	3✔
56	if updatedBytes, err := delegateAddDeviceID(bytes, deviceID); err != nil {	×
57	return nil, logging.Errorf("error in LoadDelegateNetConf - delegateAddDeviceID unable to update delegate config: %v", err)	×
58	} else {	×
59	bytes = updatedBytes	×
60	}	×
61	}
62
63	delegateConf := &DelegateNetConf{}	3✔
64	logging.Debugf("LoadDelegateNetConf: %s, %s", string(bytes), ifnameRequest)	3✔
65	if err := json.Unmarshal(bytes, &delegateConf.Conf); err != nil {	3✔
66	return nil, logging.Errorf("error in LoadDelegateNetConf - unmarshalling delegate config: %v", err)	×
67	}	×
68
69	// Do some minimal validation
70	if delegateConf.Conf.Type == "" {	3✔
71	if err := LoadDelegateNetConfList(bytes, delegateConf); err != nil {	×
72	return nil, logging.Errorf("error in LoadDelegateNetConf: %v", err)	×
73	}	×
74	}
75
76	if ifnameRequest != "" {	3✔
77	delegateConf.IfnameRequest = ifnameRequest	×
78	}	×
79
80	delegateConf.Bytes = bytes	3✔
81		3✔
82	return delegateConf, nil	3✔
83	}
84
85	func LoadCNIRuntimeConf(args skel.CmdArgs, k8sArgs K8sArgs, ifName string) (*libcni.RuntimeConf, error) {	×
86		×
87	logging.Debugf("LoadCNIRuntimeConf: %v, %v, %s", args, k8sArgs, ifName)	×
88	// In part, adapted from K8s pkg/kubelet/dockershim/network/cni/cni.go#buildCNIRuntimeConf	×
89	// Todo	×
90	// ingress, egress and bandwidth capability features as same as kubelet.	×
91	rt := &libcni.RuntimeConf{	×
92	ContainerID: args.ContainerID,	×
93	NetNS: args.Netns,	×
94	IfName: ifName,	×
95	Args: [][2]string{	×
96	{"IgnoreUnknown", "1"},	×
97	{"K8S_POD_NAMESPACE", string(k8sArgs.K8S_POD_NAMESPACE)},	×
98	{"K8S_POD_NAME", string(k8sArgs.K8S_POD_NAME)},	×
99	{"K8S_POD_INFRA_CONTAINER_ID", string(k8sArgs.K8S_POD_INFRA_CONTAINER_ID)},	×
100	},	×
101	}	×
102	return rt, nil	×
103	}	×
104
105	func LoadNetworkStatus(r types.Result, netName string, defaultNet bool) (*NetworkStatus, error) {	×
106	logging.Debugf("LoadNetworkStatus: %v, %s, %s", r, netName, defaultNet)	×
107		×
108	// Convert whatever the IPAM result was into the current Result type	×
109	result, err := current.NewResultFromResult(r)	×
110	if err != nil {	×
111	return nil, logging.Errorf("error convert the type.Result to current.Result: %v", err)	×
112	}	×
113
114	netstatus := &NetworkStatus{}	×
115	netstatus.Name = netName	×
116	netstatus.Default = defaultNet	×
117		×
118	for _, ifs := range result.Interfaces {	×
119	//Only pod interfaces can have sandbox information	×
120	if ifs.Sandbox != "" {	×
121	netstatus.Interface = ifs.Name	×
122	netstatus.Mac = ifs.Mac	×
123	}	×
124	}
125
126	for _, ipconfig := range result.IPs {	×
127	if ipconfig.Version == "4" && ipconfig.Address.IP.To4() != nil {	×
128	netstatus.IPs = append(netstatus.IPs, ipconfig.Address.IP.String())	×
129	}	×
130
131	if ipconfig.Version == "6" && ipconfig.Address.IP.To16() != nil {	×
132	netstatus.IPs = append(netstatus.IPs, ipconfig.Address.IP.String())	×
133	}	×
134	}
135
136	netstatus.DNS = result.DNS	×
137		×
138	return netstatus, nil	×
139
140	}
141
142	func LoadNetConf(bytes []byte) (*NetConf, error) {	4✔
143	netconf := &NetConf{}	4✔
144		4✔
145	logging.Debugf("LoadNetConf: %s", string(bytes))	4✔
146	if err := json.Unmarshal(bytes, netconf); err != nil {	4✔
147	return nil, logging.Errorf("failed to load netconf: %v", err)	×
148	}	×
149
150	// Logging
151	if netconf.LogFile != "" {	4✔
152	logging.SetLogFile(netconf.LogFile)	×
153	}	×
154	if netconf.LogLevel != "" {	4✔
155	logging.SetLogLevel(netconf.LogLevel)	×
156	}	×
157
158	// Parse previous result
159	if netconf.RawPrevResult != nil {	4✔
160	resultBytes, err := json.Marshal(netconf.RawPrevResult)	×
161	if err != nil {	×
162	return nil, logging.Errorf("could not serialize prevResult: %v", err)	×
163	}	×
164	res, err := version.NewResult(netconf.CNIVersion, resultBytes)	×
165	if err != nil {	×
166	return nil, logging.Errorf("could not parse prevResult: %v", err)	×
167	}	×
168	netconf.RawPrevResult = nil	×
169	netconf.PrevResult, err = current.NewResultFromResult(res)	×
170	if err != nil {	×
171	return nil, logging.Errorf("could not convert result to current version: %v", err)	×
172	}	×
173	}
174
175	// Delegates must always be set. If no kubeconfig is present, the
176	// delegates are executed in-order. If a kubeconfig is present,
177	// at least one delegate must be present and the first delegate is
178	// the master plugin. Kubernetes CRD delegates are then appended to
179	// the existing delegate list and all delegates executed in-order.
180
181	if len(netconf.RawDelegates) == 0 {	6✔
182	return nil, logging.Errorf("at least one delegate must be specified")	2✔
183	}	2✔
184
185	if netconf.CNIDir == "" {	4✔
186	netconf.CNIDir = defaultCNIDir	2✔
187	}	2✔
188
189	if netconf.ConfDir == "" {	4✔
190	netconf.ConfDir = defaultConfDir	2✔
191	}	2✔
192
193	if netconf.BinDir == "" {	4✔
194	netconf.BinDir = defaultBinDir	2✔
195	}	2✔
196
197	for idx, rawConf := range netconf.RawDelegates {	5✔
198	bytes, err := json.Marshal(rawConf)	3✔
199	if err != nil {	3✔
200	return nil, logging.Errorf("error marshalling delegate %d config: %v", idx, err)	×
201	}	×
202	delegateConf, err := LoadDelegateNetConf(bytes, "", "")	3✔
203	if err != nil {	3✔
204	return nil, logging.Errorf("failed to load delegate %d config: %v", idx, err)	×
205	}	×
206	netconf.Delegates = append(netconf.Delegates, delegateConf)	3✔
207	}
208	netconf.RawDelegates = nil	2✔
209		2✔
210	// First delegate is always the master plugin	2✔
211	netconf.Delegates[0].MasterPlugin = true	2✔
212		2✔
213	return netconf, nil	2✔
214	}
215
216	// AddDelegates appends the new delegates to the delegates list
217	func (n NetConf) AddDelegates(newDelegates []DelegateNetConf) error {	×
218	logging.Debugf("AddDelegates: %v", newDelegates)	×
219	n.Delegates = append(n.Delegates, newDelegates...)	×
220	return nil	×
221	}	×
222
223	// delegateAddDeviceID injects deviceID information in delegate bytes
224	func delegateAddDeviceID(inBytes []byte, deviceID string) ([]byte, error) {	×
225	var rawConfig map[string]interface{}	×
226	var err error	×
227		×
228	err = json.Unmarshal(inBytes, &rawConfig)	×
229	if err != nil {	×
230	return nil, logging.Errorf("delegateAddDeviceID: failed to unmarshal inBytes: %v", err)	×
231	}	×
232	// Inject deviceID
233	rawConfig["deviceID"] = deviceID	×
234	configBytes, err := json.Marshal(rawConfig)	×
235	if err != nil {	×
236	return nil, logging.Errorf("delegateAddDeviceID: failed to re-marshal Spec.Config: %v", err)	×
237	}	×
238	return configBytes, nil	×
239	}

intel / multus-cni / 385

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