Example #1
0
    def _create_consumer_pods(self, num_of_volumes):
        for i in range(num_of_volumes):
            pod_name = 'consumer-{}'.format(i)
            pvc_name = 'vol-{}'.format(i)
            pod = KubeUtils.get_fs_consumer_pod_template(pod_name, pvc_name)

            KubeUtils.create_pod(pod)
    def test_step_2_create_consumer_pods(self):
        for i in range(TestConfig.NumberOfVolumes):
            pod_name = 'consumer-{}'.format(i)
            pvc_name = 'vol-{}'.format(i)
            pod = KubeUtils.get_fs_consumer_pod_template(pod_name, pvc_name)

            KubeUtils.create_pod(pod)

        for i in range(TestConfig.NumberOfVolumes):
            pod_name = 'consumer-{}'.format(i)
            KubeUtils.wait_for_pod_to_be_running(pod_name)
Example #3
0
    def _test_extend_fs_volume(self, storage_class_name, fs_type):
        # Create PVC
        pvc_name = 'pvc-extend-fs'
        KubeUtils.create_pvc_and_wait_to_bound(self,
                                               pvc_name,
                                               storage_class_name,
                                               access_modes=['ReadWriteMany'])

        # Create Pod
        pod_name = 'extend-fs-consumer'
        pod = KubeUtils.get_fs_consumer_pod_template(pod_name, pvc_name)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))
        KubeUtils.wait_for_pod_to_be_running(pod_name)

        # Edit the PVC to increase the volume capacity
        new_size = '5Gi'
        pvc_patch = {
            'spec': {
                'resources': {
                    'requests': {
                        'storage': new_size
                    }
                },
            }
        }

        logger.info("Extending Volume {}".format(pvc_name))
        KubeUtils.patch_pvc(pvc_name, pvc_patch)

        # verify kuberentes object updated
        KubeUtils.wait_for_pvc_to_extend(pvc_name, new_size)

        # wait for NVMesh Volume to show the updated size
        nvmesh_vol_name = KubeUtils.get_nvmesh_vol_name_from_pvc_name(pvc_name)
        size_5_gib_in_bytes = 5368709120

        NVMeshUtils.wait_for_nvmesh_vol_properties(
            nvmesh_vol_name, {'capacity': size_5_gib_in_bytes},
            self,
            attempts=15)

        # check block device size in container (using lsblk)
        KubeUtils.wait_for_block_device_resize(self, pod_name, nvmesh_vol_name,
                                               '5G')

        # check file system size inside the container  (using df -h)
        expected_size = '4.9G' if fs_type == FSType.EXT4 else '5.0G'
        self._wait_for_file_system_resize(pod_name, expected_size)
    def test_block_volume(self):

        # create the PVC
        pvc_name = 'test-block-volume'
        KubeUtils.create_pvc_and_wait_to_bound(self,
                                               pvc_name,
                                               'nvmesh-raid10',
                                               volumeMode='Block')

        # Create Consumer pod
        pod_name = 'block-volume-consumer'
        pod = KubeUtils.get_block_consumer_pod_template(pod_name, pvc_name)
        KubeUtils.create_pod(pod)
        KubeUtils.wait_for_pod_to_be_running(pod_name)

        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))
    def test_block_volume_extend(self):
        # Create PVC
        pvc_name = 'pvc-extend-block'
        KubeUtils.create_pvc_and_wait_to_bound(self,
                                               pvc_name,
                                               'nvmesh-raid10',
                                               volumeMode='Block',
                                               access_modes=['ReadWriteMany'])

        # Create Pod
        pod_name = 'extend-block-consumer'
        pod = KubeUtils.get_block_consumer_pod_template(pod_name, pvc_name)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))
        KubeUtils.wait_for_pod_to_be_running(pod_name)

        # Edit the PVC to increase the volume capacity
        new_size = '5Gi'
        pvc_patch = {
            'spec': {
                'resources': {
                    'requests': {
                        'storage': new_size
                    }
                },
            }
        }

        logger.info("Extending Volume {}".format(pvc_name))
        KubeUtils.patch_pvc(pvc_name, pvc_patch)

        # verify kuberentes object updated
        KubeUtils.wait_for_pvc_to_extend(pvc_name, new_size)

        # wait for NVMesh Volume to show the updated size
        nvmesh_vol_name = KubeUtils.get_nvmesh_vol_name_from_pvc_name(pvc_name)
        size_5_gib_in_bytes = 5368709120

        NVMeshUtils.wait_for_nvmesh_vol_properties(
            nvmesh_vol_name, {'capacity': size_5_gib_in_bytes},
            self,
            attempts=15)

        # check block device size in container (using lsblk)
        KubeUtils.wait_for_block_device_resize(self, pod_name, nvmesh_vol_name,
                                               '5G')
