ansible-collections/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2025-07-22 12:50:22 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Resolve issues in NetApp E-Series Host module (#39748)

Browse source 
* Resolve issues in NetApp E-Series Host module

The E-Series host module had some bugs relating to the update/creation
of host definitions when iSCSI initiators when included in the
configuration. This patch resolves this and other minor issues with
correctly detecting updates.

There were also several minor issues found that were causing issues with
truly idepotent updates/changes to the host definition.

This patch also provides some unit tests and integration tests to help
catch future issues in these areas.

fixes #28272

* Improve NetApp E-Series Host module testing

The NetApp E-Series Host module integration test lacked feature test
verification to verify the changes made to the storage array.

The NetApp E-Series rest api was used to verify host create, update, and
remove changes made to the NetApp E-Series storage arrays.
This commit is contained in:
Michael Price 2018-08-24 09:44:59 -05:00 • committed by John R Barker
commit ad91793428
8 changed files with 808 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

444
lib/ansible/modules/storage/netapp/netapp_e_host.py
View file

@ -1,17 +1,16 @@
#!/usr/bin/python
# (c) 2016, NetApp, Inc
# -*- coding: utf-8 -*-
#
# (c) 2018, 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
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = """
---
module: netapp_e_host
@ -25,44 +24,141 @@ extends_documentation_fragment:
options:
name:
description:
- If the host doesn't yet exist, the label to assign at creation time.
- If the hosts already exists, this is what is used to identify the host to apply any desired changes
- If the host doesn't yet exist, the label/name to assign at creation time.
- If the hosts already exists, this will be used to uniquely identify the host to make any required changes
required: True
aliases:
- label
state:
description:
- Set to absent to remove an existing host
- Set to present to modify or create a new host definition
choices:
- absent
- present
default: present
version_added: 2.7
host_type_index:
description:
- The index that maps to host type you wish to create. It is recommended to use the M(netapp_e_facts) module to gather this information.
Alternatively you can use the WSP portal to retrieve the information.
required: True
- Required when C(state=present)
aliases:
- host_type
ports:
description:
- a list of of dictionaries of host ports you wish to associate with the newly created host
- A list of host ports you wish to associate with the host.
- Host ports are uniquely identified by their WWN or IQN. Their assignments to a particular host are
uniquely identified by a label and these must be unique.
required: False
suboptions:
type:
description:
- The interface type of the port to define.
- Acceptable choices depend on the capabilities of the target hardware/software platform.
required: true
choices:
- iscsi
- sas
- fc
- ib
- nvmeof
- ethernet
label:
description:
- A unique label to assign to this port assignment.
required: true
port:
description:
- The WWN or IQN of the hostPort to assign to this port definition.
required: true
force_port:
description:
- Allow ports that are already assigned to be re-assigned to your current host
required: false
type: bool
version_added: 2.7
group:
description:
- the group you want the host to be a member of
- The unique identifier of the host-group you want the host to be a member of; this is used for clustering.
required: False
aliases:
- cluster
log_path:
description:
- A local path to a file to be used for debug logging
required: False
version_added: 2.7
"""
EXAMPLES = """
- name: Set Host Info
- name: Define or update an existing host named 'Host1'
netapp_e_host:
ssid: "{{ ssid }}"
api_url: "{{ netapp_api_url }}"
api_username: "{{ netapp_api_username }}"
api_password: "{{ netapp_api_password }}"
name: "{{ host_name }}"
host_type_index: "{{ host_type_index }}"
ssid: "1"
api_url: "10.113.1.101:8443"
api_username: "admin"
api_password: "myPassword"
name: "Host1"
state: present
host_type_index: 28
ports:
- type: 'iscsi'
label: 'PORT_1'
port: 'iqn.1996-04.de.suse:01:56f86f9bd1fe'
- type: 'fc'
label: 'FC_1'
port: '10:00:FF:7C:FF:FF:FF:01'
- type: 'fc'
label: 'FC_2'
port: '10:00:FF:7C:FF:FF:FF:00'
- name: Ensure a host named 'Host2' doesn't exist
netapp_e_host:
ssid: "1"
api_url: "10.113.1.101:8443"
api_username: "admin"
api_password: "myPassword"
name: "Host2"
state: absent
"""
RETURN = """
msg:
description: Success message
returned: success
description:
- A user-readable description of the actions performed.
returned: on success
type: string
sample: The host has been created.
id:
description:
- the unique identifier of the host on the E-Series storage-system
returned: on success when state=present
type: string
sample: 00000000600A098000AAC0C3003004700AD86A52
version_added: "2.6"
ssid:
description:
- the unique identifer of the E-Series storage-system with the current api
returned: on success
type: string
sample: 1
version_added: "2.6"
api_url:
description:
- the url of the API that this request was proccessed by
returned: on success
type: string
sample: https://webservices.example.com:8443
version_added: "2.6"
"""
import json
import logging
from pprint import pformat
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.netapp import request, eseries_host_argument_spec
@ -78,15 +174,22 @@ class Host(object):
def __init__(self):
argument_spec = eseries_host_argument_spec()
argument_spec.update(dict(
state=dict(type='str', required=True, choices=['absent', 'present']),
group=dict(type='str', required=False),
state=dict(type='str', default='present', choices=['absent', 'present']),
group=dict(type='str', required=False, aliases=['cluster']),
ports=dict(type='list', required=False),
force_port=dict(type='bool', default=False),
name=dict(type='str', required=True),
host_type_index=dict(type='int', required=True)
name=dict(type='str', required=True, aliases=['label']),
host_type_index=dict(type='int', aliases=['host_type']),
log_path=dict(type='str', required=False),
))
self.module = AnsibleModule(argument_spec=argument_spec)
required_if = [
["state", "absent", ["name"]],
["state", "present", ["name", "host_type"]]
]
self.module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, required_if=required_if)
self.check_mode = self.module.check_mode
args = self.module.params
self.group = args['group']
self.ports = args['ports']
@ -99,12 +202,32 @@ class Host(object):
self.user = args['api_username']
self.pwd = args['api_password']
self.certs = args['validate_certs']
self.ports = args['ports']
self.post_body = dict()
self.all_hosts = list()
self.newPorts = list()
self.portsForUpdate = list()
self.force_port_update = False
log_path = args['log_path']
# logging setup
self._logger = logging.getLogger(self.__class__.__name__)
if log_path:
logging.basicConfig(
level=logging.DEBUG, filename=log_path, filemode='w',
format='%(relativeCreated)dms %(levelname)s %(module)s.%(funcName)s:%(lineno)d\n %(message)s')
if not self.url.endswith('/'):
self.url += '/'
# Fix port representation if they are provided with colons
if self.ports is not None:
for port in self.ports:
if port['type'] != 'iscsi':
port['port'] = port['port'].replace(':', '')
@property
def valid_host_type(self):
try:
@ -115,40 +238,25 @@ class Host(object):
msg="Failed to get host types. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
try:
match = filter(lambda host_type: host_type['index'] == self.host_type_index, host_types)[0]
match = list(filter(lambda host_type: host_type['index'] == self.host_type_index, host_types))[0]
return True
except IndexError:
self.module.fail_json(msg="There is no host type with index %s" % self.host_type_index)
@property
def hostports_available(self):
used_ids = list()
try:
(rc, self.available_ports) = request(self.url + 'storage-systems/%s/unassociated-host-ports' % self.ssid,
url_password=self.pwd, url_username=self.user,
validate_certs=self.certs,
headers=HEADERS)
except Exception as err:
self.module.fail_json(
msg="Failed to get unassociated host ports. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
if len(self.available_ports) > 0 and len(self.ports) <= len(self.available_ports):
for port in self.ports:
for free_port in self.available_ports:
# Desired Type matches but also make sure we haven't already used the ID
if not free_port['id'] in used_ids:
# update the port arg to have an id attribute
used_ids.append(free_port['id'])
break
if len(used_ids) != len(self.ports) and not self.force_port:
self.module.fail_json(
msg="There are not enough free host ports with the specified port types to proceed")
else:
return True
else:
self.module.fail_json(msg="There are no host ports available OR there are not enough unassigned host ports")
def host_ports_available(self):
"""Determine if the hostPorts requested have already been assigned"""
for host in self.all_hosts:
if host['label'] != self.name:
for host_port in host['hostSidePorts']:
for port in self.ports:
if (port['port'] == host_port['address'] or port['label'] == host_port['label']):
if not self.force_port:
self.module.fail_json(
msg="There are no host ports available OR there are not enough unassigned host ports")
else:
return False
return True
@property
def group_id(self):
@ -162,7 +270,7 @@ class Host(object):
msg="Failed to get host groups. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
try:
group_obj = filter(lambda group: group['name'] == self.group, all_groups)[0]
group_obj = list(filter(lambda group: group['name'] == self.group, all_groups))[0]
return group_obj['id']
except IndexError:
self.module.fail_json(msg="No group with the name: %s exists" % self.group)
@ -172,6 +280,10 @@ class Host(object):
@property
def host_exists(self):
"""Determine if the requested host exists
As a side effect, set the full list of defined hosts in 'all_hosts', and the target host in 'host_obj'.
"""
all_hosts = list()
try:
(rc, all_hosts) = request(self.url + 'storage-systems/%s/hosts' % self.ssid, url_password=self.pwd,
url_username=self.user, validate_certs=self.certs, headers=HEADERS)
@ -180,8 +292,20 @@ class Host(object):
msg="Failed to determine host existence. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
self.all_hosts = all_hosts
# Augment the host objects
for host in all_hosts:
# Augment hostSidePorts with their ID (this is an omission in the API)
host_side_ports = host['hostSidePorts']
initiators = dict((port['label'], port['id']) for port in host['initiators'])
ports = dict((port['label'], port['id']) for port in host['ports'])
ports.update(initiators)
for port in host_side_ports:
if port['label'] in ports:
port['id'] = ports[port['label']]
try: # Try to grab the host object
self.host_obj = filter(lambda host: host['label'] == self.name, all_hosts)[0]
self.host_obj = list(filter(lambda host: host['label'] == self.name, all_hosts))[0]
return True
except IndexError:
# Host with the name passed in does not exist
@ -189,28 +313,51 @@ class Host(object):
@property
def needs_update(self):
"""Determine whether we need to update the Host object
As a side effect, we will set the ports that we need to update (portsForUpdate), and the ports we need to add
(newPorts), on self.
:return:
"""
needs_update = False
self.force_port_update = False
if self.host_obj['clusterRef'] != self.group_id or \
self.host_obj['hostTypeIndex'] != self.host_type_index:
if self.host_obj['clusterRef'] != self.group_id or self.host_obj['hostTypeIndex'] != self.host_type_index:
self._logger.info("Either hostType or the clusterRef doesn't match, an update is required.")
needs_update = True
if self.ports:
if not self.host_obj['ports']:
self._logger.debug("Determining if ports need to be updated.")
# Find the names of all defined ports
port_names = set(port['label'] for port in self.host_obj['hostSidePorts'])
port_addresses = set(port['address'] for port in self.host_obj['hostSidePorts'])
# If we have ports defined and there are no ports on the host object, we need an update
if not self.host_obj['hostSidePorts']:
needs_update = True
for arg_port in self.ports:
# First a quick check to see if the port is mapped to a different host
if not self.port_on_diff_host(arg_port):
for obj_port in self.host_obj['ports']:
if arg_port['label'] == obj_port['label']:
# Confirmed that port arg passed in exists on the host
# port_id = self.get_port_id(obj_port['label'])
if arg_port['type'] != obj_port['portId']['ioInterfaceType']:
needs_update = True
if 'iscsiChapSecret' in arg_port:
# No way to know the current secret attr, so always return True just in case
needs_update = True
# The port (as defined), currently does not exist
if arg_port['label'] not in port_names:
needs_update = True
# This port has not been defined on the host at all
if arg_port['port'] not in port_addresses:
self.newPorts.append(arg_port)
# A port label update has been requested
else:
self.portsForUpdate.append(arg_port)
# The port does exist, does it need to be updated?
else:
for obj_port in self.host_obj['hostSidePorts']:
if arg_port['label'] == obj_port['label']:
# Confirmed that port arg passed in exists on the host
# port_id = self.get_port_id(obj_port['label'])
if arg_port['type'] != obj_port['type']:
needs_update = True
self.portsForUpdate.append(arg_port)
if 'iscsiChapSecret' in arg_port:
# No way to know the current secret attr, so always return True just in case
needs_update = True
self.portsForUpdate.append(arg_port)
else:
# If the user wants the ports to be reassigned, do it
if self.force_port:
@ -218,106 +365,165 @@ class Host(object):
needs_update = True
else:
self.module.fail_json(
msg="The port you specified:\n%s\n is associated with a different host. Specify force_port as True or try a different "
"port spec" % arg_port
msg="The port you specified:\n%s\n is associated with a different host. Specify force_port"
" as True or try a different port spec" % arg_port
)
self._logger.debug("Is an update required ?=%s", needs_update)
return needs_update
def get_ports_on_host(self):
"""Retrieve the hostPorts that are defined on the target host
:return: a list of hostPorts with their labels and ids
Example:
[
{
'name': 'hostPort1',
'id': '0000000000000000000000'
}
]
"""
ret = dict()
for host in self.all_hosts:
if host['name'] == self.name:
ports = host['hostSidePorts']
for port in ports:
ret[port['address']] = {'label': port['label'], 'id': port['id'], 'address': port['address']}
return ret
def port_on_diff_host(self, arg_port):
""" Checks to see if a passed in port arg is present on a different host """
for host in self.all_hosts:
# Only check 'other' hosts
if self.host_obj['name'] != self.name:
for port in host['ports']:
if host['name'] != self.name:
for port in host['hostSidePorts']:
# Check if the port label is found in the port dict list of each host
if arg_port['label'] == port['label']:
if arg_port['label'] == port['label'] or arg_port['port'] == port['address']:
self.other_host = host
return True
return False
def get_port(self, label, address):
for host in self.all_hosts:
for port in host['hostSidePorts']:
if port['label'] == label or port['address'] == address:
return port
def reassign_ports(self, apply=True):
if not self.post_body:
self.post_body = dict(
portsToUpdate=dict()
)
post_body = dict(
portsToUpdate=dict()
)
for port in self.ports:
if self.port_on_diff_host(port):
self.post_body['portsToUpdate'].update(dict(
portRef=self.other_host['hostPortRef'],
host_port = self.get_port(port['label'], port['port'])
post_body['portsToUpdate'].update(dict(
portRef=host_port['id'],
hostRef=self.host_obj['id'],
label=port['label']
# Doesn't yet address port identifier or chap secret
))
self._logger.info("reassign_ports: %s", pformat(post_body))
if apply:
try:
(rc, self.host_obj) = request(
self.url + 'storage-systems/%s/hosts/%s' % (self.ssid, self.host_obj['id']),
url_username=self.user, url_password=self.pwd, headers=HEADERS,
validate_certs=self.certs, method='POST', data=json.dumps(self.post_body))
validate_certs=self.certs, method='POST', data=json.dumps(post_body))
except Exception as err:
self.module.fail_json(
msg="Failed to reassign host port. Host Id [%s]. Array Id [%s]. Error [%s]." % (
self.host_obj['id'], self.ssid, to_native(err)))
def update_host(self):
if self.ports:
if self.hostports_available:
if self.force_port_update is True:
self.reassign_ports(apply=False)
# Make sure that only ports that arent being reassigned are passed into the ports attr
self.ports = [port for port in self.ports if not self.port_on_diff_host(port)]
return post_body
self.post_body['ports'] = self.ports
def update_host(self):
self._logger.debug("Beginning the update for host=%s.", self.name)
if self.ports:
self._logger.info("Requested ports: %s", pformat(self.ports))
if self.host_ports_available or self.force_port:
self.reassign_ports(apply=True)
# Make sure that only ports that aren't being reassigned are passed into the ports attr
host_ports = self.get_ports_on_host()
ports_for_update = list()
self._logger.info("Ports on host: %s", pformat(host_ports))
for port in self.portsForUpdate:
if port['port'] in host_ports:
defined_port = host_ports.get(port['port'])
defined_port.update(port)
defined_port['portRef'] = defined_port['id']
ports_for_update.append(defined_port)
self._logger.info("Ports to update: %s", pformat(ports_for_update))
self._logger.info("Ports to define: %s", pformat(self.newPorts))
self.post_body['portsToUpdate'] = ports_for_update
self.post_body['ports'] = self.newPorts
else:
self._logger.debug("No host ports were defined.")
if self.group:
self.post_body['groupId'] = self.group_id
self.post_body['hostType'] = dict(index=self.host_type_index)
try:
(rc, self.host_obj) = request(self.url + 'storage-systems/%s/hosts/%s' % (self.ssid, self.host_obj['id']),
url_username=self.user, url_password=self.pwd, headers=HEADERS,
validate_certs=self.certs, method='POST', data=json.dumps(self.post_body))
except Exception as err:
self.module.fail_json(msg="Failed to update host. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
api = self.url + 'storage-systems/%s/hosts/%s' % (self.ssid, self.host_obj['id'])
self._logger.info("POST => url=%s, body=%s.", api, pformat(self.post_body))
self.module.exit_json(changed=True, **self.host_obj)
if not self.check_mode:
try:
(rc, self.host_obj) = request(api, url_username=self.user, url_password=self.pwd, headers=HEADERS,
validate_certs=self.certs, method='POST', data=json.dumps(self.post_body))
except Exception as err:
self.module.fail_json(
msg="Failed to update host. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
payload = self.build_success_payload(self.host_obj)
self.module.exit_json(changed=True, **payload)
def create_host(self):
self._logger.info("Creating host definition.")
needs_reassignment = False
post_body = dict(
name=self.name,
hostType=dict(index=self.host_type_index),
groupId=self.group_id,
ports=self.ports
)
if self.ports:
# Check that all supplied port args are valid
if self.hostports_available:
if self.host_ports_available:
self._logger.info("The host-ports requested are available.")
post_body.update(ports=self.ports)
elif not self.force_port:
self.module.fail_json(
msg="You supplied ports that are already in use. Supply force_port to True if you wish to reassign the ports")
msg="You supplied ports that are already in use."
" Supply force_port to True if you wish to reassign the ports")
else:
needs_reassignment = True
if not self.host_exists:
api = self.url + "storage-systems/%s/hosts" % self.ssid
self._logger.info('POST => url=%s, body=%s', api, pformat(post_body))
if not (self.host_exists and self.check_mode):
try:
(rc, create_resp) = request(self.url + "storage-systems/%s/hosts" % self.ssid, method='POST',
url_username=self.user, url_password=self.pwd, validate_certs=self.certs,
data=json.dumps(post_body), headers=HEADERS)
(rc, self.host_obj) = request(api, method='POST',
url_username=self.user, url_password=self.pwd, validate_certs=self.certs,
data=json.dumps(post_body), headers=HEADERS)
except Exception as err:
self.module.fail_json(
msg="Failed to create host. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
else:
payload = self.build_success_payload(self.host_obj)
self.module.exit_json(changed=False,
msg="Host already exists. Id [%s]. Host [%s]." % (self.ssid, self.name))
msg="Host already exists. Id [%s]. Host [%s]." % (self.ssid, self.name), **payload)
self.host_obj = create_resp
if self.ports and self.force_port:
self._logger.info("Created host, beginning port re-assignment.")
if needs_reassignment:
self.reassign_ports()
self.module.exit_json(changed=True, **self.host_obj)
payload = self.build_success_payload(self.host_obj)
self.module.exit_json(changed=True, msg='Host created.', **payload)
def remove_host(self):
try:
@ -326,25 +532,37 @@ class Host(object):
url_username=self.user, url_password=self.pwd, validate_certs=self.certs)
except Exception as err:
self.module.fail_json(
msg="Failed to remote host. Host[%s]. Array Id [%s]. Error [%s]." % (self.host_obj['id'],
msg="Failed to remove host. Host[%s]. Array Id [%s]. Error [%s]." % (self.host_obj['id'],
self.ssid,
to_native(err)))
def build_success_payload(self, host=None):
keys = ['id']
if host is not None:
result = dict((key, host[key]) for key in keys)
else:
result = dict()
result['ssid'] = self.ssid
result['api_url'] = self.url
return result
def apply(self):
if self.state == 'present':
if self.host_exists:
if self.needs_update and self.valid_host_type:
self.update_host()
else:
self.module.exit_json(changed=False, msg="Host already present.", id=self.ssid, label=self.name)
payload = self.build_success_payload(self.host_obj)
self.module.exit_json(changed=False, msg="Host already present; no changes required.", **payload)
elif self.valid_host_type:
self.create_host()
else:
payload = self.build_success_payload()
if self.host_exists:
self.remove_host()
self.module.exit_json(changed=True, msg="Host removed.")
self.module.exit_json(changed=True, msg="Host removed.", **payload)
else:
self.module.exit_json(changed=False, msg="Host already absent.", id=self.ssid, label=self.name)
self.module.exit_json(changed=False, msg="Host already absent.", **payload)
def main():