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_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)
def test_heketi_devices_info_verification(self):
"""Validate whether device related information is displayed"""
# Get devices from topology info
devices_from_topology = {}
topology_info = heketi_ops.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_ops.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()))
self.assertEqual(device_info['id'], device_from_t_info['id'])
self.assertEqual(device_info['name'], device_from_t_info['name'])
self.assertEqual(device_info['state'], device_from_t_info['state'])
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_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)