Example #6
0
    def _test_fs_type(self, fs_type, **kwargs):
        # Create Storage class for the specific File System Type
        sc_name = self._create_storage_class_for_fs_type(fs_type, **kwargs)

        # create the PVC
        pvc_name = 'test-{}'.format(fs_type)
        KubeUtils.create_pvc_and_wait_to_bound(self, pvc_name, sc_name)

        # Create Consumer pod
        pod_name = 'consumer-{}'.format(fs_type)
        pod = KubeUtils.get_fs_consumer_pod_template(pod_name, pvc_name)
        KubeUtils.create_pod(pod)

        def cleanup_pod():
            KubeUtils.delete_pod(pod_name)
            KubeUtils.wait_for_pod_to_delete(pod_name)

        self.addCleanup(cleanup_pod)

        KubeUtils.wait_for_pod_to_be_running(pod_name)
Example #7
0
    def _check_pods_using_same_pvc_are_on_same_zone(self, storage_class_name):
        pod_names = set()
        for i in range(5):
            pod_names.add('pod-' + str(i))

        # create PVC
        pvc_name = 'topology-single-pvc-' + storage_class_name
        KubeUtils.create_pvc_with_cleanup(self,
                                          pvc_name,
                                          storage_class_name,
                                          volumeMode='Block')

        # Create Pods
        for pod_name in pod_names:
            pod = KubeUtils.get_block_consumer_pod_template(pod_name, pvc_name)
            KubeUtils.create_pod(pod)

        # cleanup
        def pods_cleanup():
            for pod_name in pod_names:
                KubeUtils.delete_pod(pod_name)

            for pod_name in pod_names:
                KubeUtils.wait_for_pod_to_delete(pod_name)

        self.addCleanup(pods_cleanup)

        for pod_name in pod_names:
            KubeUtils.wait_for_pod_to_be_running(pod_name, attempts=15)

        # collect Pod, Node and Zone data
        info = self._collect_pods_info(pod_names)

        # at least 2 different zones
        all_zones = set()

        for pod_name, pod_info in info.iteritems():
            all_zones.add(pod_info['zone'])

        print('all_zones = %s' % all_zones)
        self.assertEqual(len(all_zones), 1)
Example #8
0
    def _create_multiple_pods_each_with_own_pvc(self,
                                                storage_class_name,
                                                num_of_pods=6):
        pod_names = set()
        pvc_names = set()

        for i in range(num_of_pods):
            pod_names.add('pod-' + str(i))
            pvc_names.add('pvc-' + str(i))

        # create PVCs
        for pvc_name in pvc_names:
            KubeUtils.create_pvc_with_cleanup(self,
                                              pvc_name,
                                              storage_class_name,
                                              volumeMode='Block')

        # Create Pods
        for i in range(num_of_pods):
            pod_name = 'pod-' + str(i)
            pvc_name = 'pvc-' + str(i)
            pod = KubeUtils.get_block_consumer_pod_template(pod_name, pvc_name)
            KubeUtils.create_pod(pod)

        # pods cleanups
        def cleanup():
            for pod_name in pod_names:
                KubeUtils.delete_pod(pod_name)

            for pod_name in pod_names:
                KubeUtils.wait_for_pod_to_delete(pod_name)

        self.addCleanup(cleanup)

        for pod_name in pod_names:
            KubeUtils.wait_for_pod_to_be_running(pod_name, attempts=30)

        return pod_names
