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)
