Replace godep with dep

vendor/k8s.io/kubernetes/pkg/controller/volume/OWNERS

@@ -0,0 +1,13 @@
+approvers:
+- childsb
+- jsafrane
+- saad-ali
+reviewers:
+- childsb
+- saad-ali
+- jsafrane
+- jingxu97
+- pmorie
+- justinsb
+- rootfs
+- gnufied

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/BUILD

@@ -0,0 +1,76 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["attach_detach_controller.go"],
+    deps = [
+        "//pkg/cloudprovider:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/populator:go_default_library",
+        "//pkg/controller/volume/attachdetach/reconciler:go_default_library",
+        "//pkg/controller/volume/attachdetach/statusupdater:go_default_library",
+        "//pkg/controller/volume/attachdetach/util:go_default_library",
+        "//pkg/util/io:go_default_library",
+        "//pkg/util/mount:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/operationexecutor:go_default_library",
+        "//pkg/volume/util/volumehelper:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["attach_detach_controller_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/testing:go_default_library",
+        "//pkg/volume: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/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/controller/volume/attachdetach/cache:all-srcs",
+        "//pkg/controller/volume/attachdetach/populator:all-srcs",
+        "//pkg/controller/volume/attachdetach/reconciler:all-srcs",
+        "//pkg/controller/volume/attachdetach/statusupdater:all-srcs",
+        "//pkg/controller/volume/attachdetach/testing:all-srcs",
+        "//pkg/controller/volume/attachdetach/util:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/OWNERS

@@ -0,0 +1,2 @@
+approvers:
+- saad-ali

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/attach_detach_controller.go

@@ -0,0 +1,595 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 volume implements a controller to manage volume attach and detach
+// operations.
+package attachdetach
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/runtime"
+	coreinformers "k8s.io/client-go/informers/core/v1"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes/scheme"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	kcache "k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/populator"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/reconciler"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/util"
+	"k8s.io/kubernetes/pkg/util/io"
+	"k8s.io/kubernetes/pkg/util/mount"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+// TimerConfig contains configuration of internal attach/detach timers and
+// should be used only to speed up tests. DefaultTimerConfig is the suggested
+// timer configuration for production.
+type TimerConfig struct {
+	// ReconcilerLoopPeriod is the amount of time the reconciler loop waits
+	// between successive executions
+	ReconcilerLoopPeriod time.Duration
+
+	// ReconcilerMaxWaitForUnmountDuration is the maximum amount of time the
+	// attach detach controller will wait for a volume to be safely unmounted
+	// from its node. Once this time has expired, the controller will assume the
+	// node or kubelet are unresponsive and will detach the volume anyway.
+	ReconcilerMaxWaitForUnmountDuration time.Duration
+
+	// DesiredStateOfWorldPopulatorLoopSleepPeriod is the amount of time the
+	// DesiredStateOfWorldPopulator loop waits between successive executions
+	DesiredStateOfWorldPopulatorLoopSleepPeriod time.Duration
+
+	// DesiredStateOfWorldPopulatorListPodsRetryDuration is the amount of
+	// time the DesiredStateOfWorldPopulator loop waits between list pods
+	// calls.
+	DesiredStateOfWorldPopulatorListPodsRetryDuration time.Duration
+}
+
+// DefaultTimerConfig is the default configuration of Attach/Detach controller
+// timers.
+var DefaultTimerConfig TimerConfig = TimerConfig{
+	ReconcilerLoopPeriod:                              100 * time.Millisecond,
+	ReconcilerMaxWaitForUnmountDuration:               6 * time.Minute,
+	DesiredStateOfWorldPopulatorLoopSleepPeriod:       1 * time.Minute,
+	DesiredStateOfWorldPopulatorListPodsRetryDuration: 3 * time.Minute,
+}
+
+// AttachDetachController defines the operations supported by this controller.
+type AttachDetachController interface {
+	Run(stopCh <-chan struct{})
+	GetDesiredStateOfWorld() cache.DesiredStateOfWorld
+}
+
+// NewAttachDetachController returns a new instance of AttachDetachController.
+func NewAttachDetachController(
+	kubeClient clientset.Interface,
+	podInformer coreinformers.PodInformer,
+	nodeInformer coreinformers.NodeInformer,
+	pvcInformer coreinformers.PersistentVolumeClaimInformer,
+	pvInformer coreinformers.PersistentVolumeInformer,
+	cloud cloudprovider.Interface,
+	plugins []volume.VolumePlugin,
+	prober volume.DynamicPluginProber,
+	disableReconciliationSync bool,
+	reconcilerSyncDuration time.Duration,
+	timerConfig TimerConfig) (AttachDetachController, error) {
+	// TODO: The default resyncPeriod for shared informers is 12 hours, this is
+	// unacceptable for the attach/detach controller. For example, if a pod is
+	// skipped because the node it is scheduled to didn't set its annotation in
+	// time, we don't want to have to wait 12hrs before processing the pod
+	// again.
+	// Luckily https://github.com/kubernetes/kubernetes/issues/23394 is being
+	// worked on and will split resync in to resync and relist. Once that
+	// happens the resync period can be set to something much faster (30
+	// seconds).
+	// If that issue is not resolved in time, then this controller will have to
+	// consider some unappealing alternate options: use a non-shared informer
+	// and set a faster resync period even if it causes relist, or requeue
+	// dropped pods so they are continuously processed until it is accepted or
+	// deleted (probably can't do this with sharedInformer), etc.
+	adc := &attachDetachController{
+		kubeClient:  kubeClient,
+		pvcLister:   pvcInformer.Lister(),
+		pvcsSynced:  pvcInformer.Informer().HasSynced,
+		pvLister:    pvInformer.Lister(),
+		pvsSynced:   pvInformer.Informer().HasSynced,
+		podLister:   podInformer.Lister(),
+		podsSynced:  podInformer.Informer().HasSynced,
+		nodeLister:  nodeInformer.Lister(),
+		nodesSynced: nodeInformer.Informer().HasSynced,
+		cloud:       cloud,
+	}
+
+	if err := adc.volumePluginMgr.InitPlugins(plugins, prober, adc); err != nil {
+		return nil, fmt.Errorf("Could not initialize volume plugins for Attach/Detach Controller: %+v", err)
+	}
+
+	eventBroadcaster := record.NewBroadcaster()
+	eventBroadcaster.StartLogging(glog.Infof)
+	eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: v1core.New(kubeClient.Core().RESTClient()).Events("")})
+	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "attachdetach"})
+
+	adc.desiredStateOfWorld = cache.NewDesiredStateOfWorld(&adc.volumePluginMgr)
+	adc.actualStateOfWorld = cache.NewActualStateOfWorld(&adc.volumePluginMgr)
+	adc.attacherDetacher =
+		operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(
+			kubeClient,
+			&adc.volumePluginMgr,
+			recorder,
+			false)) // flag for experimental binary check for volume mount
+	adc.nodeStatusUpdater = statusupdater.NewNodeStatusUpdater(
+		kubeClient, nodeInformer.Lister(), adc.actualStateOfWorld)
+
+	// Default these to values in options
+	adc.reconciler = reconciler.NewReconciler(
+		timerConfig.ReconcilerLoopPeriod,
+		timerConfig.ReconcilerMaxWaitForUnmountDuration,
+		reconcilerSyncDuration,
+		disableReconciliationSync,
+		adc.desiredStateOfWorld,
+		adc.actualStateOfWorld,
+		adc.attacherDetacher,
+		adc.nodeStatusUpdater,
+		recorder)
+
+	adc.desiredStateOfWorldPopulator = populator.NewDesiredStateOfWorldPopulator(
+		timerConfig.DesiredStateOfWorldPopulatorLoopSleepPeriod,
+		timerConfig.DesiredStateOfWorldPopulatorListPodsRetryDuration,
+		podInformer.Lister(),
+		adc.desiredStateOfWorld,
+		&adc.volumePluginMgr,
+		pvcInformer.Lister(),
+		pvInformer.Lister())
+
+	podInformer.Informer().AddEventHandler(kcache.ResourceEventHandlerFuncs{
+		AddFunc:    adc.podAdd,
+		UpdateFunc: adc.podUpdate,
+		DeleteFunc: adc.podDelete,
+	})
+
+	nodeInformer.Informer().AddEventHandler(kcache.ResourceEventHandlerFuncs{
+		AddFunc:    adc.nodeAdd,
+		UpdateFunc: adc.nodeUpdate,
+		DeleteFunc: adc.nodeDelete,
+	})
+
+	return adc, nil
+}
+
+type attachDetachController struct {
+	// kubeClient is the kube API client used by volumehost to communicate with
+	// the API server.
+	kubeClient clientset.Interface
+
+	// pvcLister is the shared PVC lister used to fetch and store PVC
+	// objects from the API server. It is shared with other controllers and
+	// therefore the PVC objects in its store should be treated as immutable.
+	pvcLister  corelisters.PersistentVolumeClaimLister
+	pvcsSynced kcache.InformerSynced
+
+	// pvLister is the shared PV lister used to fetch and store PV objects
+	// from the API server. It is shared with other controllers and therefore
+	// the PV objects in its store should be treated as immutable.
+	pvLister  corelisters.PersistentVolumeLister
+	pvsSynced kcache.InformerSynced
+
+	podLister  corelisters.PodLister
+	podsSynced kcache.InformerSynced
+
+	nodeLister  corelisters.NodeLister
+	nodesSynced kcache.InformerSynced
+
+	// cloud provider used by volume host
+	cloud cloudprovider.Interface
+
+	// volumePluginMgr used to initialize and fetch volume plugins
+	volumePluginMgr volume.VolumePluginMgr
+
+	// desiredStateOfWorld is a data structure containing the desired state of
+	// the world according to this controller: i.e. what nodes the controller
+	// is managing, what volumes it wants be attached to these nodes, and which
+	// pods are scheduled to those nodes referencing the volumes.
+	// The data structure is populated by the controller using a stream of node
+	// and pod API server objects fetched by the informers.
+	desiredStateOfWorld cache.DesiredStateOfWorld
+
+	// actualStateOfWorld is a data structure containing the actual state of
+	// the world according to this controller: i.e. which volumes are attached
+	// to which nodes.
+	// The data structure is populated upon successful completion of attach and
+	// detach actions triggered by the controller and a periodic sync with
+	// storage providers for the "true" state of the world.
+	actualStateOfWorld cache.ActualStateOfWorld
+
+	// attacherDetacher is used to start asynchronous attach and operations
+	attacherDetacher operationexecutor.OperationExecutor
+
+	// reconciler is used to run an asynchronous periodic loop to reconcile the
+	// desiredStateOfWorld with the actualStateOfWorld by triggering attach
+	// detach operations using the attacherDetacher.
+	reconciler reconciler.Reconciler
+
+	// nodeStatusUpdater is used to update node status with the list of attached
+	// volumes
+	nodeStatusUpdater statusupdater.NodeStatusUpdater
+
+	// desiredStateOfWorldPopulator runs an asynchronous periodic loop to
+	// populate the current pods using podInformer.
+	desiredStateOfWorldPopulator populator.DesiredStateOfWorldPopulator
+
+	// recorder is used to record events in the API server
+	recorder record.EventRecorder
+}
+
+func (adc *attachDetachController) Run(stopCh <-chan struct{}) {
+	defer runtime.HandleCrash()
+
+	glog.Infof("Starting attach detach controller")
+	defer glog.Infof("Shutting down attach detach controller")
+
+	if !controller.WaitForCacheSync("attach detach", stopCh, adc.podsSynced, adc.nodesSynced, adc.pvcsSynced, adc.pvsSynced) {
+		return
+	}
+
+	err := adc.populateActualStateOfWorld()
+	if err != nil {
+		glog.Errorf("Error populating the actual state of world: %v", err)
+	}
+	err = adc.populateDesiredStateOfWorld()
+	if err != nil {
+		glog.Errorf("Error populating the desired state of world: %v", err)
+	}
+	go adc.reconciler.Run(stopCh)
+	go adc.desiredStateOfWorldPopulator.Run(stopCh)
+
+	<-stopCh
+}
+
+func (adc *attachDetachController) populateActualStateOfWorld() error {
+	glog.V(5).Infof("Populating ActualStateOfworld")
+	nodes, err := adc.nodeLister.List(labels.Everything())
+	if err != nil {
+		return err
+	}
+
+	for _, node := range nodes {
+		nodeName := types.NodeName(node.Name)
+		for _, attachedVolume := range node.Status.VolumesAttached {
+			uniqueName := attachedVolume.Name
+			// The nil VolumeSpec is safe only in the case the volume is not in use by any pod.
+			// In such a case it should be detached in the first reconciliation cycle and the
+			// volume spec is not needed to detach a volume. If the volume is used by a pod, it
+			// its spec can be: this would happen during in the populateDesiredStateOfWorld which
+			// scans the pods and updates their volumes in the ActualStateOfWorld too.
+			err = adc.actualStateOfWorld.MarkVolumeAsAttached(uniqueName, nil /* VolumeSpec */, nodeName, attachedVolume.DevicePath)
+			if err != nil {
+				glog.Errorf("Failed to mark the volume as attached: %v", err)
+				continue
+			}
+			adc.processVolumesInUse(nodeName, node.Status.VolumesInUse, true /* forceUnmount */)
+			adc.addNodeToDswp(node, types.NodeName(node.Name))
+		}
+	}
+	return nil
+}
+
+func (adc *attachDetachController) getNodeVolumeDevicePath(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) (string, error) {
+	var devicePath string
+	var found bool
+	node, err := adc.nodeLister.Get(string(nodeName))
+	if err != nil {
+		return devicePath, err
+	}
+	for _, attachedVolume := range node.Status.VolumesAttached {
+		if volumeName == attachedVolume.Name {
+			devicePath = attachedVolume.DevicePath
+			found = true
+			break
+		}
+	}
+	if !found {
+		err = fmt.Errorf("Volume %s not found on node %s", volumeName, nodeName)
+	}
+
+	return devicePath, err
+}
+
+func (adc *attachDetachController) populateDesiredStateOfWorld() error {
+	glog.V(5).Infof("Populating DesiredStateOfworld")
+
+	pods, err := adc.podLister.List(labels.Everything())
+	if err != nil {
+		return err
+	}
+	for _, pod := range pods {
+		podToAdd := pod
+		adc.podAdd(&podToAdd)
+		for _, podVolume := range podToAdd.Spec.Volumes {
+			// The volume specs present in the ActualStateOfWorld are nil, let's replace those
+			// with the correct ones found on pods. The present in the ASW with no corresponding
+			// pod will be detached and the spec is irrelevant.
+			volumeSpec, err := util.CreateVolumeSpec(podVolume, podToAdd.Namespace, adc.pvcLister, adc.pvLister)
+			if err != nil {
+				glog.Errorf(
+					"Error creating spec for volume %q, pod %q/%q: %v",
+					podVolume.Name,
+					podToAdd.Namespace,
+					podToAdd.Name,
+					err)
+				continue
+			}
+			nodeName := types.NodeName(podToAdd.Spec.NodeName)
+			plugin, err := adc.volumePluginMgr.FindAttachablePluginBySpec(volumeSpec)
+			if err != nil || plugin == nil {
+				glog.V(10).Infof(
+					"Skipping volume %q for pod %q/%q: it does not implement attacher interface. err=%v",
+					podVolume.Name,
+					podToAdd.Namespace,
+					podToAdd.Name,
+					err)
+				continue
+			}
+			volumeName, err := volumehelper.GetUniqueVolumeNameFromSpec(plugin, volumeSpec)
+			if err != nil {
+				glog.Errorf(
+					"Failed to find unique name for volume %q, pod %q/%q: %v",
+					podVolume.Name,
+					podToAdd.Namespace,
+					podToAdd.Name,
+					err)
+				continue
+			}
+			if adc.actualStateOfWorld.VolumeNodeExists(volumeName, nodeName) {
+				devicePath, err := adc.getNodeVolumeDevicePath(volumeName, nodeName)
+				if err != nil {
+					glog.Errorf("Failed to find device path: %v", err)
+					continue
+				}
+				err = adc.actualStateOfWorld.MarkVolumeAsAttached(volumeName, volumeSpec, nodeName, devicePath)
+				if err != nil {
+					glog.Errorf("Failed to update volume spec for node %s: %v", nodeName, err)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (adc *attachDetachController) podAdd(obj interface{}) {
+	pod, ok := obj.(*v1.Pod)
+	if pod == nil || !ok {
+		return
+	}
+	if pod.Spec.NodeName == "" {
+		// Ignore pods without NodeName, indicating they are not scheduled.
+		return
+	}
+
+	volumeActionFlag := util.DetermineVolumeAction(
+		pod,
+		adc.desiredStateOfWorld,
+		true /* default volume action */)
+
+	util.ProcessPodVolumes(pod, volumeActionFlag, /* addVolumes */
+		adc.desiredStateOfWorld, &adc.volumePluginMgr, adc.pvcLister, adc.pvLister)
+}
+
+// GetDesiredStateOfWorld returns desired state of world associated with controller
+func (adc *attachDetachController) GetDesiredStateOfWorld() cache.DesiredStateOfWorld {
+	return adc.desiredStateOfWorld
+}
+
+func (adc *attachDetachController) podUpdate(oldObj, newObj interface{}) {
+	pod, ok := newObj.(*v1.Pod)
+	if pod == nil || !ok {
+		return
+	}
+	if pod.Spec.NodeName == "" {
+		// Ignore pods without NodeName, indicating they are not scheduled.
+		return
+	}
+
+	volumeActionFlag := util.DetermineVolumeAction(
+		pod,
+		adc.desiredStateOfWorld,
+		true /* default volume action */)
+
+	util.ProcessPodVolumes(pod, volumeActionFlag, /* addVolumes */
+		adc.desiredStateOfWorld, &adc.volumePluginMgr, adc.pvcLister, adc.pvLister)
+}
+
+func (adc *attachDetachController) podDelete(obj interface{}) {
+	pod, ok := obj.(*v1.Pod)
+	if pod == nil || !ok {
+		return
+	}
+
+	util.ProcessPodVolumes(pod, false, /* addVolumes */
+		adc.desiredStateOfWorld, &adc.volumePluginMgr, adc.pvcLister, adc.pvLister)
+}
+
+func (adc *attachDetachController) nodeAdd(obj interface{}) {
+	node, ok := obj.(*v1.Node)
+	// TODO: investigate if nodeName is empty then if we can return
+	// kubernetes/kubernetes/issues/37777
+	if node == nil || !ok {
+		return
+	}
+	nodeName := types.NodeName(node.Name)
+	adc.nodeUpdate(nil, obj)
+	// kubernetes/kubernetes/issues/37586
+	// This is to workaround the case when a node add causes to wipe out
+	// the attached volumes field. This function ensures that we sync with
+	// the actual status.
+	adc.actualStateOfWorld.SetNodeStatusUpdateNeeded(nodeName)
+}
+
+func (adc *attachDetachController) nodeUpdate(oldObj, newObj interface{}) {
+	node, ok := newObj.(*v1.Node)
+	// TODO: investigate if nodeName is empty then if we can return
+	if node == nil || !ok {
+		return
+	}
+
+	nodeName := types.NodeName(node.Name)
+	adc.addNodeToDswp(node, nodeName)
+	adc.processVolumesInUse(nodeName, node.Status.VolumesInUse, false /* forceUnmount */)
+}
+
+func (adc *attachDetachController) nodeDelete(obj interface{}) {
+	node, ok := obj.(*v1.Node)
+	if node == nil || !ok {
+		return
+	}
+
+	nodeName := types.NodeName(node.Name)
+	if err := adc.desiredStateOfWorld.DeleteNode(nodeName); err != nil {
+		// This might happen during drain, but we still want it to appear in our logs
+		glog.Infof("error removing node %q from desired-state-of-world: %v", nodeName, err)
+	}
+
+	adc.processVolumesInUse(nodeName, node.Status.VolumesInUse, false /* forceUnmount */)
+}
+
+// processVolumesInUse processes the list of volumes marked as "in-use"
+// according to the specified Node's Status.VolumesInUse and updates the
+// corresponding volume in the actual state of the world to indicate that it is
+// mounted.
+func (adc *attachDetachController) processVolumesInUse(
+	nodeName types.NodeName, volumesInUse []v1.UniqueVolumeName, forceUnmount bool) {
+	glog.V(4).Infof("processVolumesInUse for node %q", nodeName)
+	for _, attachedVolume := range adc.actualStateOfWorld.GetAttachedVolumesForNode(nodeName) {
+		mounted := false
+		for _, volumeInUse := range volumesInUse {
+			if attachedVolume.VolumeName == volumeInUse {
+				mounted = true
+				break
+			}
+		}
+		err := adc.actualStateOfWorld.SetVolumeMountedByNode(
+			attachedVolume.VolumeName, nodeName, mounted, forceUnmount)
+		if err != nil {
+			glog.Warningf(
+				"SetVolumeMountedByNode(%q, %q, %q) returned an error: %v",
+				attachedVolume.VolumeName, nodeName, mounted, err)
+		}
+	}
+}
+
+// VolumeHost implementation
+// This is an unfortunate requirement of the current factoring of volume plugin
+// initializing code. It requires kubelet specific methods used by the mounting
+// code to be implemented by all initializers even if the initializer does not
+// do mounting (like this attach/detach controller).
+// Issue kubernetes/kubernetes/issues/14217 to fix this.
+func (adc *attachDetachController) GetPluginDir(podUID string) string {
+	return ""
+}
+
+func (adc *attachDetachController) GetPodVolumeDir(podUID types.UID, pluginName, volumeName string) string {
+	return ""
+}
+
+func (adc *attachDetachController) GetPodPluginDir(podUID types.UID, pluginName string) string {
+	return ""
+}
+
+func (adc *attachDetachController) GetKubeClient() clientset.Interface {
+	return adc.kubeClient
+}
+
+func (adc *attachDetachController) NewWrapperMounter(volName string, spec volume.Spec, pod *v1.Pod, opts volume.VolumeOptions) (volume.Mounter, error) {
+	return nil, fmt.Errorf("NewWrapperMounter not supported by Attach/Detach controller's VolumeHost implementation")
+}
+
+func (adc *attachDetachController) NewWrapperUnmounter(volName string, spec volume.Spec, podUID types.UID) (volume.Unmounter, error) {
+	return nil, fmt.Errorf("NewWrapperUnmounter not supported by Attach/Detach controller's VolumeHost implementation")
+}
+
+func (adc *attachDetachController) GetCloudProvider() cloudprovider.Interface {
+	return adc.cloud
+}
+
+func (adc *attachDetachController) GetMounter(pluginName string) mount.Interface {
+	return nil
+}
+
+func (adc *attachDetachController) GetWriter() io.Writer {
+	return nil
+}
+
+func (adc *attachDetachController) GetHostName() string {
+	return ""
+}
+
+func (adc *attachDetachController) GetHostIP() (net.IP, error) {
+	return nil, fmt.Errorf("GetHostIP() not supported by Attach/Detach controller's VolumeHost implementation")
+}
+
+func (adc *attachDetachController) GetNodeAllocatable() (v1.ResourceList, error) {
+	return v1.ResourceList{}, nil
+}
+
+func (adc *attachDetachController) GetSecretFunc() func(namespace, name string) (*v1.Secret, error) {
+	return func(_, _ string) (*v1.Secret, error) {
+		return nil, fmt.Errorf("GetSecret unsupported in attachDetachController")
+	}
+}
+
+func (adc *attachDetachController) GetConfigMapFunc() func(namespace, name string) (*v1.ConfigMap, error) {
+	return func(_, _ string) (*v1.ConfigMap, error) {
+		return nil, fmt.Errorf("GetConfigMap unsupported in attachDetachController")
+	}
+}
+
+func (adc *attachDetachController) GetExec(pluginName string) mount.Exec {
+	return mount.NewOsExec()
+}
+
+func (adc *attachDetachController) addNodeToDswp(node *v1.Node, nodeName types.NodeName) {
+	if _, exists := node.Annotations[volumehelper.ControllerManagedAttachAnnotation]; exists {
+		keepTerminatedPodVolumes := false
+
+		if t, ok := node.Annotations[volumehelper.KeepTerminatedPodVolumesAnnotation]; ok {
+			keepTerminatedPodVolumes = (t == "true")
+		}
+
+		// Node specifies annotation indicating it should be managed by attach
+		// detach controller. Add it to desired state of world.
+		adc.desiredStateOfWorld.AddNode(nodeName, keepTerminatedPodVolumes)
+	}
+}
+
+func (adc *attachDetachController) GetNodeLabels() (map[string]string, error) {
+	return nil, fmt.Errorf("GetNodeLabels() unsupported in Attach/Detach controller")
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/attach_detach_controller_test.go

@@ -0,0 +1,301 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 attachdetach
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/informers"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	controllervolumetesting "k8s.io/kubernetes/pkg/controller/volume/attachdetach/testing"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+func Test_NewAttachDetachController_Positive(t *testing.T) {
+	// Arrange
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	informerFactory := informers.NewSharedInformerFactory(fakeKubeClient, controller.NoResyncPeriodFunc())
+
+	// Act
+	_, err := NewAttachDetachController(
+		fakeKubeClient,
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		nil, /* cloud */
+		nil, /* plugins */
+		nil, /* prober */
+		false,
+		5*time.Second,
+		DefaultTimerConfig)
+
+	// Assert
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: <%v>", err)
+	}
+}
+
+func Test_AttachDetachControllerStateOfWolrdPopulators_Positive(t *testing.T) {
+	// Arrange
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	informerFactory := informers.NewSharedInformerFactory(fakeKubeClient, controller.NoResyncPeriodFunc())
+	podInformer := informerFactory.Core().V1().Pods()
+	nodeInformer := informerFactory.Core().V1().Nodes()
+	pvcInformer := informerFactory.Core().V1().PersistentVolumeClaims()
+	pvInformer := informerFactory.Core().V1().PersistentVolumes()
+
+	adc := &attachDetachController{
+		kubeClient:  fakeKubeClient,
+		pvcLister:   pvcInformer.Lister(),
+		pvcsSynced:  pvcInformer.Informer().HasSynced,
+		pvLister:    pvInformer.Lister(),
+		pvsSynced:   pvInformer.Informer().HasSynced,
+		podLister:   podInformer.Lister(),
+		podsSynced:  podInformer.Informer().HasSynced,
+		nodeLister:  nodeInformer.Lister(),
+		nodesSynced: nodeInformer.Informer().HasSynced,
+		cloud:       nil,
+	}
+
+	// Act
+	plugins := controllervolumetesting.CreateTestPlugin()
+	var prober volume.DynamicPluginProber = nil // TODO (#51147) inject mock
+
+	if err := adc.volumePluginMgr.InitPlugins(plugins, prober, adc); err != nil {
+		t.Fatalf("Could not initialize volume plugins for Attach/Detach Controller: %+v", err)
+	}
+
+	adc.actualStateOfWorld = cache.NewActualStateOfWorld(&adc.volumePluginMgr)
+	adc.desiredStateOfWorld = cache.NewDesiredStateOfWorld(&adc.volumePluginMgr)
+
+	err := adc.populateActualStateOfWorld()
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: <%v>", err)
+	}
+
+	err = adc.populateDesiredStateOfWorld()
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: %v", err)
+	}
+
+	// Test the ActualStateOfWorld contains all the node volumes
+	nodes, err := adc.nodeLister.List(labels.Everything())
+	if err != nil {
+		t.Fatalf("Failed to list nodes in indexer. Expected: <no error> Actual: %v", err)
+	}
+
+	for _, node := range nodes {
+		nodeName := types.NodeName(node.Name)
+		for _, attachedVolume := range node.Status.VolumesAttached {
+			found := adc.actualStateOfWorld.VolumeNodeExists(attachedVolume.Name, nodeName)
+			if !found {
+				t.Fatalf("Run failed with error. Node %s, volume %s not found", nodeName, attachedVolume.Name)
+			}
+		}
+	}
+
+	pods, err := adc.podLister.List(labels.Everything())
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: %v", err)
+	}
+	for _, pod := range pods {
+		uniqueName := fmt.Sprintf("%s/%s", controllervolumetesting.TestPluginName, pod.Spec.Volumes[0].Name)
+		nodeName := types.NodeName(pod.Spec.NodeName)
+		found := adc.desiredStateOfWorld.VolumeExists(v1.UniqueVolumeName(uniqueName), nodeName)
+		if !found {
+			t.Fatalf("Run failed with error. Volume %s, node %s not found in DesiredStateOfWorld",
+				pod.Spec.Volumes[0].Name,
+				pod.Spec.NodeName)
+		}
+	}
+}
+
+func Test_AttachDetachControllerRecovery(t *testing.T) {
+	attachDetachRecoveryTestCase(t, []*v1.Pod{}, []*v1.Pod{})
+	newPod1 := controllervolumetesting.NewPodWithVolume("newpod-1", "volumeName2", "mynode-1")
+	attachDetachRecoveryTestCase(t, []*v1.Pod{newPod1}, []*v1.Pod{})
+	newPod1 = controllervolumetesting.NewPodWithVolume("newpod-1", "volumeName2", "mynode-1")
+	attachDetachRecoveryTestCase(t, []*v1.Pod{}, []*v1.Pod{newPod1})
+	newPod1 = controllervolumetesting.NewPodWithVolume("newpod-1", "volumeName2", "mynode-1")
+	newPod2 := controllervolumetesting.NewPodWithVolume("newpod-2", "volumeName3", "mynode-1")
+	attachDetachRecoveryTestCase(t, []*v1.Pod{newPod1}, []*v1.Pod{newPod2})
+}
+
+func attachDetachRecoveryTestCase(t *testing.T, extraPods1 []*v1.Pod, extraPods2 []*v1.Pod) {
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	informerFactory := informers.NewSharedInformerFactory(fakeKubeClient, time.Second*1)
+	//informerFactory := informers.NewSharedInformerFactory(fakeKubeClient, time.Second*1)
+	plugins := controllervolumetesting.CreateTestPlugin()
+	var prober volume.DynamicPluginProber = nil // TODO (#51147) inject mock
+	nodeInformer := informerFactory.Core().V1().Nodes().Informer()
+	podInformer := informerFactory.Core().V1().Pods().Informer()
+	var podsNum, extraPodsNum, nodesNum, i int
+
+	stopCh := make(chan struct{})
+
+	pods, err := fakeKubeClient.Core().Pods(v1.NamespaceAll).List(metav1.ListOptions{})
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: %v", err)
+	}
+
+	for _, pod := range pods.Items {
+		podToAdd := pod
+		podInformer.GetIndexer().Add(&podToAdd)
+		podsNum++
+	}
+	nodes, err := fakeKubeClient.Core().Nodes().List(metav1.ListOptions{})
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: %v", err)
+	}
+	for _, node := range nodes.Items {
+		nodeToAdd := node
+		nodeInformer.GetIndexer().Add(&nodeToAdd)
+		nodesNum++
+	}
+
+	informerFactory.Start(stopCh)
+
+	if !controller.WaitForCacheSync("attach detach", stopCh,
+		informerFactory.Core().V1().Pods().Informer().HasSynced,
+		informerFactory.Core().V1().Nodes().Informer().HasSynced) {
+		t.Fatalf("Error waiting for the informer caches to sync")
+	}
+
+	// Make sure the nodes and pods are in the inforer cache
+	i = 0
+	nodeList, err := informerFactory.Core().V1().Nodes().Lister().List(labels.Everything())
+	for len(nodeList) < nodesNum {
+		if err != nil {
+			t.Fatalf("Error getting list of nodes %v", err)
+		}
+		if i > 100 {
+			t.Fatalf("Time out while waiting for the node informer sync: found %d nodes, expected %d nodes", len(nodeList), nodesNum)
+		}
+		time.Sleep(100 * time.Millisecond)
+		nodeList, err = informerFactory.Core().V1().Nodes().Lister().List(labels.Everything())
+		i++
+	}
+	i = 0
+	podList, err := informerFactory.Core().V1().Pods().Lister().List(labels.Everything())
+	for len(podList) < podsNum {
+		if err != nil {
+			t.Fatalf("Error getting list of nodes %v", err)
+		}
+		if i > 100 {
+			t.Fatalf("Time out while waiting for the pod informer sync: found %d pods, expected %d pods", len(podList), podsNum)
+		}
+		time.Sleep(100 * time.Millisecond)
+		podList, err = informerFactory.Core().V1().Pods().Lister().List(labels.Everything())
+		i++
+	}
+
+	// Create the controller
+	adcObj, err := NewAttachDetachController(
+		fakeKubeClient,
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		nil, /* cloud */
+		plugins,
+		prober,
+		false,
+		1*time.Second,
+		DefaultTimerConfig)
+
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: <%v>", err)
+	}
+
+	adc := adcObj.(*attachDetachController)
+
+	// Populate ASW
+	err = adc.populateActualStateOfWorld()
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: <%v>", err)
+	}
+
+	for _, newPod := range extraPods1 {
+		// Add a new pod between ASW and DSW ppoulators
+		_, err = adc.kubeClient.Core().Pods(newPod.ObjectMeta.Namespace).Create(newPod)
+		if err != nil {
+			t.Fatalf("Run failed with error. Failed to create a new pod: <%v>", err)
+		}
+		extraPodsNum++
+		podInformer.GetIndexer().Add(newPod)
+
+	}
+
+	// Populate DSW
+	err = adc.populateDesiredStateOfWorld()
+	if err != nil {
+		t.Fatalf("Run failed with error. Expected: <no error> Actual: %v", err)
+	}
+
+	for _, newPod := range extraPods2 {
+		// Add a new pod between DSW ppoulator and reconciler run
+		_, err = adc.kubeClient.Core().Pods(newPod.ObjectMeta.Namespace).Create(newPod)
+		if err != nil {
+			t.Fatalf("Run failed with error. Failed to create a new pod: <%v>", err)
+		}
+		extraPodsNum++
+		podInformer.GetIndexer().Add(newPod)
+	}
+
+	go adc.reconciler.Run(stopCh)
+	go adc.desiredStateOfWorldPopulator.Run(stopCh)
+	defer close(stopCh)
+
+	time.Sleep(time.Second * 1) // Wait so the reconciler calls sync at least once
+
+	testPlugin := plugins[0].(*controllervolumetesting.TestPlugin)
+	for i = 0; i <= 10; i++ {
+		var attachedVolumesNum int = 0
+		var detachedVolumesNum int = 0
+
+		time.Sleep(time.Second * 1) // Wait for a second
+		for _, volumeList := range testPlugin.GetAttachedVolumes() {
+			attachedVolumesNum += len(volumeList)
+		}
+		for _, volumeList := range testPlugin.GetDetachedVolumes() {
+			detachedVolumesNum += len(volumeList)
+		}
+
+		// All the "extra pods" should result in volume to be attached, the pods all share one volume
+		// which should be attached (+1), the volumes found only in the nodes status should be detached
+		if attachedVolumesNum == 1+extraPodsNum && detachedVolumesNum == nodesNum {
+			break
+		}
+		if i == 10 { // 10 seconds time out
+			t.Fatalf("Waiting for the volumes to attach/detach timed out: attached %d (expected %d); detached %d (%d)",
+				attachedVolumesNum, 1+extraPodsNum, detachedVolumesNum, nodesNum)
+		}
+	}
+
+	if testPlugin.GetErrorEncountered() {
+		t.Fatalf("Fatal error encountered in the testing volume plugin")
+	}
+
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "actual_state_of_world.go",
+        "desired_state_of_world.go",
+    ],
+    deps = [
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/operationexecutor:go_default_library",
+        "//pkg/volume/util/types:go_default_library",
+        "//pkg/volume/util/volumehelper:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "actual_state_of_world_test.go",
+        "desired_state_of_world_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/controller/volume/attachdetach/testing:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+        "//pkg/volume/util/types:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache/actual_state_of_world.go

@@ -0,0 +1,655 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 cache implements data structures used by the attach/detach controller
+to keep track of volumes, the nodes they are attached to, and the pods that
+reference them.
+*/
+package cache
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/golang/glog"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+// ActualStateOfWorld defines a set of thread-safe operations supported on
+// the attach/detach controller's actual state of the world cache.
+// This cache contains volumes->nodes i.e. a set of all volumes and the nodes
+// the attach/detach controller believes are successfully attached.
+// Note: This is distinct from the ActualStateOfWorld implemented by the kubelet
+// volume manager. They both keep track of different objects. This contains
+// attach/detach controller specific state.
+type ActualStateOfWorld interface {
+	// ActualStateOfWorld must implement the methods required to allow
+	// operationexecutor to interact with it.
+	operationexecutor.ActualStateOfWorldAttacherUpdater
+
+	// AddVolumeNode adds the given volume and node to the underlying store
+	// indicating the specified volume is attached to the specified node.
+	// A unique volume name is generated from the volumeSpec and returned on
+	// success.
+	// If volumeSpec is not an attachable volume plugin, an error is returned.
+	// If no volume with the name volumeName exists in the store, the volume is
+	// added.
+	// If no node with the name nodeName exists in list of attached nodes for
+	// the specified volume, the node is added.
+	AddVolumeNode(uniqueName v1.UniqueVolumeName, volumeSpec *volume.Spec, nodeName types.NodeName, devicePath string) (v1.UniqueVolumeName, error)
+
+	// SetVolumeMountedByNode sets the MountedByNode value for the given volume
+	// and node. When set to true the mounted parameter indicates the volume
+	// is mounted by the given node, indicating it may not be safe to detach.
+	// If the forceUnmount is set to true the MountedByNode value would be reset
+	// to false even it was not set yet (this is required during a controller
+	// crash recovery).
+	// If no volume with the name volumeName exists in the store, an error is
+	// returned.
+	// If no node with the name nodeName exists in list of attached nodes for
+	// the specified volume, an error is returned.
+	SetVolumeMountedByNode(volumeName v1.UniqueVolumeName, nodeName types.NodeName, mounted bool, forceUnmount bool) error
+
+	// SetNodeStatusUpdateNeeded sets statusUpdateNeeded for the specified
+	// node to true indicating the AttachedVolume field in the Node's Status
+	// object needs to be updated by the node updater again.
+	// If the specifed node does not exist in the nodesToUpdateStatusFor list,
+	// log the error and return
+	SetNodeStatusUpdateNeeded(nodeName types.NodeName)
+
+	// ResetDetachRequestTime resets the detachRequestTime to 0 which indicates there is no detach
+	// request any more for the volume
+	ResetDetachRequestTime(volumeName v1.UniqueVolumeName, nodeName types.NodeName)
+
+	// SetDetachRequestTime sets the detachRequestedTime to current time if this is no
+	// previous request (the previous detachRequestedTime is zero) and return the time elapsed
+	// since last request
+	SetDetachRequestTime(volumeName v1.UniqueVolumeName, nodeName types.NodeName) (time.Duration, error)
+
+	// DeleteVolumeNode removes the given volume and node from the underlying
+	// store indicating the specified volume is no longer attached to the
+	// specified node.
+	// If the volume/node combo does not exist, this is a no-op.
+	// If after deleting the node, the specified volume contains no other child
+	// nodes, the volume is also deleted.
+	DeleteVolumeNode(volumeName v1.UniqueVolumeName, nodeName types.NodeName)
+
+	// VolumeNodeExists returns true if the specified volume/node combo exists
+	// in the underlying store indicating the specified volume is attached to
+	// the specified node.
+	VolumeNodeExists(volumeName v1.UniqueVolumeName, nodeName types.NodeName) bool
+
+	// GetAttachedVolumes generates and returns a list of volumes/node pairs
+	// reflecting which volumes are attached to which nodes based on the
+	// current actual state of the world.
+	GetAttachedVolumes() []AttachedVolume
+
+	// GetAttachedVolumes generates and returns a list of volumes attached to
+	// the specified node reflecting which volumes are attached to that node
+	// based on the current actual state of the world.
+	GetAttachedVolumesForNode(nodeName types.NodeName) []AttachedVolume
+
+	GetAttachedVolumesPerNode() map[types.NodeName][]operationexecutor.AttachedVolume
+
+	// GetNodesForVolume returns the nodes on which the volume is attached
+	GetNodesForVolume(volumeName v1.UniqueVolumeName) []types.NodeName
+
+	// GetVolumesToReportAttached returns a map containing the set of nodes for
+	// which the VolumesAttached Status field in the Node API object should be
+	// updated. The key in this map is the name of the node to update and the
+	// value is list of volumes that should be reported as attached (note that
+	// this may differ from the actual list of attached volumes for the node
+	// since volumes should be removed from this list as soon a detach operation
+	// is considered, before the detach operation is triggered).
+	GetVolumesToReportAttached() map[types.NodeName][]v1.AttachedVolume
+
+	// GetNodesToUpdateStatusFor returns the map of nodeNames to nodeToUpdateStatusFor
+	GetNodesToUpdateStatusFor() map[types.NodeName]nodeToUpdateStatusFor
+}
+
+// AttachedVolume represents a volume that is attached to a node.
+type AttachedVolume struct {
+	operationexecutor.AttachedVolume
+
+	// MountedByNode indicates that this volume has been been mounted by the
+	// node and is unsafe to detach.
+	// The value is set and unset by SetVolumeMountedByNode(...).
+	MountedByNode bool
+
+	// DetachRequestedTime is used to capture the desire to detach this volume.
+	// When the volume is newly created this value is set to time zero.
+	// It is set to current time, when SetDetachRequestTime(...) is called, if it
+	// was previously set to zero (other wise its value remains the same).
+	// It is reset to zero on ResetDetachRequestTime(...) calls.
+	DetachRequestedTime time.Time
+}
+
+// NewActualStateOfWorld returns a new instance of ActualStateOfWorld.
+func NewActualStateOfWorld(volumePluginMgr *volume.VolumePluginMgr) ActualStateOfWorld {
+	return &actualStateOfWorld{
+		attachedVolumes:        make(map[v1.UniqueVolumeName]attachedVolume),
+		nodesToUpdateStatusFor: make(map[types.NodeName]nodeToUpdateStatusFor),
+		volumePluginMgr:        volumePluginMgr,
+	}
+}
+
+type actualStateOfWorld struct {
+	// attachedVolumes is a map containing the set of volumes the attach/detach
+	// controller believes to be successfully attached to the nodes it is
+	// managing. The key in this map is the name of the volume and the value is
+	// an object containing more information about the attached volume.
+	attachedVolumes map[v1.UniqueVolumeName]attachedVolume
+
+	// nodesToUpdateStatusFor is a map containing the set of nodes for which to
+	// update the VolumesAttached Status field. The key in this map is the name
+	// of the node and the value is an object containing more information about
+	// the node (including the list of volumes to report attached).
+	nodesToUpdateStatusFor map[types.NodeName]nodeToUpdateStatusFor
+
+	// volumePluginMgr is the volume plugin manager used to create volume
+	// plugin objects.
+	volumePluginMgr *volume.VolumePluginMgr
+
+	sync.RWMutex
+}
+
+// The volume object represents a volume the the attach/detach controller
+// believes to be successfully attached to a node it is managing.
+type attachedVolume struct {
+	// volumeName contains the unique identifier for this volume.
+	volumeName v1.UniqueVolumeName
+
+	// spec is the volume spec containing the specification for this volume.
+	// Used to generate the volume plugin object, and passed to attach/detach
+	// methods.
+	spec *volume.Spec
+
+	// nodesAttachedTo is a map containing the set of nodes this volume has
+	// successfully been attached to. The key in this map is the name of the
+	// node and the value is a node object containing more information about
+	// the node.
+	nodesAttachedTo map[types.NodeName]nodeAttachedTo
+
+	// devicePath contains the path on the node where the volume is attached
+	devicePath string
+}
+
+// The nodeAttachedTo object represents a node that has volumes attached to it.
+type nodeAttachedTo struct {
+	// nodeName contains the name of this node.
+	nodeName types.NodeName
+
+	// mountedByNode indicates that this node/volume combo is mounted by the
+	// node and is unsafe to detach
+	mountedByNode bool
+
+	// number of times SetVolumeMountedByNode has been called to set the value
+	// of mountedByNode to true. This is used to prevent mountedByNode from
+	// being reset during the period between attach and mount when volumesInUse
+	// status for the node may not be set.
+	mountedByNodeSetCount uint
+
+	// detachRequestedTime used to capture the desire to detach this volume
+	detachRequestedTime time.Time
+}
+
+// nodeToUpdateStatusFor is an object that reflects a node that has one or more
+// volume attached. It keeps track of the volumes that should be reported as
+// attached in the Node's Status API object.
+type nodeToUpdateStatusFor struct {
+	// nodeName contains the name of this node.
+	nodeName types.NodeName
+
+	// statusUpdateNeeded indicates that the value of the VolumesAttached field
+	// in the Node's Status API object should be updated. This should be set to
+	// true whenever a volume is added or deleted from
+	// volumesToReportAsAttached. It should be reset whenever the status is
+	// updated.
+	statusUpdateNeeded bool
+
+	// volumesToReportAsAttached is the list of volumes that should be reported
+	// as attached in the Node's status (note that this may differ from the
+	// actual list of attached volumes since volumes should be removed from this
+	// list as soon a detach operation is considered, before the detach
+	// operation is triggered).
+	volumesToReportAsAttached map[v1.UniqueVolumeName]v1.UniqueVolumeName
+}
+
+func (asw *actualStateOfWorld) MarkVolumeAsAttached(
+	uniqueName v1.UniqueVolumeName, volumeSpec *volume.Spec, nodeName types.NodeName, devicePath string) error {
+	_, err := asw.AddVolumeNode(uniqueName, volumeSpec, nodeName, devicePath)
+	return err
+}
+
+func (asw *actualStateOfWorld) MarkVolumeAsDetached(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) {
+	asw.DeleteVolumeNode(volumeName, nodeName)
+}
+
+func (asw *actualStateOfWorld) RemoveVolumeFromReportAsAttached(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) error {
+	asw.Lock()
+	defer asw.Unlock()
+	return asw.removeVolumeFromReportAsAttached(volumeName, nodeName)
+}
+
+func (asw *actualStateOfWorld) AddVolumeToReportAsAttached(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) {
+	asw.Lock()
+	defer asw.Unlock()
+	asw.addVolumeToReportAsAttached(volumeName, nodeName)
+}
+
+func (asw *actualStateOfWorld) AddVolumeNode(
+	uniqueName v1.UniqueVolumeName, volumeSpec *volume.Spec, nodeName types.NodeName, devicePath string) (v1.UniqueVolumeName, error) {
+	asw.Lock()
+	defer asw.Unlock()
+
+	var volumeName v1.UniqueVolumeName
+	if volumeSpec != nil {
+		attachableVolumePlugin, err := asw.volumePluginMgr.FindAttachablePluginBySpec(volumeSpec)
+		if err != nil || attachableVolumePlugin == nil {
+			return "", fmt.Errorf(
+				"failed to get AttachablePlugin from volumeSpec for volume %q err=%v",
+				volumeSpec.Name(),
+				err)
+		}
+
+		volumeName, err = volumehelper.GetUniqueVolumeNameFromSpec(
+			attachableVolumePlugin, volumeSpec)
+		if err != nil {
+			return "", fmt.Errorf(
+				"failed to GetUniqueVolumeNameFromSpec for volumeSpec %q err=%v",
+				volumeSpec.Name(),
+				err)
+		}
+	} else {
+		// volumeSpec is nil
+		// This happens only on controller startup when reading the volumes from node
+		// status; if the pods using the volume have been removed and are unreachable
+		// the volumes should be detached immediately and the spec is not needed
+		volumeName = uniqueName
+	}
+
+	volumeObj, volumeExists := asw.attachedVolumes[volumeName]
+	if !volumeExists {
+		volumeObj = attachedVolume{
+			volumeName:      volumeName,
+			spec:            volumeSpec,
+			nodesAttachedTo: make(map[types.NodeName]nodeAttachedTo),
+			devicePath:      devicePath,
+		}
+	} else {
+		// If volume object already exists, it indicates that the information would be out of date.
+		// Update the fields for volume object except the nodes attached to the volumes.
+		volumeObj.devicePath = devicePath
+		volumeObj.spec = volumeSpec
+		glog.V(2).Infof("Volume %q is already added to attachedVolume list to node %q, update device path %q",
+			volumeName,
+			nodeName,
+			devicePath)
+	}
+	asw.attachedVolumes[volumeName] = volumeObj
+
+	_, nodeExists := volumeObj.nodesAttachedTo[nodeName]
+	if !nodeExists {
+		// Create object if it doesn't exist.
+		volumeObj.nodesAttachedTo[nodeName] = nodeAttachedTo{
+			nodeName:              nodeName,
+			mountedByNode:         true, // Assume mounted, until proven otherwise
+			mountedByNodeSetCount: 0,
+			detachRequestedTime:   time.Time{},
+		}
+	} else {
+		glog.V(5).Infof("Volume %q is already added to attachedVolume list to the node %q",
+			volumeName,
+			nodeName)
+	}
+
+	asw.addVolumeToReportAsAttached(volumeName, nodeName)
+	return volumeName, nil
+}
+
+func (asw *actualStateOfWorld) SetVolumeMountedByNode(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName, mounted bool, forceUnmount bool) error {
+	asw.Lock()
+	defer asw.Unlock()
+
+	volumeObj, nodeObj, err := asw.getNodeAndVolume(volumeName, nodeName)
+	if err != nil {
+		return fmt.Errorf("Failed to SetVolumeMountedByNode with error: %v", err)
+	}
+
+	if mounted {
+		// Increment set count
+		nodeObj.mountedByNodeSetCount = nodeObj.mountedByNodeSetCount + 1
+	} else {
+		// Do not allow value to be reset unless it has been set at least once
+		if nodeObj.mountedByNodeSetCount == 0 && !forceUnmount {
+			return nil
+		}
+	}
+
+	nodeObj.mountedByNode = mounted
+	volumeObj.nodesAttachedTo[nodeName] = nodeObj
+	glog.V(4).Infof("SetVolumeMountedByNode volume %v to the node %q mounted %t",
+		volumeName,
+		nodeName,
+		mounted)
+	return nil
+}
+
+func (asw *actualStateOfWorld) ResetDetachRequestTime(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) {
+	asw.Lock()
+	defer asw.Unlock()
+
+	volumeObj, nodeObj, err := asw.getNodeAndVolume(volumeName, nodeName)
+	if err != nil {
+		glog.Errorf("Failed to ResetDetachRequestTime with error: %v", err)
+		return
+	}
+	nodeObj.detachRequestedTime = time.Time{}
+	volumeObj.nodesAttachedTo[nodeName] = nodeObj
+}
+
+func (asw *actualStateOfWorld) SetDetachRequestTime(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) (time.Duration, error) {
+	asw.Lock()
+	defer asw.Unlock()
+
+	volumeObj, nodeObj, err := asw.getNodeAndVolume(volumeName, nodeName)
+	if err != nil {
+		return 0, fmt.Errorf("Failed to set detach request time with error: %v", err)
+	}
+	// If there is no previous detach request, set it to the current time
+	if nodeObj.detachRequestedTime.IsZero() {
+		nodeObj.detachRequestedTime = time.Now()
+		volumeObj.nodesAttachedTo[nodeName] = nodeObj
+		glog.V(4).Infof("Set detach request time to current time for volume %v on node %q",
+			volumeName,
+			nodeName)
+	}
+	return time.Since(nodeObj.detachRequestedTime), nil
+}
+
+// Get the volume and node object from actual state of world
+// This is an internal function and caller should acquire and release the lock
+//
+// Note that this returns disconnected objects, so if you change the volume object you must set it back with
+// `asw.attachedVolumes[volumeName]=volumeObj`.
+//
+// If you change the node object you must use `volumeObj.nodesAttachedTo[nodeName] = nodeObj`
+// This is correct, because if volumeObj is empty this function returns an error, and nodesAttachedTo
+// map is a reference type, and thus mutating the copy changes the original map.
+func (asw *actualStateOfWorld) getNodeAndVolume(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) (attachedVolume, nodeAttachedTo, error) {
+
+	volumeObj, volumeExists := asw.attachedVolumes[volumeName]
+	if volumeExists {
+		nodeObj, nodeExists := volumeObj.nodesAttachedTo[nodeName]
+		if nodeExists {
+			return volumeObj, nodeObj, nil
+		}
+	}
+
+	return attachedVolume{}, nodeAttachedTo{}, fmt.Errorf("volume %v is no longer attached to the node %q",
+		volumeName,
+		nodeName)
+}
+
+// Remove the volumeName from the node's volumesToReportAsAttached list
+// This is an internal function and caller should acquire and release the lock
+func (asw *actualStateOfWorld) removeVolumeFromReportAsAttached(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) error {
+
+	nodeToUpdate, nodeToUpdateExists := asw.nodesToUpdateStatusFor[nodeName]
+	if nodeToUpdateExists {
+		_, nodeToUpdateVolumeExists :=
+			nodeToUpdate.volumesToReportAsAttached[volumeName]
+		if nodeToUpdateVolumeExists {
+			nodeToUpdate.statusUpdateNeeded = true
+			delete(nodeToUpdate.volumesToReportAsAttached, volumeName)
+			asw.nodesToUpdateStatusFor[nodeName] = nodeToUpdate
+			return nil
+		}
+	}
+	return fmt.Errorf("volume %q does not exist in volumesToReportAsAttached list or node %q does not exist in nodesToUpdateStatusFor list",
+		volumeName,
+		nodeName)
+
+}
+
+// Add the volumeName to the node's volumesToReportAsAttached list
+// This is an internal function and caller should acquire and release the lock
+func (asw *actualStateOfWorld) addVolumeToReportAsAttached(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) {
+	// In case the volume/node entry is no longer in attachedVolume list, skip the rest
+	if _, _, err := asw.getNodeAndVolume(volumeName, nodeName); err != nil {
+		glog.V(4).Infof("Volume %q is no longer attached to node %q", volumeName, nodeName)
+		return
+	}
+	nodeToUpdate, nodeToUpdateExists := asw.nodesToUpdateStatusFor[nodeName]
+	if !nodeToUpdateExists {
+		// Create object if it doesn't exist
+		nodeToUpdate = nodeToUpdateStatusFor{
+			nodeName:                  nodeName,
+			statusUpdateNeeded:        true,
+			volumesToReportAsAttached: make(map[v1.UniqueVolumeName]v1.UniqueVolumeName),
+		}
+		asw.nodesToUpdateStatusFor[nodeName] = nodeToUpdate
+		glog.V(4).Infof("Add new node %q to nodesToUpdateStatusFor", nodeName)
+	}
+	_, nodeToUpdateVolumeExists :=
+		nodeToUpdate.volumesToReportAsAttached[volumeName]
+	if !nodeToUpdateVolumeExists {
+		nodeToUpdate.statusUpdateNeeded = true
+		nodeToUpdate.volumesToReportAsAttached[volumeName] = volumeName
+		asw.nodesToUpdateStatusFor[nodeName] = nodeToUpdate
+		glog.V(4).Infof("Report volume %q as attached to node %q", volumeName, nodeName)
+	}
+}
+
+// Update the flag statusUpdateNeeded to indicate whether node status is already updated or
+// needs to be updated again by the node status updater.
+// If the specifed node does not exist in the nodesToUpdateStatusFor list, log the error and return
+// This is an internal function and caller should acquire and release the lock
+func (asw *actualStateOfWorld) updateNodeStatusUpdateNeeded(nodeName types.NodeName, needed bool) error {
+	nodeToUpdate, nodeToUpdateExists := asw.nodesToUpdateStatusFor[nodeName]
+	if !nodeToUpdateExists {
+		// should not happen
+		errMsg := fmt.Sprintf("Failed to set statusUpdateNeeded to needed %t because nodeName=%q  does not exist",
+			needed, nodeName)
+		glog.Errorf(errMsg)
+		return fmt.Errorf(errMsg)
+	}
+
+	nodeToUpdate.statusUpdateNeeded = needed
+	asw.nodesToUpdateStatusFor[nodeName] = nodeToUpdate
+
+	return nil
+}
+
+func (asw *actualStateOfWorld) SetNodeStatusUpdateNeeded(nodeName types.NodeName) {
+	asw.Lock()
+	defer asw.Unlock()
+	if err := asw.updateNodeStatusUpdateNeeded(nodeName, true); err != nil {
+		glog.Errorf("Failed to update statusUpdateNeeded field in actual state of world: %v", err)
+	}
+}
+
+func (asw *actualStateOfWorld) DeleteVolumeNode(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) {
+	asw.Lock()
+	defer asw.Unlock()
+
+	volumeObj, volumeExists := asw.attachedVolumes[volumeName]
+	if !volumeExists {
+		return
+	}
+
+	_, nodeExists := volumeObj.nodesAttachedTo[nodeName]
+	if nodeExists {
+		delete(asw.attachedVolumes[volumeName].nodesAttachedTo, nodeName)
+	}
+
+	if len(volumeObj.nodesAttachedTo) == 0 {
+		delete(asw.attachedVolumes, volumeName)
+	}
+
+	// Remove volume from volumes to report as attached
+	asw.removeVolumeFromReportAsAttached(volumeName, nodeName)
+}
+
+func (asw *actualStateOfWorld) VolumeNodeExists(
+	volumeName v1.UniqueVolumeName, nodeName types.NodeName) bool {
+	asw.RLock()
+	defer asw.RUnlock()
+
+	volumeObj, volumeExists := asw.attachedVolumes[volumeName]
+	if volumeExists {
+		if _, nodeExists := volumeObj.nodesAttachedTo[nodeName]; nodeExists {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (asw *actualStateOfWorld) GetAttachedVolumes() []AttachedVolume {
+	asw.RLock()
+	defer asw.RUnlock()
+
+	attachedVolumes := make([]AttachedVolume, 0 /* len */, len(asw.attachedVolumes) /* cap */)
+	for _, volumeObj := range asw.attachedVolumes {
+		for _, nodeObj := range volumeObj.nodesAttachedTo {
+			attachedVolumes = append(
+				attachedVolumes,
+				getAttachedVolume(&volumeObj, &nodeObj))
+		}
+	}
+
+	return attachedVolumes
+}
+
+func (asw *actualStateOfWorld) GetAttachedVolumesForNode(
+	nodeName types.NodeName) []AttachedVolume {
+	asw.RLock()
+	defer asw.RUnlock()
+
+	attachedVolumes := make(
+		[]AttachedVolume, 0 /* len */, len(asw.attachedVolumes) /* cap */)
+	for _, volumeObj := range asw.attachedVolumes {
+		for actualNodeName, nodeObj := range volumeObj.nodesAttachedTo {
+			if actualNodeName == nodeName {
+				attachedVolumes = append(
+					attachedVolumes,
+					getAttachedVolume(&volumeObj, &nodeObj))
+			}
+		}
+	}
+
+	return attachedVolumes
+}
+
+func (asw *actualStateOfWorld) GetAttachedVolumesPerNode() map[types.NodeName][]operationexecutor.AttachedVolume {
+	asw.RLock()
+	defer asw.RUnlock()
+
+	attachedVolumesPerNode := make(map[types.NodeName][]operationexecutor.AttachedVolume)
+	for _, volumeObj := range asw.attachedVolumes {
+		for nodeName, nodeObj := range volumeObj.nodesAttachedTo {
+			volumes := attachedVolumesPerNode[nodeName]
+			volumes = append(volumes, getAttachedVolume(&volumeObj, &nodeObj).AttachedVolume)
+			attachedVolumesPerNode[nodeName] = volumes
+		}
+	}
+
+	return attachedVolumesPerNode
+}
+
+func (asw *actualStateOfWorld) GetNodesForVolume(volumeName v1.UniqueVolumeName) []types.NodeName {
+	asw.RLock()
+	defer asw.RUnlock()
+
+	volumeObj, volumeExists := asw.attachedVolumes[volumeName]
+	if !volumeExists || len(volumeObj.nodesAttachedTo) == 0 {
+		return []types.NodeName{}
+	}
+
+	nodes := []types.NodeName{}
+	for k := range volumeObj.nodesAttachedTo {
+		nodes = append(nodes, k)
+	}
+	return nodes
+}
+
+func (asw *actualStateOfWorld) GetVolumesToReportAttached() map[types.NodeName][]v1.AttachedVolume {
+	asw.RLock()
+	defer asw.RUnlock()
+
+	volumesToReportAttached := make(map[types.NodeName][]v1.AttachedVolume)
+	for nodeName, nodeToUpdateObj := range asw.nodesToUpdateStatusFor {
+		if nodeToUpdateObj.statusUpdateNeeded {
+			attachedVolumes := make(
+				[]v1.AttachedVolume,
+				len(nodeToUpdateObj.volumesToReportAsAttached) /* len */)
+			i := 0
+			for _, volume := range nodeToUpdateObj.volumesToReportAsAttached {
+				attachedVolumes[i] = v1.AttachedVolume{
+					Name:       volume,
+					DevicePath: asw.attachedVolumes[volume].devicePath,
+				}
+				i++
+			}
+			volumesToReportAttached[nodeToUpdateObj.nodeName] = attachedVolumes
+		}
+		// When GetVolumesToReportAttached is called by node status updater, the current status
+		// of this node will be updated, so set the flag statusUpdateNeeded to false indicating
+		// the current status is already updated.
+		if err := asw.updateNodeStatusUpdateNeeded(nodeName, false); err != nil {
+			glog.Errorf("Failed to update statusUpdateNeeded field when getting volumes: %v", err)
+		}
+	}
+
+	return volumesToReportAttached
+}
+
+func (asw *actualStateOfWorld) GetNodesToUpdateStatusFor() map[types.NodeName]nodeToUpdateStatusFor {
+	return asw.nodesToUpdateStatusFor
+}
+
+func getAttachedVolume(
+	attachedVolume *attachedVolume,
+	nodeAttachedTo *nodeAttachedTo) AttachedVolume {
+	return AttachedVolume{
+		AttachedVolume: operationexecutor.AttachedVolume{
+			VolumeName:         attachedVolume.volumeName,
+			VolumeSpec:         attachedVolume.spec,
+			NodeName:           nodeAttachedTo.nodeName,
+			DevicePath:         attachedVolume.devicePath,
+			PluginIsAttachable: true,
+		},
+		MountedByNode:       nodeAttachedTo.mountedByNode,
+		DetachRequestedTime: nodeAttachedTo.detachRequestedTime}
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache/desired_state_of_world.go

@@ -0,0 +1,395 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 cache implements data structures used by the attach/detach controller
+to keep track of volumes, the nodes they are attached to, and the pods that
+reference them.
+*/
+package cache
+
+import (
+	"fmt"
+	"sync"
+
+	"k8s.io/api/core/v1"
+	k8stypes "k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+	"k8s.io/kubernetes/pkg/volume/util/types"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+// DesiredStateOfWorld defines a set of thread-safe operations supported on
+// the attach/detach controller's desired state of the world cache.
+// This cache contains nodes->volumes->pods where nodes are all the nodes
+// managed by the attach/detach controller, volumes are all the volumes that
+// should be attached to the specified node, and pods are the pods that
+// reference the volume and are scheduled to that node.
+// Note: This is distinct from the DesiredStateOfWorld implemented by the
+// kubelet volume manager. The both keep track of different objects. This
+// contains attach/detach controller specific state.
+type DesiredStateOfWorld interface {
+	// AddNode adds the given node to the list of nodes managed by the attach/
+	// detach controller.
+	// If the node already exists this is a no-op.
+	// keepTerminatedPodVolumes is a property of the node that determines
+	// if for terminated pods volumes should be mounted and attached.
+	AddNode(nodeName k8stypes.NodeName, keepTerminatedPodVolumes bool)
+
+	// AddPod adds the given pod to the list of pods that reference the
+	// specified volume and is scheduled to the specified node.
+	// A unique volumeName is generated from the volumeSpec and returned on
+	// success.
+	// If the pod already exists under the specified volume, this is a no-op.
+	// If volumeSpec is not an attachable volume plugin, an error is returned.
+	// If no volume with the name volumeName exists in the list of volumes that
+	// should be attached to the specified node, the volume is implicitly added.
+	// If no node with the name nodeName exists in list of nodes managed by the
+	// attach/detach attached controller, an error is returned.
+	AddPod(podName types.UniquePodName, pod *v1.Pod, volumeSpec *volume.Spec, nodeName k8stypes.NodeName) (v1.UniqueVolumeName, error)
+
+	// DeleteNode removes the given node from the list of nodes managed by the
+	// attach/detach controller.
+	// If the node does not exist this is a no-op.
+	// If the node exists but has 1 or more child volumes, an error is returned.
+	DeleteNode(nodeName k8stypes.NodeName) error
+
+	// DeletePod removes the given pod from the list of pods that reference the
+	// specified volume and are scheduled to the specified node.
+	// If no pod exists in the list of pods that reference the specified volume
+	// and are scheduled to the specified node, this is a no-op.
+	// If a node with the name nodeName does not exist in the list of nodes
+	// managed by the attach/detach attached controller, this is a no-op.
+	// If no volume with the name volumeName exists in the list of managed
+	// volumes under the specified node, this is a no-op.
+	// If after deleting the pod, the specified volume contains no other child
+	// pods, the volume is also deleted.
+	DeletePod(podName types.UniquePodName, volumeName v1.UniqueVolumeName, nodeName k8stypes.NodeName)
+
+	// NodeExists returns true if the node with the specified name exists in
+	// the list of nodes managed by the attach/detach controller.
+	NodeExists(nodeName k8stypes.NodeName) bool
+
+	// VolumeExists returns true if the volume with the specified name exists
+	// in the list of volumes that should be attached to the specified node by
+	// the attach detach controller.
+	VolumeExists(volumeName v1.UniqueVolumeName, nodeName k8stypes.NodeName) bool
+
+	// GetVolumesToAttach generates and returns a list of volumes to attach
+	// and the nodes they should be attached to based on the current desired
+	// state of the world.
+	GetVolumesToAttach() []VolumeToAttach
+
+	// GetPodToAdd generates and returns a map of pods based on the current desired
+	// state of world
+	GetPodToAdd() map[types.UniquePodName]PodToAdd
+
+	// GetKeepTerminatedPodVolumesForNode determines if node wants volumes to be
+	// mounted and attached for terminated pods
+	GetKeepTerminatedPodVolumesForNode(k8stypes.NodeName) bool
+}
+
+// VolumeToAttach represents a volume that should be attached to a node.
+type VolumeToAttach struct {
+	operationexecutor.VolumeToAttach
+}
+
+// PodToAdd represents a pod that references the underlying volume and is
+// scheduled to the underlying node.
+type PodToAdd struct {
+	// pod contains the api object of pod
+	Pod *v1.Pod
+
+	// volumeName contains the unique identifier for this volume.
+	VolumeName v1.UniqueVolumeName
+
+	// nodeName contains the name of this node.
+	NodeName k8stypes.NodeName
+}
+
+// NewDesiredStateOfWorld returns a new instance of DesiredStateOfWorld.
+func NewDesiredStateOfWorld(volumePluginMgr *volume.VolumePluginMgr) DesiredStateOfWorld {
+	return &desiredStateOfWorld{
+		nodesManaged:    make(map[k8stypes.NodeName]nodeManaged),
+		volumePluginMgr: volumePluginMgr,
+	}
+}
+
+type desiredStateOfWorld struct {
+	// nodesManaged is a map containing the set of nodes managed by the attach/
+	// detach controller. The key in this map is the name of the node and the
+	// value is a node object containing more information about the node.
+	nodesManaged map[k8stypes.NodeName]nodeManaged
+	// volumePluginMgr is the volume plugin manager used to create volume
+	// plugin objects.
+	volumePluginMgr *volume.VolumePluginMgr
+	sync.RWMutex
+}
+
+// nodeManaged represents a node that is being managed by the attach/detach
+// controller.
+type nodeManaged struct {
+	// nodeName contains the name of this node.
+	nodeName k8stypes.NodeName
+
+	// volumesToAttach is a map containing the set of volumes that should be
+	// attached to this node. The key in the map is the name of the volume and
+	// the value is a pod object containing more information about the volume.
+	volumesToAttach map[v1.UniqueVolumeName]volumeToAttach
+
+	// keepTerminatedPodVolumes determines if for terminated pods(on this node) - volumes
+	// should be kept mounted and attached.
+	keepTerminatedPodVolumes bool
+}
+
+// The volume object represents a volume that should be attached to a node.
+type volumeToAttach struct {
+	// multiAttachErrorReported indicates whether the multi-attach error has been reported for the given volume.
+	// It is used to to prevent reporting the error from being reported more than once for a given volume.
+	multiAttachErrorReported bool
+
+	// volumeName contains the unique identifier for this volume.
+	volumeName v1.UniqueVolumeName
+
+	// spec is the volume spec containing the specification for this volume.
+	// Used to generate the volume plugin object, and passed to attach/detach
+	// methods.
+	spec *volume.Spec
+
+	// scheduledPods is a map containing the set of pods that reference this
+	// volume and are scheduled to the underlying node. The key in the map is
+	// the name of the pod and the value is a pod object containing more
+	// information about the pod.
+	scheduledPods map[types.UniquePodName]pod
+}
+
+// The pod represents a pod that references the underlying volume and is
+// scheduled to the underlying node.
+type pod struct {
+	// podName contains the unique identifier for this pod
+	podName types.UniquePodName
+
+	// pod object contains the api object of pod
+	podObj *v1.Pod
+}
+
+func (dsw *desiredStateOfWorld) AddNode(nodeName k8stypes.NodeName, keepTerminatedPodVolumes bool) {
+	dsw.Lock()
+	defer dsw.Unlock()
+
+	if _, nodeExists := dsw.nodesManaged[nodeName]; !nodeExists {
+		dsw.nodesManaged[nodeName] = nodeManaged{
+			nodeName:                 nodeName,
+			volumesToAttach:          make(map[v1.UniqueVolumeName]volumeToAttach),
+			keepTerminatedPodVolumes: keepTerminatedPodVolumes,
+		}
+	}
+}
+
+func (dsw *desiredStateOfWorld) AddPod(
+	podName types.UniquePodName,
+	podToAdd *v1.Pod,
+	volumeSpec *volume.Spec,
+	nodeName k8stypes.NodeName) (v1.UniqueVolumeName, error) {
+	dsw.Lock()
+	defer dsw.Unlock()
+
+	nodeObj, nodeExists := dsw.nodesManaged[nodeName]
+	if !nodeExists {
+		return "", fmt.Errorf(
+			"no node with the name %q exists in the list of managed nodes",
+			nodeName)
+	}
+
+	attachableVolumePlugin, err := dsw.volumePluginMgr.FindAttachablePluginBySpec(volumeSpec)
+	if err != nil || attachableVolumePlugin == nil {
+		return "", fmt.Errorf(
+			"failed to get AttachablePlugin from volumeSpec for volume %q err=%v",
+			volumeSpec.Name(),
+			err)
+	}
+
+	volumeName, err := volumehelper.GetUniqueVolumeNameFromSpec(
+		attachableVolumePlugin, volumeSpec)
+	if err != nil {
+		return "", fmt.Errorf(
+			"failed to GetUniqueVolumeNameFromSpec for volumeSpec %q err=%v",
+			volumeSpec.Name(),
+			err)
+	}
+
+	volumeObj, volumeExists := nodeObj.volumesToAttach[volumeName]
+	if !volumeExists {
+		volumeObj = volumeToAttach{
+			multiAttachErrorReported: false,
+			volumeName:               volumeName,
+			spec:                     volumeSpec,
+			scheduledPods:            make(map[types.UniquePodName]pod),
+		}
+		dsw.nodesManaged[nodeName].volumesToAttach[volumeName] = volumeObj
+	}
+	if _, podExists := volumeObj.scheduledPods[podName]; !podExists {
+		dsw.nodesManaged[nodeName].volumesToAttach[volumeName].scheduledPods[podName] =
+			pod{
+				podName: podName,
+				podObj:  podToAdd,
+			}
+	}
+
+	return volumeName, nil
+}
+
+func (dsw *desiredStateOfWorld) DeleteNode(nodeName k8stypes.NodeName) error {
+	dsw.Lock()
+	defer dsw.Unlock()
+
+	nodeObj, nodeExists := dsw.nodesManaged[nodeName]
+	if !nodeExists {
+		return nil
+	}
+
+	if len(nodeObj.volumesToAttach) > 0 {
+		return fmt.Errorf(
+			"failed to delete node %q from list of nodes managed by attach/detach controller--the node still contains %v volumes in its list of volumes to attach",
+			nodeName,
+			len(nodeObj.volumesToAttach))
+	}
+
+	delete(
+		dsw.nodesManaged,
+		nodeName)
+	return nil
+}
+
+func (dsw *desiredStateOfWorld) DeletePod(
+	podName types.UniquePodName,
+	volumeName v1.UniqueVolumeName,
+	nodeName k8stypes.NodeName) {
+	dsw.Lock()
+	defer dsw.Unlock()
+
+	nodeObj, nodeExists := dsw.nodesManaged[nodeName]
+	if !nodeExists {
+		return
+	}
+
+	volumeObj, volumeExists := nodeObj.volumesToAttach[volumeName]
+	if !volumeExists {
+		return
+	}
+	if _, podExists := volumeObj.scheduledPods[podName]; !podExists {
+		return
+	}
+
+	delete(
+		dsw.nodesManaged[nodeName].volumesToAttach[volumeName].scheduledPods,
+		podName)
+
+	if len(volumeObj.scheduledPods) == 0 {
+		delete(
+			dsw.nodesManaged[nodeName].volumesToAttach,
+			volumeName)
+	}
+}
+
+func (dsw *desiredStateOfWorld) NodeExists(nodeName k8stypes.NodeName) bool {
+	dsw.RLock()
+	defer dsw.RUnlock()
+
+	_, nodeExists := dsw.nodesManaged[nodeName]
+	return nodeExists
+}
+
+func (dsw *desiredStateOfWorld) VolumeExists(
+	volumeName v1.UniqueVolumeName, nodeName k8stypes.NodeName) bool {
+	dsw.RLock()
+	defer dsw.RUnlock()
+
+	nodeObj, nodeExists := dsw.nodesManaged[nodeName]
+	if nodeExists {
+		if _, volumeExists := nodeObj.volumesToAttach[volumeName]; volumeExists {
+			return true
+		}
+	}
+
+	return false
+}
+
+// GetKeepTerminatedPodVolumesForNode determines if node wants volumes to be
+// mounted and attached for terminated pods
+func (dsw *desiredStateOfWorld) GetKeepTerminatedPodVolumesForNode(nodeName k8stypes.NodeName) bool {
+	dsw.RLock()
+	defer dsw.RUnlock()
+
+	if nodeName == "" {
+		return false
+	}
+	if node, ok := dsw.nodesManaged[nodeName]; ok {
+		return node.keepTerminatedPodVolumes
+	}
+	return false
+}
+
+func (dsw *desiredStateOfWorld) GetVolumesToAttach() []VolumeToAttach {
+	dsw.RLock()
+	defer dsw.RUnlock()
+
+	volumesToAttach := make([]VolumeToAttach, 0 /* len */, len(dsw.nodesManaged) /* cap */)
+	for nodeName, nodeObj := range dsw.nodesManaged {
+		for volumeName, volumeObj := range nodeObj.volumesToAttach {
+			volumesToAttach = append(volumesToAttach,
+				VolumeToAttach{
+					VolumeToAttach: operationexecutor.VolumeToAttach{
+						MultiAttachErrorReported: volumeObj.multiAttachErrorReported,
+						VolumeName:               volumeName,
+						VolumeSpec:               volumeObj.spec,
+						NodeName:                 nodeName,
+						ScheduledPods:            getPodsFromMap(volumeObj.scheduledPods),
+					}})
+		}
+	}
+
+	return volumesToAttach
+}
+
+// Construct a list of v1.Pod objects from the given pod map
+func getPodsFromMap(podMap map[types.UniquePodName]pod) []*v1.Pod {
+	pods := make([]*v1.Pod, 0, len(podMap))
+	for _, pod := range podMap {
+		pods = append(pods, pod.podObj)
+	}
+	return pods
+}
+
+func (dsw *desiredStateOfWorld) GetPodToAdd() map[types.UniquePodName]PodToAdd {
+	dsw.RLock()
+	defer dsw.RUnlock()
+
+	pods := make(map[types.UniquePodName]PodToAdd)
+	for nodeName, nodeObj := range dsw.nodesManaged {
+		for volumeName, volumeObj := range nodeObj.volumesToAttach {
+			for podUID, pod := range volumeObj.scheduledPods {
+				pods[podUID] = PodToAdd{
+					Pod:        pod.podObj,
+					VolumeName: volumeName,
+					NodeName:   nodeName,
+				}
+			}
+		}
+	}
+	return pods
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/populator/BUILD

@@ -0,0 +1,55 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["desired_state_of_world_populator.go"],
+    deps = [
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/util:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/volumehelper:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["desired_state_of_world_populator_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+        "//pkg/volume/util/volumehelper: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/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/populator/desired_state_of_world_populator.go

@@ -0,0 +1,170 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 populator implements interfaces that monitor and keep the states of the
+// desired_state_of_word in sync with the "ground truth" from informer.
+package populator
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/golang/glog"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	kcache "k8s.io/client-go/tools/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/util"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+// DesiredStateOfWorldPopulator periodically verifies that the pods in the
+// desired state of the world still exist, if not, it removes them.
+// It also loops through the list of active pods and ensures that
+// each one exists in the desired state of the world cache
+// if it has volumes.
+type DesiredStateOfWorldPopulator interface {
+	Run(stopCh <-chan struct{})
+}
+
+// NewDesiredStateOfWorldPopulator returns a new instance of DesiredStateOfWorldPopulator.
+// loopSleepDuration - the amount of time the populator loop sleeps between
+//     successive executions
+// podManager - the kubelet podManager that is the source of truth for the pods
+//     that exist on this host
+// desiredStateOfWorld - the cache to populate
+func NewDesiredStateOfWorldPopulator(
+	loopSleepDuration time.Duration,
+	listPodsRetryDuration time.Duration,
+	podLister corelisters.PodLister,
+	desiredStateOfWorld cache.DesiredStateOfWorld,
+	volumePluginMgr *volume.VolumePluginMgr,
+	pvcLister corelisters.PersistentVolumeClaimLister,
+	pvLister corelisters.PersistentVolumeLister) DesiredStateOfWorldPopulator {
+	return &desiredStateOfWorldPopulator{
+		loopSleepDuration:     loopSleepDuration,
+		listPodsRetryDuration: listPodsRetryDuration,
+		podLister:             podLister,
+		desiredStateOfWorld:   desiredStateOfWorld,
+		volumePluginMgr:       volumePluginMgr,
+		pvcLister:             pvcLister,
+		pvLister:              pvLister,
+	}
+}
+
+type desiredStateOfWorldPopulator struct {
+	loopSleepDuration     time.Duration
+	podLister             corelisters.PodLister
+	desiredStateOfWorld   cache.DesiredStateOfWorld
+	volumePluginMgr       *volume.VolumePluginMgr
+	pvcLister             corelisters.PersistentVolumeClaimLister
+	pvLister              corelisters.PersistentVolumeLister
+	listPodsRetryDuration time.Duration
+	timeOfLastListPods    time.Time
+}
+
+func (dswp *desiredStateOfWorldPopulator) Run(stopCh <-chan struct{}) {
+	wait.Until(dswp.populatorLoopFunc(), dswp.loopSleepDuration, stopCh)
+}
+
+func (dswp *desiredStateOfWorldPopulator) populatorLoopFunc() func() {
+	return func() {
+		dswp.findAndRemoveDeletedPods()
+
+		// findAndAddActivePods is called periodically, independently of the main
+		// populator loop.
+		if time.Since(dswp.timeOfLastListPods) < dswp.listPodsRetryDuration {
+			glog.V(5).Infof(
+				"Skipping findAndAddActivePods(). Not permitted until %v (listPodsRetryDuration %v).",
+				dswp.timeOfLastListPods.Add(dswp.listPodsRetryDuration),
+				dswp.listPodsRetryDuration)
+
+			return
+		}
+		dswp.findAndAddActivePods()
+	}
+}
+
+// Iterate through all pods in desired state of world, and remove if they no
+// longer exist in the informer
+func (dswp *desiredStateOfWorldPopulator) findAndRemoveDeletedPods() {
+	for dswPodUID, dswPodToAdd := range dswp.desiredStateOfWorld.GetPodToAdd() {
+		dswPodKey, err := kcache.MetaNamespaceKeyFunc(dswPodToAdd.Pod)
+		if err != nil {
+			glog.Errorf("MetaNamespaceKeyFunc failed for pod %q (UID %q) with: %v", dswPodKey, dswPodUID, err)
+			continue
+		}
+
+		// Retrieve the pod object from pod informer with the namespace key
+		namespace, name, err := kcache.SplitMetaNamespaceKey(dswPodKey)
+		if err != nil {
+			utilruntime.HandleError(fmt.Errorf("error splitting dswPodKey %q: %v", dswPodKey, err))
+			continue
+		}
+		informerPod, err := dswp.podLister.Pods(namespace).Get(name)
+		switch {
+		case errors.IsNotFound(err):
+			// if we can't find the pod, we need to delete it below
+		case err != nil:
+			glog.Errorf("podLister Get failed for pod %q (UID %q) with %v", dswPodKey, dswPodUID, err)
+			continue
+		default:
+			volumeActionFlag := util.DetermineVolumeAction(
+				informerPod,
+				dswp.desiredStateOfWorld,
+				true /* default volume action */)
+
+			if volumeActionFlag {
+				informerPodUID := volumehelper.GetUniquePodName(informerPod)
+				// Check whether the unique identifier of the pod from dsw matches the one retrieved from pod informer
+				if informerPodUID == dswPodUID {
+					glog.V(10).Infof("Verified pod %q (UID %q) from dsw exists in pod informer.", dswPodKey, dswPodUID)
+					continue
+				}
+			}
+		}
+
+		// the pod from dsw does not exist in pod informer, or it does not match the unique identifer retrieved
+		// from the informer, delete it from dsw
+		glog.V(1).Infof("Removing pod %q (UID %q) from dsw because it does not exist in pod informer.", dswPodKey, dswPodUID)
+		dswp.desiredStateOfWorld.DeletePod(dswPodUID, dswPodToAdd.VolumeName, dswPodToAdd.NodeName)
+	}
+}
+
+func (dswp *desiredStateOfWorldPopulator) findAndAddActivePods() {
+	pods, err := dswp.podLister.List(labels.Everything())
+	if err != nil {
+		glog.Errorf("podLister List failed: %v", err)
+		return
+	}
+	dswp.timeOfLastListPods = time.Now()
+
+	for _, pod := range pods {
+		if volumehelper.IsPodTerminated(pod, pod.Status) {
+			// Do not add volumes for terminated pods
+			continue
+		}
+		util.ProcessPodVolumes(pod, true,
+			dswp.desiredStateOfWorld, dswp.volumePluginMgr, dswp.pvcLister, dswp.pvLister)
+
+	}
+
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/populator/desired_state_of_world_populator_test.go

@@ -0,0 +1,137 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 populator
+
+import (
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	k8stypes "k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	volumetesting "k8s.io/kubernetes/pkg/volume/testing"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+func TestFindAndAddActivePods_FindAndRemoveDeletedPods(t *testing.T) {
+	fakeVolumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
+	fakeClient := &fake.Clientset{}
+
+	fakeInformerFactory := informers.NewSharedInformerFactory(fakeClient, controller.NoResyncPeriodFunc())
+	fakePodInformer := fakeInformerFactory.Core().V1().Pods()
+
+	fakesDSW := cache.NewDesiredStateOfWorld(fakeVolumePluginMgr)
+
+	pod := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "dswp-test-pod",
+			UID:       "dswp-test-pod-uid",
+			Namespace: "dswp-test",
+		},
+		Spec: v1.PodSpec{
+			NodeName: "dswp-test-host",
+			Volumes: []v1.Volume{
+				{
+					Name: "dswp-test-volume-name",
+					VolumeSource: v1.VolumeSource{
+						GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{
+							PDName: "dswp-test-fake-device",
+						},
+					},
+				},
+			},
+		},
+		Status: v1.PodStatus{
+			Phase: v1.PodPhase("Running"),
+		},
+	}
+
+	fakePodInformer.Informer().GetStore().Add(pod)
+
+	podName := volumehelper.GetUniquePodName(pod)
+
+	generatedVolumeName := "fake-plugin/" + pod.Spec.Volumes[0].Name
+
+	pvcLister := fakeInformerFactory.Core().V1().PersistentVolumeClaims().Lister()
+	pvLister := fakeInformerFactory.Core().V1().PersistentVolumes().Lister()
+
+	dswp := &desiredStateOfWorldPopulator{
+		loopSleepDuration:     100 * time.Millisecond,
+		listPodsRetryDuration: 3 * time.Second,
+		desiredStateOfWorld:   fakesDSW,
+		volumePluginMgr:       fakeVolumePluginMgr,
+		podLister:             fakePodInformer.Lister(),
+		pvcLister:             pvcLister,
+		pvLister:              pvLister,
+	}
+
+	//add the given node to the list of nodes managed by dsw
+	dswp.desiredStateOfWorld.AddNode(k8stypes.NodeName(pod.Spec.NodeName), false /*keepTerminatedPodVolumes*/)
+
+	dswp.findAndAddActivePods()
+
+	expectedVolumeName := v1.UniqueVolumeName(generatedVolumeName)
+
+	//check if the given volume referenced by the pod is added to dsw
+	volumeExists := dswp.desiredStateOfWorld.VolumeExists(expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
+	if !volumeExists {
+		t.Fatalf(
+			"VolumeExists(%q) failed. Expected: <true> Actual: <%v>",
+			expectedVolumeName,
+			volumeExists)
+	}
+
+	//delete the pod and volume manually
+	dswp.desiredStateOfWorld.DeletePod(podName, expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
+
+	//check if the given volume referenced by the pod still exists in dsw
+	volumeExists = dswp.desiredStateOfWorld.VolumeExists(expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
+	if volumeExists {
+		t.Fatalf(
+			"VolumeExists(%q) failed. Expected: <false> Actual: <%v>",
+			expectedVolumeName,
+			volumeExists)
+	}
+
+	//add pod and volume again
+	dswp.findAndAddActivePods()
+
+	//check if the given volume referenced by the pod is added to dsw for the second time
+	volumeExists = dswp.desiredStateOfWorld.VolumeExists(expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
+	if !volumeExists {
+		t.Fatalf(
+			"VolumeExists(%q) failed. Expected: <true> Actual: <%v>",
+			expectedVolumeName,
+			volumeExists)
+	}
+
+	fakePodInformer.Informer().GetStore().Delete(pod)
+	dswp.findAndRemoveDeletedPods()
+	//check if the given volume referenced by the pod still exists in dsw
+	volumeExists = dswp.desiredStateOfWorld.VolumeExists(expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
+	if volumeExists {
+		t.Fatalf(
+			"VolumeExists(%q) failed. Expected: <false> Actual: <%v>",
+			expectedVolumeName,
+			volumeExists)
+	}
+
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/reconciler/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["reconciler.go"],
+    deps = [
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/statusupdater:go_default_library",
+        "//pkg/kubelet/events:go_default_library",
+        "//pkg/util/goroutinemap/exponentialbackoff:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/operationexecutor:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["reconciler_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/controller/volume/attachdetach/statusupdater:go_default_library",
+        "//pkg/controller/volume/attachdetach/testing:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+        "//pkg/volume/util/operationexecutor:go_default_library",
+        "//pkg/volume/util/types:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/reconciler/reconciler.go

@@ -0,0 +1,292 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 reconciler implements interfaces that attempt to reconcile the
+// desired state of the with the actual state of the world by triggering
+// actions.
+package reconciler
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater"
+	kevents "k8s.io/kubernetes/pkg/kubelet/events"
+	"k8s.io/kubernetes/pkg/util/goroutinemap/exponentialbackoff"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+)
+
+// Reconciler runs a periodic loop to reconcile the desired state of the world with
+// the actual state of the world by triggering attach detach operations.
+// Note: This is distinct from the Reconciler implemented by the kubelet volume
+// manager. This reconciles state for the attach/detach controller. That
+// reconciles state for the kubelet volume manager.
+type Reconciler interface {
+	// Starts running the reconciliation loop which executes periodically, checks
+	// if volumes that should be attached are attached and volumes that should
+	// be detached are detached. If not, it will trigger attach/detach
+	// operations to rectify.
+	Run(stopCh <-chan struct{})
+}
+
+// NewReconciler returns a new instance of Reconciler that waits loopPeriod
+// between successive executions.
+// loopPeriod is the amount of time the reconciler loop waits between
+// successive executions.
+// maxWaitForUnmountDuration is the max amount of time the reconciler will wait
+// for the volume to be safely unmounted, after this it will detach the volume
+// anyway (to handle crashed/unavailable nodes). If during this time the volume
+// becomes used by a new pod, the detach request will be aborted and the timer
+// cleared.
+func NewReconciler(
+	loopPeriod time.Duration,
+	maxWaitForUnmountDuration time.Duration,
+	syncDuration time.Duration,
+	disableReconciliationSync bool,
+	desiredStateOfWorld cache.DesiredStateOfWorld,
+	actualStateOfWorld cache.ActualStateOfWorld,
+	attacherDetacher operationexecutor.OperationExecutor,
+	nodeStatusUpdater statusupdater.NodeStatusUpdater,
+	recorder record.EventRecorder) Reconciler {
+	return &reconciler{
+		loopPeriod:                loopPeriod,
+		maxWaitForUnmountDuration: maxWaitForUnmountDuration,
+		syncDuration:              syncDuration,
+		disableReconciliationSync: disableReconciliationSync,
+		desiredStateOfWorld:       desiredStateOfWorld,
+		actualStateOfWorld:        actualStateOfWorld,
+		attacherDetacher:          attacherDetacher,
+		nodeStatusUpdater:         nodeStatusUpdater,
+		timeOfLastSync:            time.Now(),
+		recorder:                  recorder,
+	}
+}
+
+type reconciler struct {
+	loopPeriod                time.Duration
+	maxWaitForUnmountDuration time.Duration
+	syncDuration              time.Duration
+	desiredStateOfWorld       cache.DesiredStateOfWorld
+	actualStateOfWorld        cache.ActualStateOfWorld
+	attacherDetacher          operationexecutor.OperationExecutor
+	nodeStatusUpdater         statusupdater.NodeStatusUpdater
+	timeOfLastSync            time.Time
+	disableReconciliationSync bool
+	recorder                  record.EventRecorder
+}
+
+func (rc *reconciler) Run(stopCh <-chan struct{}) {
+	wait.Until(rc.reconciliationLoopFunc(), rc.loopPeriod, stopCh)
+}
+
+// reconciliationLoopFunc this can be disabled via cli option disableReconciliation.
+// It periodically checks whether the attached volumes from actual state
+// are still attached to the node and update the status if they are not.
+func (rc *reconciler) reconciliationLoopFunc() func() {
+	return func() {
+
+		rc.reconcile()
+
+		if rc.disableReconciliationSync {
+			glog.V(5).Info("Skipping reconciling attached volumes still attached since it is disabled via the command line.")
+		} else if rc.syncDuration < time.Second {
+			glog.V(5).Info("Skipping reconciling attached volumes still attached since it is set to less than one second via the command line.")
+		} else if time.Since(rc.timeOfLastSync) > rc.syncDuration {
+			glog.V(5).Info("Starting reconciling attached volumes still attached")
+			rc.sync()
+		}
+	}
+}
+
+func (rc *reconciler) sync() {
+	defer rc.updateSyncTime()
+	rc.syncStates()
+}
+
+func (rc *reconciler) updateSyncTime() {
+	rc.timeOfLastSync = time.Now()
+}
+
+func (rc *reconciler) syncStates() {
+	volumesPerNode := rc.actualStateOfWorld.GetAttachedVolumesPerNode()
+	rc.attacherDetacher.VerifyVolumesAreAttached(volumesPerNode, rc.actualStateOfWorld)
+}
+
+// isMultiAttachForbidden checks if attaching this volume to multiple nodes is definitely not allowed/possible.
+// In its current form, this function can only reliably say for which volumes it's definitely forbidden. If it returns
+// false, it is not guaranteed that multi-attach is actually supported by the volume type and we must rely on the
+// attacher to fail fast in such cases.
+// Please see https://github.com/kubernetes/kubernetes/issues/40669 and https://github.com/kubernetes/kubernetes/pull/40148#discussion_r98055047
+func (rc *reconciler) isMultiAttachForbidden(volumeSpec *volume.Spec) bool {
+	if volumeSpec.Volume != nil {
+		// Check for volume types which are known to fail slow or cause trouble when trying to multi-attach
+		if volumeSpec.Volume.AzureDisk != nil ||
+			volumeSpec.Volume.Cinder != nil {
+			return true
+		}
+	}
+
+	// Only if this volume is a persistent volume, we have reliable information on wether it's allowed or not to
+	// multi-attach. We trust in the individual volume implementations to not allow unsupported access modes
+	if volumeSpec.PersistentVolume != nil {
+		// Check for persistent volume types which do not fail when trying to multi-attach
+		if volumeSpec.PersistentVolume.Spec.VsphereVolume != nil {
+			return false
+		}
+
+		if len(volumeSpec.PersistentVolume.Spec.AccessModes) == 0 {
+			// No access mode specified so we don't know for sure. Let the attacher fail if needed
+			return false
+		}
+
+		// check if this volume is allowed to be attached to multiple PODs/nodes, if yes, return false
+		for _, accessMode := range volumeSpec.PersistentVolume.Spec.AccessModes {
+			if accessMode == v1.ReadWriteMany || accessMode == v1.ReadOnlyMany {
+				return false
+			}
+		}
+		return true
+	}
+
+	// we don't know if it's supported or not and let the attacher fail later in cases it's not supported
+	return false
+}
+
+func (rc *reconciler) reconcile() {
+	// Detaches are triggered before attaches so that volumes referenced by
+	// pods that are rescheduled to a different node are detached first.
+
+	// Ensure volumes that should be detached are detached.
+	for _, attachedVolume := range rc.actualStateOfWorld.GetAttachedVolumes() {
+		if !rc.desiredStateOfWorld.VolumeExists(
+			attachedVolume.VolumeName, attachedVolume.NodeName) {
+
+			// Don't even try to start an operation if there is already one running
+			// This check must be done before we do any other checks, as otherwise the other checks
+			// may pass while at the same time the volume leaves the pending state, resulting in
+			// double detach attempts
+			if rc.attacherDetacher.IsOperationPending(attachedVolume.VolumeName, "") {
+				glog.V(10).Infof("Operation for volume %q is already running. Can't start detach for %q", attachedVolume.VolumeName, attachedVolume.NodeName)
+				continue
+			}
+
+			// Set the detach request time
+			elapsedTime, err := rc.actualStateOfWorld.SetDetachRequestTime(attachedVolume.VolumeName, attachedVolume.NodeName)
+			if err != nil {
+				glog.Errorf("Cannot trigger detach because it fails to set detach request time with error %v", err)
+				continue
+			}
+			// Check whether timeout has reached the maximum waiting time
+			timeout := elapsedTime > rc.maxWaitForUnmountDuration
+			// Check whether volume is still mounted. Skip detach if it is still mounted unless timeout
+			if attachedVolume.MountedByNode && !timeout {
+				glog.V(12).Infof(attachedVolume.GenerateMsgDetailed("Cannot detach volume because it is still mounted", ""))
+				continue
+			}
+
+			// Before triggering volume detach, mark volume as detached and update the node status
+			// If it fails to update node status, skip detach volume
+			err = rc.actualStateOfWorld.RemoveVolumeFromReportAsAttached(attachedVolume.VolumeName, attachedVolume.NodeName)
+			if err != nil {
+				glog.V(5).Infof("RemoveVolumeFromReportAsAttached failed while removing volume %q from node %q with: %v",
+					attachedVolume.VolumeName,
+					attachedVolume.NodeName,
+					err)
+			}
+
+			// Update Node Status to indicate volume is no longer safe to mount.
+			err = rc.nodeStatusUpdater.UpdateNodeStatuses()
+			if err != nil {
+				// Skip detaching this volume if unable to update node status
+				glog.Errorf(attachedVolume.GenerateErrorDetailed("UpdateNodeStatuses failed while attempting to report volume as attached", err).Error())
+				continue
+			}
+
+			// Trigger detach volume which requires verifing safe to detach step
+			// If timeout is true, skip verifySafeToDetach check
+			glog.V(5).Infof(attachedVolume.GenerateMsgDetailed("Starting attacherDetacher.DetachVolume", ""))
+			verifySafeToDetach := !timeout
+			err = rc.attacherDetacher.DetachVolume(attachedVolume.AttachedVolume, verifySafeToDetach, rc.actualStateOfWorld)
+			if err == nil {
+				if !timeout {
+					glog.Infof(attachedVolume.GenerateMsgDetailed("attacherDetacher.DetachVolume started", ""))
+				} else {
+					glog.Warningf(attachedVolume.GenerateMsgDetailed("attacherDetacher.DetachVolume started", fmt.Sprintf("This volume is not safe to detach, but maxWaitForUnmountDuration %v expired, force detaching", rc.maxWaitForUnmountDuration)))
+				}
+			}
+			if err != nil && !exponentialbackoff.IsExponentialBackoff(err) {
+				// Ignore exponentialbackoff.IsExponentialBackoff errors, they are expected.
+				// Log all other errors.
+				glog.Errorf(attachedVolume.GenerateErrorDetailed("attacherDetacher.DetachVolume failed to start", err).Error())
+			}
+		}
+	}
+
+	// Ensure volumes that should be attached are attached.
+	for _, volumeToAttach := range rc.desiredStateOfWorld.GetVolumesToAttach() {
+		if rc.actualStateOfWorld.VolumeNodeExists(
+			volumeToAttach.VolumeName, volumeToAttach.NodeName) {
+			// Volume/Node exists, touch it to reset detachRequestedTime
+			glog.V(5).Infof(volumeToAttach.GenerateMsgDetailed("Volume attached--touching", ""))
+			rc.actualStateOfWorld.ResetDetachRequestTime(volumeToAttach.VolumeName, volumeToAttach.NodeName)
+		} else {
+			// Don't even try to start an operation if there is already one running
+			if rc.attacherDetacher.IsOperationPending(volumeToAttach.VolumeName, "") {
+				glog.V(10).Infof("Operation for volume %q is already running. Can't start attach for %q", volumeToAttach.VolumeName, volumeToAttach.NodeName)
+				continue
+			}
+
+			if rc.isMultiAttachForbidden(volumeToAttach.VolumeSpec) {
+				nodes := rc.actualStateOfWorld.GetNodesForVolume(volumeToAttach.VolumeName)
+				if len(nodes) > 0 {
+					if !volumeToAttach.MultiAttachErrorReported {
+						simpleMsg, detailedMsg := volumeToAttach.GenerateMsg("Multi-Attach error", "Volume is already exclusively attached to one node and can't be attached to another")
+						for _, pod := range volumeToAttach.ScheduledPods {
+							rc.recorder.Eventf(pod, v1.EventTypeWarning, kevents.FailedAttachVolume, simpleMsg)
+						}
+						volumeToAttach.MultiAttachErrorReported = true
+						glog.Warningf(detailedMsg)
+					}
+					continue
+				}
+			}
+
+			// Volume/Node doesn't exist, spawn a goroutine to attach it
+			glog.V(5).Infof(volumeToAttach.GenerateMsgDetailed("Starting attacherDetacher.AttachVolume", ""))
+			err := rc.attacherDetacher.AttachVolume(volumeToAttach.VolumeToAttach, rc.actualStateOfWorld)
+			if err == nil {
+				glog.Infof(volumeToAttach.GenerateMsgDetailed("attacherDetacher.AttachVolume started", ""))
+			}
+			if err != nil && !exponentialbackoff.IsExponentialBackoff(err) {
+				// Ignore exponentialbackoff.IsExponentialBackoff errors, they are expected.
+				// Log all other errors.
+				glog.Errorf(volumeToAttach.GenerateErrorDetailed("attacherDetacher.AttachVolume failed to start", err).Error())
+			}
+		}
+	}
+
+	// Update Node Status
+	err := rc.nodeStatusUpdater.UpdateNodeStatuses()
+	if err != nil {
+		glog.Warningf("UpdateNodeStatuses failed with: %v", err)
+	}
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/reconciler/reconciler_test.go

@@ -0,0 +1,749 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 reconciler
+
+import (
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	k8stypes "k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater"
+	controllervolumetesting "k8s.io/kubernetes/pkg/controller/volume/attachdetach/testing"
+	volumetesting "k8s.io/kubernetes/pkg/volume/testing"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+	"k8s.io/kubernetes/pkg/volume/util/types"
+)
+
+const (
+	reconcilerLoopPeriod      time.Duration = 0 * time.Millisecond
+	syncLoopPeriod            time.Duration = 100 * time.Minute
+	maxWaitForUnmountDuration time.Duration = 50 * time.Millisecond
+	resyncPeriod              time.Duration = 5 * time.Minute
+)
+
+// Calls Run()
+// Verifies there are no calls to attach or detach.
+func Test_Run_Positive_DoNothing(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	informerFactory := informers.NewSharedInformerFactory(fakeKubeClient, controller.NoResyncPeriodFunc())
+	nsu := statusupdater.NewNodeStatusUpdater(
+		fakeKubeClient, informerFactory.Core().V1().Nodes().Lister(), asw)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 0 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, true /* expectZeroNewAttacherCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 0 /* expectedAttachCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+}
+
+// Populates desiredStateOfWorld cache with one node/volume/pod tuple.
+// Calls Run()
+// Verifies there is one attach call and no detach calls.
+func Test_Run_Positive_OneDesiredVolumeAttach(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	nsu := statusupdater.NewFakeNodeStatusUpdater(false /* returnError */)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+	podName := "pod-uid"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	nodeName := k8stypes.NodeName("node-name")
+	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
+	volumeExists := dsw.VolumeExists(volumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Volume %q/node %q should not exist, but it does.",
+			volumeName,
+			nodeName)
+	}
+
+	_, podErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
+	if podErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podErr)
+	}
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+}
+
+// Populates desiredStateOfWorld cache with one node/volume/pod tuple.
+// Calls Run()
+// Verifies there is one attach call and no detach calls.
+// Marks the node/volume as unmounted.
+// Deletes the node/volume/pod tuple from desiredStateOfWorld cache.
+// Verifies there is one detach call and no (new) attach calls.
+func Test_Run_Positive_OneDesiredVolumeAttachThenDetachWithUnmountedVolume(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	nsu := statusupdater.NewFakeNodeStatusUpdater(false /* returnError */)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+	podName := "pod-uid"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	nodeName := k8stypes.NodeName("node-name")
+	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
+	volumeExists := dsw.VolumeExists(volumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Volume %q/node %q should not exist, but it does.",
+			volumeName,
+			nodeName)
+	}
+
+	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+
+	// Act
+	dsw.DeletePod(types.UniquePodName(podName), generatedVolumeName, nodeName)
+	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
+			podName,
+			generatedVolumeName,
+			nodeName)
+	}
+	asw.SetVolumeMountedByNode(generatedVolumeName, nodeName, true /* mounted */, false)
+	asw.SetVolumeMountedByNode(generatedVolumeName, nodeName, false /* mounted */, false)
+
+	// Assert
+	waitForNewDetacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, false /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 1 /* expectedDetachCallCount */, fakePlugin)
+}
+
+// Populates desiredStateOfWorld cache with one node/volume/pod tuple.
+// Calls Run()
+// Verifies there is one attach call and no detach calls.
+// Deletes the node/volume/pod tuple from desiredStateOfWorld cache without first marking the node/volume as unmounted.
+// Verifies there is one detach call and no (new) attach calls.
+func Test_Run_Positive_OneDesiredVolumeAttachThenDetachWithMountedVolume(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	nsu := statusupdater.NewFakeNodeStatusUpdater(false /* returnError */)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+	podName := "pod-uid"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	nodeName := k8stypes.NodeName("node-name")
+	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
+	volumeExists := dsw.VolumeExists(volumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Volume %q/node %q should not exist, but it does.",
+			volumeName,
+			nodeName)
+	}
+
+	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+
+	// Act
+	dsw.DeletePod(types.UniquePodName(podName), generatedVolumeName, nodeName)
+	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
+			podName,
+			generatedVolumeName,
+			nodeName)
+	}
+
+	// Assert -- Timer will triger detach
+	waitForNewDetacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, false /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 1 /* expectedDetachCallCount */, fakePlugin)
+}
+
+// Populates desiredStateOfWorld cache with one node/volume/pod tuple.
+// Has node update fail
+// Calls Run()
+// Verifies there is one attach call and no detach calls.
+// Marks the node/volume as unmounted.
+// Deletes the node/volume/pod tuple from desiredStateOfWorld cache.
+// Verifies there are NO detach call and no (new) attach calls.
+func Test_Run_Negative_OneDesiredVolumeAttachThenDetachWithUnmountedVolumeUpdateStatusFail(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	nsu := statusupdater.NewFakeNodeStatusUpdater(true /* returnError */)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+	podName := "pod-uid"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	nodeName := k8stypes.NodeName("node-name")
+	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
+	volumeExists := dsw.VolumeExists(volumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Volume %q/node %q should not exist, but it does.",
+			volumeName,
+			nodeName)
+	}
+
+	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+
+	// Act
+	dsw.DeletePod(types.UniquePodName(podName), generatedVolumeName, nodeName)
+	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
+	if volumeExists {
+		t.Fatalf(
+			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
+			podName,
+			generatedVolumeName,
+			nodeName)
+	}
+	asw.SetVolumeMountedByNode(generatedVolumeName, nodeName, true /* mounted */, false)
+	asw.SetVolumeMountedByNode(generatedVolumeName, nodeName, false /* mounted */, false)
+
+	// Assert
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, false /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+}
+
+// Creates a volume with accessMode ReadWriteMany
+// Populates desiredStateOfWorld cache with two ode/volume/pod tuples pointing to the created volume
+// Calls Run()
+// Verifies there are two attach calls and no detach calls.
+// Deletes the first node/volume/pod tuple from desiredStateOfWorld cache without first marking the node/volume as unmounted.
+// Verifies there is one detach call and no (new) attach calls.
+// Deletes the second node/volume/pod tuple from desiredStateOfWorld cache without first marking the node/volume as unmounted.
+// Verifies there are two detach calls and no (new) attach calls.
+func Test_Run_OneVolumeAttachAndDetachMultipleNodesWithReadWriteMany(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	nsu := statusupdater.NewFakeNodeStatusUpdater(false /* returnError */)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+	podName1 := "pod-uid1"
+	podName2 := "pod-uid2"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	volumeSpec.PersistentVolume.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteMany}
+	nodeName1 := k8stypes.NodeName("node-name1")
+	nodeName2 := k8stypes.NodeName("node-name2")
+	dsw.AddNode(nodeName1, false /*keepTerminatedPodVolumes*/)
+	dsw.AddNode(nodeName2, false /*keepTerminatedPodVolumes*/)
+
+	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName1), controllervolumetesting.NewPod(podName1, podName1), volumeSpec, nodeName1)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+	_, podAddErr = dsw.AddPod(types.UniquePodName(podName2), controllervolumetesting.NewPod(podName2, podName2), volumeSpec, nodeName2)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 2 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForTotalAttachCallCount(t, 2 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+	waitForAttachedToNodesCount(t, 2 /* expectedNodeCount */, generatedVolumeName, asw)
+
+	// Act
+	dsw.DeletePod(types.UniquePodName(podName1), generatedVolumeName, nodeName1)
+	volumeExists := dsw.VolumeExists(generatedVolumeName, nodeName1)
+	if volumeExists {
+		t.Fatalf(
+			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
+			podName1,
+			generatedVolumeName,
+			nodeName1)
+	}
+
+	// Assert -- Timer will triger detach
+	waitForNewDetacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForTotalAttachCallCount(t, 2 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, false /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForTotalDetachCallCount(t, 1 /* expectedDetachCallCount */, fakePlugin)
+
+	// Act
+	dsw.DeletePod(types.UniquePodName(podName2), generatedVolumeName, nodeName2)
+	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName2)
+	if volumeExists {
+		t.Fatalf(
+			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
+			podName2,
+			generatedVolumeName,
+			nodeName2)
+	}
+
+	// Assert -- Timer will triger detach
+	waitForNewDetacherCallCount(t, 2 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForTotalAttachCallCount(t, 2 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, false /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForTotalDetachCallCount(t, 2 /* expectedDetachCallCount */, fakePlugin)
+}
+
+// Creates a volume with accessMode ReadWriteOnce
+// Populates desiredStateOfWorld cache with two ode/volume/pod tuples pointing to the created volume
+// Calls Run()
+// Verifies there is one attach call and no detach calls.
+// Deletes the node/volume/pod tuple from desiredStateOfWorld which succeeded in attaching
+// Verifies there are two attach call and one detach call.
+func Test_Run_OneVolumeAttachAndDetachMultipleNodesWithReadWriteOnce(t *testing.T) {
+	// Arrange
+	volumePluginMgr, fakePlugin := volumetesting.GetTestVolumePluginMgr(t)
+	dsw := cache.NewDesiredStateOfWorld(volumePluginMgr)
+	asw := cache.NewActualStateOfWorld(volumePluginMgr)
+	fakeKubeClient := controllervolumetesting.CreateTestClient()
+	fakeRecorder := &record.FakeRecorder{}
+	ad := operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(fakeKubeClient, volumePluginMgr, fakeRecorder, false /* checkNodeCapabilitiesBeforeMount */))
+	nsu := statusupdater.NewFakeNodeStatusUpdater(false /* returnError */)
+	reconciler := NewReconciler(
+		reconcilerLoopPeriod, maxWaitForUnmountDuration, syncLoopPeriod, false, dsw, asw, ad, nsu, fakeRecorder)
+	podName1 := "pod-uid1"
+	podName2 := "pod-uid2"
+	volumeName := v1.UniqueVolumeName("volume-name")
+	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
+	volumeSpec.PersistentVolume.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+	nodeName1 := k8stypes.NodeName("node-name1")
+	nodeName2 := k8stypes.NodeName("node-name2")
+	dsw.AddNode(nodeName1, false /*keepTerminatedPodVolumes*/)
+	dsw.AddNode(nodeName2, false /*keepTerminatedPodVolumes*/)
+
+	// Add both pods at the same time to provoke a potential race condition in the reconciler
+	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName1), controllervolumetesting.NewPod(podName1, podName1), volumeSpec, nodeName1)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+	_, podAddErr = dsw.AddPod(types.UniquePodName(podName2), controllervolumetesting.NewPod(podName2, podName2), volumeSpec, nodeName2)
+	if podAddErr != nil {
+		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podAddErr)
+	}
+
+	// Act
+	ch := make(chan struct{})
+	go reconciler.Run(ch)
+	defer close(ch)
+
+	// Assert
+	waitForNewAttacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForTotalAttachCallCount(t, 1 /* expectedAttachCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, true /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForDetachCallCount(t, 0 /* expectedDetachCallCount */, fakePlugin)
+	waitForAttachedToNodesCount(t, 1 /* expectedNodeCount */, generatedVolumeName, asw)
+
+	nodesForVolume := asw.GetNodesForVolume(generatedVolumeName)
+
+	// Act
+	podToDelete := ""
+	if nodesForVolume[0] == nodeName1 {
+		podToDelete = podName1
+	} else if nodesForVolume[0] == nodeName2 {
+		podToDelete = podName2
+	} else {
+		t.Fatal("Volume attached to unexpected node")
+	}
+
+	dsw.DeletePod(types.UniquePodName(podToDelete), generatedVolumeName, nodesForVolume[0])
+	volumeExists := dsw.VolumeExists(generatedVolumeName, nodesForVolume[0])
+	if volumeExists {
+		t.Fatalf(
+			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
+			podToDelete,
+			generatedVolumeName,
+			nodesForVolume[0])
+	}
+
+	// Assert
+	waitForNewDetacherCallCount(t, 1 /* expectedCallCount */, fakePlugin)
+	verifyNewDetacherCallCount(t, false /* expectZeroNewDetacherCallCount */, fakePlugin)
+	waitForTotalDetachCallCount(t, 1 /* expectedDetachCallCount */, fakePlugin)
+	waitForNewAttacherCallCount(t, 2 /* expectedCallCount */, fakePlugin)
+	verifyNewAttacherCallCount(t, false /* expectZeroNewAttacherCallCount */, fakePlugin)
+	waitForTotalAttachCallCount(t, 2 /* expectedAttachCallCount */, fakePlugin)
+}
+
+func waitForNewAttacherCallCount(
+	t *testing.T,
+	expectedCallCount int,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			actualCallCount := fakePlugin.GetNewAttacherCallCount()
+			if actualCallCount >= expectedCallCount {
+				return true, nil
+			}
+			t.Logf(
+				"Warning: Wrong NewAttacherCallCount. Expected: <%v> Actual: <%v>. Will retry.",
+				expectedCallCount,
+				actualCallCount)
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		t.Fatalf(
+			"Timed out waiting for NewAttacherCallCount. Expected: <%v> Actual: <%v>",
+			expectedCallCount,
+			fakePlugin.GetNewAttacherCallCount())
+	}
+}
+
+func waitForNewDetacherCallCount(
+	t *testing.T,
+	expectedCallCount int,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			actualCallCount := fakePlugin.GetNewDetacherCallCount()
+			if actualCallCount >= expectedCallCount {
+				return true, nil
+			}
+			t.Logf(
+				"Warning: Wrong NewDetacherCallCount. Expected: <%v> Actual: <%v>. Will retry.",
+				expectedCallCount,
+				actualCallCount)
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		t.Fatalf(
+			"Timed out waiting for NewDetacherCallCount. Expected: <%v> Actual: <%v>",
+			expectedCallCount,
+			fakePlugin.GetNewDetacherCallCount())
+	}
+}
+
+func waitForAttachCallCount(
+	t *testing.T,
+	expectedAttachCallCount int,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+	if len(fakePlugin.GetAttachers()) == 0 && expectedAttachCallCount == 0 {
+		return
+	}
+
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			for i, attacher := range fakePlugin.GetAttachers() {
+				actualCallCount := attacher.GetAttachCallCount()
+				if actualCallCount == expectedAttachCallCount {
+					return true, nil
+				}
+				t.Logf(
+					"Warning: Wrong attacher[%v].GetAttachCallCount(). Expected: <%v> Actual: <%v>. Will try next attacher.",
+					i,
+					expectedAttachCallCount,
+					actualCallCount)
+			}
+
+			t.Logf(
+				"Warning: No attachers have expected AttachCallCount. Expected: <%v>. Will retry.",
+				expectedAttachCallCount)
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		t.Fatalf(
+			"No attachers have expected AttachCallCount. Expected: <%v>",
+			expectedAttachCallCount)
+	}
+}
+
+func waitForTotalAttachCallCount(
+	t *testing.T,
+	expectedAttachCallCount int,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+	if len(fakePlugin.GetAttachers()) == 0 && expectedAttachCallCount == 0 {
+		return
+	}
+
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			totalCount := 0
+			for _, attacher := range fakePlugin.GetAttachers() {
+				totalCount += attacher.GetAttachCallCount()
+			}
+			if totalCount == expectedAttachCallCount {
+				return true, nil
+			}
+			t.Logf(
+				"Warning: Wrong total GetAttachCallCount(). Expected: <%v> Actual: <%v>. Will retry.",
+				expectedAttachCallCount,
+				totalCount)
+
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		t.Fatalf(
+			"Total AttachCallCount does not match expected value. Expected: <%v>",
+			expectedAttachCallCount)
+	}
+}
+
+func waitForDetachCallCount(
+	t *testing.T,
+	expectedDetachCallCount int,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+	if len(fakePlugin.GetDetachers()) == 0 && expectedDetachCallCount == 0 {
+		return
+	}
+
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			for i, detacher := range fakePlugin.GetDetachers() {
+				actualCallCount := detacher.GetDetachCallCount()
+				if actualCallCount == expectedDetachCallCount {
+					return true, nil
+				}
+				t.Logf(
+					"Wrong detacher[%v].GetDetachCallCount(). Expected: <%v> Actual: <%v>. Will try next detacher.",
+					i,
+					expectedDetachCallCount,
+					actualCallCount)
+			}
+
+			t.Logf(
+				"Warning: No detachers have expected DetachCallCount. Expected: <%v>. Will retry.",
+				expectedDetachCallCount)
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		t.Fatalf(
+			"No detachers have expected DetachCallCount. Expected: <%v>",
+			expectedDetachCallCount)
+	}
+}
+
+func waitForTotalDetachCallCount(
+	t *testing.T,
+	expectedDetachCallCount int,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+	if len(fakePlugin.GetDetachers()) == 0 && expectedDetachCallCount == 0 {
+		return
+	}
+
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			totalCount := 0
+			for _, detacher := range fakePlugin.GetDetachers() {
+				totalCount += detacher.GetDetachCallCount()
+			}
+			if totalCount == expectedDetachCallCount {
+				return true, nil
+			}
+			t.Logf(
+				"Warning: Wrong total GetDetachCallCount(). Expected: <%v> Actual: <%v>. Will retry.",
+				expectedDetachCallCount,
+				totalCount)
+
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		t.Fatalf(
+			"Total DetachCallCount does not match expected value. Expected: <%v>",
+			expectedDetachCallCount)
+	}
+}
+
+func waitForAttachedToNodesCount(
+	t *testing.T,
+	expectedNodeCount int,
+	volumeName v1.UniqueVolumeName,
+	asw cache.ActualStateOfWorld) {
+
+	err := retryWithExponentialBackOff(
+		time.Duration(5*time.Millisecond),
+		func() (bool, error) {
+			count := len(asw.GetNodesForVolume(volumeName))
+			if count == expectedNodeCount {
+				return true, nil
+			}
+			t.Logf(
+				"Warning: Wrong number of nodes having <%v> attached. Expected: <%v> Actual: <%v>. Will retry.",
+				volumeName,
+				expectedNodeCount,
+				count)
+
+			return false, nil
+		},
+	)
+
+	if err != nil {
+		count := len(asw.GetNodesForVolume(volumeName))
+		t.Fatalf(
+			"Wrong number of nodes having <%v> attached. Expected: <%v> Actual: <%v>",
+			volumeName,
+			expectedNodeCount,
+			count)
+	}
+}
+
+func verifyNewAttacherCallCount(
+	t *testing.T,
+	expectZeroNewAttacherCallCount bool,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+
+	if expectZeroNewAttacherCallCount &&
+		fakePlugin.GetNewAttacherCallCount() != 0 {
+		t.Fatalf(
+			"Wrong NewAttacherCallCount. Expected: <0> Actual: <%v>",
+			fakePlugin.GetNewAttacherCallCount())
+	}
+}
+
+func verifyNewDetacherCallCount(
+	t *testing.T,
+	expectZeroNewDetacherCallCount bool,
+	fakePlugin *volumetesting.FakeVolumePlugin) {
+
+	if expectZeroNewDetacherCallCount &&
+		fakePlugin.GetNewDetacherCallCount() != 0 {
+		t.Fatalf("Wrong NewDetacherCallCount. Expected: <0> Actual: <%v>",
+			fakePlugin.GetNewDetacherCallCount())
+	}
+}
+
+func retryWithExponentialBackOff(initialDuration time.Duration, fn wait.ConditionFunc) error {
+	backoff := wait.Backoff{
+		Duration: initialDuration,
+		Factor:   3,
+		Jitter:   0,
+		Steps:    6,
+	}
+	return wait.ExponentialBackoff(backoff, fn)
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "fake_node_status_updater.go",
+        "node_status_updater.go",
+    ],
+    deps = [
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/strategicpatch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater/fake_node_status_updater.go

@@ -0,0 +1,39 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 statusupdater
+
+import (
+	"fmt"
+)
+
+func NewFakeNodeStatusUpdater(returnError bool) NodeStatusUpdater {
+	return &fakeNodeStatusUpdater{
+		returnError: returnError,
+	}
+}
+
+type fakeNodeStatusUpdater struct {
+	returnError bool
+}
+
+func (fnsu *fakeNodeStatusUpdater) UpdateNodeStatuses() error {
+	if fnsu.returnError {
+		return fmt.Errorf("fake error on update node status")
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater/node_status_updater.go

@@ -0,0 +1,146 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 statusupdater implements interfaces that enable updating the status
+// of API objects.
+package statusupdater
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/golang/glog"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
+	clientset "k8s.io/client-go/kubernetes"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+)
+
+// NodeStatusUpdater defines a set of operations for updating the
+// VolumesAttached field in the Node Status.
+type NodeStatusUpdater interface {
+	// Gets a list of node statuses that should be updated from the actual state
+	// of the world and updates them.
+	UpdateNodeStatuses() error
+}
+
+// NewNodeStatusUpdater returns a new instance of NodeStatusUpdater.
+func NewNodeStatusUpdater(
+	kubeClient clientset.Interface,
+	nodeLister corelisters.NodeLister,
+	actualStateOfWorld cache.ActualStateOfWorld) NodeStatusUpdater {
+	return &nodeStatusUpdater{
+		actualStateOfWorld: actualStateOfWorld,
+		nodeLister:         nodeLister,
+		kubeClient:         kubeClient,
+	}
+}
+
+type nodeStatusUpdater struct {
+	kubeClient         clientset.Interface
+	nodeLister         corelisters.NodeLister
+	actualStateOfWorld cache.ActualStateOfWorld
+}
+
+func (nsu *nodeStatusUpdater) UpdateNodeStatuses() error {
+	// TODO: investigate right behavior if nodeName is empty
+	// kubernetes/kubernetes/issues/37777
+	nodesToUpdate := nsu.actualStateOfWorld.GetVolumesToReportAttached()
+	for nodeName, attachedVolumes := range nodesToUpdate {
+		nodeObj, err := nsu.nodeLister.Get(string(nodeName))
+		if errors.IsNotFound(err) {
+			// If node does not exist, its status cannot be updated.
+			// Do nothing so that there is no retry until node is created.
+			glog.V(2).Infof(
+				"Could not update node status. Failed to find node %q in NodeInformer cache. Error: '%v'",
+				nodeName,
+				err)
+			continue
+		} else if err != nil {
+			// For all other errors, log error and reset flag statusUpdateNeeded
+			// back to true to indicate this node status needs to be updated again.
+			glog.V(2).Infof("Error retrieving nodes from node lister. Error: %v", err)
+			nsu.actualStateOfWorld.SetNodeStatusUpdateNeeded(nodeName)
+			continue
+		}
+
+		if err := nsu.updateNodeStatus(nodeName, nodeObj, attachedVolumes); err != nil {
+			// If update node status fails, reset flag statusUpdateNeeded back to true
+			// to indicate this node status needs to be updated again
+			nsu.actualStateOfWorld.SetNodeStatusUpdateNeeded(nodeName)
+
+			glog.V(2).Infof(
+				"Could not update node status for %q; re-marking for update. %v",
+				nodeName,
+				err)
+
+			// We currently always return immediately on error
+			return err
+		}
+	}
+	return nil
+}
+
+func (nsu *nodeStatusUpdater) updateNodeStatus(nodeName types.NodeName, nodeObj *v1.Node, attachedVolumes []v1.AttachedVolume) error {
+	node := nodeObj.DeepCopy()
+
+	// TODO: Change to pkg/util/node.UpdateNodeStatus.
+	oldData, err := json.Marshal(node)
+	if err != nil {
+		return fmt.Errorf(
+			"failed to Marshal oldData for node %q. %v",
+			nodeName,
+			err)
+	}
+
+	node.Status.VolumesAttached = attachedVolumes
+
+	newData, err := json.Marshal(node)
+	if err != nil {
+		return fmt.Errorf(
+			"failed to Marshal newData for node %q. %v",
+			nodeName,
+			err)
+	}
+
+	patchBytes, err :=
+		strategicpatch.CreateTwoWayMergePatch(oldData, newData, node)
+	if err != nil {
+		return fmt.Errorf(
+			"failed to CreateTwoWayMergePatch for node %q. %v",
+			nodeName,
+			err)
+	}
+
+	_, err = nsu.kubeClient.Core().Nodes().PatchStatus(string(nodeName), patchBytes)
+	if err != nil {
+		return fmt.Errorf(
+			"failed to kubeClient.Core().Nodes().Patch for node %q. %v",
+			nodeName,
+			err)
+	}
+	glog.V(4).Infof(
+		"Updating status for node %q succeeded. patchBytes: %q VolumesAttached: %v",
+		nodeName,
+		string(patchBytes),
+		node.Status.VolumesAttached)
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/testing/BUILD

@@ -0,0 +1,36 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["testvolumespec.go"],
+    deps = [
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/volumehelper:go_default_library",
+        "//vendor/github.com/golang/glog: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/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/testing/testvolumespec.go

@@ -0,0 +1,429 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 testing
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/kubernetes/fake"
+	core "k8s.io/client-go/testing"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+const TestPluginName = "kubernetes.io/testPlugin"
+
+// GetTestVolumeSpec returns a test volume spec
+func GetTestVolumeSpec(volumeName string, diskName v1.UniqueVolumeName) *volume.Spec {
+	return &volume.Spec{
+		Volume: &v1.Volume{
+			Name: volumeName,
+			VolumeSource: v1.VolumeSource{
+				GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{
+					PDName:   string(diskName),
+					FSType:   "fake",
+					ReadOnly: false,
+				},
+			},
+		},
+		PersistentVolume: &v1.PersistentVolume{
+			Spec: v1.PersistentVolumeSpec{
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+				},
+			},
+		},
+	}
+}
+
+var extraPods *v1.PodList
+
+func CreateTestClient() *fake.Clientset {
+	fakeClient := &fake.Clientset{}
+
+	extraPods = &v1.PodList{}
+	fakeClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		obj := &v1.PodList{}
+		podNamePrefix := "mypod"
+		namespace := "mynamespace"
+		for i := 0; i < 5; i++ {
+			podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
+			pod := v1.Pod{
+				Status: v1.PodStatus{
+					Phase: v1.PodRunning,
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      podName,
+					UID:       types.UID(podName),
+					Namespace: namespace,
+					Labels: map[string]string{
+						"name": podName,
+					},
+				},
+				Spec: v1.PodSpec{
+					Containers: []v1.Container{
+						{
+							Name:  "containerName",
+							Image: "containerImage",
+							VolumeMounts: []v1.VolumeMount{
+								{
+									Name:      "volumeMountName",
+									ReadOnly:  false,
+									MountPath: "/mnt",
+								},
+							},
+						},
+					},
+					Volumes: []v1.Volume{
+						{
+							Name: "volumeName",
+							VolumeSource: v1.VolumeSource{
+								GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{
+									PDName:   "pdName",
+									FSType:   "ext4",
+									ReadOnly: false,
+								},
+							},
+						},
+					},
+					NodeName: "mynode",
+				},
+			}
+			obj.Items = append(obj.Items, pod)
+		}
+		for _, pod := range extraPods.Items {
+			obj.Items = append(obj.Items, pod)
+		}
+		return true, obj, nil
+	})
+	fakeClient.AddReactor("create", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		createAction := action.(core.CreateAction)
+		pod := createAction.GetObject().(*v1.Pod)
+		extraPods.Items = append(extraPods.Items, *pod)
+		return true, createAction.GetObject(), nil
+	})
+	fakeClient.AddReactor("list", "nodes", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		obj := &v1.NodeList{}
+		nodeNamePrefix := "mynode"
+		for i := 0; i < 5; i++ {
+			var nodeName string
+			if i != 0 {
+				nodeName = fmt.Sprintf("%s-%d", nodeNamePrefix, i)
+			} else {
+				// We want also the "mynode" node since all the testing pods live there
+				nodeName = nodeNamePrefix
+			}
+			node := v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: nodeName,
+					Labels: map[string]string{
+						"name": nodeName,
+					},
+					Annotations: map[string]string{
+						volumehelper.ControllerManagedAttachAnnotation: "true",
+					},
+				},
+				Status: v1.NodeStatus{
+					VolumesAttached: []v1.AttachedVolume{
+						{
+							Name:       TestPluginName + "/lostVolumeName",
+							DevicePath: "fake/path",
+						},
+					},
+				},
+				Spec: v1.NodeSpec{ExternalID: string(nodeName)},
+			}
+			obj.Items = append(obj.Items, node)
+		}
+		return true, obj, nil
+	})
+
+	fakeWatch := watch.NewFake()
+	fakeClient.AddWatchReactor("*", core.DefaultWatchReactor(fakeWatch, nil))
+
+	return fakeClient
+}
+
+// NewPod returns a test pod object
+func NewPod(uid, name string) *v1.Pod {
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			UID:       types.UID(uid),
+			Name:      name,
+			Namespace: name,
+		},
+	}
+}
+
+// NewPod returns a test pod object
+func NewPodWithVolume(podName, volumeName, nodeName string) *v1.Pod {
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			UID:       types.UID(podName),
+			Name:      podName,
+			Namespace: "mynamespace",
+			Labels: map[string]string{
+				"name": podName,
+			},
+		},
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Name:  "containerName",
+					Image: "containerImage",
+					VolumeMounts: []v1.VolumeMount{
+						{
+							Name:      "volumeMountName",
+							ReadOnly:  false,
+							MountPath: "/mnt",
+						},
+					},
+				},
+			},
+			Volumes: []v1.Volume{
+				{
+					Name: volumeName,
+					VolumeSource: v1.VolumeSource{
+						GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{
+							PDName:   "pdName",
+							FSType:   "ext4",
+							ReadOnly: false,
+						},
+					},
+				},
+			},
+			NodeName: nodeName,
+		},
+	}
+}
+
+type TestPlugin struct {
+	ErrorEncountered  bool
+	attachedVolumeMap map[string][]string
+	detachedVolumeMap map[string][]string
+	pluginLock        *sync.RWMutex
+}
+
+func (plugin *TestPlugin) Init(host volume.VolumeHost) error {
+	return nil
+}
+
+func (plugin *TestPlugin) GetPluginName() string {
+	return TestPluginName
+}
+
+func (plugin *TestPlugin) GetVolumeName(spec *volume.Spec) (string, error) {
+	plugin.pluginLock.Lock()
+	defer plugin.pluginLock.Unlock()
+	if spec == nil {
+		glog.Errorf("GetVolumeName called with nil volume spec")
+		plugin.ErrorEncountered = true
+	}
+	return spec.Name(), nil
+}
+
+func (plugin *TestPlugin) CanSupport(spec *volume.Spec) bool {
+	plugin.pluginLock.Lock()
+	defer plugin.pluginLock.Unlock()
+	if spec == nil {
+		glog.Errorf("CanSupport called with nil volume spec")
+		plugin.ErrorEncountered = true
+	}
+	return true
+}
+
+func (plugin *TestPlugin) RequiresRemount() bool {
+	return false
+}
+
+func (plugin *TestPlugin) NewMounter(spec *volume.Spec, podRef *v1.Pod, opts volume.VolumeOptions) (volume.Mounter, error) {
+	plugin.pluginLock.Lock()
+	defer plugin.pluginLock.Unlock()
+	if spec == nil {
+		glog.Errorf("NewMounter called with nil volume spec")
+		plugin.ErrorEncountered = true
+	}
+	return nil, nil
+}
+
+func (plugin *TestPlugin) NewUnmounter(name string, podUID types.UID) (volume.Unmounter, error) {
+	return nil, nil
+}
+
+func (plugin *TestPlugin) ConstructVolumeSpec(volumeName, mountPath string) (*volume.Spec, error) {
+	fakeVolume := &v1.Volume{
+		Name: volumeName,
+		VolumeSource: v1.VolumeSource{
+			GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{
+				PDName:   "pdName",
+				FSType:   "ext4",
+				ReadOnly: false,
+			},
+		},
+	}
+	return volume.NewSpecFromVolume(fakeVolume), nil
+}
+
+func (plugin *TestPlugin) NewAttacher() (volume.Attacher, error) {
+	attacher := testPluginAttacher{
+		ErrorEncountered:  &plugin.ErrorEncountered,
+		attachedVolumeMap: plugin.attachedVolumeMap,
+		pluginLock:        plugin.pluginLock,
+	}
+	return &attacher, nil
+}
+
+func (plugin *TestPlugin) NewDetacher() (volume.Detacher, error) {
+	detacher := testPluginDetacher{
+		detachedVolumeMap: plugin.detachedVolumeMap,
+		pluginLock:        plugin.pluginLock,
+	}
+	return &detacher, nil
+}
+
+func (plugin *TestPlugin) GetDeviceMountRefs(deviceMountPath string) ([]string, error) {
+	return []string{}, nil
+}
+
+func (plugin *TestPlugin) SupportsMountOption() bool {
+	return false
+}
+
+func (plugin *TestPlugin) SupportsBulkVolumeVerification() bool {
+	return false
+}
+
+func (plugin *TestPlugin) GetErrorEncountered() bool {
+	plugin.pluginLock.RLock()
+	defer plugin.pluginLock.RUnlock()
+	return plugin.ErrorEncountered
+}
+
+func (plugin *TestPlugin) GetAttachedVolumes() map[string][]string {
+	plugin.pluginLock.RLock()
+	defer plugin.pluginLock.RUnlock()
+	ret := make(map[string][]string)
+	for nodeName, volumeList := range plugin.attachedVolumeMap {
+		ret[nodeName] = make([]string, len(volumeList))
+		copy(ret[nodeName], volumeList)
+	}
+	return ret
+}
+
+func (plugin *TestPlugin) GetDetachedVolumes() map[string][]string {
+	plugin.pluginLock.RLock()
+	defer plugin.pluginLock.RUnlock()
+	ret := make(map[string][]string)
+	for nodeName, volumeList := range plugin.detachedVolumeMap {
+		ret[nodeName] = make([]string, len(volumeList))
+		copy(ret[nodeName], volumeList)
+	}
+	return ret
+}
+
+func CreateTestPlugin() []volume.VolumePlugin {
+	attachedVolumes := make(map[string][]string)
+	detachedVolumes := make(map[string][]string)
+	return []volume.VolumePlugin{&TestPlugin{
+		ErrorEncountered:  false,
+		attachedVolumeMap: attachedVolumes,
+		detachedVolumeMap: detachedVolumes,
+		pluginLock:        &sync.RWMutex{},
+	}}
+}
+
+// Attacher
+type testPluginAttacher struct {
+	ErrorEncountered  *bool
+	attachedVolumeMap map[string][]string
+	pluginLock        *sync.RWMutex
+}
+
+func (attacher *testPluginAttacher) Attach(spec *volume.Spec, nodeName types.NodeName) (string, error) {
+	attacher.pluginLock.Lock()
+	defer attacher.pluginLock.Unlock()
+	if spec == nil {
+		*attacher.ErrorEncountered = true
+		glog.Errorf("Attach called with nil volume spec")
+		return "", fmt.Errorf("Attach called with nil volume spec")
+	}
+	attacher.attachedVolumeMap[string(nodeName)] = append(attacher.attachedVolumeMap[string(nodeName)], spec.Name())
+	return spec.Name(), nil
+}
+
+func (attacher *testPluginAttacher) VolumesAreAttached(specs []*volume.Spec, nodeName types.NodeName) (map[*volume.Spec]bool, error) {
+	return nil, nil
+}
+
+func (attacher *testPluginAttacher) WaitForAttach(spec *volume.Spec, devicePath string, pod *v1.Pod, timeout time.Duration) (string, error) {
+	attacher.pluginLock.Lock()
+	defer attacher.pluginLock.Unlock()
+	if spec == nil {
+		*attacher.ErrorEncountered = true
+		glog.Errorf("WaitForAttach called with nil volume spec")
+		return "", fmt.Errorf("WaitForAttach called with nil volume spec")
+	}
+	fakePath := fmt.Sprintf("%s/%s", devicePath, spec.Name())
+	return fakePath, nil
+}
+
+func (attacher *testPluginAttacher) GetDeviceMountPath(spec *volume.Spec) (string, error) {
+	attacher.pluginLock.Lock()
+	defer attacher.pluginLock.Unlock()
+	if spec == nil {
+		*attacher.ErrorEncountered = true
+		glog.Errorf("GetDeviceMountPath called with nil volume spec")
+		return "", fmt.Errorf("GetDeviceMountPath called with nil volume spec")
+	}
+	return "", nil
+}
+
+func (attacher *testPluginAttacher) MountDevice(spec *volume.Spec, devicePath string, deviceMountPath string) error {
+	attacher.pluginLock.Lock()
+	defer attacher.pluginLock.Unlock()
+	if spec == nil {
+		*attacher.ErrorEncountered = true
+		glog.Errorf("MountDevice called with nil volume spec")
+		return fmt.Errorf("MountDevice called with nil volume spec")
+	}
+	return nil
+}
+
+// Detacher
+type testPluginDetacher struct {
+	detachedVolumeMap map[string][]string
+	pluginLock        *sync.RWMutex
+}
+
+func (detacher *testPluginDetacher) Detach(volumeName string, nodeName types.NodeName) error {
+	detacher.pluginLock.Lock()
+	defer detacher.pluginLock.Unlock()
+	detacher.detachedVolumeMap[string(nodeName)] = append(detacher.detachedVolumeMap[string(nodeName)], volumeName)
+	return nil
+}
+
+func (detacher *testPluginDetacher) UnmountDevice(deviceMountPath string) error {
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/util/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    deps = [
+        "//pkg/controller/volume/attachdetach/cache:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/volumehelper:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/attachdetach/util/util.go

@@ -0,0 +1,251 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 util
+
+import (
+	"fmt"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+)
+
+// CreateVolumeSpec creates and returns a mutatable volume.Spec object for the
+// specified volume. It dereference any PVC to get PV objects, if needed.
+func CreateVolumeSpec(podVolume v1.Volume, podNamespace string, pvcLister corelisters.PersistentVolumeClaimLister, pvLister corelisters.PersistentVolumeLister) (*volume.Spec, error) {
+	if pvcSource := podVolume.VolumeSource.PersistentVolumeClaim; pvcSource != nil {
+		glog.V(10).Infof(
+			"Found PVC, ClaimName: %q/%q",
+			podNamespace,
+			pvcSource.ClaimName)
+
+		// If podVolume is a PVC, fetch the real PV behind the claim
+		pvName, pvcUID, err := getPVCFromCacheExtractPV(
+			podNamespace, pvcSource.ClaimName, pvcLister)
+		if err != nil {
+			return nil, fmt.Errorf(
+				"error processing PVC %q/%q: %v",
+				podNamespace,
+				pvcSource.ClaimName,
+				err)
+		}
+
+		glog.V(10).Infof(
+			"Found bound PV for PVC (ClaimName %q/%q pvcUID %v): pvName=%q",
+			podNamespace,
+			pvcSource.ClaimName,
+			pvcUID,
+			pvName)
+
+		// Fetch actual PV object
+		volumeSpec, err := getPVSpecFromCache(
+			pvName, pvcSource.ReadOnly, pvcUID, pvLister)
+		if err != nil {
+			return nil, fmt.Errorf(
+				"error processing PVC %q/%q: %v",
+				podNamespace,
+				pvcSource.ClaimName,
+				err)
+		}
+
+		glog.V(10).Infof(
+			"Extracted volumeSpec (%v) from bound PV (pvName %q) and PVC (ClaimName %q/%q pvcUID %v)",
+			volumeSpec.Name,
+			pvName,
+			podNamespace,
+			pvcSource.ClaimName,
+			pvcUID)
+
+		return volumeSpec, nil
+	}
+
+	// Do not return the original volume object, since it's from the shared
+	// informer it may be mutated by another consumer.
+	clonedPodVolume := podVolume.DeepCopy()
+
+	return volume.NewSpecFromVolume(clonedPodVolume), nil
+}
+
+// getPVCFromCacheExtractPV fetches the PVC object with the given namespace and
+// name from the shared internal PVC store extracts the name of the PV it is
+// pointing to and returns it.
+// This method returns an error if a PVC object does not exist in the cache
+// with the given namespace/name.
+// This method returns an error if the PVC object's phase is not "Bound".
+func getPVCFromCacheExtractPV(namespace string, name string, pvcLister corelisters.PersistentVolumeClaimLister) (string, types.UID, error) {
+	pvc, err := pvcLister.PersistentVolumeClaims(namespace).Get(name)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to find PVC %s/%s in PVCInformer cache: %v", namespace, name, err)
+	}
+
+	if pvc.Status.Phase != v1.ClaimBound || pvc.Spec.VolumeName == "" {
+		return "", "", fmt.Errorf(
+			"PVC %s/%s has non-bound phase (%q) or empty pvc.Spec.VolumeName (%q)",
+			namespace,
+			name,
+			pvc.Status.Phase,
+			pvc.Spec.VolumeName)
+	}
+
+	return pvc.Spec.VolumeName, pvc.UID, nil
+}
+
+// getPVSpecFromCache fetches the PV object with the given name from the shared
+// internal PV store and returns a volume.Spec representing it.
+// This method returns an error if a PV object does not exist in the cache with
+// the given name.
+// This method deep copies the PV object so the caller may use the returned
+// volume.Spec object without worrying about it mutating unexpectedly.
+func getPVSpecFromCache(name string, pvcReadOnly bool, expectedClaimUID types.UID, pvLister corelisters.PersistentVolumeLister) (*volume.Spec, error) {
+	pv, err := pvLister.Get(name)
+	if err != nil {
+		return nil, fmt.Errorf("failed to find PV %q in PVInformer cache: %v", name, err)
+	}
+
+	if pv.Spec.ClaimRef == nil {
+		return nil, fmt.Errorf(
+			"found PV object %q but it has a nil pv.Spec.ClaimRef indicating it is not yet bound to the claim",
+			name)
+	}
+
+	if pv.Spec.ClaimRef.UID != expectedClaimUID {
+		return nil, fmt.Errorf(
+			"found PV object %q but its pv.Spec.ClaimRef.UID (%q) does not point to claim.UID (%q)",
+			name,
+			pv.Spec.ClaimRef.UID,
+			expectedClaimUID)
+	}
+
+	// Do not return the object from the informer, since the store is shared it
+	// may be mutated by another consumer.
+	clonedPV := pv.DeepCopy()
+
+	return volume.NewSpecFromPersistentVolume(clonedPV, pvcReadOnly), nil
+}
+
+// DetermineVolumeAction returns true if volume and pod needs to be added to dswp
+// and it returns false if volume and pod needs to be removed from dswp
+func DetermineVolumeAction(pod *v1.Pod, desiredStateOfWorld cache.DesiredStateOfWorld, defaultAction bool) bool {
+	if pod == nil || len(pod.Spec.Volumes) <= 0 {
+		return defaultAction
+	}
+	nodeName := types.NodeName(pod.Spec.NodeName)
+	keepTerminatedPodVolume := desiredStateOfWorld.GetKeepTerminatedPodVolumesForNode(nodeName)
+
+	if volumehelper.IsPodTerminated(pod, pod.Status) {
+		// if pod is terminate we let kubelet policy dictate if volume
+		// should be detached or not
+		return keepTerminatedPodVolume
+	}
+	return defaultAction
+}
+
+// ProcessPodVolumes processes the volumes in the given pod and adds them to the
+// desired state of the world if addVolumes is true, otherwise it removes them.
+func ProcessPodVolumes(pod *v1.Pod, addVolumes bool, desiredStateOfWorld cache.DesiredStateOfWorld, volumePluginMgr *volume.VolumePluginMgr, pvcLister corelisters.PersistentVolumeClaimLister, pvLister corelisters.PersistentVolumeLister) {
+	if pod == nil {
+		return
+	}
+
+	if len(pod.Spec.Volumes) <= 0 {
+		glog.V(10).Infof("Skipping processing of pod %q/%q: it has no volumes.",
+			pod.Namespace,
+			pod.Name)
+		return
+	}
+
+	nodeName := types.NodeName(pod.Spec.NodeName)
+	if nodeName == "" {
+		glog.V(10).Infof(
+			"Skipping processing of pod %q/%q: it is not scheduled to a node.",
+			pod.Namespace,
+			pod.Name)
+		return
+	} else if !desiredStateOfWorld.NodeExists(nodeName) {
+		// If the node the pod is scheduled to does not exist in the desired
+		// state of the world data structure, that indicates the node is not
+		// yet managed by the controller. Therefore, ignore the pod.
+		glog.V(4).Infof(
+			"Skipping processing of pod %q/%q: it is scheduled to node %q which is not managed by the controller.",
+			pod.Namespace,
+			pod.Name,
+			nodeName)
+		return
+	}
+
+	// Process volume spec for each volume defined in pod
+	for _, podVolume := range pod.Spec.Volumes {
+		volumeSpec, err := CreateVolumeSpec(podVolume, pod.Namespace, pvcLister, pvLister)
+		if err != nil {
+			glog.V(10).Infof(
+				"Error processing volume %q for pod %q/%q: %v",
+				podVolume.Name,
+				pod.Namespace,
+				pod.Name,
+				err)
+			continue
+		}
+
+		attachableVolumePlugin, err :=
+			volumePluginMgr.FindAttachablePluginBySpec(volumeSpec)
+		if err != nil || attachableVolumePlugin == nil {
+			glog.V(10).Infof(
+				"Skipping volume %q for pod %q/%q: it does not implement attacher interface. err=%v",
+				podVolume.Name,
+				pod.Namespace,
+				pod.Name,
+				err)
+			continue
+		}
+
+		uniquePodName := volumehelper.GetUniquePodName(pod)
+		if addVolumes {
+			// Add volume to desired state of world
+			_, err := desiredStateOfWorld.AddPod(
+				uniquePodName, pod, volumeSpec, nodeName)
+			if err != nil {
+				glog.V(10).Infof(
+					"Failed to add volume %q for pod %q/%q to desiredStateOfWorld. %v",
+					podVolume.Name,
+					pod.Namespace,
+					pod.Name,
+					err)
+			}
+
+		} else {
+			// Remove volume from desired state of world
+			uniqueVolumeName, err := volumehelper.GetUniqueVolumeNameFromSpec(
+				attachableVolumePlugin, volumeSpec)
+			if err != nil {
+				glog.V(10).Infof(
+					"Failed to delete volume %q for pod %q/%q from desiredStateOfWorld. GetUniqueVolumeNameFromSpec failed with %v",
+					podVolume.Name,
+					pod.Namespace,
+					pod.Name,
+					err)
+				continue
+			}
+			desiredStateOfWorld.DeletePod(
+				uniquePodName, uniqueVolumeName, nodeName)
+		}
+	}
+	return
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/events/BUILD

@@ -0,0 +1,24 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["event.go"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/events/event.go

@@ -0,0 +1,32 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 events
+
+const (
+	// volume relevant event reasons
+	FailedBinding             = "FailedBinding"
+	VolumeMismatch            = "VolumeMismatch"
+	VolumeFailedRecycle       = "VolumeFailedRecycle"
+	VolumeRecycled            = "VolumeRecycled"
+	RecyclerPod               = "RecyclerPod"
+	VolumeDelete              = "VolumeDelete"
+	VolumeFailedDelete        = "VolumeFailedDelete"
+	ExternalProvisioning      = "ExternalProvisioning"
+	ProvisioningFailed        = "ProvisioningFailed"
+	ProvisioningCleanupFailed = "ProvisioningCleanupFailed"
+	ProvisioningSucceeded     = "ProvisioningSucceeded"
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "expand_controller.go",
+        "pvc_populator.go",
+        "sync_volume_resize.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/cloudprovider:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/expand/cache:go_default_library",
+        "//pkg/controller/volume/expand/util:go_default_library",
+        "//pkg/util/goroutinemap/exponentialbackoff:go_default_library",
+        "//pkg/util/io:go_default_library",
+        "//pkg/util/mount:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/operationexecutor:go_default_library",
+        "//vendor/github.com/golang/glog: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/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/controller/volume/expand/cache:all-srcs",
+        "//pkg/controller/volume/expand/util:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/OWNERS

@@ -0,0 +1,4 @@
+approvers:
+- saad-ali
+- jsafrane
+- gnufied

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/cache/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["volume_resize_map.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/controller/volume/expand/util:go_default_library",
+        "//pkg/util/strings:go_default_library",
+        "//pkg/volume/util/types:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/strategicpatch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["volume_resize_map_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/volume/util/types:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/cache/volume_resize_map.go

@@ -0,0 +1,211 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 cache
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	commontypes "k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/controller/volume/expand/util"
+	"k8s.io/kubernetes/pkg/util/strings"
+	"k8s.io/kubernetes/pkg/volume/util/types"
+)
+
+// VolumeResizeMap defines an interface that serves as a cache for holding pending resizing requests
+type VolumeResizeMap interface {
+	// AddPVCUpdate adds pvc for resizing
+	AddPVCUpdate(pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume)
+	// DeletePVC deletes pvc that is scheduled for resizing
+	DeletePVC(pvc *v1.PersistentVolumeClaim)
+	// GetPVCsWithResizeRequest returns all pending pvc resize requests
+	GetPVCsWithResizeRequest() []*PVCWithResizeRequest
+	// MarkAsResized marks a pvc as fully resized
+	MarkAsResized(*PVCWithResizeRequest, resource.Quantity) error
+	// UpdatePVSize updates just pv size after cloudprovider resizing is successful
+	UpdatePVSize(*PVCWithResizeRequest, resource.Quantity) error
+}
+
+type volumeResizeMap struct {
+	// map of unique pvc name and resize requests that are pending or inflight
+	pvcrs map[types.UniquePVCName]*PVCWithResizeRequest
+	// kube client for making API calls
+	kubeClient clientset.Interface
+	// for guarding access to pvcrs map
+	sync.RWMutex
+}
+
+// PVCWithResizeRequest struct defines data structure that stores state needed for
+// performing file system resize
+type PVCWithResizeRequest struct {
+	// PVC that needs to be resized
+	PVC *v1.PersistentVolumeClaim
+	// persistentvolume
+	PersistentVolume *v1.PersistentVolume
+	// Current volume size
+	CurrentSize resource.Quantity
+	// Expended volume size
+	ExpectedSize resource.Quantity
+}
+
+// UniquePVCKey returns unique key of the PVC based on its UID
+func (pvcr *PVCWithResizeRequest) UniquePVCKey() types.UniquePVCName {
+	return types.UniquePVCName(pvcr.PVC.UID)
+}
+
+// QualifiedName returns namespace and name combination of the PVC
+func (pvcr *PVCWithResizeRequest) QualifiedName() string {
+	return strings.JoinQualifiedName(pvcr.PVC.Namespace, pvcr.PVC.Name)
+}
+
+// NewVolumeResizeMap returns new VolumeResizeMap which acts as a cache
+// for holding pending resize requests.
+func NewVolumeResizeMap(kubeClient clientset.Interface) VolumeResizeMap {
+	resizeMap := &volumeResizeMap{}
+	resizeMap.pvcrs = make(map[types.UniquePVCName]*PVCWithResizeRequest)
+	resizeMap.kubeClient = kubeClient
+	return resizeMap
+}
+
+// AddPVCUpdate adds pvc for resizing
+func (resizeMap *volumeResizeMap) AddPVCUpdate(pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume) {
+	if pv.Spec.ClaimRef == nil || pvc.Namespace != pv.Spec.ClaimRef.Namespace || pvc.Name != pv.Spec.ClaimRef.Name {
+		glog.V(4).Infof("Persistent Volume is not bound to PVC being updated : %s", util.ClaimToClaimKey(pvc))
+		return
+	}
+
+	if pvc.Status.Phase != v1.ClaimBound {
+		return
+	}
+
+	resizeMap.Lock()
+	defer resizeMap.Unlock()
+
+	pvcSize := pvc.Spec.Resources.Requests[v1.ResourceStorage]
+	pvcStatusSize := pvc.Status.Capacity[v1.ResourceStorage]
+
+	if pvcStatusSize.Cmp(pvcSize) >= 0 {
+		return
+	}
+
+	glog.V(4).Infof("Adding pvc %s with Size %s/%s for resizing", util.ClaimToClaimKey(pvc), pvcSize.String(), pvcStatusSize.String())
+
+	pvcRequest := &PVCWithResizeRequest{
+		PVC:              pvc,
+		CurrentSize:      pvcStatusSize,
+		ExpectedSize:     pvcSize,
+		PersistentVolume: pv,
+	}
+	resizeMap.pvcrs[types.UniquePVCName(pvc.UID)] = pvcRequest
+}
+
+// GetPVCsWithResizeRequest returns all pending pvc resize requests
+func (resizeMap *volumeResizeMap) GetPVCsWithResizeRequest() []*PVCWithResizeRequest {
+	resizeMap.Lock()
+	defer resizeMap.Unlock()
+
+	pvcrs := []*PVCWithResizeRequest{}
+	for _, pvcr := range resizeMap.pvcrs {
+		pvcrs = append(pvcrs, pvcr)
+	}
+	// Empty out pvcrs map, we will add back failed resize requests later
+	resizeMap.pvcrs = map[types.UniquePVCName]*PVCWithResizeRequest{}
+	return pvcrs
+}
+
+// DeletePVC removes given pvc object from list of pvcs that needs resizing.
+// deleting a pvc in this map doesn't affect operations that are already inflight.
+func (resizeMap *volumeResizeMap) DeletePVC(pvc *v1.PersistentVolumeClaim) {
+	resizeMap.Lock()
+	defer resizeMap.Unlock()
+	pvcUniqueName := types.UniquePVCName(pvc.UID)
+	glog.V(5).Infof("Removing PVC %v from resize map", pvcUniqueName)
+	delete(resizeMap.pvcrs, pvcUniqueName)
+}
+
+// MarkAsResized marks a pvc as fully resized
+func (resizeMap *volumeResizeMap) MarkAsResized(pvcr *PVCWithResizeRequest, newSize resource.Quantity) error {
+	resizeMap.Lock()
+	defer resizeMap.Unlock()
+
+	emptyCondition := []v1.PersistentVolumeClaimCondition{}
+
+	err := resizeMap.updatePVCCapacityAndConditions(pvcr, newSize, emptyCondition)
+	if err != nil {
+		glog.V(4).Infof("Error updating PV spec capacity for volume %q with : %v", pvcr.QualifiedName(), err)
+		return err
+	}
+	return nil
+}
+
+// UpdatePVSize updates just pv size after cloudprovider resizing is successful
+func (resizeMap *volumeResizeMap) UpdatePVSize(pvcr *PVCWithResizeRequest, newSize resource.Quantity) error {
+	resizeMap.Lock()
+	defer resizeMap.Unlock()
+
+	oldPv := pvcr.PersistentVolume
+	pvClone := oldPv.DeepCopy()
+
+	oldData, err := json.Marshal(pvClone)
+
+	if err != nil {
+		return fmt.Errorf("Unexpected error marshaling PV : %q with error %v", pvClone.Name, err)
+	}
+
+	pvClone.Spec.Capacity[v1.ResourceStorage] = newSize
+
+	newData, err := json.Marshal(pvClone)
+
+	if err != nil {
+		return fmt.Errorf("Unexpected error marshaling PV : %q with error %v", pvClone.Name, err)
+	}
+
+	patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, pvClone)
+
+	if err != nil {
+		return fmt.Errorf("Error Creating two way merge patch for  PV : %q with error %v", pvClone.Name, err)
+	}
+
+	_, updateErr := resizeMap.kubeClient.CoreV1().PersistentVolumes().Patch(pvClone.Name, commontypes.StrategicMergePatchType, patchBytes)
+
+	if updateErr != nil {
+		glog.V(4).Infof("Error updating pv %q with error : %v", pvClone.Name, updateErr)
+		return updateErr
+	}
+	return nil
+}
+
+func (resizeMap *volumeResizeMap) updatePVCCapacityAndConditions(pvcr *PVCWithResizeRequest, newSize resource.Quantity, pvcConditions []v1.PersistentVolumeClaimCondition) error {
+
+	claimClone := pvcr.PVC.DeepCopy()
+
+	claimClone.Status.Capacity[v1.ResourceStorage] = newSize
+	claimClone.Status.Conditions = pvcConditions
+
+	_, updateErr := resizeMap.kubeClient.CoreV1().PersistentVolumeClaims(claimClone.Namespace).UpdateStatus(claimClone)
+	if updateErr != nil {
+		glog.V(4).Infof("updating PersistentVolumeClaim[%s] status: failed: %v", pvcr.QualifiedName(), updateErr)
+		return updateErr
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/cache/volume_resize_map_test.go

@@ -0,0 +1,147 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 cache
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/fake"
+	"k8s.io/kubernetes/pkg/volume/util/types"
+)
+
+func Test_AddValidPVCUpdate(t *testing.T) {
+	claim := testVolumeClaim("foo", "ns", v1.PersistentVolumeClaimSpec{
+		AccessModes: []v1.PersistentVolumeAccessMode{
+			v1.ReadWriteOnce,
+			v1.ReadOnlyMany,
+		},
+		Resources: v1.ResourceRequirements{
+			Requests: v1.ResourceList{
+				v1.ResourceName(v1.ResourceStorage): resource.MustParse("12G"),
+			},
+		},
+		VolumeName: "foo",
+	})
+
+	unboundClaim := claim.DeepCopy()
+	unboundClaim.Status.Phase = v1.ClaimPending
+
+	noResizeClaim := claim.DeepCopy()
+	noResizeClaim.Status.Capacity = v1.ResourceList{
+		v1.ResourceName(v1.ResourceStorage): resource.MustParse("12G"),
+	}
+
+	boundPV := getPersistentVolume("foo", resource.MustParse("10G"), claim)
+	unboundPV := getPersistentVolume("foo", resource.MustParse("10G"), nil)
+	misboundPV := getPersistentVolume("foo", resource.MustParse("10G"), nil)
+	misboundPV.Spec.ClaimRef = &v1.ObjectReference{
+		Namespace: "someOtherNamespace",
+		Name:      "someOtherName",
+	}
+
+	tests := []struct {
+		name         string
+		pvc          *v1.PersistentVolumeClaim
+		pv           *v1.PersistentVolume
+		expectedPVCs int
+	}{
+		{
+			"validPVCUpdate",
+			claim,
+			boundPV,
+			1,
+		},
+		{
+			"noResizeRequired",
+			noResizeClaim,
+			boundPV,
+			0,
+		},
+		{
+			"unboundPVC",
+			unboundClaim,
+			boundPV,
+			0,
+		},
+		{
+			"unboundPV",
+			claim,
+			unboundPV,
+			0,
+		},
+		{
+			"misboundPV",
+			claim,
+			misboundPV,
+			0,
+		},
+	}
+	for _, test := range tests {
+		resizeMap := createTestVolumeResizeMap()
+		pvc := test.pvc.DeepCopy()
+		pv := test.pv.DeepCopy()
+		resizeMap.AddPVCUpdate(pvc, pv)
+		pvcr := resizeMap.GetPVCsWithResizeRequest()
+		if len(pvcr) != test.expectedPVCs {
+			t.Errorf("Test %q expected %d pvc resize request got %d", test.name, test.expectedPVCs, len(pvcr))
+		}
+		if test.expectedPVCs > 0 {
+			assert.Equal(t, resource.MustParse("12G"), pvcr[0].ExpectedSize, test.name)
+		}
+		assert.Equal(t, 0, len(resizeMap.pvcrs), test.name)
+	}
+}
+
+func createTestVolumeResizeMap() *volumeResizeMap {
+	fakeClient := &fake.Clientset{}
+	resizeMap := &volumeResizeMap{}
+	resizeMap.pvcrs = make(map[types.UniquePVCName]*PVCWithResizeRequest)
+	resizeMap.kubeClient = fakeClient
+	return resizeMap
+}
+
+func testVolumeClaim(name string, namespace string, spec v1.PersistentVolumeClaimSpec) *v1.PersistentVolumeClaim {
+	return &v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: namespace},
+		Spec:       spec,
+		Status: v1.PersistentVolumeClaimStatus{
+			Phase: v1.ClaimBound,
+		},
+	}
+}
+
+func getPersistentVolume(volumeName string, capacity resource.Quantity, pvc *v1.PersistentVolumeClaim) *v1.PersistentVolume {
+	volume := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{Name: volumeName},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity: v1.ResourceList{
+				v1.ResourceName(v1.ResourceStorage): capacity,
+			},
+		},
+	}
+	if pvc != nil {
+		volume.Spec.ClaimRef = &v1.ObjectReference{
+			Namespace: pvc.Namespace,
+			Name:      pvc.Name,
+		}
+	}
+	return volume
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/expand_controller.go

@@ -0,0 +1,268 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 expand implements interfaces that attempt to resize a pvc
+// by adding pvc to a volume resize map from which PVCs are picked and
+// resized
+package expand
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/golang/glog"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/runtime"
+	coreinformers "k8s.io/client-go/informers/core/v1"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes/scheme"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	kcache "k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/volume/expand/cache"
+	"k8s.io/kubernetes/pkg/util/io"
+	"k8s.io/kubernetes/pkg/util/mount"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+)
+
+const (
+	// How often resizing loop runs
+	syncLoopPeriod time.Duration = 30 * time.Second
+	// How often pvc populator runs
+	populatorLoopPeriod time.Duration = 2 * time.Minute
+)
+
+// ExpandController expands the pvs
+type ExpandController interface {
+	Run(stopCh <-chan struct{})
+}
+
+type expandController struct {
+	// kubeClient is the kube API client used by volumehost to communicate with
+	// the API server.
+	kubeClient clientset.Interface
+
+	// pvcLister is the shared PVC lister used to fetch and store PVC
+	// objects from the API server. It is shared with other controllers and
+	// therefore the PVC objects in its store should be treated as immutable.
+	pvcLister  corelisters.PersistentVolumeClaimLister
+	pvcsSynced kcache.InformerSynced
+
+	pvLister corelisters.PersistentVolumeLister
+	pvSynced kcache.InformerSynced
+
+	// cloud provider used by volume host
+	cloud cloudprovider.Interface
+
+	// volumePluginMgr used to initialize and fetch volume plugins
+	volumePluginMgr volume.VolumePluginMgr
+
+	// recorder is used to record events in the API server
+	recorder record.EventRecorder
+
+	// Volume resize map of volumes that needs resizing
+	resizeMap cache.VolumeResizeMap
+
+	// Worker goroutine to process resize requests from resizeMap
+	syncResize SyncVolumeResize
+
+	// Operation executor
+	opExecutor operationexecutor.OperationExecutor
+
+	// populator for periodically polling all PVCs
+	pvcPopulator PVCPopulator
+}
+
+func NewExpandController(
+	kubeClient clientset.Interface,
+	pvcInformer coreinformers.PersistentVolumeClaimInformer,
+	pvInformer coreinformers.PersistentVolumeInformer,
+	cloud cloudprovider.Interface,
+	plugins []volume.VolumePlugin) (ExpandController, error) {
+
+	expc := &expandController{
+		kubeClient: kubeClient,
+		cloud:      cloud,
+		pvcLister:  pvcInformer.Lister(),
+		pvcsSynced: pvcInformer.Informer().HasSynced,
+		pvLister:   pvInformer.Lister(),
+		pvSynced:   pvInformer.Informer().HasSynced,
+	}
+
+	if err := expc.volumePluginMgr.InitPlugins(plugins, nil, expc); err != nil {
+		return nil, fmt.Errorf("Could not initialize volume plugins for Expand Controller : %+v", err)
+	}
+
+	eventBroadcaster := record.NewBroadcaster()
+	eventBroadcaster.StartLogging(glog.Infof)
+	eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: v1core.New(kubeClient.CoreV1().RESTClient()).Events("")})
+	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "volume_expand"})
+
+	expc.opExecutor = operationexecutor.NewOperationExecutor(operationexecutor.NewOperationGenerator(
+		kubeClient,
+		&expc.volumePluginMgr,
+		recorder,
+		false))
+
+	expc.resizeMap = cache.NewVolumeResizeMap(expc.kubeClient)
+
+	pvcInformer.Informer().AddEventHandler(kcache.ResourceEventHandlerFuncs{
+		UpdateFunc: expc.pvcUpdate,
+		DeleteFunc: expc.deletePVC,
+	})
+
+	expc.syncResize = NewSyncVolumeResize(syncLoopPeriod, expc.opExecutor, expc.resizeMap, kubeClient)
+	expc.pvcPopulator = NewPVCPopulator(
+		populatorLoopPeriod,
+		expc.resizeMap,
+		expc.pvcLister,
+		expc.pvLister,
+		kubeClient)
+	return expc, nil
+}
+
+func (expc *expandController) Run(stopCh <-chan struct{}) {
+	defer runtime.HandleCrash()
+	glog.Infof("Starting expand controller")
+	defer glog.Infof("Shutting down expand controller")
+
+	if !controller.WaitForCacheSync("expand", stopCh, expc.pvcsSynced, expc.pvSynced) {
+		return
+	}
+
+	// Run volume sync work goroutine
+	go expc.syncResize.Run(stopCh)
+	// Start the pvc populator loop
+	go expc.pvcPopulator.Run(stopCh)
+	<-stopCh
+}
+
+func (expc *expandController) deletePVC(obj interface{}) {
+	pvc, ok := obj.(*v1.PersistentVolumeClaim)
+
+	if pvc == nil || !ok {
+		return
+	}
+
+	expc.resizeMap.DeletePVC(pvc)
+}
+
+func (expc *expandController) pvcUpdate(oldObj, newObj interface{}) {
+	oldPvc, ok := oldObj.(*v1.PersistentVolumeClaim)
+
+	if oldPvc == nil || !ok {
+		return
+	}
+
+	newPVC, ok := newObj.(*v1.PersistentVolumeClaim)
+
+	if newPVC == nil || !ok {
+		return
+	}
+	pv, err := getPersistentVolume(newPVC, expc.pvLister)
+	if err != nil {
+		glog.V(5).Infof("Error getting Persistent Volume for pvc %q : %v", newPVC.UID, err)
+		return
+	}
+	expc.resizeMap.AddPVCUpdate(newPVC, pv)
+}
+
+func getPersistentVolume(pvc *v1.PersistentVolumeClaim, pvLister corelisters.PersistentVolumeLister) (*v1.PersistentVolume, error) {
+	volumeName := pvc.Spec.VolumeName
+	pv, err := pvLister.Get(volumeName)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to find PV %q in PV informer cache with error : %v", volumeName, err)
+	}
+
+	return pv.DeepCopy(), nil
+}
+
+// Implementing VolumeHost interface
+func (expc *expandController) GetPluginDir(pluginName string) string {
+	return ""
+}
+
+func (expc *expandController) GetPodVolumeDir(podUID types.UID, pluginName string, volumeName string) string {
+	return ""
+}
+
+func (expc *expandController) GetPodPluginDir(podUID types.UID, pluginName string) string {
+	return ""
+}
+
+func (expc *expandController) GetKubeClient() clientset.Interface {
+	return expc.kubeClient
+}
+
+func (expc *expandController) NewWrapperMounter(volName string, spec volume.Spec, pod *v1.Pod, opts volume.VolumeOptions) (volume.Mounter, error) {
+	return nil, fmt.Errorf("NewWrapperMounter not supported by expand controller's VolumeHost implementation")
+}
+
+func (expc *expandController) NewWrapperUnmounter(volName string, spec volume.Spec, podUID types.UID) (volume.Unmounter, error) {
+	return nil, fmt.Errorf("NewWrapperUnmounter not supported by expand controller's VolumeHost implementation")
+}
+
+func (expc *expandController) GetCloudProvider() cloudprovider.Interface {
+	return expc.cloud
+}
+
+func (expc *expandController) GetMounter(pluginName string) mount.Interface {
+	return nil
+}
+
+func (expc *expandController) GetExec(pluginName string) mount.Exec {
+	return mount.NewOsExec()
+}
+
+func (expc *expandController) GetWriter() io.Writer {
+	return nil
+}
+
+func (expc *expandController) GetHostName() string {
+	return ""
+}
+
+func (expc *expandController) GetHostIP() (net.IP, error) {
+	return nil, fmt.Errorf("GetHostIP not supported by expand controller's VolumeHost implementation")
+}
+
+func (expc *expandController) GetNodeAllocatable() (v1.ResourceList, error) {
+	return v1.ResourceList{}, nil
+}
+
+func (expc *expandController) GetSecretFunc() func(namespace, name string) (*v1.Secret, error) {
+	return func(_, _ string) (*v1.Secret, error) {
+		return nil, fmt.Errorf("GetSecret unsupported in expandController")
+	}
+}
+
+func (expc *expandController) GetConfigMapFunc() func(namespace, name string) (*v1.ConfigMap, error) {
+	return func(_, _ string) (*v1.ConfigMap, error) {
+		return nil, fmt.Errorf("GetConfigMap unsupported in expandController")
+	}
+}
+
+func (expc *expandController) GetNodeLabels() (map[string]string, error) {
+	return nil, fmt.Errorf("GetNodeLabels unsupported in expandController")
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/pvc_populator.go

@@ -0,0 +1,85 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 reconciler implements interfaces that attempt to reconcile the
+// desired state of the with the actual state of the world by triggering
+// actions.
+
+package expand
+
+import (
+	"time"
+
+	"github.com/golang/glog"
+
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/wait"
+	clientset "k8s.io/client-go/kubernetes"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/kubernetes/pkg/controller/volume/expand/cache"
+)
+
+// PVCPopulator iterates through PVCs and checks if for bound PVCs
+// their size doesn't match with Persistent Volume size
+type PVCPopulator interface {
+	Run(stopCh <-chan struct{})
+}
+
+type pvcPopulator struct {
+	loopPeriod time.Duration
+	resizeMap  cache.VolumeResizeMap
+	pvcLister  corelisters.PersistentVolumeClaimLister
+	pvLister   corelisters.PersistentVolumeLister
+	kubeClient clientset.Interface
+}
+
+func NewPVCPopulator(
+	loopPeriod time.Duration,
+	resizeMap cache.VolumeResizeMap,
+	pvcLister corelisters.PersistentVolumeClaimLister,
+	pvLister corelisters.PersistentVolumeLister,
+	kubeClient clientset.Interface) PVCPopulator {
+	populator := &pvcPopulator{
+		loopPeriod: loopPeriod,
+		pvcLister:  pvcLister,
+		pvLister:   pvLister,
+		resizeMap:  resizeMap,
+		kubeClient: kubeClient,
+	}
+	return populator
+}
+
+func (populator *pvcPopulator) Run(stopCh <-chan struct{}) {
+	wait.Until(populator.Sync, populator.loopPeriod, stopCh)
+}
+
+func (populator *pvcPopulator) Sync() {
+	pvcs, err := populator.pvcLister.List(labels.Everything())
+	if err != nil {
+		glog.Errorf("Listing PVCs failed in populator : %v", err)
+		return
+	}
+
+	for _, pvc := range pvcs {
+		pv, err := getPersistentVolume(pvc, populator.pvLister)
+
+		if err != nil {
+			glog.V(5).Infof("Error getting persistent volume for pvc %q : %v", pvc.UID, err)
+			continue
+		}
+		populator.resizeMap.AddPVCUpdate(pvc, pv)
+	}
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/sync_volume_resize.go

@@ -0,0 +1,101 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 expand
+
+import (
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/controller/volume/expand/cache"
+	"k8s.io/kubernetes/pkg/controller/volume/expand/util"
+	"k8s.io/kubernetes/pkg/util/goroutinemap/exponentialbackoff"
+	"k8s.io/kubernetes/pkg/volume/util/operationexecutor"
+)
+
+type SyncVolumeResize interface {
+	Run(stopCh <-chan struct{})
+}
+
+type syncResize struct {
+	loopPeriod  time.Duration
+	resizeMap   cache.VolumeResizeMap
+	opsExecutor operationexecutor.OperationExecutor
+	kubeClient  clientset.Interface
+}
+
+// NewSyncVolumeResize returns actual volume resize handler
+func NewSyncVolumeResize(
+	loopPeriod time.Duration,
+	opsExecutor operationexecutor.OperationExecutor,
+	resizeMap cache.VolumeResizeMap,
+	kubeClient clientset.Interface) SyncVolumeResize {
+	rc := &syncResize{
+		loopPeriod:  loopPeriod,
+		opsExecutor: opsExecutor,
+		resizeMap:   resizeMap,
+		kubeClient:  kubeClient,
+	}
+	return rc
+}
+
+func (rc *syncResize) Run(stopCh <-chan struct{}) {
+	wait.Until(rc.Sync, rc.loopPeriod, stopCh)
+}
+
+func (rc *syncResize) Sync() {
+	// Resize PVCs that require resize
+	for _, pvcWithResizeRequest := range rc.resizeMap.GetPVCsWithResizeRequest() {
+		uniqueVolumeKey := v1.UniqueVolumeName(pvcWithResizeRequest.UniquePVCKey())
+		updatedClaim, err := markPVCResizeInProgress(pvcWithResizeRequest, rc.kubeClient)
+		if err != nil {
+			glog.V(5).Infof("Error setting PVC %s in progress with error : %v", pvcWithResizeRequest.QualifiedName(), err)
+			continue
+		}
+		if updatedClaim != nil {
+			pvcWithResizeRequest.PVC = updatedClaim
+		}
+
+		if rc.opsExecutor.IsOperationPending(uniqueVolumeKey, "") {
+			glog.V(10).Infof("Operation for PVC %v is already pending", pvcWithResizeRequest.QualifiedName())
+			continue
+		}
+		glog.V(5).Infof("Starting opsExecutor.ExpandVolume for volume %s", pvcWithResizeRequest.QualifiedName())
+		growFuncError := rc.opsExecutor.ExpandVolume(pvcWithResizeRequest, rc.resizeMap)
+		if growFuncError != nil && !exponentialbackoff.IsExponentialBackoff(growFuncError) {
+			glog.Errorf("Error growing pvc %s with %v", pvcWithResizeRequest.QualifiedName(), growFuncError)
+		}
+		if growFuncError == nil {
+			glog.V(5).Infof("Started opsExecutor.ExpandVolume for volume %s", pvcWithResizeRequest.QualifiedName())
+		}
+	}
+}
+
+func markPVCResizeInProgress(pvcWithResizeRequest *cache.PVCWithResizeRequest, kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) {
+	// Mark PVC as Resize Started
+	progressCondition := v1.PersistentVolumeClaimCondition{
+		Type:               v1.PersistentVolumeClaimResizing,
+		Status:             v1.ConditionTrue,
+		LastTransitionTime: metav1.Now(),
+	}
+	conditions := []v1.PersistentVolumeClaimCondition{progressCondition}
+
+	return util.UpdatePVCCondition(pvcWithResizeRequest.PVC, conditions, kubeClient)
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/util/BUILD

@@ -0,0 +1,26 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/expand/util/util.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+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 util
+
+import (
+	"fmt"
+
+	"github.com/golang/glog"
+
+	"k8s.io/api/core/v1"
+	clientset "k8s.io/client-go/kubernetes"
+)
+
+// ClaimToClaimKey return namespace/name string for pvc
+func ClaimToClaimKey(claim *v1.PersistentVolumeClaim) string {
+	return fmt.Sprintf("%s/%s", claim.Namespace, claim.Name)
+}
+
+// UpdatePVCCondition updates pvc with given condition status
+func UpdatePVCCondition(pvc *v1.PersistentVolumeClaim,
+	pvcConditions []v1.PersistentVolumeClaimCondition,
+	kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) {
+
+	claimClone := pvc.DeepCopy()
+	claimClone.Status.Conditions = pvcConditions
+	updatedClaim, updateErr := kubeClient.CoreV1().PersistentVolumeClaims(claimClone.Namespace).UpdateStatus(claimClone)
+	if updateErr != nil {
+		glog.V(4).Infof("updating PersistentVolumeClaim[%s] status: failed: %v", ClaimToClaimKey(pvc), updateErr)
+		return nil, updateErr
+	}
+	return updatedClaim, nil
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/BUILD

@@ -0,0 +1,107 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "index.go",
+        "pv_controller.go",
+        "pv_controller_base.go",
+        "volume_host.go",
+    ],
+    deps = [
+        "//pkg/api/v1/helper:go_default_library",
+        "//pkg/cloudprovider:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/volume/events:go_default_library",
+        "//pkg/util/goroutinemap:go_default_library",
+        "//pkg/util/goroutinemap/exponentialbackoff:go_default_library",
+        "//pkg/util/io:go_default_library",
+        "//pkg/util/mount:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/storage/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/storage/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/storage/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+        "//vendor/k8s.io/client-go/tools/reference:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "binder_test.go",
+        "delete_test.go",
+        "framework_test.go",
+        "index_test.go",
+        "provision_test.go",
+        "pv_controller_test.go",
+        "recycle_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/storage/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/listers/storage/v1:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+        "//vendor/k8s.io/client-go/tools/reference:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/controller/volume/persistentvolume/options:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/OWNERS

@@ -0,0 +1,4 @@
+approvers:
+- jsafrane
+- saad-ali
+- thockin

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/binder_test.go

@@ -0,0 +1,569 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+)
+
+// Test single call to syncClaim and syncVolume methods.
+// 1. Fill in the controller with initial data
+// 2. Call the tested function (syncClaim/syncVolume) via
+//    controllerTest.testCall *once*.
+// 3. Compare resulting volumes and claims with expected volumes and claims.
+func TestSync(t *testing.T) {
+	labels := map[string]string{
+		"foo": "true",
+		"bar": "false",
+	}
+
+	tests := []controllerTest{
+		// [Unit test set 1] User did not care which PV they get.
+		// Test the matching with no claim.Spec.VolumeName and with various
+		// volumes.
+		{
+			// syncClaim binds to a matching unbound volume.
+			"1-1 - successful bind",
+			newVolumeArray("volume1-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume1-1", "1Gi", "uid1-1", "claim1-1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim1-1", "uid1-1", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim1-1", "uid1-1", "1Gi", "volume1-1", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim does not do anything when there is no matching volume.
+			"1-2 - noop",
+			newVolumeArray("volume1-2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume1-2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim1-2", "uid1-2", "10Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim1-2", "uid1-2", "10Gi", "", v1.ClaimPending, nil),
+			[]string{"Normal FailedBinding"},
+			noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim resets claim.Status to Pending when there is no
+			// matching volume.
+			"1-3 - reset to Pending",
+			newVolumeArray("volume1-3", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume1-3", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim1-3", "uid1-3", "10Gi", "", v1.ClaimBound, nil),
+			newClaimArray("claim1-3", "uid1-3", "10Gi", "", v1.ClaimPending, nil),
+			[]string{"Normal FailedBinding"},
+			noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim binds claims to the smallest matching volume
+			"1-4 - smallest volume",
+			[]*v1.PersistentVolume{
+				newVolume("volume1-4_1", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume1-4_2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume1-4_1", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume1-4_2", "1Gi", "uid1-4", "claim1-4", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			},
+			newClaimArray("claim1-4", "uid1-4", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim1-4", "uid1-4", "1Gi", "volume1-4_2", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim binds a claim only to volume that points to it (by
+			// name), even though a smaller one is available.
+			"1-5 - prebound volume by name - success",
+			[]*v1.PersistentVolume{
+				newVolume("volume1-5_1", "10Gi", "", "claim1-5", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume1-5_2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume1-5_1", "10Gi", "uid1-5", "claim1-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume1-5_2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			newClaimArray("claim1-5", "uid1-5", "1Gi", "", v1.ClaimPending, nil),
+			withExpectedCapacity("10Gi", newClaimArray("claim1-5", "uid1-5", "1Gi", "volume1-5_1", v1.ClaimBound, nil, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim binds a claim only to volume that points to it (by
+			// UID), even though a smaller one is available.
+			"1-6 - prebound volume by UID - success",
+			[]*v1.PersistentVolume{
+				newVolume("volume1-6_1", "10Gi", "uid1-6", "claim1-6", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume1-6_2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume1-6_1", "10Gi", "uid1-6", "claim1-6", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume1-6_2", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			newClaimArray("claim1-6", "uid1-6", "1Gi", "", v1.ClaimPending, nil),
+			withExpectedCapacity("10Gi", newClaimArray("claim1-6", "uid1-6", "1Gi", "volume1-6_1", v1.ClaimBound, nil, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim does not bind claim to a volume prebound to a claim with
+			// same name and different UID
+			"1-7 - prebound volume to different claim",
+			newVolumeArray("volume1-7", "10Gi", "uid1-777", "claim1-7", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume1-7", "10Gi", "uid1-777", "claim1-7", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim1-7", "uid1-7", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim1-7", "uid1-7", "1Gi", "", v1.ClaimPending, nil),
+			[]string{"Normal FailedBinding"},
+			noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim completes binding - simulates controller crash after
+			// PV.ClaimRef is saved
+			"1-8 - complete bind after crash - PV bound",
+			newVolumeArray("volume1-8", "1Gi", "uid1-8", "claim1-8", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newVolumeArray("volume1-8", "1Gi", "uid1-8", "claim1-8", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim1-8", "uid1-8", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim1-8", "uid1-8", "1Gi", "volume1-8", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim completes binding - simulates controller crash after
+			// PV.Status is saved
+			"1-9 - complete bind after crash - PV status saved",
+			newVolumeArray("volume1-9", "1Gi", "uid1-9", "claim1-9", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newVolumeArray("volume1-9", "1Gi", "uid1-9", "claim1-9", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim1-9", "uid1-9", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim1-9", "uid1-9", "1Gi", "volume1-9", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim completes binding - simulates controller crash after
+			// PVC.VolumeName is saved
+			"1-10 - complete bind after crash - PVC bound",
+			newVolumeArray("volume1-10", "1Gi", "uid1-10", "claim1-10", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newVolumeArray("volume1-10", "1Gi", "uid1-10", "claim1-10", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim1-10", "uid1-10", "1Gi", "volume1-10", v1.ClaimPending, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim1-10", "uid1-10", "1Gi", "volume1-10", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim binds a claim only when the label selector matches the volume
+			"1-11 - bind when selector matches",
+			withLabels(labels, newVolumeArray("volume1-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty)),
+			withLabels(labels, newVolumeArray("volume1-1", "1Gi", "uid1-1", "claim1-1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController)),
+			withLabelSelector(labels, newClaimArray("claim1-1", "uid1-1", "1Gi", "", v1.ClaimPending, nil)),
+			withLabelSelector(labels, newClaimArray("claim1-1", "uid1-1", "1Gi", "volume1-1", v1.ClaimBound, nil, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim does not bind a claim when the label selector doesn't match
+			"1-12 - do not bind when selector does not match",
+			newVolumeArray("volume1-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume1-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			withLabelSelector(labels, newClaimArray("claim1-1", "uid1-1", "1Gi", "", v1.ClaimPending, nil)),
+			withLabelSelector(labels, newClaimArray("claim1-1", "uid1-1", "1Gi", "", v1.ClaimPending, nil)),
+			[]string{"Normal FailedBinding"},
+			noerrors, testSyncClaim,
+		},
+
+		// [Unit test set 2] User asked for a specific PV.
+		// Test the binding when pv.ClaimRef is already set by controller or
+		// by user.
+		{
+			// syncClaim with claim pre-bound to a PV that does not exist
+			"2-1 - claim prebound to non-existing volume - noop",
+			novolumes,
+			novolumes,
+			newClaimArray("claim2-1", "uid2-1", "10Gi", "volume2-1", v1.ClaimPending, nil),
+			newClaimArray("claim2-1", "uid2-1", "10Gi", "volume2-1", v1.ClaimPending, nil),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that does not exist.
+			// Check that the claim status is reset to Pending
+			"2-2 - claim prebound to non-existing volume - reset status",
+			novolumes,
+			novolumes,
+			newClaimArray("claim2-2", "uid2-2", "10Gi", "volume2-2", v1.ClaimBound, nil),
+			newClaimArray("claim2-2", "uid2-2", "10Gi", "volume2-2", v1.ClaimPending, nil),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that exists and is
+			// unbound. Check it gets bound and no annBoundByController is set.
+			"2-3 - claim prebound to unbound volume",
+			newVolumeArray("volume2-3", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-3", "1Gi", "uid2-3", "claim2-3", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim2-3", "uid2-3", "1Gi", "volume2-3", v1.ClaimPending, nil),
+			newClaimArray("claim2-3", "uid2-3", "1Gi", "volume2-3", v1.ClaimBound, nil, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// claim with claim pre-bound to a PV that is pre-bound to the claim
+			// by name. Check it gets bound and no annBoundByController is set.
+			"2-4 - claim prebound to prebound volume by name",
+			newVolumeArray("volume2-4", "1Gi", "", "claim2-4", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-4", "1Gi", "uid2-4", "claim2-4", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim2-4", "uid2-4", "1Gi", "volume2-4", v1.ClaimPending, nil),
+			newClaimArray("claim2-4", "uid2-4", "1Gi", "volume2-4", v1.ClaimBound, nil, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that is pre-bound to the
+			// claim by UID. Check it gets bound and no annBoundByController is
+			// set.
+			"2-5 - claim prebound to prebound volume by UID",
+			newVolumeArray("volume2-5", "1Gi", "uid2-5", "claim2-5", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-5", "1Gi", "uid2-5", "claim2-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim2-5", "uid2-5", "1Gi", "volume2-5", v1.ClaimPending, nil),
+			newClaimArray("claim2-5", "uid2-5", "1Gi", "volume2-5", v1.ClaimBound, nil, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that is bound to different
+			// claim. Check it's reset to Pending.
+			"2-6 - claim prebound to already bound volume",
+			newVolumeArray("volume2-6", "1Gi", "uid2-6_1", "claim2-6_1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-6", "1Gi", "uid2-6_1", "claim2-6_1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim2-6", "uid2-6", "1Gi", "volume2-6", v1.ClaimBound, nil),
+			newClaimArray("claim2-6", "uid2-6", "1Gi", "volume2-6", v1.ClaimPending, nil),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound by controller to a PV that is bound to
+			// different claim. Check it throws an error.
+			"2-7 - claim bound by controller to already bound volume",
+			newVolumeArray("volume2-7", "1Gi", "uid2-7_1", "claim2-7_1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-7", "1Gi", "uid2-7_1", "claim2-7_1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim2-7", "uid2-7", "1Gi", "volume2-7", v1.ClaimBound, nil, annBoundByController),
+			newClaimArray("claim2-7", "uid2-7", "1Gi", "volume2-7", v1.ClaimBound, nil, annBoundByController),
+			noevents, noerrors, testSyncClaimError,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that exists and is
+			// unbound, but does not match the selector. Check it gets bound
+			// and no annBoundByController is set.
+			"2-8 - claim prebound to unbound volume that does not match the selector",
+			newVolumeArray("volume2-8", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-8", "1Gi", "uid2-8", "claim2-8", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			withLabelSelector(labels, newClaimArray("claim2-8", "uid2-8", "1Gi", "volume2-8", v1.ClaimPending, nil)),
+			withLabelSelector(labels, newClaimArray("claim2-8", "uid2-8", "1Gi", "volume2-8", v1.ClaimBound, nil, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that exists and is
+			// unbound, but its size is smaller than requested.
+			//Check that the claim status is reset to Pending
+			"2-9 - claim prebound to unbound volume that size is smaller than requested",
+			newVolumeArray("volume2-9", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume2-9", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim2-9", "uid2-9", "2Gi", "volume2-9", v1.ClaimBound, nil),
+			newClaimArray("claim2-9", "uid2-9", "2Gi", "volume2-9", v1.ClaimPending, nil),
+			[]string{"Warning VolumeMismatch"}, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim pre-bound to a PV that exists and is
+			// unbound, but its class does not match. Check that the claim status is reset to Pending
+			"2-10 - claim prebound to unbound volume that class is different",
+			newVolumeArray("volume2-10", "1Gi", "1", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+			newVolumeArray("volume2-10", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+			newClaimArray("claim2-10", "uid2-10", "1Gi", "volume2-10", v1.ClaimBound, nil),
+			newClaimArray("claim2-10", "uid2-10", "1Gi", "volume2-10", v1.ClaimPending, nil),
+			[]string{"Warning VolumeMismatch"}, noerrors, testSyncClaim,
+		},
+
+		// [Unit test set 3] Syncing bound claim
+		{
+			// syncClaim with claim  bound and its claim.Spec.VolumeName is
+			// removed. Check it's marked as Lost.
+			"3-1 - bound claim with missing VolumeName",
+			novolumes,
+			novolumes,
+			newClaimArray("claim3-1", "uid3-1", "10Gi", "", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim3-1", "uid3-1", "10Gi", "", v1.ClaimLost, nil, annBoundByController, annBindCompleted),
+			[]string{"Warning ClaimLost"}, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound to non-existing volume. Check it's
+			// marked as Lost.
+			"3-2 - bound claim with missing volume",
+			novolumes,
+			novolumes,
+			newClaimArray("claim3-2", "uid3-2", "10Gi", "volume3-2", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim3-2", "uid3-2", "10Gi", "volume3-2", v1.ClaimLost, nil, annBoundByController, annBindCompleted),
+			[]string{"Warning ClaimLost"}, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound to unbound volume. Check it's bound.
+			// Also check that Pending phase is set to Bound
+			"3-3 - bound claim with unbound volume",
+			newVolumeArray("volume3-3", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume3-3", "10Gi", "uid3-3", "claim3-3", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim3-3", "uid3-3", "10Gi", "volume3-3", v1.ClaimPending, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim3-3", "uid3-3", "10Gi", "volume3-3", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound to volume with missing (or different)
+			// volume.Spec.ClaimRef.UID. Check that the claim is marked as lost.
+			"3-4 - bound claim with prebound volume",
+			newVolumeArray("volume3-4", "10Gi", "claim3-4-x", "claim3-4", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume3-4", "10Gi", "claim3-4-x", "claim3-4", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim3-4", "uid3-4", "10Gi", "volume3-4", v1.ClaimPending, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim3-4", "uid3-4", "10Gi", "volume3-4", v1.ClaimLost, nil, annBoundByController, annBindCompleted),
+			[]string{"Warning ClaimMisbound"}, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound to bound volume. Check that the
+			// controller does not do anything. Also check that Pending phase is
+			// set to Bound
+			"3-5 - bound claim with bound volume",
+			newVolumeArray("volume3-5", "10Gi", "uid3-5", "claim3-5", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume3-5", "10Gi", "uid3-5", "claim3-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim3-5", "uid3-5", "10Gi", "volume3-5", v1.ClaimPending, nil, annBindCompleted),
+			newClaimArray("claim3-5", "uid3-5", "10Gi", "volume3-5", v1.ClaimBound, nil, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound to a volume that is bound to different
+			// claim. Check that the claim is marked as lost.
+			// TODO: test that an event is emitted
+			"3-6 - bound claim with bound volume",
+			newVolumeArray("volume3-6", "10Gi", "uid3-6-x", "claim3-6-x", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume3-6", "10Gi", "uid3-6-x", "claim3-6-x", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim3-6", "uid3-6", "10Gi", "volume3-6", v1.ClaimPending, nil, annBindCompleted),
+			newClaimArray("claim3-6", "uid3-6", "10Gi", "volume3-6", v1.ClaimLost, nil, annBindCompleted),
+			[]string{"Warning ClaimMisbound"}, noerrors, testSyncClaim,
+		},
+		{
+			// syncClaim with claim bound to unbound volume. Check it's bound
+			// even if the claim's selector doesn't match the volume. Also
+			// check that Pending phase is set to Bound
+			"3-7 - bound claim with unbound volume where selector doesn't match",
+			newVolumeArray("volume3-3", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume3-3", "10Gi", "uid3-3", "claim3-3", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			withLabelSelector(labels, newClaimArray("claim3-3", "uid3-3", "10Gi", "volume3-3", v1.ClaimPending, nil, annBoundByController, annBindCompleted)),
+			withLabelSelector(labels, newClaimArray("claim3-3", "uid3-3", "10Gi", "volume3-3", v1.ClaimBound, nil, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		// [Unit test set 4] All syncVolume tests.
+		{
+			// syncVolume with pending volume. Check it's marked as Available.
+			"4-1 - pending volume",
+			newVolumeArray("volume4-1", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-1", "10Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with prebound pending volume. Check it's marked as
+			// Available.
+			"4-2 - pending prebound volume",
+			newVolumeArray("volume4-2", "10Gi", "", "claim4-2", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-2", "10Gi", "", "claim4-2", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound to missing claim.
+			// Check the volume gets Released
+			"4-3 - bound volume with missing claim",
+			newVolumeArray("volume4-3", "10Gi", "uid4-3", "claim4-3", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-3", "10Gi", "uid4-3", "claim4-3", v1.VolumeReleased, v1.PersistentVolumeReclaimRetain, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound to claim with different UID.
+			// Check the volume gets Released.
+			"4-4 - volume bound to claim with different UID",
+			newVolumeArray("volume4-4", "10Gi", "uid4-4", "claim4-4", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-4", "10Gi", "uid4-4", "claim4-4", v1.VolumeReleased, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim4-4", "uid4-4-x", "10Gi", "volume4-4", v1.ClaimBound, nil, annBindCompleted),
+			newClaimArray("claim4-4", "uid4-4-x", "10Gi", "volume4-4", v1.ClaimBound, nil, annBindCompleted),
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound by controller to unbound claim.
+			// Check syncVolume does not do anything.
+			"4-5 - volume bound by controller to unbound claim",
+			newVolumeArray("volume4-5", "10Gi", "uid4-5", "claim4-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newVolumeArray("volume4-5", "10Gi", "uid4-5", "claim4-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim4-5", "uid4-5", "10Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim4-5", "uid4-5", "10Gi", "", v1.ClaimPending, nil),
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound by user to unbound claim.
+			// Check syncVolume does not do anything.
+			"4-5 - volume bound by user to bound claim",
+			newVolumeArray("volume4-5", "10Gi", "uid4-5", "claim4-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-5", "10Gi", "uid4-5", "claim4-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim4-5", "uid4-5", "10Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim4-5", "uid4-5", "10Gi", "", v1.ClaimPending, nil),
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound to bound claim.
+			// Check that the volume is marked as Bound.
+			"4-6 - volume bound by to bound claim",
+			newVolumeArray("volume4-6", "10Gi", "uid4-6", "claim4-6", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-6", "10Gi", "uid4-6", "claim4-6", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim4-6", "uid4-6", "10Gi", "volume4-6", v1.ClaimBound, nil),
+			newClaimArray("claim4-6", "uid4-6", "10Gi", "volume4-6", v1.ClaimBound, nil),
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound by controller to claim bound to
+			// another volume. Check that the volume is rolled back.
+			"4-7 - volume bound by controller to claim bound somewhere else",
+			newVolumeArray("volume4-7", "10Gi", "uid4-7", "claim4-7", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newVolumeArray("volume4-7", "10Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim4-7", "uid4-7", "10Gi", "volume4-7-x", v1.ClaimBound, nil),
+			newClaimArray("claim4-7", "uid4-7", "10Gi", "volume4-7-x", v1.ClaimBound, nil),
+			noevents, noerrors, testSyncVolume,
+		},
+		{
+			// syncVolume with volume bound by user to claim bound to
+			// another volume. Check that the volume is marked as Available
+			// and its UID is reset.
+			"4-8 - volume bound by user to claim bound somewhere else",
+			newVolumeArray("volume4-8", "10Gi", "uid4-8", "claim4-8", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume4-8", "10Gi", "", "claim4-8", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newClaimArray("claim4-8", "uid4-8", "10Gi", "volume4-8-x", v1.ClaimBound, nil),
+			newClaimArray("claim4-8", "uid4-8", "10Gi", "volume4-8-x", v1.ClaimBound, nil),
+			noevents, noerrors, testSyncVolume,
+		},
+
+		// PVC with class
+		{
+			// syncVolume binds a claim to requested class even if there is a
+			// smaller PV available
+			"13-1 - binding to class",
+			[]*v1.PersistentVolume{
+				newVolume("volume13-1-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume13-1-2", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume13-1-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+				newVolume("volume13-1-2", "10Gi", "uid13-1", "claim13-1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classGold, annBoundByController),
+			},
+			newClaimArray("claim13-1", "uid13-1", "1Gi", "", v1.ClaimPending, &classGold),
+			withExpectedCapacity("10Gi", newClaimArray("claim13-1", "uid13-1", "1Gi", "volume13-1-2", v1.ClaimBound, &classGold, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncVolume binds a claim without a class even if there is a
+			// smaller PV with a class available
+			"13-2 - binding without a class",
+			[]*v1.PersistentVolume{
+				newVolume("volume13-2-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+				newVolume("volume13-2-2", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume13-2-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+				newVolume("volume13-2-2", "10Gi", "uid13-2", "claim13-2", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			},
+			newClaimArray("claim13-2", "uid13-2", "1Gi", "", v1.ClaimPending, nil),
+			withExpectedCapacity("10Gi", newClaimArray("claim13-2", "uid13-2", "1Gi", "volume13-2-2", v1.ClaimBound, nil, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncVolume binds a claim with given class even if there is a
+			// smaller PV with different class available
+			"13-3 - binding to specific a class",
+			[]*v1.PersistentVolume{
+				newVolume("volume13-3-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classSilver),
+				newVolume("volume13-3-2", "10Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume13-3-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classSilver),
+				newVolume("volume13-3-2", "10Gi", "uid13-3", "claim13-3", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classGold, annBoundByController),
+			},
+			newClaimArray("claim13-3", "uid13-3", "1Gi", "", v1.ClaimPending, &classGold),
+			withExpectedCapacity("10Gi", newClaimArray("claim13-3", "uid13-3", "1Gi", "volume13-3-2", v1.ClaimBound, &classGold, annBoundByController, annBindCompleted)),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncVolume binds claim requesting class "" to claim to PV with
+			// class=""
+			"13-4 - empty class",
+			newVolumeArray("volume13-4", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume13-4", "1Gi", "uid13-4", "claim13-4", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim13-4", "uid13-4", "1Gi", "", v1.ClaimPending, &classEmpty),
+			newClaimArray("claim13-4", "uid13-4", "1Gi", "volume13-4", v1.ClaimBound, &classEmpty, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// syncVolume binds claim requesting class nil to claim to PV with
+			// class = ""
+			"13-5 - nil class",
+			newVolumeArray("volume13-5", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume13-5", "1Gi", "uid13-5", "claim13-5", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim13-5", "uid13-5", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim13-5", "uid13-5", "1Gi", "volume13-5", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+	}
+	runSyncTests(t, tests, []*storage.StorageClass{})
+}
+
+// Test multiple calls to syncClaim/syncVolume and periodic sync of all
+// volume/claims. The test follows this pattern:
+// 0. Load the controller with initial data.
+// 1. Call controllerTest.testCall() once as in TestSync()
+// 2. For all volumes/claims changed by previous syncVolume/syncClaim calls,
+//    call appropriate syncVolume/syncClaim (simulating "volume/claim changed"
+//    events). Go to 2. if these calls change anything.
+// 3. When all changes are processed and no new changes were made, call
+//    syncVolume/syncClaim on all volumes/claims (simulating "periodic sync").
+// 4. If some changes were done by step 3., go to 2. (simulation of
+//    "volume/claim updated" events, eventually performing step 3. again)
+// 5. When 3. does not do any changes, finish the tests and compare final set
+//    of volumes/claims with expected claims/volumes and report differences.
+// Some limit of calls in enforced to prevent endless loops.
+func TestMultiSync(t *testing.T) {
+	tests := []controllerTest{
+		// Test simple binding
+		{
+			// syncClaim binds to a matching unbound volume.
+			"10-1 - successful bind",
+			newVolumeArray("volume10-1", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume10-1", "1Gi", "uid10-1", "claim10-1", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim10-1", "uid10-1", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim10-1", "uid10-1", "1Gi", "volume10-1", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+		{
+			// Two controllers bound two PVs to single claim. Test one of them
+			// wins and the second rolls back.
+			"10-2 - bind PV race",
+			[]*v1.PersistentVolume{
+				newVolume("volume10-2-1", "1Gi", "uid10-2", "claim10-2", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+				newVolume("volume10-2-2", "1Gi", "uid10-2", "claim10-2", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume10-2-1", "1Gi", "uid10-2", "claim10-2", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+				newVolume("volume10-2-2", "1Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			},
+			newClaimArray("claim10-2", "uid10-2", "1Gi", "volume10-2-1", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim10-2", "uid10-2", "1Gi", "volume10-2-1", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors, testSyncClaim,
+		},
+	}
+
+	runMultisyncTests(t, tests, []*storage.StorageClass{}, "")
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/delete_test.go

@@ -0,0 +1,228 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"errors"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+)
+
+// Test single call to syncVolume, expecting recycling to happen.
+// 1. Fill in the controller with initial data
+// 2. Call the syncVolume *once*.
+// 3. Compare resulting volumes with expected volumes.
+func TestDeleteSync(t *testing.T) {
+	tests := []controllerTest{
+		{
+			// delete volume bound by controller
+			"8-1 - successful delete",
+			newVolumeArray("volume8-1", "1Gi", "uid8-1", "claim8-1", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annBoundByController),
+			novolumes,
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			// Inject deleter into the controller and call syncVolume. The
+			// deleter simulates one delete() call that succeeds.
+			wrapTestWithReclaimCalls(operationDelete, []error{nil}, testSyncVolume),
+		},
+		{
+			// delete volume bound by user
+			"8-2 - successful delete with prebound volume",
+			newVolumeArray("volume8-2", "1Gi", "uid8-2", "claim8-2", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			novolumes,
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			// Inject deleter into the controller and call syncVolume. The
+			// deleter simulates one delete() call that succeeds.
+			wrapTestWithReclaimCalls(operationDelete, []error{nil}, testSyncVolume),
+		},
+		{
+			// delete failure - plugin not found
+			"8-3 - plugin not found",
+			newVolumeArray("volume8-3", "1Gi", "uid8-3", "claim8-3", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			withMessage("Error getting deleter volume plugin for volume \"volume8-3\": no volume plugin matched", newVolumeArray("volume8-3", "1Gi", "uid8-3", "claim8-3", v1.VolumeFailed, v1.PersistentVolumeReclaimDelete, classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedDelete"}, noerrors, testSyncVolume,
+		},
+		{
+			// delete failure - newDeleter returns error
+			"8-4 - newDeleter returns error",
+			newVolumeArray("volume8-4", "1Gi", "uid8-4", "claim8-4", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			withMessage("Failed to create deleter for volume \"volume8-4\": Mock plugin error: no deleteCalls configured", newVolumeArray("volume8-4", "1Gi", "uid8-4", "claim8-4", v1.VolumeFailed, v1.PersistentVolumeReclaimDelete, classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedDelete"}, noerrors,
+			wrapTestWithReclaimCalls(operationDelete, []error{}, testSyncVolume),
+		},
+		{
+			// delete failure - delete() returns error
+			"8-5 - delete returns error",
+			newVolumeArray("volume8-5", "1Gi", "uid8-5", "claim8-5", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			withMessage("Mock delete error", newVolumeArray("volume8-5", "1Gi", "uid8-5", "claim8-5", v1.VolumeFailed, v1.PersistentVolumeReclaimDelete, classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedDelete"}, noerrors,
+			wrapTestWithReclaimCalls(operationDelete, []error{errors.New("Mock delete error")}, testSyncVolume),
+		},
+		{
+			// delete success(?) - volume is deleted before doDelete() starts
+			"8-6 - volume is deleted before deleting",
+			newVolumeArray("volume8-6", "1Gi", "uid8-6", "claim8-6", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			novolumes,
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			wrapTestWithInjectedOperation(wrapTestWithReclaimCalls(operationDelete, []error{}, testSyncVolume), func(ctrl *PersistentVolumeController, reactor *volumeReactor) {
+				// Delete the volume before delete operation starts
+				reactor.lock.Lock()
+				delete(reactor.volumes, "volume8-6")
+				reactor.lock.Unlock()
+			}),
+		},
+		{
+			// delete success(?) - volume is bound just at the time doDelete()
+			// starts. This simulates "volume no longer needs recycling,
+			// skipping".
+			"8-7 - volume is bound before deleting",
+			newVolumeArray("volume8-7", "1Gi", "uid8-7", "claim8-7", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annBoundByController),
+			newVolumeArray("volume8-7", "1Gi", "uid8-7", "claim8-7", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annBoundByController),
+			noclaims,
+			newClaimArray("claim8-7", "uid8-7", "10Gi", "volume8-7", v1.ClaimBound, nil),
+			noevents, noerrors,
+			wrapTestWithInjectedOperation(wrapTestWithReclaimCalls(operationDelete, []error{}, testSyncVolume), func(ctrl *PersistentVolumeController, reactor *volumeReactor) {
+				reactor.lock.Lock()
+				defer reactor.lock.Unlock()
+				// Bind the volume to resurrected claim (this should never
+				// happen)
+				claim := newClaim("claim8-7", "uid8-7", "10Gi", "volume8-7", v1.ClaimBound, nil)
+				reactor.claims[claim.Name] = claim
+				ctrl.claims.Add(claim)
+				volume := reactor.volumes["volume8-7"]
+				volume.Status.Phase = v1.VolumeBound
+			}),
+		},
+		{
+			// delete success - volume bound by user is deleted, while a new
+			// claim is created with another UID.
+			"8-9 - prebound volume is deleted while the claim exists",
+			newVolumeArray("volume8-9", "1Gi", "uid8-9", "claim8-9", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			novolumes,
+			newClaimArray("claim8-9", "uid8-9-x", "10Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim8-9", "uid8-9-x", "10Gi", "", v1.ClaimPending, nil),
+			noevents, noerrors,
+			// Inject deleter into the controller and call syncVolume. The
+			// deleter simulates one delete() call that succeeds.
+			wrapTestWithReclaimCalls(operationDelete, []error{nil}, testSyncVolume),
+		},
+		{
+			// PV requires external deleter
+			"8-10 - external deleter",
+			newVolumeArray("volume8-10", "1Gi", "uid10-1", "claim10-1", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annBoundByController),
+			newVolumeArray("volume8-10", "1Gi", "uid10-1", "claim10-1", v1.VolumeReleased, v1.PersistentVolumeReclaimDelete, classEmpty, annBoundByController),
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			func(ctrl *PersistentVolumeController, reactor *volumeReactor, test controllerTest) error {
+				// Inject external deleter annotation
+				test.initialVolumes[0].Annotations[annDynamicallyProvisioned] = "external.io/test"
+				test.expectedVolumes[0].Annotations[annDynamicallyProvisioned] = "external.io/test"
+				return testSyncVolume(ctrl, reactor, test)
+			},
+		},
+		{
+			// delete success - two PVs are provisioned for a single claim.
+			// One of the PVs is deleted.
+			"8-11 - two PVs provisioned for a single claim",
+			[]*v1.PersistentVolume{
+				newVolume("volume8-11-1", "1Gi", "uid8-11", "claim8-11", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+				newVolume("volume8-11-2", "1Gi", "uid8-11", "claim8-11", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume8-11-2", "1Gi", "uid8-11", "claim8-11", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+			},
+			// the claim is bound to volume8-11-2 -> volume8-11-1 has lost the race and will be deleted
+			newClaimArray("claim8-11", "uid8-11", "10Gi", "volume8-11-2", v1.ClaimBound, nil),
+			newClaimArray("claim8-11", "uid8-11", "10Gi", "volume8-11-2", v1.ClaimBound, nil),
+			noevents, noerrors,
+			// Inject deleter into the controller and call syncVolume. The
+			// deleter simulates one delete() call that succeeds.
+			wrapTestWithReclaimCalls(operationDelete, []error{nil}, testSyncVolume),
+		},
+		{
+			// delete success - two PVs are externally provisioned for a single
+			// claim. One of the PVs is marked as Released to be deleted by the
+			// external provisioner.
+			"8-12 - two PVs externally provisioned for a single claim",
+			[]*v1.PersistentVolume{
+				newVolume("volume8-12-1", "1Gi", "uid8-12", "claim8-12", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+				newVolume("volume8-12-2", "1Gi", "uid8-12", "claim8-12", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+			},
+			[]*v1.PersistentVolume{
+				newVolume("volume8-12-1", "1Gi", "uid8-12", "claim8-12", v1.VolumeReleased, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+				newVolume("volume8-12-2", "1Gi", "uid8-12", "claim8-12", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty, annDynamicallyProvisioned),
+			},
+			// the claim is bound to volume8-12-2 -> volume8-12-1 has lost the race and will be "Released"
+			newClaimArray("claim8-12", "uid8-12", "10Gi", "volume8-12-2", v1.ClaimBound, nil),
+			newClaimArray("claim8-12", "uid8-12", "10Gi", "volume8-12-2", v1.ClaimBound, nil),
+			noevents, noerrors,
+			func(ctrl *PersistentVolumeController, reactor *volumeReactor, test controllerTest) error {
+				// Inject external deleter annotation
+				test.initialVolumes[0].Annotations[annDynamicallyProvisioned] = "external.io/test"
+				test.expectedVolumes[0].Annotations[annDynamicallyProvisioned] = "external.io/test"
+				return testSyncVolume(ctrl, reactor, test)
+			},
+		},
+	}
+	runSyncTests(t, tests, []*storage.StorageClass{})
+}
+
+// Test multiple calls to syncClaim/syncVolume and periodic sync of all
+// volume/claims. The test follows this pattern:
+// 0. Load the controller with initial data.
+// 1. Call controllerTest.testCall() once as in TestSync()
+// 2. For all volumes/claims changed by previous syncVolume/syncClaim calls,
+//    call appropriate syncVolume/syncClaim (simulating "volume/claim changed"
+//    events). Go to 2. if these calls change anything.
+// 3. When all changes are processed and no new changes were made, call
+//    syncVolume/syncClaim on all volumes/claims (simulating "periodic sync").
+// 4. If some changes were done by step 3., go to 2. (simulation of
+//    "volume/claim updated" events, eventually performing step 3. again)
+// 5. When 3. does not do any changes, finish the tests and compare final set
+//    of volumes/claims with expected claims/volumes and report differences.
+// Some limit of calls in enforced to prevent endless loops.
+func TestDeleteMultiSync(t *testing.T) {
+	tests := []controllerTest{
+		{
+			// delete failure - delete returns error. The controller should
+			// try again.
+			"9-1 - delete returns error",
+			newVolumeArray("volume9-1", "1Gi", "uid9-1", "claim9-1", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classEmpty),
+			novolumes,
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedDelete"}, noerrors,
+			wrapTestWithReclaimCalls(operationDelete, []error{errors.New("Mock delete error"), nil}, testSyncVolume),
+		},
+	}
+
+	runMultisyncTests(t, tests, []*storage.StorageClass{}, "")
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/index.go

@@ -0,0 +1,243 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"fmt"
+	"sort"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+	v1helper "k8s.io/kubernetes/pkg/api/v1/helper"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+// persistentVolumeOrderedIndex is a cache.Store that keeps persistent volumes
+// indexed by AccessModes and ordered by storage capacity.
+type persistentVolumeOrderedIndex struct {
+	store cache.Indexer
+}
+
+func newPersistentVolumeOrderedIndex() persistentVolumeOrderedIndex {
+	return persistentVolumeOrderedIndex{cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"accessmodes": accessModesIndexFunc})}
+}
+
+// accessModesIndexFunc is an indexing function that returns a persistent
+// volume's AccessModes as a string
+func accessModesIndexFunc(obj interface{}) ([]string, error) {
+	if pv, ok := obj.(*v1.PersistentVolume); ok {
+		modes := v1helper.GetAccessModesAsString(pv.Spec.AccessModes)
+		return []string{modes}, nil
+	}
+	return []string{""}, fmt.Errorf("object is not a persistent volume: %v", obj)
+}
+
+// listByAccessModes returns all volumes with the given set of
+// AccessModeTypes. The list is unsorted!
+func (pvIndex *persistentVolumeOrderedIndex) listByAccessModes(modes []v1.PersistentVolumeAccessMode) ([]*v1.PersistentVolume, error) {
+	pv := &v1.PersistentVolume{
+		Spec: v1.PersistentVolumeSpec{
+			AccessModes: modes,
+		},
+	}
+
+	objs, err := pvIndex.store.Index("accessmodes", pv)
+	if err != nil {
+		return nil, err
+	}
+
+	volumes := make([]*v1.PersistentVolume, len(objs))
+	for i, obj := range objs {
+		volumes[i] = obj.(*v1.PersistentVolume)
+	}
+
+	return volumes, nil
+}
+
+// find returns the nearest PV from the ordered list or nil if a match is not found
+func (pvIndex *persistentVolumeOrderedIndex) findByClaim(claim *v1.PersistentVolumeClaim) (*v1.PersistentVolume, error) {
+	// PVs are indexed by their access modes to allow easier searching.  Each
+	// index is the string representation of a set of access modes. There is a
+	// finite number of possible sets and PVs will only be indexed in one of
+	// them (whichever index matches the PV's modes).
+	//
+	// A request for resources will always specify its desired access modes.
+	// Any matching PV must have at least that number of access modes, but it
+	// can have more.  For example, a user asks for ReadWriteOnce but a GCEPD
+	// is available, which is ReadWriteOnce+ReadOnlyMany.
+	//
+	// Searches are performed against a set of access modes, so we can attempt
+	// not only the exact matching modes but also potential matches (the GCEPD
+	// example above).
+	allPossibleModes := pvIndex.allPossibleMatchingAccessModes(claim.Spec.AccessModes)
+
+	var smallestVolume *v1.PersistentVolume
+	var smallestVolumeQty resource.Quantity
+	requestedQty := claim.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
+	requestedClass := v1helper.GetPersistentVolumeClaimClass(claim)
+
+	var selector labels.Selector
+	if claim.Spec.Selector != nil {
+		internalSelector, err := metav1.LabelSelectorAsSelector(claim.Spec.Selector)
+		if err != nil {
+			// should be unreachable code due to validation
+			return nil, fmt.Errorf("error creating internal label selector for claim: %v: %v", claimToClaimKey(claim), err)
+		}
+		selector = internalSelector
+	}
+
+	for _, modes := range allPossibleModes {
+		volumes, err := pvIndex.listByAccessModes(modes)
+		if err != nil {
+			return nil, err
+		}
+
+		// Go through all available volumes with two goals:
+		// - find a volume that is either pre-bound by user or dynamically
+		//   provisioned for this claim. Because of this we need to loop through
+		//   all volumes.
+		// - find the smallest matching one if there is no volume pre-bound to
+		//   the claim.
+		for _, volume := range volumes {
+			if isVolumeBoundToClaim(volume, claim) {
+				// this claim and volume are pre-bound; return
+				// the volume if the size request is satisfied,
+				// otherwise continue searching for a match
+				volumeQty := volume.Spec.Capacity[v1.ResourceStorage]
+				if volumeQty.Cmp(requestedQty) < 0 {
+					continue
+				}
+				return volume, nil
+			}
+
+			// filter out:
+			// - volumes bound to another claim
+			// - volumes whose labels don't match the claim's selector, if specified
+			// - volumes in Class that is not requested
+			if volume.Spec.ClaimRef != nil {
+				continue
+			} else if selector != nil && !selector.Matches(labels.Set(volume.Labels)) {
+				continue
+			}
+			if v1helper.GetPersistentVolumeClass(volume) != requestedClass {
+				continue
+			}
+
+			volumeQty := volume.Spec.Capacity[v1.ResourceStorage]
+			if volumeQty.Cmp(requestedQty) >= 0 {
+				if smallestVolume == nil || smallestVolumeQty.Cmp(volumeQty) > 0 {
+					smallestVolume = volume
+					smallestVolumeQty = volumeQty
+				}
+			}
+		}
+
+		if smallestVolume != nil {
+			// Found a matching volume
+			return smallestVolume, nil
+		}
+	}
+	return nil, nil
+}
+
+// findBestMatchForClaim is a convenience method that finds a volume by the claim's AccessModes and requests for Storage
+func (pvIndex *persistentVolumeOrderedIndex) findBestMatchForClaim(claim *v1.PersistentVolumeClaim) (*v1.PersistentVolume, error) {
+	return pvIndex.findByClaim(claim)
+}
+
+// allPossibleMatchingAccessModes returns an array of AccessMode arrays that
+// can satisfy a user's requested modes.
+//
+// see comments in the Find func above regarding indexing.
+//
+// allPossibleMatchingAccessModes gets all stringified accessmodes from the
+// index and returns all those that contain at least all of the requested
+// mode.
+//
+// For example, assume the index contains 2 types of PVs where the stringified
+// accessmodes are:
+//
+// "RWO,ROX" -- some number of GCEPDs
+// "RWO,ROX,RWX" -- some number of NFS volumes
+//
+// A request for RWO could be satisfied by both sets of indexed volumes, so
+// allPossibleMatchingAccessModes returns:
+//
+// [][]v1.PersistentVolumeAccessMode {
+//      []v1.PersistentVolumeAccessMode {
+//			v1.ReadWriteOnce, v1.ReadOnlyMany,
+//		},
+//      []v1.PersistentVolumeAccessMode {
+//			v1.ReadWriteOnce, v1.ReadOnlyMany, v1.ReadWriteMany,
+//		},
+// }
+//
+// A request for RWX can be satisfied by only one set of indexed volumes, so
+// the return is:
+//
+// [][]v1.PersistentVolumeAccessMode {
+//      []v1.PersistentVolumeAccessMode {
+//			v1.ReadWriteOnce, v1.ReadOnlyMany, v1.ReadWriteMany,
+//		},
+// }
+//
+// This func returns modes with ascending levels of modes to give the user
+// what is closest to what they actually asked for.
+func (pvIndex *persistentVolumeOrderedIndex) allPossibleMatchingAccessModes(requestedModes []v1.PersistentVolumeAccessMode) [][]v1.PersistentVolumeAccessMode {
+	matchedModes := [][]v1.PersistentVolumeAccessMode{}
+	keys := pvIndex.store.ListIndexFuncValues("accessmodes")
+	for _, key := range keys {
+		indexedModes := v1helper.GetAccessModesFromString(key)
+		if volume.AccessModesContainedInAll(indexedModes, requestedModes) {
+			matchedModes = append(matchedModes, indexedModes)
+		}
+	}
+
+	// sort by the number of modes in each array with the fewest number of
+	// modes coming first. this allows searching for volumes by the minimum
+	// number of modes required of the possible matches.
+	sort.Sort(byAccessModes{matchedModes})
+	return matchedModes
+}
+
+// byAccessModes is used to order access modes by size, with the fewest modes first
+type byAccessModes struct {
+	modes [][]v1.PersistentVolumeAccessMode
+}
+
+func (c byAccessModes) Less(i, j int) bool {
+	return len(c.modes[i]) < len(c.modes[j])
+}
+
+func (c byAccessModes) Swap(i, j int) {
+	c.modes[i], c.modes[j] = c.modes[j], c.modes[i]
+}
+
+func (c byAccessModes) Len() int {
+	return len(c.modes)
+}
+
+func claimToClaimKey(claim *v1.PersistentVolumeClaim) string {
+	return fmt.Sprintf("%s/%s", claim.Namespace, claim.Name)
+}
+
+func claimrefToClaimKey(claimref *v1.ObjectReference) string {
+	return fmt.Sprintf("%s/%s", claimref.Namespace, claimref.Name)
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/index_test.go

@@ -0,0 +1,763 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"sort"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/scheme"
+	ref "k8s.io/client-go/tools/reference"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+func makePVC(size string, modfn func(*v1.PersistentVolumeClaim)) *v1.PersistentVolumeClaim {
+	pvc := v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "claim01",
+			Namespace: "myns",
+		},
+		Spec: v1.PersistentVolumeClaimSpec{
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany, v1.ReadWriteOnce},
+			Resources: v1.ResourceRequirements{
+				Requests: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse(size),
+				},
+			},
+		},
+	}
+	if modfn != nil {
+		modfn(&pvc)
+	}
+	return &pvc
+}
+
+func TestMatchVolume(t *testing.T) {
+	volList := newPersistentVolumeOrderedIndex()
+	for _, pv := range createTestVolumes() {
+		volList.store.Add(pv)
+	}
+
+	scenarios := map[string]struct {
+		expectedMatch string
+		claim         *v1.PersistentVolumeClaim
+	}{
+		"successful-match-gce-10": {
+			expectedMatch: "gce-pd-10",
+			claim:         makePVC("8G", nil),
+		},
+		"successful-match-nfs-5": {
+			expectedMatch: "nfs-5",
+			claim: makePVC("5G", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany, v1.ReadWriteOnce, v1.ReadWriteMany}
+			}),
+		},
+		"successful-skip-1g-bound-volume": {
+			expectedMatch: "gce-pd-5",
+			claim:         makePVC("1G", nil),
+		},
+		"successful-no-match": {
+			expectedMatch: "",
+			claim:         makePVC("999G", nil),
+		},
+		"successful-no-match-due-to-label": {
+			expectedMatch: "",
+			claim: makePVC("999G", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.Selector = &metav1.LabelSelector{
+					MatchLabels: map[string]string{
+						"should-not-exist": "true",
+					},
+				}
+			}),
+		},
+		"successful-no-match-due-to-size-constraint-with-label-selector": {
+			expectedMatch: "",
+			claim: makePVC("20000G", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.Selector = &metav1.LabelSelector{
+					MatchLabels: map[string]string{
+						"should-exist": "true",
+					},
+				}
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany, v1.ReadWriteOnce}
+			}),
+		},
+		"successful-match-due-with-constraint-and-label-selector": {
+			expectedMatch: "gce-pd-2",
+			claim: makePVC("20000G", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.Selector = &metav1.LabelSelector{
+					MatchLabels: map[string]string{
+						"should-exist": "true",
+					},
+				}
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+			}),
+		},
+		"successful-match-with-class": {
+			expectedMatch: "gce-pd-silver1",
+			claim: makePVC("1G", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.Selector = &metav1.LabelSelector{
+					MatchLabels: map[string]string{
+						"should-exist": "true",
+					},
+				}
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+				pvc.Spec.StorageClassName = &classSilver
+			}),
+		},
+		"successful-match-with-class-and-labels": {
+			expectedMatch: "gce-pd-silver2",
+			claim: makePVC("1G", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+				pvc.Spec.StorageClassName = &classSilver
+			}),
+		},
+		"successful-match-very-large": {
+			expectedMatch: "local-pd-very-large",
+			// we keep the pvc size less than int64 so that in case the pv overflows
+			// the pvc does not overflow equally and give us false matching signals.
+			claim: makePVC("1E", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+				pvc.Spec.StorageClassName = &classLarge
+			}),
+		},
+		"successful-match-exact-extremely-large": {
+			expectedMatch: "local-pd-extremely-large",
+			claim: makePVC("800E", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+				pvc.Spec.StorageClassName = &classLarge
+			}),
+		},
+		"successful-no-match-way-too-large": {
+			expectedMatch: "",
+			claim: makePVC("950E", func(pvc *v1.PersistentVolumeClaim) {
+				pvc.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+				pvc.Spec.StorageClassName = &classLarge
+			}),
+		},
+	}
+
+	for name, scenario := range scenarios {
+		volume, err := volList.findBestMatchForClaim(scenario.claim)
+		if err != nil {
+			t.Errorf("Unexpected error matching volume by claim: %v", err)
+		}
+		if len(scenario.expectedMatch) != 0 && volume == nil {
+			t.Errorf("Expected match but received nil volume for scenario: %s", name)
+		}
+		if len(scenario.expectedMatch) != 0 && volume != nil && string(volume.UID) != scenario.expectedMatch {
+			t.Errorf("Expected %s but got volume %s in scenario %s", scenario.expectedMatch, volume.UID, name)
+		}
+		if len(scenario.expectedMatch) == 0 && volume != nil {
+			t.Errorf("Unexpected match for scenario: %s, matched with %s instead", name, volume.UID)
+		}
+	}
+}
+
+func TestMatchingWithBoundVolumes(t *testing.T) {
+	volumeIndex := newPersistentVolumeOrderedIndex()
+	// two similar volumes, one is bound
+	pv1 := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			UID:  "gce-pd-1",
+			Name: "gce001",
+		},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity: v1.ResourceList{
+				v1.ResourceName(v1.ResourceStorage): resource.MustParse("1G"),
+			},
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany},
+			// this one we're pretending is already bound
+			ClaimRef: &v1.ObjectReference{UID: "abc123"},
+		},
+	}
+
+	pv2 := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			UID:  "gce-pd-2",
+			Name: "gce002",
+		},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity: v1.ResourceList{
+				v1.ResourceName(v1.ResourceStorage): resource.MustParse("1G"),
+			},
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany},
+		},
+	}
+
+	volumeIndex.store.Add(pv1)
+	volumeIndex.store.Add(pv2)
+
+	claim := &v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "claim01",
+			Namespace: "myns",
+		},
+		Spec: v1.PersistentVolumeClaimSpec{
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany, v1.ReadWriteOnce},
+			Resources: v1.ResourceRequirements{
+				Requests: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("1G"),
+				},
+			},
+		},
+	}
+
+	volume, err := volumeIndex.findBestMatchForClaim(claim)
+	if err != nil {
+		t.Fatalf("Unexpected error matching volume by claim: %v", err)
+	}
+	if volume == nil {
+		t.Fatalf("Unexpected nil volume.  Expected %s", pv2.Name)
+	}
+	if pv2.Name != volume.Name {
+		t.Errorf("Expected %s but got volume %s instead", pv2.Name, volume.Name)
+	}
+}
+
+func TestListByAccessModes(t *testing.T) {
+	volList := newPersistentVolumeOrderedIndex()
+	for _, pv := range createTestVolumes() {
+		volList.store.Add(pv)
+	}
+
+	volumes, err := volList.listByAccessModes([]v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany})
+	if err != nil {
+		t.Error("Unexpected error retrieving volumes by access modes:", err)
+	}
+	sort.Sort(byCapacity{volumes})
+
+	for i, expected := range []string{"gce-pd-1", "gce-pd-5", "gce-pd-10"} {
+		if string(volumes[i].UID) != expected {
+			t.Errorf("Incorrect ordering of persistent volumes.  Expected %s but got %s", expected, volumes[i].UID)
+		}
+	}
+
+	volumes, err = volList.listByAccessModes([]v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany, v1.ReadWriteMany})
+	if err != nil {
+		t.Error("Unexpected error retrieving volumes by access modes:", err)
+	}
+	sort.Sort(byCapacity{volumes})
+
+	for i, expected := range []string{"nfs-1", "nfs-5", "nfs-10", "local-pd-very-large", "local-pd-extremely-large"} {
+		if string(volumes[i].UID) != expected {
+			t.Errorf("Incorrect ordering of persistent volumes.  Expected %s but got %s", expected, volumes[i].UID)
+		}
+	}
+}
+
+func TestAllPossibleAccessModes(t *testing.T) {
+	index := newPersistentVolumeOrderedIndex()
+	for _, pv := range createTestVolumes() {
+		index.store.Add(pv)
+	}
+
+	// the mock PVs creates contain 2 types of accessmodes:   RWO+ROX and RWO+ROW+RWX
+	possibleModes := index.allPossibleMatchingAccessModes([]v1.PersistentVolumeAccessMode{v1.ReadWriteOnce})
+	if len(possibleModes) != 3 {
+		t.Errorf("Expected 3 arrays of modes that match RWO, but got %v", len(possibleModes))
+	}
+	for _, m := range possibleModes {
+		if !volume.AccessModesContains(m, v1.ReadWriteOnce) {
+			t.Errorf("AccessModes does not contain %s", v1.ReadWriteOnce)
+		}
+	}
+
+	possibleModes = index.allPossibleMatchingAccessModes([]v1.PersistentVolumeAccessMode{v1.ReadWriteMany})
+	if len(possibleModes) != 1 {
+		t.Errorf("Expected 1 array of modes that match RWX, but got %v", len(possibleModes))
+	}
+	if !volume.AccessModesContains(possibleModes[0], v1.ReadWriteMany) {
+		t.Errorf("AccessModes does not contain %s", v1.ReadWriteOnce)
+	}
+
+}
+
+func TestFindingVolumeWithDifferentAccessModes(t *testing.T) {
+	gce := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{UID: "001", Name: "gce"},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity:               v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse("10G")},
+			PersistentVolumeSource: v1.PersistentVolumeSource{GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{}},
+			AccessModes: []v1.PersistentVolumeAccessMode{
+				v1.ReadWriteOnce,
+				v1.ReadOnlyMany,
+			},
+		},
+	}
+
+	ebs := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{UID: "002", Name: "ebs"},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity:               v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse("10G")},
+			PersistentVolumeSource: v1.PersistentVolumeSource{AWSElasticBlockStore: &v1.AWSElasticBlockStoreVolumeSource{}},
+			AccessModes: []v1.PersistentVolumeAccessMode{
+				v1.ReadWriteOnce,
+			},
+		},
+	}
+
+	nfs := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{UID: "003", Name: "nfs"},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity:               v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse("10G")},
+			PersistentVolumeSource: v1.PersistentVolumeSource{NFS: &v1.NFSVolumeSource{}},
+			AccessModes: []v1.PersistentVolumeAccessMode{
+				v1.ReadWriteOnce,
+				v1.ReadOnlyMany,
+				v1.ReadWriteMany,
+			},
+		},
+	}
+
+	claim := &v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "claim01",
+			Namespace: "myns",
+		},
+		Spec: v1.PersistentVolumeClaimSpec{
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+			Resources:   v1.ResourceRequirements{Requests: v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse("1G")}},
+		},
+	}
+
+	index := newPersistentVolumeOrderedIndex()
+	index.store.Add(gce)
+	index.store.Add(ebs)
+	index.store.Add(nfs)
+
+	volume, _ := index.findBestMatchForClaim(claim)
+	if volume.Name != ebs.Name {
+		t.Errorf("Expected %s but got volume %s instead", ebs.Name, volume.Name)
+	}
+
+	claim.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != gce.Name {
+		t.Errorf("Expected %s but got volume %s instead", gce.Name, volume.Name)
+	}
+
+	// order of the requested modes should not matter
+	claim.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteMany, v1.ReadWriteOnce, v1.ReadOnlyMany}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != nfs.Name {
+		t.Errorf("Expected %s but got volume %s instead", nfs.Name, volume.Name)
+	}
+
+	// fewer modes requested should still match
+	claim.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteMany}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != nfs.Name {
+		t.Errorf("Expected %s but got volume %s instead", nfs.Name, volume.Name)
+	}
+
+	// pretend the exact match is bound.  should get the next level up of modes.
+	ebs.Spec.ClaimRef = &v1.ObjectReference{}
+	claim.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != gce.Name {
+		t.Errorf("Expected %s but got volume %s instead", gce.Name, volume.Name)
+	}
+
+	// continue up the levels of modes.
+	gce.Spec.ClaimRef = &v1.ObjectReference{}
+	claim.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != nfs.Name {
+		t.Errorf("Expected %s but got volume %s instead", nfs.Name, volume.Name)
+	}
+
+	// partial mode request
+	gce.Spec.ClaimRef = nil
+	claim.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != gce.Name {
+		t.Errorf("Expected %s but got volume %s instead", gce.Name, volume.Name)
+	}
+}
+
+func createTestVolumes() []*v1.PersistentVolume {
+	// these volumes are deliberately out-of-order to test indexing and sorting
+	return []*v1.PersistentVolume{
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-10",
+				Name: "gce003",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("10G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-20",
+				Name: "gce004",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("20G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+				},
+				// this one we're pretending is already bound
+				ClaimRef: &v1.ObjectReference{UID: "def456"},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "nfs-5",
+				Name: "nfs002",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("5G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					Glusterfs: &v1.GlusterfsVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+					v1.ReadWriteMany,
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-1",
+				Name: "gce001",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("1G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+				},
+				// this one we're pretending is already bound
+				ClaimRef: &v1.ObjectReference{UID: "abc123"},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "nfs-10",
+				Name: "nfs003",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("10G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					Glusterfs: &v1.GlusterfsVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+					v1.ReadWriteMany,
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-5",
+				Name: "gce002",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("5G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "nfs-1",
+				Name: "nfs001",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("1G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					Glusterfs: &v1.GlusterfsVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+					v1.ReadWriteMany,
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-2",
+				Name: "gce0022",
+				Labels: map[string]string{
+					"should-exist": "true",
+				},
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("20000G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+				},
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-silver1",
+				Name: "gce0023",
+				Labels: map[string]string{
+					"should-exist": "true",
+				},
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("10000G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+				},
+				StorageClassName: classSilver,
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-silver2",
+				Name: "gce0024",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("100G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+				},
+				StorageClassName: classSilver,
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "gce-pd-gold",
+				Name: "gce0025",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("50G"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					GCEPersistentDisk: &v1.GCEPersistentDiskVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+				},
+				StorageClassName: classGold,
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "local-pd-very-large",
+				Name: "local001",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("200E"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					Local: &v1.LocalVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+					v1.ReadWriteMany,
+				},
+				StorageClassName: classLarge,
+			},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				UID:  "local-pd-extremely-large",
+				Name: "local002",
+			},
+			Spec: v1.PersistentVolumeSpec{
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse("800E"),
+				},
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					Local: &v1.LocalVolumeSource{},
+				},
+				AccessModes: []v1.PersistentVolumeAccessMode{
+					v1.ReadWriteOnce,
+					v1.ReadOnlyMany,
+					v1.ReadWriteMany,
+				},
+				StorageClassName: classLarge,
+			},
+		},
+	}
+}
+
+func testVolume(name, size string) *v1.PersistentVolume {
+	return &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:        name,
+			Annotations: map[string]string{},
+		},
+		Spec: v1.PersistentVolumeSpec{
+			Capacity:               v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse(size)},
+			PersistentVolumeSource: v1.PersistentVolumeSource{HostPath: &v1.HostPathVolumeSource{}},
+			AccessModes:            []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+		},
+	}
+}
+
+func TestFindingPreboundVolumes(t *testing.T) {
+	claim := &v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "claim01",
+			Namespace: "myns",
+			SelfLink:  testapi.Default.SelfLink("pvc", ""),
+		},
+		Spec: v1.PersistentVolumeClaimSpec{
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+			Resources:   v1.ResourceRequirements{Requests: v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse("1Gi")}},
+		},
+	}
+	claimRef, err := ref.GetReference(scheme.Scheme, claim)
+	if err != nil {
+		t.Errorf("error getting claimRef: %v", err)
+	}
+
+	pv1 := testVolume("pv1", "1Gi")
+	pv5 := testVolume("pv5", "5Gi")
+	pv8 := testVolume("pv8", "8Gi")
+	pvBadSize := testVolume("pvBadSize", "1Mi")
+	pvBadMode := testVolume("pvBadMode", "1Gi")
+	pvBadMode.Spec.AccessModes = []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany}
+
+	index := newPersistentVolumeOrderedIndex()
+	index.store.Add(pv1)
+	index.store.Add(pv5)
+	index.store.Add(pv8)
+	index.store.Add(pvBadSize)
+	index.store.Add(pvBadMode)
+
+	// expected exact match on size
+	volume, _ := index.findBestMatchForClaim(claim)
+	if volume.Name != pv1.Name {
+		t.Errorf("Expected %s but got volume %s instead", pv1.Name, volume.Name)
+	}
+
+	// pretend the exact match is pre-bound.  should get the next size up.
+	pv1.Spec.ClaimRef = &v1.ObjectReference{Name: "foo", Namespace: "bar"}
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != pv5.Name {
+		t.Errorf("Expected %s but got volume %s instead", pv5.Name, volume.Name)
+	}
+
+	// pretend the exact match is available but the largest volume is pre-bound to the claim.
+	pv1.Spec.ClaimRef = nil
+	pv8.Spec.ClaimRef = claimRef
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != pv8.Name {
+		t.Errorf("Expected %s but got volume %s instead", pv8.Name, volume.Name)
+	}
+
+	// pretend the volume with too small a size is pre-bound to the claim. should get the exact match.
+	pv8.Spec.ClaimRef = nil
+	pvBadSize.Spec.ClaimRef = claimRef
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != pv1.Name {
+		t.Errorf("Expected %s but got volume %s instead", pv1.Name, volume.Name)
+	}
+
+	// pretend the volume without the right access mode is pre-bound to the claim. should get the exact match.
+	pvBadSize.Spec.ClaimRef = nil
+	pvBadMode.Spec.ClaimRef = claimRef
+	volume, _ = index.findBestMatchForClaim(claim)
+	if volume.Name != pv1.Name {
+		t.Errorf("Expected %s but got volume %s instead", pv1.Name, volume.Name)
+	}
+}
+
+// byCapacity is used to order volumes by ascending storage size
+type byCapacity struct {
+	volumes []*v1.PersistentVolume
+}
+
+func (c byCapacity) Less(i, j int) bool {
+	return matchStorageCapacity(c.volumes[i], c.volumes[j])
+}
+
+func (c byCapacity) Swap(i, j int) {
+	c.volumes[i], c.volumes[j] = c.volumes[j], c.volumes[i]
+}
+
+func (c byCapacity) Len() int {
+	return len(c.volumes)
+}
+
+// matchStorageCapacity is a matchPredicate used to sort and find volumes
+func matchStorageCapacity(pvA, pvB *v1.PersistentVolume) bool {
+	aQty := pvA.Spec.Capacity[v1.ResourceStorage]
+	bQty := pvB.Spec.Capacity[v1.ResourceStorage]
+	return aQty.Cmp(bQty) <= 0
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/options/BUILD

@@ -0,0 +1,25 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["options.go"],
+    deps = ["//vendor/github.com/spf13/pflag:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/options/options.go

@@ -0,0 +1,91 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 options
+
+import (
+	"time"
+
+	"github.com/spf13/pflag"
+)
+
+// VolumeConfigFlags is used to bind CLI flags to variables.  This top-level struct contains *all* enumerated
+// CLI flags meant to configure all volume plugins.  From this config, the binary will create many instances
+// of volume.VolumeConfig which are then passed to the appropriate plugin. The ControllerManager binary is the only
+// part of the code which knows what plugins are supported and which CLI flags correspond to each plugin.
+type VolumeConfigFlags struct {
+	PersistentVolumeRecyclerMaximumRetry                int
+	PersistentVolumeRecyclerMinimumTimeoutNFS           int
+	PersistentVolumeRecyclerPodTemplateFilePathNFS      string
+	PersistentVolumeRecyclerIncrementTimeoutNFS         int
+	PersistentVolumeRecyclerPodTemplateFilePathHostPath string
+	PersistentVolumeRecyclerMinimumTimeoutHostPath      int
+	PersistentVolumeRecyclerIncrementTimeoutHostPath    int
+	EnableHostPathProvisioning                          bool
+	EnableDynamicProvisioning                           bool
+}
+
+type PersistentVolumeControllerOptions struct {
+	PVClaimBinderSyncPeriod time.Duration
+	VolumeConfigFlags       VolumeConfigFlags
+}
+
+func NewPersistentVolumeControllerOptions() PersistentVolumeControllerOptions {
+	return PersistentVolumeControllerOptions{
+		PVClaimBinderSyncPeriod: 15 * time.Second,
+		VolumeConfigFlags: VolumeConfigFlags{
+			// default values here
+			PersistentVolumeRecyclerMaximumRetry:             3,
+			PersistentVolumeRecyclerMinimumTimeoutNFS:        300,
+			PersistentVolumeRecyclerIncrementTimeoutNFS:      30,
+			PersistentVolumeRecyclerMinimumTimeoutHostPath:   60,
+			PersistentVolumeRecyclerIncrementTimeoutHostPath: 30,
+			EnableHostPathProvisioning:                       false,
+			EnableDynamicProvisioning:                        true,
+		},
+	}
+}
+
+func (o *PersistentVolumeControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	fs.DurationVar(&o.PVClaimBinderSyncPeriod, "pvclaimbinder-sync-period", o.PVClaimBinderSyncPeriod,
+		"The period for syncing persistent volumes and persistent volume claims")
+	fs.StringVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS,
+		"pv-recycler-pod-template-filepath-nfs", o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS,
+		"The file path to a pod definition used as a template for NFS persistent volume recycling")
+	fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs",
+		o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod")
+	fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs",
+		o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod")
+	fs.StringVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath",
+		o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath,
+		"The file path to a pod definition used as a template for HostPath persistent volume recycling. "+
+			"This is for development and testing only and will not work in a multi-node cluster.")
+	fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath",
+		o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath,
+		"The minimum ActiveDeadlineSeconds to use for a HostPath Recycler pod. This is for development and testing only and will not work in a multi-node cluster.")
+	fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath",
+		o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath,
+		"the increment of time added per Gi to ActiveDeadlineSeconds for a HostPath scrubber pod. "+
+			"This is for development and testing only and will not work in a multi-node cluster.")
+	fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerMaximumRetry, "pv-recycler-maximum-retry",
+		o.VolumeConfigFlags.PersistentVolumeRecyclerMaximumRetry,
+		"Maximum number of attempts to recycle or delete a persistent volume")
+	fs.BoolVar(&o.VolumeConfigFlags.EnableHostPathProvisioning, "enable-hostpath-provisioner", o.VolumeConfigFlags.EnableHostPathProvisioning,
+		"Enable HostPath PV provisioning when running without a cloud provider. This allows testing and development of provisioning features. "+
+			"HostPath provisioning is not supported in any way, won't work in a multi-node cluster, and should not be used for anything other than testing or development.")
+	fs.BoolVar(&o.VolumeConfigFlags.EnableDynamicProvisioning, "enable-dynamic-provisioning", o.VolumeConfigFlags.EnableDynamicProvisioning,
+		"Enable dynamic provisioning for environments that support it.")
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/provision_test.go

@@ -0,0 +1,462 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"errors"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	apierrs "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/api"
+)
+
+var class1Parameters = map[string]string{
+	"param1": "value1",
+}
+var class2Parameters = map[string]string{
+	"param2": "value2",
+}
+var deleteReclaimPolicy = v1.PersistentVolumeReclaimDelete
+var storageClasses = []*storage.StorageClass{
+	{
+		TypeMeta: metav1.TypeMeta{
+			Kind: "StorageClass",
+		},
+
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "gold",
+		},
+
+		Provisioner:   mockPluginName,
+		Parameters:    class1Parameters,
+		ReclaimPolicy: &deleteReclaimPolicy,
+	},
+	{
+		TypeMeta: metav1.TypeMeta{
+			Kind: "StorageClass",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "silver",
+		},
+		Provisioner:   mockPluginName,
+		Parameters:    class2Parameters,
+		ReclaimPolicy: &deleteReclaimPolicy,
+	},
+	{
+		TypeMeta: metav1.TypeMeta{
+			Kind: "StorageClass",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "external",
+		},
+		Provisioner:   "vendor.com/my-volume",
+		Parameters:    class1Parameters,
+		ReclaimPolicy: &deleteReclaimPolicy,
+	},
+	{
+		TypeMeta: metav1.TypeMeta{
+			Kind: "StorageClass",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "unknown-internal",
+		},
+		Provisioner:   "kubernetes.io/unknown",
+		Parameters:    class1Parameters,
+		ReclaimPolicy: &deleteReclaimPolicy,
+	},
+	{
+		TypeMeta: metav1.TypeMeta{
+			Kind: "StorageClass",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "unsupported-mountoptions",
+		},
+		Provisioner:   mockPluginName,
+		Parameters:    class1Parameters,
+		ReclaimPolicy: &deleteReclaimPolicy,
+		MountOptions:  []string{"foo"},
+	},
+}
+
+// call to storageClass 1, returning an error
+var provision1Error = provisionCall{
+	ret:                errors.New("Mock provisioner error"),
+	expectedParameters: class1Parameters,
+}
+
+// call to storageClass 1, returning a valid PV
+var provision1Success = provisionCall{
+	ret:                nil,
+	expectedParameters: class1Parameters,
+}
+
+// call to storageClass 2, returning a valid PV
+var provision2Success = provisionCall{
+	ret:                nil,
+	expectedParameters: class2Parameters,
+}
+
+var provisionAlphaSuccess = provisionCall{
+	ret: nil,
+}
+
+// Test single call to syncVolume, expecting provisioning to happen.
+// 1. Fill in the controller with initial data
+// 2. Call the syncVolume *once*.
+// 3. Compare resulting volumes with expected volumes.
+func TestProvisionSync(t *testing.T) {
+	tests := []controllerTest{
+		{
+			// Provision a volume (with a default class)
+			"11-1 - successful provision with storage class 1",
+			novolumes,
+			newVolumeArray("pvc-uid11-1", "1Gi", "uid11-1", "claim11-1", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classGold, annBoundByController, annDynamicallyProvisioned),
+			newClaimArray("claim11-1", "uid11-1", "1Gi", "", v1.ClaimPending, &classGold),
+			// Binding will be completed in the next syncClaim
+			newClaimArray("claim11-1", "uid11-1", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Normal ProvisioningSucceeded"}, noerrors, wrapTestWithProvisionCalls([]provisionCall{provision1Success}, testSyncClaim),
+		},
+		{
+			// Provision failure - plugin not found
+			"11-2 - plugin not found",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-2", "uid11-2", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-2", "uid11-2", "1Gi", "", v1.ClaimPending, &classGold),
+			[]string{"Warning ProvisioningFailed"}, noerrors,
+			testSyncClaim,
+		},
+		{
+			// Provision failure - newProvisioner returns error
+			"11-3 - newProvisioner failure",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-3", "uid11-3", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-3", "uid11-3", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Warning ProvisioningFailed"}, noerrors,
+			wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+		{
+			// Provision failure - Provision returns error
+			"11-4 - provision failure",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-4", "uid11-4", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-4", "uid11-4", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Warning ProvisioningFailed"}, noerrors,
+			wrapTestWithProvisionCalls([]provisionCall{provision1Error}, testSyncClaim),
+		},
+		{
+			// No provisioning if there is a matching volume available
+			"11-6 - provisioning when there is a volume available",
+			newVolumeArray("volume11-6", "1Gi", "", "", v1.VolumePending, v1.PersistentVolumeReclaimRetain, classGold),
+			newVolumeArray("volume11-6", "1Gi", "uid11-6", "claim11-6", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classGold, annBoundByController),
+			newClaimArray("claim11-6", "uid11-6", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-6", "uid11-6", "1Gi", "volume11-6", v1.ClaimBound, &classGold, annBoundByController, annBindCompleted),
+			noevents, noerrors,
+			// No provisioning plugin confingure - makes the test fail when
+			// the controller errorneously tries to provision something
+			wrapTestWithProvisionCalls([]provisionCall{provision1Success}, testSyncClaim),
+		},
+		{
+			// Provision success? - claim is bound before provisioner creates
+			// a volume.
+			"11-7 - claim is bound before provisioning",
+			novolumes,
+			newVolumeArray("pvc-uid11-7", "1Gi", "uid11-7", "claim11-7", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classGold, annBoundByController, annDynamicallyProvisioned),
+			newClaimArray("claim11-7", "uid11-7", "1Gi", "", v1.ClaimPending, &classGold),
+			// The claim would be bound in next syncClaim
+			newClaimArray("claim11-7", "uid11-7", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			noevents, noerrors,
+			wrapTestWithInjectedOperation(wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim), func(ctrl *PersistentVolumeController, reactor *volumeReactor) {
+				// Create a volume before provisionClaimOperation starts.
+				// This similates a parallel controller provisioning the volume.
+				reactor.lock.Lock()
+				volume := newVolume("pvc-uid11-7", "1Gi", "uid11-7", "claim11-7", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classGold, annBoundByController, annDynamicallyProvisioned)
+				reactor.volumes[volume.Name] = volume
+				reactor.lock.Unlock()
+			}),
+		},
+		{
+			// Provision success - cannot save provisioned PV once,
+			// second retry succeeds
+			"11-8 - cannot save provisioned volume",
+			novolumes,
+			newVolumeArray("pvc-uid11-8", "1Gi", "uid11-8", "claim11-8", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classGold, annBoundByController, annDynamicallyProvisioned),
+			newClaimArray("claim11-8", "uid11-8", "1Gi", "", v1.ClaimPending, &classGold),
+			// Binding will be completed in the next syncClaim
+			newClaimArray("claim11-8", "uid11-8", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Normal ProvisioningSucceeded"},
+			[]reactorError{
+				// Inject error to the first
+				// kubeclient.PersistentVolumes.Create() call. All other calls
+				// will succeed.
+				{"create", "persistentvolumes", errors.New("Mock creation error")},
+			},
+			wrapTestWithProvisionCalls([]provisionCall{provision1Success}, testSyncClaim),
+		},
+		{
+			// Provision success? - cannot save provisioned PV five times,
+			// volume is deleted and delete succeeds
+			"11-9 - cannot save provisioned volume, delete succeeds",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-9", "uid11-9", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-9", "uid11-9", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Warning ProvisioningFailed"},
+			[]reactorError{
+				// Inject error to five kubeclient.PersistentVolumes.Create()
+				// calls
+				{"create", "persistentvolumes", errors.New("Mock creation error1")},
+				{"create", "persistentvolumes", errors.New("Mock creation error2")},
+				{"create", "persistentvolumes", errors.New("Mock creation error3")},
+				{"create", "persistentvolumes", errors.New("Mock creation error4")},
+				{"create", "persistentvolumes", errors.New("Mock creation error5")},
+			},
+			wrapTestWithPluginCalls(
+				nil,                                // recycle calls
+				[]error{nil},                       // delete calls
+				[]provisionCall{provision1Success}, // provision calls
+				testSyncClaim,
+			),
+		},
+		{
+			// Provision failure - cannot save provisioned PV five times,
+			// volume delete failed - no plugin found
+			"11-10 - cannot save provisioned volume, no delete plugin found",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-10", "uid11-10", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-10", "uid11-10", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Warning ProvisioningFailed", "Warning ProvisioningCleanupFailed"},
+			[]reactorError{
+				// Inject error to five kubeclient.PersistentVolumes.Create()
+				// calls
+				{"create", "persistentvolumes", errors.New("Mock creation error1")},
+				{"create", "persistentvolumes", errors.New("Mock creation error2")},
+				{"create", "persistentvolumes", errors.New("Mock creation error3")},
+				{"create", "persistentvolumes", errors.New("Mock creation error4")},
+				{"create", "persistentvolumes", errors.New("Mock creation error5")},
+			},
+			// No deleteCalls are configured, which results into no deleter plugin available for the volume
+			wrapTestWithProvisionCalls([]provisionCall{provision1Success}, testSyncClaim),
+		},
+		{
+			// Provision failure - cannot save provisioned PV five times,
+			// volume delete failed - deleter returns error five times
+			"11-11 - cannot save provisioned volume, deleter fails",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-11", "uid11-11", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-11", "uid11-11", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Warning ProvisioningFailed", "Warning ProvisioningCleanupFailed"},
+			[]reactorError{
+				// Inject error to five kubeclient.PersistentVolumes.Create()
+				// calls
+				{"create", "persistentvolumes", errors.New("Mock creation error1")},
+				{"create", "persistentvolumes", errors.New("Mock creation error2")},
+				{"create", "persistentvolumes", errors.New("Mock creation error3")},
+				{"create", "persistentvolumes", errors.New("Mock creation error4")},
+				{"create", "persistentvolumes", errors.New("Mock creation error5")},
+			},
+			wrapTestWithPluginCalls(
+				nil, // recycle calls
+				[]error{ // delete calls
+					errors.New("Mock deletion error1"),
+					errors.New("Mock deletion error2"),
+					errors.New("Mock deletion error3"),
+					errors.New("Mock deletion error4"),
+					errors.New("Mock deletion error5"),
+				},
+				[]provisionCall{provision1Success}, // provision calls
+				testSyncClaim),
+		},
+		{
+			// Provision failure - cannot save provisioned PV five times,
+			// volume delete succeeds 2nd time
+			"11-12 - cannot save provisioned volume, delete succeeds 2nd time",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-12", "uid11-12", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-12", "uid11-12", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			[]string{"Warning ProvisioningFailed"},
+			[]reactorError{
+				// Inject error to five kubeclient.PersistentVolumes.Create()
+				// calls
+				{"create", "persistentvolumes", errors.New("Mock creation error1")},
+				{"create", "persistentvolumes", errors.New("Mock creation error2")},
+				{"create", "persistentvolumes", errors.New("Mock creation error3")},
+				{"create", "persistentvolumes", errors.New("Mock creation error4")},
+				{"create", "persistentvolumes", errors.New("Mock creation error5")},
+			},
+			wrapTestWithPluginCalls(
+				nil, // recycle calls
+				[]error{ // delete calls
+					errors.New("Mock deletion error1"),
+					nil,
+				}, //  provison calls
+				[]provisionCall{provision1Success},
+				testSyncClaim,
+			),
+		},
+		{
+			// Provision a volume (with non-default class)
+			"11-13 - successful provision with storage class 2",
+			novolumes,
+			newVolumeArray("pvc-uid11-13", "1Gi", "uid11-13", "claim11-13", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classSilver, annBoundByController, annDynamicallyProvisioned),
+			newClaimArray("claim11-13", "uid11-13", "1Gi", "", v1.ClaimPending, &classSilver),
+			// Binding will be completed in the next syncClaim
+			newClaimArray("claim11-13", "uid11-13", "1Gi", "", v1.ClaimPending, &classSilver, annStorageProvisioner),
+			[]string{"Normal ProvisioningSucceeded"}, noerrors, wrapTestWithProvisionCalls([]provisionCall{provision2Success}, testSyncClaim),
+		},
+		{
+			// Provision error - non existing class
+			"11-14 - fail due to non-existing class",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-14", "uid11-14", "1Gi", "", v1.ClaimPending, &classNonExisting),
+			newClaimArray("claim11-14", "uid11-14", "1Gi", "", v1.ClaimPending, &classNonExisting),
+			noevents, noerrors, wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+		{
+			// No provisioning with class=""
+			"11-15 - no provisioning with class=''",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-15", "uid11-15", "1Gi", "", v1.ClaimPending, &classEmpty),
+			newClaimArray("claim11-15", "uid11-15", "1Gi", "", v1.ClaimPending, &classEmpty),
+			noevents, noerrors, wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+		{
+			// No provisioning with class=nil
+			"11-16 - no provisioning with class=nil",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-15", "uid11-15", "1Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim11-15", "uid11-15", "1Gi", "", v1.ClaimPending, nil),
+			noevents, noerrors, wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+		{
+			// No provisioning + normal event with external provisioner
+			"11-17 - external provisioner",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-17", "uid11-17", "1Gi", "", v1.ClaimPending, &classExternal),
+			claimWithAnnotation(annStorageProvisioner, "vendor.com/my-volume",
+				newClaimArray("claim11-17", "uid11-17", "1Gi", "", v1.ClaimPending, &classExternal)),
+			[]string{"Normal ExternalProvisioning"},
+			noerrors, wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+		{
+			// No provisioning + warning event with unknown internal provisioner
+			"11-18 - unknown internal provisioner",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-18", "uid11-18", "1Gi", "", v1.ClaimPending, &classUnknownInternal),
+			newClaimArray("claim11-18", "uid11-18", "1Gi", "", v1.ClaimPending, &classUnknownInternal),
+			[]string{"Warning ProvisioningFailed"},
+			noerrors, wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+		{
+			// Provision success - first save of a PV to API server fails (API
+			// server has written the object to etcd, but crashed before sending
+			// 200 OK response to the controller). Controller retries and the
+			// second save of the PV returns "AlreadyExists" because the PV
+			// object already is in the API server.
+			//
+			"11-19 - provisioned volume saved but API server crashed",
+			novolumes,
+			// We don't actually simulate API server saving the object and
+			// crashing afterwards, Create() just returns error without saving
+			// the volume in this test. So the set of expected volumes at the
+			// end of the test is empty.
+			novolumes,
+			newClaimArray("claim11-19", "uid11-19", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim11-19", "uid11-19", "1Gi", "", v1.ClaimPending, &classGold, annStorageProvisioner),
+			noevents,
+			[]reactorError{
+				// Inject errors to simulate crashed API server during
+				// kubeclient.PersistentVolumes.Create()
+				{"create", "persistentvolumes", errors.New("Mock creation error1")},
+				{"create", "persistentvolumes", apierrs.NewAlreadyExists(api.Resource("persistentvolumes"), "")},
+			},
+			wrapTestWithPluginCalls(
+				nil, // recycle calls
+				nil, // delete calls - if Delete was called the test would fail
+				[]provisionCall{provision1Success},
+				testSyncClaim,
+			),
+		},
+		{
+			// No provisioning + warning event with unsupported storageClass.mountOptions
+			"11-20 - unsupported storageClass.mountOptions",
+			novolumes,
+			novolumes,
+			newClaimArray("claim11-20", "uid11-20", "1Gi", "", v1.ClaimPending, &classUnsupportedMountOptions),
+			newClaimArray("claim11-20", "uid11-20", "1Gi", "", v1.ClaimPending, &classUnsupportedMountOptions, annStorageProvisioner),
+			// Expect event to be prefixed with "Mount options" because saving PV will fail anyway
+			[]string{"Warning ProvisioningFailed Mount options"},
+			noerrors, wrapTestWithProvisionCalls([]provisionCall{}, testSyncClaim),
+		},
+	}
+	runSyncTests(t, tests, storageClasses)
+}
+
+// Test multiple calls to syncClaim/syncVolume and periodic sync of all
+// volume/claims. The test follows this pattern:
+// 0. Load the controller with initial data.
+// 1. Call controllerTest.testCall() once as in TestSync()
+// 2. For all volumes/claims changed by previous syncVolume/syncClaim calls,
+//    call appropriate syncVolume/syncClaim (simulating "volume/claim changed"
+//    events). Go to 2. if these calls change anything.
+// 3. When all changes are processed and no new changes were made, call
+//    syncVolume/syncClaim on all volumes/claims (simulating "periodic sync").
+// 4. If some changes were done by step 3., go to 2. (simulation of
+//    "volume/claim updated" events, eventually performing step 3. again)
+// 5. When 3. does not do any changes, finish the tests and compare final set
+//    of volumes/claims with expected claims/volumes and report differences.
+// Some limit of calls in enforced to prevent endless loops.
+func TestProvisionMultiSync(t *testing.T) {
+	tests := []controllerTest{
+		{
+			// Provision a volume with binding
+			"12-1 - successful provision",
+			novolumes,
+			newVolumeArray("pvc-uid12-1", "1Gi", "uid12-1", "claim12-1", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classGold, annBoundByController, annDynamicallyProvisioned),
+			newClaimArray("claim12-1", "uid12-1", "1Gi", "", v1.ClaimPending, &classGold),
+			newClaimArray("claim12-1", "uid12-1", "1Gi", "pvc-uid12-1", v1.ClaimBound, &classGold, annBoundByController, annBindCompleted, annStorageProvisioner),
+			noevents, noerrors, wrapTestWithProvisionCalls([]provisionCall{provision1Success}, testSyncClaim),
+		},
+	}
+
+	runMultisyncTests(t, tests, storageClasses, storageClasses[0].Name)
+}
+
+// When provisioning is disabled, provisioning a claim should instantly return nil
+func TestDisablingDynamicProvisioner(t *testing.T) {
+	ctrl, err := newTestController(nil, nil, false)
+	if err != nil {
+		t.Fatalf("Construct PersistentVolume controller failed: %v", err)
+	}
+	retVal := ctrl.provisionClaim(nil)
+	if retVal != nil {
+		t.Errorf("Expected nil return but got %v", retVal)
+	}
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/pv_controller_base.go

@@ -0,0 +1,526 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	coreinformers "k8s.io/client-go/informers/core/v1"
+	storageinformers "k8s.io/client-go/informers/storage/v1"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes/scheme"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/client-go/util/workqueue"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/util/goroutinemap"
+	vol "k8s.io/kubernetes/pkg/volume"
+
+	"github.com/golang/glog"
+)
+
+// This file contains the controller base functionality, i.e. framework to
+// process PV/PVC added/updated/deleted events. The real binding, provisioning,
+// recycling and deleting is done in pv_controller.go
+
+// ControllerParameters contains arguments for creation of a new
+// PersistentVolume controller.
+type ControllerParameters struct {
+	KubeClient                clientset.Interface
+	SyncPeriod                time.Duration
+	VolumePlugins             []vol.VolumePlugin
+	Cloud                     cloudprovider.Interface
+	ClusterName               string
+	VolumeInformer            coreinformers.PersistentVolumeInformer
+	ClaimInformer             coreinformers.PersistentVolumeClaimInformer
+	ClassInformer             storageinformers.StorageClassInformer
+	EventRecorder             record.EventRecorder
+	EnableDynamicProvisioning bool
+}
+
+// NewController creates a new PersistentVolume controller
+func NewController(p ControllerParameters) (*PersistentVolumeController, error) {
+	eventRecorder := p.EventRecorder
+	if eventRecorder == nil {
+		broadcaster := record.NewBroadcaster()
+		broadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: v1core.New(p.KubeClient.Core().RESTClient()).Events("")})
+		eventRecorder = broadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "persistentvolume-controller"})
+	}
+
+	controller := &PersistentVolumeController{
+		volumes:           newPersistentVolumeOrderedIndex(),
+		claims:            cache.NewStore(cache.DeletionHandlingMetaNamespaceKeyFunc),
+		kubeClient:        p.KubeClient,
+		eventRecorder:     eventRecorder,
+		runningOperations: goroutinemap.NewGoRoutineMap(true /* exponentialBackOffOnError */),
+		cloud:             p.Cloud,
+		enableDynamicProvisioning:     p.EnableDynamicProvisioning,
+		clusterName:                   p.ClusterName,
+		createProvisionedPVRetryCount: createProvisionedPVRetryCount,
+		createProvisionedPVInterval:   createProvisionedPVInterval,
+		claimQueue:                    workqueue.NewNamed("claims"),
+		volumeQueue:                   workqueue.NewNamed("volumes"),
+		resyncPeriod:                  p.SyncPeriod,
+	}
+
+	// Prober is nil because PV is not aware of Flexvolume.
+	if err := controller.volumePluginMgr.InitPlugins(p.VolumePlugins, nil /* prober */, controller); err != nil {
+		return nil, fmt.Errorf("Could not initialize volume plugins for PersistentVolume Controller: %v", err)
+	}
+
+	p.VolumeInformer.Informer().AddEventHandler(
+		cache.ResourceEventHandlerFuncs{
+			AddFunc:    func(obj interface{}) { controller.enqueueWork(controller.volumeQueue, obj) },
+			UpdateFunc: func(oldObj, newObj interface{}) { controller.enqueueWork(controller.volumeQueue, newObj) },
+			DeleteFunc: func(obj interface{}) { controller.enqueueWork(controller.volumeQueue, obj) },
+		},
+	)
+	controller.volumeLister = p.VolumeInformer.Lister()
+	controller.volumeListerSynced = p.VolumeInformer.Informer().HasSynced
+
+	p.ClaimInformer.Informer().AddEventHandler(
+		cache.ResourceEventHandlerFuncs{
+			AddFunc:    func(obj interface{}) { controller.enqueueWork(controller.claimQueue, obj) },
+			UpdateFunc: func(oldObj, newObj interface{}) { controller.enqueueWork(controller.claimQueue, newObj) },
+			DeleteFunc: func(obj interface{}) { controller.enqueueWork(controller.claimQueue, obj) },
+		},
+	)
+	controller.claimLister = p.ClaimInformer.Lister()
+	controller.claimListerSynced = p.ClaimInformer.Informer().HasSynced
+
+	controller.classLister = p.ClassInformer.Lister()
+	controller.classListerSynced = p.ClassInformer.Informer().HasSynced
+	return controller, nil
+}
+
+// initializeCaches fills all controller caches with initial data from etcd in
+// order to have the caches already filled when first addClaim/addVolume to
+// perform initial synchronization of the controller.
+func (ctrl *PersistentVolumeController) initializeCaches(volumeLister corelisters.PersistentVolumeLister, claimLister corelisters.PersistentVolumeClaimLister) {
+	volumeList, err := volumeLister.List(labels.Everything())
+	if err != nil {
+		glog.Errorf("PersistentVolumeController can't initialize caches: %v", err)
+		return
+	}
+	for _, volume := range volumeList {
+		volumeClone := volume.DeepCopy()
+		if _, err = ctrl.storeVolumeUpdate(volumeClone); err != nil {
+			glog.Errorf("error updating volume cache: %v", err)
+		}
+	}
+
+	claimList, err := claimLister.List(labels.Everything())
+	if err != nil {
+		glog.Errorf("PersistentVolumeController can't initialize caches: %v", err)
+		return
+	}
+	for _, claim := range claimList {
+		if _, err = ctrl.storeClaimUpdate(claim.DeepCopy()); err != nil {
+			glog.Errorf("error updating claim cache: %v", err)
+		}
+	}
+	glog.V(4).Infof("controller initialized")
+}
+
+// enqueueWork adds volume or claim to given work queue.
+func (ctrl *PersistentVolumeController) enqueueWork(queue workqueue.Interface, obj interface{}) {
+	// Beware of "xxx deleted" events
+	if unknown, ok := obj.(cache.DeletedFinalStateUnknown); ok && unknown.Obj != nil {
+		obj = unknown.Obj
+	}
+	objName, err := controller.KeyFunc(obj)
+	if err != nil {
+		glog.Errorf("failed to get key from object: %v", err)
+		return
+	}
+	glog.V(5).Infof("enqueued %q for sync", objName)
+	queue.Add(objName)
+}
+
+func (ctrl *PersistentVolumeController) storeVolumeUpdate(volume interface{}) (bool, error) {
+	return storeObjectUpdate(ctrl.volumes.store, volume, "volume")
+}
+
+func (ctrl *PersistentVolumeController) storeClaimUpdate(claim interface{}) (bool, error) {
+	return storeObjectUpdate(ctrl.claims, claim, "claim")
+}
+
+// updateVolume runs in worker thread and handles "volume added",
+// "volume updated" and "periodic sync" events.
+func (ctrl *PersistentVolumeController) updateVolume(volume *v1.PersistentVolume) {
+	// Store the new volume version in the cache and do not process it if this
+	// is an old version.
+	new, err := ctrl.storeVolumeUpdate(volume)
+	if err != nil {
+		glog.Errorf("%v", err)
+	}
+	if !new {
+		return
+	}
+
+	err = ctrl.syncVolume(volume)
+	if err != nil {
+		if errors.IsConflict(err) {
+			// Version conflict error happens quite often and the controller
+			// recovers from it easily.
+			glog.V(3).Infof("could not sync volume %q: %+v", volume.Name, err)
+		} else {
+			glog.Errorf("could not sync volume %q: %+v", volume.Name, err)
+		}
+	}
+}
+
+// deleteVolume runs in worker thread and handles "volume deleted" event.
+func (ctrl *PersistentVolumeController) deleteVolume(volume *v1.PersistentVolume) {
+	_ = ctrl.volumes.store.Delete(volume)
+	glog.V(4).Infof("volume %q deleted", volume.Name)
+
+	if volume.Spec.ClaimRef == nil {
+		return
+	}
+	// sync the claim when its volume is deleted. Explicitly syncing the
+	// claim here in response to volume deletion prevents the claim from
+	// waiting until the next sync period for its Lost status.
+	claimKey := claimrefToClaimKey(volume.Spec.ClaimRef)
+	glog.V(5).Infof("deleteVolume[%s]: scheduling sync of claim %q", volume.Name, claimKey)
+	ctrl.claimQueue.Add(claimKey)
+}
+
+// updateClaim runs in worker thread and handles "claim added",
+// "claim updated" and "periodic sync" events.
+func (ctrl *PersistentVolumeController) updateClaim(claim *v1.PersistentVolumeClaim) {
+	// Store the new claim version in the cache and do not process it if this is
+	// an old version.
+	new, err := ctrl.storeClaimUpdate(claim)
+	if err != nil {
+		glog.Errorf("%v", err)
+	}
+	if !new {
+		return
+	}
+	err = ctrl.syncClaim(claim)
+	if err != nil {
+		if errors.IsConflict(err) {
+			// Version conflict error happens quite often and the controller
+			// recovers from it easily.
+			glog.V(3).Infof("could not sync claim %q: %+v", claimToClaimKey(claim), err)
+		} else {
+			glog.Errorf("could not sync volume %q: %+v", claimToClaimKey(claim), err)
+		}
+	}
+}
+
+// deleteClaim runs in worker thread and handles "claim deleted" event.
+func (ctrl *PersistentVolumeController) deleteClaim(claim *v1.PersistentVolumeClaim) {
+	_ = ctrl.claims.Delete(claim)
+	glog.V(4).Infof("claim %q deleted", claimToClaimKey(claim))
+
+	// sync the volume when its claim is deleted.  Explicitly sync'ing the
+	// volume here in response to claim deletion prevents the volume from
+	// waiting until the next sync period for its Release.
+	volumeName := claim.Spec.VolumeName
+	glog.V(5).Infof("deleteClaim[%s]: scheduling sync of volume %q", claimToClaimKey(claim), volumeName)
+	ctrl.volumeQueue.Add(volumeName)
+}
+
+// Run starts all of this controller's control loops
+func (ctrl *PersistentVolumeController) Run(stopCh <-chan struct{}) {
+	defer utilruntime.HandleCrash()
+	defer ctrl.claimQueue.ShutDown()
+	defer ctrl.volumeQueue.ShutDown()
+
+	glog.Infof("Starting persistent volume controller")
+	defer glog.Infof("Shutting down peristent volume controller")
+
+	if !controller.WaitForCacheSync("persistent volume", stopCh, ctrl.volumeListerSynced, ctrl.claimListerSynced, ctrl.classListerSynced) {
+		return
+	}
+
+	ctrl.initializeCaches(ctrl.volumeLister, ctrl.claimLister)
+
+	go wait.Until(ctrl.resync, ctrl.resyncPeriod, stopCh)
+	go wait.Until(ctrl.volumeWorker, time.Second, stopCh)
+	go wait.Until(ctrl.claimWorker, time.Second, stopCh)
+
+	<-stopCh
+}
+
+// volumeWorker processes items from volumeQueue. It must run only once,
+// syncVolume is not assured to be reentrant.
+func (ctrl *PersistentVolumeController) volumeWorker() {
+	workFunc := func() bool {
+		keyObj, quit := ctrl.volumeQueue.Get()
+		if quit {
+			return true
+		}
+		defer ctrl.volumeQueue.Done(keyObj)
+		key := keyObj.(string)
+		glog.V(5).Infof("volumeWorker[%s]", key)
+
+		_, name, err := cache.SplitMetaNamespaceKey(key)
+		if err != nil {
+			glog.V(4).Infof("error getting name of volume %q to get volume from informer: %v", key, err)
+			return false
+		}
+		volume, err := ctrl.volumeLister.Get(name)
+		if err == nil {
+			// The volume still exists in informer cache, the event must have
+			// been add/update/sync
+			ctrl.updateVolume(volume)
+			return false
+		}
+		if !errors.IsNotFound(err) {
+			glog.V(2).Infof("error getting volume %q from informer: %v", key, err)
+			return false
+		}
+
+		// The volume is not in informer cache, the event must have been
+		// "delete"
+		volumeObj, found, err := ctrl.volumes.store.GetByKey(key)
+		if err != nil {
+			glog.V(2).Infof("error getting volume %q from cache: %v", key, err)
+			return false
+		}
+		if !found {
+			// The controller has already processed the delete event and
+			// deleted the volume from its cache
+			glog.V(2).Infof("deletion of volume %q was already processed", key)
+			return false
+		}
+		volume, ok := volumeObj.(*v1.PersistentVolume)
+		if !ok {
+			glog.Errorf("expected volume, got %+v", volumeObj)
+			return false
+		}
+		ctrl.deleteVolume(volume)
+		return false
+	}
+	for {
+		if quit := workFunc(); quit {
+			glog.Infof("volume worker queue shutting down")
+			return
+		}
+	}
+}
+
+// claimWorker processes items from claimQueue. It must run only once,
+// syncClaim is not reentrant.
+func (ctrl *PersistentVolumeController) claimWorker() {
+	workFunc := func() bool {
+		keyObj, quit := ctrl.claimQueue.Get()
+		if quit {
+			return true
+		}
+		defer ctrl.claimQueue.Done(keyObj)
+		key := keyObj.(string)
+		glog.V(5).Infof("claimWorker[%s]", key)
+
+		namespace, name, err := cache.SplitMetaNamespaceKey(key)
+		if err != nil {
+			glog.V(4).Infof("error getting namespace & name of claim %q to get claim from informer: %v", key, err)
+			return false
+		}
+		claim, err := ctrl.claimLister.PersistentVolumeClaims(namespace).Get(name)
+		if err == nil {
+			// The claim still exists in informer cache, the event must have
+			// been add/update/sync
+			ctrl.updateClaim(claim)
+			return false
+		}
+		if !errors.IsNotFound(err) {
+			glog.V(2).Infof("error getting claim %q from informer: %v", key, err)
+			return false
+		}
+
+		// The claim is not in informer cache, the event must have been "delete"
+		claimObj, found, err := ctrl.claims.GetByKey(key)
+		if err != nil {
+			glog.V(2).Infof("error getting claim %q from cache: %v", key, err)
+			return false
+		}
+		if !found {
+			// The controller has already processed the delete event and
+			// deleted the claim from its cache
+			glog.V(2).Infof("deletion of claim %q was already processed", key)
+			return false
+		}
+		claim, ok := claimObj.(*v1.PersistentVolumeClaim)
+		if !ok {
+			glog.Errorf("expected claim, got %+v", claimObj)
+			return false
+		}
+		ctrl.deleteClaim(claim)
+		return false
+	}
+	for {
+		if quit := workFunc(); quit {
+			glog.Infof("claim worker queue shutting down")
+			return
+		}
+	}
+}
+
+// resync supplements short resync period of shared informers - we don't want
+// all consumers of PV/PVC shared informer to have a short resync period,
+// therefore we do our own.
+func (ctrl *PersistentVolumeController) resync() {
+	glog.V(4).Infof("resyncing PV controller")
+
+	pvcs, err := ctrl.claimLister.List(labels.NewSelector())
+	if err != nil {
+		glog.Warningf("cannot list claims: %s", err)
+		return
+	}
+	for _, pvc := range pvcs {
+		ctrl.enqueueWork(ctrl.claimQueue, pvc)
+	}
+
+	pvs, err := ctrl.volumeLister.List(labels.NewSelector())
+	if err != nil {
+		glog.Warningf("cannot list persistent volumes: %s", err)
+		return
+	}
+	for _, pv := range pvs {
+		ctrl.enqueueWork(ctrl.volumeQueue, pv)
+	}
+}
+
+// setClaimProvisioner saves
+// claim.Annotations[annStorageProvisioner] = class.Provisioner
+func (ctrl *PersistentVolumeController) setClaimProvisioner(claim *v1.PersistentVolumeClaim, class *storage.StorageClass) (*v1.PersistentVolumeClaim, error) {
+	if val, ok := claim.Annotations[annStorageProvisioner]; ok && val == class.Provisioner {
+		// annotation is already set, nothing to do
+		return claim, nil
+	}
+
+	// The volume from method args can be pointing to watcher cache. We must not
+	// modify these, therefore create a copy.
+	claimClone := claim.DeepCopy()
+	metav1.SetMetaDataAnnotation(&claimClone.ObjectMeta, annStorageProvisioner, class.Provisioner)
+	newClaim, err := ctrl.kubeClient.Core().PersistentVolumeClaims(claim.Namespace).Update(claimClone)
+	if err != nil {
+		return newClaim, err
+	}
+	_, err = ctrl.storeClaimUpdate(newClaim)
+	if err != nil {
+		return newClaim, err
+	}
+	return newClaim, nil
+}
+
+// Stateless functions
+
+func getClaimStatusForLogging(claim *v1.PersistentVolumeClaim) string {
+	bound := metav1.HasAnnotation(claim.ObjectMeta, annBindCompleted)
+	boundByController := metav1.HasAnnotation(claim.ObjectMeta, annBoundByController)
+
+	return fmt.Sprintf("phase: %s, bound to: %q, bindCompleted: %v, boundByController: %v", claim.Status.Phase, claim.Spec.VolumeName, bound, boundByController)
+}
+
+func getVolumeStatusForLogging(volume *v1.PersistentVolume) string {
+	boundByController := metav1.HasAnnotation(volume.ObjectMeta, annBoundByController)
+	claimName := ""
+	if volume.Spec.ClaimRef != nil {
+		claimName = fmt.Sprintf("%s/%s (uid: %s)", volume.Spec.ClaimRef.Namespace, volume.Spec.ClaimRef.Name, volume.Spec.ClaimRef.UID)
+	}
+	return fmt.Sprintf("phase: %s, bound to: %q, boundByController: %v", volume.Status.Phase, claimName, boundByController)
+}
+
+// isVolumeBoundToClaim returns true, if given volume is pre-bound or bound
+// to specific claim. Both claim.Name and claim.Namespace must be equal.
+// If claim.UID is present in volume.Spec.ClaimRef, it must be equal too.
+func isVolumeBoundToClaim(volume *v1.PersistentVolume, claim *v1.PersistentVolumeClaim) bool {
+	if volume.Spec.ClaimRef == nil {
+		return false
+	}
+	if claim.Name != volume.Spec.ClaimRef.Name || claim.Namespace != volume.Spec.ClaimRef.Namespace {
+		return false
+	}
+	if volume.Spec.ClaimRef.UID != "" && claim.UID != volume.Spec.ClaimRef.UID {
+		return false
+	}
+	return true
+}
+
+// storeObjectUpdate updates given cache with a new object version from Informer
+// callback (i.e. with events from etcd) or with an object modified by the
+// controller itself. Returns "true", if the cache was updated, false if the
+// object is an old version and should be ignored.
+func storeObjectUpdate(store cache.Store, obj interface{}, className string) (bool, error) {
+	objName, err := controller.KeyFunc(obj)
+	if err != nil {
+		return false, fmt.Errorf("Couldn't get key for object %+v: %v", obj, err)
+	}
+	oldObj, found, err := store.Get(obj)
+	if err != nil {
+		return false, fmt.Errorf("Error finding %s %q in controller cache: %v", className, objName, err)
+	}
+
+	objAccessor, err := meta.Accessor(obj)
+	if err != nil {
+		return false, err
+	}
+
+	if !found {
+		// This is a new object
+		glog.V(4).Infof("storeObjectUpdate: adding %s %q, version %s", className, objName, objAccessor.GetResourceVersion())
+		if err = store.Add(obj); err != nil {
+			return false, fmt.Errorf("Error adding %s %q to controller cache: %v", className, objName, err)
+		}
+		return true, nil
+	}
+
+	oldObjAccessor, err := meta.Accessor(oldObj)
+	if err != nil {
+		return false, err
+	}
+
+	objResourceVersion, err := strconv.ParseInt(objAccessor.GetResourceVersion(), 10, 64)
+	if err != nil {
+		return false, fmt.Errorf("Error parsing ResourceVersion %q of %s %q: %s", objAccessor.GetResourceVersion(), className, objName, err)
+	}
+	oldObjResourceVersion, err := strconv.ParseInt(oldObjAccessor.GetResourceVersion(), 10, 64)
+	if err != nil {
+		return false, fmt.Errorf("Error parsing old ResourceVersion %q of %s %q: %s", oldObjAccessor.GetResourceVersion(), className, objName, err)
+	}
+
+	// Throw away only older version, let the same version pass - we do want to
+	// get periodic sync events.
+	if oldObjResourceVersion > objResourceVersion {
+		glog.V(4).Infof("storeObjectUpdate: ignoring %s %q version %s", className, objName, objAccessor.GetResourceVersion())
+		return false, nil
+	}
+
+	glog.V(4).Infof("storeObjectUpdate updating %s %q with version %s", className, objName, objAccessor.GetResourceVersion())
+	if err = store.Update(obj); err != nil {
+		return false, fmt.Errorf("Error updating %s %q in controller cache: %v", className, objName, err)
+	}
+	return true, nil
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/pv_controller_test.go

@@ -0,0 +1,234 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"testing"
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
+	core "k8s.io/client-go/testing"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/kubernetes/pkg/controller"
+)
+
+// Test the real controller methods (add/update/delete claim/volume) with
+// a fake API server.
+// There is no controller API to 'initiate syncAll now', therefore these tests
+// can't reliably simulate periodic sync of volumes/claims - it would be
+// either very timing-sensitive or slow to wait for real periodic sync.
+func TestControllerSync(t *testing.T) {
+	tests := []controllerTest{
+		// [Unit test set 5] - controller tests.
+		// We test the controller as if
+		// it was connected to real API server, i.e. we call add/update/delete
+		// Claim/Volume methods. Also, all changes to volumes and claims are
+		// sent to add/update/delete Claim/Volume as real controller would do.
+		{
+			// addClaim gets a new claim. Check it's bound to a volume.
+			"5-2 - complete bind",
+			newVolumeArray("volume5-2", "1Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimRetain, classEmpty),
+			newVolumeArray("volume5-2", "1Gi", "uid5-2", "claim5-2", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			noclaims, /* added in testAddClaim5_2 */
+			newClaimArray("claim5-2", "uid5-2", "1Gi", "volume5-2", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noevents, noerrors,
+			// Custom test function that generates an add event
+			func(ctrl *PersistentVolumeController, reactor *volumeReactor, test controllerTest) error {
+				claim := newClaim("claim5-2", "uid5-2", "1Gi", "", v1.ClaimPending, nil)
+				reactor.addClaimEvent(claim)
+				return nil
+			},
+		},
+		{
+			// deleteClaim with a bound claim makes bound volume released.
+			"5-3 - delete claim",
+			newVolumeArray("volume5-3", "10Gi", "uid5-3", "claim5-3", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newVolumeArray("volume5-3", "10Gi", "uid5-3", "claim5-3", v1.VolumeReleased, v1.PersistentVolumeReclaimRetain, classEmpty, annBoundByController),
+			newClaimArray("claim5-3", "uid5-3", "1Gi", "volume5-3", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			noclaims,
+			noevents, noerrors,
+			// Custom test function that generates a delete event
+			func(ctrl *PersistentVolumeController, reactor *volumeReactor, test controllerTest) error {
+				obj := ctrl.claims.List()[0]
+				claim := obj.(*v1.PersistentVolumeClaim)
+				reactor.deleteClaimEvent(claim)
+				return nil
+			},
+		},
+		{
+			// deleteVolume with a bound volume. Check the claim is Lost.
+			"5-4 - delete volume",
+			newVolumeArray("volume5-4", "1Gi", "uid5-4", "claim5-4", v1.VolumeBound, v1.PersistentVolumeReclaimRetain, classEmpty),
+			novolumes,
+			newClaimArray("claim5-4", "uid5-4", "1Gi", "volume5-4", v1.ClaimBound, nil, annBoundByController, annBindCompleted),
+			newClaimArray("claim5-4", "uid5-4", "1Gi", "volume5-4", v1.ClaimLost, nil, annBoundByController, annBindCompleted),
+			[]string{"Warning ClaimLost"}, noerrors,
+			// Custom test function that generates a delete event
+			func(ctrl *PersistentVolumeController, reactor *volumeReactor, test controllerTest) error {
+				obj := ctrl.volumes.store.List()[0]
+				volume := obj.(*v1.PersistentVolume)
+				reactor.deleteVolumeEvent(volume)
+				return nil
+			},
+		},
+	}
+
+	for _, test := range tests {
+		glog.V(4).Infof("starting test %q", test.name)
+
+		// Initialize the controller
+		client := &fake.Clientset{}
+
+		fakeVolumeWatch := watch.NewFake()
+		client.PrependWatchReactor("persistentvolumes", core.DefaultWatchReactor(fakeVolumeWatch, nil))
+		fakeClaimWatch := watch.NewFake()
+		client.PrependWatchReactor("persistentvolumeclaims", core.DefaultWatchReactor(fakeClaimWatch, nil))
+		client.PrependWatchReactor("storageclasses", core.DefaultWatchReactor(watch.NewFake(), nil))
+
+		informers := informers.NewSharedInformerFactory(client, controller.NoResyncPeriodFunc())
+		ctrl, err := newTestController(client, informers, true)
+		if err != nil {
+			t.Fatalf("Test %q construct persistent volume failed: %v", test.name, err)
+		}
+
+		reactor := newVolumeReactor(client, ctrl, fakeVolumeWatch, fakeClaimWatch, test.errors)
+		for _, claim := range test.initialClaims {
+			reactor.claims[claim.Name] = claim
+			go func(claim *v1.PersistentVolumeClaim) {
+				fakeClaimWatch.Add(claim)
+			}(claim)
+		}
+		for _, volume := range test.initialVolumes {
+			reactor.volumes[volume.Name] = volume
+			go func(volume *v1.PersistentVolume) {
+				fakeVolumeWatch.Add(volume)
+			}(volume)
+		}
+
+		// Start the controller
+		stopCh := make(chan struct{})
+		informers.Start(stopCh)
+		go ctrl.Run(stopCh)
+
+		// Wait for the controller to pass initial sync and fill its caches.
+		for !ctrl.volumeListerSynced() ||
+			!ctrl.claimListerSynced() ||
+			len(ctrl.claims.ListKeys()) < len(test.initialClaims) ||
+			len(ctrl.volumes.store.ListKeys()) < len(test.initialVolumes) {
+
+			time.Sleep(10 * time.Millisecond)
+		}
+		glog.V(4).Infof("controller synced, starting test")
+
+		// Call the tested function
+		err = test.test(ctrl, reactor, test)
+		if err != nil {
+			t.Errorf("Test %q initial test call failed: %v", test.name, err)
+		}
+		// Simulate a periodic resync, just in case some events arrived in a
+		// wrong order.
+		ctrl.resync()
+
+		err = reactor.waitTest(test)
+		if err != nil {
+			t.Errorf("Failed to run test %s: %v", test.name, err)
+		}
+		close(stopCh)
+
+		evaluateTestResults(ctrl, reactor, test, t)
+	}
+}
+
+func storeVersion(t *testing.T, prefix string, c cache.Store, version string, expectedReturn bool) {
+	pv := newVolume("pvName", "1Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimDelete, classEmpty)
+	pv.ResourceVersion = version
+	ret, err := storeObjectUpdate(c, pv, "volume")
+	if err != nil {
+		t.Errorf("%s: expected storeObjectUpdate to succeed, got: %v", prefix, err)
+	}
+	if expectedReturn != ret {
+		t.Errorf("%s: expected storeObjectUpdate to return %v, got: %v", prefix, expectedReturn, ret)
+	}
+
+	// find the stored version
+
+	pvObj, found, err := c.GetByKey("pvName")
+	if err != nil {
+		t.Errorf("expected volume 'pvName' in the cache, got error instead: %v", err)
+	}
+	if !found {
+		t.Errorf("expected volume 'pvName' in the cache but it was not found")
+	}
+	pv, ok := pvObj.(*v1.PersistentVolume)
+	if !ok {
+		t.Errorf("expected volume in the cache, got different object instead: %#v", pvObj)
+	}
+
+	if ret {
+		if pv.ResourceVersion != version {
+			t.Errorf("expected volume with version %s in the cache, got %s instead", version, pv.ResourceVersion)
+		}
+	} else {
+		if pv.ResourceVersion == version {
+			t.Errorf("expected volume with version other than %s in the cache, got %s instead", version, pv.ResourceVersion)
+		}
+	}
+}
+
+// TestControllerCache tests func storeObjectUpdate()
+func TestControllerCache(t *testing.T) {
+	// Cache under test
+	c := cache.NewStore(cache.DeletionHandlingMetaNamespaceKeyFunc)
+
+	// Store new PV
+	storeVersion(t, "Step1", c, "1", true)
+	// Store the same PV
+	storeVersion(t, "Step2", c, "1", true)
+	// Store newer PV
+	storeVersion(t, "Step3", c, "2", true)
+	// Store older PV - simulating old "PV updated" event or periodic sync with
+	// old data
+	storeVersion(t, "Step4", c, "1", false)
+	// Store newer PV - test integer parsing ("2" > "10" as string,
+	// while 2 < 10 as integers)
+	storeVersion(t, "Step5", c, "10", true)
+}
+
+func TestControllerCacheParsingError(t *testing.T) {
+	c := cache.NewStore(cache.DeletionHandlingMetaNamespaceKeyFunc)
+	// There must be something in the cache to compare with
+	storeVersion(t, "Step1", c, "1", true)
+
+	pv := newVolume("pvName", "1Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimDelete, classEmpty)
+	pv.ResourceVersion = "xxx"
+	_, err := storeObjectUpdate(c, pv, "volume")
+	if err == nil {
+		t.Errorf("Expected parsing error, got nil instead")
+	}
+}
+
+func addVolumeAnnotation(volume *v1.PersistentVolume, annName, annValue string) *v1.PersistentVolume {
+	if volume.Annotations == nil {
+		volume.Annotations = make(map[string]string)
+	}
+	volume.Annotations[annName] = annValue
+	return volume
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/recycle_test.go

@@ -0,0 +1,197 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"errors"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+)
+
+// Test single call to syncVolume, expecting recycling to happen.
+// 1. Fill in the controller with initial data
+// 2. Call the syncVolume *once*.
+// 3. Compare resulting volumes with expected volumes.
+func TestRecycleSync(t *testing.T) {
+	tests := []controllerTest{
+		{
+			// recycle volume bound by controller
+			"6-1 - successful recycle",
+			newVolumeArray("volume6-1", "1Gi", "uid6-1", "claim6-1", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty, annBoundByController),
+			newVolumeArray("volume6-1", "1Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			// Inject recycler into the controller and call syncVolume. The
+			// recycler simulates one recycle() call that succeeds.
+			wrapTestWithReclaimCalls(operationRecycle, []error{nil}, testSyncVolume),
+		},
+		{
+			// recycle volume bound by user
+			"6-2 - successful recycle with prebound volume",
+			newVolumeArray("volume6-2", "1Gi", "uid6-2", "claim6-2", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			newVolumeArray("volume6-2", "1Gi", "", "claim6-2", v1.VolumeAvailable, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			// Inject recycler into the controller and call syncVolume. The
+			// recycler simulates one recycle() call that succeeds.
+			wrapTestWithReclaimCalls(operationRecycle, []error{nil}, testSyncVolume),
+		},
+		{
+			// recycle failure - plugin not found
+			"6-3 - plugin not found",
+			newVolumeArray("volume6-3", "1Gi", "uid6-3", "claim6-3", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			withMessage("No recycler plugin found for the volume!", newVolumeArray("volume6-3", "1Gi", "uid6-3", "claim6-3", v1.VolumeFailed, v1.PersistentVolumeReclaimRecycle, classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedRecycle"}, noerrors, testSyncVolume,
+		},
+		{
+			// recycle failure - Recycle returns error
+			"6-4 - newRecycler returns error",
+			newVolumeArray("volume6-4", "1Gi", "uid6-4", "claim6-4", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			withMessage("Recycle failed: Mock plugin error: no recycleCalls configured", newVolumeArray("volume6-4", "1Gi", "uid6-4", "claim6-4", v1.VolumeFailed, v1.PersistentVolumeReclaimRecycle, classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedRecycle"}, noerrors,
+			wrapTestWithReclaimCalls(operationRecycle, []error{}, testSyncVolume),
+		},
+		{
+			// recycle failure - recycle returns error
+			"6-5 - recycle returns error",
+			newVolumeArray("volume6-5", "1Gi", "uid6-5", "claim6-5", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			withMessage("Recycle failed: Mock recycle error", newVolumeArray("volume6-5", "1Gi", "uid6-5", "claim6-5", v1.VolumeFailed, v1.PersistentVolumeReclaimRecycle, classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedRecycle"}, noerrors,
+			wrapTestWithReclaimCalls(operationRecycle, []error{errors.New("Mock recycle error")}, testSyncVolume),
+		},
+		{
+			// recycle success(?) - volume is deleted before doRecycle() starts
+			"6-6 - volume is deleted before recycling",
+			newVolumeArray("volume6-6", "1Gi", "uid6-6", "claim6-6", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			novolumes,
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			wrapTestWithInjectedOperation(wrapTestWithReclaimCalls(operationRecycle, []error{}, testSyncVolume), func(ctrl *PersistentVolumeController, reactor *volumeReactor) {
+				// Delete the volume before recycle operation starts
+				reactor.lock.Lock()
+				delete(reactor.volumes, "volume6-6")
+				reactor.lock.Unlock()
+			}),
+		},
+		{
+			// recycle success(?) - volume is recycled by previous recycler just
+			// at the time new doRecycle() starts. This simulates "volume no
+			// longer needs recycling, skipping".
+			"6-7 - volume is deleted before recycling",
+			newVolumeArray("volume6-7", "1Gi", "uid6-7", "claim6-7", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty, annBoundByController),
+			newVolumeArray("volume6-7", "1Gi", "", "", v1.VolumeAvailable, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			wrapTestWithInjectedOperation(wrapTestWithReclaimCalls(operationRecycle, []error{}, testSyncVolume), func(ctrl *PersistentVolumeController, reactor *volumeReactor) {
+				// Mark the volume as Available before the recycler starts
+				reactor.lock.Lock()
+				volume := reactor.volumes["volume6-7"]
+				volume.Spec.ClaimRef = nil
+				volume.Status.Phase = v1.VolumeAvailable
+				volume.Annotations = nil
+				reactor.lock.Unlock()
+			}),
+		},
+		{
+			// recycle success(?) - volume bound by user is recycled by previous
+			// recycler just at the time new doRecycle() starts. This simulates
+			// "volume no longer needs recycling, skipping" with volume bound by
+			// user.
+			"6-8 - prebound volume is deleted before recycling",
+			newVolumeArray("volume6-8", "1Gi", "uid6-8", "claim6-8", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			newVolumeArray("volume6-8", "1Gi", "", "claim6-8", v1.VolumeAvailable, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			noclaims,
+			noclaims,
+			noevents, noerrors,
+			wrapTestWithInjectedOperation(wrapTestWithReclaimCalls(operationRecycle, []error{}, testSyncVolume), func(ctrl *PersistentVolumeController, reactor *volumeReactor) {
+				// Mark the volume as Available before the recycler starts
+				reactor.lock.Lock()
+				volume := reactor.volumes["volume6-8"]
+				volume.Spec.ClaimRef.UID = ""
+				volume.Status.Phase = v1.VolumeAvailable
+				reactor.lock.Unlock()
+			}),
+		},
+		{
+			// recycle success - volume bound by user is recycled, while a new
+			// claim is created with another UID.
+			"6-9 - prebound volume is recycled while the claim exists",
+			newVolumeArray("volume6-9", "1Gi", "uid6-9", "claim6-9", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			newVolumeArray("volume6-9", "1Gi", "", "claim6-9", v1.VolumeAvailable, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			newClaimArray("claim6-9", "uid6-9-x", "10Gi", "", v1.ClaimPending, nil),
+			newClaimArray("claim6-9", "uid6-9-x", "10Gi", "", v1.ClaimPending, nil),
+			noevents, noerrors,
+			// Inject recycler into the controller and call syncVolume. The
+			// recycler simulates one recycle() call that succeeds.
+			wrapTestWithReclaimCalls(operationRecycle, []error{nil}, testSyncVolume),
+		},
+		{
+			// volume has unknown reclaim policy - failure expected
+			"6-10 - unknown reclaim policy",
+			newVolumeArray("volume6-10", "1Gi", "uid6-10", "claim6-10", v1.VolumeBound, "Unknown", classEmpty),
+			withMessage("Volume has unrecognized PersistentVolumeReclaimPolicy", newVolumeArray("volume6-10", "1Gi", "uid6-10", "claim6-10", v1.VolumeFailed, "Unknown", classEmpty)),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeUnknownReclaimPolicy"}, noerrors, testSyncVolume,
+		},
+	}
+	runSyncTests(t, tests, []*storage.StorageClass{})
+}
+
+// Test multiple calls to syncClaim/syncVolume and periodic sync of all
+// volume/claims. The test follows this pattern:
+// 0. Load the controller with initial data.
+// 1. Call controllerTest.testCall() once as in TestSync()
+// 2. For all volumes/claims changed by previous syncVolume/syncClaim calls,
+//    call appropriate syncVolume/syncClaim (simulating "volume/claim changed"
+//    events). Go to 2. if these calls change anything.
+// 3. When all changes are processed and no new changes were made, call
+//    syncVolume/syncClaim on all volumes/claims (simulating "periodic sync").
+// 4. If some changes were done by step 3., go to 2. (simulation of
+//    "volume/claim updated" events, eventually performing step 3. again)
+// 5. When 3. does not do any changes, finish the tests and compare final set
+//    of volumes/claims with expected claims/volumes and report differences.
+// Some limit of calls in enforced to prevent endless loops.
+func TestRecycleMultiSync(t *testing.T) {
+	tests := []controllerTest{
+		{
+			// recycle failure - recycle returns error. The controller should
+			// try again.
+			"7-1 - recycle returns error",
+			newVolumeArray("volume7-1", "1Gi", "uid7-1", "claim7-1", v1.VolumeBound, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			newVolumeArray("volume7-1", "1Gi", "", "claim7-1", v1.VolumeAvailable, v1.PersistentVolumeReclaimRecycle, classEmpty),
+			noclaims,
+			noclaims,
+			[]string{"Warning VolumeFailedRecycle"}, noerrors,
+			wrapTestWithReclaimCalls(operationRecycle, []error{errors.New("Mock recycle error"), nil}, testSyncVolume),
+		},
+	}
+
+	runMultisyncTests(t, tests, []*storage.StorageClass{}, "")
+}

vendor/k8s.io/kubernetes/pkg/controller/volume/persistentvolume/volume_host.go

@@ -0,0 +1,102 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 persistentvolume
+
+import (
+	"fmt"
+	"net"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+	"k8s.io/kubernetes/pkg/util/io"
+	"k8s.io/kubernetes/pkg/util/mount"
+	vol "k8s.io/kubernetes/pkg/volume"
+)
+
+// VolumeHost interface implementation for PersistentVolumeController.
+
+var _ vol.VolumeHost = &PersistentVolumeController{}
+
+func (ctrl *PersistentVolumeController) GetPluginDir(pluginName string) string {
+	return ""
+}
+
+func (ctrl *PersistentVolumeController) GetPodVolumeDir(podUID types.UID, pluginName string, volumeName string) string {
+	return ""
+}
+
+func (ctrl *PersistentVolumeController) GetPodPluginDir(podUID types.UID, pluginName string) string {
+	return ""
+}
+
+func (ctrl *PersistentVolumeController) GetKubeClient() clientset.Interface {
+	return ctrl.kubeClient
+}
+
+func (ctrl *PersistentVolumeController) NewWrapperMounter(volName string, spec vol.Spec, pod *v1.Pod, opts vol.VolumeOptions) (vol.Mounter, error) {
+	return nil, fmt.Errorf("PersistentVolumeController.NewWrapperMounter is not implemented")
+}
+
+func (ctrl *PersistentVolumeController) NewWrapperUnmounter(volName string, spec vol.Spec, podUID types.UID) (vol.Unmounter, error) {
+	return nil, fmt.Errorf("PersistentVolumeController.NewWrapperMounter is not implemented")
+}
+
+func (ctrl *PersistentVolumeController) GetCloudProvider() cloudprovider.Interface {
+	return ctrl.cloud
+}
+
+func (ctrl *PersistentVolumeController) GetMounter(pluginName string) mount.Interface {
+	return nil
+}
+
+func (ctrl *PersistentVolumeController) GetWriter() io.Writer {
+	return nil
+}
+
+func (ctrl *PersistentVolumeController) GetHostName() string {
+	return ""
+}
+
+func (ctrl *PersistentVolumeController) GetHostIP() (net.IP, error) {
+	return nil, fmt.Errorf("PersistentVolumeController.GetHostIP() is not implemented")
+}
+
+func (ctrl *PersistentVolumeController) GetNodeAllocatable() (v1.ResourceList, error) {
+	return v1.ResourceList{}, nil
+}
+
+func (adc *PersistentVolumeController) GetSecretFunc() func(namespace, name string) (*v1.Secret, error) {
+	return func(_, _ string) (*v1.Secret, error) {
+		return nil, fmt.Errorf("GetSecret unsupported in PersistentVolumeController")
+	}
+}
+
+func (adc *PersistentVolumeController) GetConfigMapFunc() func(namespace, name string) (*v1.ConfigMap, error) {
+	return func(_, _ string) (*v1.ConfigMap, error) {
+		return nil, fmt.Errorf("GetConfigMap unsupported in PersistentVolumeController")
+	}
+}
+
+func (adc *PersistentVolumeController) GetExec(pluginName string) mount.Exec {
+	return mount.NewOsExec()
+}
+
+func (ctrl *PersistentVolumeController) GetNodeLabels() (map[string]string, error) {
+	return nil, fmt.Errorf("GetNodeLabels() unsupported in PersistentVolumeController")
+}