Example #9
0
    def _test_fs_type(self, fs_type):

        # Create Storage class for the specific File System Type
        sc_name = 'raid1-{}'.format(fs_type)
        sc_params = {'fsType': fs_type, 'vpg': 'DEFAULT_RAID_1_VPG'}
        KubeUtils.create_storage_class(sc_name, sc_params)
        self.addCleanup(lambda: KubeUtils.delete_storage_class(sc_name))

        # create the PVC
        pvc_name = 'test-{}'.format(fs_type)
        KubeUtils.create_pvc_and_wait_to_bound(self, pvc_name, sc_name)

        # Create Consumer pod
        pod_name = 'consumer-{}'.format(fs_type)
        pod = KubeUtils.get_fs_consumer_pod_template(pod_name, pvc_name)
        KubeUtils.create_pod(pod)

        def cleanup_pod():
            KubeUtils.delete_pod(pod_name)
            KubeUtils.wait_for_pod_to_delete(pod_name)

        self.addCleanup(cleanup_pod)

        KubeUtils.wait_for_pod_to_be_running(pod_name)
 def _create_pod_on_specific_node(self, pod_name, pvc_name, node_index):
     pod = KubeUtils.get_block_consumer_pod_template(pod_name, pvc_name)
     pod['spec']['nodeSelector'] = {'worker-index': str(node_index)}
     KubeUtils.create_pod(pod)
     self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))
    def test_mixed_access_modes(self):
        # This test creates a PV with reclaimPolicy: Retain (making sure it is not deleted when the bounded PVC is deleted)
        # Then will create PVC's with different AccessModes to use the same PV. in between some PV clean needs to be done.
        # Create Storage Class with reclaimPolicy: Retain
        sc_name = 'sc-nvmesh-retain'
        KubeUtils.create_storage_class(sc_name, {'vpg': 'DEFAULT_RAID_10_VPG'},
                                       reclaimPolicy='Retain')
        self.addCleanup(lambda: KubeUtils.delete_storage_class(sc_name))

        # Create NVMesh Volume
        nvmesh_volume_name = "vol1"
        volume = Volume(
            name=nvmesh_volume_name,
            RAIDLevel=RAIDLevels.STRIPED_AND_MIRRORED_RAID_10,
            VPG='DEFAULT_RAID_10_VPG',
            capacity=5 * GiB,
            description="Volume for CSI Driver Static Provisioning")
        err, out = NVMeshUtils.getVolumeAPI().save([volume])
        self.assertIsNone(err, 'Error Creating NVMesh Volume. %s' % err)
        create_res = out[0]
        self.assertTrue(
            create_res['success'],
            'Error Creating NVMesh Volume. %s' % create_res['error'])

        self.addCleanup(lambda: NVMeshUtils.getVolumeAPI().delete([volume]))

        # Create PV
        pv_name = 'csi-testing-pv-vol1'
        volume_size = '5Gi'

        self.create_pv_for_static_prov(nvmesh_volume_name, pv_name, sc_name,
                                       volume_size)

        # Create PVC with accessMode ReadWriteOnce
        pvc_name = 'pvc-rwo'
        KubeUtils.create_pvc_and_wait_to_bound(self,
                                               pvc_name,
                                               sc_name,
                                               access_modes=['ReadWriteOnce'],
                                               storage=volume_size,
                                               volumeMode='Filesystem')

        self.addCleanup(lambda: KubeUtils.delete_pvc(pvc_name))

        # Create Pod to create a file on the File System
        pod_name = 'pod-file-writer'
        cmd = 'echo hello > /vol/file1'
        pod = KubeUtils.get_shell_pod_template(pod_name, pvc_name, cmd)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))

        KubeUtils.wait_for_pod_to_complete(pod_name)
        KubeUtils.delete_pod_and_wait(pod_name)

        # Delete the PVC
        KubeUtils.delete_pvc(pvc_name)
        KubeUtils.wait_for_pv_to_be_released(pv_name)

        # Make PV Available for the next PVC (by removing claimRef field from the PV ==OR== deleting and recreating the PV)
        KubeUtils.delete_pv(pv_name)
        KubeUtils.wait_for_pv_to_delete(pv_name)
        self.create_pv_for_static_prov(nvmesh_volume_name, pv_name, sc_name,
                                       volume_size)

        # Create PVC With ReadOnlyMany
        pvc_name = 'pvc-rox'
        KubeUtils.create_pvc_and_wait_to_bound(self,
                                               pvc_name,
                                               sc_name,
                                               access_modes=['ReadOnlyMany'],
                                               storage=volume_size,
                                               volumeMode='Filesystem')

        self.addCleanup(lambda: KubeUtils.delete_pvc(pvc_name))

        # 7. Create 2 Pods that will read the File System - Should Succeed
        pod1_name = 'pod-file-reader1'
        cmd = 'cat /vol/file1'
        pod = KubeUtils.get_shell_pod_template(pod1_name, pvc_name, cmd)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod1_name))

        pod2_name = 'pod-file-reader2'
        pod = KubeUtils.get_shell_pod_template(pod2_name, pvc_name, cmd)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod2_name))

        KubeUtils.wait_for_pod_to_complete(pod2_name)

        # 8. Create 1 Pod that will try to write to the FileSystem - Should Fail
        pod_name = 'pod-file-writer'
        cmd = 'echo hello > /vol/file1'
        pod = KubeUtils.get_shell_pod_template(pod_name, pvc_name, cmd)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))

        KubeUtils.wait_for_pod_to_fail(pod_name)
