def test_dynamic_provisioning_glusterblock_reclaim_policy_retain(self):
"""Validate retain policy for gluster-block after PVC deletion"""
if get_openshift_version() < "3.9":
self.skipTest(
"'Reclaim' feature is not supported in OCP older than 3.9")
self.create_storage_class(reclaim_policy='Retain')
self.create_and_wait_for_pvc()
dc_name = oc_create_app_dc_with_io(self.node, self.pvc_name)
try:
pod_name = get_pod_name_from_dc(self.node, dc_name)
wait_for_pod_be_ready(self.node, pod_name)
finally:
scale_dc_pod_amount_and_wait(self.node, dc_name, pod_amount=0)
oc_delete(self.node, 'dc', dc_name)
# get the name of volume
pv_name = get_pv_name_from_pvc(self.node, self.pvc_name)
custom = [
r':.metadata.annotations."gluster\.org\/volume\-id"',
r':.spec.persistentVolumeReclaimPolicy'
]
vol_id, reclaim_policy = oc_get_custom_resource(
self.node, 'pv', custom, pv_name)
# checking the retainPolicy of pvc
self.assertEqual(reclaim_policy, 'Retain')
# delete the pvc
oc_delete(self.node, 'pvc', self.pvc_name)
# check if pv is also deleted or not
with self.assertRaises(ExecutionError):
wait_for_resource_absence(self.node,
'pvc',
self.pvc_name,
interval=3,
timeout=30)
# getting the blockvol list
blocklist = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url)
self.assertIn(vol_id, blocklist)
heketi_blockvolume_delete(self.heketi_client_node,
self.heketi_server_url, vol_id)
blocklist = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url)
self.assertNotIn(vol_id, blocklist)
oc_delete(self.node, 'pv', pv_name)
wait_for_resource_absence(self.node, 'pv', pv_name)
def test_dynamic_provisioning_glusterblock_reclaim_policy_retain(self):
"""Validate retain policy for gluster-block after PVC deletion"""
if get_openshift_version() < "3.9":
self.skipTest(
"'Reclaim' feature is not supported in OCP older than 3.9")
self.create_storage_class(reclaim_policy='Retain')
self.create_and_wait_for_pvc()
dc_name = oc_create_app_dc_with_io(self.node, self.pvc_name)
try:
pod_name = get_pod_name_from_dc(self.node, dc_name)
wait_for_pod_be_ready(self.node, pod_name)
finally:
scale_dc_pod_amount_and_wait(self.node, dc_name, pod_amount=0)
oc_delete(self.node, 'dc', dc_name)
# get the name of volume
pv_name = get_pv_name_from_pvc(self.node, self.pvc_name)
custom = [r':.metadata.annotations."gluster\.org\/volume\-id"',
r':.spec.persistentVolumeReclaimPolicy']
vol_id, reclaim_policy = oc_get_custom_resource(
self.node, 'pv', custom, pv_name)
# checking the retainPolicy of pvc
self.assertEqual(reclaim_policy, 'Retain')
# delete the pvc
oc_delete(self.node, 'pvc', self.pvc_name)
# check if pv is also deleted or not
with self.assertRaises(ExecutionError):
wait_for_resource_absence(
self.node, 'pvc', self.pvc_name, interval=3, timeout=30)
# getting the blockvol list
blocklist = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url)
self.assertIn(vol_id, blocklist)
heketi_blockvolume_delete(self.heketi_client_node,
self.heketi_server_url, vol_id)
blocklist = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url)
self.assertNotIn(vol_id, blocklist)
oc_delete(self.node, 'pv', pv_name)
wait_for_resource_absence(self.node, 'pv', pv_name)
def test_block_volume_delete(self):
"""Validate deletion of gluster-block volume and capacity of used pool
"""
block_vol = heketi_blockvolume_create(self.heketi_client_node,
self.heketi_server_url,
1,
json=True)
self.addCleanup(heketi_blockvolume_delete,
self.heketi_client_node,
self.heketi_server_url,
block_vol["id"],
raise_on_error=False)
heketi_blockvolume_delete(self.heketi_client_node,
self.heketi_server_url,
block_vol["id"],
json=True)
volume_list = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url,
json=True)
self.assertNotIn(
block_vol["id"], volume_list["blockvolumes"],
"The block volume has not been successfully deleted,"
" ID is %s" % block_vol["id"])
def get_heketi_block_volumes(self):
"""lists heketi block volumes
Returns:
list : list of ids of heketi block volumes
"""
heketi_cmd_out = heketi_blockvolume_list(
self.heketi_client_node,
self.heketi_server_url,
secret=self.heketi_cli_key,
user=self.heketi_cli_user
)
self.assertTrue(heketi_cmd_out, "failed to get block volume list")
heketi_block_volume_ids = []
heketi_block_volume_names = []
for block_vol in heketi_cmd_out.split("\n"):
heketi_vol_match = re.search(
HEKETI_BLOCK_VOLUME_REGEX % self.prefix, block_vol.strip()
)
if heketi_vol_match:
heketi_block_volume_ids.append(
(heketi_vol_match.group(1)).strip()
)
heketi_block_volume_names.append(
(heketi_vol_match.group(3)).strip()
)
return (sorted(heketi_block_volume_ids), sorted(
heketi_block_volume_names)
)
def test_compare_block_volumes(self):
"""Validate blockvolume count using heketi gluster examine"""
# Create some blockvolumes
size = 1
for i in range(5):
volume = heketi_ops.heketi_blockvolume_create(
self.heketi_client_node,
self.heketi_server_url,
size,
json=True)['id']
self.addCleanup(heketi_ops.heketi_blockvolume_delete,
self.heketi_client_node, self.heketi_server_url,
volume)
# Get the list of blockvolumes from heketi gluster examine
out = heketi_ops.heketi_examine_gluster(self.heketi_client_node,
self.heketi_server_url)
examine_blockvolumes, clusters = [], out['heketidb']['clusterentries']
for cluster in clusters.values():
examine_blockvolumes += cluster['Info']['blockvolumes']
# Get list of blockvolume from heketi blockvolume list
heketi_block_volumes = heketi_ops.heketi_blockvolume_list(
self.heketi_client_node, self.heketi_server_url,
json=True)['blockvolumes']
# Compare volume list
msg = ("Heketi blockvolume list {} and list of blockvolumes in heketi "
"gluster examine {} are not same".format(
heketi_block_volumes, examine_blockvolumes))
self.assertEqual(heketi_block_volumes, examine_blockvolumes, msg)
def get_heketi_block_volumes(self):
"""lists heketi block volumes
Returns:
list : list of ids of heketi block volumes
"""
heketi_cmd_out = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url,
secret=self.heketi_cli_key,
user=self.heketi_cli_user)
self.assertTrue(heketi_cmd_out, "failed to get block volume list")
heketi_block_volume_ids = []
heketi_block_volume_names = []
for block_vol in heketi_cmd_out.split("\n"):
heketi_vol_match = re.search(
HEKETI_BLOCK_VOLUME_REGEX % self.prefix, block_vol.strip())
if heketi_vol_match:
heketi_block_volume_ids.append(
(heketi_vol_match.group(1)).strip())
heketi_block_volume_names.append(
(heketi_vol_match.group(3)).strip())
return (sorted(heketi_block_volume_ids),
sorted(heketi_block_volume_names))
def test_volname_prefix_glusterblock(self):
"""Validate custom volname prefix blockvol"""
self.dynamic_provisioning_glusterblock(
set_hacount=False, create_vol_name_prefix=True)
pv_name = get_pv_name_from_pvc(self.node, self.pvc_name)
vol_name = oc_get_custom_resource(
self.node, 'pv',
':.metadata.annotations.glusterBlockShare', pv_name)[0]
block_vol_list = heketi_blockvolume_list(
self.heketi_client_node, self.heketi_server_url)
self.assertIn(vol_name, block_vol_list)
self.assertTrue(vol_name.startswith(
self.sc.get('volumenameprefix', 'autotest')))
def test_volname_prefix_glusterblock(self):
"""Validate custom volname prefix blockvol"""
self.dynamic_provisioning_glusterblock(set_hacount=False,
create_vol_name_prefix=True)
pv_name = get_pv_name_from_pvc(self.node, self.pvc_name)
vol_name = oc_get_custom_resource(
self.node, 'pv', ':.metadata.annotations.glusterBlockShare',
pv_name)[0]
block_vol_list = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url)
self.assertIn(vol_name, block_vol_list)
self.assertTrue(
vol_name.startswith(self.sc.get('volumenameprefix', 'autotest')))
def test_block_volume_delete(self):
"""Validate deletion of gluster-block volume and capacity of used pool
"""
block_vol = heketi_blockvolume_create(
self.heketi_client_node, self.heketi_server_url, 1, json=True)
self.addCleanup(
heketi_blockvolume_delete, self.heketi_client_node,
self.heketi_server_url, block_vol["id"], raise_on_error=False)
heketi_blockvolume_delete(
self.heketi_client_node, self.heketi_server_url,
block_vol["id"], json=True)
volume_list = heketi_blockvolume_list(
self.heketi_client_node, self.heketi_server_url, json=True)
self.assertNotIn(block_vol["id"], volume_list["blockvolumes"],
"The block volume has not been successfully deleted,"
" ID is %s" % block_vol["id"])
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_block_volume_list(self):
"""Validate heketi blockvolume list command works as expected"""
created_vol_ids = []
for count in range(3):
block_vol = heketi_blockvolume_create(
self.heketi_client_node, self.heketi_server_url, 1, json=True)
self.addCleanup(
heketi_blockvolume_delete, self.heketi_client_node,
self.heketi_server_url, block_vol["id"])
created_vol_ids.append(block_vol["id"])
volumes = heketi_blockvolume_list(
self.heketi_client_node, self.heketi_server_url, json=True)
existing_vol_ids = volumes.values()[0]
for vol_id in created_vol_ids:
self.assertIn(vol_id, existing_vol_ids,
"Block vol with '%s' ID is absent in the "
"list of block volumes." % vol_id)
def test_block_volume_list(self):
"""Validate heketi blockvolume list command works as expected"""
created_vol_ids = []
for count in range(3):
block_vol = heketi_blockvolume_create(self.heketi_client_node,
self.heketi_server_url,
1,
json=True)
self.addCleanup(heketi_blockvolume_delete, self.heketi_client_node,
self.heketi_server_url, block_vol["id"])
created_vol_ids.append(block_vol["id"])
volumes = heketi_blockvolume_list(self.heketi_client_node,
self.heketi_server_url,
json=True)
existing_vol_ids = list(volumes.values())[0]
for vol_id in created_vol_ids:
self.assertIn(
vol_id, existing_vol_ids,
"Block vol with '%s' ID is absent in the "
"list of block volumes." % vol_id)
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))
