def validate_block_volumes_count(self, h_node, h_server, node_ip): # get list of block volumes using heketi h_blockvol_list = heketi_blockvolume_list( h_node, h_server, json=True) # Get existing BHV list bhv_list = list( get_block_hosting_volume_list(h_node, h_server).keys()) for vol in bhv_list: bhv_info = heketi_volume_info(h_node, h_server, vol, json=True) bhv_name = bhv_info['name'] gluster_block_list = get_block_list(node_ip, volname=bhv_name) self.assertIsNotNone( gluster_block_list, "Failed to get gluster block list") self.assertEqual( len(h_blockvol_list['blockvolumes']), len(gluster_block_list), "Failed to verify blockvolume count Expected:'{}', " "Actual:'{}'".format( len(h_blockvol_list['blockvolumes']), len(gluster_block_list)))
def test_create_max_num_blockhostingvolumes(self): num_of_bv = 10 new_bhv_list, bv_list, g_nodes = [], [], [] free_space, nodenum = get_total_free_space(self.heketi_client_node, self.heketi_server_url) if nodenum < 3: self.skipTest("Skip the test case since number of" "online nodes is less than 3.") free_space_available = int(free_space / nodenum) default_bhv_size = get_default_block_hosting_volume_size( self.heketi_client_node, self.heketi_dc_name) # Get existing list of BHV's existing_bhv_list = get_block_hosting_volume_list( self.heketi_client_node, self.heketi_server_url) # Skip the test if available space is less than default_bhv_size if free_space_available < default_bhv_size: self.skipTest("Skip the test case since free_space_available %s" "is less than space_required_for_bhv %s ." % (free_space_available, default_bhv_size)) # Create BHV's while free_space_available > default_bhv_size: block_host_create_info = heketi_volume_create( self.heketi_client_node, self.heketi_server_url, default_bhv_size, json=True, block=True) if block_host_create_info["id"] not in existing_bhv_list.keys(): new_bhv_list.append(block_host_create_info["id"]) self.addCleanup(heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, block_host_create_info["id"], raise_on_error=False) block_vol_size = int( block_host_create_info["blockinfo"]["freesize"] / num_of_bv) # Create specified number of BV's in BHV's created for i in range(0, num_of_bv): block_vol = heketi_blockvolume_create(self.heketi_client_node, self.heketi_server_url, block_vol_size, json=True, ha=3, auth=True) self.addCleanup(heketi_blockvolume_delete, self.heketi_client_node, self.heketi_server_url, block_vol["id"], raise_on_error=False) bv_list.append(block_vol["id"]) free_space_available = int(free_space_available - default_bhv_size) # Get gluster node ips h_nodes_ids = heketi_node_list(self.heketi_client_node, self.heketi_server_url) for h_node in h_nodes_ids[:2]: g_node = heketi_node_info(self.heketi_client_node, self.heketi_server_url, h_node, json=True) g_nodes.append(g_node['hostnames']['manage'][0]) # Check if there is no crash in gluster related services & heketi services = (("glusterd", "running"), ("gluster-blockd", "running"), ("tcmu-runner", "running"), ("gluster-block-target", "exited")) for g_node in g_nodes: for service, state in services: wait_for_service_status_on_gluster_pod_or_node( self.ocp_client[0], service, 'active', state, g_node, raise_on_error=False) out = hello_heketi(self.heketi_client_node, self.heketi_server_url) self.assertTrue( out, "Heketi server %s is not alive" % self.heketi_server_url) # Delete all the BHV's and BV's created for bv_volume in bv_list: heketi_blockvolume_delete(self.heketi_client_node, self.heketi_server_url, bv_volume) # Check if any blockvolume exist in heketi & gluster for bhv_volume in new_bhv_list[:]: heketi_vol_info = heketi_volume_info(self.heketi_client_node, self.heketi_server_url, bhv_volume, json=True) self.assertNotIn("blockvolume", heketi_vol_info["blockinfo"].keys()) gluster_vol_info = get_block_list('auto_get_gluster_endpoint', volname="vol_%s" % bhv_volume) self.assertIsNotNone(gluster_vol_info, "Failed to get volume info %s" % bhv_volume) new_bhv_list.remove(bhv_volume) for blockvol in gluster_vol_info: self.assertNotIn("blockvol_", blockvol) heketi_volume_delete(self.heketi_client_node, self.heketi_server_url, bhv_volume) # Check if all blockhosting volumes are deleted from heketi self.assertFalse(new_bhv_list)
def test_heket_block_volume_info_with_gluster_block_volume_info(self): """Verify heketi block volume info with the backend gluster block volume info """ h_node, h_server = self.heketi_client_node, self.heketi_server_url vol_size = 1 h_block_vol = heketi_blockvolume_create(h_node, h_server, vol_size, auth=True, json=True) self.addCleanup(heketi_blockvolume_delete, h_node, h_server, h_block_vol["id"]) h_block_vol["blockvolume"]["hosts"].sort() h_block_vol_gbid = h_block_vol["blockvolume"]["username"] h_block_vol_name = h_block_vol["name"] h_block_vol_paswd = h_block_vol["blockvolume"]["password"] h_block_vol_hosts = h_block_vol["blockvolume"]["hosts"] h_block_host_vol_id = h_block_vol["blockhostingvolume"] h_block_vol_ha = h_block_vol["hacount"] # Fetch heketi blockhostingvolume info h_bhv_info = heketi_volume_info(h_node, h_server, h_block_host_vol_id, json=True) err_msg = "Failed to get heketi blockhostingvolume info for {}" self.assertTrue(h_bhv_info, err_msg.format(h_block_host_vol_id)) h_bhv_name = h_bhv_info['name'] err_msg = "Failed to get heketi BHV name for heketi blockvolume Id {}" self.assertTrue(h_bhv_name, err_msg.format(h_block_host_vol_id)) # Get gluster blockvolume list g_block_vol_list = get_block_list('auto_get_gluster_endpoint', h_bhv_name) err_msg = ("Failed to get gluter blockvolume list {}".format( g_block_vol_list)) self.assertTrue(g_block_vol_list, err_msg) err_msg = ( "Heketi block volume {} not present in gluster blockvolumes {}". format(h_block_vol_name, g_block_vol_list)) self.assertIn(h_block_vol_name, g_block_vol_list, err_msg) g_block_info = get_block_info('auto_get_gluster_endpoint', h_bhv_name, h_block_vol_name) g_block_info["EXPORTED ON"].sort() g_block_vol_hosts = g_block_info["EXPORTED ON"] g_block_vol_gbid = g_block_info["GBID"] g_block_vol_name = g_block_info["NAME"] g_block_vol_paswd = g_block_info["PASSWORD"] g_block_vol_id = g_block_info["VOLUME"][4:] g_block_vol_ha = g_block_info["HA"] # verfiy block device info and glusterblock volume info err_msg = ("Did not match {} from heketi {} and gluster {} side") self.assertEqual( h_block_vol_gbid, g_block_vol_gbid, err_msg.format("GBID", h_block_vol_gbid, g_block_vol_gbid, err_msg)) self.assertEqual( h_block_vol_name, g_block_vol_name, err_msg.format("blockvolume", h_block_vol_name, g_block_vol_name, err_msg)) self.assertEqual( h_block_vol_paswd, g_block_vol_paswd, err_msg.format("password", h_block_vol_paswd, g_block_vol_paswd, err_msg)) self.assertEqual( h_block_vol_hosts, g_block_vol_hosts, err_msg.format("hosts", h_block_vol_hosts, g_block_vol_hosts, err_msg)) self.assertEqual( h_block_host_vol_id, g_block_vol_id, err_msg.format("blockhost vol id", h_block_host_vol_id, g_block_vol_id, err_msg)) self.assertEqual( h_block_vol_ha, g_block_vol_ha, err_msg.format("ha", h_block_vol_ha, g_block_vol_ha, err_msg))
def test_dev_path_block_volume_delete(self): """Validate device path name changes the deletion of already existing file volumes """ pvc_size, pvc_amount = 2, 5 pvc_names, gluster_block_list, vol_details = [], [], [] # Fetch BHV list h_bhv_list_before = heketi_ops.get_block_hosting_volume_list( self.h_node, self.h_server).keys() # Create storage class sc_name = self.create_storage_class() # Delete created BHV and BV as cleanup during failures self.addCleanup(self._cleanup_heketi_volumes, h_bhv_list_before) # Create PVC's for i in range(0, pvc_amount): pvc_name = openshift_ops.oc_create_pvc(self.node, sc_name, pvc_size=pvc_size) pvc_names.append(pvc_name) self.addCleanup(openshift_ops.wait_for_resource_absence, self.node, 'pvc', pvc_name) self.addCleanup(openshift_ops.oc_delete, self.node, 'pvc', pvc_name, raise_on_absence=False) # Wait for PVC's to be bound openshift_ops.wait_for_pvc_be_bound(self.node, pvc_names) # Get volume name list for pvc_name in pvc_names: pv_name = openshift_ops.get_pv_name_from_pvc(self.node, pvc_name) volume_name = openshift_ops.get_vol_names_from_pv(self.node, pv_name, vol_type='block') vol_details.append(volume_name) # Get BHV list after BV creation h_bhv_list_after = heketi_ops.get_block_hosting_volume_list( self.h_node, self.h_server).keys() self.assertTrue(h_bhv_list_after, "Failed to get the BHV list") # Validate BV's count self.validate_block_volumes_count(self.h_node, self.h_server, self.node_ip) # Collect pvs info and detach disks and collect pvs info pvs_info_before = openshift_storage_libs.get_pvs_info( self.node, self.node_ip, self.devices_list, raise_on_error=False) self.detach_and_attach_vmdk(self.vm_name, self.node_hostname, self.devices_list) pvs_info_after = openshift_storage_libs.get_pvs_info( self.node, self.node_ip, self.devices_list, raise_on_error=False) # Compare pvs info before and after for (path, uuid, vg_name), (_path, _uuid, _vg_name) in zip(pvs_info_before[:-1], pvs_info_after[1:]): self.assertEqual( uuid, _uuid, "pv_uuid check failed. Expected:{}," "Actual: {}".format(uuid, _uuid)) self.assertEqual( vg_name, _vg_name, "vg_name check failed. Expected:" "{}, Actual:{}".format(vg_name, _vg_name)) # Delete created PVC's for pvc_name in pvc_names: openshift_ops.oc_delete(self.node, 'pvc', pvc_name) # Wait for pvc to get deleted openshift_ops.wait_for_resources_absence(self.node, 'pvc', pvc_names) # Get existing BHV list for bhv_name in h_bhv_list_after: b_list = block_libs.get_block_list(self.node_ip, volname=bhv_name) self.assertIsNotNone(gluster_block_list, "Failed to get gluster block list") gluster_block_list.append(b_list) # Get list of block volumes using heketi h_blockvol_list = heketi_ops.heketi_blockvolume_list(self.h_node, self.h_server, json=True) # Validate volumes created are not present for vol in vol_details: self.assertNotIn(vol, gluster_block_list, "Failed to delete volume {}".format(vol)) self.assertNotIn(vol, h_blockvol_list['blockvolumes'], "Failed to delete blockvolume '{}'".format(vol))