refactoring checkpoint.go code to be testable

this changes will allow mocking checkpoint instance for unit tests

Change-Id: I72fb25d15d5c9f28577a0fcbfcd385df523a5e57

checkpoint/checkpoint.go

@@ -45,50 +45,59 @@ type Data struct {
 	Checksum uint64
 }
 
-// getPodEntries gets all Pod device allocation entries from checkpoint file
+type Checkpoint interface {
-func getPodEntries() ([]PodDevicesEntry, error) {
+	// GetComputeDeviceMap returns an instance of a map of ResourceInfo for a PodID
+	GetComputeDeviceMap(string) (map[string]*types.ResourceInfo, error)
+}
+type checkpoint struct {
+	fileName   string
+	podEntires []PodDevicesEntry
+}
 
-	podEntries := []PodDevicesEntry{}
+// GetCheckpoint returns an instance of Checkpoint
+func GetCheckpoint() (Checkpoint, error) {
+	logging.Debugf("GetCheckpoint(): invoked")
+	return getCheckpoint(checkPointfile)
+}
+
+func getCheckpoint(filePath string) (Checkpoint, 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(checkPointfile)
+	rawBytes, err := ioutil.ReadFile(cp.fileName)
 	if err != nil {
-		return podEntries, logging.Errorf("getPodEntries(): error reading file %s\n%v\n", checkPointfile, err)
+		return logging.Errorf("getPodEntries(): error reading file %s\n%v\n", checkPointfile, err)
-
 	}
 
 	if err = json.Unmarshal(rawBytes, cpd); err != nil {
-		return podEntries, logging.Errorf("getPodEntries(): error unmarshalling raw bytes %v", err)
+		return logging.Errorf("getPodEntries(): error unmarshalling raw bytes %v", err)
 	}
 
-	return cpd.Data.PodDeviceEntries, nil
+	cp.podEntires = cpd.Data.PodDeviceEntries
+	logging.Debugf("getPodEntries(): podEntires %+v", cp.podEntires)
+	return nil
 }
 
-var instance map[string]*types.ResourceInfo
-
 // GetComputeDeviceMap returns an instance of a map of ResourceInfo
-func GetComputeDeviceMap(podID string) (map[string]*types.ResourceInfo, error) {
+func (cp *checkpoint) GetComputeDeviceMap(podID string) (map[string]*types.ResourceInfo, error) {
 
-	if instance == nil {
-		if resourceMap, err := getResourceMapFromFile(podID); err == nil {
-			logging.Debugf("GetComputeDeviceMap(): created new instance of resourceMap for Pod: %s", podID)
-			instance = resourceMap
-		} else {
-			logging.Errorf("GetComputeDeviceMap(): error creating resourceMap instance %v", err)
-			return nil, err
-		}
-	}
-	logging.Debugf("GetComputeDeviceMap(): resourceMap instance: %+v", instance)
-	return instance, nil
-}
-
-func getResourceMapFromFile(podID string) (map[string]*types.ResourceInfo, error) {
 	resourceMap := make(map[string]*types.ResourceInfo)
-	podEntires, err := getPodEntries()
+
-	if err != nil {
+	if podID == "" {
-		return nil, err
+		return nil, logging.Errorf("GetComputeDeviceMap(): invalid Pod cannot be empty")
 	}
-	for _, pod := range podEntires {
+
+	for _, pod := range cp.podEntires {
 		if pod.PodUID == podID {
 			entry, ok := resourceMap[pod.ResourceName]
 			if ok {

k8sclient/k8sclient.go

@@ -349,12 +349,20 @@ func getKubernetesDelegate(client KubeClient, net *types.NetworkSelectionElement
 	deviceID := ""
 	resourceName, ok := customResource.Metadata.Annotations[resourceNameAnnot]
 	if ok && podID != "" {
-		logging.Debugf("getKubernetesDelegate: found resourceName annotation : %s", resourceName)
 		// ResourceName annotation is found; try to get device info from resourceMap
-		resourceMap, err := checkpoint.GetComputeDeviceMap(podID)
+		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 {
@@ -493,18 +501,18 @@ func GetK8sNetwork(k8sclient KubeClient, k8sArgs *types.K8sArgs, confdir string)
 	}
 
 	// resourceMap holds Pod device allocation information; only initizized if CRD contains 'resourceName' annotation.
-	// This is only initialized once and all delegate objects can reference this to look up device info.
+	// 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, resourceMap, err := getKubernetesDelegate(k8sclient, net, confdir, podID, resourceMap)
+		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 // workaround for 'Go' error: 'resourceMap' declared and not used.
+		resourceMap = updatedResourceMap
 	}
 
 	return delegates, nil