new changes

tests/e2e/csi_snapshot_basic.go

@@ -2124,8 +2124,15 @@ var _ = ginkgo.Describe("Volume Snapshot Basic Test", func() {
  defer cancel()
 
  ginkgo.By("Create storage class")
- storageclass, err := createStorageClass(client, scParameters, nil, "", "", false, scName)
+ storageclass, err := createStorageClass(client, scParameters, nil, "", "", true, scName)
  gomega.Expect(err).NotTo(gomega.HaveOccurred())
+
+ if !vanillaCluster {
+ var allowExpansion = true
+ storageclass.AllowVolumeExpansion = &allowExpansion
+ storageclass, err = client.StorageV1().StorageClasses().Update(ctx, storageclass, metav1.UpdateOptions{})
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }
  defer func() {
  if vanillaCluster {
  err := client.StorageV1().StorageClasses().Delete(ctx, storageclass.Name, *metav1.NewDeleteOptions(0))
@@ -2182,7 +2189,7 @@ var _ = ginkgo.Describe("Volume Snapshot Basic Test", func() {
  }()
 
  ginkgo.By("Create PVC from dynamic volume snapshot but with a different higher size")
- pvcSpec := getPersistentVolumeClaimSpecWithDatasource(namespace, defaultrqLimit, storageclass, nil,
+ pvcSpec := getPersistentVolumeClaimSpecWithDatasource(namespace, defaultrqLimit, storageclass, labelsMap,
  v1.ReadWriteOnce, volumeSnapshot.Name, snapshotapigroup)
  pvclaim2, err := fpv.CreatePVC(ctx, client, namespace, pvcSpec)
  gomega.Expect(err).NotTo(gomega.HaveOccurred())
@@ -3067,7 +3074,7 @@ var _ = ginkgo.Describe("Volume Snapshot Basic Test", func() {
 
  ginkgo.By("Creating a new deployment from the restored pvc")
  dep2, err := createDeployment(ctx, client, 1, labelsMap2, nil, namespace,
- []*v1.PersistentVolumeClaim{pvclaim2}, "", false, busyBoxImageOnGcr)
+ []*v1.PersistentVolumeClaim{pvclaim2}, execRWXCommandPod2, false, busyBoxImageOnGcr)
  gomega.Expect(err).NotTo(gomega.HaveOccurred())
  defer func() {
  ginkgo.By("Delete Deployment-2")
@@ -3084,7 +3091,11 @@ var _ = ginkgo.Describe("Volume Snapshot Basic Test", func() {
 
  ginkgo.By("Verify the volume is accessible and Read/write is possible")
  output := readFileFromPod(namespace, pod2.Name, filePathPod1)
- gomega.Expect(strings.Contains(output, "Hello message from Pod1")).NotTo(gomega.BeFalse())
+ //gomega.Expect(strings.Contains(output, "Hello message from Pod1")).NotTo(gomega.BeFalse())
+
+ writeDataOnFileFromPod(namespace, pod2.Name, filePathPod1, "Hello message from Pod2")
+ output = readFileFromPod(namespace, pod2.Name, filePathPod1)
+ gomega.Expect(strings.Contains(output, "Hello message from Pod2")).NotTo(gomega.BeFalse())
 
  ginkgo.By("Delete dynamic volume snapshot")
  snapshotCreated, snapshotContentCreated, err = deleteVolumeSnapshot(ctx, snapc, namespace,
@@ -3117,7 +3128,6 @@ var _ = ginkgo.Describe("Volume Snapshot Basic Test", func() {
  storageclass.AllowVolumeExpansion = &allowExpansion
  storageclass, err = client.StorageV1().StorageClasses().Update(ctx, storageclass, metav1.UpdateOptions{})
  gomega.Expect(err).NotTo(gomega.HaveOccurred())
-
  defer func() {
  if vanillaCluster {
  err := client.StorageV1().StorageClasses().Delete(ctx, storageclass.Name, *metav1.NewDeleteOptions(0))
@@ -6915,7 +6925,7 @@ var _ = ginkgo.Describe("Volume Snapshot Basic Test", func() {
  }()
 
  ginkgo.By("Create PVC")
- pvclaim, persistentVolumes := createPVCAndQueryVolumeInCNS(ctx, client, namespace, labelsMap, "",
+ pvclaim, persistentVolumes := createPVCAndQueryVolumeInCNS(ctx, client, namespace, labelsMap, v1.ReadWriteOnce,
  diskSize, storageclass, true)
  volHandle = persistentVolumes[0].Spec.CSI.VolumeHandle
  if guestCluster {

tests/e2e/csi_snapshot_utils.go

@@ -315,17 +315,17 @@ func deleteVolumeSnapshot(ctx context.Context, snapc *snapclient.Clientset, name
  }
  snapshotContentCreated := false
 
- // framework.Logf("Verify snapshot entry %v is deleted from CNS for volume %v", snapshotID, volHandle)
- // err = waitForCNSSnapshotToBeDeleted(volHandle, snapshotID)
- // if err != nil {
- //  return snapshotCreated, snapshotContentCreated, err
- // }
-
- // framework.Logf("Verify snapshot entry is deleted from CNS")
- // err = verifySnapshotIsDeletedInCNS(volHandle, snapshotID)
- // if err != nil {
- //  return snapshotCreated, snapshotContentCreated, err
- // }
+ framework.Logf("Verify snapshot entry %v is deleted from CNS for volume %v", snapshotID, volHandle)
+ err = waitForCNSSnapshotToBeDeleted(volHandle, snapshotID)
+ if err != nil {
+ return snapshotCreated, snapshotContentCreated, err
+ }
+
+ framework.Logf("Verify snapshot entry is deleted from CNS")
+ err = verifySnapshotIsDeletedInCNS(volHandle, snapshotID)
+ if err != nil {
+ return snapshotCreated, snapshotContentCreated, err
+ }
 
  framework.Logf("Deleting volume snapshot again to check 'Not found' error")
  deleteVolumeSnapshotWithPandoraWait(ctx, snapc, namespace, volumeSnapshot.Name, pandoraSyncWaitTime)

tests/e2e/snapshot_vmservice_vm.go

@@ -271,6 +271,139 @@ var _ bool = ginkgo.Describe("[vmsvc] vm service with csi vol tests", func() {
  }
  }()
 
+ ginkgo.By("Create a dynamic volume snapshot")
+ volumeSnapshot, snapshotContent, snapshotCreated,
+ snapshotContentCreated, snapshotId, _, err := createDynamicVolumeSnapshot(ctx, namespace, snapc, volumeSnapshotClass,
+ pvc, volHandle, diskSize, true)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ defer func() {
+ if snapshotContentCreated {
+ err = deleteVolumeSnapshotContent(ctx, snapshotContent, snapc, pandoraSyncWaitTime)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }
+
+ if snapshotCreated {
+ framework.Logf("Deleting volume snapshot")
+ deleteVolumeSnapshotWithPandoraWait(ctx, snapc, namespace, volumeSnapshot.Name, pandoraSyncWaitTime)
+
+ framework.Logf("Wait till the volume snapshot is deleted")
+ err = waitForVolumeSnapshotContentToBeDeletedWithPandoraWait(ctx, snapc,
+ *volumeSnapshot.Status.BoundVolumeSnapshotContentName, pandoraSyncWaitTime)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }
+ }()
+
+ ginkgo.By("Delete dynamic volume snapshot")
+ snapshotCreated, snapshotContentCreated, err = deleteVolumeSnapshot(ctx, snapc, namespace,
+ volumeSnapshot, pandoraSyncWaitTime, volHandle, snapshotId)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+
+ })
+
+ /*
+ Dynamic PVC → VM → Snapshot
+ Steps:
+ 1. Create a PVC using the storage class (storage policy) tagged to the supervisor namespace
+ 2. Wait for PVC to reach the Bound state.
+ 3. Create a VM service VM using the PVC created in step #1
+ 4. Wait for the VM service to be up and in the powered-on state.
+ 5. Once the VM is up, verify that the volume is accessible inside the VM
+ 6. Write some data into the volume.
+ 7. Get VolumeSnapshotClass "volumesnapshotclass-delete" from supervisor cluster
+ 8. Create a volume snapshot for the PVC created in step #1.
+ 9. Snapshot Verification: Execute and verify the steps mentioned in the Create snapshot mandatory checks
+ 10. Verify CNS metadata for a PVC
+ 11. Cleanup: Execute and verify the steps mentioned in the Delete snapshot mandatory checks
+ */
+
+ ginkgo.It("TC2VM", func() {
+
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ ginkgo.By("Create a storageclass")
+ storageclass, err := client.StorageV1().StorageClasses().Get(ctx, storageClassName, metav1.GetOptions{})
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+
+ ginkgo.By("Create a PVC")
+ pvc, err := createPVC(ctx, client, namespace, nil, "", storageclass, "")
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ ginkgo.By("Waiting for all claims to be in bound state")
+ pvs, err := fpv.WaitForPVClaimBoundPhase(ctx, client, []*v1.PersistentVolumeClaim{pvc}, pollTimeout)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ pv := pvs[0]
+ volHandle := pv.Spec.CSI.VolumeHandle
+ gomega.Expect(volHandle).NotTo(gomega.BeEmpty())
+ defer func() {
+ ginkgo.By("Delete PVCs")
+ err = fpv.DeletePersistentVolumeClaim(ctx, client, pvc.Name, namespace)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+
+ ginkgo.By("Waiting for CNS volumes to be deleted")
+ err = e2eVSphere.waitForCNSVolumeToBeDeleted(volHandle)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }()
+
+ ginkgo.By("Creating VM bootstrap data")
+ // creating a secret for vm credentials
+ secretName := createBootstrapSecretForVmsvcVms(ctx, client, namespace)
+ defer func() {
+ ginkgo.By("Deleting VM bootstrap data")
+ err := client.CoreV1().Secrets(namespace).Delete(ctx, secretName, *metav1.NewDeleteOptions(0))
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }()
+
+ ginkgo.By("Creating VM")
+ vm := createVmServiceVmWithPvcs(
+ ctx, vmopC, namespace, vmClass, []*v1.PersistentVolumeClaim{pvc}, vmi, storageClassName, secretName)
+ defer func() {
+ ginkgo.By("Deleting VM")
+ err = vmopC.Delete(ctx, &vmopv1.VirtualMachine{ObjectMeta: metav1.ObjectMeta{
+ Name: vm.Name,
+ Namespace: namespace,
+ }})
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }()
+
+ ginkgo.By("Creating loadbalancing service for ssh with the VM")
+ vmlbsvc := createService4Vm(ctx, vmopC, namespace, vm.Name)
+ defer func() {
+ ginkgo.By("Deleting loadbalancing service for ssh with the VM")
+ err = vmopC.Delete(ctx, &vmopv1.VirtualMachineService{ObjectMeta: metav1.ObjectMeta{
+ Name: vmlbsvc.Name,
+ Namespace: namespace,
+ }})
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }()
+
+ ginkgo.By("Wait for VM to come up and get an IP")
+ vmIp, err := waitNgetVmsvcVmIp(ctx, vmopC, namespace, vm.Name)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+
+ ginkgo.By("Wait and verify PVCs are attached to the VM")
+ gomega.Expect(waitNverifyPvcsAreAttachedToVmsvcVm(ctx, vmopC, cnsopC, vm,
+ []*v1.PersistentVolumeClaim{pvc})).NotTo(gomega.HaveOccurred())
+
+ ginkgo.By("Verify PVCs are accessible to the VM")
+ ginkgo.By("Write some IO to the CSI volumes and read it back from them and verify the data integrity")
+ vm, err = getVmsvcVM(ctx, vmopC, vm.Namespace, vm.Name) // refresh vm info
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ for i, vol := range vm.Status.Volumes {
+ volFolder := formatNVerifyPvcIsAccessible(vol.DiskUuid, i+1, vmIp)
+ verifyDataIntegrityOnVmDisk(vmIp, volFolder)
+ }
+
+ ginkgo.By("Create volume snapshot class")
+ volumeSnapshotClass, err := createVolumeSnapshotClass(ctx, snapc, deletionPolicy)
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ defer func() {
+ if vanillaCluster {
+ err = snapc.SnapshotV1().VolumeSnapshotClasses().Delete(ctx, volumeSnapshotClass.Name,
+ metav1.DeleteOptions{})
+ gomega.Expect(err).NotTo(gomega.HaveOccurred())
+ }
+ }()
+
  ginkgo.By("Create a dynamic volume snapshot")
  volumeSnapshot, snapshotContent, snapshotCreated,
  snapshotContentCreated, snapshotId, _, err := createDynamicVolumeSnapshot(ctx, namespace, snapc, volumeSnapshotClass,