From e0ab1dcfe2583d92bce244d4dcb7e33ca7c53e3b Mon Sep 17 00:00:00 2001 From: Jan Safranek Date: Fri, 17 Mar 2017 14:08:39 +0100 Subject: [PATCH] Use storage.k8s.io/v1 in tests instead of v1beta1 --- test/e2e/BUILD | 3 +- test/e2e/volume_provisioning.go | 131 +++++++++++++++++++------------- 2 files changed, 79 insertions(+), 55 deletions(-) diff --git a/test/e2e/BUILD b/test/e2e/BUILD index 74c55158eaf..875e7f6e8d2 100644 --- a/test/e2e/BUILD +++ b/test/e2e/BUILD @@ -116,8 +116,9 @@ go_library( "//pkg/apis/extensions/v1beta1:go_default_library", "//pkg/apis/rbac/v1beta1:go_default_library", "//pkg/apis/settings/v1alpha1:go_default_library", + "//pkg/apis/storage/v1:go_default_library", + "//pkg/apis/storage/v1/util:go_default_library", "//pkg/apis/storage/v1beta1:go_default_library", - "//pkg/apis/storage/v1beta1/util:go_default_library", "//pkg/client/clientset_generated/clientset:go_default_library", "//pkg/client/clientset_generated/clientset/typed/core/v1:go_default_library", "//pkg/client/clientset_generated/clientset/typed/extensions/v1beta1:go_default_library", diff --git a/test/e2e/volume_provisioning.go b/test/e2e/volume_provisioning.go index 3e837fee7db..cce1445a0c9 100644 --- a/test/e2e/volume_provisioning.go +++ b/test/e2e/volume_provisioning.go @@ -26,8 +26,9 @@ import ( "k8s.io/apiserver/pkg/authentication/serviceaccount" "k8s.io/kubernetes/pkg/api/v1" rbacv1beta1 "k8s.io/kubernetes/pkg/apis/rbac/v1beta1" - storage "k8s.io/kubernetes/pkg/apis/storage/v1beta1" - storageutil "k8s.io/kubernetes/pkg/apis/storage/v1beta1/util" + storage "k8s.io/kubernetes/pkg/apis/storage/v1" + storageutil "k8s.io/kubernetes/pkg/apis/storage/v1/util" + storagebeta "k8s.io/kubernetes/pkg/apis/storage/v1beta1" "k8s.io/kubernetes/pkg/client/clientset_generated/clientset" "k8s.io/kubernetes/test/e2e/framework" @@ -104,46 +105,44 @@ var _ = framework.KubeDescribe("Dynamic provisioning", func() { ns = f.Namespace.Name }) - /* - TODO: enable when GKE is updated with the new API - framework.KubeDescribe("DynamicProvisioner", func() { - It("should create and delete persistent volumes [Slow] [Volume]", func() { - framework.SkipUnlessProviderIs("openstack", "gce", "aws", "gke", "vsphere") + framework.KubeDescribe("DynamicProvisioner", func() { + It("should create and delete persistent volumes [Slow] [Volume]", func() { + framework.SkipUnlessProviderIs("openstack", "gce", "aws", "gke") - By("creating a StorageClass") - class := newStorageClass("", "internal") - class, err := c.StorageV1beta1().StorageClasses().Create(class) - defer c.StorageV1beta1().StorageClasses().Delete(class.Name, nil) - Expect(err).NotTo(HaveOccurred()) + By("creating a StorageClass") + class := newStorageClass("", "internal") + class, err := c.StorageV1().StorageClasses().Create(class) + defer c.StorageV1().StorageClasses().Delete(class.Name, nil) + Expect(err).NotTo(HaveOccurred()) - By("creating a claim with a dynamic provisioning annotation") - claim := newClaim(ns) - claim.Spec.StorageClassName = &class.Name + By("creating a claim with a dynamic provisioning annotation") + claim := newClaim(ns) + claim.Spec.StorageClassName = &class.Name - defer func() { - c.Core().PersistentVolumeClaims(ns).Delete(claim.Name, nil) - }() - claim, err = c.Core().PersistentVolumeClaims(ns).Create(claim) - Expect(err).NotTo(HaveOccurred()) + defer func() { + c.Core().PersistentVolumeClaims(ns).Delete(claim.Name, nil) + }() + claim, err = c.Core().PersistentVolumeClaims(ns).Create(claim) + Expect(err).NotTo(HaveOccurred()) - if framework.ProviderIs("vsphere") { - // vsphere provider does not allocate volumes in 1GiB chunks, so setting expected size - // equal to requestedSize - testDynamicProvisioning(c, claim, requestedSize) - } else { - // Expected size of the volume is 2GiB, because the other three supported cloud - // providers allocate volumes in 1GiB chunks. - testDynamicProvisioning(c, claim, "2Gi") - } - }) + if framework.ProviderIs("vsphere") { + // vsphere provider does not allocate volumes in 1GiB chunks, so setting expected size + // equal to requestedSize + testDynamicProvisioning(c, claim, requestedSize) + } else { + // Expected size of the volume is 2GiB, because the other three supported cloud + // providers allocate volumes in 1GiB chunks. + testDynamicProvisioning(c, claim, "2Gi") + } }) - */ + }) + framework.KubeDescribe("DynamicProvisioner Beta", func() { It("should create and delete persistent volumes [Slow] [Volume]", func() { framework.SkipUnlessProviderIs("openstack", "gce", "aws", "gke") By("creating a StorageClass") - class := newStorageClass("", "beta") + class := newBetaStorageClass("", "beta") _, err := c.StorageV1beta1().StorageClasses().Create(class) defer c.StorageV1beta1().StorageClasses().Delete(class.Name, nil) Expect(err).NotTo(HaveOccurred()) @@ -199,17 +198,13 @@ var _ = framework.KubeDescribe("Dynamic provisioning", func() { sc := newStorageClass("", suffix) // Set an unmanaged zone. sc.Parameters = map[string]string{"zone": unmanagedZone} - sc, err = c.StorageV1beta1().StorageClasses().Create(sc) - defer Expect(c.StorageV1beta1().StorageClasses().Delete(sc.Name, nil)).To(Succeed()) + sc, err = c.StorageV1().StorageClasses().Create(sc) + defer Expect(c.StorageV1().StorageClasses().Delete(sc.Name, nil)).To(Succeed()) Expect(err).NotTo(HaveOccurred()) By("Creating a claim and expecting it to timeout") pvc := newClaim(ns) - // TODO: switch to attribute when GKE is updated - pvc.Annotations = map[string]string{ - v1.BetaStorageClassAnnotation: sc.Name, - } - //pvc.Spec.StorageClassName = &className + pvc.Spec.StorageClassName = &sc.Name pvc, err = c.Core().PersistentVolumeClaims(ns).Create(pvc) defer Expect(c.Core().PersistentVolumeClaims(ns).Delete(pvc.Name, nil)).To(Succeed()) Expect(err).NotTo(HaveOccurred()) @@ -261,16 +256,19 @@ var _ = framework.KubeDescribe("Dynamic provisioning", func() { By("creating a StorageClass") class := newStorageClass(externalPluginName, "external") - _, err = c.StorageV1beta1().StorageClasses().Create(class) - defer c.StorageV1beta1().StorageClasses().Delete(class.Name, nil) + _, err = c.StorageV1().StorageClasses().Create(class) + defer c.StorageV1().StorageClasses().Delete(class.Name, nil) Expect(err).NotTo(HaveOccurred()) By("creating a claim with a dynamic provisioning annotation") claim := newClaim(ns) className := class.Name - // TODO: switch to attribute when GKE is updated - claim.Annotations = map[string]string{v1.BetaStorageClassAnnotation: className} - //claim.Spec.StorageClassName = &className + // the external provisioner understands Beta only right now, see + // https://github.com/kubernetes-incubator/external-storage/issues/37 + // claim.Spec.StorageClassName = &className + claim.Annotations = map[string]string{ + v1.BetaStorageClassAnnotation: className, + } defer func() { c.Core().PersistentVolumeClaims(ns).Delete(claim.Name, nil) }() @@ -362,11 +360,13 @@ func updateDefaultStorageClass(c clientset.Interface, defaultStr string) { if defaultStr == "" { delete(sc.Annotations, storageutil.BetaIsDefaultStorageClassAnnotation) + delete(sc.Annotations, storageutil.IsDefaultStorageClassAnnotation) } else { if sc.Annotations == nil { sc.Annotations = make(map[string]string) } sc.Annotations[storageutil.BetaIsDefaultStorageClassAnnotation] = defaultStr + sc.Annotations[storageutil.IsDefaultStorageClassAnnotation] = defaultStr } sc, err = c.StorageV1().StorageClasses().Update(sc) @@ -447,18 +447,23 @@ func runInPodWithVolume(c clientset.Interface, ns, claimName, command string) { framework.ExpectNoError(framework.WaitForPodSuccessInNamespaceSlow(c, pod.Name, pod.Namespace)) } +func getDefaultPluginName() string { + switch { + case framework.ProviderIs("gke"), framework.ProviderIs("gce"): + return "kubernetes.io/gce-pd" + case framework.ProviderIs("aws"): + return "kubernetes.io/aws-ebs" + case framework.ProviderIs("openstack"): + return "kubernetes.io/cinder" + case framework.ProviderIs("vsphere"): + return "kubernetes.io/vsphere-volume" + } + return "" +} + func newStorageClass(pluginName, suffix string) *storage.StorageClass { if pluginName == "" { - switch { - case framework.ProviderIs("gke"), framework.ProviderIs("gce"): - pluginName = "kubernetes.io/gce-pd" - case framework.ProviderIs("aws"): - pluginName = "kubernetes.io/aws-ebs" - case framework.ProviderIs("openstack"): - pluginName = "kubernetes.io/cinder" - case framework.ProviderIs("vsphere"): - pluginName = "kubernetes.io/vsphere-volume" - } + pluginName = getDefaultPluginName() } return &storage.StorageClass{ @@ -472,6 +477,24 @@ func newStorageClass(pluginName, suffix string) *storage.StorageClass { } } +// TODO: remove when storage.k8s.io/v1beta1 and beta storage class annotations +// are removed. +func newBetaStorageClass(pluginName, suffix string) *storagebeta.StorageClass { + if pluginName == "" { + pluginName = getDefaultPluginName() + } + + return &storagebeta.StorageClass{ + TypeMeta: metav1.TypeMeta{ + Kind: "StorageClass", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "myclass-" + suffix, + }, + Provisioner: pluginName, + } +} + func startExternalProvisioner(c clientset.Interface, ns string) *v1.Pod { podClient := c.Core().Pods(ns)