387 lines
15 KiB
Python
387 lines
15 KiB
Python
#!/usr/bin/python
|
|
""" this is interface module
|
|
|
|
(c) 2018-2019, NetApp, Inc
|
|
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
"""
|
|
|
|
from __future__ import absolute_import, division, print_function
|
|
__metaclass__ = type
|
|
|
|
ANSIBLE_METADATA = {
|
|
'metadata_version': '1.1',
|
|
'status': ['preview'],
|
|
'supported_by': 'certified'
|
|
}
|
|
|
|
DOCUMENTATION = '''
|
|
---
|
|
|
|
module: na_ontap_interface
|
|
short_description: NetApp ONTAP LIF configuration
|
|
|
|
extends_documentation_fragment:
|
|
- netapp.na_ontap
|
|
version_added: '2.6'
|
|
author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
|
|
|
|
description:
|
|
- Creating / deleting and modifying the LIF.
|
|
|
|
options:
|
|
state:
|
|
description:
|
|
- Whether the specified interface should exist or not.
|
|
choices: ['present', 'absent']
|
|
default: present
|
|
|
|
interface_name:
|
|
description:
|
|
- Specifies the logical interface (LIF) name.
|
|
required: true
|
|
|
|
home_node:
|
|
description:
|
|
- Specifies the LIF's home node.
|
|
- By default, the first node from the cluster is considered as home node
|
|
|
|
home_port:
|
|
description:
|
|
- Specifies the LIF's home port.
|
|
- Required when C(state=present)
|
|
|
|
role:
|
|
description:
|
|
- Specifies the role of the LIF.
|
|
- When setting role as "intercluster", setting protocol is not supported.
|
|
- Required when C(state=present).
|
|
|
|
address:
|
|
description:
|
|
- Specifies the LIF's IP address.
|
|
- Required when C(state=present)
|
|
|
|
netmask:
|
|
description:
|
|
- Specifies the LIF's netmask.
|
|
- Required when C(state=present).
|
|
|
|
vserver:
|
|
description:
|
|
- The name of the vserver to use.
|
|
required: true
|
|
|
|
firewall_policy:
|
|
description:
|
|
- Specifies the firewall policy for the LIF.
|
|
|
|
failover_policy:
|
|
description:
|
|
- Specifies the failover policy for the LIF.
|
|
- Possible values are 'disabled', 'system-defined', 'local-only', 'sfo-partner-only', and 'broadcast-domain-wide'
|
|
|
|
subnet_name:
|
|
description:
|
|
- Subnet where the interface address is allocated from.
|
|
If the option is not used, the IP address will need to be provided by
|
|
the administrator during configuration.
|
|
version_added: '2.8'
|
|
|
|
admin_status:
|
|
choices: ['up', 'down']
|
|
description:
|
|
- Specifies the administrative status of the LIF.
|
|
|
|
is_auto_revert:
|
|
description:
|
|
If true, data LIF will revert to its home node under certain circumstances such as startup, and load balancing
|
|
migration capability is disabled automatically
|
|
type: bool
|
|
|
|
protocols:
|
|
description:
|
|
- Specifies the list of data protocols configured on the LIF. By default, the values in this element are nfs, cifs and fcache.
|
|
- Other supported protocols are iscsi and fcp. A LIF can be configured to not support any data protocols by specifying 'none'.
|
|
- Protocol values of none, iscsi, fc-nvme or fcp can't be combined with any other data protocol(s).
|
|
- address, netmask and firewall_policy parameters are not supported for 'fc-nvme' option.
|
|
|
|
'''
|
|
|
|
EXAMPLES = '''
|
|
- name: Create interface
|
|
na_ontap_interface:
|
|
state: present
|
|
interface_name: data2
|
|
home_port: e0d
|
|
home_node: laurentn-vsim1
|
|
role: data
|
|
protocols: nfs
|
|
admin_status: up
|
|
failover_policy: local-only
|
|
firewall_policy: mgmt
|
|
is_auto_revert: true
|
|
address: 10.10.10.10
|
|
netmask: 255.255.255.0
|
|
vserver: svm1
|
|
hostname: "{{ netapp_hostname }}"
|
|
username: "{{ netapp_username }}"
|
|
password: "{{ netapp_password }}"
|
|
|
|
- name: Delete interface
|
|
na_ontap_interface:
|
|
state: absent
|
|
interface_name: data2
|
|
vserver: svm1
|
|
hostname: "{{ netapp_hostname }}"
|
|
username: "{{ netapp_username }}"
|
|
password: "{{ netapp_password }}"
|
|
|
|
'''
|
|
|
|
RETURN = """
|
|
|
|
"""
|
|
|
|
import traceback
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils.netapp_module import NetAppModule
|
|
from ansible.module_utils._text import to_native
|
|
import ansible.module_utils.netapp as netapp_utils
|
|
|
|
HAS_NETAPP_LIB = netapp_utils.has_netapp_lib()
|
|
|
|
|
|
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(
|
|
state=dict(type='str', default='present', choices=['absent', 'present']),
|
|
interface_name=dict(type='str', required=True),
|
|
home_node=dict(type='str'),
|
|
home_port=dict(type='str'),
|
|
role=dict(type='str'),
|
|
address=dict(type='str'),
|
|
netmask=dict(type='str'),
|
|
vserver=dict(type='str', required=True),
|
|
firewall_policy=dict(type='str'),
|
|
failover_policy=dict(type='str'),
|
|
admin_status=dict(type='str', choices=['up', 'down']),
|
|
subnet_name=dict(type='str'),
|
|
is_auto_revert=dict(type='bool'),
|
|
protocols=dict(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'],
|
|
'failover_policy': interface_attributes['failover-policy'].replace('_', '-'),
|
|
'is_auto_revert': True if interface_attributes['is-auto-revert'] == 'true' else False,
|
|
}
|
|
if interface_attributes.get_child_by_name('address'):
|
|
return_value['address'] = interface_attributes['address']
|
|
if interface_attributes.get_child_by_name('netmask'):
|
|
return_value['netmask'] = interface_attributes['netmask']
|
|
if interface_attributes.get_child_by_name('firewall-policy'):
|
|
return_value['firewall_policy'] = interface_attributes['firewall-policy']
|
|
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 set_protocol_option(self, required_keys):
|
|
""" set protocols for create """
|
|
if self.parameters.get('protocols') is not None:
|
|
data_protocols_obj = netapp_utils.zapi.NaElement('data-protocols')
|
|
for protocol in self.parameters.get('protocols'):
|
|
if protocol.lower() == 'fc-nvme':
|
|
required_keys.remove('address')
|
|
required_keys.remove('home_port')
|
|
required_keys.remove('netmask')
|
|
not_required_params = set(['address', 'netmask', 'firewall_policy'])
|
|
if not not_required_params.isdisjoint(set(self.parameters.keys())):
|
|
self.module.fail_json(msg='Error: Following parameters for creating interface are not supported'
|
|
' for data-protocol fc-nvme: %s' % ', '.join(not_required_params))
|
|
data_protocols_obj.add_new_child('data-protocol', protocol)
|
|
return data_protocols_obj
|
|
return None
|
|
|
|
def get_home_node_for_cluster(self):
|
|
''' get the first node name from this cluster '''
|
|
get_node = netapp_utils.zapi.NaElement('cluster-node-get-iter')
|
|
attributes = {
|
|
'query': {
|
|
'cluster-node-info': {}
|
|
}
|
|
}
|
|
get_node.translate_struct(attributes)
|
|
try:
|
|
result = self.server.invoke_successfully(get_node, enable_tunneling=True)
|
|
except netapp_utils.zapi.NaApiError as exc:
|
|
self.module.fail_json(msg='Error fetching node for interface %s: %s' %
|
|
(self.parameters['interface_name'], to_native(exc)),
|
|
exception=traceback.format_exc())
|
|
if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1:
|
|
attributes = result.get_child_by_name('attributes-list')
|
|
return attributes.get_child_by_name('cluster-node-info').get_child_content('node-name')
|
|
return None
|
|
|
|
def validate_create_parameters(self, keys):
|
|
'''
|
|
Validate if required parameters for create are present.
|
|
Parameter requirement might vary based on given data-protocol.
|
|
:return: None
|
|
'''
|
|
if self.parameters.get('home_node') is None:
|
|
node = self.get_home_node_for_cluster()
|
|
if node is not None:
|
|
self.parameters['home_node'] = node
|
|
# validate if mandatory parameters are present for create
|
|
if not keys.issubset(set(self.parameters.keys())):
|
|
self.module.fail_json(msg='Error: Missing one or more required parameters for creating interface: %s'
|
|
% ', '.join(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')
|
|
|
|
def create_interface(self):
|
|
''' calling zapi to create interface '''
|
|
required_keys = set(['role', 'address', 'home_port', 'netmask'])
|
|
data_protocols_obj = self.set_protocol_option(required_keys)
|
|
self.validate_create_parameters(required_keys)
|
|
|
|
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 data_protocols_obj is not None:
|
|
interface_create.add_child_elem(data_protocols_obj)
|
|
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)
|
|
|
|
|
|
def main():
|
|
interface = NetAppOntapInterface()
|
|
interface.apply()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|