PV & PVC Client implementation

pkg/registry/persistentvolume/doc.go

@@ -0,0 +1,17 @@
+/*
+Copyright 2014 Google Inc. 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 persistentvolume

pkg/registry/persistentvolume/etcd/etcd.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2015 Google Inc. 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 etcd
+
+import (
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic"
+	etcdgeneric "github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic/etcd"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/persistentvolume"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/tools"
+)
+
+// rest implements a RESTStorage for persistentvolumes against etcd
+type REST struct {
+	*etcdgeneric.Etcd
+}
+
+// NewREST returns a RESTStorage object that will work against PersistentVolume objects.
+func NewStorage(h tools.EtcdHelper) (*REST, *StatusREST) {
+	prefix := "/registry/persistentvolumes"
+	store := &etcdgeneric.Etcd{
+		NewFunc:     func() runtime.Object { return &api.PersistentVolume{} },
+		NewListFunc: func() runtime.Object { return &api.PersistentVolumeList{} },
+		KeyRootFunc: func(ctx api.Context) string {
+			return prefix
+		},
+		KeyFunc: func(ctx api.Context, name string) (string, error) {
+			return prefix + "/" + name, nil
+		},
+		ObjectNameFunc: func(obj runtime.Object) (string, error) {
+			return obj.(*api.PersistentVolume).Name, nil
+		},
+		PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
+			return persistentvolume.MatchPersistentVolumes(label, field)
+		},
+		EndpointName: "persistentvolume",
+
+		Helper: h,
+	}
+
+	store.CreateStrategy = persistentvolume.Strategy
+	store.UpdateStrategy = persistentvolume.Strategy
+	store.ReturnDeletedObject = true
+
+	statusStore := *store
+	statusStore.UpdateStrategy = persistentvolume.StatusStrategy
+
+	return &REST{store}, &StatusREST{store: &statusStore}
+}
+
+// StatusREST implements the REST endpoint for changing the status of a persistentvolume.
+type StatusREST struct {
+	store *etcdgeneric.Etcd
+}
+
+func (r *StatusREST) New() runtime.Object {
+	return &api.PersistentVolume{}
+}
+
+// Update alters the status subset of an object.
+func (r *StatusREST) Update(ctx api.Context, obj runtime.Object) (runtime.Object, bool, error) {
+	return r.store.Update(ctx, obj)
+}

pkg/registry/persistentvolume/etcd/etcd_test.go

@@ -0,0 +1,342 @@
+/*
+Copyright 2015 Google Inc. 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 etcd
+
+import (
+	"testing"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/resource"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/rest/resttest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/registrytest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/tools"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
+
+	"github.com/coreos/go-etcd/etcd"
+)
+
+type testRegistry struct {
+	*registrytest.GenericRegistry
+}
+
+func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient, tools.EtcdHelper) {
+	fakeEtcdClient := tools.NewFakeEtcdClient(t)
+	fakeEtcdClient.TestIndex = true
+	helper := tools.NewEtcdHelper(fakeEtcdClient, latest.Codec)
+	storage, statusStorage := NewStorage(helper)
+	return storage, statusStorage, fakeEtcdClient, helper
+}
+
+func validNewPersistentVolume(name string) *api.PersistentVolume {
+	pv := &api.PersistentVolume{
+		ObjectMeta: api.ObjectMeta{
+			Name: name,
+		},
+		Spec: api.PersistentVolumeSpec{
+			Capacity: api.ResourceList{
+				api.ResourceName(api.ResourceStorage): resource.MustParse("10G"),
+			},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				HostPath: &api.HostPathVolumeSource{Path: "/foo"},
+			},
+		},
+	}
+	return pv
+}
+
+func validChangedPersistentVolume() *api.PersistentVolume {
+	pv := validNewPersistentVolume("foo")
+	pv.ResourceVersion = "1"
+	return pv
+}
+
+func TestCreate(t *testing.T) {
+	storage, _, fakeEtcdClient, _ := newStorage(t)
+	test := resttest.New(t, storage, fakeEtcdClient.SetError)
+	pv := validNewPersistentVolume("foo")
+	pv.ObjectMeta = api.ObjectMeta{}
+	test.TestCreate(
+		// valid
+		pv,
+		// invalid
+		&api.PersistentVolume{
+			ObjectMeta: api.ObjectMeta{Name: "*BadName!"},
+		},
+	)
+}
+
+func TestDelete(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeEtcdClient, _ := newStorage(t)
+	test := resttest.New(t, storage, fakeEtcdClient.SetError)
+
+	pv := validChangedPersistentVolume()
+	key, _ := storage.KeyFunc(ctx, pv.Name)
+	createFn := func() runtime.Object {
+		fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{
+			R: &etcd.Response{
+				Node: &etcd.Node{
+					Value:         runtime.EncodeOrDie(latest.Codec, pv),
+					ModifiedIndex: 1,
+				},
+			},
+		}
+		return pv
+	}
+	gracefulSetFn := func() bool {
+		if fakeEtcdClient.Data[key].R.Node == nil {
+			return false
+		}
+		return fakeEtcdClient.Data[key].R.Node.TTL == 30
+	}
+	test.TestDeleteNoGraceful(createFn, gracefulSetFn)
+}
+
+func TestEtcdListPersistentVolumes(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeClient, _ := newStorage(t)
+	key := storage.KeyRootFunc(ctx)
+	fakeClient.Data[key] = tools.EtcdResponseWithError{
+		R: &etcd.Response{
+			Node: &etcd.Node{
+				Nodes: []*etcd.Node{
+					{
+						Value: runtime.EncodeOrDie(latest.Codec, validNewPersistentVolume("foo")),
+					},
+					{
+						Value: runtime.EncodeOrDie(latest.Codec, validNewPersistentVolume("bar")),
+					},
+				},
+			},
+		},
+		E: nil,
+	}
+
+	pvObj, err := storage.List(ctx, labels.Everything(), fields.Everything())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	pvs := pvObj.(*api.PersistentVolumeList)
+
+	if len(pvs.Items) != 2 || pvs.Items[0].Name != "foo" || pvs.Items[1].Name != "bar" {
+		t.Errorf("Unexpected persistentVolume list: %#v", pvs)
+	}
+}
+
+func TestEtcdGetPersistentVolumes(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeClient, _ := newStorage(t)
+	persistentVolume := validNewPersistentVolume("foo")
+	name := persistentVolume.Name
+	key, _ := storage.KeyFunc(ctx, name)
+	fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, persistentVolume), 0)
+
+	response, err := fakeClient.Get(key, false, false)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	var persistentVolumeOut api.PersistentVolume
+	err = latest.Codec.DecodeInto([]byte(response.Node.Value), &persistentVolumeOut)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	obj, err := storage.Get(ctx, name)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	got := obj.(*api.PersistentVolume)
+
+	persistentVolume.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion
+	if e, a := persistentVolume, got; !api.Semantic.DeepEqual(*e, *a) {
+		t.Errorf("Unexpected persistentVolume: %#v, expected %#v", e, a)
+	}
+}
+
+func TestListEmptyPersistentVolumesList(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeClient, _ := newStorage(t)
+	fakeClient.ChangeIndex = 1
+	key := storage.KeyRootFunc(ctx)
+	fakeClient.Data[key] = tools.EtcdResponseWithError{
+		R: &etcd.Response{},
+		E: fakeClient.NewError(tools.EtcdErrorCodeNotFound),
+	}
+
+	persistentVolume, err := storage.List(ctx, labels.Everything(), fields.Everything())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(persistentVolume.(*api.PersistentVolumeList).Items) != 0 {
+		t.Errorf("Unexpected non-zero pod list: %#v", persistentVolume)
+	}
+	if persistentVolume.(*api.PersistentVolumeList).ResourceVersion != "1" {
+		t.Errorf("Unexpected resource version: %#v", persistentVolume)
+	}
+}
+
+func TestListPersistentVolumesList(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeClient, _ := newStorage(t)
+	fakeClient.ChangeIndex = 1
+	key := storage.KeyRootFunc(ctx)
+	fakeClient.Data[key] = tools.EtcdResponseWithError{
+		R: &etcd.Response{
+			Node: &etcd.Node{
+				Nodes: []*etcd.Node{
+					{
+						Value: runtime.EncodeOrDie(latest.Codec, &api.PersistentVolume{
+							ObjectMeta: api.ObjectMeta{Name: "foo"},
+						}),
+					},
+					{
+						Value: runtime.EncodeOrDie(latest.Codec, &api.PersistentVolume{
+							ObjectMeta: api.ObjectMeta{Name: "bar"},
+						}),
+					},
+				},
+			},
+		},
+	}
+
+	persistentVolumeObj, err := storage.List(ctx, labels.Everything(), fields.Everything())
+	persistentVolumeList := persistentVolumeObj.(*api.PersistentVolumeList)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(persistentVolumeList.Items) != 2 {
+		t.Errorf("Unexpected persistentVolume list: %#v", persistentVolumeList)
+	}
+	if persistentVolumeList.Items[0].Name != "foo" {
+		t.Errorf("Unexpected persistentVolume: %#v", persistentVolumeList.Items[0])
+	}
+	if persistentVolumeList.Items[1].Name != "bar" {
+		t.Errorf("Unexpected persistentVolume: %#v", persistentVolumeList.Items[1])
+	}
+}
+
+func TestPersistentVolumesDecode(t *testing.T) {
+	storage, _, _, _ := newStorage(t)
+	expected := validNewPersistentVolume("foo")
+	body, err := latest.Codec.Encode(expected)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	actual := storage.New()
+	if err := latest.Codec.DecodeInto(body, actual); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if !api.Semantic.DeepEqual(expected, actual) {
+		t.Errorf("mismatch: %s", util.ObjectDiff(expected, actual))
+	}
+}
+
+func TestEtcdUpdatePersistentVolumes(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeClient, _ := newStorage(t)
+	persistentVolume := validChangedPersistentVolume()
+
+	key, _ := storage.KeyFunc(ctx, "foo")
+	fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, validNewPersistentVolume("foo")), 0)
+
+	_, _, err := storage.Update(ctx, persistentVolume)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	response, err := fakeClient.Get(key, false, false)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	var persistentVolumeOut api.PersistentVolume
+	err = latest.Codec.DecodeInto([]byte(response.Node.Value), &persistentVolumeOut)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	persistentVolume.ObjectMeta.ResourceVersion = persistentVolumeOut.ObjectMeta.ResourceVersion
+	if !api.Semantic.DeepEqual(persistentVolume, &persistentVolumeOut) {
+		t.Errorf("Unexpected persistentVolume: %#v, expected %#v", &persistentVolumeOut, persistentVolume)
+	}
+}
+
+func TestDeletePersistentVolumes(t *testing.T) {
+	ctx := api.NewDefaultContext()
+	storage, _, fakeClient, _ := newStorage(t)
+	persistentVolume := validNewPersistentVolume("foo")
+	name := persistentVolume.Name
+	key, _ := storage.KeyFunc(ctx, name)
+	fakeClient.ChangeIndex = 1
+	fakeClient.Data[key] = tools.EtcdResponseWithError{
+		R: &etcd.Response{
+			Node: &etcd.Node{
+				Value:         runtime.EncodeOrDie(latest.Codec, persistentVolume),
+				ModifiedIndex: 1,
+				CreatedIndex:  1,
+			},
+		},
+	}
+	_, err := storage.Delete(ctx, name, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestEtcdUpdateStatus(t *testing.T) {
+	storage, statusStorage, fakeClient, helper := newStorage(t)
+	ctx := api.NewDefaultContext()
+	fakeClient.TestIndex = true
+
+	key, _ := storage.KeyFunc(ctx, "foo")
+	pvStart := validNewPersistentVolume("foo")
+	fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, pvStart), 1)
+
+	pvIn := &api.PersistentVolume{
+		ObjectMeta: api.ObjectMeta{
+			Name:            "foo",
+			ResourceVersion: "1",
+		},
+		Status: api.PersistentVolumeStatus{
+			Phase: api.VolumeBound,
+		},
+	}
+
+	expected := *pvStart
+	expected.ResourceVersion = "2"
+	expected.Labels = pvIn.Labels
+	expected.Status = pvIn.Status
+
+	_, _, err := statusStorage.Update(ctx, pvIn)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	var pvOut api.PersistentVolume
+	if err := helper.ExtractObj(key, &pvOut, false); err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	if !api.Semantic.DeepEqual(expected, pvOut) {
+		t.Errorf("unexpected object: %s", util.ObjectDiff(expected, pvOut))
+	}
+}

pkg/registry/persistentvolume/registry.go

@@ -0,0 +1,87 @@
+/*
+Copyright 2015 Google Inc. 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 persistentvolume
+
+import (
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/rest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
+)
+
+// Registry is an interface implemented by things that know how to store PersistentVolume objects.
+type Registry interface {
+	// ListPersistentVolumes obtains a list of persistentVolumes having labels which match selector.
+	ListPersistentVolumes(ctx api.Context, selector labels.Selector) (*api.PersistentVolumeList, error)
+	// Watch for new/changed/deleted persistentVolumes
+	WatchPersistentVolumes(ctx api.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error)
+	// Get a specific persistentVolume
+	GetPersistentVolume(ctx api.Context, persistentVolumeID string) (*api.PersistentVolume, error)
+	// Create a persistentVolume based on a specification.
+	CreatePersistentVolume(ctx api.Context, persistentVolume *api.PersistentVolume) error
+	// Update an existing persistentVolume
+	UpdatePersistentVolume(ctx api.Context, persistentVolume *api.PersistentVolume) error
+	// Delete an existing persistentVolume
+	DeletePersistentVolume(ctx api.Context, persistentVolumeID string) error
+}
+
+// storage puts strong typing around storage calls
+type storage struct {
+	rest.StandardStorage
+}
+
+// NewRegistry returns a new Registry interface for the given Storage. Any mismatched
+// types will panic.
+func NewRegistry(s rest.StandardStorage) Registry {
+	return &storage{s}
+}
+
+func (s *storage) ListPersistentVolumes(ctx api.Context, label labels.Selector) (*api.PersistentVolumeList, error) {
+	obj, err := s.List(ctx, label, fields.Everything())
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*api.PersistentVolumeList), nil
+}
+
+func (s *storage) WatchPersistentVolumes(ctx api.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) {
+	return s.Watch(ctx, label, field, resourceVersion)
+}
+
+func (s *storage) GetPersistentVolume(ctx api.Context, persistentVolumeID string) (*api.PersistentVolume, error) {
+	obj, err := s.Get(ctx, persistentVolumeID)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*api.PersistentVolume), nil
+}
+
+func (s *storage) CreatePersistentVolume(ctx api.Context, persistentVolume *api.PersistentVolume) error {
+	_, err := s.Create(ctx, persistentVolume)
+	return err
+}
+
+func (s *storage) UpdatePersistentVolume(ctx api.Context, persistentVolume *api.PersistentVolume) error {
+	_, _, err := s.Update(ctx, persistentVolume)
+	return err
+}
+
+func (s *storage) DeletePersistentVolume(ctx api.Context, persistentVolumeID string) error {
+	_, err := s.Delete(ctx, persistentVolumeID, nil)
+	return err
+}

pkg/registry/persistentvolume/rest.go

@@ -0,0 +1,109 @@
+/*
+Copyright 2014 Google Inc. 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 persistentvolume
+
+import (
+	"fmt"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/validation"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/fielderrors"
+)
+
+// persistentvolumeStrategy implements behavior for PersistentVolume objects
+type persistentvolumeStrategy struct {
+	runtime.ObjectTyper
+	api.NameGenerator
+}
+
+// Strategy is the default logic that applies when creating and updating PersistentVolume
+// objects via the REST API.
+var Strategy = persistentvolumeStrategy{api.Scheme, api.SimpleNameGenerator}
+
+// NamespaceScoped is false for persistentvolumes.
+func (persistentvolumeStrategy) NamespaceScoped() bool {
+	return false
+}
+
+// ResetBeforeCreate clears fields that are not allowed to be set by end users on creation.
+func (persistentvolumeStrategy) PrepareForCreate(obj runtime.Object) {
+	pv := obj.(*api.PersistentVolume)
+	pv.Status = api.PersistentVolumeStatus{}
+}
+
+// PrepareForUpdate clears fields that are not allowed to be set by end users on update.
+func (persistentvolumeStrategy) PrepareForUpdate(obj, old runtime.Object) {
+	newPv := obj.(*api.PersistentVolume)
+	oldPv := obj.(*api.PersistentVolume)
+	newPv.Status = oldPv.Status
+}
+
+// Validate validates a new persistentvolume.
+func (persistentvolumeStrategy) Validate(obj runtime.Object) fielderrors.ValidationErrorList {
+	persistentvolume := obj.(*api.PersistentVolume)
+	return validation.ValidatePersistentVolume(persistentvolume)
+}
+
+// AllowCreateOnUpdate is false for persistentvolumes.
+func (persistentvolumeStrategy) AllowCreateOnUpdate() bool {
+	return false
+}
+
+// ValidateUpdate is the default update validation for an end user.
+func (persistentvolumeStrategy) ValidateUpdate(obj, old runtime.Object) fielderrors.ValidationErrorList {
+	return validation.ValidatePersistentVolumeUpdate(obj.(*api.PersistentVolume), old.(*api.PersistentVolume))
+}
+
+type persistentvolumeStatusStrategy struct {
+	persistentvolumeStrategy
+}
+
+var StatusStrategy = persistentvolumeStatusStrategy{Strategy}
+
+func (persistentvolumeStatusStrategy) PrepareForUpdate(obj, old runtime.Object) {
+	newPv := obj.(*api.PersistentVolume)
+	oldPv := obj.(*api.PersistentVolume)
+	newPv.Spec = oldPv.Spec
+}
+
+func (persistentvolumeStatusStrategy) ValidateUpdate(obj, old runtime.Object) fielderrors.ValidationErrorList {
+	return validation.ValidatePersistentVolumeStatusUpdate(obj.(*api.PersistentVolume), old.(*api.PersistentVolume))
+}
+
+// MatchPersistentVolume returns a generic matcher for a given label and field selector.
+func MatchPersistentVolumes(label labels.Selector, field fields.Selector) generic.Matcher {
+	return generic.MatcherFunc(func(obj runtime.Object) (bool, error) {
+		persistentvolumeObj, ok := obj.(*api.PersistentVolume)
+		if !ok {
+			return false, fmt.Errorf("not a persistentvolume")
+		}
+		fields := PersistentVolumeToSelectableFields(persistentvolumeObj)
+		return label.Matches(labels.Set(persistentvolumeObj.Labels)) && field.Matches(fields), nil
+	})
+}
+
+// PersistentVolumeToSelectableFields returns a label set that represents the object
+// TODO: fields are not labels, and the validation rules for them do not apply.
+func PersistentVolumeToSelectableFields(persistentvolume *api.PersistentVolume) labels.Set {
+	return labels.Set{
+		"name": persistentvolume.Name,
+	}
+}