def test_device_delete_with_bricks(self): """Validate device deletion with existing bricks on the device""" h_node, h_url = self.heketi_client_node, self.heketi_server_url # Create volume vol_size = 1 vol_info = heketi_volume_create(h_node, h_url, vol_size, json=True) self.addCleanup(heketi_volume_delete, h_node, h_url, vol_info['id']) device_delete_id = vol_info['bricks'][0]['device'] node_id = vol_info['bricks'][0]['node'] device_info = heketi_device_info(h_node, h_url, device_delete_id, json=True) device_name = device_info['name'] # Disable the device heketi_device_disable(h_node, h_url, device_delete_id) self.addCleanup(heketi_device_enable, h_node, h_url, device_delete_id) # Delete device with bricks with self.assertRaises(AssertionError): heketi_device_delete(h_node, h_url, device_delete_id) self.addCleanup(heketi_device_add, h_node, h_url, device_name, node_id)
def check_any_of_bricks_present_in_device(self, bricks, device_id): """ Check any of the bricks present in the device. :param bricks: list bricks of volume :param device_id: device ID :return True: bool if bricks are present on device :return False: bool if bricks are not present on device """ if device_id is None: return False device_info = heketi_device_info(self.heketi_client_node, self.heketi_server_url, device_id, json=True) self.assertNotEqual(device_info, False, "Device info on %s failed" % device_id) for brick in bricks: if brick['device'] != device_id: continue for brick_info in device_info['bricks']: if brick_info['path'] == brick['path']: return True return False
def test_heketi_device_info(self): """Validate whether device related information is displayed""" # Get devices from topology info devices_from_topology = {} topology_info = heketi_topology_info(self.heketi_client_node, self.heketi_server_url, json=True) self.assertTrue(topology_info) self.assertIn('clusters', list(topology_info.keys())) self.assertGreater(len(topology_info['clusters']), 0) for cluster in topology_info['clusters']: self.assertIn('nodes', list(cluster.keys())) self.assertGreater(len(cluster['nodes']), 0) for node in cluster['nodes']: self.assertIn('devices', list(node.keys())) self.assertGreater(len(node['devices']), 0) for device in node['devices']: # Expected keys are state, storage, id, name and bricks. self.assertIn('id', list(device.keys())) devices_from_topology[device['id']] = device # Get devices info and make sure data are consistent and complete for device_id, device_from_t_info in devices_from_topology.items(): device_info = heketi_device_info(self.heketi_client_node, self.heketi_server_url, device_id, json=True) self.assertTrue(device_info) # Verify 'id', 'name', 'state' and 'storage' data for key in ('id', 'name', 'state', 'storage', 'bricks'): self.assertIn(key, list(device_from_t_info.keys())) self.assertIn(key, list(device_info.keys())) for key in ('id', 'name', 'state'): self.assertEqual(device_info[key], device_from_t_info[key]) device_info_storage = device_info['storage'] device_from_t_info_storage = device_from_t_info['storage'] device_info_storage_keys = list(device_info_storage.keys()) device_from_t_info_storage_keys = list( device_from_t_info_storage.keys()) for key in ('total', 'used', 'free'): self.assertIn(key, device_info_storage_keys) self.assertIn(key, device_from_t_info_storage_keys) self.assertEqual(device_info_storage[key], device_from_t_info_storage[key]) self.assertIsInstance(device_info_storage[key], int) self.assertGreater(device_info_storage[key], -1) # Verify 'bricks' data self.assertEqual(len(device_info['bricks']), len(device_from_t_info['bricks'])) brick_match_count = 0 for brick in device_info['bricks']: for brick_from_t in device_from_t_info['bricks']: if brick_from_t['id'] != brick['id']: continue brick_match_count += 1 brick_from_t_keys = list(brick_from_t.keys()) brick_keys = list(brick.keys()) for key in ('device', 'volume', 'size', 'path', 'id', 'node'): self.assertIn(key, brick_from_t_keys) self.assertIn(key, brick_keys) self.assertEqual(brick[key], brick_from_t[key]) self.assertEqual(brick_match_count, len(device_info['bricks']))
def test_create_volumes_enabling_and_disabling_heketi_devices(self): """Validate enable/disable of heketi device""" # Get nodes info node_id_list = heketi_ops.heketi_node_list(self.heketi_client_node, self.heketi_server_url) node_info_list = [] for node_id in node_id_list[0:3]: node_info = heketi_ops.heketi_node_info(self.heketi_client_node, self.heketi_server_url, node_id, json=True) node_info_list.append(node_info) # Disable 4th and other nodes if len(node_id_list) > 3: for node_id in node_id_list[3:]: heketi_ops.heketi_node_disable(self.heketi_client_node, self.heketi_server_url, node_id) self.addCleanup(heketi_ops.heketi_node_enable, self.heketi_client_node, self.heketi_server_url, node_id) # Disable second and other devices on the first 3 nodes for node_info in node_info_list[0:3]: devices = node_info["devices"] self.assertTrue( devices, "Node '%s' does not have devices." % node_info["id"]) if devices[0]["state"].strip().lower() != "online": self.skipTest("Test expects first device to be enabled.") if len(devices) < 2: continue for device in node_info["devices"][1:]: out = heketi_ops.heketi_device_disable(self.heketi_client_node, self.heketi_server_url, device["id"]) self.assertTrue( out, "Failed to disable the device %s" % device["id"]) self.addCleanup(heketi_ops.heketi_device_enable, self.heketi_client_node, self.heketi_server_url, device["id"]) # Create heketi volume out = heketi_ops.heketi_volume_create(self.heketi_client_node, self.heketi_server_url, 1, json=True) self.assertTrue(out, "Failed to create heketi volume of size 1") g.log.info("Successfully created heketi volume of size 1") device_id = out["bricks"][0]["device"] self.addCleanup(heketi_ops.heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, out["bricks"][0]["volume"]) # Disable device g.log.info("Disabling '%s' device" % device_id) out = heketi_ops.heketi_device_disable(self.heketi_client_node, self.heketi_server_url, device_id) self.assertTrue(out, "Failed to disable the device %s" % device_id) g.log.info("Successfully disabled device %s" % device_id) try: # Get device info g.log.info("Retrieving '%s' device info" % device_id) out = heketi_ops.heketi_device_info(self.heketi_client_node, self.heketi_server_url, device_id, json=True) self.assertTrue(out, "Failed to get device info %s" % device_id) g.log.info("Successfully retrieved device info %s" % device_id) name = out["name"] self.assertEqual(out["state"].lower().strip(), "offline", "Device %s is not in offline state." % name) g.log.info("Device %s is now offine" % name) # Try to create heketi volume g.log.info("Creating heketi volume: Expected to fail.") try: out = heketi_ops.heketi_volume_create(self.heketi_client_node, self.heketi_server_url, 1, json=True) except AssertionError: g.log.info("Volume was not created as expected.") else: self.addCleanup(heketi_ops.heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, out["bricks"][0]["volume"]) msg = "Volume unexpectedly created. Out: %s" % out assert False, msg finally: # Enable the device back g.log.info("Enable '%s' device back." % device_id) out = heketi_ops.heketi_device_enable(self.heketi_client_node, self.heketi_server_url, device_id) self.assertTrue(out, "Failed to enable the device %s" % device_id) g.log.info("Successfully enabled device %s" % device_id) # Get device info out = heketi_ops.heketi_device_info(self.heketi_client_node, self.heketi_server_url, device_id, json=True) self.assertTrue(out, ("Failed to get device info %s" % device_id)) g.log.info("Successfully retrieved device info %s" % device_id) name = out["name"] self.assertEqual(out["state"], "online", "Device %s is not in online state." % name) # Create heketi volume of size out = heketi_ops.heketi_volume_create(self.heketi_client_node, self.heketi_server_url, 1, json=True) self.assertTrue(out, "Failed to create volume of size 1") self.addCleanup(heketi_ops.heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, out["bricks"][0]["volume"]) g.log.info("Successfully created volume of size 1") name = out["name"] # Get gluster volume info vol_info = get_volume_info('auto_get_gluster_endpoint', volname=name) self.assertTrue(vol_info, "Failed to get '%s' volume info." % name) g.log.info("Successfully got the '%s' volume info." % name)
def test_expand_arbiter_volume_setting_tags_on_nodes_or_devices( self, node_tags): """Validate exapnsion of arbiter volume with defferent tags This test case is going to run two tests: 1. If value is True it is going to set tags on nodes and run test 2. If value is False it is going to set tags on devices and run test """ data_nodes = [] arbiter_nodes = [] # set tags arbiter:disabled, arbiter:required for i, node_id in enumerate(self.node_id_list): if node_tags: self._set_arbiter_tag_with_further_revert( self.heketi_client_node, self.heketi_server_url, 'node', node_id, 'disabled' if i < 2 else 'required') node_info = heketi_ops.heketi_node_info(self.heketi_client_node, self.heketi_server_url, node_id, json=True) if not node_tags: for device in node_info['devices']: self._set_arbiter_tag_with_further_revert( self.heketi_client_node, self.heketi_server_url, 'device', device['id'], 'disabled' if i < 2 else 'required') device_info = heketi_ops.heketi_device_info( self.heketi_client_node, self.heketi_server_url, device['id'], json=True) self.assertEqual(device_info['tags']['arbiter'], 'disabled' if i < 2 else 'required') node = { 'id': node_id, 'host': node_info['hostnames']['storage'][0] } if node_tags: self.assertEqual(node_info['tags']['arbiter'], 'disabled' if i < 2 else 'required') data_nodes.append(node) if i < 2 else arbiter_nodes.append(node) # Create sc with gluster arbiter info self.create_storage_class(is_arbiter_vol=True, allow_volume_expansion=True) # Create PVC and wait for it to be in 'Bound' state self.create_and_wait_for_pvc() vol_info = openshift_ops.get_gluster_vol_info_by_pvc_name( self.node, self.pvc_name) bricks = self.verify_amount_and_proportion_of_arbiter_and_data_bricks( vol_info) arbiter_hosts = [obj['host'] for obj in arbiter_nodes] data_hosts = [obj['host'] for obj in data_nodes] for brick in bricks['arbiter_list']: self.assertIn(brick['name'].split(':')[0], arbiter_hosts) for brick in bricks['data_list']: self.assertIn(brick['name'].split(':')[0], data_hosts) # Expand PVC and verify the size pvc_size = 2 openshift_ops.resize_pvc(self.node, self.pvc_name, pvc_size) openshift_ops.verify_pvc_size(self.node, self.pvc_name, pvc_size) vol_info = openshift_ops.get_gluster_vol_info_by_pvc_name( self.node, self.pvc_name) bricks = self.verify_amount_and_proportion_of_arbiter_and_data_bricks( vol_info, arbiter_bricks=2, data_bricks=4) for brick in bricks['arbiter_list']: self.assertIn(brick['name'].split(':')[0], arbiter_hosts) for brick in bricks['data_list']: self.assertIn(brick['name'].split(':')[0], data_hosts)
def test_device_settags_tier_option(self): """Validate volume creation with a tag-matching rule""" h_node, h_server = self.heketi_client_node, self.heketi_server_url initial_brick_count, before_brick_count, after_brick_count = [], [], [] # Set tag on device on 3 different nodes node_list = heketi_node_list(h_node, h_server, json=True) device_list = [] for node_id in node_list[:3]: node_info = heketi_node_info(h_node, h_server, node_id, json=True) device_id = node_info.get('devices', {})[0].get('id') device_list.append(device_id) set_tags(h_node, h_server, 'device', device_id, "tier:test") self.addCleanup(rm_tags, h_node, h_server, 'device', device_id, "tier", raise_on_error=False) # Get initial number of bricks present on device for device_id in device_list: device_info = heketi_device_info(h_node, h_server, device_id, json=True) initial_brick_count.append(len(device_info.get("bricks"))) # Create volume with device tag option volume_info = heketi_volume_create( h_node, h_server, 2, gluster_volume_options="user.heketi.device-tag-match tier=test", json=True) self.addCleanup(heketi_volume_delete, h_node, h_server, volume_info.get("id")) # Get number of bricks present on device after volume create for device_id in device_list: device_info = heketi_device_info(h_node, h_server, device_id, json=True) before_brick_count.append(len(device_info.get("bricks"))) # Validate volume has created on tag devices self.assertGreater( before_brick_count, initial_brick_count, "Volume {} has not created on tag devices".format( volume_info.get("id"))) # Create volume with not equal to tag option volume_info = heketi_volume_create( h_node, h_server, 2, gluster_volume_options="user.heketi.device-tag-match tier!=test", json=True) self.addCleanup(heketi_volume_delete, h_node, h_server, volume_info.get("id")) # Get number of bricks present on device after volume create for device_id in device_list: device_info = heketi_device_info(h_node, h_server, device_id, json=True) after_brick_count.append(len(device_info.get("bricks"))) # Validate volume has not created on tag devices self.assertEqual( before_brick_count, after_brick_count, "Volume {} has created on tag devices".format( volume_info.get("id"))) # Update the tag on device for device_id in device_list: set_tags(h_node, h_server, 'device', device_id, "tier:test_update") self.addCleanup(rm_tags, h_node, h_server, 'device', device_id, "tier")
def test_volume_creation_of_size_greater_than_the_device_size(self): """Validate creation of a volume of size greater than the size of a device. """ h_node, h_url = self.heketi_client_node, self.heketi_server_url # Remove existing BHV to calculate freespace bhv_list = heketi_ops.get_block_hosting_volume_list(h_node, h_url) if bhv_list: for bhv in bhv_list: bhv_info = heketi_ops.heketi_volume_info(h_node, h_url, bhv, json=True) if bhv_info['blockinfo'].get('blockvolume') is None: heketi_ops.heketi_volume_delete(h_node, h_url, bhv) topology = heketi_ops.heketi_topology_info(h_node, h_url, json=True) nodes_free_space, nodes_ips = [], [] selected_nodes, selected_devices = [], [] cluster = topology['clusters'][0] node_count = len(cluster['nodes']) msg = ("At least 3 Nodes are required in cluster. " "But only %s Nodes are present." % node_count) if node_count < 3: self.skipTest(msg) online_nodes_count = 0 for node in cluster['nodes']: nodes_ips.append(node['hostnames']['storage'][0]) if node['state'] != 'online': continue online_nodes_count += 1 # Disable nodes after 3rd online nodes if online_nodes_count > 3: heketi_ops.heketi_node_disable(h_node, h_url, node['id']) self.addCleanup(heketi_ops.heketi_node_enable, h_node, h_url, node['id']) continue selected_nodes.append(node['id']) device_count = len(node['devices']) msg = ("At least 2 Devices are required on each Node." "But only %s Devices are present." % device_count) if device_count < 2: self.skipTest(msg) sel_devices, online_devices_count, free_space = [], 0, 0 for device in node['devices']: if device['state'] != 'online': continue online_devices_count += 1 # Disable devices after 2nd online devices if online_devices_count > 2: heketi_ops.heketi_device_disable(h_node, h_url, device['id']) self.addCleanup(heketi_ops.heketi_device_enable, h_node, h_url, device['id']) continue sel_devices.append(device['id']) free_space += int(device['storage']['free'] / (1024**2)) selected_devices.append(sel_devices) nodes_free_space.append(free_space) msg = ("At least 2 online Devices are required on each Node. " "But only %s Devices are online on Node: %s." % (online_devices_count, node['id'])) if online_devices_count < 2: self.skipTest(msg) msg = ("At least 3 online Nodes are required in cluster. " "But only %s Nodes are online in Cluster: %s." % (online_nodes_count, cluster['id'])) if online_nodes_count < 3: self.skipTest(msg) # Select node with minimum free space min_free_size = min(nodes_free_space) index = nodes_free_space.index(min_free_size) # Get max device size from selected node device_size = 0 for device in selected_devices[index]: device_info = heketi_ops.heketi_device_info(h_node, h_url, device, json=True) device_size = max(device_size, (int(device_info['storage']['total'] / (1024**2)))) vol_size = device_size + 1 if vol_size >= min_free_size: self.skipTest('Required free space %s is not available' % vol_size) # Create heketi volume with device size + 1 vol_info = self.create_heketi_volume_with_name_and_wait( name="volume_size_greater_than_device_size", size=vol_size, json=True) # Get gluster server IP's from heketi volume info glusterfs_servers = heketi_ops.get_vol_file_servers_and_hosts( h_node, h_url, vol_info['id']) # Verify gluster server IP's in heketi volume info msg = ("gluster IP's '%s' does not match with IP's '%s' found in " "heketi volume info" % (nodes_ips, glusterfs_servers['vol_servers'])) self.assertEqual(set(glusterfs_servers['vol_servers']), set(nodes_ips), msg) vol_name = vol_info['name'] gluster_v_info = self.get_gluster_vol_info(vol_name) # Verify replica count in gluster v info msg = "Volume %s is replica %s instead of replica 3" % ( vol_name, gluster_v_info['replicaCount']) self.assertEqual('3', gluster_v_info['replicaCount']) # Verify distCount in gluster v info msg = "Volume %s distCount is %s instead of distCount as 3" % ( vol_name, int(gluster_v_info['distCount'])) self.assertEqual( int(gluster_v_info['brickCount']) // 3, int(gluster_v_info['distCount']), msg) # Verify bricks count in gluster v info msg = ( "Volume %s does not have bricks count multiple of 3. It has %s" % (vol_name, gluster_v_info['brickCount'])) self.assertFalse(int(gluster_v_info['brickCount']) % 3, msg)
def test_dev_path_mapping_heketi_device_delete(self): """Validate dev path mapping for heketi device delete lifecycle""" h_client, h_url = self.heketi_client_node, self.heketi_server_url node_ids = heketi_ops.heketi_node_list(h_client, h_url) self.assertTrue(node_ids, "Failed to get heketi node list") # Fetch #4th node for the operations h_disable_node = node_ids[3] # Fetch bricks on the devices before volume create h_node_details_before, h_node = self._get_bricks_and_device_details() # Bricks count on the node before pvc creation brick_count_before = [count[1] for count in h_node_details_before] # Create file volume with app pod and verify IO's # and compare path, UUID, vg_name pod_name, dc_name, use_percent = self._create_app_pod_and_verify_pvs() # Check if IO's are running use_percent_after = self._get_space_use_percent_in_app_pod(pod_name) self.assertNotEqual( use_percent, use_percent_after, "Failed to execute IO's in the app pod {} after respin".format( pod_name)) # Fetch bricks on the devices after volume create h_node_details_after, h_node = self._get_bricks_and_device_details() # Bricks count on the node after pvc creation brick_count_after = [count[1] for count in h_node_details_after] self.assertGreater( sum(brick_count_after), sum(brick_count_before), "Failed to add bricks on the node {}".format(h_node)) # Enable the #4th node heketi_ops.heketi_node_enable(h_client, h_url, h_disable_node) node_info = heketi_ops.heketi_node_info(h_client, h_url, h_disable_node, json=True) h_node_id = node_info['id'] self.assertEqual(node_info['state'], "online", "Failed to enable node {}".format(h_disable_node)) # Fetch device list i.e to be deleted h_node_info = heketi_ops.heketi_node_info(h_client, h_url, h_node, json=True) devices_list = [[device['id'], device['name']] for device in h_node_info['devices']] # Device deletion operation for device in devices_list: device_id, device_name = device[0], device[1] self.addCleanup(heketi_ops.heketi_device_enable, h_client, h_url, device_id, raise_on_error=False) # Disable device from heketi device_disable = heketi_ops.heketi_device_disable( h_client, h_url, device_id) self.assertTrue( device_disable, "Device {} could not be disabled".format(device_id)) device_info = heketi_ops.heketi_device_info(h_client, h_url, device_id, json=True) self.assertEqual(device_info['state'], "offline", "Failed to disable device {}".format(device_id)) # Remove device from heketi device_remove = heketi_ops.heketi_device_remove( h_client, h_url, device_id) self.assertTrue(device_remove, "Device {} could not be removed".format(device_id)) # Bricks after device removal device_info = heketi_ops.heketi_device_info(h_client, h_url, device_id, json=True) bricks_count_after = len(device_info['bricks']) self.assertFalse( bricks_count_after, "Failed to remove the bricks from the device {}".format( device_id)) # Delete device from heketi self.addCleanup(heketi_ops.heketi_device_add, h_client, h_url, device_name, h_node, raise_on_error=False) device_delete = heketi_ops.heketi_device_delete( h_client, h_url, device_id) self.assertTrue(device_delete, "Device {} could not be deleted".format(device_id)) # Check if IO's are running after device is deleted use_percent_after = self._get_space_use_percent_in_app_pod(pod_name) self.assertNotEqual( use_percent, use_percent_after, "Failed to execute IO's in the app pod {} after respin".format( pod_name)) # Add device operations for device in devices_list: device_name = device[1] # Add device back to the node heketi_ops.heketi_device_add(h_client, h_url, device_name, h_node) # Fetch device info after device add node_info = heketi_ops.heketi_node_info(h_client, h_url, h_node, json=True) device_id = None for device in node_info["devices"]: if device["name"] == device_name: device_id = device["id"] break self.assertTrue( device_id, "Failed to add device {} on node" " {}".format(device_name, h_node)) # Disable the #4th node heketi_ops.heketi_node_disable(h_client, h_url, h_node_id) node_info = heketi_ops.heketi_node_info(h_client, h_url, h_node_id, json=True) self.assertEqual(node_info['state'], "offline", "Failed to disable node {}".format(h_node_id)) pvc_amount, pvc_size = 5, 1 # Fetch bricks on the devices before volume create h_node_details_before, h_node = self._get_bricks_and_device_details() # Bricks count on the node before pvc creation brick_count_before = [count[1] for count in h_node_details_before] # Create file volumes pvc_name = self.create_and_wait_for_pvcs(pvc_size=pvc_size, pvc_amount=pvc_amount) self.assertEqual(len(pvc_name), pvc_amount, "Failed to create {} pvc".format(pvc_amount)) # Fetch bricks on the devices after volume create h_node_details_after, h_node = self._get_bricks_and_device_details() # Bricks count on the node after pvc creation brick_count_after = [count[1] for count in h_node_details_after] self.assertGreater( sum(brick_count_after), sum(brick_count_before), "Failed to add bricks on the node {}".format(h_node)) # Check if IO's are running after new device is added use_percent_after = self._get_space_use_percent_in_app_pod(pod_name) self.assertNotEqual( use_percent, use_percent_after, "Failed to execute IO's in the app pod {} after respin".format( pod_name))
def test_expand_arbiter_volume_setting_tags_on_nodes_or_devices( self, node_tags): """Validate exapnsion of arbiter volume with defferent tags This test case is going to run two tests: 1. If value is True it is going to set tags on nodes and run test 2. If value is False it is going to set tags on devices and run test """ data_nodes = [] arbiter_nodes = [] # set tags arbiter:disabled, arbiter:required for i, node_id in enumerate(self.node_id_list): if node_tags: self._set_arbiter_tag_with_further_revert( self.heketi_client_node, self.heketi_server_url, 'node', node_id, 'disabled' if i < 2 else 'required') node_info = heketi_ops.heketi_node_info( self.heketi_client_node, self.heketi_server_url, node_id, json=True) if not node_tags: for device in node_info['devices']: self._set_arbiter_tag_with_further_revert( self.heketi_client_node, self.heketi_server_url, 'device', device['id'], 'disabled' if i < 2 else 'required') device_info = heketi_ops.heketi_device_info( self.heketi_client_node, self.heketi_server_url, device['id'], json=True) self.assertEqual( device_info['tags']['arbiter'], 'disabled' if i < 2 else 'required') node = { 'id': node_id, 'host': node_info['hostnames']['storage'][0]} if node_tags: self.assertEqual( node_info['tags']['arbiter'], 'disabled' if i < 2 else 'required') data_nodes.append(node) if i < 2 else arbiter_nodes.append( node) # Create sc with gluster arbiter info self.create_storage_class( is_arbiter_vol=True, allow_volume_expansion=True) # Create PVC and wait for it to be in 'Bound' state self.create_and_wait_for_pvc() vol_info = get_gluster_vol_info_by_pvc_name(self.node, self.pvc_name) bricks = self.verify_amount_and_proportion_of_arbiter_and_data_bricks( vol_info) arbiter_hosts = [obj['host'] for obj in arbiter_nodes] data_hosts = [obj['host'] for obj in data_nodes] for brick in bricks['arbiter_list']: self.assertIn(brick['name'].split(':')[0], arbiter_hosts) for brick in bricks['data_list']: self.assertIn(brick['name'].split(':')[0], data_hosts) # Expand PVC and verify the size pvc_size = 2 resize_pvc(self.node, self.pvc_name, pvc_size) verify_pvc_size(self.node, self.pvc_name, pvc_size) vol_info = get_gluster_vol_info_by_pvc_name(self.node, self.pvc_name) bricks = self.verify_amount_and_proportion_of_arbiter_and_data_bricks( vol_info, arbiter_bricks=2, data_bricks=4) for brick in bricks['arbiter_list']: self.assertIn(brick['name'].split(':')[0], arbiter_hosts) for brick in bricks['data_list']: self.assertIn(brick['name'].split(':')[0], data_hosts)
def test_create_volumes_enabling_and_disabling_heketi_devices(self): """Validate enable/disable of heketi device""" # Get nodes info node_id_list = heketi_ops.heketi_node_list( self.heketi_client_node, self.heketi_server_url) node_info_list = [] for node_id in node_id_list[0:3]: node_info = heketi_ops.heketi_node_info( self.heketi_client_node, self.heketi_server_url, node_id, json=True) node_info_list.append(node_info) # Disable 4th and other nodes if len(node_id_list) > 3: for node in node_id_list[3:]: heketi_ops.heketi_node_disable( self.heketi_client_node, self.heketi_server_url, node_id) self.addCleanup( heketi_ops.heketi_node_enable, self.heketi_client_node, self.heketi_server_url, node_id) # Disable second and other devices on the first 3 nodes for node_info in node_info_list[0:3]: devices = node_info["devices"] self.assertTrue( devices, "Node '%s' does not have devices." % node_info["id"]) if devices[0]["state"].strip().lower() != "online": self.skipTest("Test expects first device to be enabled.") if len(devices) < 2: continue for device in node_info["devices"][1:]: out = heketi_ops.heketi_device_disable( self.heketi_client_node, self.heketi_server_url, device["id"]) self.assertTrue( out, "Failed to disable the device %s" % device["id"]) self.addCleanup( heketi_ops.heketi_device_enable, self.heketi_client_node, self.heketi_server_url, device["id"]) # Create heketi volume out = heketi_ops.heketi_volume_create( self.heketi_client_node, self.heketi_server_url, 1, json=True) self.assertTrue(out, "Failed to create heketi volume of size 1") g.log.info("Successfully created heketi volume of size 1") device_id = out["bricks"][0]["device"] self.addCleanup( heketi_ops.heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, out["bricks"][0]["volume"]) # Disable device g.log.info("Disabling '%s' device" % device_id) out = heketi_ops.heketi_device_disable( self.heketi_client_node, self.heketi_server_url, device_id) self.assertTrue(out, "Failed to disable the device %s" % device_id) g.log.info("Successfully disabled device %s" % device_id) try: # Get device info g.log.info("Retrieving '%s' device info" % device_id) out = heketi_ops.heketi_device_info( self.heketi_client_node, self.heketi_server_url, device_id, json=True) self.assertTrue(out, "Failed to get device info %s" % device_id) g.log.info("Successfully retrieved device info %s" % device_id) name = out["name"] if out["state"].lower().strip() != "offline": raise exceptions.ExecutionError( "Device %s is not in offline state." % name) g.log.info("Device %s is now offine" % name) # Try to create heketi volume g.log.info("Creating heketi volume: Expected to fail.") try: out = heketi_ops.heketi_volume_create( self.heketi_client_node, self.heketi_server_url, 1, json=True) except exceptions.ExecutionError: g.log.info("Volume was not created as expected.") else: self.addCleanup( heketi_ops.heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, out["bricks"][0]["volume"]) msg = "Volume unexpectedly created. Out: %s" % out assert False, msg finally: # Enable the device back g.log.info("Enable '%s' device back." % device_id) out = heketi_ops.heketi_device_enable( self.heketi_client_node, self.heketi_server_url, device_id) self.assertTrue(out, "Failed to enable the device %s" % device_id) g.log.info("Successfully enabled device %s" % device_id) # Get device info out = heketi_ops.heketi_device_info( self.heketi_client_node, self.heketi_server_url, device_id, json=True) self.assertTrue(out, ("Failed to get device info %s" % device_id)) g.log.info("Successfully retrieved device info %s" % device_id) name = out["name"] if out["state"] != "online": raise exceptions.ExecutionError( "Device %s is not in online state." % name) # Create heketi volume of size out = heketi_ops.heketi_volume_create( self.heketi_client_node, self.heketi_server_url, 1, json=True) self.assertTrue(out, "Failed to create volume of size 1") self.addCleanup( heketi_ops.heketi_volume_delete, self.heketi_client_node, self.heketi_server_url, out["bricks"][0]["volume"]) g.log.info("Successfully created volume of size 1") name = out["name"] # Get gluster volume info vol_info = get_volume_info('auto_get_gluster_endpoint', volname=name) self.assertTrue(vol_info, "Failed to get '%s' volume info." % name) g.log.info("Successfully got the '%s' volume info." % name)