Add support for PersistentVolumeClaim in Attacher/Detacher interface

cmd/kubelet/app/plugins.go

@@ -44,7 +44,6 @@ import (
 	"k8s.io/kubernetes/pkg/volume/host_path"
 	"k8s.io/kubernetes/pkg/volume/iscsi"
 	"k8s.io/kubernetes/pkg/volume/nfs"
-	"k8s.io/kubernetes/pkg/volume/persistent_claim"
 	"k8s.io/kubernetes/pkg/volume/rbd"
 	"k8s.io/kubernetes/pkg/volume/secret"
 	// Cloud providers
@@ -72,7 +71,6 @@ func ProbeVolumePlugins(pluginDir string) []volume.VolumePlugin {
 	allPlugins = append(allPlugins, secret.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, iscsi.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, glusterfs.ProbeVolumePlugins()...)
-	allPlugins = append(allPlugins, persistent_claim.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, rbd.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, cinder.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, cephfs.ProbeVolumePlugins()...)

pkg/kubelet/kubelet_test.go

@@ -565,6 +565,166 @@ func TestCleanupOrphanedVolumes(t *testing.T) {
 	}
 }
 
+func TestGetPersistentVolumeBySpec(t *testing.T) {
+	testKubelet := newTestKubelet(t)
+	kubelet := testKubelet.kubelet
+	kubeClient := testKubelet.fakeKubeClient
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.PersistentVolumeClaimList{Items: []api.PersistentVolumeClaim{}}).ReactionChain
+
+	// Test claim does not exist
+	_, err := kubelet.getPersistentVolumeByClaimName("myclaim", "test")
+	if err == nil {
+		t.Errorf("Expected claim to not be found")
+	}
+
+	// Test claim found not bound.
+	claim := api.PersistentVolumeClaim{
+		ObjectMeta: api.ObjectMeta{
+			Name:      "myclaim",
+			Namespace: "test",
+		},
+	}
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.PersistentVolumeClaimList{Items: []api.PersistentVolumeClaim{
+		claim,
+	}}).ReactionChain
+
+	_, err = kubelet.getPersistentVolumeByClaimName("myclaim", "test")
+	if err == nil {
+		t.Errorf("Expected a claim not bound error to occur")
+	}
+
+	// Test claim found, bound but PV does not exist
+	claim = api.PersistentVolumeClaim{
+		ObjectMeta: api.ObjectMeta{
+			Name:      "myclaim",
+			Namespace: "test",
+			UID:       types.UID("myclaimUID123"),
+		},
+		Spec: api.PersistentVolumeClaimSpec{
+			VolumeName: "myrealvol",
+		},
+	}
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.PersistentVolumeClaimList{Items: []api.PersistentVolumeClaim{
+		claim,
+	}}).ReactionChain
+
+	_, err = kubelet.getPersistentVolumeByClaimName("myclaim", "test")
+	if err == nil {
+		t.Errorf("Expected PV not found error to occur")
+	}
+
+	// Test volume found but not bound.
+	volume := api.PersistentVolume{
+		ObjectMeta: api.ObjectMeta{
+			Name: "myrealvol",
+		},
+	}
+	kubeClient.ReactionChain = fake.NewSimpleClientset(
+		&api.PersistentVolumeClaimList{Items: []api.PersistentVolumeClaim{
+			claim,
+		}},
+		&api.PersistentVolumeList{Items: []api.PersistentVolume{
+			volume,
+		}},
+	).ReactionChain
+	_, err = kubelet.getPersistentVolumeByClaimName("myclaim", "test")
+	if err == nil {
+		t.Errorf("Expected PV not bound error to occur")
+	}
+
+	// Test volume found and incorrectly bound
+	volume = api.PersistentVolume{
+		ObjectMeta: api.ObjectMeta{
+			Name: "myrealvol",
+		},
+		Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{
+				Name:      "myclaim",
+				Namespace: "test",
+				UID:       types.UID("veryWrongUID"),
+			},
+		},
+	}
+	kubeClient.ReactionChain = fake.NewSimpleClientset(
+		&api.PersistentVolumeClaimList{Items: []api.PersistentVolumeClaim{
+			claim,
+		}},
+		&api.PersistentVolumeList{Items: []api.PersistentVolume{
+			volume,
+		}},
+	).ReactionChain
+	_, err = kubelet.getPersistentVolumeByClaimName("myclaim", "test")
+	if err == nil {
+		t.Errorf("Expected wrong UID error to occur")
+	}
+
+	// Test volume found and correctly bound
+	volume = api.PersistentVolume{
+		ObjectMeta: api.ObjectMeta{
+			Name: "myrealvol",
+		},
+		Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{
+				Name:      "myclaim",
+				Namespace: "test",
+				UID:       types.UID("myclaimUID123"),
+			},
+		},
+	}
+	kubeClient.ReactionChain = fake.NewSimpleClientset(
+		&api.PersistentVolumeClaimList{Items: []api.PersistentVolumeClaim{
+			claim,
+		}},
+		&api.PersistentVolumeList{Items: []api.PersistentVolume{
+			volume,
+		}},
+	).ReactionChain
+
+	foundVolume, err := kubelet.getPersistentVolumeByClaimName("myclaim", "test")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+
+	if foundVolume.Name != volume.Name {
+		t.Errorf("Found incorrect volume expected %v, but got %v", volume, foundVolume)
+	}
+}
+
+func TestApplyPersistentVolumeAnnotations(t *testing.T) {
+	testKubelet := newTestKubelet(t)
+	kubelet := testKubelet.kubelet
+
+	pod := &api.Pod{}
+
+	pv := &api.PersistentVolume{
+		ObjectMeta: api.ObjectMeta{
+			Name: "pv",
+			Annotations: map[string]string{
+				volumeGidAnnotationKey: "12345",
+			},
+		},
+		Spec: api.PersistentVolumeSpec{
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				GCEPersistentDisk: &api.GCEPersistentDiskVolumeSource{},
+			},
+			ClaimRef: &api.ObjectReference{
+				Name: "claim",
+				UID:  types.UID("abc123"),
+			},
+		},
+	}
+
+	kubelet.applyPersistentVolumeAnnotations(pv, pod)
+
+	if pod.Spec.SecurityContext == nil {
+		t.Errorf("Pod SecurityContext was not set")
+	}
+
+	if pod.Spec.SecurityContext.SupplementalGroups[0] != 12345 {
+		t.Errorf("Pod's SupplementalGroups list does not contain expect group")
+	}
+}
+
 type stubVolume struct {
 	path string
 	volume.MetricsNil

pkg/kubelet/volumes.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"path"
+	"strconv"
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
@@ -34,6 +35,10 @@ import (
 	"k8s.io/kubernetes/pkg/volume"
 )
 
+const (
+	volumeGidAnnotationKey = "pv.beta.kubernetes.io/gid"
+)
+
 // This just exports required functions from kubelet proper, for use by volume
 // plugins.
 type volumeHost struct {
@@ -126,8 +131,20 @@ func (kl *Kubelet) mountExternalVolumes(pod *api.Pod) (kubecontainer.VolumeMap,
 			return nil, err
 		}
 
+		var volSpec *volume.Spec
+		if pod.Spec.Volumes[i].VolumeSource.PersistentVolumeClaim != nil {
+			claimName := pod.Spec.Volumes[i].PersistentVolumeClaim.ClaimName
+			pv, err := kl.getPersistentVolumeByClaimName(claimName, pod.Namespace)
+			if err != nil {
+				glog.Errorf("Could not find persistentVolume for claim %s err %v", claimName, err)
+				return nil, err
+			}
+			kl.applyPersistentVolumeAnnotations(pv, pod)
+			volSpec = volume.NewSpecFromPersistentVolume(pv, pod.Spec.Volumes[i].PersistentVolumeClaim.ReadOnly)
+		} else {
+			volSpec = volume.NewSpecFromVolume(&pod.Spec.Volumes[i])
+		}
 		// Try to use a plugin for this volume.
-		volSpec := volume.NewSpecFromVolume(&pod.Spec.Volumes[i])
 		mounter, err := kl.newVolumeMounterFromPlugins(volSpec, pod, volume.VolumeOptions{RootContext: rootContext})
 		if err != nil {
 			glog.Errorf("Could not create volume mounter for pod %s: %v", pod.UID, err)
@@ -137,7 +154,7 @@ func (kl *Kubelet) mountExternalVolumes(pod *api.Pod) (kubecontainer.VolumeMap,
 		// some volumes require attachment before mounter's setup.
 		// The plugin can be nil, but non-nil errors are legitimate errors.
 		// For non-nil plugins, Attachment to a node is required before Mounter's setup.
-		attacher, err := kl.newVolumeAttacherFromPlugins(volSpec, pod, volume.VolumeOptions{RootContext: rootContext})
+		attacher, err := kl.newVolumeAttacherFromPlugins(volSpec, pod)
 		if err != nil {
 			glog.Errorf("Could not create volume attacher for pod %s: %v", pod.UID, err)
 			return nil, err
@@ -153,7 +170,7 @@ func (kl *Kubelet) mountExternalVolumes(pod *api.Pod) (kubecontainer.VolumeMap,
 				return nil, err
 			}
 
-			deviceMountPath := attacher.GetDeviceMountPath(&volumeHost{kl}, volSpec)
+			deviceMountPath := attacher.GetDeviceMountPath(volSpec)
 			if err = attacher.MountDevice(volSpec, devicePath, deviceMountPath, kl.mounter); err != nil {
 				return nil, err
 			}
@@ -163,7 +180,7 @@ func (kl *Kubelet) mountExternalVolumes(pod *api.Pod) (kubecontainer.VolumeMap,
 		if err != nil {
 			return nil, err
 		}
-		podVolumes[volSpec.Volume.Name] = kubecontainer.VolumeInfo{Mounter: mounter}
+		podVolumes[pod.Spec.Volumes[i].Name] = kubecontainer.VolumeInfo{Mounter: mounter}
 	}
 	return podVolumes, nil
 }
@@ -270,6 +287,57 @@ func (kl *Kubelet) getPodVolumesFromDisk() map[string]cleaner {
 	return currentVolumes
 }
 
+func (kl *Kubelet) getPersistentVolumeByClaimName(claimName string, namespace string) (*api.PersistentVolume, error) {
+	claim, err := kl.kubeClient.Core().PersistentVolumeClaims(namespace).Get(claimName)
+	if err != nil {
+		glog.Errorf("Error finding claim: %+v\n", claimName)
+		return nil, err
+	}
+	glog.V(5).Infof("Found claim %v ", claim)
+
+	if claim.Spec.VolumeName == "" {
+		return nil, fmt.Errorf("The claim %+v is not yet bound to a volume", claimName)
+	}
+
+	pv, err := kl.kubeClient.Core().PersistentVolumes().Get(claim.Spec.VolumeName)
+	if err != nil {
+		glog.Errorf("Error finding persistent volume for claim: %+v\n", claimName)
+		return nil, err
+	}
+
+	if pv.Spec.ClaimRef == nil {
+		return nil, fmt.Errorf("The volume is not yet bound to the claim. Expected to find the bind on volume.Spec.ClaimRef: %+v", pv)
+	}
+
+	if pv.Spec.ClaimRef.UID != claim.UID {
+		return nil, fmt.Errorf("Expected volume.Spec.ClaimRef.UID %+v but have %+v", pv.Spec.ClaimRef.UID, claim.UID)
+	}
+
+	return pv, nil
+}
+
+func (kl *Kubelet) applyPersistentVolumeAnnotations(pv *api.PersistentVolume, pod *api.Pod) error {
+	// If a GID annotation is provided set the GID attribute.
+	if volumeGid, ok := pv.Annotations[volumeGidAnnotationKey]; ok {
+		gid, err := strconv.ParseInt(volumeGid, 10, 64)
+		if err != nil {
+			return fmt.Errorf("Invalid value for %s %v", volumeGidAnnotationKey, err)
+		}
+
+		if pod.Spec.SecurityContext == nil {
+			pod.Spec.SecurityContext = &api.PodSecurityContext{}
+		}
+		for _, existingGid := range pod.Spec.SecurityContext.SupplementalGroups {
+			if gid == existingGid {
+				return nil
+			}
+		}
+		pod.Spec.SecurityContext.SupplementalGroups = append(pod.Spec.SecurityContext.SupplementalGroups, gid)
+	}
+
+	return nil
+}
+
 // newVolumeMounterFromPlugins attempts to find a plugin by volume spec, pod
 // and volume options and then creates a Mounter.
 // Returns a valid Unmounter or an error.
@@ -293,7 +361,7 @@ func (kl *Kubelet) newVolumeMounterFromPlugins(spec *volume.Spec, pod *api.Pod,
 //  - an error if no plugin was found for the volume
 //    or the attacher failed to instantiate
 //  - nil if there is no appropriate attacher for this volume
-func (kl *Kubelet) newVolumeAttacherFromPlugins(spec *volume.Spec, pod *api.Pod, opts volume.VolumeOptions) (volume.Attacher, error) {
+func (kl *Kubelet) newVolumeAttacherFromPlugins(spec *volume.Spec, pod *api.Pod) (volume.Attacher, error) {
 	plugin, err := kl.volumePluginMgr.FindAttachablePluginBySpec(spec)
 	if err != nil {
 		return nil, fmt.Errorf("can't use volume plugins for %s: %v", spec.Name(), err)

pkg/volume/persistent_claim/OWNERS

-maintainers:
-- childsb

pkg/volume/persistent_claim/doc.go

-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 persistent_claim contains the internal representation of persistent
-// volume claims.
-package persistent_claim

pkg/volume/persistent_claim/persistent_claim.go

-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 persistent_claim
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/golang/glog"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/types"
-	"k8s.io/kubernetes/pkg/volume"
-)
-
-func ProbeVolumePlugins() []volume.VolumePlugin {
-	return []volume.VolumePlugin{&persistentClaimPlugin{host: nil}}
-}
-
-type persistentClaimPlugin struct {
-	host     volume.VolumeHost
-	readOnly bool
-}
-
-var _ volume.VolumePlugin = &persistentClaimPlugin{}
-
-const (
-	persistentClaimPluginName = "kubernetes.io/persistent-claim"
-	volumeGidAnnotationKey    = "pv.beta.kubernetes.io/gid"
-)
-
-func (plugin *persistentClaimPlugin) Init(host volume.VolumeHost) error {
-	plugin.host = host
-	return nil
-}
-
-func (plugin *persistentClaimPlugin) Name() string {
-	return persistentClaimPluginName
-}
-
-func (plugin *persistentClaimPlugin) CanSupport(spec *volume.Spec) bool {
-	return spec.Volume != nil && spec.Volume.PersistentVolumeClaim != nil
-}
-
-func (plugin *persistentClaimPlugin) NewMounter(spec *volume.Spec, pod *api.Pod, opts volume.VolumeOptions) (volume.Mounter, error) {
-	claim, err := plugin.host.GetKubeClient().Core().PersistentVolumeClaims(pod.Namespace).Get(spec.Volume.PersistentVolumeClaim.ClaimName)
-	if err != nil {
-		glog.Errorf("Error finding claim: %+v\n", spec.Volume.PersistentVolumeClaim.ClaimName)
-		return nil, err
-	}
-
-	if claim.Spec.VolumeName == "" {
-		return nil, fmt.Errorf("The claim %+v is not yet bound to a volume", claim.Name)
-	}
-
-	pv, err := plugin.host.GetKubeClient().Core().PersistentVolumes().Get(claim.Spec.VolumeName)
-	if err != nil {
-		glog.Errorf("Error finding persistent volume for claim: %+v\n", claim.Name)
-		return nil, err
-	}
-
-	if pv.Spec.ClaimRef == nil {
-		glog.Errorf("The volume is not yet bound to the claim. Expected to find the bind on volume.Spec.ClaimRef: %+v", pv)
-		return nil, err
-	}
-
-	if pv.Spec.ClaimRef.UID != claim.UID {
-		glog.Errorf("Expected volume.Spec.ClaimRef.UID %+v but have %+v", pv.Spec.ClaimRef.UID, claim.UID)
-		return nil, err
-	}
-
-	// If a GID annotation is provided set the GID attribute.
-	if volumeGid, ok := pv.Annotations[volumeGidAnnotationKey]; ok {
-		gid, err := strconv.ParseInt(volumeGid, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("Invalid value for %s %v", volumeGidAnnotationKey, err)
-		}
-
-		if pod.Spec.SecurityContext == nil {
-			pod.Spec.SecurityContext = &api.PodSecurityContext{}
-		}
-		pod.Spec.SecurityContext.SupplementalGroups = append(pod.Spec.SecurityContext.SupplementalGroups, gid)
-	}
-
-	mounter, err := plugin.host.NewWrapperMounter(claim.Spec.VolumeName, *volume.NewSpecFromPersistentVolume(pv, spec.ReadOnly), pod, opts)
-	if err != nil {
-		glog.Errorf("Error creating mounter for claim: %+v\n", claim.Name)
-		return nil, err
-	}
-
-	return mounter, nil
-}
-
-func (plugin *persistentClaimPlugin) NewUnmounter(_ string, _ types.UID) (volume.Unmounter, error) {
-	return nil, fmt.Errorf("This will never be called directly. The PV backing this claim has a unmounter.  Kubelet uses that unmounter, not this one, when removing orphaned volumes.")
-}

pkg/volume/testing/testing.go

@@ -273,7 +273,7 @@ func (fv *FakeVolume) WaitForAttach(spec *Spec, spectimeout time.Duration) (stri
 	return "", nil
 }
 
-func (fv *FakeVolume) GetDeviceMountPath(host VolumeHost, spec *Spec) string {
+func (fv *FakeVolume) GetDeviceMountPath(spec *Spec) string {
 	fv.GetDeviceMountPathCallCount++
 	return ""
 }

pkg/volume/volume.go

@@ -143,7 +143,7 @@ type Attacher interface {
 	// GetDeviceMountPath returns a path where the device should
 	// be mounted after it is attached. This is a global mount
 	// point which should be bind mounted for individual volumes.
-	GetDeviceMountPath(host VolumeHost, spec *Spec) string
+	GetDeviceMountPath(spec *Spec) string
 
 	// MountDevice mounts the disk to a global path which
 	// individual pods can then bind mount