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.get_unassigned_disk_count()
owned_disks = self.get_owned_disk_count()
if 'disk_count' in self.parameters:
if self.parameters['disk_count'] < owned_disks:
self.module.fail_json(
msg="Fewer disks than are currently owned was requested. "
"This module does not do any disk removing. "
"All disk removing will need to be done manually.")
if self.parameters['disk_count'] > owned_disks + unowned_disks:
self.module.fail_json(
msg="Not enough unowned disks remain to fulfill request")
if unowned_disks >= 1:
if 'disk_count' in self.parameters:
if self.parameters['disk_count'] > owned_disks:
needed_disks = self.parameters['disk_count'] - owned_disks
self.disk_assign(needed_disks)
changed = True
else:
self.disk_assign(0)
changed = True
self.module.exit_json(changed=changed)
def apply(self):
netapp_utils.ems_log_event("na_ontap_vscan_on_access_policy", self.server)
changed = False
policy_obj = self.return_on_access_policy()
if self.state == 'present':
if not self.exists_access_policy(policy_obj):
if not self.module.check_mode:
self.create_on_access_policy()
if self.policy_status:
self.status_modify_on_access_policy()
changed = True
else:
# Check if anything has changed first.
if self.has_policy_changed():
if not self.module.check_mode:
result = policy_obj.get_child_by_name('attributes-list').get_child_by_name('vscan-on-access-policy-info')
if str(self.policy_status).lower() != result.get_child_content('is-policy-enabled'):
if self.policy_status is not None:
self.status_modify_on_access_policy()
self.modify_on_access_policy()
changed = True
if self.state == 'absent':
if self.exists_access_policy(policy_obj):
if not self.module.check_mode:
result = policy_obj.get_child_by_name('attributes-list').get_child_by_name('vscan-on-access-policy-info')
if result.get_child_content('is-policy-enabled') == 'true':
self.status_modify_on_access_policy()
self.delete_on_access_policy()
changed = True
self.module.exit_json(changed=changed)
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)
def apply(self):
"""
Applies action from playbook
"""
netapp_utils.ems_log_event("na_ontap_autosupport", self.server)
current, modify = self.portset_get(), None
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action is None and self.parameters['state'] == 'present':
if self.parameters.get(
'type') and self.parameters['type'] != current['type']:
self.module.fail_json(
msg=
"modify protocol(type) not supported and %s already exists in vserver %s under different type"
% (self.parameters['name'], self.parameters['vserver']))
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_portset()
self.add_ports()
elif cd_action == 'delete':
self.delete_portset()
elif modify:
self.remove_ports(current['ports'])
self.add_ports()
self.module.exit_json(changed=self.na_helper.changed)
def autosupport_log(self, event_name):
"""
Create a log event against the provided vserver
"""
server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
netapp_utils.ems_log_event(event_name, server)
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)
def apply(self):
# logging ems event
results = netapp_utils.get_cserver(self.cluster)
cserver = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=results)
netapp_utils.ems_log_event("na_ontap_node", cserver)
from_exists = None
modify = None
current = self.get_node(self.parameters['name'])
if current is None and 'from_name' in self.parameters:
from_exists = self.get_node(self.parameters['from_name'])
# since from_exists contains the node name, modify will at least contain the node name if a rename is required.
modify = self.na_helper.get_modified_attributes(
from_exists, self.parameters)
elif current is not None:
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if current is None and from_exists is None:
msg = 'from_name: %s' % self.parameters.get('from_name') if 'from_name' in self.parameters \
else 'name: %s' % self.parameters['name']
self.module.fail_json(msg='Node not found: %s' % msg)
if self.na_helper.changed:
if not self.module.check_mode:
if 'name' in modify:
self.rename_node()
modify.pop('name')
if modify:
self.modify_node()
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
"""
Run Module based on play book
"""
changed = False
broadcast_domain_details = self.get_broadcast_domain_ports()
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_broadcast_domain_ports", cserver)
if broadcast_domain_details is None:
self.module.fail_json(msg='Error broadcast domain not found: %s' %
self.broadcast_domain)
if self.module.check_mode:
pass
else:
if self.state == 'present': # execute create
ports_to_add = [
port for port in self.ports
if port not in broadcast_domain_details['ports']
]
if len(ports_to_add) > 0:
changed = self.create_broadcast_domain_ports(ports_to_add)
elif self.state == 'absent': # execute delete
ports_to_delete = [
port for port in self.ports
if port in broadcast_domain_details['ports']
]
if len(ports_to_delete) > 0:
changed = self.delete_broadcast_domain_ports(
ports_to_delete)
self.module.exit_json(changed=changed)
def apply(self):
'''Call create/modify/delete operations.'''
current = self.get_ldap_client()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
# state is present, either ldap_servers or ad_domain is required
if self.parameters['state'] == 'present' and not self.parameters.get('ldap_servers') \
and self.parameters.get('ad_domain') is None:
self.module.fail_json(
msg='Required one of ldap_servers or ad_domain')
if self.parameters['state'] == 'present' and cd_action is None:
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
# create an ems log event for users with auto support turned on
try:
netapp_utils.ems_log_event("na_ontap_ldap_client", self.server)
except netapp_utils.zapi.NaApiError as errcatch:
self.module.fail_json(
msg='Error connecting to %s: %s' %
(self.parameters['hostname'], to_native(errcatch)),
exception=traceback.format_exc())
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_ldap_client()
elif cd_action == 'delete':
self.delete_ldap_client()
elif modify:
self.modify_ldap_client(modify)
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
netapp_utils.ems_log_event("na_ontap_lun_map_reporting_nodes",
self.server)
reporting_nodes = self.get_lun_map_reporting_nodes()
if reporting_nodes is None:
self.module.fail_json(
msg=
'Error: LUN map for found for vserver %s, LUN path: %s, igroup: %s'
% (self.parameters['vserver'], self.parameters['path'],
self.parameters['initiator_group_name']))
if self.parameters['state'] == 'present':
nodes_to_add = [
node for node in self.parameters['nodes']
if node not in reporting_nodes
]
nodes_to_delete = list()
else:
nodes_to_add = list()
nodes_to_delete = [
node for node in self.parameters['nodes']
if node in reporting_nodes
]
changed = len(nodes_to_add) > 0 or len(nodes_to_delete) > 0
if changed and not self.module.check_mode:
if nodes_to_add:
self.add_lun_map_reporting_nodes(nodes_to_add)
if nodes_to_delete:
self.remove_lun_map_reporting_nodes(nodes_to_delete)
self.module.exit_json(changed=changed,
reporting_nodes=reporting_nodes,
nodes_to_add=nodes_to_add,
nodes_to_delete=nodes_to_delete)
def apply(self):
'''Call create/modify/delete operations.'''
current = self.get_ldap_client()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
# state is present, either ldap_servers or ad_domain is required
if self.parameters['state'] == 'present' and not self.parameters.get('ldap_servers') \
and self.parameters.get('ad_domain') is None:
self.module.fail_json(
msg='Required one of ldap_servers or ad_domain')
if self.parameters['state'] == 'present' and cd_action is None:
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
# create an ems log event for users with auto support turned on
netapp_utils.ems_log_event("na_ontap_ldap_client", self.server)
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_ldap_client()
elif cd_action == 'delete':
self.delete_ldap_client()
elif modify:
self.modify_ldap_client(modify)
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
if not self.use_rest:
netapp_utils.ems_log_event("na_ontap_volume_efficiency", self.server)
current = self.get_volume_efficiency()
# If the volume efficiency does not exist for a given path to create this current is set to disabled
# this is for ONTAP systems that do not enable efficiency by default.
if current is None:
current = {'enabled': 'disabled'}
modify = self.na_helper.get_modified_attributes(current, self.parameters)
if self.na_helper.changed:
if not self.module.check_mode:
if self.parameters['state'] == 'present' and current['enabled'] == 'disabled':
self.enable_volume_efficiency()
# Checking to see if there are any additional parameters that need to be set after enabling volume efficiency required for Non-AFF systems
current = self.get_volume_efficiency()
modify = self.na_helper.get_modified_attributes(current, self.parameters)
elif self.parameters['state'] == 'absent' and current['enabled'] == 'enabled':
self.disable_volume_efficiency()
if 'enabled' in modify:
del modify['enabled']
# Removed the enabled key if there is anything remaining in the modify dict we need to modify.
if modify:
self.modify_volume_efficiency()
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
"""
Apply action to NVMe service
"""
netapp_utils.ems_log_event("na_ontap_nvme", self.server)
current = self.get_nvme()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if self.parameters.get('status_admin') is not None:
self.parameters[
'status_admin'] = self.na_helper.get_value_for_bool(
False, self.parameters['status_admin'])
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 cd_action == 'create':
self.create_nvme()
elif cd_action == 'delete':
# NVMe status_admin needs to be down before deleting it
self.modify_nvme('false')
self.delete_nvme()
elif modify:
self.modify_nvme()
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
netapp_utils.ems_log_event("na_ontap_lun", self.server)
current = self.get_lun()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = None
if cd_action is None and self.parameters['state'] == 'present':
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if cd_action == 'create' and self.parameters.get('size') is None:
self.module.fail_json(
msg="size is a required parameter for create.")
if self.na_helper.changed and not self.module.check_mode:
if cd_action == 'create':
self.create_lun()
elif cd_action == 'delete':
self.delete_lun()
else:
size_changed = False
if 'size' in modify:
# Ensure that size was actually changed. Please
# read notes in 'resize_lun' function for details.
size_changed = self.resize_lun()
modify.pop('size')
if modify:
self.modify_lun(modify)
else:
self.na_helper.changed = size_changed
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
"""
check the option in the playbook to see what needs to be done
:return:
"""
changed = False
result = 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_vlan", cserver)
existing_vlan = self.does_vlan_exist()
if existing_vlan:
if self.state == 'absent': # delete
changed = True
else:
if self.state == 'present': # create
changed = True
if changed:
if self.module.check_mode:
pass
else:
if self.state == 'present':
self.create_vlan()
elif self.state == 'absent':
self.delete_vlan()
self.module.exit_json(changed=changed, meta=result)
def apply(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_fcp", cserver)
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()
elif self.parameters['status'] == 'down':
self.stop_fcp()
changed = True
else:
if exists:
if self.current_status():
self.stop_fcp()
self.destroy_fcp()
changed = True
self.module.exit_json(changed=changed)
def apply(self):
"""Apply action to ntp-server"""
changed = False
ntp_modify = 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_ntp", cserver)
ntp_server_details = self.get_ntp_server()
if ntp_server_details is not None:
if self.state == 'absent': # delete
changed = True
elif self.state == 'present' and self.version:
# modify version
if self.version != ntp_server_details['version']:
ntp_modify = True
changed = True
else:
if self.state == 'present': # create
changed = True
if changed:
if self.module.check_mode:
pass
else:
if self.state == 'present':
if ntp_server_details is None:
self.create_ntp_server()
elif ntp_modify:
self.modify_version()
elif self.state == 'absent':
self.delete_ntp_server()
self.module.exit_json(changed=changed)
def apply(self):
'''Apply action to cifs share'''
netapp_utils.ems_log_event("na_ontap_cifs", self.server)
current = self.get_cifs_share()
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = None
if cd_action is None:
# ZAPI accepts both 'show-previous-versions' and 'show_previous_versions', but only returns the latter
if 'show-previous-versions' in self.parameters.get('share_properties', []) and\
current and 'show_previous_versions' in current.get('share_properties', []):
self.parameters['share_properties'].remove(
'show-previous-versions')
self.parameters['share_properties'].append(
'show_previous_versions')
modify = self.na_helper.get_modified_attributes(
current, self.parameters)
if self.na_helper.changed and not self.module.check_mode:
if cd_action == 'create':
self.create_cifs_share()
elif cd_action == 'delete':
self.delete_cifs_share()
elif modify:
self.modify_cifs_share()
results = dict(changed=self.na_helper.changed)
if modify and netapp_utils.has_feature(self.module, 'show_modified'):
results['modify'] = str(modify)
self.module.exit_json(**results)
def apply(self):
"""
Apply action to cifs-share-access-control
"""
changed = False
cifs_acl_exists = False
netapp_utils.ems_log_event("na_ontap_cifs_acl", self.server)
cifs_acl_details = self.get_cifs_acl()
if cifs_acl_details:
cifs_acl_exists = True
if self.state == 'absent': # delete
changed = True
elif self.state == 'present':
if cifs_acl_details['permission'] != self.permission: # rename
changed = True
else:
if self.state == 'present': # create
changed = True
if changed:
if self.module.check_mode:
pass
else:
if self.state == 'present': # execute create
if not cifs_acl_exists:
self.create_cifs_acl()
else: # execute modify
self.modify_cifs_acl_permission()
elif self.state == 'absent': # execute delete
self.delete_cifs_acl()
self.module.exit_json(changed=changed)
def apply(self):
changed = False
netapp_utils.ems_log_event("na_ontap_svm_options", self.server)
is_set = self.is_option_set()
if not is_set:
self.set_options()
changed = True
self.module.exit_json(changed=changed)
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 autosupport_log(self):
"""
Autosupport log for job_schedule
: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_job_schedule", cserver)
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
"""
netapp_utils.ems_log_event(event_name, self.server)
def autosupport_log(self):
"""
Autosupport log for ucadater
: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_ucadapter", cserver)
def test_ems_log_event_version():
''' validate Ansible version is correctly read '''
source = 'unittest'
server = MockONTAPConnection()
netapp_utils.ems_log_event(source, server)
xml = server.xml_in
version = xml.get_child_content('app-version')
assert version == ansible_version
print("Ansible version: %s" % ansible_version)
def apply(self):
if self.use_rest:
self.apply_for_rest()
else:
create_delete_decision = {}
modify_decision = {}
netapp_utils.ems_log_event("na_ontap_user", self.server)
for application in self.parameters['applications']:
current = self.get_user(application)
if current is not None:
current['lock_user'] = self.na_helper.get_value_for_bool(
True, current['lock_user'])
cd_action = self.na_helper.get_cd_action(
current, self.parameters)
if cd_action is not None:
create_delete_decision[application] = cd_action
else:
modify_decision[
application] = self.na_helper.get_modified_attributes(
current, self.parameters)
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
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
for application in create_delete_decision:
if create_delete_decision[application] == 'create':
self.create_user(application)
elif create_delete_decision[application] == 'delete':
self.delete_user(application)
lock_user = False
for application in modify_decision:
if 'role_name' in modify_decision[application]:
self.modify_user(application)
if 'lock_user' in modify_decision[application]:
lock_user = True
if 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()
# NOTE: unlock has to be performed after setting a password
if lock_user:
if self.parameters.get('lock_user'):
self.lock_given_user()
else:
self.unlock_given_user()
self.module.exit_json(changed=self.na_helper.changed)
def apply(self):
'''Call create/delete/modify/rename operations'''
if not self.use_rest:
netapp_utils.ems_log_event("na_ontap_qtree", self.server)
current = self.get_qtree()
rename, cd_action, modify = None, None, None
if self.parameters.get('from_name'):
from_qtree = self.get_qtree(self.parameters['from_name'])
rename = self.na_helper.is_rename_action(from_qtree, current)
if rename is None:
self.module.fail_json(
msg='Error renaming: qtree %s does not exist' %
self.parameters['from_name'])
if rename:
current = from_qtree
else:
cd_action = self.na_helper.get_cd_action(current, self.parameters)
if cd_action is None and self.parameters['state'] == 'present':
if self.parameters.get('security_style') and self.parameters[
'security_style'] != current['security_style']:
modify = True
if self.parameters.get('unix_permissions') and \
self.parameters['unix_permissions'] != str(current['unix_permissions']):
modify = True
# rest and zapi handle export policy differently
if self.use_rest:
if self.parameters.get('export_policy') and \
self.parameters['export_policy'] != current['export_policy']['name']:
modify = True
else:
if self.parameters.get('export_policy') and \
self.parameters['export_policy'] != current['export_policy']:
modify = True
if self.use_rest and cd_action == 'delete' and not self.parameters[
'force_delete']:
self.module.fail_json(
msg=
'Error: force_delete option is not supported for REST, unless set to true.'
)
if modify:
self.na_helper.changed = True
if self.na_helper.changed:
if self.module.check_mode:
pass
else:
if cd_action == 'create':
self.create_qtree()
elif cd_action == 'delete':
self.delete_qtree(current)
else:
if rename:
self.rename_qtree(current)
if modify:
self.modify_qtree(current)
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)
def apply(self):
"""
Run Module based on play book
"""
if not self.use_rest:
netapp_utils.ems_log_event("na_ontap_net_routes", self.server)
current = self.get_net_route()
modify, cd_action = None, None
if self.use_rest:
modify_params = {'gateway': self.parameters.get('from_gateway'),
'destination': self.parameters.get('from_destination')}
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.
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)
else:
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':
if not self.module.check_mode:
self.create_net_route()
elif cd_action == 'delete':
if not self.module.check_mode:
self.delete_net_route(current)
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)
def ems(self, zapi):
"""
Error out if Cluster Admin username is used with Vserver, or Vserver admin used with out vserver being set
:return:
"""
if self.vserver:
try:
netapp_utils.ems_log_event("na_ontap_zapi" + str(zapi), self.server)
except netapp_utils.zapi.NaApiError:
pass
else:
self.asup_log_for_cserver("na_ontap_zapi: " + str(zapi))
