def perform_module_operation(self):
"""
Perform different actions on the port based on user parameters
specified in the playbook
"""
port_details = None
changed = False
# Get port details
port_details = self.get_port()
if port_details is None and self.state == 'absent':
msg = "Could not get the details of the port {0} from {1}"
msg = msg.format(self.port_nm, self.cl_name)
LOG.error(msg)
elif port_details is None and self.state == 'present':
msg = "Could not get the details of the port {0} from {1}"
msg = msg.format(self.port_nm, self.cl_name)
LOG.error(msg)
self.module.fail_json(msg=msg)
elif port_details and self.enabled is not None:
if self.enabled != port_details.enabled:
port_details = self.en_dis_port()
changed = True
# Finally update the module changed state details
self.result["changed"] = changed
if port_details:
port_details = utils.serialize_content(port_details)
self.result["port_details"] = port_details
self.module.exit_json(**self.result)
def exit_module(volume, change_flag):
"""module exit function"""
volume = utils.serialize_content(volume)
if 'itls' in volume:
volume = filter_itls(volume)
result = {"changed": change_flag, "storage_details": volume}
LOG.debug("Result %s\n", result)
self.module.exit_json(**result)
def perform_module_operation(self):
"""
Perform Rediscover StorageArray operation based on user parameters
chosen in playbook
"""
cluster_name = self.module.params['cluster_name']
array_name = self.module.params['array_name']
rediscover = self.module.params['rediscover']
array_present = self.get_array(cluster_name, array_name)
changed = False
result = dict(changed=False, array_details=None)
array_details = utils.serialize_content(array_present)
if rediscover:
LOG.info("Rediscover Array %s", array_name)
obj_array = self.rediscover_array(cluster_name, array_name)
array_details = utils.serialize_content(obj_array)
changed = True
result['changed'] = changed
result['array_details'] = array_details
self.module.exit_json(**result)
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_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 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_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 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_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_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 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_cgrp(self, cluster_name, cg_name):
"""
Get the details of a consistency group.
"""
try:
obj_cgrp = self.cgrp.get_consistency_group(cluster_name, cg_name)
LOG.info("Got consistency group details %s from %s", cg_name,
cluster_name)
LOG.debug("Consistency group Details:\n%s", obj_cgrp)
cg_details = utils.serialize_content(obj_cgrp)
return cg_details
except utils.ApiException as err:
err_msg = ("Could not get consistency group {0} of {1} due to"
" error: {2}".format(cg_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return None
def get_consistency_group_list(self, cluster_name=None):
"""Get the list of consistency groups on a specific cluster
in VPLEX"""
try:
consistency_grp = self.api_obj.ConsistencyGroupApi(
api_client=self.client)
obj = consistency_grp.get_consistency_groups(cluster_name)
self.logmsg('Consistency Group', obj, cluster_name)
consistency_grp_details = utils.serialize_content(obj)
return self.parse_data(consistency_grp_details)
except utils.ApiException as err:
err_msg = ("Could not get Consistency Groups 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_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
def is_virtual_vol_in_use(self, virtualvol):
"""
Checks if virtual volume is used by any other storage view
"""
try:
get_map = self.maps.get_map(virtualvol)
except utils.ApiException as err:
msg = ("Could not get the map view of {0} due to "
"error {1}".format(virtualvol, utils.error_msg(err)))
LOG.error("%s\n%s\n", msg, err)
self.module.fail_json(msg=msg)
vview_list = utils.serialize_content(get_map)
# Collect the storage view if it has virtual volume
if len(vview_list['parents']) > 0:
return True
return False
def get_d_cgrp(self, dr_cg_name):
"""
Get the details of a distributed consistency group.
"""
try:
obj_dcgrp = self.dcgrp.get_distributed_consistency_group(
dr_cg_name)
LOG.info("Got distributed consistency group details %s",
dr_cg_name)
LOG.debug("Distributed consistency group Details:\n%s", obj_dcgrp)
d_cg_details = utils.serialize_content(obj_dcgrp)
return d_cg_details
except utils.ApiException as err:
err_msg = ("Could not get 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)
return None
def get_virtual_volume_list(self, cluster_name=None):
"""Get the list of virtual volumes on a specific cluster
in VPLEX"""
try:
virtual_volume = self.api_obj.VirtualVolumeApi(
api_client=self.client)
obj = virtual_volume.get_virtual_volumes(cluster_name)
self.logmsg('Virtual Volume', obj, cluster_name)
virt_vol_details = utils.serialize_content(obj)
return self.parse_data(virt_vol_details)
except utils.ApiException as err:
err_msg = ("Could not get Virtual Volumes 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 create_d_cgrp(self, d_cg_payload):
"""
Create Distributed consistency group on VPLEX
"""
try:
obj_d_cgrp = self.dcgrp.create_distributed_consistency_group(
d_cg_payload)
LOG.info("Created distributed consistency group %s",
d_cg_payload['name'])
LOG.debug("Consistency group details:\n%s", obj_d_cgrp)
d_cg_details = utils.serialize_content(obj_d_cgrp)
return d_cg_details
except utils.ApiException as err:
err_msg = ("Could not create distributed consistency group {0}"
" due to error: {1}".format(d_cg_payload['name'],
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def update_d_cgrp(self, dr_cg_name, d_cg_patch_payload):
"""
Update distributed consistency group attributes
"""
try:
obj_dcgrp = self.dcgrp.patch_distributed_consistency_group(
dr_cg_name, d_cg_patch_payload)
LOG.info("Final payload: %s", d_cg_patch_payload)
LOG.info("Updated distributed consistency group %s", dr_cg_name)
LOG.debug("Distributed consistency group details:\n%s", obj_dcgrp)
d_cg_details = utils.serialize_content(obj_dcgrp)
return d_cg_details
except utils.ApiException as err:
err_msg = ("Could not update the 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 d_resume(self, dr_cg_name, d_cg_resume_payload):
"""
resume Distributed consistency group
"""
try:
obj_dcgrp = self.dcgrp.resume(dr_cg_name, d_cg_resume_payload)
LOG.info("Resume on the distributed consistency group %s",
dr_cg_name)
LOG.debug("Distributed consistency group details:\n%s", obj_dcgrp)
d_cg_details = utils.serialize_content(obj_dcgrp)
return d_cg_details
except utils.ApiException as err:
err_msg = ("Could not resume 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 create_cgrp(self, cluster_name, cg_payload):
"""
Create consistency group on VPLEX
"""
try:
obj_cgrp = self.cgrp.create_consistency_group(
cluster_name, cg_payload)
LOG.info("Created consistency group %s in %s", cg_payload['name'],
cluster_name)
LOG.debug("Consistency group details:\n%s", obj_cgrp)
cg_details = utils.serialize_content(obj_cgrp)
return cg_details
except utils.ApiException as err:
err_msg = ("Could not create consistency group {0} in {1} due to"
" error: {2}".format(cg_payload['name'], cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def create_job(
self,
migration_name,
cluster_name, # pylint: disable=R0913
target_cluster,
source_name,
target_name,
transfer_size,
status):
"""
Create data migration job on VPLEX
"""
# Validate the source and the target
self.validate_src_target(cluster_name, target_cluster, source_name,
target_name)
try:
src_uri = ("/vplex/v2/clusters/{0}/{1}/{2}".format(
cluster_name, self.storage_uri, source_name))
target_uri = ("/vplex/v2/clusters/{0}/{1}/{2}".format(
target_cluster, self.storage_uri, target_name))
data_payload = {
'name': migration_name,
'source': src_uri,
'target': target_uri
}
if status == "pause":
data_payload['paused'] = True
if transfer_size:
data_payload['transfer_size'] = transfer_size
if self.storage == "device":
job_details = self.data.create_device_migration(data_payload)
LOG.info("Created a %s migration job %s", self.storage,
migration_name)
LOG.debug("%s migration job details:\n%s", self.storage,
job_details)
job_details = utils.serialize_content(job_details)
return job_details
except utils.ApiException as err:
err_msg = ("Could not create {0} migration job {1} due to"
" error: {1}".format(migration_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def exit_module(volume, change_flag):
"""module exit function"""
volume = utils.serialize_content(volume)
if vol_type:
if vol_type == 'mirrored':
volume['mirrors'] = list(children.values())
volume['additional_devs'] = []
elif vol_type == 'expanded':
volume['mirrors'] = []
volume['additional_devs'] = list(children.values())
elif volume != {}:
volume['mirrors'] = []
volume['additional_devs'] = []
result = {
"changed": change_flag,
"storage_details": volume
}
LOG.debug("Result %s\n", result)
self.module.exit_json(**result)
def create_device(self, cluster_name, device_payload):
"""
Create device on VPLEX
"""
try:
obj_device = self.device.create_device(cluster_name,
device_payload)
LOG.info("Created device in %s", 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 create device {0} in {1} due to"
" error: {2}".format(device_payload['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_job_details(self, migration_name):
"""
Get the details of a migration job
"""
try:
job_details = None
if self.storage == "device":
job_details = self.data.get_device_migration(migration_name)
LOG.info("Got the %s migration job details %s ", self.storage,
migration_name)
LOG.debug("%s migration job details:\n%s", self.storage,
job_details)
job_details = utils.serialize_content(job_details)
return job_details
except utils.ApiException as err:
err_msg = ("Could not get {0} migration job {1} details due to"
" error: {2}".format(self.storage, migration_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
return None
def update_cgrp(self, cluster_name, cg_name, cg_patch_payload):
"""
Update consistency group attributes
"""
try:
obj_cgrp = self.cgrp.patch_consistency_group(
cluster_name, cg_name, cg_patch_payload)
LOG.info("Final payload: %s", cg_patch_payload)
LOG.info("Updated consistency group %s in %s", cg_name,
cluster_name)
LOG.debug("Consistency group details:\n%s", obj_cgrp)
cg_details = utils.serialize_content(obj_cgrp)
return cg_details
except utils.ApiException as err:
err_msg = ("Could not update the consistency group {0} in {1} due"
" to error: {2}".format(cg_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def update_local_device(self, cluster_name, device_name,
device_patch_payload):
"""
Update device attributes
"""
try:
LOG.info("Final payload: %s", device_patch_payload)
obj_device = self.device.patch_local_device(
cluster_name, device_name, device_patch_payload)
LOG.info("Updated device %s in %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 update the device {0} in {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 is_extent_inuse(self, cluster_name, extent_name):
"""
Check if the extent is used by any Device
"""
try:
extent_details = None
use = None
extent_details = self.ext.get_extent(cluster_name, extent_name)
if extent_details:
LOG.debug("Extent details:\n%s", str(extent_details))
use = extent_details.use
extent_details = utils.serialize_content(extent_details)
return (use, extent_details)
except utils.ApiException as err:
err_msg = ("Could not get extent details {0} of {1} due to"
" error: {2}".format(extent_name, cluster_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def update_migration_job(self, migration_name, data_patch_payload):
"""
Update data migration job
"""
try:
LOG.info("Final payload: %s", data_patch_payload)
if self.storage == "device":
job_details = self.data.patch_device_migration(
migration_name, data_patch_payload)
LOG.info("Updated the %s data migration job %s", self.storage,
migration_name)
LOG.debug("%s migration job details:\n%s", self.storage,
job_details)
job_details = utils.serialize_content(job_details)
return job_details
except utils.ApiException as err:
err_msg = ("Could not update the migration job {0} due to"
" error: {1}".format(migration_name,
utils.error_msg(err)))
LOG.error("%s\n%s\n", err_msg, err)
self.module.fail_json(msg=err_msg)
def exit_module(changed, initiator_details):
self.result["changed"] = changed
if initiator_details:
initiator_details = utils.serialize_content(initiator_details)
self.result["initiator_details"] = initiator_details
self.module.exit_json(**self.result)
