intel / multus-cni / 709

Committed 20 Mar 2019 12:21PM UTC coverage: 51.583% (-0.04%) from 51.624%

Build # 709

Build Type

Pull #231

travis-ci

Committed by

web-flow

Commit Message

add kubelet client for Pod resource info

This change introduces kubelet client to get allocated device
information of a Pod from newly added Kubelet grpc service.
For more information please see:
[kubernetes/kubernetes#70508](https://github.com/kubernetes/kubernetes/pull/70508)

Change-Id: I11e58ccdd
Signed-off-by: Abdul Halim <abdul.halim@intel.com>

Pull Request Pull Request #231: add kubelet client for Pod resource info

Run Details

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

603 of 1169 relevant lines covered (51.58%)

3.99 hits per line

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

67.44

/checkpoint/checkpoint.go

// Copyright (c) 2018 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 checkpoint

import (
        "encoding/json"
        "io/ioutil"

        "github.com/intel/multus-cni/logging"
        "github.com/intel/multus-cni/types"
        v1 "k8s.io/api/core/v1"
)

const (
        checkPointfile = "/var/lib/kubelet/device-plugins/kubelet_internal_checkpoint"
)

type PodDevicesEntry struct {
        PodUID        string
        ContainerName string
        ResourceName  string
        DeviceIDs     []string
        AllocResp     []byte
}

type checkpointData struct {
        PodDeviceEntries  []PodDevicesEntry
        RegisteredDevices map[string][]string
}

type Data struct {
        Data     checkpointData
        Checksum uint64
}

type checkpoint struct {
        fileName   string
        podEntires []PodDevicesEntry
}

// GetCheckpoint returns an instance of Checkpoint
func GetCheckpoint() (types.ResourceClient, error) {
        logging.Debugf("GetCheckpoint(): invoked")
        return getCheckpoint(checkPointfile)
}

func getCheckpoint(filePath string) (types.ResourceClient, error) {
        cp := &checkpoint{fileName: filePath}
        err := cp.getPodEntries()
        if err != nil {
                return nil, err
        }
        logging.Debugf("getCheckpoint(): created checkpoint instance with file: %s", filePath)
        return cp, nil
}

// getPodEntries gets all Pod device allocation entries from checkpoint file
func (cp *checkpoint) getPodEntries() error {

        cpd := &Data{}
        rawBytes, err := ioutil.ReadFile(cp.fileName)
        if err != nil {
                return logging.Errorf("getPodEntries(): error reading file %s\n%v\n", checkPointfile, err)
        }

        if err = json.Unmarshal(rawBytes, cpd); err != nil {
                return logging.Errorf("getPodEntries(): error unmarshalling raw bytes %v", err)
        }

        cp.podEntires = cpd.Data.PodDeviceEntries
        logging.Debugf("getPodEntries(): podEntires %+v", cp.podEntires)
        return nil
}

// GetComputeDeviceMap returns an instance of a map of ResourceInfo
func (cp *checkpoint) GetPodResourceMap(pod *v1.Pod) (map[string]*types.ResourceInfo, error) {
        podID := string(pod.UID)
        resourceMap := make(map[string]*types.ResourceInfo)

        if podID == "" {
                return nil, logging.Errorf("GetPodResourceMap(): invalid Pod cannot be empty")
        }

        for _, pod := range cp.podEntires {
                if pod.PodUID == podID {
                        entry, ok := resourceMap[pod.ResourceName]
                        if ok {
                                // already exists; append to it
                                entry.DeviceIDs = append(entry.DeviceIDs, pod.DeviceIDs...)
                        } else {
                                // new entry
                                resourceMap[pod.ResourceName] = &types.ResourceInfo{DeviceIDs: pod.DeviceIDs}
                        }
                }
        }
        return resourceMap, nil
}

1	// Copyright (c) 2018 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 checkpoint
17
18	import (
19	"encoding/json"
20	"io/ioutil"
21
22	"github.com/intel/multus-cni/logging"
23	"github.com/intel/multus-cni/types"
24	v1 "k8s.io/api/core/v1"
25	)
26
27	const (
28	checkPointfile = "/var/lib/kubelet/device-plugins/kubelet_internal_checkpoint"
29	)
30
31	type PodDevicesEntry struct {
32	PodUID string
33	ContainerName string
34	ResourceName string
35	DeviceIDs []string
36	AllocResp []byte
37	}
38
39	type checkpointData struct {
40	PodDeviceEntries []PodDevicesEntry
41	RegisteredDevices map[string][]string
42	}
43
44	type Data struct {
45	Data checkpointData
46	Checksum uint64
47	}
48
49	type checkpoint struct {
50	fileName string
51	podEntires []PodDevicesEntry
52	}
53
54	// GetCheckpoint returns an instance of Checkpoint
55	func GetCheckpoint() (types.ResourceClient, error) {	×
56	logging.Debugf("GetCheckpoint(): invoked")	×
57	return getCheckpoint(checkPointfile)	×
58	}	×
59
60	func getCheckpoint(filePath string) (types.ResourceClient, error) {	1✔
61	cp := &checkpoint{fileName: filePath}	1✔
62	err := cp.getPodEntries()	1✔
63	if err != nil {	1✔
64	return nil, err	×
65	}	×
66	logging.Debugf("getCheckpoint(): created checkpoint instance with file: %s", filePath)	1✔
67	return cp, nil	1✔
68	}
69
70	// getPodEntries gets all Pod device allocation entries from checkpoint file
71	func (cp *checkpoint) getPodEntries() error {	1✔
72		1✔
73	cpd := &Data{}	1✔
74	rawBytes, err := ioutil.ReadFile(cp.fileName)	1✔
75	if err != nil {	1✔
76	return logging.Errorf("getPodEntries(): error reading file %s\n%v\n", checkPointfile, err)	×
77	}	×
78
79	if err = json.Unmarshal(rawBytes, cpd); err != nil {	1✔
80	return logging.Errorf("getPodEntries(): error unmarshalling raw bytes %v", err)	×
81	}	×
82
83	cp.podEntires = cpd.Data.PodDeviceEntries	1✔
84	logging.Debugf("getPodEntries(): podEntires %+v", cp.podEntires)	1✔
85	return nil	1✔
86	}
87
88	// GetComputeDeviceMap returns an instance of a map of ResourceInfo
89	func (cp checkpoint) GetPodResourceMap(pod v1.Pod) (map[string]*types.ResourceInfo, error) {	1✔
90	podID := string(pod.UID)	1✔
91	resourceMap := make(map[string]*types.ResourceInfo)	1✔
92		1✔
93	if podID == "" {	1✔
94	return nil, logging.Errorf("GetPodResourceMap(): invalid Pod cannot be empty")	×
95	}	×
96
97	for _, pod := range cp.podEntires {	2✔
98	if pod.PodUID == podID {	2✔
99	entry, ok := resourceMap[pod.ResourceName]	1✔
100	if ok {	1✔
101	// already exists; append to it	×
102	entry.DeviceIDs = append(entry.DeviceIDs, pod.DeviceIDs...)	×
103	} else {	1✔
104	// new entry	1✔
105	resourceMap[pod.ResourceName] = &types.ResourceInfo{DeviceIDs: pod.DeviceIDs}	1✔
106	}	1✔
107	}
108	}
109	return resourceMap, nil	1✔
110	}

intel / multus-cni / 709

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