def is_storvol_inuse(self, stor_vol, ext_name):
"""
Get the status of the storage volume
"""
try:
extent_details = None
use = None
details = None
details = self.stor_obj.get_storage_volume(self.cl_name, stor_vol)
LOG.info("Got the details of storage volume %s in %s", stor_vol,
self.cl_name)
if details:
if details.use == "used":
extent_name = details.used_by[0].split('/')[-1]
extent_details = self.get_extent(extent_name)
if extent_details:
LOG.info(
"The storage volume %s contains an extent"
" %s in %s", stor_vol, extent_name, self.cl_name)
else:
if ext_name is None and self.state != 'absent':
msg = "Could not get extent details from {0} "\
"because it has no extent on it".format(stor_vol)
LOG.error(msg)
self.module.fail_json(msg=msg)
use = details.use
return (use, extent_details, details)
except utils.ApiException as err:
err_msg = ("Could not get storage volume details {0} from {1} due"
" to error: {2}".format(stor_vol, self.cl_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_clusters(self):
"""Get all clusters object from VPLEX"""
LOG.info('Get all clusters')
try:
res = self.cluster_cl.get_clusters()
LOG.debug('Clusters details: %s', res)
return [each.name for each in res]
except utils.ApiException as err:
err_msg = ("Could not get all clusters due to "
"error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return str(err_msg)
def get_clusters(self):
"""Get the list of clusters in VPLEX"""
try:
clusters = self.api_obj.ClustersApi(api_client=self.client)
obj = clusters.get_clusters()
self.logmsg('cluster', obj)
return obj
except utils.ApiException as err:
err_msg = ("Could not get Clusters due to"
" error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def is_device_present(self, cluster_name, device_name):
""" checking if device present or not """
try:
LOG.info("Trying to check whether given device is present")
obj_device = self.device.get_device(cluster_name, device_name)
LOG.info("Found the device %s in %s", device_name, cluster_name)
return obj_device
except utils.ApiException as ex:
err_msg = 'Could not find the device {0}'.format(device_name)
err_msg += ' in {0} due to error: {1}'.format(
cluster_name, utils.error_msg(ex))
LOG.error("%s\n%s\n", err_msg, ex)
return None
def get_all_devices(self, cluster_name):
"""Get all devices from VPLEX"""
LOG.info('Get all devices from %s', cluster_name)
try:
all_devs = self.dev_cl.get_devices(
cluster_name=cluster_name)
LOG.debug("Obtained devices details: %s", all_devs)
return all_devs
except utils.ApiException as err:
err_msg = ("Could not get all devices from "
"{0} due to error: {1}".format(
cluster_name, utils.error_msg(err)))
LOG.error("%s\n%s", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_be_port_list(self):
"""Get the list of back end ports on a specific cluster in VPLEX"""
try:
be_port = self.api_obj.HardwarePortsApi(api_client=self.client)
obj = be_port.get_hardware_ports(role="back-end")
self.logmsg('Back end Port', obj)
port_details = utils.serialize_content(obj)
return port_details
except utils.ApiException as err:
err_msg = ("Could not get Back end Ports due to"
" error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_distributed_virtual_volume(self, vol_name):
"""Get distributed virtual volume object by volume name"""
LOG.info('Get distributed virtual volume by name')
try:
res = self.dist_virt_cl.get_distributed_virtual_volume(vol_name)
LOG.info("Got distributed virtual volume details %s", vol_name)
LOG.debug("Volume details: %s", res)
return res, None
except utils.ApiException as err:
err_msg = ("Could not get distributed virtual volume {0} from"
" {1} due to error: {2}".format(
vol_name, self.cluster_name, utils.error_msg(err)))
LOG.error("%s\n%s", err_msg, err)
return None, err_msg
def get_distributed_device(self, dev_name):
"""
Get distributed device details
"""
try:
dev = self.distvv.get_distributed_device(dev_name)
LOG.info("Got Distributed Device details %s", dev_name)
LOG.debug("Distributed Device Details: %s", dev)
return dev
except utils.ApiException as err:
err_msg = ("Could not get the distributed device {0} due to"
" error: {1}".format(dev_name, utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return None
def get_distributed_virtual_volumes(self):
"""
Get all distributed virtual volumes
"""
LOG.info("Get all distributed virtual volumes")
try:
res = self.distvv.get_distributed_virtual_volumes()
LOG.debug("Distributed Virtual Volumes Details: %s", res)
return res
except utils.ApiException as err:
err_msg = ("Could not get the distributed virtual volumes due to"
" error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def delete_distributed_vv(self, dist_vv_name):
"""
Delete the distributed virtual volume
"""
try:
self.distvv.delete_distributed_virtual_volume(dist_vv_name)
LOG.info("Deleted distributed virtual volume %s", dist_vv_name)
return True
except utils.ApiException as err:
err_msg = ("Could not delete distributed virtual volume {0} due"
" to error: {1}".format(dist_vv_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def delete_storageview(self):
"""
Delete a storageview
"""
try:
self.storageview.delete_storage_view(self.cl_name, self.st_name)
LOG.info("Successfully deleted storageview %s from %s",
self.st_name, self.cl_name)
except utils.ApiException as err:
err_msg = ("Could not delete storageview {0} from {1} due to "
"error: {3}".format(self.st_name, self.cl_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def delete_extent(self, extent_name):
"""
Delete an extent
"""
try:
self.extent.delete_extent(self.cl_name, extent_name)
LOG.info("Deleted extent %s from %s", extent_name, self.cl_name)
return True
except utils.ApiException as err:
err_msg = ("Could not delete extent {0} from {1} due to"
" error: {2}".format(extent_name, self.cl_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_device_migration_list(self):
"""Get the list of device migration jobs in VPLEX"""
try:
device_mig = self.api_obj.DataMigrationApi(api_client=self.client)
obj = device_mig.get_device_migrations()
self.logmsg('Device migration job', obj)
device_mig_details = utils.serialize_content(obj)
return self.parse_data(device_mig_details)
except utils.ApiException as err:
err_msg = ("Could not get Device migration jobs due to"
" error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def delete_d_cgrp(self, dr_cg_name):
"""
Delete distributed consistency group on VPLEX
"""
try:
self.dcgrp.delete_distributed_consistency_group(dr_cg_name)
LOG.info("Deleted the distributed consistency group %s",
dr_cg_name)
return True
except utils.ApiException as err:
err_msg = ("Could not delete distributed consistency group {0} due"
" to error: {1}".format(dr_cg_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_initiator_list(self, cluster_name=None):
"""Get the list of initiators on a specific cluster in VPLEX"""
try:
initiator = self.api_obj.ExportsApi(api_client=self.client)
obj = initiator.get_initiator_ports(cluster_name)
self.logmsg('Initiator', obj, cluster_name)
initiator_details = utils.serialize_content(obj)
return self.parse_data(initiator_details, initiator=True)
except utils.ApiException as err:
err_msg = ("Could not get Initiators from {0} due to"
" error: {1}".format(cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_extent_list(self, cluster_name=None):
"""Get the list of extents on a specific cluster in VPLEX"""
try:
extent = self.api_obj.ExtentApi(api_client=self.client)
obj = extent.get_extents(cluster_name)
self.logmsg('Extent', obj, cluster_name)
device_details = utils.serialize_content(obj)
return self.parse_data(device_details)
except utils.ApiException as err:
err_msg = ("Could not get Extents from {0} due to"
" error: {1}".format(cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_distributed_consistency_group_list(self):
"""Get the list of distributed consistency groups in VPLEX"""
try:
dist_cgp = self.api_obj.DistributedStorageApi(
api_client=self.client)
obj = dist_cgp.get_distributed_consistency_groups()
self.logmsg('Distributed Consistency Group', obj)
dist_cg_details = utils.serialize_content(obj)
return self.parse_data(dist_cg_details)
except utils.ApiException as err:
err_msg = ("Could not get Distributed Consistency Groups due to"
" error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_distributed_virtual_volume_list(self):
"""Get the list of distributed virtual volumes in VPLEX"""
try:
dist_virt_volume = self.api_obj.DistributedStorageApi(
api_client=self.client)
obj = dist_virt_volume.get_distributed_virtual_volumes()
self.logmsg('Distributed Virtual Volume', obj)
dist_virvol_details = utils.serialize_content(obj)
return self.parse_data(dist_virvol_details)
except utils.ApiException as err:
err_msg = ("Could not get Distributed Virtual Volumes due to"
" error: {0}".format(utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def delete_distributed_device(self, distributed_device_name):
"""delete distributed device """
try:
msg = "Trying to delete the distributed device {0}".format(
distributed_device_name)
LOG.info(msg)
dist_device_obj = self.distdevice.delete_distributed_device(
distributed_device_name)
LOG.info("Successfully deleted the distributed device")
return dist_device_obj
except utils.ApiException as ex:
err_msg = 'Could not delete the distributed device {0}'.format(
distributed_device_name)
err_msg += ' due to error: {0}'.format(utils.error_msg(ex))
LOG.error("%s\n%s\n", err_msg, ex)
self.module.fail_json(msg=err_msg)
def delete_device(self, cluster_name, device_name):
"""
Delete device on VPLEX
"""
try:
obj_device = self.device.delete_device(cluster_name, device_name)
LOG.info("Deleted device %s from %s", device_name, cluster_name)
LOG.debug("Device details:\n%s", obj_device)
return True
except utils.ApiException as err:
err_msg = ("Could not delete device {0} from {1} due to"
" error: {2}".format(device_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_port(self):
"""
Get port details
"""
try:
port_details = self.port.get_port(self.cl_name, self.port_nm)
LOG.info("Obtained the port %s details in %s",
self.port_nm, self.cl_name)
LOG.debug("Port Details:\n%s", port_details)
return port_details
except utils.ApiException as err:
err_msg = ("Could not get the Port {0} Details in {1} due to"
" error: {2}".format(
self.port_nm, self.cl_name, utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return None
def get_map(self, uri):
"""Get map object from VPLEX"""
obj = uri.split('/')[-1]
LOG.info('Get map for %s', obj)
try:
res = self.maps_cl.get_map(uri)
LOG.info('Map Found')
LOG.debug('Map details: %s', res)
return res
except utils.ApiException as err:
err_msg = ("Could not get map for {0} in {1} due to"
" error: {2}".format(
obj, self.cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return str(err_msg)
def rediscover_initiator(self):
"""
Rediscover initiator ports
"""
try:
initiator_details = self.initr.rediscover_initiator_ports(
self.cl_name)
LOG.info("Rediscovered initiators from %s", self.cl_name)
LOG.debug("Initiator Details:\n%s", initiator_details)
return initiator_details
except utils.ApiException as err:
err_msg = ("Could not discover initiators from {0} due to"
" error: {1}".format(self.cl_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def register_initiator(self, initiator_payload):
"""
Register an initiator port either with iscsi_name or port_wwn
"""
try:
det = self.initr.register_initiator_port( # pylint: disable=E1121
self.cl_name, initiator_payload)
LOG.info("Registered initiator %s in %s", det.name, self.cl_name)
LOG.debug("Initiator Details:\n%s", det)
return det
except utils.ApiException as err:
err_msg = ("Could not register initiator in {0} due to"
" error: {1}".format(self.cl_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_array_management_provider_list(self, cluster_name=None):
"""Get the list of registered array manamgement providers on a
specific cluster in VPLEX"""
try:
amps = self.api_obj.AmpApi(api_client=self.client)
obj = amps.get_array_management_providers(cluster_name)
self.logmsg('Array Management Provider', obj, cluster_name)
amp_details = utils.serialize_content(obj)
return self.parse_data(amp_details)
except utils.ApiException as err:
err_msg = ("Could not get Array Management Providers from {0}"
" due to error: {1}".format(cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def rediscover_array(self, cluster_name, array_name):
"""
Rediscover StorageArray on VPLEX
"""
try:
obj_array = self.rediscoverarray.rediscover_storage_array(
cluster_name, array_name)
LOG.info("Rediscovered StorageArray in %s", cluster_name)
LOG.debug("StorageArray details:\n%s", obj_array)
return obj_array
except utils.ApiException as err:
err_msg = ("Could not Rediscover array {0} in {1} due to"
" error: {2}".format(array_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def unregister_initiator(self, initiator_name):
"""
Unregister an initiator port
"""
try:
self.initr.unregister_initiator_port(
self.cl_name, initiator_name)
LOG.info("Unregistered initiator %s from %s", initiator_name,
self.cl_name)
return True
except utils.ApiException as err:
err_msg = ("Could not unregister initiator {0} from {1} due to"
" error: {2}".format(initiator_name, self.cl_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_storage_view_list(self, cluster_name=None):
"""Get the list of storage views on a specific cluster
in VPLEX"""
try:
storage_view = self.api_obj.ExportsApi(api_client=self.client)
obj = storage_view.get_storage_views(cluster_name)
self.logmsg('Storage View', obj, cluster_name)
view_details = utils.serialize_content(obj)
return self.parse_data(view_details)
except utils.ApiException as err:
err_msg = ("Could not get Storage Views from {0} due to"
" error: {1}".format(cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_array(self, cluster_name, array_name):
"""
Get the details of StorageArray
"""
try:
obj_array = self.rediscoverarray.get_storage_array(
cluster_name, array_name)
LOG.info("Got Array details %s from %s", array_name, cluster_name)
LOG.debug("StorageArray details:\n%s", obj_array)
return obj_array
except utils.ApiException as err:
err_msg = ("Could not get StorageArray {0} of {1} due to"
" error: {2}".format(array_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def get_device(self, cluster_name, device_name):
"""
Get the details of a device
"""
try:
obj_device = self.device.get_device(cluster_name, device_name)
LOG.info("Got device details for %s from %s", device_name,
cluster_name)
LOG.debug("Device Details:\n%s", obj_device)
device_details = utils.serialize_content(obj_device)
return device_details
except utils.ApiException as err:
err_msg = ("Could not get device {0} details in {1} due to"
" error: {2}".format(device_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return None
