def verify_gluster_server_present_in_heketi_vol_info_or_not(
self, vol_ids, gluster_server, state='present'):
# Verify gluster servers in vol info
for vol_id in vol_ids:
g_servers = heketi_ops.get_vol_file_servers_and_hosts(
self.h_node, self.h_url, vol_id)
g_servers = (g_servers['vol_servers'] + g_servers['vol_hosts'])
if state == 'present':
self.assertIn(gluster_server, g_servers)
elif state == 'absent':
self.assertNotIn(gluster_server, g_servers)
else:
msg = "State %s is other than present, absent" % state
raise AssertionError(msg)
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)