Example #12
0
    def test_static_provisioning(self):
        # Create NVMesh Volume
        nvmesh_volume_name = "csi-testing-static-prov"
        volume = Volume(
            name=nvmesh_volume_name,
            RAIDLevel=RAIDLevels.STRIPED_AND_MIRRORED_RAID_10,
            VPG='DEFAULT_RAID_10_VPG',
            capacity=5 * GiB,
            description="Volume for CSI Driver Static Provisioning")
        err, out = NVMeshUtils.getVolumeAPI().save([volume])
        self.assertIsNone(err, 'Error Creating NVMesh Volume. %s' % err)
        create_res = out[0]
        self.assertTrue(
            create_res['success'],
            'Error Creating NVMesh Volume. %s' % create_res['error'])

        self.addCleanup(lambda: NVMeshUtils.getVolumeAPI().delete([volume]))

        # Create PV
        pv_name = 'pv-name-in-k8s'
        accessModes = ['ReadWriteOnce']
        volume_size = '5Gi'
        sc_name = 'nvmesh-raid10'
        pv = KubeUtils.get_pv_for_static_provisioning(pv_name,
                                                      nvmesh_volume_name,
                                                      accessModes, sc_name,
                                                      volume_size)

        core_api.create_persistent_volume(pv)

        self.addCleanup(lambda: core_api.delete_persistent_volume(pv_name))

        pv_list = core_api.list_persistent_volume(
            field_selector='metadata.name={}'.format(pv_name))
        self.assertIsNotNone(pv_list)
        self.assertTrue(len(pv_list.items))
        self.assertEqual(pv_list.items[0].metadata.name, pv_name)

        # Create PVC
        pvc_name = 'pvc-static-prov'
        KubeUtils.create_pvc_and_wait_to_bound(self,
                                               pvc_name,
                                               sc_name,
                                               access_modes=accessModes,
                                               storage=volume_size,
                                               volumeMode='Block')

        self.addCleanup(lambda: KubeUtils.delete_pvc(pvc_name))

        # Create Consumer pod
        pod_name = 'pod-static-prov'
        cmd = 'echo hello ; while true ; do sleep 60; done'
        pod = KubeUtils.get_shell_pod_template(pod_name,
                                               pvc_name,
                                               cmd,
                                               volume_mode_block=True)
        KubeUtils.create_pod(pod)

        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))

        KubeUtils.wait_for_pod_to_be_running(pod_name)
Example #13
0
	def create_pod_with_cleanup(self, pod):
		KubeUtils.create_pod(pod)
		self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod['metadata']['name']))
Example #14
0
    def _run_shell_pod(self, pod_name, pvc_name, cmd, attempts=60):
        pod = KubeUtils.get_shell_pod_template(pod_name, pvc_name, cmd)
        KubeUtils.create_pod(pod)
        self.addCleanup(lambda: KubeUtils.delete_pod_and_wait(pod_name))

        KubeUtils.wait_for_pod_to_complete(pod_name, attempts=attempts)