class NetAppOntapNetPort(object):
"""
Modify a Net port
"""
def __init__(self):
"""
Initialize the Ontap Net Port Class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present'],
default='present'),
node=dict(required=True, type="str"),
ports=dict(required=True, type="list", aliases=['port']),
mtu=dict(required=False, type="str", default=None),
autonegotiate_admin=dict(required=False,
type="str",
default=None),
duplex_admin=dict(required=False, type="str", default=None),
speed_admin=dict(required=False, type="str", default=None),
flowcontrol_admin=dict(required=False,
type="str",
default=None),
ipspace=dict(required=False, type="str", default=None),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
self.set_playbook_zapi_key_map()
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def set_playbook_zapi_key_map(self):
self.na_helper.zapi_string_keys = {
'mtu': 'mtu',
'autonegotiate_admin': 'is-administrative-auto-negotiate',
'duplex_admin': 'administrative-duplex',
'speed_admin': 'administrative-speed',
'flowcontrol_admin': 'administrative-flowcontrol',
'ipspace': 'ipspace'
}
def get_net_port(self, port):
"""
Return details about the net port
:param: port: Name of the port
:return: Dictionary with current state of the port. None if not found.
:rtype: dict
"""
net_port_get = netapp_utils.zapi.NaElement('net-port-get-iter')
attributes = {
'query': {
'net-port-info': {
'node': self.parameters['node'],
'port': port
}
}
}
net_port_get.translate_struct(attributes)
try:
result = self.server.invoke_successfully(net_port_get, True)
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) >= 1:
port_info = result['attributes-list']['net-port-info']
port_details = dict()
else:
return None
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error getting net ports for %s: %s' %
(self.parameters['node'], to_native(error)),
exception=traceback.format_exc())
for item_key, zapi_key in self.na_helper.zapi_string_keys.items():
port_details[item_key] = port_info.get_child_content(zapi_key)
return port_details
def modify_net_port(self, port, modify):
"""
Modify a port
:param port: Name of the port
:param modify: dict with attributes to be modified
:return: None
"""
port_modify = netapp_utils.zapi.NaElement('net-port-modify')
port_attributes = {'node': self.parameters['node'], 'port': port}
for key in modify:
if key in self.na_helper.zapi_string_keys:
zapi_key = self.na_helper.zapi_string_keys.get(key)
port_attributes[zapi_key] = modify[key]
port_modify.translate_struct(port_attributes)
try:
self.server.invoke_successfully(port_modify, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error modifying net ports for %s: %s' %
(self.parameters['node'], to_native(error)),
exception=traceback.format_exc())
def autosupport_log(self):
"""
AutoSupport log for na_ontap_net_port
:return: None
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_net_port", cserver)
def apply(self):
"""
Run Module based on play book
"""
self.autosupport_log()
# Run the task for all ports in the list of 'ports'
for port in self.parameters['ports']:
current = self.get_net_port(port)
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if modify:
self.modify_net_port(port, modify)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapDisks(object):
''' object initialize and class methods '''
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
node=dict(required=True, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def disk_check(self):
"""
Check for disks
"""
disk_iter = netapp_utils.zapi.NaElement('storage-disk-get-iter')
disk_storage_info = netapp_utils.zapi.NaElement('storage-disk-info')
disk_raid_info = netapp_utils.zapi.NaElement('disk-raid-info')
disk_raid_info.add_new_child('container-type', 'unassigned')
disk_storage_info.add_child_elem(disk_raid_info)
disk_query = netapp_utils.zapi.NaElement('query')
disk_query.add_child_elem(disk_storage_info)
disk_iter.add_child_elem(disk_query)
result = self.server.invoke_successfully(disk_iter, True)
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) >= 1:
has_disks = "true"
return has_disks
def disk_assign(self):
"""
enable aggregate (online).
"""
assign_disk = netapp_utils.zapi.NaElement.create_node_with_children(
'disk-sanown-assign', **{'node-name': self.parameters['node'],
'all': 'true'})
try:
self.server.invoke_successfully(assign_disk,
enable_tunneling=True)
return True
except netapp_utils.zapi.NaApiError as error:
if to_native(error.code) == "13001":
# Error 13060 denotes aggregate is already online
return False
else:
self.module.fail_json(msg='Error assigning disks %s' %
(to_native(error)),
exception=traceback.format_exc())
def apply(self):
'''Apply action to disks'''
changed = False
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=results)
netapp_utils.ems_log_event("na_ontap_disks", cserver)
# check if anything needs to be changed (add/delete/update)
unowned_disks = self.disk_check()
if unowned_disks == 'true':
self.disk_assign()
changed = True
self.module.exit_json(changed=changed)
class NetAppONTAPSnapmirror(object):
"""
Class with Snapmirror methods
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
source_vserver=dict(required=False, type='str'),
destination_vserver=dict(required=False, type='str'),
source_volume=dict(required=False, type='str'),
destination_volume=dict(required=False, type='str'),
source_path=dict(required=False, type='str'),
destination_path=dict(required=False, type='str'),
schedule=dict(required=False, type='str'),
policy=dict(required=False, type='str'),
relationship_type=dict(required=False, type='str',
choices=['data_protection', 'load_sharing',
'vault', 'restore',
'transition_data_protection',
'extended_data_protection']
),
source_hostname=dict(required=False, type='str'),
connection_type=dict(required=False, type='str',
choices=['ontap_ontap', 'elementsw_ontap', 'ontap_elementsw'],
default='ontap_ontap'),
source_username=dict(required=False, type='str'),
source_password=dict(required=False, type='str', no_log=True),
max_transfer_rate=dict(required=False, type='int'),
identity_preserve=dict(required=False, type='bool')
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_together=(['source_volume', 'destination_volume'],
['source_vserver', 'destination_vserver']),
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# setup later if required
self.source_server = None
# only for ElementSW -> ONTAP snapmirroring, validate if ElementSW SDK is available
if self.parameters.get('connection_type') in ['elementsw_ontap', 'ontap_elementsw']:
if HAS_SF_SDK is False:
self.module.fail_json(msg="Unable to import the SolidFire Python SDK")
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
if self.parameters.get('connection_type') != 'ontap_elementsw':
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
else:
if self.parameters.get('source_username'):
self.module.params['username'] = self.parameters['source_username']
if self.parameters.get('source_password'):
self.module.params['password'] = self.parameters['source_password']
self.module.params['hostname'] = self.parameters['source_hostname']
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def set_element_connection(self, kind):
if kind == 'source':
self.module.params['hostname'] = self.parameters['source_hostname']
self.module.params['username'] = self.parameters['source_username']
self.module.params['password'] = self.parameters['source_password']
elif kind == 'destination':
self.module.params['hostname'] = self.parameters['hostname']
self.module.params['username'] = self.parameters['username']
self.module.params['password'] = self.parameters['password']
elem = netapp_utils.create_sf_connection(module=self.module)
elementsw_helper = NaElementSWModule(elem)
return elementsw_helper, elem
def snapmirror_get_iter(self, destination=None):
"""
Compose NaElement object to query current SnapMirror relations using destination-path
SnapMirror relation for a destination path is unique
:return: NaElement object for SnapMirror-get-iter
"""
snapmirror_get_iter = netapp_utils.zapi.NaElement('snapmirror-get-iter')
query = netapp_utils.zapi.NaElement('query')
snapmirror_info = netapp_utils.zapi.NaElement('snapmirror-info')
if destination is None:
destination = self.parameters['destination_path']
snapmirror_info.add_new_child('destination-location', destination)
query.add_child_elem(snapmirror_info)
snapmirror_get_iter.add_child_elem(query)
return snapmirror_get_iter
def snapmirror_get(self, destination=None):
"""
Get current SnapMirror relations
:return: Dictionary of current SnapMirror details if query successful, else None
"""
snapmirror_get_iter = self.snapmirror_get_iter(destination)
snap_info = dict()
try:
result = self.server.invoke_successfully(snapmirror_get_iter, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching snapmirror info: %s' % to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) > 0:
snapmirror_info = result.get_child_by_name('attributes-list').get_child_by_name(
'snapmirror-info')
snap_info['mirror_state'] = snapmirror_info.get_child_content('mirror-state')
snap_info['status'] = snapmirror_info.get_child_content('relationship-status')
snap_info['schedule'] = snapmirror_info.get_child_content('schedule')
snap_info['policy'] = snapmirror_info.get_child_content('policy')
snap_info['relationship'] = snapmirror_info.get_child_content('relationship-type')
if snapmirror_info.get_child_by_name('max-transfer-rate'):
snap_info['max_transfer_rate'] = int(snapmirror_info.get_child_content('max-transfer-rate'))
if snap_info['schedule'] is None:
snap_info['schedule'] = ""
return snap_info
return None
def check_if_remote_volume_exists(self):
"""
Validate existence of source volume
:return: True if volume exists, False otherwise
"""
self.set_source_cluster_connection()
# do a get volume to check if volume exists or not
volume_info = netapp_utils.zapi.NaElement('volume-get-iter')
volume_attributes = netapp_utils.zapi.NaElement('volume-attributes')
volume_id_attributes = netapp_utils.zapi.NaElement('volume-id-attributes')
volume_id_attributes.add_new_child('name', self.parameters['source_volume'])
# if source_volume is present, then source_vserver is also guaranteed to be present
volume_id_attributes.add_new_child('vserver-name', self.parameters['source_vserver'])
volume_attributes.add_child_elem(volume_id_attributes)
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(volume_attributes)
volume_info.add_child_elem(query)
try:
result = self.source_server.invoke_successfully(volume_info, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching source volume details %s : %s'
% (self.parameters['source_volume'], to_native(error)),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) > 0:
return True
return False
def snapmirror_create(self):
"""
Create a SnapMirror relationship
"""
if self.parameters.get('source_hostname') and self.parameters.get('source_volume'):
if not self.check_if_remote_volume_exists():
self.module.fail_json(msg='Source volume does not exist. Please specify a volume that exists')
options = {'source-location': self.parameters['source_path'],
'destination-location': self.parameters['destination_path']}
snapmirror_create = netapp_utils.zapi.NaElement.create_node_with_children('snapmirror-create', **options)
if self.parameters.get('relationship_type'):
snapmirror_create.add_new_child('relationship-type', self.parameters['relationship_type'])
if self.parameters.get('schedule'):
snapmirror_create.add_new_child('schedule', self.parameters['schedule'])
if self.parameters.get('policy'):
snapmirror_create.add_new_child('policy', self.parameters['policy'])
if self.parameters.get('max_transfer_rate'):
snapmirror_create.add_new_child('max-transfer-rate', str(self.parameters['max_transfer_rate']))
if self.parameters.get('identity_preserve'):
snapmirror_create.add_new_child('identity-preserve', str(self.parameters['identity_preserve']))
try:
self.server.invoke_successfully(snapmirror_create, enable_tunneling=True)
self.snapmirror_initialize()
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating SnapMirror %s' % to_native(error),
exception=traceback.format_exc())
def set_source_cluster_connection(self):
"""
Setup ontap ZAPI server connection for source hostname
:return: None
"""
if self.parameters.get('source_username'):
self.module.params['username'] = self.parameters['source_username']
if self.parameters.get('source_password'):
self.module.params['password'] = self.parameters['source_password']
self.module.params['hostname'] = self.parameters['source_hostname']
self.source_server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def delete_snapmirror(self, is_hci, relationship_type):
"""
Delete a SnapMirror relationship
#1. Quiesce the SnapMirror relationship at destination
#2. Break the SnapMirror relationship at the destination
#3. Release the SnapMirror at source
#4. Delete SnapMirror at destination
"""
if not is_hci:
if not self.parameters.get('source_hostname'):
self.module.fail_json(msg='Missing parameters for delete: Please specify the '
'source cluster hostname to release the SnapMirror relation')
# Quiesce at destination
self.snapmirror_quiesce()
# Break at destination
if relationship_type not in ['load_sharing', 'vault']:
self.snapmirror_break()
# if source is ONTAP, release the destination at source cluster
if not is_hci:
self.set_source_cluster_connection()
if self.get_destination():
# Release at source
self.snapmirror_release()
# Delete at destination
self.snapmirror_delete()
def snapmirror_quiesce(self):
"""
Quiesce SnapMirror relationship - disable all future transfers to this destination
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_quiesce = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-quiesce', **options)
try:
self.server.invoke_successfully(snapmirror_quiesce,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error Quiescing SnapMirror : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_delete(self):
"""
Delete SnapMirror relationship at destination cluster
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-destroy', **options)
try:
self.server.invoke_successfully(snapmirror_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting SnapMirror : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_break(self, destination=None):
"""
Break SnapMirror relationship at destination cluster
"""
if destination is None:
destination = self.parameters['destination_path']
options = {'destination-location': destination}
snapmirror_break = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-break', **options)
try:
self.server.invoke_successfully(snapmirror_break,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error breaking SnapMirror relationship : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_release(self):
"""
Release SnapMirror relationship from source cluster
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_release = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-release', **options)
try:
self.source_server.invoke_successfully(snapmirror_release,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error releasing SnapMirror relationship : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_abort(self):
"""
Abort a SnapMirror relationship in progress
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_abort = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-abort', **options)
try:
self.server.invoke_successfully(snapmirror_abort,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error aborting SnapMirror relationship : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_initialize(self):
"""
Initialize SnapMirror based on relationship type
"""
current = self.snapmirror_get()
if current['mirror_state'] != 'snapmirrored':
initialize_zapi = 'snapmirror-initialize'
if self.parameters.get('relationship_type') and self.parameters['relationship_type'] == 'load_sharing':
initialize_zapi = 'snapmirror-initialize-ls-set'
options = {'source-location': self.parameters['source_path']}
else:
options = {'destination-location': self.parameters['destination_path']}
snapmirror_init = netapp_utils.zapi.NaElement.create_node_with_children(
initialize_zapi, **options)
try:
self.server.invoke_successfully(snapmirror_init,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error initializing SnapMirror : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_modify(self, modify):
"""
Modify SnapMirror schedule or policy
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_modify = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-modify', **options)
if modify.get('schedule') is not None:
snapmirror_modify.add_new_child('schedule', modify.get('schedule'))
if modify.get('policy'):
snapmirror_modify.add_new_child('policy', modify.get('policy'))
if modify.get('max_transfer_rate'):
snapmirror_modify.add_new_child('max-transfer-rate', str(modify.get('max_transfer_rate')))
try:
self.server.invoke_successfully(snapmirror_modify,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error modifying SnapMirror schedule or policy : %s'
% (to_native(error)),
exception=traceback.format_exc())
def snapmirror_update(self):
"""
Update data in destination endpoint
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_update = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-update', **options)
try:
result = self.server.invoke_successfully(snapmirror_update,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error updating SnapMirror : %s'
% (to_native(error)),
exception=traceback.format_exc())
def check_parameters(self):
"""
Validate parameters and fail if one or more required params are missing
Update source and destination path from vserver and volume parameters
"""
if self.parameters['state'] == 'present'\
and (self.parameters.get('source_path') or self.parameters.get('destination_path')):
if not self.parameters.get('destination_path') or not self.parameters.get('source_path'):
self.module.fail_json(msg='Missing parameters: Source path or Destination path')
elif self.parameters.get('source_volume'):
if not self.parameters.get('source_vserver') or not self.parameters.get('destination_vserver'):
self.module.fail_json(msg='Missing parameters: source vserver or destination vserver or both')
self.parameters['source_path'] = self.parameters['source_vserver'] + ":" + self.parameters['source_volume']
self.parameters['destination_path'] = self.parameters['destination_vserver'] + ":" +\
self.parameters['destination_volume']
elif self.parameters.get('source_vserver'):
self.parameters['source_path'] = self.parameters['source_vserver'] + ":"
self.parameters['destination_path'] = self.parameters['destination_vserver'] + ":"
def get_destination(self):
result = None
release_get = netapp_utils.zapi.NaElement('snapmirror-get-destination-iter')
query = netapp_utils.zapi.NaElement('query')
snapmirror_dest_info = netapp_utils.zapi.NaElement('snapmirror-destination-info')
snapmirror_dest_info.add_new_child('destination-location', self.parameters['destination_path'])
query.add_child_elem(snapmirror_dest_info)
release_get.add_child_elem(query)
try:
result = self.source_server.invoke_successfully(release_get, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching snapmirror destinations info: %s' % to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) > 0:
return True
return None
@staticmethod
def element_source_path_format_matches(value):
return re.match(pattern=r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\/lun\/[0-9]+",
string=value)
def check_elementsw_parameters(self, kind='source'):
"""
Validate all ElementSW cluster parameters required for managing the SnapMirror relationship
Validate if both source and destination paths are present
Validate if source_path follows the required format
Validate SVIP
Validate if ElementSW volume exists
:return: None
"""
path = None
if kind == 'destination':
path = self.parameters.get('destination_path')
elif kind == 'source':
path = self.parameters.get('source_path')
if path is None:
self.module.fail_json(msg="Error: Missing required parameter %s_path for "
"connection_type %s" % (kind, self.parameters['connection_type']))
else:
if NetAppONTAPSnapmirror.element_source_path_format_matches(path) is None:
self.module.fail_json(msg="Error: invalid %s_path %s. "
"If the path is a ElementSW cluster, the value should be of the format"
" <Element_SVIP>:/lun/<Element_VOLUME_ID>" % (kind, path))
# validate source_path
elementsw_helper, elem = self.set_element_connection(kind)
self.validate_elementsw_svip(path, elem)
self.check_if_elementsw_volume_exists(path, elementsw_helper)
def validate_elementsw_svip(self, path, elem):
"""
Validate ElementSW cluster SVIP
:return: None
"""
result = None
try:
result = elem.get_cluster_info()
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error fetching SVIP", exception=to_native(err))
if result and result.cluster_info.svip:
cluster_svip = result.cluster_info.svip
svip = path.split(':')[0] # split IP address from source_path
if svip != cluster_svip:
self.module.fail_json(msg="Error: Invalid SVIP")
def check_if_elementsw_volume_exists(self, path, elementsw_helper):
"""
Check if remote ElementSW volume exists
:return: None
"""
volume_id, vol_id = None, path.split('/')[-1]
try:
volume_id = elementsw_helper.volume_id_exists(int(vol_id))
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error fetching Volume details", exception=to_native(err))
if volume_id is None:
self.module.fail_json(msg="Error: Source volume does not exist in the ElementSW cluster")
def asup_log_for_cserver(self, event_name):
"""
Fetch admin vserver for the given cluster
Create and Autosupport log event with the given module name
:param event_name: Name of the event log
:return: None
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=results)
netapp_utils.ems_log_event(event_name, cserver)
def apply(self):
"""
Apply action to SnapMirror
"""
self.asup_log_for_cserver("na_ontap_snapmirror")
# source is ElementSW
if self.parameters['state'] == 'present' and self.parameters.get('connection_type') == 'elementsw_ontap':
self.check_elementsw_parameters()
elif self.parameters.get('connection_type') == 'ontap_elementsw':
self.check_elementsw_parameters('destination')
else:
self.check_parameters()
if self.parameters['state'] == 'present' and self.parameters.get('connection_type') == 'ontap_elementsw':
current_elementsw_ontap = self.snapmirror_get(self.parameters['source_path'])
if current_elementsw_ontap is None:
self.module.fail_json(msg='Error: creating an ONTAP to ElementSW snapmirror relationship requires an '
'established SnapMirror relation from ElementSW to ONTAP cluster')
current = self.snapmirror_get()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(current, self.parameters)
element_snapmirror = False
if cd_action == 'create':
self.snapmirror_create()
elif cd_action == 'delete':
if current['status'] == 'transferring':
self.snapmirror_abort()
else:
if self.parameters.get('connection_type') == 'elementsw_ontap':
element_snapmirror = True
self.delete_snapmirror(element_snapmirror, current['relationship'])
else:
if modify:
self.snapmirror_modify(modify)
# check for initialize
if current and current['mirror_state'] != 'snapmirrored':
self.snapmirror_initialize()
# set changed explicitly for initialize
self.na_helper.changed = True
# Update when create is called again, or modify is being called
if self.parameters['state'] == 'present':
self.snapmirror_update()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapUser(object):
"""
Common operations to manage users and roles.
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
name=dict(required=True, type='str'),
applications=dict(required=True, type='list', aliases=['application'],
choices=['console', 'http', 'ontapi', 'rsh', 'snmp',
'sp', 'service-processor', 'ssh', 'telnet'],),
authentication_method=dict(required=True, type='str',
choices=['community', 'password',
'publickey', 'domain',
'nsswitch', 'usm']),
set_password=dict(required=False, type='str', no_log=True),
role_name=dict(required=False, type='str'),
lock_user=dict(required=False, type='bool'),
vserver=dict(required=True, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_if=[
('state', 'present', ['role_name'])
],
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def get_user(self, application=None):
"""
Checks if the user exists.
:param: application: application to grant access to
:return:
True if user found
False if user is not found
:rtype: bool
"""
security_login_get_iter = netapp_utils.zapi.NaElement('security-login-get-iter')
query_details = netapp_utils.zapi.NaElement.create_node_with_children(
'security-login-account-info', **{'vserver': self.parameters['vserver'],
'user-name': self.parameters['name'],
'authentication-method': self.parameters['authentication_method']})
if application is not None:
query_details.add_new_child('application', application)
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(query_details)
security_login_get_iter.add_child_elem(query)
try:
result = self.server.invoke_successfully(security_login_get_iter,
enable_tunneling=False)
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) >= 1:
interface_attributes = result.get_child_by_name('attributes-list').\
get_child_by_name('security-login-account-info')
return_value = {
'lock_user': interface_attributes.get_child_content('is-locked')
}
return return_value
return None
except netapp_utils.zapi.NaApiError as error:
# Error 16034 denotes a user not being found.
if to_native(error.code) == "16034":
return False
# Error 16043 denotes the user existing, but the application missing
elif to_native(error.code) == "16043":
return False
else:
self.module.fail_json(msg='Error getting user %s: %s' % (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def create_user(self, application):
"""
creates the user for the given application and authentication_method
:param: application: application to grant access to
"""
user_create = netapp_utils.zapi.NaElement.create_node_with_children(
'security-login-create', **{'vserver': self.parameters['vserver'],
'user-name': self.parameters['name'],
'application': application,
'authentication-method': self.parameters['authentication_method'],
'role-name': self.parameters.get('role_name')})
if self.parameters.get('set_password') is not None:
user_create.add_new_child('password', self.parameters.get('set_password'))
try:
self.server.invoke_successfully(user_create,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating user %s: %s' % (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def lock_given_user(self):
"""
locks the user
:return:
True if user locked
False if lock user is not performed
:rtype: bool
"""
user_lock = netapp_utils.zapi.NaElement.create_node_with_children(
'security-login-lock', **{'vserver': self.parameters['vserver'],
'user-name': self.parameters['name']})
try:
self.server.invoke_successfully(user_lock,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error locking user %s: %s' % (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def unlock_given_user(self):
"""
unlocks the user
:return:
True if user unlocked
False if unlock user is not performed
:rtype: bool
"""
user_unlock = netapp_utils.zapi.NaElement.create_node_with_children(
'security-login-unlock', **{'vserver': self.parameters['vserver'],
'user-name': self.parameters['name']})
try:
self.server.invoke_successfully(user_unlock,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
if to_native(error.code) == '13114':
return False
else:
self.module.fail_json(msg='Error unlocking user %s: %s' % (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
return True
def delete_user(self, application):
"""
deletes the user for the given application and authentication_method
:param: application: application to grant access to
"""
user_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'security-login-delete', **{'vserver': self.parameters['vserver'],
'user-name': self.parameters['name'],
'application': application,
'authentication-method': self.parameters['authentication_method']})
try:
self.server.invoke_successfully(user_delete,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error removing user %s: %s' % (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def change_password(self):
"""
Changes the password
:return:
True if password updated
False if password is not updated
:rtype: bool
"""
# self.server.set_vserver(self.parameters['vserver'])
modify_password = netapp_utils.zapi.NaElement.create_node_with_children(
'security-login-modify-password', **{
'new-password': str(self.parameters.get('set_password')),
'user-name': self.parameters['name']})
try:
self.server.invoke_successfully(modify_password,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
if to_native(error.code) == '13114':
return False
# if the user give the same password, instead of returning an error, return ok
if to_native(error.code) == '13214' and error.message.startswith('New password must be different than the old password.'):
return False
self.module.fail_json(msg='Error setting password for user %s: %s' % (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
self.server.set_vserver(None)
return True
def apply(self):
create_delete_decision = {}
modify = {}
netapp_utils.ems_log_event("na_ontap_user", self.server)
for application in self.parameters['applications']:
current = self.get_user(application)
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action is not None:
create_delete_decision[application] = cd_action
if not create_delete_decision and self.parameters.get('state') == 'present':
if self.parameters.get('set_password') is not None:
self.na_helper.changed = True
current = self.get_user()
if current is not None:
current['lock_user'] = self.na_helper.get_value_for_bool(True, current['lock_user'])
modify = self.na_helper.get_modified_attributes(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if create_delete_decision:
for cd_action in create_delete_decision:
if create_delete_decision[cd_action] == 'create':
self.create_user(cd_action)
elif create_delete_decision[cd_action] == 'delete':
self.delete_user(cd_action)
elif modify:
if self.parameters.get('lock_user'):
self.lock_given_user()
else:
self.unlock_given_user()
elif not create_delete_decision and self.parameters.get('set_password') is not None:
# if change password return false nothing has changed so we need to set changed to False
self.na_helper.changed = self.change_password()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapInterface(object):
''' object to describe interface info '''
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
interface_name=dict(required=True, type='str'),
home_node=dict(required=False, type='str', default=None),
home_port=dict(required=False, type='str'),
role=dict(required=False, type='str'),
address=dict(required=False, type='str'),
netmask=dict(required=False, type='str'),
vserver=dict(required=True, type='str'),
firewall_policy=dict(required=False, type='str',
default=None),
failover_policy=dict(required=False, type='str',
default=None),
admin_status=dict(required=False, choices=['up', 'down']),
subnet_name=dict(required=False, type='str'),
is_auto_revert=dict(required=False, type=bool, default=None),
protocols=dict(required=False, type='list')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def get_interface(self, interface_name=None):
"""
Return details about the interface
:param:
name : Name of the name of the interface
:return: Details about the interface. None if not found.
:rtype: dict
"""
if interface_name is None:
interface_name = self.parameters['interface_name']
interface_info = netapp_utils.zapi.NaElement('net-interface-get-iter')
interface_attributes = netapp_utils.zapi.NaElement(
'net-interface-info')
interface_attributes.add_new_child('interface-name', interface_name)
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(interface_attributes)
interface_info.add_child_elem(query)
result = self.server.invoke_successfully(interface_info, True)
return_value = None
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) >= 1:
interface_attributes = result.get_child_by_name('attributes-list').\
get_child_by_name('net-interface-info')
return_value = {
'interface_name':
self.parameters['interface_name'],
'admin_status':
interface_attributes['administrative-status'],
'home_port':
interface_attributes['home-port'],
'home_node':
interface_attributes['home-node'],
'address':
interface_attributes['address'],
'netmask':
interface_attributes['netmask'],
'failover_policy':
interface_attributes['failover-policy'].replace('_', '-'),
'firewall_policy':
interface_attributes['firewall-policy'],
'is_auto_revert':
True
if interface_attributes['is-auto-revert'] == 'true' else False,
}
return return_value
def set_options(self, options, parameters):
""" set attributes for create or modify """
if parameters.get('home_port') is not None:
options['home-port'] = parameters['home_port']
if parameters.get('subnet_name') is not None:
options['subnet-name'] = parameters['subnet_name']
if parameters.get('address') is not None:
options['address'] = parameters['address']
if parameters.get('netmask') is not None:
options['netmask'] = parameters['netmask']
if parameters.get('failover_policy') is not None:
options['failover-policy'] = parameters['failover_policy']
if parameters.get('firewall_policy') is not None:
options['firewall-policy'] = parameters['firewall_policy']
if parameters.get('is_auto_revert') is not None:
options['is-auto-revert'] = 'true' if parameters[
'is_auto_revert'] is True else 'false'
if parameters.get('admin_status') is not None:
options['administrative-status'] = parameters['admin_status']
def create_interface(self):
''' calling zapi to create interface '''
# validate if mandatory parameters are present for create
required_keys = set(
['role', 'address', 'home_node', 'home_port', 'netmask'])
if not required_keys.issubset(set(self.parameters.keys())):
self.module.fail_json(
msg=
'Error: Missing one or more required parameters for creating interface: %s'
% ', '.join(required_keys))
# if role is intercluster, protocol cannot be specified
if self.parameters['role'] == "intercluster" and self.parameters.get(
'protocols') is not None:
self.module.fail_json(
msg='Error: Protocol cannot be specified for intercluster role,'
'failed to create interface')
options = {
'interface-name': self.parameters['interface_name'],
'role': self.parameters['role'],
'home-node': self.parameters.get('home_node'),
'vserver': self.parameters['vserver']
}
self.set_options(options, self.parameters)
interface_create = netapp_utils.zapi.NaElement.create_node_with_children(
'net-interface-create', **options)
if self.parameters.get('protocols') is not None:
data_protocols_obj = netapp_utils.zapi.NaElement('data-protocols')
interface_create.add_child_elem(data_protocols_obj)
for protocol in self.parameters.get('protocols'):
data_protocols_obj.add_new_child('data-protocol', protocol)
try:
self.server.invoke_successfully(interface_create,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as exc:
self.module.fail_json(
msg='Error Creating interface %s: %s' %
(self.parameters['interface_name'], to_native(exc)),
exception=traceback.format_exc())
def delete_interface(self, current_status):
''' calling zapi to delete interface '''
if current_status == 'up':
self.parameters['admin_status'] = 'down'
self.modify_interface({'admin_status': 'down'})
interface_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'net-interface-delete', **{
'interface-name': self.parameters['interface_name'],
'vserver': self.parameters['vserver']
})
try:
self.server.invoke_successfully(interface_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as exc:
self.module.fail_json(
msg='Error deleting interface %s: %s' %
(self.parameters['interface_name'], to_native(exc)),
exception=traceback.format_exc())
def modify_interface(self, modify):
"""
Modify the interface.
"""
options = {
'interface-name': self.parameters['interface_name'],
'vserver': self.parameters['vserver']
}
self.set_options(options, modify)
interface_modify = netapp_utils.zapi.NaElement.create_node_with_children(
'net-interface-modify', **options)
try:
self.server.invoke_successfully(interface_modify,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as err:
self.module.fail_json(
msg='Error modifying interface %s: %s' %
(self.parameters['interface_name'], to_native(err)),
exception=traceback.format_exc())
def autosupport_log(self):
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_interface", cserver)
def apply(self):
''' calling all interface features '''
self.autosupport_log()
current = self.get_interface()
# rename and create are mutually exclusive
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_interface()
elif cd_action == 'delete':
self.delete_interface(current['admin_status'])
elif modify:
self.modify_interface(modify)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPNVMESubsystem(object):
"""
Class with NVME subsytem methods
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
subsystem=dict(required=True, type='str'),
ostype=dict(required=False, type='str', choices=['windows', 'linux', 'vmware', 'xen', 'hyper_v']),
skip_host_check=dict(required=False, type='bool', default=False),
skip_mapped_check=dict(required=False, type='bool', default=False),
hosts=dict(required=False, type='list'),
paths=dict(required=False, type='list')
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def get_subsystem(self):
"""
Get current subsystem details
:return: dict if subsystem exists, None otherwise
"""
subsystem_get = netapp_utils.zapi.NaElement('nvme-subsystem-get-iter')
query = {
'query': {
'nvme-subsytem-info': {
'subsystem': self.parameters.get('subsystem')
}
}
}
subsystem_get.translate_struct(query)
try:
result = self.server.invoke_successfully(subsystem_get, enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching subsystem info: %s' % to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1:
return True
return None
def create_subsystem(self):
"""
Create a NVME Subsystem
"""
if self.parameters.get('ostype') is None:
self.module.fail_json(msg="Error: Missing required parameter 'os_type' for creating subsystem")
options = {'subsystem': self.parameters['subsystem'],
'ostype': self.parameters['ostype']
}
subsystem_create = netapp_utils.zapi.NaElement('nvme-subsystem-create')
subsystem_create.translate_struct(options)
try:
self.server.invoke_successfully(subsystem_create, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating subsystem for %s: %s'
% (self.parameters.get('subsystem'), to_native(error)),
exception=traceback.format_exc())
def delete_subsystem(self):
"""
Delete a NVME subsystem
"""
options = {'subsystem': self.parameters['subsystem'],
'skip-host-check': 'true' if self.parameters.get('skip_host_check') else 'false',
'skip-mapped-check': 'true' if self.parameters.get('skip_mapped_check') else 'false',
}
subsystem_delete = netapp_utils.zapi.NaElement.create_node_with_children('nvme-subsystem-delete', **options)
try:
self.server.invoke_successfully(subsystem_delete, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting subsystem for %s: %s'
% (self.parameters.get('subsystem'), to_native(error)),
exception=traceback.format_exc())
def get_subsystem_host_map(self, type):
"""
Get current subsystem host details
:return: list if host exists, None otherwise
"""
if type == 'hosts':
zapi_get, zapi_info, zapi_type = 'nvme-subsystem-host-get-iter', 'nvme-target-subsystem-host-info',\
'host-nqn'
elif type == 'paths':
zapi_get, zapi_info, zapi_type = 'nvme-subsystem-map-get-iter', 'nvme-target-subsystem-map-info', 'path'
subsystem_get = netapp_utils.zapi.NaElement(zapi_get)
query = {
'query': {
zapi_info: {
'subsystem': self.parameters.get('subsystem')
}
}
}
subsystem_get.translate_struct(query)
try:
result = self.server.invoke_successfully(subsystem_get, enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching subsystem info: %s' % to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1:
attrs_list = result.get_child_by_name('attributes-list')
return_list = []
for item in attrs_list.get_children():
return_list.append(item[zapi_type])
return {type: return_list}
return None
def add_subsystem_host_map(self, data, type):
"""
Add a NVME Subsystem host/map
:param: data: list of hosts/paths to be added
:param: type: hosts/paths
"""
if type == 'hosts':
zapi_add, zapi_type = 'nvme-subsystem-host-add', 'host-nqn'
elif type == 'paths':
zapi_add, zapi_type = 'nvme-subsystem-map-add', 'path'
for item in data:
options = {'subsystem': self.parameters['subsystem'],
zapi_type: item
}
subsystem_add = netapp_utils.zapi.NaElement.create_node_with_children(zapi_add, **options)
try:
self.server.invoke_successfully(subsystem_add, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error adding %s for subsystem %s: %s'
% (item, self.parameters.get('subsystem'), to_native(error)),
exception=traceback.format_exc())
def remove_subsystem_host_map(self, data, type):
"""
Remove a NVME Subsystem host/map
:param: data: list of hosts/paths to be added
:param: type: hosts/paths
"""
if type == 'hosts':
zapi_remove, zapi_type = 'nvme-subsystem-host-remove', 'host-nqn'
elif type == 'paths':
zapi_remove, zapi_type = 'nvme-subsystem-map-remove', 'path'
for item in data:
options = {'subsystem': self.parameters['subsystem'],
zapi_type: item
}
subsystem_remove = netapp_utils.zapi.NaElement.create_node_with_children(zapi_remove, **options)
try:
self.server.invoke_successfully(subsystem_remove, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error removing %s for subsystem %s: %s'
% (item, self.parameters.get('subsystem'), to_native(error)),
exception=traceback.format_exc())
def associate_host_map(self, types):
"""
Check if there are hosts or paths to be associated with the subsystem
"""
action_add_dict = {}
action_remove_dict = {}
for type in types:
if self.parameters.get(type):
current = self.get_subsystem_host_map(type)
if current:
add_items = self.na_helper.\
get_modified_attributes(current, self.parameters, get_list_diff=True).get(type)
remove_items = [item for item in current[type] if item not in self.parameters.get(type)]
else:
add_items = self.parameters[type]
remove_items = {}
if add_items:
action_add_dict[type] = add_items
self.na_helper.changed = True
if remove_items:
action_remove_dict[type] = remove_items
self.na_helper.changed = True
return action_add_dict, action_remove_dict
def modify_host_map(self, add_host_map, remove_host_map):
for type, data in add_host_map.items():
self.add_subsystem_host_map(data, type)
for type, data in remove_host_map.items():
self.remove_subsystem_host_map(data, type)
def apply(self):
"""
Apply action to NVME subsystem
"""
netapp_utils.ems_log_event("na_ontap_nvme_subsystem", self.server)
types = ['hosts', 'paths']
current = self.get_subsystem()
add_host_map, remove_host_map = dict(), dict()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action != 'delete' and self.parameters['state'] == 'present':
add_host_map, remove_host_map = self.associate_host_map(types)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_subsystem()
self.modify_host_map(add_host_map, remove_host_map)
elif cd_action == 'delete':
self.delete_subsystem()
elif cd_action is None:
self.modify_host_map(add_host_map, remove_host_map)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapLUNCopy(object):
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present'],
default='present'),
destination_vserver=dict(required=True, type='str'),
destination_path=dict(required=True, type='str'),
source_path=dict(required=True, type='str'),
source_vserver=dict(required=False, type='str'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module,
vserver=self.parameters['destination_vserver'])
def get_lun(self):
"""
Check if the LUN exists
:return: true is it exists, false otherwise
:rtype: bool
"""
return_value = False
lun_info = netapp_utils.zapi.NaElement('lun-get-iter')
query_details = netapp_utils.zapi.NaElement('lun-info')
query_details.add_new_child('path',
self.parameters['destination_path'])
query_details.add_new_child('vserver',
self.parameters['destination_vserver'])
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(query_details)
lun_info.add_child_elem(query)
try:
result = self.server.invoke_successfully(lun_info, True)
except netapp_utils.zapi.NaApiError as e:
self.module.fail_json(
msg="Error getting lun info %s for verver %s: %s" %
(self.parameters['destination_path'],
self.parameters['destination_vserver'], to_native(e)),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) >= 1:
return_value = True
return return_value
def copy_lun(self):
"""
Copy LUN with requested path and vserver
"""
lun_copy = netapp_utils.zapi.NaElement.create_node_with_children(
'lun-copy-start',
**{'source-vserver': self.parameters['source_vserver']})
path_obj = netapp_utils.zapi.NaElement('paths')
pair = netapp_utils.zapi.NaElement('lun-path-pair')
pair.add_new_child('destination-path',
self.parameters['destination_path'])
pair.add_new_child('source-path', self.parameters['source_path'])
path_obj.add_child_elem(pair)
lun_copy.add_child_elem(path_obj)
try:
self.server.invoke_successfully(lun_copy, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as e:
self.module.fail_json(
msg="Error copying lun from %s to vserver %s: %s" %
(self.parameters['source_vserver'],
self.parameters['destination_vserver'], to_native(e)),
exception=traceback.format_exc())
def apply(self):
netapp_utils.ems_log_event("na_ontap_lun_copy", self.server)
if self.get_lun(): # lun already exists at destination
changed = False
else:
changed = True
if self.module.check_mode:
pass
else:
# need to copy lun
if self.parameters['state'] == 'present':
self.copy_lun()
self.module.exit_json(changed=changed)
class NetAppONTAPNVMENamespace(object):
"""
Class with NVME namespace methods
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
ostype=dict(required=False, type='str', choices=['windows', 'linux', 'vmware', 'xen', 'hyper_v']),
path=dict(required=True, type='str'),
size=dict(required=False, type='int')
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_if=[('state', 'present', ['ostype', 'size'])],
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def get_namespace(self):
"""
Get current namespace details
:return: dict if namespace exists, None otherwise
"""
namespace_get = netapp_utils.zapi.NaElement('nvme-namespace-get-iter')
query = {
'query': {
'nvme-namespace-info': {
'path': self.parameters['path'],
'vserver': self.parameters['vserver']
}
}
}
namespace_get.translate_struct(query)
try:
result = self.server.invoke_successfully(namespace_get, enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching namespace info: %s' % to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1:
return result
return None
def create_namespace(self):
"""
Create a NVME Namespace
"""
options = {'path': self.parameters['path'],
'ostype': self.parameters['ostype'],
'size': self.parameters['size']
}
namespace_create = netapp_utils.zapi.NaElement('nvme-namespace-create')
namespace_create.translate_struct(options)
try:
self.server.invoke_successfully(namespace_create, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating namespace for path %s: %s'
% (self.parameters.get('path'), to_native(error)),
exception=traceback.format_exc())
def delete_namespace(self):
"""
Delete a NVME Namespace
"""
options = {'path': self.parameters['path']
}
namespace_delete = netapp_utils.zapi.NaElement.create_node_with_children('nvme-namespace-delete', **options)
try:
self.server.invoke_successfully(namespace_delete, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting namespace for path %s: %s'
% (self.parameters.get('path'), to_native(error)),
exception=traceback.format_exc())
def apply(self):
"""
Apply action to NVME Namespace
"""
netapp_utils.ems_log_event("na_ontap_nvme_namespace", self.server)
current = self.get_namespace()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_namespace()
elif cd_action == 'delete':
self.delete_namespace()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapQosPolicyGroup(object):
"""
Create, delete, modify and rename a policy group.
"""
def __init__(self):
"""
Initialize the Ontap qos policy group class.
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str'),
vserver=dict(required=True, type='str'),
max_throughput=dict(required=False, type='str'),
min_throughput=dict(required=False, type='str'),
force=dict(required=False, type='bool', default=False)))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def get_policy_group(self, policy_group_name=None):
"""
Return details of a policy group.
:param policy_group_name: policy group name
:return: policy group details.
:rtype: dict.
"""
if policy_group_name is None:
policy_group_name = self.parameters['name']
policy_group_get_iter = netapp_utils.zapi.NaElement(
'qos-policy-group-get-iter')
policy_group_info = netapp_utils.zapi.NaElement(
'qos-policy-group-info')
policy_group_info.add_new_child('policy-group', policy_group_name)
policy_group_info.add_new_child('vserver', self.parameters['vserver'])
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(policy_group_info)
policy_group_get_iter.add_child_elem(query)
result = self.server.invoke_successfully(policy_group_get_iter, True)
policy_group_detail = None
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) == 1:
policy_info = result.get_child_by_name(
'attributes-list').get_child_by_name('qos-policy-group-info')
policy_group_detail = {
'name': policy_info.get_child_content('policy-group'),
'vserver': policy_info.get_child_content('vserver'),
'max_throughput':
policy_info.get_child_content('max-throughput'),
'min_throughput':
policy_info.get_child_content('min-throughput')
}
return policy_group_detail
def create_policy_group(self):
"""
create a policy group name.
"""
policy_group = netapp_utils.zapi.NaElement('qos-policy-group-create')
policy_group.add_new_child('policy-group', self.parameters['name'])
policy_group.add_new_child('vserver', self.parameters['vserver'])
if self.parameters.get('max_throughput'):
policy_group.add_new_child('max-throughput',
self.parameters['max_throughput'])
if self.parameters.get('min_throughput'):
policy_group.add_new_child('min-throughput',
self.parameters['min_throughput'])
try:
self.server.invoke_successfully(policy_group, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error creating qos policy group %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def delete_policy_group(self, policy_group=None):
"""
delete an existing policy group.
:param policy_group: policy group name.
"""
if policy_group is None:
policy_group = self.parameters['name']
policy_group_obj = netapp_utils.zapi.NaElement(
'qos-policy-group-delete')
policy_group_obj.add_new_child('policy-group', policy_group)
if self.parameters.get('force'):
policy_group_obj.add_new_child('force',
str(self.parameters['force']))
try:
self.server.invoke_successfully(policy_group_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error deleting qos policy group %s: %s' %
(policy_group, to_native(error)),
exception=traceback.format_exc())
def modify_policy_group(self):
"""
Modify policy group.
"""
policy_group_obj = netapp_utils.zapi.NaElement(
'qos-policy-group-modify')
policy_group_obj.add_new_child('policy-group', self.parameters['name'])
if self.parameters.get('max_throughput'):
policy_group_obj.add_new_child('max-throughput',
self.parameters['max_throughput'])
if self.parameters.get('min_throughput'):
policy_group_obj.add_new_child('min-throughput',
self.parameters['min_throughput'])
try:
self.server.invoke_successfully(policy_group_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error modifying qos policy group %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def rename_policy_group(self):
"""
Rename policy group name.
"""
rename_obj = netapp_utils.zapi.NaElement('qos-policy-group-rename')
rename_obj.add_new_child('new-name', self.parameters['name'])
rename_obj.add_new_child('policy-group-name',
self.parameters['from_name'])
try:
self.server.invoke_successfully(rename_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error renaming qos policy group %s: %s' %
(self.parameters['from_name'], to_native(error)),
exception=traceback.format_exc())
def modify_helper(self, modify):
"""
helper method to modify policy group.
:param modify: modified attributes.
"""
for attribute in modify.keys():
if attribute in ['max_throughput', 'min_throughput']:
self.modify_policy_group()
def apply(self):
"""
Run module based on playbook
"""
self.asup_log_for_cserver("na_ontap_qos_policy_group")
current = self.get_policy_group()
rename, cd_action = None, None
if self.parameters.get('from_name'):
rename = self.na_helper.is_rename_action(
self.get_policy_group(self.parameters['from_name']), current)
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if rename:
self.rename_policy_group()
if cd_action == 'create':
self.create_policy_group()
elif cd_action == 'delete':
self.delete_policy_group()
elif modify:
self.modify_helper(modify)
self.module.exit_json(changed=self.na_helper.changed)
def asup_log_for_cserver(self, event_name):
"""
Fetch admin vserver for the given cluster
Create and Autosupport log event with the given module name
:param event_name: Name of the event log
:return: None
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event(event_name, cserver)
class NetAppOntapSnapshotPolicy(object):
"""
Creates and deletes a Snapshot Policy
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type="str"),
enabled=dict(required=False, type="bool"),
# count is a list of integers
count=dict(required=False, type="list", elements="int"),
comment=dict(required=False, type="str"),
schedule=dict(required=False, type="list", elements="str")))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_if=[
('state', 'present',
['enabled', 'count', 'schedule']),
],
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def get_snapshot_policy(self):
"""
Checks to see if a snapshot policy exists or not
:return: Return policy details if a snapshot policy exists, None if it doesn't
"""
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-policy-get-iter")
# compose query
query = netapp_utils.zapi.NaElement("query")
snapshot_info_obj = netapp_utils.zapi.NaElement("snapshot-policy-info")
snapshot_info_obj.add_new_child("policy", self.parameters['name'])
query.add_child_elem(snapshot_info_obj)
snapshot_obj.add_child_elem(query)
try:
result = self.server.invoke_successfully(snapshot_obj, True)
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) == 1:
return result
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg=to_native(error),
exception=traceback.format_exc())
return None
def validate_parameters(self):
"""
Validate if each schedule has a count associated
:return: None
"""
if len(self.parameters['count']) > 5 or len(self.parameters['schedule']) > 5 or \
len(self.parameters['count']) != len(self.parameters['schedule']):
self.module.fail_json(
msg=
"Error: A Snapshot policy can have up to a maximum of 5 schedules,"
"and a count representing maximum number of Snapshot copies for each schedule"
)
def create_snapshot_policy(self):
"""
Creates a new snapshot policy
"""
# set up required variables to create a snapshot policy
self.validate_parameters()
options = {
'policy': self.parameters['name'],
'enabled': str(self.parameters['enabled']),
}
# zapi attribute for first schedule is schedule1, second is schedule2 and so on
positions = [
str(i) for i in range(1,
len(self.parameters['schedule']) + 1)
]
for schedule, count, position in zip(self.parameters['schedule'],
self.parameters['count'],
positions):
options['count' + position] = str(count)
options['schedule' + position] = schedule
snapshot_obj = netapp_utils.zapi.NaElement.create_node_with_children(
'snapshot-policy-create', **options)
# Set up optional variables to create a snapshot policy
if self.parameters.get('comment'):
snapshot_obj.add_new_child("comment", self.parameters['comment'])
try:
self.server.invoke_successfully(snapshot_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating snapshot policy %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def delete_snapshot_policy(self):
"""
Deletes an existing snapshot policy
"""
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-policy-delete")
# Set up required variables to delete a snapshot policy
snapshot_obj.add_new_child("policy", self.parameters['name'])
try:
self.server.invoke_successfully(snapshot_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting snapshot policy %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def asup_log_for_cserver(self, event_name):
"""
Fetch admin vserver for the given cluster
Create and Autosupport log event with the given module name
:param event_name: Name of the event log
:return: None
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event(event_name, cserver)
def apply(self):
"""
Check to see which play we should run
"""
self.asup_log_for_cserver("na_ontap_snapshot_policy")
current = self.get_snapshot_policy()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_snapshot_policy()
elif cd_action == 'delete':
self.delete_snapshot_policy()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapIgroup(object):
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str', default=None),
ostype=dict(required=False, type='str'),
initiator_group_type=dict(required=False,
type='str',
choices=['fcp', 'iscsi', 'mixed']),
initiators=dict(required=False,
type='list',
aliases=['initiator']),
vserver=dict(required=True, type='str'),
force_remove_initiator=dict(required=False,
type='bool',
default=False),
bind_portset=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
def get_igroup(self, name):
"""
Return details about the igroup
:param:
name : Name of the igroup
:return: Details about the igroup. None if not found.
:rtype: dict
"""
igroup_info = netapp_utils.zapi.NaElement('igroup-get-iter')
attributes = dict(
query={
'initiator-group-info': {
'initiator-group-name': name,
'vserver': self.parameters['vserver']
}
})
igroup_info.translate_struct(attributes)
result, current = None, None
try:
result = self.server.invoke_successfully(igroup_info, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching igroup info %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) >= 1:
igroup = result.get_child_by_name(
'attributes-list').get_child_by_name('initiator-group-info')
initiators = []
if igroup.get_child_by_name('initiators'):
current_initiators = igroup['initiators'].get_children()
for initiator in current_initiators:
initiators.append(initiator['initiator-name'])
current = {'initiators': initiators}
return current
def add_initiators(self):
"""
Add the list of initiators to igroup
:return: None
"""
# don't add if initiators is empty string
if self.parameters.get('initiators') == [
''
] or self.parameters.get('initiators') is None:
return
for initiator in self.parameters['initiators']:
self.modify_initiator(initiator, 'igroup-add')
def remove_initiators(self, initiators):
"""
Removes all existing initiators from igroup
:return: None
"""
for initiator in initiators:
self.modify_initiator(initiator, 'igroup-remove')
def modify_initiator(self, initiator, zapi):
"""
Add or remove an initiator to/from an igroup
"""
initiator.strip(
) # remove leading spaces if any (eg: if user types a space after comma in initiators list)
options = {
'initiator-group-name': self.parameters['name'],
'initiator': initiator
}
igroup_modify = netapp_utils.zapi.NaElement.create_node_with_children(
zapi, **options)
try:
self.server.invoke_successfully(igroup_modify,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error modifying igroup initiator %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def create_igroup(self):
"""
Create the igroup.
"""
options = {'initiator-group-name': self.parameters['name']}
if self.parameters.get('ostype') is not None:
options['os-type'] = self.parameters['ostype']
if self.parameters.get('initiator_group_type') is not None:
options['initiator-group-type'] = self.parameters[
'initiator_group_type']
if self.parameters.get('bind_portset') is not None:
options['bind-portset'] = self.parameters['bind_portset']
igroup_create = netapp_utils.zapi.NaElement.create_node_with_children(
'igroup-create', **options)
try:
self.server.invoke_successfully(igroup_create,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error provisioning igroup %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
self.add_initiators()
def delete_igroup(self):
"""
Delete the igroup.
"""
igroup_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'igroup-destroy', **{
'initiator-group-name':
self.parameters['name'],
'force':
'true'
if self.parameters['force_remove_initiator'] else 'false'
})
try:
self.server.invoke_successfully(igroup_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting igroup %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def rename_igroup(self):
"""
Rename the igroup.
"""
igroup_rename = netapp_utils.zapi.NaElement.create_node_with_children(
'igroup-rename', **{
'initiator-group-name': self.parameters['from_name'],
'initiator-group-new-name': str(self.parameters['name'])
})
try:
self.server.invoke_successfully(igroup_rename,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error renaming igroup %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def autosupport_log(self):
netapp_utils.ems_log_event("na_ontap_igroup", self.server)
def apply(self):
self.autosupport_log()
current = self.get_igroup(self.parameters['name'])
# rename and create are mutually exclusive
rename, cd_action, modify = None, None, None
if self.parameters.get('from_name'):
rename = self.na_helper.is_rename_action(
self.get_igroup(self.parameters['from_name']), current)
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action is None and self.parameters['state'] == 'present':
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if rename:
self.rename_igroup()
elif cd_action == 'create':
self.create_igroup()
elif cd_action == 'delete':
self.delete_igroup()
if modify:
self.remove_initiators(current['initiators'])
self.add_initiators()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPQuotas(object):
'''Class with quotas methods'''
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
volume=dict(required=True, type='str'),
quota_target=dict(required=True, type='str'),
qtree=dict(required=False, type='str', default=""),
type=dict(required=True, type='str', choices=['user', 'group', 'tree']),
policy=dict(required=False, type='str'),
set_quota_status=dict(required=False, type='bool'),
file_limit=dict(required=False, type='str', default='-'),
disk_limit=dict(required=False, type='str', default='-'),
threshold=dict(required=False, type='str', default='-')
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def get_quota_status(self):
"""
Return details about the quota status
:param:
name : volume name
:return: status of the quota. None if not found.
:rtype: dict
"""
quota_status_get = netapp_utils.zapi.NaElement('quota-status')
quota_status_get.translate_struct({
'volume': self.parameters['volume']
})
try:
result = self.server.invoke_successfully(quota_status_get, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching quotas status info: %s' % to_native(error),
exception=traceback.format_exc())
if result:
return result['status']
return None
def get_quotas(self):
"""
Get quota details
:return: name of volume if quota exists, None otherwise
"""
quota_get = netapp_utils.zapi.NaElement('quota-list-entries-iter')
query = {
'query': {
'quota-entry': {
'volume': self.parameters['volume'],
'quota-target': self.parameters['quota_target'],
'quota-type': self.parameters['type'],
'vserver': self.parameters['vserver']
}
}
}
quota_get.translate_struct(query)
if self.parameters.get('policy'):
quota_get['query']['quota-entry'].add_new_child('policy', self.parameters['policy'])
try:
result = self.server.invoke_successfully(quota_get, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching quotas info: %s' % to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1:
return_values = {'volume': result['attributes-list']['quota-entry']['volume'],
'file_limit': result['attributes-list']['quota-entry']['file-limit'],
'disk_limit': result['attributes-list']['quota-entry']['disk-limit'],
'threshold': result['attributes-list']['quota-entry']['threshold']}
return return_values
return None
def quota_entry_set(self):
"""
Adds a quota entry
"""
options = {'volume': self.parameters['volume'],
'quota-target': self.parameters['quota_target'],
'quota-type': self.parameters['type'],
'qtree': self.parameters['qtree'],
'file-limit': self.parameters['file_limit'],
'disk-limit': self.parameters['disk_limit'],
'threshold': self.parameters['threshold']}
if self.parameters.get('policy'):
options['policy'] = self.parameters['policy']
set_entry = netapp_utils.zapi.NaElement.create_node_with_children(
'quota-set-entry', **options)
try:
self.server.invoke_successfully(set_entry, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error adding/modifying quota entry %s: %s'
% (self.parameters['volume'], to_native(error)),
exception=traceback.format_exc())
def quota_entry_delete(self):
"""
Deletes a quota entry
"""
options = {'volume': self.parameters['volume'],
'quota-target': self.parameters['quota_target'],
'quota-type': self.parameters['type'],
'qtree': self.parameters['qtree']}
set_entry = netapp_utils.zapi.NaElement.create_node_with_children(
'quota-delete-entry', **options)
if self.parameters.get('policy'):
set_entry.add_new_child('policy', self.parameters['policy'])
try:
self.server.invoke_successfully(set_entry, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting quota entry %s: %s'
% (self.parameters['volume'], to_native(error)),
exception=traceback.format_exc())
def quota_entry_modify(self, modify_attrs):
"""
Modifies a quota entry
"""
options = {'volume': self.parameters['volume'],
'quota-target': self.parameters['quota_target'],
'quota-type': self.parameters['type'],
'qtree': self.parameters['qtree']}
options.update(modify_attrs)
if self.parameters.get('policy'):
options['policy'] = str(self.parameters['policy'])
modify_entry = netapp_utils.zapi.NaElement.create_node_with_children(
'quota-modify-entry', **options)
try:
self.server.invoke_successfully(modify_entry, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error modifying quota entry %s: %s'
% (self.parameters['volume'], to_native(error)),
exception=traceback.format_exc())
def on_or_off_quota(self, status):
"""
on or off quota
"""
quota = netapp_utils.zapi.NaElement.create_node_with_children(
status, **{'volume': self.parameters['volume']})
try:
self.server.invoke_successfully(quota,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error setting %s for %s: %s'
% (status, self.parameters['volume'], to_native(error)),
exception=traceback.format_exc())
def apply(self):
"""
Apply action to quotas
"""
netapp_utils.ems_log_event("na_ontap_quotas", self.server)
modify_quota_status = None
modify_quota = None
current = self.get_quotas()
if 'set_quota_status' in self.parameters:
quota_status = self.get_quota_status()
if quota_status is not None:
quota_status_action = self.na_helper.get_modified_attributes(
{'set_quota_status': True if quota_status == 'on' else False}, self.parameters)
if quota_status_action:
modify_quota_status = 'quota-on' if quota_status_action['set_quota_status'] else 'quota-off'
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action is None:
modify_quota = self.na_helper.get_modified_attributes(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.quota_entry_set()
elif cd_action == 'delete':
self.quota_entry_delete()
elif modify_quota is not None:
for key in list(modify_quota):
modify_quota[key.replace("_", "-")] = modify_quota.pop(key)
self.quota_entry_modify(modify_quota)
if modify_quota_status is not None:
self.on_or_off_quota(modify_quota_status)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPFlexCache(object):
"""
Class with FlexCache methods
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
origin_volume=dict(required=False, type='str'),
origin_vserver=dict(required=False, type='str'),
origin_cluster=dict(required=False, type='str'),
auto_provision_as=dict(required=False, type='str'),
volume=dict(required=True, type='str'),
junction_path=dict(required=False, type='str'),
size=dict(required=False, type='int'),
size_unit=dict(default='gb',
choices=[
'bytes', 'b', 'kb', 'mb', 'gb', 'tb', 'pb',
'eb', 'zb', 'yb'
],
type='str'),
vserver=dict(required=True, type='str'),
aggr_list=dict(required=False, type='list'),
aggr_list_multiplier=dict(required=False, type='int'),
force_offline=dict(required=False, type='bool', default=False),
force_unmount=dict(required=False, type='bool', default=False),
time_out=dict(required=False, type='int', default=180),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
mutually_exclusive=[
('aggr_list', 'auto_provision_as'),
],
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if self.parameters.get('size'):
self.parameters['size'] = self.parameters['size'] * \
netapp_utils.POW2_BYTE_MAP[self.parameters['size_unit']]
# setup later if required
self.origin_server = None
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
def add_parameter_to_dict(self, adict, name, key=None, tostr=False):
''' add defined parameter (not None) to adict using key '''
if key is None:
key = name
if self.parameters.get(name) is not None:
if tostr:
adict[key] = str(self.parameters.get(name))
else:
adict[key] = self.parameters.get(name)
def get_job(self, jobid, server):
"""
Get job details by id
"""
job_get = netapp_utils.zapi.NaElement('job-get')
job_get.add_new_child('job-id', jobid)
try:
result = server.invoke_successfully(job_get, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
if to_native(error.code) == "15661":
# Not found
return None
self.module.fail_json(msg='Error fetching job info: %s' %
to_native(error),
exception=traceback.format_exc())
results = dict()
job_info = result.get_child_by_name('attributes').get_child_by_name(
'job-info')
results = {
'job-progress': job_info['job-progress'],
'job-state': job_info['job-state']
}
if job_info.get_child_by_name('job-completion') is not None:
results['job-completion'] = job_info['job-completion']
else:
results['job-completion'] = None
return results
def check_job_status(self, jobid):
"""
Loop until job is complete
"""
server = self.server
sleep_time = 5
time_out = self.parameters['time_out']
while time_out > 0:
results = self.get_job(jobid, server)
# If running as cluster admin, the job is owned by cluster vserver
# rather than the target vserver.
if results is None and server == self.server:
results = netapp_utils.get_cserver(self.server)
server = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
continue
if results is None:
error = 'cannot locate job with id: %d' % jobid
break
if results['job-state'] in ('queued', 'running'):
time.sleep(sleep_time)
time_out -= sleep_time
continue
if results['job-state'] in ('success', 'failure'):
break
else:
self.module.fail_json(msg='Unexpected job status in: %s' %
repr(results))
if results is not None:
if results['job-state'] == 'success':
error = None
elif results['job-state'] in ('queued', 'running'):
error = 'job completion exceeded expected timer of: %s seconds' % \
self.parameters['time_out']
else:
if results['job-completion'] is not None:
error = results['job-completion']
else:
error = results['job-progress']
return error
def flexcache_get_iter(self):
"""
Compose NaElement object to query current FlexCache relation
"""
options = {'volume': self.parameters['volume']}
self.add_parameter_to_dict(options, 'origin_volume', 'origin-volume')
self.add_parameter_to_dict(options, 'origin_vserver', 'origin-vserver')
self.add_parameter_to_dict(options, 'origin_cluster', 'origin-cluster')
flexcache_info = netapp_utils.zapi.NaElement.create_node_with_children(
'flexcache-info', **options)
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(flexcache_info)
flexcache_get_iter = netapp_utils.zapi.NaElement('flexcache-get-iter')
flexcache_get_iter.add_child_elem(query)
return flexcache_get_iter
def flexcache_get(self):
"""
Get current FlexCache relations
:return: Dictionary of current FlexCache details if query successful, else None
"""
flexcache_get_iter = self.flexcache_get_iter()
flex_info = dict()
try:
result = self.server.invoke_successfully(flexcache_get_iter,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching FlexCache info: %s' %
to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) == 1:
flexcache_info = result.get_child_by_name('attributes-list') \
.get_child_by_name('flexcache-info')
flex_info['origin_cluster'] = flexcache_info.get_child_content(
'origin-cluster')
flex_info['origin_volume'] = flexcache_info.get_child_content(
'origin-volume')
flex_info['origin_vserver'] = flexcache_info.get_child_content(
'origin-vserver')
flex_info['size'] = flexcache_info.get_child_content('size')
flex_info['volume'] = flexcache_info.get_child_content('volume')
flex_info['vserver'] = flexcache_info.get_child_content('vserver')
flex_info['auto_provision_as'] = flexcache_info.get_child_content(
'auto-provision-as')
return flex_info
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) > 1:
msg = 'Multiple records found for %s:' % self.parameters['volume']
self.module.fail_json(msg='Error fetching FlexCache info: %s' %
msg)
return None
def flexcache_create_async(self):
"""
Create a FlexCache relationship
"""
options = {
'origin-volume': self.parameters['origin_volume'],
'origin-vserver': self.parameters['origin_vserver'],
'volume': self.parameters['volume']
}
self.add_parameter_to_dict(options, 'junction_path', 'junction-path')
self.add_parameter_to_dict(options, 'auto_provision_as',
'auto-provision-as')
self.add_parameter_to_dict(options, 'size', 'size', tostr=True)
if self.parameters.get('aggr_list'):
if self.parameters.get('aggr_list_multiplier'):
self.tobytes_aggr_list_multiplier = bytes(
self.parameters['aggr_list_multiplier'])
self.add_parameter_to_dict(options,
'tobytes_aggr_list_multiplier',
'aggr-list-multiplier')
flexcache_create = netapp_utils.zapi.NaElement.create_node_with_children(
'flexcache-create-async', **options)
if self.parameters.get('aggr_list'):
aggregates = netapp_utils.zapi.NaElement('aggr-list')
for aggregate in self.parameters['aggr_list']:
aggregates.add_new_child('aggr-name', aggregate)
flexcache_create.add_child_elem(aggregates)
try:
result = self.server.invoke_successfully(flexcache_create,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating FlexCache %s' %
to_native(error),
exception=traceback.format_exc())
results = dict()
for key in ('result-status', 'result-jobid'):
if result.get_child_by_name(key):
results[key] = result[key]
return results
def flexcache_create(self):
"""
Create a FlexCache relationship
Check job status
"""
results = self.flexcache_create_async()
status = results.get('result-status')
if status == 'in_progress' and 'result-jobid' in results:
if self.parameters['time_out'] == 0:
# asynchronous call, assuming success!
return
error = self.check_job_status(results['result-jobid'])
if error is None:
return
else:
self.module.fail_json(msg='Error when creating flexcache: %s' %
error)
self.module.fail_json(
msg='Unexpected error when creating flexcache: results is: %s' %
repr(results))
def flexcache_delete_async(self):
"""
Delete FlexCache relationship at destination cluster
"""
options = {'volume': self.parameters['volume']}
flexcache_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'flexcache-destroy-async', **options)
try:
result = self.server.invoke_successfully(flexcache_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting FlexCache : %s' %
(to_native(error)),
exception=traceback.format_exc())
results = dict()
for key in ('result-status', 'result-jobid'):
if result.get_child_by_name(key):
results[key] = result[key]
return results
def volume_offline(self):
"""
Offline FlexCache volume at destination cluster
"""
options = {'name': self.parameters['volume']}
xml = netapp_utils.zapi.NaElement.create_node_with_children(
'volume-offline', **options)
try:
self.server.invoke_successfully(xml, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error offlining FlexCache volume: %s' %
(to_native(error)),
exception=traceback.format_exc())
def volume_unmount(self):
"""
Unmount FlexCache volume at destination cluster
"""
options = {'volume-name': self.parameters['volume']}
xml = netapp_utils.zapi.NaElement.create_node_with_children(
'volume-unmount', **options)
try:
self.server.invoke_successfully(xml, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error unmounting FlexCache volume: %s' %
(to_native(error)),
exception=traceback.format_exc())
def flexcache_delete_async(self):
"""
Delete FlexCache relationship at destination cluster
"""
options = {'volume': self.parameters['volume']}
flexcache_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'flexcache-destroy-async', **options)
try:
result = self.server.invoke_successfully(flexcache_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting FlexCache : %s' %
(to_native(error)),
exception=traceback.format_exc())
results = dict()
for key in ('result-status', 'result-jobid'):
if result.get_child_by_name(key):
results[key] = result[key]
return results
def flexcache_delete(self):
"""
Delete FlexCache relationship at destination cluster
Check job status
"""
if self.parameters['force_unmount']:
self.volume_unmount()
if self.parameters['force_offline']:
self.volume_offline()
results = self.flexcache_delete_async()
status = results.get('result-status')
if status == 'in_progress' and 'result-jobid' in results:
if self.parameters['time_out'] == 0:
# asynchronous call, assuming success!
return
error = self.check_job_status(results['result-jobid'])
if error is None:
return
else:
self.module.fail_json(msg='Error when deleting flexcache: %s' %
error)
self.module.fail_json(
msg='Unexpected error when deleting flexcache: results is: %s' %
repr(results))
def check_parameters(self):
"""
Validate parameters and fail if one or more required params are missing
"""
missings = list()
expected = ('origin_volume', 'origin_vserver')
if self.parameters['state'] == 'present':
for param in expected:
if not self.parameters.get(param):
missings.append(param)
if missings:
plural = 's' if len(missings) > 1 else ''
msg = 'Missing parameter%s: %s' % (plural, ', '.join(missings))
self.module.fail_json(msg=msg)
def apply(self):
"""
Apply action to FlexCache
"""
netapp_utils.ems_log_event("na_ontap_flexcache", self.server)
current = self.flexcache_get()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action == 'create':
self.check_parameters()
self.flexcache_create()
elif cd_action == 'delete':
self.flexcache_delete()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapSnapshot(object):
"""
Creates, modifies, and deletes a Snapshot
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=[
'present', 'absent'], default='present'),
from_name=dict(required=False, type='str'),
snapshot=dict(required=True, type="str"),
volume=dict(required=True, type="str"),
async_bool=dict(required=False, type="bool", default=False),
comment=dict(required=False, type="str"),
snapmirror_label=dict(required=False, type="str"),
ignore_owners=dict(required=False, type="bool", default=False),
snapshot_instance_uuid=dict(required=False, type="str"),
vserver=dict(required=True, type="str"),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
return
def get_snapshot(self, snapshot_name=None):
"""
Checks to see if a snapshot exists or not
:return: Return True if a snapshot exists, False if it doesn't
"""
if snapshot_name is None:
snapshot_name = self.parameters['snapshot']
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-get-iter")
desired_attr = netapp_utils.zapi.NaElement("desired-attributes")
snapshot_info = netapp_utils.zapi.NaElement('snapshot-info')
comment = netapp_utils.zapi.NaElement('comment')
snapmirror_label = netapp_utils.zapi.NaElement('snapmirror-label')
# add more desired attributes that are allowed to be modified
snapshot_info.add_child_elem(comment)
snapshot_info.add_child_elem(snapmirror_label)
desired_attr.add_child_elem(snapshot_info)
snapshot_obj.add_child_elem(desired_attr)
# compose query
query = netapp_utils.zapi.NaElement("query")
snapshot_info_obj = netapp_utils.zapi.NaElement("snapshot-info")
snapshot_info_obj.add_new_child("name", snapshot_name)
snapshot_info_obj.add_new_child("volume", self.parameters['volume'])
snapshot_info_obj.add_new_child("vserver", self.parameters['vserver'])
query.add_child_elem(snapshot_info_obj)
snapshot_obj.add_child_elem(query)
result = self.server.invoke_successfully(snapshot_obj, True)
return_value = None
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) == 1:
attributes_list = result.get_child_by_name('attributes-list')
snap_info = attributes_list.get_child_by_name('snapshot-info')
return_value = {'comment': snap_info.get_child_content('comment')}
if snap_info.get_child_by_name('snapmirror-label'):
return_value['snapmirror_label'] = snap_info.get_child_content('snapmirror-label')
else:
return_value['snapmirror_label'] = None
return return_value
def create_snapshot(self):
"""
Creates a new snapshot
"""
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-create")
# set up required variables to create a snapshot
snapshot_obj.add_new_child("snapshot", self.parameters['snapshot'])
snapshot_obj.add_new_child("volume", self.parameters['volume'])
# Set up optional variables to create a snapshot
if self.parameters.get('async_bool'):
snapshot_obj.add_new_child("async", str(self.parameters['async_bool']))
if self.parameters.get('comment'):
snapshot_obj.add_new_child("comment", self.parameters['comment'])
if self.parameters.get('snapmirror_label'):
snapshot_obj.add_new_child(
"snapmirror-label", self.parameters['snapmirror_label'])
try:
self.server.invoke_successfully(snapshot_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating snapshot %s: %s' %
(self.parameters['snapshot'], to_native(error)),
exception=traceback.format_exc())
def delete_snapshot(self):
"""
Deletes an existing snapshot
"""
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-delete")
# Set up required variables to delete a snapshot
snapshot_obj.add_new_child("snapshot", self.parameters['snapshot'])
snapshot_obj.add_new_child("volume", self.parameters['volume'])
# set up optional variables to delete a snapshot
if self.parameters.get('ignore_owners'):
snapshot_obj.add_new_child("ignore-owners", str(self.parameters['ignore_owners']))
if self.parameters.get('snapshot_instance_uuid'):
snapshot_obj.add_new_child("snapshot-instance-uuid", self.parameters['snapshot_instance_uuid'])
try:
self.server.invoke_successfully(snapshot_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting snapshot %s: %s' %
(self.parameters['snapshot'], to_native(error)),
exception=traceback.format_exc())
def modify_snapshot(self):
"""
Modify an existing snapshot
:return:
"""
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-modify-iter")
# Create query object, this is the existing object
query = netapp_utils.zapi.NaElement("query")
snapshot_info_obj = netapp_utils.zapi.NaElement("snapshot-info")
snapshot_info_obj.add_new_child("name", self.parameters['snapshot'])
snapshot_info_obj.add_new_child("vserver", self.parameters['vserver'])
query.add_child_elem(snapshot_info_obj)
snapshot_obj.add_child_elem(query)
# this is what we want to modify in the snapshot object
attributes = netapp_utils.zapi.NaElement("attributes")
snapshot_info_obj = netapp_utils.zapi.NaElement("snapshot-info")
snapshot_info_obj.add_new_child("name", self.parameters['snapshot'])
if self.parameters.get('comment'):
snapshot_info_obj.add_new_child("comment", self.parameters['comment'])
if self.parameters.get('snapmirror_label'):
snapshot_info_obj.add_new_child("snapmirror-label", self.parameters['snapmirror_label'])
attributes.add_child_elem(snapshot_info_obj)
snapshot_obj.add_child_elem(attributes)
try:
self.server.invoke_successfully(snapshot_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error modifying snapshot %s: %s' %
(self.parameters['snapshot'], to_native(error)),
exception=traceback.format_exc())
def rename_snapshot(self):
"""
Rename the snapshot
"""
snapshot_obj = netapp_utils.zapi.NaElement("snapshot-rename")
# set up required variables to rename a snapshot
snapshot_obj.add_new_child("current-name", self.parameters['from_name'])
snapshot_obj.add_new_child("new-name", self.parameters['snapshot'])
snapshot_obj.add_new_child("volume", self.parameters['volume'])
try:
self.server.invoke_successfully(snapshot_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error renaming snapshot %s to %s: %s' %
(self.parameters['from_name'], self.parameters['snapshot'], to_native(error)),
exception=traceback.format_exc())
def apply(self):
"""
Check to see which play we should run
"""
current = self.get_snapshot()
netapp_utils.ems_log_event("na_ontap_snapshot", self.server)
rename, cd_action = None, None
modify = {}
if self.parameters.get('from_name'):
current_old_name = self.get_snapshot(self.parameters['from_name'])
rename = self.na_helper.is_rename_action(current_old_name, current)
modify = self.na_helper.get_modified_attributes(current_old_name, self.parameters)
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action is None:
modify = self.na_helper.get_modified_attributes(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if rename:
self.rename_snapshot()
if cd_action == 'create':
self.create_snapshot()
elif cd_action == 'delete':
self.delete_snapshot()
elif modify:
self.modify_snapshot()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapNetRoutes(object):
"""
Create, Modifies and Destroys a Net Route
"""
def __init__(self):
"""
Initialize the Ontap Net Route class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
vserver=dict(required=True, type='str'),
destination=dict(required=True, type='str'),
gateway=dict(required=True, type='str'),
metric=dict(required=False, type='str'),
from_destination=dict(required=False, type='str',
default=None),
from_gateway=dict(required=False, type='str', default=None),
from_metric=dict(required=False, type='str', default=None),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
return
def create_net_route(self, current_metric=None):
"""
Creates a new Route
"""
route_obj = netapp_utils.zapi.NaElement('net-routes-create')
route_obj.add_new_child("destination", self.parameters['destination'])
route_obj.add_new_child("gateway", self.parameters['gateway'])
if current_metric is None and self.parameters.get(
'metric') is not None:
metric = self.parameters['metric']
else:
metric = current_metric
# Metric can be None, Can't set metric to none
if metric is not None:
route_obj.add_new_child("metric", metric)
try:
self.server.invoke_successfully(route_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating net route: %s' %
(to_native(error)),
exception=traceback.format_exc())
def delete_net_route(self, params=None):
"""
Deletes a given Route
"""
route_obj = netapp_utils.zapi.NaElement('net-routes-destroy')
if params is None:
params = self.parameters
route_obj.add_new_child("destination", params['destination'])
route_obj.add_new_child("gateway", params['gateway'])
try:
self.server.invoke_successfully(route_obj, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting net route: %s' %
(to_native(error)),
exception=traceback.format_exc())
def modify_net_route(self, current, desired):
"""
Modify a net route
"""
# return if there is nothing to change
for key, val in desired.items():
if val != current[key]:
self.na_helper.changed = True
break
if not self.na_helper.changed:
return
# delete and re-create with new params
self.delete_net_route(current)
route_obj = netapp_utils.zapi.NaElement('net-routes-create')
for attribute in ['metric', 'destination', 'gateway']:
if desired.get(attribute) is not None:
value = desired[attribute]
else:
value = current[attribute]
route_obj.add_new_child(attribute, value)
try:
result = self.server.invoke_successfully(route_obj, True)
except netapp_utils.zapi.NaApiError as error:
# restore the old route, create the route with the existing metric
self.create_net_route(current['metric'])
# return if desired route already exists
if to_native(error.code) == '13001':
return
# Invalid value specified for any of the attributes
self.module.fail_json(msg='Error modifying net route: %s' %
(to_native(error)),
exception=traceback.format_exc())
def get_net_route(self, params=None):
"""
Checks to see if a route exist or not
:return: NaElement object if a route exists, None otherwise
"""
if params is not None:
# we need at least on of the new_destination or new_gateway to fetch desired route
if params.get('destination') is None and params.get(
'gateway') is None:
return None
current = None
route_obj = netapp_utils.zapi.NaElement('net-routes-get')
for attr in ['destination', 'gateway']:
if params and params.get(attr) is not None:
value = params[attr]
else:
value = self.parameters[attr]
route_obj.add_new_child(attr, value)
try:
result = self.server.invoke_successfully(route_obj, True)
if result.get_child_by_name('attributes') is not None:
route_info = result.get_child_by_name(
'attributes').get_child_by_name('net-vs-routes-info')
current = {
'destination': route_info.get_child_content('destination'),
'gateway': route_info.get_child_content('gateway'),
'metric': route_info.get_child_content('metric')
}
except netapp_utils.zapi.NaApiError as error:
# Error 13040 denotes a route doesn't exist.
if to_native(error.code) == "15661":
return None
self.module.fail_json(msg='Error fetching net route: %s' %
(to_native(error)),
exception=traceback.format_exc())
return current
def is_modify_action(self, current, desired):
"""
Get desired action to be applied for net routes
Destination and gateway are unique params for a route and cannot be duplicated
So if a route with desired destination or gateway exists already, we don't try to modify
:param current: current details
:param desired: desired details
:return: create / delete / modify / None
"""
if current is None and desired is None:
# this is invalid
# cannot modify a non existent resource
return None
if current is None and desired is not None:
# idempotency or duplication
# we need not create
return False
if current is not None and desired is not None:
# we can't modify an ambiguous route (idempotency/duplication)
return False
return True
def get_params_to_be_modified(self, current):
"""
Get parameters and values that need to be modified
:param current: current details
:return: dict(), None
"""
if current is None:
return None
desired = dict()
if self.parameters.get('new_destination') is not None and \
self.parameters['new_destination'] != current['destination']:
desired['destination'] = self.parameters['new_destination']
if self.parameters.get('new_gateway') is not None and \
self.parameters['new_gateway'] != current['gateway']:
desired['gateway'] = self.parameters['new_gateway']
if self.parameters.get('new_metric') is not None and \
self.parameters['new_metric'] != current['metric']:
desired['metric'] = self.parameters['new_metric']
return desired
def apply(self):
"""
Run Module based on play book
"""
netapp_utils.ems_log_event("na_ontap_net_routes", self.server)
current = self.get_net_route()
modify, cd_action = None, None
modify_params = {
'destination': self.parameters.get('from_destination'),
'gateway': self.parameters.get('from_gateway'),
'metric': self.parameters.get('from_metric')
}
# if any from_* param is present in playbook, check for modify action
if any(modify_params.values()):
# destination and gateway combination is unique, and is considered like a id. so modify destination
# or gateway is considered a rename action. metric is considered an attribute of the route so it is
# considered as modify.
if modify_params.get('metric') is not None:
modify = True
old_params = current
else:
# get parameters that are eligible for modify
old_params = self.get_net_route(modify_params)
modify = self.na_helper.is_rename_action(old_params, current)
if modify is None:
self.module.fail_json(
msg="Error modifying: route %s does not exist" %
self.parameters['from_destination'])
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action == 'create':
self.create_net_route()
elif cd_action == 'delete':
self.delete_net_route()
elif modify:
desired = {}
for key, value in old_params.items():
desired[key] = value
for key, value in modify_params.items():
if value is not None:
desired[key] = self.parameters.get(key)
self.modify_net_route(old_params, desired)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPFirewallPolicy(object):
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
allow_list=dict(required=False, type="list"),
policy=dict(required=True, type='str'),
service=dict(required=True,
type='str',
choices=[
'http', 'https', 'ntp', 'rsh', 'snmp', 'ssh',
'telnet'
]),
vserver=dict(required=True, type="str"),
enable=dict(required=False,
type="str",
choices=['enable', 'disable'],
default='enable'),
logging=dict(required=False,
type="str",
choices=["enable", 'disable'],
default='disable'),
node=dict(required=True, type="str")))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def create_firewall_policy(self):
"""
Create a firewall policy
:return: Nothing
"""
net_firewall_policy_obj = netapp_utils.zapi.NaElement(
"net-firewall-policy-create")
net_firewall_policy_obj = self.create_modify_policy(
net_firewall_policy_obj)
try:
self.server.invoke_successfully(net_firewall_policy_obj,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg="Error creating Firewall Policy: %s" %
(to_native(error)),
exception=traceback.format_exc())
def destroy_firewall_policy(self):
"""
Destroy a Firewall Policy
:return: None
"""
net_firewall_policy_obj = netapp_utils.zapi.NaElement(
"net-firewall-policy-destroy")
net_firewall_policy_obj.add_new_child('policy',
self.parameters['policy'])
net_firewall_policy_obj.add_new_child('service',
self.parameters['service'])
net_firewall_policy_obj.add_new_child('vserver',
self.parameters['vserver'])
try:
self.server.invoke_successfully(net_firewall_policy_obj,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg="Error destroying Firewall Policy: %s" %
(to_native(error)),
exception=traceback.format_exc())
def get_firewall_policy(self):
"""
Get a firewall policy
:return: returns a firewall policy object, or returns False if there are none
"""
net_firewall_policy_obj = netapp_utils.zapi.NaElement(
"net-firewall-policy-get-iter")
net_firewall_policy_info = netapp_utils.zapi.NaElement(
"net-firewall-policy-info")
query = netapp_utils.zapi.NaElement('query')
net_firewall_policy_info.add_new_child('policy',
self.parameters['policy'])
query.add_child_elem(net_firewall_policy_info)
net_firewall_policy_obj.add_child_elem(query)
result = self.server.invoke_successfully(net_firewall_policy_obj, True)
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) == 1:
return result
return False
def modify_firewall_policy(self):
"""
Modify a firewall Policy
:return: none
"""
net_firewall_policy_obj = netapp_utils.zapi.NaElement(
"net-firewall-policy-modify")
net_firewall_policy_obj = self.create_modify_policy(
net_firewall_policy_obj)
try:
self.server.invoke_successfully(net_firewall_policy_obj,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg="Error modifying Firewall Policy: %s" %
(to_native(error)),
exception=traceback.format_exc())
def create_modify_policy(self, net_firewall_policy_obj):
"""
Set up the parameters for creating or modifying a policy
:param net_firewall_policy_obj: The Firewall policy to modify
:return:
"""
net_firewall_policy_obj.add_new_child('policy',
self.parameters['policy'])
net_firewall_policy_obj.add_new_child('service',
self.parameters['service'])
net_firewall_policy_obj.add_new_child('vserver',
self.parameters['vserver'])
allow_ip_list = netapp_utils.zapi.NaElement("allow-list")
for each in self.parameters['allow_list']:
net_firewall_policy_ip = netapp_utils.zapi.NaElement("ip-and-mask")
net_firewall_policy_ip.set_content(each)
allow_ip_list.add_child_elem(net_firewall_policy_ip)
net_firewall_policy_obj.add_child_elem(allow_ip_list)
return net_firewall_policy_obj
def get_firewall_config(self):
"""
Get a firewall configuration
:return: the firewall configuration
"""
net_firewall_config_obj = netapp_utils.zapi.NaElement(
"net-firewall-config-get")
net_firewall_config_obj.add_new_child('node-name',
self.parameters['node'])
try:
result = self.server.invoke_successfully(net_firewall_config_obj,
True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg="Error getting Firewall Configuration: %s" %
(to_native(error)),
exception=traceback.format_exc())
return result
def check_policy(self, policy):
"""
Check to see if a policy has been changed or not
:param policy: policy to check
:return: True if the policy has changed, False if there are no changes
"""
changed = False
attributes_list = policy.get_child_by_name('attributes-list')
policy_info = attributes_list.get_child_by_name(
'net-firewall-policy-info')
allow_list = policy_info.get_child_by_name('allow-list')
for each in allow_list.get_children():
if each.get_content() not in self.parameters['allow_list']:
changed = True
if self.parameters['service'] != policy_info.get_child_by_name(
'service').get_content():
changed = True
if self.parameters['policy'] != policy_info.get_child_by_name(
'policy').get_content():
changed = True
return changed
def modify_firewall_config(self):
"""
Modify the configuration of a firewall
:return: none
"""
net_firewall_config_obj = netapp_utils.zapi.NaElement(
"net-firewall-config-modify")
net_firewall_config_obj.add_new_child('node-name',
self.parameters['node'])
net_firewall_config_obj.add_new_child('is-enabled',
self.parameters['enable'])
net_firewall_config_obj.add_new_child('is-logging',
self.parameters['logging'])
try:
self.server.invoke_successfully(net_firewall_config_obj,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg="Error modifying Firewall Config: %s" %
(to_native(error)),
exception=traceback.format_exc())
def check_config(self, config):
"""
check to see if a firewall configuration has changed or not
:param config: The configuration to check
:return: true if it has changed, false if it has not
"""
changed = False
attributes_list = config.get_child_by_name('attributes')
firewall_info = attributes_list.get_child_by_name(
'net-firewall-config-info')
enable = firewall_info.get_child_by_name('is-enabled')
logging = firewall_info.get_child_by_name('is-logging')
if self.parameters['enable'] == 'enable':
is_enable = "true"
else:
is_enable = "false"
if enable != is_enable:
changed = True
if self.parameters['logging'] == 'logging':
is_logging = "true"
else:
is_logging = "false"
if logging != is_logging:
changed = True
return changed
def apply(self):
changed = False
if self.parameters['state'] == 'present':
policy = self.get_firewall_policy()
if not policy:
self.create_firewall_policy()
if not self.check_config(self.get_firewall_config()):
self.modify_firewall_config()
changed = True
else:
if self.check_policy(policy):
self.modify_firewall_policy()
changed = True
if not self.check_config(self.get_firewall_config()):
self.modify_firewall_config()
changed = True
else:
if self.get_firewall_policy():
self.destroy_firewall_policy()
if not self.check_config(self.get_firewall_config()):
self.modify_firewall_config()
changed = True
else:
if not self.check_config(self.get_firewall_config()):
self.modify_firewall_config()
changed = True
self.module.exit_json(changed=changed)
class NetAppOntapFCP(object):
"""
Enable and Disable FCP
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
vserver=dict(required=True, type='str'),
status=dict(required=False,
choices=['up', 'down'],
default='up')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
return
def create_fcp(self):
"""
Create's and Starts an FCP
:return: none
"""
try:
self.server.invoke_successfully(
netapp_utils.zapi.NaElement('fcp-service-create'), True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating FCP: %s' %
(to_native(error)),
exception=traceback.format_exc())
def start_fcp(self):
"""
Starts an existing FCP
:return: none
"""
try:
self.server.invoke_successfully(
netapp_utils.zapi.NaElement('fcp-service-start'), True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error starting FCP %s' %
(to_native(error)),
exception=traceback.format_exc())
def stop_fcp(self):
"""
Steps an Existing FCP
:return: none
"""
try:
self.server.invoke_successfully(
netapp_utils.zapi.NaElement('fcp-service-stop'), True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error Stoping FCP %s' %
(to_native(error)),
exception=traceback.format_exc())
def destroy_fcp(self):
"""
Destroys an already stopped FCP
:return:
"""
try:
self.server.invoke_successfully(
netapp_utils.zapi.NaElement('fcp-service-destroy'), True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error destroying FCP %s' %
(to_native(error)),
exception=traceback.format_exc())
def get_fcp(self):
fcp_obj = netapp_utils.zapi.NaElement('fcp-service-get-iter')
fcp_info = netapp_utils.zapi.NaElement('fcp-service-info')
fcp_info.add_new_child('vserver', self.parameters['vserver'])
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(fcp_info)
fcp_obj.add_child_elem(query)
result = self.server.invoke_successfully(fcp_obj, True)
# There can only be 1 FCP per vserver. If true, one is set up, else one isn't set up
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) >= 1:
return True
else:
return False
def current_status(self):
try:
status = self.server.invoke_successfully(
netapp_utils.zapi.NaElement('fcp-service-status'), True)
return status.get_child_content('is-available') == 'true'
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error destroying FCP: %s' %
(to_native(error)),
exception=traceback.format_exc())
def apply(self):
exists = self.get_fcp()
changed = False
if self.parameters['state'] == 'present':
if exists:
if self.parameters['status'] == 'up':
if not self.current_status():
self.start_fcp()
changed = True
else:
if self.current_status():
self.stop_fcp()
changed = True
else:
self.create_fcp()
if self.parameters['status'] == 'up':
self.start_fcp()
changed = True
else:
if exists:
if self.current_status():
self.stop_fcp()
self.destroy_fcp()
changed = True
self.module.exit_json(changed=changed)
class NetAppONTAPClusterPeer(object):
"""
Class with cluster peer methods
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
source_intercluster_lifs=dict(required=False, type='list'),
dest_intercluster_lifs=dict(required=False, type='list'),
passphrase=dict(required=False, type='str', no_log=True),
dest_hostname=dict(required=True, type='str'),
dest_username=dict(required=False, type='str'),
dest_password=dict(required=False, type='str', no_log=True),
source_cluster_name=dict(required=False, type='str'),
dest_cluster_name=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_together=[[
'source_intercluster_lifs',
'dest_intercluster_lifs', 'passphrase'
]],
required_if=[('state', 'absent', [
'source_cluster_name',
'dest_cluster_name'
])],
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
# set destination server connection
self.module.params['hostname'] = self.parameters['dest_hostname']
if self.parameters.get('dest_username'):
self.module.params['username'] = self.parameters[
'dest_username']
if self.parameters.get('dest_password'):
self.module.params['password'] = self.parameters[
'dest_password']
self.dest_server = netapp_utils.setup_na_ontap_zapi(
module=self.module)
# reset to source host connection for asup logs
self.module.params['hostname'] = self.parameters['hostname']
def cluster_peer_get_iter(self, cluster):
"""
Compose NaElement object to query current source cluster using peer-cluster-name and peer-addresses parameters
:param cluster: type of cluster (source or destination)
:return: NaElement object for cluster-get-iter with query
"""
cluster_peer_get = netapp_utils.zapi.NaElement('cluster-peer-get-iter')
query = netapp_utils.zapi.NaElement('query')
cluster_peer_info = netapp_utils.zapi.NaElement('cluster-peer-info')
if cluster == 'source':
peer_lifs, peer_cluster = 'dest_intercluster_lifs', 'dest_cluster_name'
else:
peer_lifs, peer_cluster = 'source_intercluster_lifs', 'source_cluster_name'
if self.parameters.get(peer_lifs):
peer_addresses = netapp_utils.zapi.NaElement('peer-addresses')
for peer in self.parameters.get(peer_lifs):
peer_addresses.add_new_child('remote-inet-address', peer)
cluster_peer_info.add_child_elem(peer_addresses)
if self.parameters.get(peer_cluster):
cluster_peer_info.add_new_child('cluster-name',
self.parameters[peer_cluster])
query.add_child_elem(cluster_peer_info)
cluster_peer_get.add_child_elem(query)
return cluster_peer_get
def cluster_peer_get(self, cluster):
"""
Get current cluster peer info
:param cluster: type of cluster (source or destination)
:return: Dictionary of current cluster peer details if query successful, else return None
"""
cluster_peer_get_iter = self.cluster_peer_get_iter(cluster)
cluster_info = dict()
if cluster == 'source':
server = self.server
else:
server = self.dest_server
try:
result = server.invoke_successfully(cluster_peer_get_iter,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching cluster peer %s: %s' %
(self.parameters['dest_cluster_name'], to_native(error)),
exception=traceback.format_exc())
# return cluster peer details
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) >= 1:
cluster_peer_info = result.get_child_by_name(
'attributes-list').get_child_by_name('cluster-peer-info')
cluster_info['cluster_name'] = cluster_peer_info.get_child_content(
'cluster-name')
peers = cluster_peer_info.get_child_by_name('peer-addresses')
cluster_info['peer-addresses'] = [
peer.get_content() for peer in peers.get_children()
]
return cluster_info
return None
def cluster_peer_delete(self, cluster):
"""
Delete a cluster peer on source or destination
For source cluster, peer cluster-name = destination cluster name and vice-versa
:param cluster: type of cluster (source or destination)
:return:
"""
if cluster == 'source':
server, peer_cluster_name = self.server, self.parameters[
'dest_cluster_name']
else:
server, peer_cluster_name = self.dest_server, self.parameters[
'source_cluster_name']
cluster_peer_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'cluster-peer-delete', **{'cluster-name': peer_cluster_name})
try:
server.invoke_successfully(cluster_peer_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting cluster peer %s: %s' %
(peer_cluster_name, to_native(error)),
exception=traceback.format_exc())
def cluster_peer_create(self, cluster):
"""
Create a cluster peer on source or destination
For source cluster, peer addresses = destination inter-cluster LIFs and vice-versa
:param cluster: type of cluster (source or destination)
:return: None
"""
cluster_peer_create = netapp_utils.zapi.NaElement.create_node_with_children(
'cluster-peer-create',
**{'passphrase': self.parameters['passphrase']})
peer_addresses = netapp_utils.zapi.NaElement('peer-addresses')
if cluster == 'source':
server, peer_address = self.server, self.parameters[
'dest_intercluster_lifs']
else:
server, peer_address = self.dest_server, self.parameters[
'source_intercluster_lifs']
for each in peer_address:
peer_addresses.add_new_child('remote-inet-address', each)
cluster_peer_create.add_child_elem(peer_addresses)
try:
server.invoke_successfully(cluster_peer_create,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating cluster peer %s: %s' %
(peer_address, to_native(error)),
exception=traceback.format_exc())
def apply(self):
"""
Apply action to cluster peer
:return: None
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_cluster_peer", cserver)
source = self.cluster_peer_get('source')
destination = self.cluster_peer_get('destination')
source_action = self.na_helper.get_cd_action(source, self.parameters)
destination_action = self.na_helper.get_cd_action(
destination, self.parameters)
self.na_helper.changed = False
# create only if expected cluster peer relation is not present on both source and destination clusters
if source_action == 'create' and destination_action == 'create':
self.cluster_peer_create('source')
self.cluster_peer_create('destination')
self.na_helper.changed = True
# delete peer relation in cluster where relation is present
else:
if source_action == 'delete':
self.cluster_peer_delete('source')
self.na_helper.changed = True
if destination_action == 'delete':
self.cluster_peer_delete('destination')
self.na_helper.changed = True
self.module.exit_json(changed=self.na_helper.changed)
class NetAppOntapVolume(object):
'''Class with volume operations'''
def __init__(self):
'''Initialize module parameters'''
self._size_unit_map = dict(
bytes=1,
b=1,
kb=1024,
mb=1024 ** 2,
gb=1024 ** 3,
tb=1024 ** 4,
pb=1024 ** 5,
eb=1024 ** 6,
zb=1024 ** 7,
yb=1024 ** 8
)
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=[
'present', 'absent'], default='present'),
name=dict(required=True, type='str'),
vserver=dict(required=True, type='str'),
from_name=dict(required=False, type='str'),
is_infinite=dict(required=False, type='bool',
default=False),
is_online=dict(required=False, type='bool',
default=True),
size=dict(type='int', default=None),
size_unit=dict(default='gb',
choices=['bytes', 'b', 'kb', 'mb', 'gb', 'tb',
'pb', 'eb', 'zb', 'yb'], type='str'),
aggregate_name=dict(type='str', default=None),
type=dict(type='str', default=None),
policy=dict(type='str', default=None),
junction_path=dict(type='str', default=None),
space_guarantee=dict(choices=['none', 'volume'], default=None),
percent_snapshot_space=dict(type='str', default=None),
volume_security_style=dict(choices=['mixed',
'ntfs', 'unified', 'unix'],
default='mixed'),
encrypt=dict(required=False, type='bool', default=False),
efficiency_policy=dict(required=False, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if self.parameters.get('size'):
self.parameters['size'] = self.parameters['size'] * \
self._size_unit_map[self.parameters['size_unit']]
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
self.cluster = netapp_utils.setup_na_ontap_zapi(module=self.module)
def volume_get_iter(self, vol_name=None):
"""
Return volume-get-iter query results
:param vol_name: name of the volume
:return: NaElement
"""
volume_info = netapp_utils.zapi.NaElement('volume-get-iter')
volume_attributes = netapp_utils.zapi.NaElement('volume-attributes')
volume_id_attributes = netapp_utils.zapi.NaElement('volume-id-attributes')
volume_id_attributes.add_new_child('name', vol_name)
volume_attributes.add_child_elem(volume_id_attributes)
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(volume_attributes)
volume_info.add_child_elem(query)
try:
result = self.server.invoke_successfully(volume_info, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching volume %s : %s'
% (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
return result
def get_volume(self, vol_name=None):
"""
Return details about the volume
:param:
name : Name of the volume
:return: Details about the volume. None if not found.
:rtype: dict
"""
if vol_name is None:
vol_name = self.parameters['name']
volume_get_iter = self.volume_get_iter(vol_name)
return_value = None
if volume_get_iter.get_child_by_name('num-records') and \
int(volume_get_iter.get_child_content('num-records')) > 0:
volume_attributes = volume_get_iter.get_child_by_name(
'attributes-list').get_child_by_name(
'volume-attributes')
# Get volume's current size
volume_space_attributes = volume_attributes.get_child_by_name(
'volume-space-attributes')
current_size = int(volume_space_attributes.get_child_content('size'))
# Get volume's state (online/offline)
volume_state_attributes = volume_attributes.get_child_by_name(
'volume-state-attributes')
current_state = volume_state_attributes.get_child_content('state')
volume_id_attributes = volume_attributes.get_child_by_name(
'volume-id-attributes')
aggregate_name = volume_id_attributes.get_child_content(
'containing-aggregate-name')
volume_export_attributes = volume_attributes.get_child_by_name(
'volume-export-attributes')
policy = volume_export_attributes.get_child_content('policy')
space_guarantee = volume_space_attributes.get_child_content(
'space-guarantee')
is_online = (current_state == "online")
return_value = {
'name': vol_name,
'size': current_size,
'is_online': is_online,
'aggregate_name': aggregate_name,
'policy': policy,
'space_guarantee': space_guarantee,
}
return return_value
def create_volume(self):
'''Create ONTAP volume'''
if self.parameters.get('aggregate_name') is None:
self.module.fail_json(msg='Error provisioning volume %s: \
aggregate_name is required'
% self.parameters['name'])
options = {'volume': self.parameters['name'],
'containing-aggr-name': self.parameters['aggregate_name'],
'size': str(self.parameters['size'])}
if self.parameters.get('percent_snapshot_space'):
options['percentage-snapshot-reserve'] = self.parameters['percent_snapshot_space']
if self.parameters.get('type'):
options['volume-type'] = self.parameters['type']
if self.parameters.get('policy'):
options['export-policy'] = self.parameters['policy']
if self.parameters.get('junction_path'):
options['junction-path'] = self.parameters['junction_path']
if self.parameters.get('space_guarantee'):
options['space-reserve'] = self.parameters['space_guarantee']
if self.parameters.get('volume_security_style'):
options['volume-security-style'] = self.parameters['volume_security_style']
volume_create = netapp_utils.zapi.NaElement.create_node_with_children('volume-create', **options)
try:
self.server.invoke_successfully(volume_create,
enable_tunneling=True)
self.ems_log_event("volume-create")
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error provisioning volume %s \
of size %s: %s'
% (self.parameters['name'], self.parameters['size'], to_native(error)),
exception=traceback.format_exc())
def delete_volume(self):
'''Delete ONTAP volume'''
if self.parameters.get('is_infinite'):
volume_delete = netapp_utils.zapi\
.NaElement.create_node_with_children(
'volume-destroy-async', **{'volume-name': self.parameters['name']})
else:
volume_delete = netapp_utils.zapi\
.NaElement.create_node_with_children(
'volume-destroy', **{'name': self.parameters['name'],
'unmount-and-offline': 'true'})
try:
self.server.invoke_successfully(volume_delete, enable_tunneling=True)
self.ems_log_event("delete")
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting volume %s: %s'
% (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def move_volume(self):
'''Move volume from source aggregate to destination aggregate'''
volume_move = netapp_utils.zapi.NaElement.create_node_with_children(
'volume-move-start', **{'source-volume': self.parameters['name'],
'vserver': self.parameters['vserver'],
'dest-aggr': self.parameters['aggregate_name']})
try:
self.cluster.invoke_successfully(volume_move,
enable_tunneling=True)
self.ems_log_event("volume-move")
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error moving volume %s: %s'
% (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def rename_volume(self):
"""
Rename the volume.
Note: 'is_infinite' needs to be set to True in order to rename an
Infinite Volume.
"""
vol_rename_zapi, vol_name_zapi = ['volume-rename-async', 'volume-name'] if self.parameters['is_infinite']\
else ['volume-rename', 'volume']
volume_rename = netapp_utils.zapi.NaElement.create_node_with_children(
vol_rename_zapi, **{vol_name_zapi: self.parameters['from_name'],
'new-volume-name': str(self.parameters['name'])})
try:
self.server.invoke_successfully(volume_rename,
enable_tunneling=True)
self.ems_log_event("volume-rename")
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error renaming volume %s: %s'
% (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def resize_volume(self):
"""
Re-size the volume.
Note: 'is_infinite' needs to be set to True in order to rename an
Infinite Volume.
"""
vol_size_zapi, vol_name_zapi = ['volume-size-async', 'volume-name'] if self.parameters['is_infinite']\
else ['volume-size', 'volume']
volume_resize = netapp_utils.zapi.NaElement.create_node_with_children(
vol_size_zapi, **{vol_name_zapi: self.parameters['name'],
'new-size': str(self.parameters['size'])})
try:
self.server.invoke_successfully(volume_resize, enable_tunneling=True)
self.ems_log_event("volume-resize")
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error re-sizing volume %s: %s'
% (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def change_volume_state(self):
"""
Change volume's state (offline/online).
"""
if self.parameters['is_online']: # Desired state is online, setup zapi APIs respectively
vol_state_zapi, vol_name_zapi = ['volume-online-async', 'volume-name'] if self.parameters['is_infinite']\
else ['volume-online', 'name']
else: # Desired state is offline, setup zapi APIs respectively
vol_state_zapi, vol_name_zapi = ['volume-offline-async', 'volume-name'] if self.parameters['is_infinite']\
else ['volume-offline', 'name']
volume_unmount = netapp_utils.zapi.NaElement.create_node_with_children(
'volume-unmount', **{'volume-name': self.parameters['name']})
volume_change_state = netapp_utils.zapi.NaElement.create_node_with_children(
vol_state_zapi, **{vol_name_zapi: self.parameters['name']})
try:
if not self.parameters['is_online']: # Unmount before offline
self.server.invoke_successfully(volume_unmount, enable_tunneling=True)
self.server.invoke_successfully(volume_change_state, enable_tunneling=True)
self.ems_log_event("change-state")
except netapp_utils.zapi.NaApiError as error:
state = "online" if self.parameters['is_online'] else "offline"
self.module.fail_json(msg='Error changing the state of volume %s to %s: %s'
% (self.parameters['name'], state, to_native(error)),
exception=traceback.format_exc())
def volume_modify_policy_space(self):
"""
modify volume parameter 'policy' or 'space_guarantee'
"""
# TODO: refactor this method
vol_mod_iter = netapp_utils.zapi.NaElement('volume-modify-iter')
attributes = netapp_utils.zapi.NaElement('attributes')
vol_mod_attributes = netapp_utils.zapi.NaElement('volume-attributes')
if self.parameters.get('policy'):
vol_export_attributes = netapp_utils.zapi.NaElement(
'volume-export-attributes')
vol_export_attributes.add_new_child('policy', self.parameters['policy'])
vol_mod_attributes.add_child_elem(vol_export_attributes)
if self.parameters.get('space_guarantee'):
vol_space_attributes = netapp_utils.zapi.NaElement(
'volume-space-attributes')
vol_space_attributes.add_new_child(
'space-guarantee', self.parameters['space_guarantee'])
vol_mod_attributes.add_child_elem(vol_space_attributes)
attributes.add_child_elem(vol_mod_attributes)
query = netapp_utils.zapi.NaElement('query')
vol_query_attributes = netapp_utils.zapi.NaElement('volume-attributes')
vol_id_attributes = netapp_utils.zapi.NaElement('volume-id-attributes')
vol_id_attributes.add_new_child('name', self.parameters['name'])
vol_query_attributes.add_child_elem(vol_id_attributes)
query.add_child_elem(vol_query_attributes)
vol_mod_iter.add_child_elem(attributes)
vol_mod_iter.add_child_elem(query)
try:
result = self.server.invoke_successfully(vol_mod_iter, enable_tunneling=True)
failures = result.get_child_by_name('failure-list')
# handle error if modify space or policy parameter fails
if failures is not None and failures.get_child_by_name('volume-modify-iter-info') is not None:
error_msg = failures.get_child_by_name('volume-modify-iter-info').get_child_content('error-message')
self.module.fail_json(msg="Error modifying volume %s: %s"
% (self.parameters['name'], error_msg),
exception=traceback.format_exc())
self.ems_log_event("volume-modify")
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error modifying volume %s: %s'
% (self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def modify_volume(self, modify):
for attribute in modify.keys():
if attribute == 'size':
self.resize_volume()
elif attribute == 'is_online':
self.change_volume_state()
elif attribute == 'aggregate_name':
self.move_volume()
else:
self.volume_modify_policy_space()
def apply(self):
'''Call create/modify/delete operations'''
current = self.get_volume()
# rename and create are mutually exclusive
rename, cd_action = None, None
if self.parameters.get('from_name'):
rename = self.na_helper.is_rename_action(self.get_volume(self.parameters['from_name']), current)
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if rename:
self.rename_volume()
if cd_action == 'create':
self.create_volume()
elif cd_action == 'delete':
self.delete_volume()
elif modify:
self.modify_volume(modify)
self.module.exit_json(changed=self.na_helper.changed)
def ems_log_event(self, state):
'''Autosupport log event'''
if state == 'create':
message = "A Volume has been created, size: " + \
str(self.parameters['size']) + str(self.parameters['size_unit'])
elif state == 'delete':
message = "A Volume has been deleted"
elif state == 'move':
message = "A Volume has been moved"
elif state == 'rename':
message = "A Volume has been renamed"
elif state == 'resize':
message = "A Volume has been resized to: " + \
str(self.parameters['size']) + str(self.parameters['size_unit'])
elif state == 'change':
message = "A Volume state has been changed"
else:
message = "na_ontap_volume has been called"
netapp_utils.ems_log_event(
"na_ontap_volume", self.server, event=message)
class NetAppOntapDns(object):
"""
Enable and Disable dns
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
vserver=dict(required=True, type='str'),
domains=dict(required=False, type='list'),
nameservers=dict(required=False, type='list')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
return
def create_dns(self):
"""
Create DNS server
:return: none
"""
dns = netapp_utils.zapi.NaElement('net-dns-create')
nameservers = netapp_utils.zapi.NaElement('name-servers')
domains = netapp_utils.zapi.NaElement('domains')
for each in self.parameters['nameservers']:
ip_address = netapp_utils.zapi.NaElement('ip-address')
ip_address.set_content(each)
nameservers.add_child_elem(ip_address)
dns.add_child_elem(nameservers)
for each in self.parameters['domains']:
domain = netapp_utils.zapi.NaElement('string')
domain.set_content(each)
domains.add_child_elem(domain)
dns.add_child_elem(domains)
try:
self.server.invoke_successfully(dns, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating dns: %s' %
(to_native(error)),
exception=traceback.format_exc())
def destroy_dns(self):
"""
Destroys an already created dns
:return:
"""
try:
self.server.invoke_successfully(
netapp_utils.zapi.NaElement('net-dns-destroy'), True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error destroying dns %s' %
(to_native(error)),
exception=traceback.format_exc())
def get_dns(self):
dns_obj = netapp_utils.zapi.NaElement('net-dns-get')
try:
result = self.server.invoke_successfully(dns_obj, True)
except netapp_utils.zapi.NaApiError as error:
if to_native(error.code) == "15661":
# 15661 is object not found
return None
else:
self.module.fail_json(msg=to_native(error),
exception=traceback.format_exc())
# read data for modify
attrs = dict()
attributes = result.get_child_by_name('attributes')
dns_info = attributes.get_child_by_name('net-dns-info')
nameservers = dns_info.get_child_by_name('name-servers')
attrs['nameservers'] = [
each.get_content() for each in nameservers.get_children()
]
domains = dns_info.get_child_by_name('domains')
attrs['domains'] = [
each.get_content() for each in domains.get_children()
]
return attrs
def modify_dns(self, dns_attrs):
changed = False
dns = netapp_utils.zapi.NaElement('net-dns-modify')
if dns_attrs['nameservers'] != self.parameters['nameservers']:
changed = True
nameservers = netapp_utils.zapi.NaElement('name-servers')
for each in self.parameters['nameservers']:
ip_address = netapp_utils.zapi.NaElement('ip-address')
ip_address.set_content(each)
nameservers.add_child_elem(ip_address)
dns.add_child_elem(nameservers)
if dns_attrs['domains'] != self.parameters['domains']:
changed = True
domains = netapp_utils.zapi.NaElement('domains')
for each in self.parameters['domains']:
domain = netapp_utils.zapi.NaElement('string')
domain.set_content(each)
domains.add_child_elem(domain)
dns.add_child_elem(domains)
if changed:
try:
self.server.invoke_successfully(dns, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error modifying dns %s' %
(to_native(error)),
exception=traceback.format_exc())
return changed
def apply(self):
# asup logging
netapp_utils.ems_log_event("na_ontap_dns", self.server)
dns_attrs = self.get_dns()
changed = False
if self.parameters['state'] == 'present':
if dns_attrs is not None:
changed = self.modify_dns(dns_attrs)
else:
self.create_dns()
changed = True
else:
if dns_attrs is not None:
self.destroy_dns()
changed = True
self.module.exit_json(changed=changed)
class ElementSWClusterPair(object):
""" class to handle cluster pairing operations """
def __init__(self):
"""
Setup Ansible parameters and ElementSW connection
"""
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
dest_mvip=dict(required=True, type='str'),
dest_username=dict(required=False, type='str'),
dest_password=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
if HAS_SF_SDK is False:
self.module.fail_json(
msg="Unable to import the SolidFire Python SDK")
else:
self.elem = netapp_utils.create_sf_connection(module=self.module)
self.elementsw_helper = NaElementSWModule(self.elem)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# get element_sw_connection for destination cluster
# overwrite existing source host, user and password with destination credentials
self.module.params['hostname'] = self.parameters['dest_mvip']
# username and password is same as source,
# if dest_username and dest_password aren't specified
if self.parameters.get('dest_username'):
self.module.params['username'] = self.parameters['dest_username']
if self.parameters.get('dest_password'):
self.module.params['password'] = self.parameters['dest_password']
self.dest_elem = netapp_utils.create_sf_connection(module=self.module)
self.dest_elementsw_helper = NaElementSWModule(self.dest_elem)
def check_if_already_paired(self):
"""
Check for idempotency
"""
# src cluster and dest cluster exist
paired_clusters = self.elem.list_cluster_pairs()
for pair in paired_clusters.cluster_pairs:
if pair.mvip == self.parameters['dest_mvip']:
return pair.cluster_pair_id
return None
def pair_clusters(self):
"""
Start cluster pairing on source, and complete on target cluster
"""
try:
pair_key = self.elem.start_cluster_pairing()
self.dest_elem.complete_cluster_pairing(
cluster_pairing_key=pair_key.cluster_pairing_key)
except solidfire.common.ApiServerError as err:
self.module.fail_json(
msg="Error pairing cluster %s and %s" %
(self.parameters['hostname'], self.parameters['dest_mvip']),
exception=to_native(err))
def unpair_clusters(self, pair_id):
"""
Delete cluster pair
"""
try:
self.elem.remove_cluster_pair(cluster_pair_id=pair_id)
self.dest_elem.remove_cluster_pair(cluster_pair_id=pair_id)
except solidfire.common.ApiServerError as err:
self.module.fail_json(
msg="Error unpairing cluster %s and %s" %
(self.parameters['hostname'], self.parameters['dest_mvip']),
exception=to_native(err))
def apply(self):
"""
Call create / delete cluster pair methods
"""
pair_id = self.check_if_already_paired()
# calling helper to determine action
cd_action = self.na_helper.get_cd_action(pair_id, self.parameters)
if cd_action == "create":
self.pair_clusters()
elif cd_action == "delete":
self.unpair_clusters(pair_id)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPFirmwareUpgrade(object):
"""
Class with ONTAP firmware upgrade methods
"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False, type='str', default='present'),
node=dict(required=False, type='str'),
firmware_type=dict(
required=True,
type='str',
choices=['service-processor', 'shelf', 'acp', 'disk']),
clear_logs=dict(required=False, type='bool', default=True),
package=dict(required=False, type='str'),
install_baseline_image=dict(required=False,
type='bool',
default=False),
update_type=dict(required=False, type='str'),
shelf_module_fw=dict(required=False, type='str'),
disk_fw=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_if=[
('firmware_type', 'acp', ['node']),
('firmware_type', 'disk', ['node']),
('firmware_type', 'service-processor',
['node', 'update_type']),
],
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if self.parameters.get('firmware_type') == 'service-processor':
if self.parameters.get(
'install_baseline_image') and self.parameters.get(
'package') is not None:
self.module.fail_json(
msg=
'Do not specify both package and install_baseline_image: true'
)
if not self.parameters.get('package') and self.parameters.get(
'install_baseline_image') == 'False':
self.module.fail_json(
msg=
'Specify at least one of package or install_baseline_image'
)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def firmware_image_get_iter(self):
"""
Compose NaElement object to query current firmware version
:return: NaElement object for firmware_image_get_iter with query
"""
firmware_image_get = netapp_utils.zapi.NaElement(
'service-processor-get-iter')
query = netapp_utils.zapi.NaElement('query')
firmware_image_info = netapp_utils.zapi.NaElement(
'service-processor-info')
firmware_image_info.add_new_child('node', self.parameters['node'])
query.add_child_elem(firmware_image_info)
firmware_image_get.add_child_elem(query)
return firmware_image_get
def firmware_image_get(self, node_name):
"""
Get current firmware image info
:return: True if query successful, else return None
"""
firmware_image_get_iter = self.firmware_image_get_iter()
try:
result = self.server.invoke_successfully(firmware_image_get_iter,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching firmware image details: %s: %s' %
(self.parameters['node'], to_native(error)),
exception=traceback.format_exc())
# return firmware image details
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) > 0:
sp_info = result.get_child_by_name(
'attributes-list').get_child_by_name('service-processor-info')
firmware_version = sp_info.get_child_content('firmware-version')
return firmware_version
return None
def acp_firmware_required_get(self):
"""
where acp firmware upgrade is required
:return: True is firmware upgrade is required else return None
"""
acp_firmware_get_iter = netapp_utils.zapi.NaElement(
'storage-shelf-acp-module-get-iter')
query = netapp_utils.zapi.NaElement('query')
acp_info = netapp_utils.zapi.NaElement('storage-shelf-acp-module')
query.add_child_elem(acp_info)
acp_firmware_get_iter.add_child_elem(query)
try:
result = self.server.invoke_successfully(acp_firmware_get_iter,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching acp firmware details details: %s' %
(to_native(error)),
exception=traceback.format_exc())
if result.get_child_by_name('attributes-list').get_child_by_name(
'storage-shelf-acp-module'):
acp_module_info = result.get_child_by_name(
'attributes-list').get_child_by_name(
'storage-shelf-acp-module')
state = acp_module_info.get_child_content('state')
if state == 'firmware_update_required':
# acp firmware version upgrade required
return True
return False
def sp_firmware_image_update_progress_get(self, node_name):
"""
Get current firmware image update progress info
:return: Dictionary of firmware image update progress if query successful, else return None
"""
firmware_update_progress_get = netapp_utils.zapi.NaElement(
'service-processor-image-update-progress-get')
firmware_update_progress_get.add_new_child('node',
self.parameters['node'])
firmware_update_progress_info = dict()
try:
result = self.server.invoke_successfully(
firmware_update_progress_get, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching firmware image upgrade progress details: %s'
% (to_native(error)),
exception=traceback.format_exc())
# return firmware image update progress details
if result.get_child_by_name('attributes').get_child_by_name(
'service-processor-image-update-progress-info'):
update_progress_info = result.get_child_by_name(
'attributes').get_child_by_name(
'service-processor-image-update-progress-info')
firmware_update_progress_info[
'is-in-progress'] = update_progress_info.get_child_content(
'is-in-progress')
firmware_update_progress_info[
'node'] = update_progress_info.get_child_content('node')
return firmware_update_progress_info
def shelf_firmware_info_get(self):
"""
Get the current firmware of shelf module
:return:dict with module id and firmware info
"""
shelf_id_fw_info = dict()
shelf_firmware_info_get = netapp_utils.zapi.NaElement(
'storage-shelf-info-get-iter')
desired_attributes = netapp_utils.zapi.NaElement('desired-attributes')
storage_shelf_info = netapp_utils.zapi.NaElement('storage-shelf-info')
shelf_module = netapp_utils.zapi.NaElement('shelf-modules')
shelf_module_info = netapp_utils.zapi.NaElement(
'storage-shelf-module-info')
shelf_module.add_child_elem(shelf_module_info)
storage_shelf_info.add_child_elem(shelf_module)
desired_attributes.add_child_elem(storage_shelf_info)
shelf_firmware_info_get.add_child_elem(desired_attributes)
try:
result = self.server.invoke_successfully(shelf_firmware_info_get,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching shelf module firmware details: %s' %
(to_native(error)),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) > 0:
shelf_info = result.get_child_by_name(
'attributes-list').get_child_by_name('storage-shelf-info')
if (shelf_info.get_child_by_name('shelf-modules')
and shelf_info.get_child_by_name('shelf-modules').
get_child_by_name('storage-shelf-module-info')):
shelves = shelf_info['shelf-modules'].get_children()
for shelf in shelves:
shelf_id_fw_info[shelf.get_child_content(
'module-id')] = shelf.get_child_content(
'module-fw-revision')
return shelf_id_fw_info
def disk_firmware_info_get(self):
"""
Get the current firmware of disks module
:return:
"""
disk_id_fw_info = dict()
disk_firmware_info_get = netapp_utils.zapi.NaElement(
'storage-disk-get-iter')
desired_attributes = netapp_utils.zapi.NaElement('desired-attributes')
storage_disk_info = netapp_utils.zapi.NaElement('storage-disk-info')
disk_inv = netapp_utils.zapi.NaElement('disk-inventory-info')
storage_disk_info.add_child_elem(disk_inv)
desired_attributes.add_child_elem(storage_disk_info)
disk_firmware_info_get.add_child_elem(desired_attributes)
try:
result = self.server.invoke_successfully(disk_firmware_info_get,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching disk module firmware details: %s' %
(to_native(error)),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and int(
result.get_child_content('num-records')) > 0:
disk_info = result.get_child_by_name('attributes-list')
disks = disk_info.get_children()
for disk in disks:
disk_id_fw_info[disk.get_child_content(
'disk-uid')] = disk.get_child_by_name(
'disk-inventory-info').get_child_content(
'firmware-revision')
return disk_id_fw_info
def disk_firmware_required_get(self):
"""
Check weather disk firmware upgrade is required or not
:return: True if the firmware upgrade is required
"""
disk_firmware_info = self.disk_firmware_info_get()
for disk in disk_firmware_info:
if (disk_firmware_info[disk]) != self.parameters['disk_fw']:
return True
return False
def shelf_firmware_required_get(self):
"""
Check weather shelf firmware upgrade is required or not
:return: True if the firmware upgrade is required
"""
shelf_firmware_info = self.shelf_firmware_info_get()
for module in shelf_firmware_info:
if (shelf_firmware_info[module]
) != self.parameters['shelf_module_fw']:
return True
return False
def sp_firmware_image_update(self):
"""
Update current firmware image
"""
firmware_update_info = netapp_utils.zapi.NaElement(
'service-processor-image-update')
if self.parameters.get('package') is not None:
firmware_update_info.add_new_child('package',
self.parameters['package'])
if self.parameters.get('clear_logs') is not None:
firmware_update_info.add_new_child(
'clear-logs', str(self.parameters['clear_logs']))
if self.parameters.get('install_baseline_image') is not None:
firmware_update_info.add_new_child(
'install-baseline-image',
str(self.parameters['install_baseline_image']))
firmware_update_info.add_new_child('node', self.parameters['node'])
firmware_update_info.add_new_child('update-type',
self.parameters['update_type'])
try:
self.server.invoke_successfully(firmware_update_info,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
# Current firmware version matches the version to be installed
if to_native(error.code) == '13001' and (error.message.startswith(
'Service Processor update skipped')):
return False
self.module.fail_json(
msg='Error updating firmware image for %s: %s' %
(self.parameters['node'], to_native(error)),
exception=traceback.format_exc())
return True
def shelf_firmware_upgrade(self):
"""
Upgrade shelf firmware image
"""
shelf_firmware_update_info = netapp_utils.zapi.NaElement(
'storage-shelf-firmware-update')
try:
self.server.invoke_successfully(shelf_firmware_update_info,
enable_tunneling=True)
return True
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error updating shelf firmware image : %s' %
(to_native(error)),
exception=traceback.format_exc())
def acp_firmware_upgrade(self):
"""
Upgrade shelf firmware image
"""
acp_firmware_update_info = netapp_utils.zapi.NaElement(
'storage-shelf-acp-firmware-update')
acp_firmware_update_info.add_new_child('node-name',
self.parameters['node'])
try:
self.server.invoke_successfully(acp_firmware_update_info,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error updating acp firmware image : %s' %
(to_native(error)),
exception=traceback.format_exc())
def disk_firmware_upgrade(self):
"""
Upgrade disk firmware
"""
disk_firmware_update_info = netapp_utils.zapi.NaElement(
'disk-update-disk-fw')
disk_firmware_update_info.add_new_child('node-name',
self.parameters['node'])
try:
self.server.invoke_successfully(disk_firmware_update_info,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error updating disk firmware image : %s' %
(to_native(error)),
exception=traceback.format_exc())
return True
def autosupport_log(self):
"""
Autosupport log for software_update
:return:
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_firmware_upgrade", cserver)
def apply(self):
"""
Apply action to upgrade firmware
"""
changed = False
self.autosupport_log()
firmware_update_progress = dict()
if self.parameters.get('firmware_type') == 'service-processor':
# service-processor firmware upgrade
current = self.firmware_image_get(self.parameters['node'])
if self.parameters.get('state') == 'present' and current:
if not self.module.check_mode:
if self.sp_firmware_image_update():
changed = True
firmware_update_progress = self.sp_firmware_image_update_progress_get(
self.parameters['node'])
while firmware_update_progress.get(
'is-in-progress') == 'true':
time.sleep(25)
firmware_update_progress = self.sp_firmware_image_update_progress_get(
self.parameters['node'])
else:
# we don't know until we try the upgrade
changed = True
elif self.parameters.get('firmware_type') == 'shelf':
# shelf firmware upgrade
if self.parameters.get('shelf_module_fw'):
if self.shelf_firmware_required_get():
if not self.module.check_mode:
changed = self.shelf_firmware_upgrade()
else:
changed = True
else:
if not self.module.check_mode:
changed = self.shelf_firmware_upgrade()
else:
# we don't know until we try the upgrade -- assuming the worst
changed = True
elif self.parameters.get('firmware_type') == 'acp':
# acp firmware upgrade
if self.acp_firmware_required_get():
if not self.module.check_mode:
self.acp_firmware_upgrade()
changed = True
elif self.parameters.get('firmware_type') == 'disk':
# Disk firmware upgrade
if self.parameters.get('disk_fw'):
if self.disk_firmware_required_get():
if not self.module.check_mode:
changed = self.disk_firmware_upgrade()
else:
changed = True
else:
if not self.module.check_mode:
changed = self.disk_firmware_upgrade()
else:
# we don't know until we try the upgrade -- assuming the worst
changed = True
self.module.exit_json(changed=changed)
class NetAppOntapAggregate(object):
''' object initialize and class methods '''
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
service_state=dict(required=False,
choices=['online', 'offline']),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str'),
disk_count=dict(required=False, type='int', default=None),
disk_type=dict(required=False,
choices=[
'ATA', 'BSAS', 'FCAL', 'FSAS', 'LUN',
'MSATA', 'SAS', 'SSD', 'VMDISK'
]),
raid_type=dict(required=False, type='str'),
disk_size=dict(required=False, type='int'),
nodes=dict(required=False, type='list'),
raid_size=dict(required=False, type='int'),
unmount_volumes=dict(required=False, type='bool'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_if=[('service_state', 'offline',
['unmount_volumes'])],
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def aggr_get_iter(self, name):
"""
Return aggr-get-iter query results
:param name: Name of the aggregate
:return: NaElement if aggregate found, None otherwise
"""
aggr_get_iter = netapp_utils.zapi.NaElement('aggr-get-iter')
query_details = netapp_utils.zapi.NaElement.create_node_with_children(
'aggr-attributes', **{'aggregate-name': name})
query = netapp_utils.zapi.NaElement('query')
query.add_child_elem(query_details)
aggr_get_iter.add_child_elem(query)
try:
result = self.server.invoke_successfully(aggr_get_iter,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
# Error 13040 denotes an aggregate not being found.
if to_native(error.code) == "13040":
return None
else:
self.module.fail_json(msg=to_native(error),
exception=traceback.format_exc())
return result
def get_aggr(self, name=None):
"""
Fetch details if aggregate exists.
:param name: Name of the aggregate to be fetched
:return:
Dictionary of current details if aggregate found
None if aggregate is not found
"""
if name is None:
name = self.parameters['name']
aggr_get = self.aggr_get_iter(name)
if (aggr_get and aggr_get.get_child_by_name('num-records')
and int(aggr_get.get_child_content('num-records')) >= 1):
current_aggr = dict()
attr = aggr_get.get_child_by_name(
'attributes-list').get_child_by_name('aggr-attributes')
current_aggr['service_state'] = attr.get_child_by_name(
'aggr-raid-attributes').get_child_content('state')
return current_aggr
return None
def aggregate_online(self):
"""
Set state of an offline aggregate to online
:return: None
"""
online_aggr = netapp_utils.zapi.NaElement.create_node_with_children(
'aggr-online', **{
'aggregate': self.parameters['name'],
'force-online': 'true'
})
try:
self.server.invoke_successfully(online_aggr, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error changing the state of aggregate %s to %s: %s' %
(self.parameters['name'], self.parameters['service_state'],
to_native(error)),
exception=traceback.format_exc())
def aggregate_offline(self):
"""
Set state of an online aggregate to offline
:return: None
"""
offline_aggr = netapp_utils.zapi.NaElement.create_node_with_children(
'aggr-offline', **{
'aggregate': self.parameters['name'],
'force-offline': 'false',
'unmount-volumes': str(self.parameters['unmount_volumes'])
})
try:
self.server.invoke_successfully(offline_aggr,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error changing the state of aggregate %s to %s: %s' %
(self.parameters['name'], self.parameters['service_state'],
to_native(error)),
exception=traceback.format_exc())
def create_aggr(self):
"""
Create aggregate
:return: None
"""
if not self.parameters.get('disk_count'):
self.module.fail_json(msg='Error provisioning aggregate %s: \
disk_count is required' %
self.parameters['name'])
options = {
'aggregate': self.parameters['name'],
'disk-count': str(self.parameters['disk_count'])
}
if self.parameters.get('disk_type'):
options['disk-type'] = self.parameters['disk_type']
if self.parameters.get('raid_size'):
options['raid-size'] = str(self.parameters['raid_size'])
if self.parameters.get('raid_type'):
options['raid-type'] = self.parameters['raid_type']
if self.parameters.get('disk_size'):
options['disk-size'] = str(self.parameters['disk_size'])
aggr_create = netapp_utils.zapi.NaElement.create_node_with_children(
'aggr-create', **options)
if self.parameters.get('nodes'):
nodes_obj = netapp_utils.zapi.NaElement('nodes')
aggr_create.add_child_elem(nodes_obj)
for node in self.parameters['nodes']:
nodes_obj.add_new_child('node-name', node)
try:
self.server.invoke_successfully(aggr_create,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg="Error provisioning aggregate %s: %s" %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def delete_aggr(self):
"""
Delete aggregate.
:return: None
"""
aggr_destroy = netapp_utils.zapi.NaElement.create_node_with_children(
'aggr-destroy', **{'aggregate': self.parameters['name']})
try:
self.server.invoke_successfully(aggr_destroy,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg="Error removing aggregate %s: %s" %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
def rename_aggregate(self):
"""
Rename aggregate.
"""
aggr_rename = netapp_utils.zapi.NaElement.create_node_with_children(
'aggr-rename', **{
'aggregate': self.parameters['from_name'],
'new-aggregate-name': self.parameters['name']
})
try:
self.server.invoke_successfully(aggr_rename,
enable_tunneling=False)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg="Error renaming aggregate %s: %s" %
(self.parameters['from_name'], to_native(error)),
exception=traceback.format_exc())
def modify_aggr(self, modify):
"""
Modify state of the aggregate
:param modify: dictionary of parameters to be modified
:return: None
"""
if modify['service_state'] == 'offline':
self.aggregate_offline()
elif modify['service_state'] == 'online':
self.aggregate_online()
def asup_log_for_cserver(self, event_name):
"""
Fetch admin vserver for the given cluster
Create and Autosupport log event with the given module name
:param event_name: Name of the event log
:return: None
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event(event_name, cserver)
def apply(self):
"""
Apply action to the aggregate
:return: None
"""
self.asup_log_for_cserver("na_ontap_aggregate")
current = self.get_aggr()
# rename and create are mutually exclusive
rename, cd_action = None, None
if self.parameters.get('from_name'):
rename = self.na_helper.is_rename_action(
self.get_aggr(self.parameters['from_name']), current)
if rename is None:
self.module.fail_json(
msg="Error renaming: aggregate %s does not exist" %
self.parameters['from_name'])
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if rename:
self.rename_aggregate()
elif cd_action == 'create':
self.create_aggr()
elif cd_action == 'delete':
self.delete_aggr()
elif modify:
self.modify_aggr(modify)
self.module.exit_json(changed=self.na_helper.changed)
class CDotMotd(object):
def __init__(self):
argument_spec = netapp_utils.na_ontap_host_argument_spec()
argument_spec.update(
dict(state=dict(required=False,
default='present',
choices=['present', 'absent']),
vserver=dict(required=True, type='str'),
message=dict(default='', type='str'),
show_cluster_motd=dict(default=True, type='bool')))
self.module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_XMLTODICT_LIB is False:
self.module.fail_json(
msg="the python xmltodict module is required")
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def _create_call(self):
api_call = netapp_utils.zapi.NaElement('vserver-motd-modify-iter')
api_call.add_new_child('message', self.parameters['message'])
api_call.add_new_child(
'is-cluster-message-enabled',
'true' if self.parameters['show_cluster_motd'] else 'false')
query = netapp_utils.zapi.NaElement('query')
motd_info = netapp_utils.zapi.NaElement('vserver-motd-info')
motd_info.add_new_child('vserver', self.parameters['vserver'])
query.add_child_elem(motd_info)
api_call.add_child_elem(query)
return api_call
def commit_changes(self):
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_motd", cserver)
if self.parameters['state'] == 'absent':
# Just make sure it is empty
self.parameters['message'] = ''
call = self._create_call()
try:
_call_result = self.server.invoke_successfully(
call, enable_tunneling=False)
except netapp_utils.zapi.NaApiError as err:
self.module.fail_json(msg="Error calling API %s: %s" %
('vserver-motd-modify-iter', to_native(err)),
exception=traceback.format_exc())
_dict_num_succeeded = xmltodict.parse(
_call_result.get_child_by_name('num-succeeded').to_string(),
xml_attribs=False)
num_succeeded = int(_dict_num_succeeded['num-succeeded'])
changed = bool(num_succeeded >= 1)
result = {'state': self.parameters['state'], 'changed': changed}
self.module.exit_json(**result)
class AwsCvsNetappSnapshot(object):
"""
Contains methods to parse arguments,
derive details of AWS_CVS objects
and send requests to AWS CVS via
the restApi
"""
def __init__(self):
"""
Parse arguments, setup state variables,
check paramenters and ensure request module is installed
"""
self.argument_spec = netapp_utils.aws_cvs_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=True, choices=['present', 'absent']),
region=dict(required=True, type='str'),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str'),
fileSystemId=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_if=[
('state', 'present',
['state', 'name', 'fileSystemId']),
],
supports_check_mode=True)
self.na_helper = NetAppModule()
# set up state variables
self.parameters = self.na_helper.set_parameters(self.module.params)
# Calling generic AWSCVS restApi class
self.restApi = AwsCvsRestAPI(self.module)
# Checking for the parameters passed and create new parameters list
self.data = {}
for key in self.parameters.keys():
self.data[key] = self.parameters[key]
def getSnapshotId(self, name):
# Check if snapshot exists
# Return snpashot Id If Snapshot is found, None otherwise
list_snapshots, error = self.restApi.get('Snapshots')
if error:
self.module.fail_json(msg=error)
for snapshot in list_snapshots:
if snapshot['name'] == name:
return snapshot['snapshotId']
return None
def getfilesystemId(self):
# Check given FileSystem is exists
# Return fileSystemId is found, None otherwise
list_filesystem, error = self.restApi.get('FileSystems')
if error:
self.module.fail_json(msg=error)
for FileSystem in list_filesystem:
if FileSystem['fileSystemId'] == self.parameters['fileSystemId']:
return FileSystem['fileSystemId']
elif FileSystem['creationToken'] == self.parameters[
'fileSystemId']:
return FileSystem['fileSystemId']
return None
def create_snapshot(self):
# Create Snapshot
api = 'Snapshots'
response, error = self.restApi.post(api, self.data)
if error:
self.module.fail_json(msg=error)
def rename_snapshot(self, snapshotId):
# Rename Snapshot
api = 'Snapshots/' + snapshotId
response, error = self.restApi.put(api, self.data)
if error:
self.module.fail_json(msg=error)
def delete_snapshot(self, snapshotId):
# Delete Snapshot
api = 'Snapshots/' + snapshotId
data = None
response, error = self.restApi.delete(api, self.data)
if error:
self.module.fail_json(msg=error)
def apply(self):
"""
Perform pre-checks, call functions and exit
"""
self.snapshotId = self.getSnapshotId(self.data['name'])
if self.snapshotId is None and 'fileSystemId' in self.data:
self.fileSystemId = self.getfilesystemId()
self.data['fileSystemId'] = self.fileSystemId
if self.fileSystemId is None:
self.module.fail_json(
msg='Error: Specified filesystem id %s does not exist ' %
self.data['fileSystemId'])
cd_action = self.na_helper.get_cd_action(self.snapshotId, self.data)
result_message = ""
if self.na_helper.changed:
if self.module.check_mode:
# Skip changes
result_message = "Check mode, skipping changes"
else:
if cd_action == "delete":
self.delete_snapshot(self.snapshotId)
result_message = "Snapshot Deleted"
elif cd_action == "create":
if 'from_name' in self.data:
# If cd_action is craete and from_name is given
snapshotId = self.getSnapshotId(self.data['from_name'])
if snapshotId is not None:
# If resource pointed by from_name exists, rename the snapshot to name
self.rename_snapshot(snapshotId)
result_message = "Snapshot Updated"
else:
# If resource pointed by from_name does not exists, error out
self.module.fail_json(
msg="Resource does not exist : %s" %
self.data['from_name'])
else:
self.create_snapshot()
# If from_name is not defined, Create from scratch.
result_message = "Snapshot Created"
self.module.exit_json(changed=self.na_helper.changed,
msg=result_message)
class ElementSWVolumePair(object):
''' class to handle volume pairing operations '''
def __init__(self):
"""
Setup Ansible parameters and SolidFire connection
"""
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
src_volume=dict(required=True, type='str'),
src_account=dict(required=True, type='str'),
dest_volume=dict(required=True, type='str'),
dest_account=dict(required=True, type='str'),
mode=dict(required=False,
type='str',
choices=['async', 'sync', 'snapshotsonly'],
default='async'),
dest_mvip=dict(required=True, type='str'),
dest_username=dict(required=False, type='str'),
dest_password=dict(required=False, type='str', no_log=True)))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
if HAS_SF_SDK is False:
self.module.fail_json(
msg="Unable to import the SolidFire Python SDK")
else:
self.elem = netapp_utils.create_sf_connection(module=self.module)
self.elementsw_helper = NaElementSWModule(self.elem)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# get element_sw_connection for destination cluster
# overwrite existing source host, user and password with destination credentials
self.module.params['hostname'] = self.parameters['dest_mvip']
# username and password is same as source,
# if dest_username and dest_password aren't specified
if self.parameters.get('dest_username'):
self.module.params['username'] = self.parameters['dest_username']
if self.parameters.get('dest_password'):
self.module.params['password'] = self.parameters['dest_password']
self.dest_elem = netapp_utils.create_sf_connection(module=self.module)
self.dest_elementsw_helper = NaElementSWModule(self.dest_elem)
def check_if_already_paired(self, vol_id):
"""
Check for idempotency
A volume can have only one pair
Return paired-volume-id if volume is paired already
None if volume is not paired
"""
paired_volumes = self.elem.list_volumes(volume_ids=[vol_id],
is_paired=True)
for vol in paired_volumes.volumes:
for pair in vol.volume_pairs:
if pair is not None:
return pair.remote_volume_id
return None
def pair_volumes(self):
"""
Start volume pairing on source, and complete on target volume
"""
try:
pair_key = self.elem.start_volume_pairing(
volume_id=self.parameters['src_vol_id'],
mode=self.parameters['mode'])
self.dest_elem.complete_volume_pairing(
volume_pairing_key=pair_key.volume_pairing_key,
volume_id=self.parameters['dest_vol_id'])
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error pairing volume id %s" %
(self.parameters['src_vol_id']),
exception=to_native(err))
def pairing_exists(self, src_id, dest_id):
src_paired = self.check_if_already_paired(
self.parameters['src_vol_id'])
dest_paired = self.check_if_already_paired(
self.parameters['dest_vol_id'])
if src_paired is not None or dest_paired is not None:
return True
return None
def unpair_volumes(self):
"""
Delete volume pair
"""
try:
self.elem.remove_volume_pair(
volume_id=self.parameters['src_vol_id'])
self.dest_elem.remove_volume_pair(
volume_id=self.parameters['dest_vol_id'])
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error unpairing volume ids %s and %s" %
(self.parameters['src_vol_id'],
self.parameters['dest_vol_id']),
exception=to_native(err))
def get_account_id(self, account, type):
"""
Get source and destination account IDs
"""
try:
if type == 'src':
self.parameters[
'src_account_id'] = self.elementsw_helper.account_exists(
account)
elif type == 'dest':
self.parameters[
'dest_account_id'] = self.dest_elementsw_helper.account_exists(
account)
except solidfire.common.ApiServerError as err:
self.module.fail_json(
msg="Error: either account %s or %s does not exist" %
(self.parameters['src_account'],
self.parameters['dest_account']),
exception=to_native(err))
def get_volume_id(self, volume, type):
"""
Get source and destination volume IDs
"""
if type == 'src':
self.parameters[
'src_vol_id'] = self.elementsw_helper.volume_exists(
volume, self.parameters['src_account_id'])
if self.parameters['src_vol_id'] is None:
self.module.fail_json(
msg="Error: source volume %s does not exist" %
(self.parameters['src_volume']))
elif type == 'dest':
self.parameters[
'dest_vol_id'] = self.dest_elementsw_helper.volume_exists(
volume, self.parameters['dest_account_id'])
if self.parameters['dest_vol_id'] is None:
self.module.fail_json(
msg="Error: destination volume %s does not exist" %
(self.parameters['dest_volume']))
def get_ids(self):
"""
Get IDs for volumes and accounts
"""
self.get_account_id(self.parameters['src_account'], 'src')
self.get_account_id(self.parameters['dest_account'], 'dest')
self.get_volume_id(self.parameters['src_volume'], 'src')
self.get_volume_id(self.parameters['dest_volume'], 'dest')
def apply(self):
"""
Call create / delete volume pair methods
"""
self.get_ids()
paired = self.pairing_exists(self.parameters['src_vol_id'],
self.parameters['dest_vol_id'])
# calling helper to determine action
cd_action = self.na_helper.get_cd_action(paired, self.parameters)
if cd_action == "create":
self.pair_volumes()
elif cd_action == "delete":
self.unpair_volumes()
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPasup(object):
"""Class with autosupport methods"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
node_name=dict(required=True, type='str'),
transport=dict(required=False,
type='str',
choices=['smtp', 'http', 'https']),
noteto=dict(required=False, type='list'),
post_url=dict(reuired=False, type='str'),
support=dict(required=False, type='bool'),
mail_hosts=dict(required=False, type='list'),
from_address=dict(required=False, type='str'),
partner_addresses=dict(required=False, type='list'),
to_addresses=dict(required=False, type='list'),
proxy_url=dict(required=False, type='str'),
hostname_in_subject=dict(required=False, type='bool'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=False)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# present or absent requires modifying state to enabled or disabled
self.parameters['service_state'] = 'started' if self.parameters[
'state'] == 'present' else 'stopped'
self.set_playbook_zapi_key_map()
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def set_playbook_zapi_key_map(self):
self.na_helper.zapi_string_keys = {
'node_name': 'node-name',
'transport': 'transport',
'post_url': 'post-url',
'from_address': 'from',
'proxy_url': 'proxy-url'
}
self.na_helper.zapi_list_keys = {
'noteto': ('noteto', 'mail-address'),
'mail_hosts': ('mail-hosts', 'string'),
'partner_addresses': ('partner-address', 'mail-address'),
'to_addresses': ('to', 'mail-address'),
}
self.na_helper.zapi_bool_keys = {
'support': 'is-support-enabled',
'hostname_in_subject': 'is-node-in-subject'
}
def get_autosupport_config(self):
"""
Invoke zapi - get current autosupport details
:return: dict()
"""
asup_details = netapp_utils.zapi.NaElement('autosupport-config-get')
asup_details.add_new_child('node-name', self.parameters['node_name'])
asup_info = dict()
try:
result = self.server.invoke_successfully(asup_details,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='%s' % to_native(error),
exception=traceback.format_exc())
# zapi invoke successful
asup_attr_info = result.get_child_by_name(
'attributes').get_child_by_name('autosupport-config-info')
asup_info['service_state'] = 'started' if asup_attr_info[
'is-enabled'] == 'true' else 'stopped'
for item_key, zapi_key in self.na_helper.zapi_string_keys.items():
asup_info[item_key] = asup_attr_info[zapi_key]
for item_key, zapi_key in self.na_helper.zapi_bool_keys.items():
asup_info[item_key] = self.na_helper.get_value_for_bool(
from_zapi=True, value=asup_attr_info[zapi_key])
for item_key, zapi_key in self.na_helper.zapi_list_keys.items():
parent, dummy = zapi_key
asup_info[item_key] = self.na_helper.get_value_for_list(
from_zapi=True,
zapi_parent=asup_attr_info.get_child_by_name(parent))
return asup_info
def modify_autosupport_config(self, modify):
"""
Invoke zapi - modify autosupport config
@return: NaElement object / FAILURE with an error_message
"""
asup_details = {'node-name': self.parameters['node_name']}
if modify.get('service_state'):
asup_details['is-enabled'] = 'true' if modify.get(
'service_state') == 'started' else 'false'
asup_config = netapp_utils.zapi.NaElement('autosupport-config-modify')
for item_key in modify:
if item_key in self.na_helper.zapi_string_keys:
zapi_key = self.na_helper.zapi_string_keys.get(item_key)
asup_details[zapi_key] = modify[item_key]
elif item_key in self.na_helper.zapi_bool_keys:
zapi_key = self.na_helper.zapi_bool_keys.get(item_key)
asup_details[zapi_key] = self.na_helper.get_value_for_bool(
from_zapi=False, value=modify[item_key])
elif item_key in self.na_helper.zapi_list_keys:
parent_key, child_key = self.na_helper.zapi_list_keys.get(
item_key)
asup_config.add_child_elem(
self.na_helper.get_value_for_list(
from_zapi=False,
zapi_parent=parent_key,
zapi_child=child_key,
data=modify.get(item_key)))
asup_config.translate_struct(asup_details)
try:
return self.server.invoke_successfully(asup_config,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='%s' % to_native(error),
exception=traceback.format_exc())
def autosupport_log(self):
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_autosupport", cserver)
def apply(self):
"""
Apply action to autosupport
"""
current = self.get_autosupport_config()
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
self.modify_autosupport_config(modify)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPasup(object):
"""Class with autosupport methods"""
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
node_name=dict(required=True, type='str'),
transport=dict(required=False,
type='str',
choices=['smtp', 'http', 'https']),
noteto=dict(required=False, type='list'),
post_url=dict(reuired=False, type='str'),
support=dict(required=False, type='bool'),
mail_hosts=dict(required=False, type='list')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=False)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# present or absent requires modifying state to enabled or disabled
self.parameters['service_state'] = 'started' if self.parameters[
'state'] == 'present' else 'stopped'
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def get_autosupport_config(self):
"""
Invoke zapi - get current autosupport status
@return: 'true' or 'false' / FAILURE with an error_message
"""
asup_details = netapp_utils.zapi.NaElement('autosupport-config-get')
asup_details.add_new_child('node-name', self.parameters['node_name'])
asup_info = dict()
try:
result = self.server.invoke_successfully(asup_details,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='%s' % to_native(error),
exception=traceback.format_exc())
# zapi invoke successful
asup_attr_info = result.get_child_by_name(
'attributes').get_child_by_name('autosupport-config-info')
current_state = asup_attr_info.get_child_content('is-enabled')
if current_state == 'true':
asup_info['service_state'] = 'started'
elif current_state == 'false':
asup_info['service_state'] = 'stopped'
current_support = asup_attr_info.get_child_content(
'is-support-enabled')
if current_support == 'true':
asup_info['support'] = True
elif current_support == 'false':
asup_info['support'] = False
asup_info['transport'] = asup_attr_info.get_child_content('transport')
asup_info['post_url'] = asup_attr_info.get_child_content('post-url')
mail_hosts = asup_attr_info.get_child_by_name('mail-hosts')
# mail hosts has one valid entry always
if mail_hosts is not None:
# get list of mail hosts
asup_info['mail_hosts'] = [
mail.get_content() for mail in mail_hosts.get_children()
]
email_list = asup_attr_info.get_child_by_name('noteto')
# if email_list is empty, noteto is also empty
asup_info['noteto'] = [] if email_list is None else [
email.get_content() for email in email_list.get_children()
]
return asup_info
def modify_autosupport_config(self, modify):
"""
Invoke zapi - modify autosupport config
@return: NaElement object / FAILURE with an error_message
"""
asup_details = netapp_utils.zapi.NaElement('autosupport-config-modify')
asup_details.add_new_child('node-name', self.parameters['node_name'])
if modify.get('service_state'):
if modify.get('service_state') == 'started':
asup_details.add_new_child('is-enabled', 'true')
elif modify.get('service_state') == 'stopped':
asup_details.add_new_child('is-enabled', 'false')
if modify.get('support') is not None:
if modify.get('support') is True:
asup_details.add_new_child('is-support-enabled', 'true')
elif modify.get('support') is False:
asup_details.add_new_child('is-support-enabled', 'false')
if modify.get('transport'):
asup_details.add_new_child('transport', modify['transport'])
if modify.get('post_url'):
asup_details.add_new_child('post-url', modify['post_url'])
if modify.get('noteto'):
asup_email = netapp_utils.zapi.NaElement('noteto')
asup_details.add_child_elem(asup_email)
for email in modify.get('noteto'):
asup_email.add_new_child('mail-address', email)
if modify.get('mail_hosts'):
asup_mail_hosts = netapp_utils.zapi.NaElement('mail-hosts')
asup_details.add_child_elem(asup_mail_hosts)
for mail in modify.get('mail_hosts'):
asup_mail_hosts.add_new_child('string', mail)
try:
result = self.server.invoke_successfully(asup_details,
enable_tunneling=True)
return result
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='%s' % to_native(error),
exception=traceback.format_exc())
def apply(self):
"""
Apply action to autosupport
"""
results = netapp_utils.get_cserver(self.server)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_autosupport", cserver)
current = self.get_autosupport_config()
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if modify:
self.modify_autosupport_config(modify)
self.module.exit_json(changed=self.na_helper.changed)
class NetAppONTAPSnapmirror(object):
"""
Class with Snapmirror methods
"""
def __init__(self):
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
source_vserver=dict(required=False, type='str'),
destination_vserver=dict(required=False, type='str'),
source_volume=dict(required=False, type='str'),
destination_volume=dict(required=False, type='str'),
source_path=dict(required=False, type='str'),
destination_path=dict(required=False, type='str'),
schedule=dict(required=False, type='str'),
relationship_type=dict(required=False,
type='str',
choices=[
'data_protection', 'load_sharing',
'vault', 'restore',
'transition_data_protection',
'extended_data_protection'
]),
source_hostname=dict(required=False, type='str'),
source_username=dict(required=False, type='str'),
source_password=dict(required=False, type='str')))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_together=(['source_volume', 'destination_volume'],
['source_vserver', 'destination_vserver']),
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# setup later if required
self.source_server = None
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def snapmirror_get_iter(self):
"""
Compose NaElement object to query current SnapMirror relations using destination-path
SnapMirror relation for a destination path is unique
:return: NaElement object for SnapMirror-get-iter
"""
snapmirror_get_iter = netapp_utils.zapi.NaElement(
'snapmirror-get-iter')
query = netapp_utils.zapi.NaElement('query')
snapmirror_info = netapp_utils.zapi.NaElement('snapmirror-info')
snapmirror_info.add_new_child('destination-location',
self.parameters['destination_path'])
query.add_child_elem(snapmirror_info)
snapmirror_get_iter.add_child_elem(query)
return snapmirror_get_iter
def snapmirror_get(self):
"""
Get current SnapMirror relations
:return: Dictionary of current SnapMirror details if query successful, else None
"""
snapmirror_get_iter = self.snapmirror_get_iter()
snap_info = dict()
try:
result = self.server.invoke_successfully(snapmirror_get_iter,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error fetching snapmirror info: %s' %
to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) > 0:
snapmirror_info = result.get_child_by_name(
'attributes-list').get_child_by_name('snapmirror-info')
snap_info['mirror_state'] = snapmirror_info.get_child_content(
'mirror-state')
snap_info['status'] = snapmirror_info.get_child_content(
'relationship-status')
snap_info['schedule'] = snapmirror_info.get_child_content(
'schedule')
if snap_info['schedule'] is None:
snap_info['schedule'] = ""
return snap_info
return None
def snapmirror_create(self):
"""
Create a SnapMirror relationship
"""
options = {
'source-location': self.parameters['source_path'],
'destination-location': self.parameters['destination_path']
}
snapmirror_create = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-create', **options)
if self.parameters.get('relationship_type'):
snapmirror_create.add_new_child(
'relationship-type', self.parameters['relationship_type'])
if self.parameters.get('schedule'):
snapmirror_create.add_new_child('schedule',
self.parameters['schedule'])
try:
self.server.invoke_successfully(snapmirror_create,
enable_tunneling=True)
self.snapmirror_initialize()
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error creating SnapMirror %s' %
to_native(error),
exception=traceback.format_exc())
def delete_snapmirror(self):
"""
Delete a SnapMirror relationship
#1. Quiesce the SnapMirror relationship at destination
#2. Break the SnapMirror relationship at the source
#3. Release the SnapMirror at destination
#4. Delete SnapMirror at destination
"""
if not self.parameters.get('source_hostname'):
self.module.fail_json(
msg='Missing parameters for delete: Please specify the '
'source cluster to release the SnapMirror relation')
if self.parameters.get('source_username'):
self.module.params['username'] = self.parameters['dest_username']
if self.parameters.get('source_password'):
self.module.params['password'] = self.parameters['dest_password']
self.source_server = netapp_utils.setup_ontap_zapi(module=self.module)
self.snapmirror_quiesce()
self.snapmirror_break()
if self.get_destination():
self.snapmirror_release()
self.snapmirror_delete()
def snapmirror_quiesce(self):
"""
Quiesce SnapMirror relationship - disable all future transfers to this destination
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_quiesce = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-quiesce', **options)
try:
self.server.invoke_successfully(snapmirror_quiesce,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error Quiescing SnapMirror : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_delete(self):
"""
Delete SnapMirror relationship at destination cluster
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_delete = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-destroy', **options)
try:
self.server.invoke_successfully(snapmirror_delete,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error deleting SnapMirror : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_break(self):
"""
Break SnapMirror relationship at destination cluster
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_break = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-break', **options)
try:
self.server.invoke_successfully(snapmirror_break,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error breaking SnapMirror relationship : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_release(self):
"""
Release SnapMirror relationship from source cluster
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_release = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-release', **options)
try:
self.source_server.invoke_successfully(snapmirror_release,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error releasing SnapMirror relationship : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_abort(self):
"""
Abort a SnapMirror relationship in progress
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_abort = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-abort', **options)
try:
self.server.invoke_successfully(snapmirror_abort,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error aborting SnapMirror relationship : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_initialize(self):
"""
Initialize SnapMirror based on relationship type
"""
current = self.snapmirror_get()
if current['mirror_state'] != 'snapmirrored':
initialize_zapi = 'snapmirror-initialize'
if self.parameters.get('relationship_type') and self.parameters[
'relationship_type'] == 'load_sharing':
initialize_zapi = 'snapmirror-initialize-ls-set'
options = {
'destination-location': self.parameters['destination_path']
}
snapmirror_init = netapp_utils.zapi.NaElement.create_node_with_children(
initialize_zapi, **options)
try:
self.server.invoke_successfully(snapmirror_init,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error initializing SnapMirror : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_modify(self, modify):
"""
Modify SnapMirror schedule
"""
options = {
'destination-location': self.parameters['destination_path'],
'schedule': modify.get('schedule')
}
snapmirror_modify = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-modify', **options)
try:
self.server.invoke_successfully(snapmirror_modify,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error modifying SnapMirror schedule : %s' %
(to_native(error)),
exception=traceback.format_exc())
def snapmirror_update(self):
"""
Update data in destination endpoint
"""
options = {'destination-location': self.parameters['destination_path']}
snapmirror_update = netapp_utils.zapi.NaElement.create_node_with_children(
'snapmirror-update', **options)
try:
result = self.server.invoke_successfully(snapmirror_update,
enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error updating SnapMirror : %s' %
(to_native(error)),
exception=traceback.format_exc())
def check_parameters(self):
"""
Validate parameters and fail if one or more required params are missing
Update source and destination path from vserver and volume parameters
"""
if self.parameters['state'] == 'present'\
and (self.parameters.get('source_path') or self.parameters.get('destination_path')):
if not self.parameters.get(
'destination_path') or not self.parameters.get(
'source_path'):
self.module.fail_json(
msg='Missing parameters: Source path or Destination path')
elif self.parameters.get('source_volume'):
if not self.parameters.get(
'source_vserver') or not self.parameters.get(
'destination_vserver'):
self.module.fail_json(
msg=
'Missing parameters: source vserver or destination vserver or both'
)
self.parameters['source_path'] = self.parameters[
'source_vserver'] + ":" + self.parameters['source_volume']
self.parameters['destination_path'] = self.parameters['destination_vserver'] + ":" +\
self.parameters['destination_volume']
elif self.parameters.get('source_vserver'):
self.parameters[
'source_path'] = self.parameters['source_vserver'] + ":"
self.parameters['destination_path'] = self.parameters[
'destination_vserver'] + ":"
def get_destination(self):
release_get = netapp_utils.zapi.NaElement(
'snapmirror-get-destination-iter')
query = netapp_utils.zapi.NaElement('query')
snapmirror_dest_info = netapp_utils.zapi.NaElement(
'snapmirror-destination-info')
snapmirror_dest_info.add_new_child('destination-location',
self.parameters['destination_path'])
query.add_child_elem(snapmirror_dest_info)
release_get.add_child_elem(query)
try:
result = self.source_server.invoke_successfully(
release_get, enable_tunneling=True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error fetching snapmirror destinations info: %s' %
to_native(error),
exception=traceback.format_exc())
if result.get_child_by_name('num-records') and \
int(result.get_child_content('num-records')) > 0:
return True
return None
def apply(self):
"""
Apply action to SnapMirror
"""
self.check_parameters()
current = self.snapmirror_get()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if cd_action == 'create':
self.snapmirror_create()
elif cd_action == 'delete':
if current['status'] == 'transferring':
self.snapmirror_abort()
else:
self.delete_snapmirror()
else:
if modify:
self.snapmirror_modify(modify)
# check for initialize
if current and current['mirror_state'] != 'snapmirrored':
self.snapmirror_initialize()
# set changed explicitly for initialize
self.na_helper.changed = True
# Update when create is called again, or modify is being called
if self.parameters['state'] == 'present':
self.snapmirror_update()
self.module.exit_json(changed=self.na_helper.changed)
class AzureRMNetAppSnapshot(AzureRMModuleBase):
def __init__(self):
self.module_arg_spec = dict(
resource_group=dict(type='str', required=True),
name=dict(type='str', required=True),
volume_name=dict(type='str', required=True),
pool_name=dict(type='str', required=True),
account_name=dict(type='str', required=True),
location=dict(type='str', required=False),
state=dict(choices=['present', 'absent'], default='present', type='str')
)
self.module = AnsibleModule(
argument_spec=self.module_arg_spec,
required_if=[
('state', 'present', ['location']),
],
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# authentication - using CLI
if HAS_AZURE_MGMT_NETAPP is False:
self.module.fail_json(msg="the python Azure-mgmt-NetApp module is required")
if HAS_AZURE_COMMON is False:
self.module.fail_json(msg="the python azure-common module is required")
self.client = get_client_from_cli_profile(AzureNetAppFilesManagementClient)
super(AzureRMNetAppSnapshot, self).__init__(derived_arg_spec=self.module_arg_spec, supports_check_mode=True)
def get_azure_netapp_snapshot(self):
"""
Returns snapshot object for an existing snapshot
Return None if snapshot does not exist
"""
try:
snapshot_get = self.client.snapshots.get(self.parameters['resource_group'], self.parameters['account_name'],
self.parameters['pool_name'], self.parameters['volume_name'],
self.parameters['name'])
except CloudError: # snapshot does not exist
return None
return snapshot_get
def create_azure_netapp_snapshot(self):
"""
Create a snapshot for the given Azure NetApp Account
:return: None
"""
snapshot_body = Snapshot(
location=self.parameters['location']
)
try:
self.client.snapshots.create(body=snapshot_body, resource_group_name=self.parameters['resource_group'],
account_name=self.parameters['account_name'],
pool_name=self.parameters['pool_name'],
volume_name=self.parameters['volume_name'], snapshot_name=self.parameters['name'])
except CloudError as error:
self.module.fail_json(msg='Error creating snapshot %s for Azure NetApp account %s: %s'
% (self.parameters['name'], self.parameters['account_name'], to_native(error)),
exception=traceback.format_exc())
def delete_azure_netapp_snapshot(self):
"""
Delete a snapshot for the given Azure NetApp Account
:return: None
"""
try:
self.client.snapshots.delete(resource_group_name=self.parameters['resource_group'],
account_name=self.parameters['account_name'],
pool_name=self.parameters['pool_name'],
volume_name=self.parameters['volume_name'], snapshot_name=self.parameters['name'])
except CloudError as error:
self.module.fail_json(msg='Error deleting snapshot %s for Azure NetApp account %s: %s'
% (self.parameters['name'], self.parameters['account_name'], to_native(error)),
exception=traceback.format_exc())
def exec_module(self, **kwargs):
current = self.get_azure_netapp_snapshot()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_azure_netapp_snapshot()
elif cd_action == 'delete':
self.delete_azure_netapp_snapshot()
self.module.exit_json(changed=self.na_helper.changed)
