vendor update for CSI 0.3.0

vendor/k8s.io/kubernetes/pkg/kubelet/checkpoint/BUILD

@@ -7,9 +7,8 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//pkg/apis/core:go_default_library",
-        "//pkg/volume/util:go_default_library",
-        "//vendor/github.com/dchest/safefile:go_default_library",
-        "//vendor/github.com/ghodss/yaml:go_default_library",
+        "//pkg/kubelet/checkpointmanager:go_default_library",
+        "//pkg/kubelet/checkpointmanager/checksum:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
     ],
@@ -21,6 +20,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//pkg/apis/core:go_default_library",
+        "//pkg/kubelet/checkpointmanager:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
     ],

vendor/k8s.io/kubernetes/pkg/kubelet/checkpoint/checkpoint.go

@@ -17,20 +17,15 @@ limitations under the License.
 package checkpoint
 
 import (
+	"encoding/json"
 	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
 
-	"github.com/dchest/safefile"
-	"github.com/ghodss/yaml"
 	"github.com/golang/glog"
 
 	"k8s.io/api/core/v1"
 	"k8s.io/kubernetes/pkg/apis/core"
-	"k8s.io/kubernetes/pkg/volume/util"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager/checksum"
 )
 
 const (
@@ -39,54 +34,44 @@ const (
 	podPrefix = "Pod"
 )
 
-// Manager is the interface used to manage checkpoints
-// which involves writing resources to disk to recover
-// during restart or failure scenarios.
-// https://github.com/kubernetes/community/pull/1241/files
-type Manager interface {
-	// LoadPods will load checkpointed Pods from disk
-	LoadPods() ([]*v1.Pod, error)
-
-	// WritePod will serialize a Pod to disk
-	WritePod(pod *v1.Pod) error
-
-	// Deletes the checkpoint of the given pod from disk
-	DeletePod(pod *v1.Pod) error
+type PodCheckpoint interface {
+	checkpointmanager.Checkpoint
+	GetPod() *v1.Pod
 }
 
-var instance Manager
-var mutex = &sync.Mutex{}
-
-// fileCheckPointManager - is a checkpointer that writes contents to disk
-// The type information of the resource objects are encoded in the name
-type fileCheckPointManager struct {
-	path string
+// Data to be stored as checkpoint
+type Data struct {
+	Pod      *v1.Pod
+	Checksum checksum.Checksum
 }
 
-// NewCheckpointManager will create a Manager that points to the following path
-func NewCheckpointManager(path string) Manager {
-	// NOTE: This is a precaution; current implementation should not run
-	// multiple checkpoint managers.
-	mutex.Lock()
-	defer mutex.Unlock()
-	instance = &fileCheckPointManager{path: path}
-	return instance
+// NewPodCheckpoint returns new pod checkpoint
+func NewPodCheckpoint(pod *v1.Pod) PodCheckpoint {
+	return &Data{Pod: pod}
 }
 
-// GetInstance will return the current Manager, there should be only one.
-func GetInstance() Manager {
-	mutex.Lock()
-	defer mutex.Unlock()
-	return instance
+// MarshalCheckpoint returns marshalled data
+func (cp *Data) MarshalCheckpoint() ([]byte, error) {
+	cp.Checksum = checksum.New(*cp.Pod)
+	return json.Marshal(*cp)
 }
 
-// loadPod will load Pod Checkpoint yaml file.
-func (fcp *fileCheckPointManager) loadPod(file string) (*v1.Pod, error) {
-	return util.LoadPodFromFile(file)
+// UnmarshalCheckpoint returns unmarshalled data
+func (cp *Data) UnmarshalCheckpoint(blob []byte) error {
+	return json.Unmarshal(blob, cp)
+}
+
+// VerifyChecksum verifies that passed checksum is same as calculated checksum
+func (cp *Data) VerifyChecksum() error {
+	return cp.Checksum.Verify(*cp.Pod)
+}
+
+func (cp *Data) GetPod() *v1.Pod {
+	return cp.Pod
 }
 
 // checkAnnotations will validate the checkpoint annotations exist on the Pod
-func (fcp *fileCheckPointManager) checkAnnotations(pod *v1.Pod) bool {
+func checkAnnotations(pod *v1.Pod) bool {
 	if podAnnotations := pod.GetAnnotations(); podAnnotations != nil {
 		if podAnnotations[core.BootstrapCheckpointAnnotationKey] == "true" {
 			return true
@@ -95,57 +80,49 @@ func (fcp *fileCheckPointManager) checkAnnotations(pod *v1.Pod) bool {
 	return false
 }
 
-// getPodPath returns the full qualified path for the pod checkpoint
-func (fcp *fileCheckPointManager) getPodPath(pod *v1.Pod) string {
-	return fmt.Sprintf("%v/Pod%v%v.yaml", fcp.path, delimiter, pod.GetUID())
+//getPodKey returns the full qualified path for the pod checkpoint
+func getPodKey(pod *v1.Pod) string {
+	return fmt.Sprintf("Pod%v%v.yaml", delimiter, pod.GetUID())
 }
 
 // LoadPods Loads All Checkpoints from disk
-func (fcp *fileCheckPointManager) LoadPods() ([]*v1.Pod, error) {
-	checkpoints := make([]*v1.Pod, 0)
-	files, err := ioutil.ReadDir(fcp.path)
+func LoadPods(cpm checkpointmanager.CheckpointManager) ([]*v1.Pod, error) {
+	pods := make([]*v1.Pod, 0)
+
+	var err error
+	checkpointKeys := []string{}
+	checkpointKeys, err = cpm.ListCheckpoints()
 	if err != nil {
-		return nil, err
+		glog.Errorf("Failed to list checkpoints: %v", err)
 	}
-	for _, f := range files {
-		// get just the filename
-		_, fname := filepath.Split(f.Name())
-		// Get just the Resource from "Resource_Name"
-		fnfields := strings.Split(fname, delimiter)
-		switch fnfields[0] {
-		case podPrefix:
-			pod, err := fcp.loadPod(fmt.Sprintf("%s/%s", fcp.path, f.Name()))
-			if err != nil {
-				return nil, err
-			}
-			checkpoints = append(checkpoints, pod)
-		default:
-			glog.Warningf("Unsupported checkpoint file detected %v", f)
+
+	for _, key := range checkpointKeys {
+		checkpoint := NewPodCheckpoint(nil)
+		err := cpm.GetCheckpoint(key, checkpoint)
+		if err != nil {
+			glog.Errorf("Failed to retrieve checkpoint for pod %q: %v", key, err)
+			continue
 		}
+		pods = append(pods, checkpoint.GetPod())
 	}
-	return checkpoints, nil
+	return pods, nil
 }
 
-// Writes a checkpoint to a file on disk if annotation is present
-func (fcp *fileCheckPointManager) WritePod(pod *v1.Pod) error {
+// WritePod a checkpoint to a file on disk if annotation is present
+func WritePod(cpm checkpointmanager.CheckpointManager, pod *v1.Pod) error {
 	var err error
-	if fcp.checkAnnotations(pod) {
-		if blob, err := yaml.Marshal(pod); err == nil {
-			err = safefile.WriteFile(fcp.getPodPath(pod), blob, 0644)
-		}
+	if checkAnnotations(pod) {
+		data := NewPodCheckpoint(pod)
+		err = cpm.CreateCheckpoint(getPodKey(pod), data)
 	} else {
 		// This is to handle an edge where a pod update could remove
 		// an annotation and the checkpoint should then be removed.
-		err = fcp.DeletePod(pod)
+		err = cpm.RemoveCheckpoint(getPodKey(pod))
 	}
 	return err
 }
 
-// Deletes a checkpoint from disk if present
-func (fcp *fileCheckPointManager) DeletePod(pod *v1.Pod) error {
-	podPath := fcp.getPodPath(pod)
-	if err := os.Remove(podPath); !os.IsNotExist(err) {
-		return err
-	}
-	return nil
+// DeletePod deletes a checkpoint from disk if present
+func DeletePod(cpm checkpointmanager.CheckpointManager, pod *v1.Pod) error {
+	return cpm.RemoveCheckpoint(getPodKey(pod))
 }

vendor/k8s.io/kubernetes/pkg/kubelet/checkpoint/checkpoint_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager"
 )
 
 // TestWriteLoadDeletePods validates all combinations of write, load, and delete
@@ -70,15 +71,18 @@ func TestWriteLoadDeletePods(t *testing.T) {
 	}
 	defer os.RemoveAll(dir)
 
-	cp := NewCheckpointManager(dir)
+	cpm, err := checkpointmanager.NewCheckpointManager(dir)
+	if err != nil {
+		t.Errorf("Failed to initialize checkpoint manager error=%v", err)
+	}
 	for _, p := range testPods {
 		// Write pods should always pass unless there is an fs error
-		if err := cp.WritePod(p.pod); err != nil {
+		if err := WritePod(cpm, p.pod); err != nil {
 			t.Errorf("Failed to Write Pod: %v", err)
 		}
 	}
 	// verify the correct written files are loaded from disk
-	pods, err := cp.LoadPods()
+	pods, err := LoadPods(cpm)
 	if err != nil {
 		t.Errorf("Failed to Load Pods: %v", err)
 	}
@@ -104,7 +108,7 @@ func TestWriteLoadDeletePods(t *testing.T) {
 		} else if lpod != nil {
 			t.Errorf("Got unexpected result for %v, should not have been loaded", pname)
 		}
-		err = cp.DeletePod(p.pod)
+		err = DeletePod(cpm, p.pod)
 		if err != nil {
 			t.Errorf("Failed to delete pod %v", pname)
 		}