mirror of
https://github.com/ansible-collections/community.general.git
synced 2024-09-14 20:13:21 +02:00
07ecfc940c
* Recover missing netapp.ontap module doc fragments from ansible/ansible@pre-ansible-base. * Fix PEP8 issues. * Remove netbox empty files, and test which shouldn't be here. * Add forgotten file for kubevirt tests. * Fix unit test imports. * ansible/ansible#68415 has been fixed. * Clean up/rearrange imports. * Update ignore.txt, fix boilerplate. * Netapp docs fragment: fix spacing * Forgot to adjust kubevirt tests.
935 lines
44 KiB
Python
935 lines
44 KiB
Python
#!/usr/bin/python
|
|
|
|
# (c) 2016, 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": "community"}
|
|
|
|
DOCUMENTATION = '''
|
|
---
|
|
module: netapp_e_storagepool
|
|
short_description: NetApp E-Series manage volume groups and disk pools
|
|
description: Create or remove volume groups and disk pools for NetApp E-series storage arrays.
|
|
author:
|
|
- Kevin Hulquest (@hulquest)
|
|
- Nathan Swartz (@ndswartz)
|
|
extends_documentation_fragment:
|
|
- community.general.netapp.eseries
|
|
|
|
options:
|
|
state:
|
|
description:
|
|
- Whether the specified storage pool should exist or not.
|
|
- Note that removing a storage pool currently requires the removal of all defined volumes first.
|
|
required: true
|
|
choices: ["present", "absent"]
|
|
name:
|
|
description:
|
|
- The name of the storage pool to manage
|
|
required: true
|
|
criteria_drive_count:
|
|
description:
|
|
- The number of disks to use for building the storage pool.
|
|
- When I(state=="present") then I(criteria_drive_count) or I(criteria_min_usable_capacity) must be specified.
|
|
- The pool will be expanded if this number exceeds the number of disks already in place (See expansion note below)
|
|
required: false
|
|
type: int
|
|
criteria_min_usable_capacity:
|
|
description:
|
|
- The minimum size of the storage pool (in size_unit).
|
|
- When I(state=="present") then I(criteria_drive_count) or I(criteria_min_usable_capacity) must be specified.
|
|
- The pool will be expanded if this value exceeds its current size. (See expansion note below)
|
|
required: false
|
|
type: float
|
|
criteria_drive_type:
|
|
description:
|
|
- The type of disk (hdd or ssd) to use when searching for candidates to use.
|
|
- When not specified each drive type will be evaluated until successful drive candidates are found starting with
|
|
the most prevalent drive type.
|
|
required: false
|
|
choices: ["hdd","ssd"]
|
|
criteria_size_unit:
|
|
description:
|
|
- The unit used to interpret size parameters
|
|
choices: ["bytes", "b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"]
|
|
default: "gb"
|
|
criteria_drive_min_size:
|
|
description:
|
|
- The minimum individual drive size (in size_unit) to consider when choosing drives for the storage pool.
|
|
criteria_drive_interface_type:
|
|
description:
|
|
- The interface type to use when selecting drives for the storage pool
|
|
- If not provided then all interface types will be considered.
|
|
choices: ["sas", "sas4k", "fibre", "fibre520b", "scsi", "sata", "pata"]
|
|
required: false
|
|
criteria_drive_require_da:
|
|
description:
|
|
- Ensures the storage pool will be created with only data assurance (DA) capable drives.
|
|
- Only available for new storage pools; existing storage pools cannot be converted.
|
|
default: false
|
|
type: bool
|
|
criteria_drive_require_fde:
|
|
description:
|
|
- Whether full disk encryption ability is required for drives to be added to the storage pool
|
|
default: false
|
|
type: bool
|
|
raid_level:
|
|
description:
|
|
- The RAID level of the storage pool to be created.
|
|
- Required only when I(state=="present").
|
|
- When I(raid_level=="raidDiskPool") then I(criteria_drive_count >= 10 or criteria_drive_count >= 11) is required
|
|
depending on the storage array specifications.
|
|
- When I(raid_level=="raid0") then I(1<=criteria_drive_count) is required.
|
|
- When I(raid_level=="raid1") then I(2<=criteria_drive_count) is required.
|
|
- When I(raid_level=="raid3") then I(3<=criteria_drive_count<=30) is required.
|
|
- When I(raid_level=="raid5") then I(3<=criteria_drive_count<=30) is required.
|
|
- When I(raid_level=="raid6") then I(5<=criteria_drive_count<=30) is required.
|
|
- Note that raidAll will be treated as raidDiskPool and raid3 as raid5.
|
|
required: false
|
|
choices: ["raidAll", "raid0", "raid1", "raid3", "raid5", "raid6", "raidDiskPool"]
|
|
default: "raidDiskPool"
|
|
secure_pool:
|
|
description:
|
|
- Enables security at rest feature on the storage pool.
|
|
- Will only work if all drives in the pool are security capable (FDE, FIPS, or mix)
|
|
- Warning, once security is enabled it is impossible to disable without erasing the drives.
|
|
required: false
|
|
type: bool
|
|
reserve_drive_count:
|
|
description:
|
|
- Set the number of drives reserved by the storage pool for reconstruction operations.
|
|
- Only valid on raid disk pools.
|
|
required: false
|
|
remove_volumes:
|
|
description:
|
|
- Prior to removing a storage pool, delete all volumes in the pool.
|
|
default: true
|
|
erase_secured_drives:
|
|
description:
|
|
- If I(state=="absent") then all storage pool drives will be erase
|
|
- If I(state=="present") then delete all available storage array drives that have security enabled.
|
|
default: true
|
|
type: bool
|
|
notes:
|
|
- The expansion operations are non-blocking due to the time consuming nature of expanding volume groups
|
|
- Traditional volume groups (raid0, raid1, raid5, raid6) are performed in steps dictated by the storage array. Each
|
|
required step will be attempted until the request fails which is likely because of the required expansion time.
|
|
- raidUnsupported will be treated as raid0, raidAll as raidDiskPool and raid3 as raid5.
|
|
- Tray loss protection and drawer loss protection will be chosen if at all possible.
|
|
'''
|
|
EXAMPLES = """
|
|
- name: No disk groups
|
|
netapp_e_storagepool:
|
|
ssid: "{{ ssid }}"
|
|
name: "{{ item }}"
|
|
state: absent
|
|
api_url: "{{ netapp_api_url }}"
|
|
api_username: "{{ netapp_api_username }}"
|
|
api_password: "{{ netapp_api_password }}"
|
|
validate_certs: "{{ netapp_api_validate_certs }}"
|
|
"""
|
|
RETURN = """
|
|
msg:
|
|
description: Success message
|
|
returned: success
|
|
type: str
|
|
sample: Json facts for the pool that was created.
|
|
"""
|
|
import functools
|
|
from itertools import groupby
|
|
from time import sleep
|
|
from pprint import pformat
|
|
from ansible_collections.netapp.ontap.plugins.module_utils.netapp import NetAppESeriesModule
|
|
from ansible.module_utils._text import to_native
|
|
|
|
|
|
def get_most_common_elements(iterator):
|
|
"""Returns a generator containing a descending list of most common elements."""
|
|
if not isinstance(iterator, list):
|
|
raise TypeError("iterator must be a list.")
|
|
|
|
grouped = [(key, len(list(group))) for key, group in groupby(sorted(iterator))]
|
|
return sorted(grouped, key=lambda x: x[1], reverse=True)
|
|
|
|
|
|
def memoize(func):
|
|
"""Generic memoizer for any function with any number of arguments including zero."""
|
|
|
|
@functools.wraps(func)
|
|
def wrapper(*args, **kwargs):
|
|
class MemoizeFuncArgs(dict):
|
|
def __missing__(self, _key):
|
|
self[_key] = func(*args, **kwargs)
|
|
return self[_key]
|
|
|
|
key = str((args, kwargs)) if args and kwargs else "no_argument_response"
|
|
return MemoizeFuncArgs().__getitem__(key)
|
|
|
|
return wrapper
|
|
|
|
|
|
class NetAppESeriesStoragePool(NetAppESeriesModule):
|
|
EXPANSION_TIMEOUT_SEC = 10
|
|
DEFAULT_DISK_POOL_MINIMUM_DISK_COUNT = 11
|
|
|
|
def __init__(self):
|
|
version = "02.00.0000.0000"
|
|
ansible_options = dict(
|
|
state=dict(required=True, choices=["present", "absent"], type="str"),
|
|
name=dict(required=True, type="str"),
|
|
criteria_size_unit=dict(choices=["bytes", "b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"],
|
|
default="gb", type="str"),
|
|
criteria_drive_count=dict(type="int"),
|
|
criteria_drive_interface_type=dict(choices=["sas", "sas4k", "fibre", "fibre520b", "scsi", "sata", "pata"],
|
|
type="str"),
|
|
criteria_drive_type=dict(choices=["ssd", "hdd"], type="str", required=False),
|
|
criteria_drive_min_size=dict(type="float"),
|
|
criteria_drive_require_da=dict(type="bool", required=False),
|
|
criteria_drive_require_fde=dict(type="bool", required=False),
|
|
criteria_min_usable_capacity=dict(type="float"),
|
|
raid_level=dict(choices=["raidAll", "raid0", "raid1", "raid3", "raid5", "raid6", "raidDiskPool"],
|
|
default="raidDiskPool"),
|
|
erase_secured_drives=dict(type="bool", default=True),
|
|
secure_pool=dict(type="bool", default=False),
|
|
reserve_drive_count=dict(type="int"),
|
|
remove_volumes=dict(type="bool", default=True))
|
|
|
|
required_if = [["state", "present", ["raid_level"]]]
|
|
super(NetAppESeriesStoragePool, self).__init__(ansible_options=ansible_options,
|
|
web_services_version=version,
|
|
supports_check_mode=True,
|
|
required_if=required_if)
|
|
|
|
args = self.module.params
|
|
self.state = args["state"]
|
|
self.ssid = args["ssid"]
|
|
self.name = args["name"]
|
|
self.criteria_drive_count = args["criteria_drive_count"]
|
|
self.criteria_min_usable_capacity = args["criteria_min_usable_capacity"]
|
|
self.criteria_size_unit = args["criteria_size_unit"]
|
|
self.criteria_drive_min_size = args["criteria_drive_min_size"]
|
|
self.criteria_drive_type = args["criteria_drive_type"]
|
|
self.criteria_drive_interface_type = args["criteria_drive_interface_type"]
|
|
self.criteria_drive_require_fde = args["criteria_drive_require_fde"]
|
|
self.criteria_drive_require_da = args["criteria_drive_require_da"]
|
|
self.raid_level = args["raid_level"]
|
|
self.erase_secured_drives = args["erase_secured_drives"]
|
|
self.secure_pool = args["secure_pool"]
|
|
self.reserve_drive_count = args["reserve_drive_count"]
|
|
self.remove_volumes = args["remove_volumes"]
|
|
self.pool_detail = None
|
|
|
|
# Change all sizes to be measured in bytes
|
|
if self.criteria_min_usable_capacity:
|
|
self.criteria_min_usable_capacity = int(self.criteria_min_usable_capacity *
|
|
self.SIZE_UNIT_MAP[self.criteria_size_unit])
|
|
if self.criteria_drive_min_size:
|
|
self.criteria_drive_min_size = int(self.criteria_drive_min_size *
|
|
self.SIZE_UNIT_MAP[self.criteria_size_unit])
|
|
self.criteria_size_unit = "bytes"
|
|
|
|
# Adjust unused raid level option to reflect documentation
|
|
if self.raid_level == "raidAll":
|
|
self.raid_level = "raidDiskPool"
|
|
if self.raid_level == "raid3":
|
|
self.raid_level = "raid5"
|
|
|
|
@property
|
|
@memoize
|
|
def available_drives(self):
|
|
"""Determine the list of available drives"""
|
|
return [drive["id"] for drive in self.drives if drive["available"] and drive["status"] == "optimal"]
|
|
|
|
@property
|
|
@memoize
|
|
def available_drive_types(self):
|
|
"""Determine the types of available drives sorted by the most common first."""
|
|
types = [drive["driveMediaType"] for drive in self.drives]
|
|
return [entry[0] for entry in get_most_common_elements(types)]
|
|
|
|
@property
|
|
@memoize
|
|
def available_drive_interface_types(self):
|
|
"""Determine the types of available drives."""
|
|
interfaces = [drive["phyDriveType"] for drive in self.drives]
|
|
return [entry[0] for entry in get_most_common_elements(interfaces)]
|
|
|
|
@property
|
|
def storage_pool_drives(self, exclude_hotspares=True):
|
|
"""Retrieve list of drives found in storage pool."""
|
|
if exclude_hotspares:
|
|
return [drive for drive in self.drives
|
|
if drive["currentVolumeGroupRef"] == self.pool_detail["id"] and not drive["hotSpare"]]
|
|
|
|
return [drive for drive in self.drives if drive["currentVolumeGroupRef"] == self.pool_detail["id"]]
|
|
|
|
@property
|
|
def expandable_drive_count(self):
|
|
"""Maximum number of drives that a storage pool can be expanded at a given time."""
|
|
capabilities = None
|
|
if self.raid_level == "raidDiskPool":
|
|
return len(self.available_drives)
|
|
|
|
try:
|
|
rc, capabilities = self.request("storage-systems/%s/capabilities" % self.ssid)
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to fetch maximum expandable drive count. Array id [%s]. Error[%s]."
|
|
% (self.ssid, to_native(error)))
|
|
|
|
return capabilities["featureParameters"]["maxDCEDrives"]
|
|
|
|
@property
|
|
def disk_pool_drive_minimum(self):
|
|
"""Provide the storage array's minimum disk pool drive count."""
|
|
rc, attr = self.request("storage-systems/%s/symbol/getSystemAttributeDefaults" % self.ssid, ignore_errors=True)
|
|
|
|
# Standard minimum is 11 drives but some allow 10 drives. 10 will be the default
|
|
if (rc != 200 or "minimumDriveCount" not in attr["defaults"]["diskPoolDefaultAttributes"].keys() or
|
|
attr["defaults"]["diskPoolDefaultAttributes"]["minimumDriveCount"] == 0):
|
|
return self.DEFAULT_DISK_POOL_MINIMUM_DISK_COUNT
|
|
|
|
return attr["defaults"]["diskPoolDefaultAttributes"]["minimumDriveCount"]
|
|
|
|
def get_available_drive_capacities(self, drive_id_list=None):
|
|
"""Determine the list of available drive capacities."""
|
|
if drive_id_list:
|
|
available_drive_capacities = set([int(drive["usableCapacity"]) for drive in self.drives
|
|
if drive["id"] in drive_id_list and drive["available"] and
|
|
drive["status"] == "optimal"])
|
|
else:
|
|
available_drive_capacities = set([int(drive["usableCapacity"]) for drive in self.drives
|
|
if drive["available"] and drive["status"] == "optimal"])
|
|
|
|
self.module.log("available drive capacities: %s" % available_drive_capacities)
|
|
return list(available_drive_capacities)
|
|
|
|
@property
|
|
def drives(self):
|
|
"""Retrieve list of drives found in storage pool."""
|
|
drives = None
|
|
try:
|
|
rc, drives = self.request("storage-systems/%s/drives" % self.ssid)
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to fetch disk drives. Array id [%s]. Error[%s]."
|
|
% (self.ssid, to_native(error)))
|
|
|
|
return drives
|
|
|
|
def is_drive_count_valid(self, drive_count):
|
|
"""Validate drive count criteria is met."""
|
|
if self.criteria_drive_count and drive_count < self.criteria_drive_count:
|
|
return False
|
|
|
|
if self.raid_level == "raidDiskPool":
|
|
return drive_count >= self.disk_pool_drive_minimum
|
|
if self.raid_level == "raid0":
|
|
return drive_count > 0
|
|
if self.raid_level == "raid1":
|
|
return drive_count >= 2 and (drive_count % 2) == 0
|
|
if self.raid_level in ["raid3", "raid5"]:
|
|
return 3 <= drive_count <= 30
|
|
if self.raid_level == "raid6":
|
|
return 5 <= drive_count <= 30
|
|
return False
|
|
|
|
@property
|
|
def storage_pool(self):
|
|
"""Retrieve storage pool information."""
|
|
storage_pools_resp = None
|
|
try:
|
|
rc, storage_pools_resp = self.request("storage-systems/%s/storage-pools" % self.ssid)
|
|
except Exception as err:
|
|
self.module.fail_json(msg="Failed to get storage pools. Array id [%s]. Error[%s]. State[%s]."
|
|
% (self.ssid, to_native(err), self.state))
|
|
|
|
pool_detail = [pool for pool in storage_pools_resp if pool["name"] == self.name]
|
|
return pool_detail[0] if pool_detail else dict()
|
|
|
|
@property
|
|
def storage_pool_volumes(self):
|
|
"""Retrieve list of volumes associated with storage pool."""
|
|
volumes_resp = None
|
|
try:
|
|
rc, volumes_resp = self.request("storage-systems/%s/volumes" % self.ssid)
|
|
except Exception as err:
|
|
self.module.fail_json(msg="Failed to get storage pools. Array id [%s]. Error[%s]. State[%s]."
|
|
% (self.ssid, to_native(err), self.state))
|
|
|
|
group_ref = self.storage_pool["volumeGroupRef"]
|
|
storage_pool_volume_list = [volume["id"] for volume in volumes_resp if volume["volumeGroupRef"] == group_ref]
|
|
return storage_pool_volume_list
|
|
|
|
def get_ddp_capacity(self, expansion_drive_list):
|
|
"""Return the total usable capacity based on the additional drives."""
|
|
|
|
def get_ddp_error_percent(_drive_count, _extent_count):
|
|
"""Determine the space reserved for reconstruction"""
|
|
if _drive_count <= 36:
|
|
if _extent_count <= 600:
|
|
return 0.40
|
|
elif _extent_count <= 1400:
|
|
return 0.35
|
|
elif _extent_count <= 6200:
|
|
return 0.20
|
|
elif _extent_count <= 50000:
|
|
return 0.15
|
|
elif _drive_count <= 64:
|
|
if _extent_count <= 600:
|
|
return 0.20
|
|
elif _extent_count <= 1400:
|
|
return 0.15
|
|
elif _extent_count <= 6200:
|
|
return 0.10
|
|
elif _extent_count <= 50000:
|
|
return 0.05
|
|
elif _drive_count <= 480:
|
|
if _extent_count <= 600:
|
|
return 0.20
|
|
elif _extent_count <= 1400:
|
|
return 0.15
|
|
elif _extent_count <= 6200:
|
|
return 0.10
|
|
elif _extent_count <= 50000:
|
|
return 0.05
|
|
|
|
self.module.fail_json(msg="Drive count exceeded the error percent table. Array[%s]" % self.ssid)
|
|
|
|
def get_ddp_reserved_drive_count(_disk_count):
|
|
"""Determine the number of reserved drive."""
|
|
reserve_count = 0
|
|
|
|
if self.reserve_drive_count:
|
|
reserve_count = self.reserve_drive_count
|
|
elif _disk_count >= 256:
|
|
reserve_count = 8
|
|
elif _disk_count >= 192:
|
|
reserve_count = 7
|
|
elif _disk_count >= 128:
|
|
reserve_count = 6
|
|
elif _disk_count >= 64:
|
|
reserve_count = 4
|
|
elif _disk_count >= 32:
|
|
reserve_count = 3
|
|
elif _disk_count >= 12:
|
|
reserve_count = 2
|
|
elif _disk_count == 11:
|
|
reserve_count = 1
|
|
|
|
return reserve_count
|
|
|
|
if self.pool_detail:
|
|
drive_count = len(self.storage_pool_drives) + len(expansion_drive_list)
|
|
else:
|
|
drive_count = len(expansion_drive_list)
|
|
|
|
drive_usable_capacity = min(min(self.get_available_drive_capacities()),
|
|
min(self.get_available_drive_capacities(expansion_drive_list)))
|
|
drive_data_extents = ((drive_usable_capacity - 8053063680) / 536870912)
|
|
maximum_stripe_count = (drive_count * drive_data_extents) / 10
|
|
|
|
error_percent = get_ddp_error_percent(drive_count, drive_data_extents)
|
|
error_overhead = (drive_count * drive_data_extents / 10 * error_percent + 10) / 10
|
|
|
|
total_stripe_count = maximum_stripe_count - error_overhead
|
|
stripe_count_per_drive = total_stripe_count / drive_count
|
|
reserved_stripe_count = get_ddp_reserved_drive_count(drive_count) * stripe_count_per_drive
|
|
available_stripe_count = total_stripe_count - reserved_stripe_count
|
|
|
|
return available_stripe_count * 4294967296
|
|
|
|
@memoize
|
|
def get_candidate_drives(self):
|
|
"""Retrieve set of drives candidates for creating a new storage pool."""
|
|
|
|
def get_candidate_drive_request():
|
|
"""Perform request for new volume creation."""
|
|
candidates_list = list()
|
|
drive_types = [self.criteria_drive_type] if self.criteria_drive_type else self.available_drive_types
|
|
interface_types = [self.criteria_drive_interface_type] \
|
|
if self.criteria_drive_interface_type else self.available_drive_interface_types
|
|
|
|
for interface_type in interface_types:
|
|
for drive_type in drive_types:
|
|
candidates = None
|
|
volume_candidate_request_data = dict(
|
|
type="diskPool" if self.raid_level == "raidDiskPool" else "traditional",
|
|
diskPoolVolumeCandidateRequestData=dict(
|
|
reconstructionReservedDriveCount=65535))
|
|
candidate_selection_type = dict(
|
|
candidateSelectionType="count",
|
|
driveRefList=dict(driveRef=self.available_drives))
|
|
criteria = dict(raidLevel=self.raid_level,
|
|
phyDriveType=interface_type,
|
|
dssPreallocEnabled=False,
|
|
securityType="capable" if self.criteria_drive_require_fde else "none",
|
|
driveMediaType=drive_type,
|
|
onlyProtectionInformationCapable=True if self.criteria_drive_require_da else False,
|
|
volumeCandidateRequestData=volume_candidate_request_data,
|
|
allocateReserveSpace=False,
|
|
securityLevel="fde" if self.criteria_drive_require_fde else "none",
|
|
candidateSelectionType=candidate_selection_type)
|
|
|
|
try:
|
|
rc, candidates = self.request("storage-systems/%s/symbol/getVolumeCandidates?verboseError"
|
|
"Response=true" % self.ssid, data=criteria, method="POST")
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to retrieve volume candidates. Array [%s]. Error [%s]."
|
|
% (self.ssid, to_native(error)))
|
|
|
|
if candidates:
|
|
candidates_list.extend(candidates["volumeCandidate"])
|
|
|
|
# Sort output based on tray and then drawer protection first
|
|
tray_drawer_protection = list()
|
|
tray_protection = list()
|
|
drawer_protection = list()
|
|
no_protection = list()
|
|
sorted_candidates = list()
|
|
for item in candidates_list:
|
|
if item["trayLossProtection"]:
|
|
if item["drawerLossProtection"]:
|
|
tray_drawer_protection.append(item)
|
|
else:
|
|
tray_protection.append(item)
|
|
elif item["drawerLossProtection"]:
|
|
drawer_protection.append(item)
|
|
else:
|
|
no_protection.append(item)
|
|
|
|
if tray_drawer_protection:
|
|
sorted_candidates.extend(tray_drawer_protection)
|
|
if tray_protection:
|
|
sorted_candidates.extend(tray_protection)
|
|
if drawer_protection:
|
|
sorted_candidates.extend(drawer_protection)
|
|
if no_protection:
|
|
sorted_candidates.extend(no_protection)
|
|
|
|
return sorted_candidates
|
|
|
|
# Determine the appropriate candidate list
|
|
for candidate in get_candidate_drive_request():
|
|
|
|
# Evaluate candidates for required drive count, collective drive usable capacity and minimum drive size
|
|
if self.criteria_drive_count:
|
|
if self.criteria_drive_count != int(candidate["driveCount"]):
|
|
continue
|
|
if self.criteria_min_usable_capacity:
|
|
if ((self.raid_level == "raidDiskPool" and self.criteria_min_usable_capacity >
|
|
self.get_ddp_capacity(candidate["driveRefList"]["driveRef"])) or
|
|
self.criteria_min_usable_capacity > int(candidate["usableSize"])):
|
|
continue
|
|
if self.criteria_drive_min_size:
|
|
if self.criteria_drive_min_size > min(self.get_available_drive_capacities(candidate["driveRefList"]["driveRef"])):
|
|
continue
|
|
|
|
return candidate
|
|
|
|
self.module.fail_json(msg="Not enough drives to meet the specified criteria. Array [%s]." % self.ssid)
|
|
|
|
@memoize
|
|
def get_expansion_candidate_drives(self):
|
|
"""Retrieve required expansion drive list.
|
|
|
|
Note: To satisfy the expansion criteria each item in the candidate list must added specified group since there
|
|
is a potential limitation on how many drives can be incorporated at a time.
|
|
* Traditional raid volume groups must be added two drives maximum at a time. No limits on raid disk pools.
|
|
|
|
:return list(candidate): list of candidate structures from the getVolumeGroupExpansionCandidates symbol endpoint
|
|
"""
|
|
|
|
def get_expansion_candidate_drive_request():
|
|
"""Perform the request for expanding existing volume groups or disk pools.
|
|
|
|
Note: the list of candidate structures do not necessarily produce candidates that meet all criteria.
|
|
"""
|
|
candidates_list = None
|
|
url = "storage-systems/%s/symbol/getVolumeGroupExpansionCandidates?verboseErrorResponse=true" % self.ssid
|
|
if self.raid_level == "raidDiskPool":
|
|
url = "storage-systems/%s/symbol/getDiskPoolExpansionCandidates?verboseErrorResponse=true" % self.ssid
|
|
|
|
try:
|
|
rc, candidates_list = self.request(url, method="POST", data=self.pool_detail["id"])
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to retrieve volume candidates. Array [%s]. Error [%s]."
|
|
% (self.ssid, to_native(error)))
|
|
|
|
return candidates_list["candidates"]
|
|
|
|
required_candidate_list = list()
|
|
required_additional_drives = 0
|
|
required_additional_capacity = 0
|
|
total_required_capacity = 0
|
|
|
|
# determine whether and how much expansion is need to satisfy the specified criteria
|
|
if self.criteria_min_usable_capacity:
|
|
total_required_capacity = self.criteria_min_usable_capacity
|
|
required_additional_capacity = self.criteria_min_usable_capacity - int(self.pool_detail["totalRaidedSpace"])
|
|
|
|
if self.criteria_drive_count:
|
|
required_additional_drives = self.criteria_drive_count - len(self.storage_pool_drives)
|
|
|
|
# Determine the appropriate expansion candidate list
|
|
if required_additional_drives > 0 or required_additional_capacity > 0:
|
|
for candidate in get_expansion_candidate_drive_request():
|
|
|
|
if self.criteria_drive_min_size:
|
|
if self.criteria_drive_min_size > min(self.get_available_drive_capacities(candidate["drives"])):
|
|
continue
|
|
|
|
if self.raid_level == "raidDiskPool":
|
|
if (len(candidate["drives"]) >= required_additional_drives and
|
|
self.get_ddp_capacity(candidate["drives"]) >= total_required_capacity):
|
|
required_candidate_list.append(candidate)
|
|
break
|
|
else:
|
|
required_additional_drives -= len(candidate["drives"])
|
|
required_additional_capacity -= int(candidate["usableCapacity"])
|
|
required_candidate_list.append(candidate)
|
|
|
|
# Determine if required drives and capacities are satisfied
|
|
if required_additional_drives <= 0 and required_additional_capacity <= 0:
|
|
break
|
|
else:
|
|
self.module.fail_json(msg="Not enough drives to meet the specified criteria. Array [%s]." % self.ssid)
|
|
|
|
return required_candidate_list
|
|
|
|
def get_reserve_drive_count(self):
|
|
"""Retrieve the current number of reserve drives for raidDiskPool (Only for raidDiskPool)."""
|
|
|
|
if not self.pool_detail:
|
|
self.module.fail_json(msg="The storage pool must exist. Array [%s]." % self.ssid)
|
|
|
|
if self.raid_level != "raidDiskPool":
|
|
self.module.fail_json(msg="The storage pool must be a raidDiskPool. Pool [%s]. Array [%s]."
|
|
% (self.pool_detail["id"], self.ssid))
|
|
|
|
return self.pool_detail["volumeGroupData"]["diskPoolData"]["reconstructionReservedDriveCount"]
|
|
|
|
def get_maximum_reserve_drive_count(self):
|
|
"""Retrieve the maximum number of reserve drives for storage pool (Only for raidDiskPool)."""
|
|
if self.raid_level != "raidDiskPool":
|
|
self.module.fail_json(msg="The storage pool must be a raidDiskPool. Pool [%s]. Array [%s]."
|
|
% (self.pool_detail["id"], self.ssid))
|
|
|
|
drives_ids = list()
|
|
|
|
if self.pool_detail:
|
|
drives_ids.extend(self.storage_pool_drives)
|
|
for candidate in self.get_expansion_candidate_drives():
|
|
drives_ids.extend((candidate["drives"]))
|
|
else:
|
|
candidate = self.get_candidate_drives()
|
|
drives_ids.extend(candidate["driveRefList"]["driveRef"])
|
|
|
|
drive_count = len(drives_ids)
|
|
maximum_reserve_drive_count = min(int(drive_count * 0.2 + 1), drive_count - 10)
|
|
if maximum_reserve_drive_count > 10:
|
|
maximum_reserve_drive_count = 10
|
|
|
|
return maximum_reserve_drive_count
|
|
|
|
def set_reserve_drive_count(self, check_mode=False):
|
|
"""Set the reserve drive count for raidDiskPool."""
|
|
changed = False
|
|
|
|
if self.raid_level == "raidDiskPool" and self.reserve_drive_count:
|
|
maximum_count = self.get_maximum_reserve_drive_count()
|
|
|
|
if self.reserve_drive_count < 0 or self.reserve_drive_count > maximum_count:
|
|
self.module.fail_json(msg="Supplied reserve drive count is invalid or exceeds the maximum allowed. "
|
|
"Note that it may be necessary to wait for expansion operations to complete "
|
|
"before the adjusting the reserve drive count. Maximum [%s]. Array [%s]."
|
|
% (maximum_count, self.ssid))
|
|
|
|
if self.reserve_drive_count != self.get_reserve_drive_count():
|
|
changed = True
|
|
|
|
if not check_mode:
|
|
try:
|
|
rc, resp = self.request("storage-systems/%s/symbol/setDiskPoolReservedDriveCount" % self.ssid,
|
|
method="POST", data=dict(volumeGroupRef=self.pool_detail["id"],
|
|
newDriveCount=self.reserve_drive_count))
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to set reserve drive count for disk pool. Disk Pool [%s]."
|
|
" Array [%s]." % (self.pool_detail["id"], self.ssid))
|
|
|
|
return changed
|
|
|
|
def erase_all_available_secured_drives(self, check_mode=False):
|
|
"""Erase all available drives that have encryption at rest feature enabled."""
|
|
changed = False
|
|
drives_list = list()
|
|
for drive in self.drives:
|
|
if drive["available"] and drive["fdeEnabled"]:
|
|
changed = True
|
|
drives_list.append(drive["id"])
|
|
|
|
if drives_list and not check_mode:
|
|
try:
|
|
rc, resp = self.request("storage-systems/%s/symbol/reprovisionDrive?verboseErrorResponse=true"
|
|
% self.ssid, method="POST", data=dict(driveRef=drives_list))
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to erase all secured drives. Array [%s]" % self.ssid)
|
|
|
|
return changed
|
|
|
|
def create_storage_pool(self):
|
|
"""Create new storage pool."""
|
|
url = "storage-systems/%s/symbol/createVolumeGroup?verboseErrorResponse=true" % self.ssid
|
|
request_body = dict(label=self.name,
|
|
candidate=self.get_candidate_drives())
|
|
|
|
if self.raid_level == "raidDiskPool":
|
|
url = "storage-systems/%s/symbol/createDiskPool?verboseErrorResponse=true" % self.ssid
|
|
|
|
request_body.update(
|
|
dict(backgroundOperationPriority="useDefault",
|
|
criticalReconstructPriority="useDefault",
|
|
degradedReconstructPriority="useDefault",
|
|
poolUtilizationCriticalThreshold=65535,
|
|
poolUtilizationWarningThreshold=0))
|
|
|
|
if self.reserve_drive_count:
|
|
request_body.update(dict(volumeCandidateData=dict(
|
|
diskPoolVolumeCandidateData=dict(reconstructionReservedDriveCount=self.reserve_drive_count))))
|
|
|
|
try:
|
|
rc, resp = self.request(url, method="POST", data=request_body)
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to create storage pool. Array id [%s]. Error[%s]."
|
|
% (self.ssid, to_native(error)))
|
|
|
|
# Update drive and storage pool information
|
|
self.pool_detail = self.storage_pool
|
|
|
|
def delete_storage_pool(self):
|
|
"""Delete storage pool."""
|
|
storage_pool_drives = [drive["id"] for drive in self.storage_pool_drives if drive["fdeEnabled"]]
|
|
try:
|
|
delete_volumes_parameter = "?delete-volumes=true" if self.remove_volumes else ""
|
|
rc, resp = self.request("storage-systems/%s/storage-pools/%s%s"
|
|
% (self.ssid, self.pool_detail["id"], delete_volumes_parameter), method="DELETE")
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to delete storage pool. Pool id [%s]. Array id [%s]. Error[%s]."
|
|
% (self.pool_detail["id"], self.ssid, to_native(error)))
|
|
|
|
if storage_pool_drives and self.erase_secured_drives:
|
|
try:
|
|
rc, resp = self.request("storage-systems/%s/symbol/reprovisionDrive?verboseErrorResponse=true"
|
|
% self.ssid, method="POST", data=dict(driveRef=storage_pool_drives))
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to erase drives prior to creating new storage pool. Array [%s]."
|
|
" Error [%s]." % (self.ssid, to_native(error)))
|
|
|
|
def secure_storage_pool(self, check_mode=False):
|
|
"""Enable security on an existing storage pool"""
|
|
self.pool_detail = self.storage_pool
|
|
needs_secure_pool = False
|
|
|
|
if not self.secure_pool and self.pool_detail["securityType"] == "enabled":
|
|
self.module.fail_json(msg="It is not possible to disable storage pool security! See array documentation.")
|
|
if self.secure_pool and self.pool_detail["securityType"] != "enabled":
|
|
needs_secure_pool = True
|
|
|
|
if needs_secure_pool and not check_mode:
|
|
try:
|
|
rc, resp = self.request("storage-systems/%s/storage-pools/%s" % (self.ssid, self.pool_detail["id"]),
|
|
data=dict(securePool=True), method="POST")
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to secure storage pool. Pool id [%s]. Array [%s]. Error"
|
|
" [%s]." % (self.pool_detail["id"], self.ssid, to_native(error)))
|
|
|
|
self.pool_detail = self.storage_pool
|
|
return needs_secure_pool
|
|
|
|
def migrate_raid_level(self, check_mode=False):
|
|
"""Request storage pool raid level migration."""
|
|
needs_migration = self.raid_level != self.pool_detail["raidLevel"]
|
|
if needs_migration and self.pool_detail["raidLevel"] == "raidDiskPool":
|
|
self.module.fail_json(msg="Raid level cannot be changed for disk pools")
|
|
|
|
if needs_migration and not check_mode:
|
|
sp_raid_migrate_req = dict(raidLevel=self.raid_level)
|
|
|
|
try:
|
|
rc, resp = self.request("storage-systems/%s/storage-pools/%s/raid-type-migration"
|
|
% (self.ssid, self.name), data=sp_raid_migrate_req, method="POST")
|
|
except Exception as error:
|
|
self.module.fail_json(msg="Failed to change the raid level of storage pool. Array id [%s]."
|
|
" Error[%s]." % (self.ssid, to_native(error)))
|
|
|
|
self.pool_detail = self.storage_pool
|
|
return needs_migration
|
|
|
|
def expand_storage_pool(self, check_mode=False):
|
|
"""Add drives to existing storage pool.
|
|
|
|
:return bool: whether drives were required to be added to satisfy the specified criteria."""
|
|
expansion_candidate_list = self.get_expansion_candidate_drives()
|
|
changed_required = bool(expansion_candidate_list)
|
|
estimated_completion_time = 0.0
|
|
|
|
# build expandable groupings of traditional raid candidate
|
|
required_expansion_candidate_list = list()
|
|
while expansion_candidate_list:
|
|
subset = list()
|
|
while expansion_candidate_list and len(subset) < self.expandable_drive_count:
|
|
subset.extend(expansion_candidate_list.pop()["drives"])
|
|
required_expansion_candidate_list.append(subset)
|
|
|
|
if required_expansion_candidate_list and not check_mode:
|
|
url = "storage-systems/%s/symbol/startVolumeGroupExpansion?verboseErrorResponse=true" % self.ssid
|
|
if self.raid_level == "raidDiskPool":
|
|
url = "storage-systems/%s/symbol/startDiskPoolExpansion?verboseErrorResponse=true" % self.ssid
|
|
|
|
while required_expansion_candidate_list:
|
|
candidate_drives_list = required_expansion_candidate_list.pop()
|
|
request_body = dict(volumeGroupRef=self.pool_detail["volumeGroupRef"],
|
|
driveRef=candidate_drives_list)
|
|
try:
|
|
rc, resp = self.request(url, method="POST", data=request_body)
|
|
except Exception as error:
|
|
rc, actions_resp = self.request("storage-systems/%s/storage-pools/%s/action-progress"
|
|
% (self.ssid, self.pool_detail["id"]), ignore_errors=True)
|
|
if rc == 200 and actions_resp:
|
|
actions = [action["currentAction"] for action in actions_resp
|
|
if action["volumeRef"] in self.storage_pool_volumes]
|
|
self.module.fail_json(msg="Failed to add drives to the storage pool possibly because of actions"
|
|
" in progress. Actions [%s]. Pool id [%s]. Array id [%s]. Error[%s]."
|
|
% (", ".join(actions), self.pool_detail["id"], self.ssid,
|
|
to_native(error)))
|
|
|
|
self.module.fail_json(msg="Failed to add drives to storage pool. Pool id [%s]. Array id [%s]."
|
|
" Error[%s]." % (self.pool_detail["id"], self.ssid, to_native(error)))
|
|
|
|
# Wait for expansion completion unless it is the last request in the candidate list
|
|
if required_expansion_candidate_list:
|
|
for dummy in range(self.EXPANSION_TIMEOUT_SEC):
|
|
rc, actions_resp = self.request("storage-systems/%s/storage-pools/%s/action-progress"
|
|
% (self.ssid, self.pool_detail["id"]), ignore_errors=True)
|
|
if rc == 200:
|
|
for action in actions_resp:
|
|
if (action["volumeRef"] in self.storage_pool_volumes and
|
|
action["currentAction"] == "remappingDce"):
|
|
sleep(1)
|
|
estimated_completion_time = action["estimatedTimeToCompletion"]
|
|
break
|
|
else:
|
|
estimated_completion_time = 0.0
|
|
break
|
|
|
|
return changed_required, estimated_completion_time
|
|
|
|
def apply(self):
|
|
"""Apply requested state to storage array."""
|
|
changed = False
|
|
|
|
if self.state == "present":
|
|
if self.criteria_drive_count is None and self.criteria_min_usable_capacity is None:
|
|
self.module.fail_json(msg="One of criteria_min_usable_capacity or criteria_drive_count must be"
|
|
" specified.")
|
|
if self.criteria_drive_count and not self.is_drive_count_valid(self.criteria_drive_count):
|
|
self.module.fail_json(msg="criteria_drive_count must be valid for the specified raid level.")
|
|
|
|
self.pool_detail = self.storage_pool
|
|
self.module.log(pformat(self.pool_detail))
|
|
|
|
if self.state == "present" and self.erase_secured_drives:
|
|
self.erase_all_available_secured_drives(check_mode=True)
|
|
|
|
# Determine whether changes need to be applied to the storage array
|
|
if self.pool_detail:
|
|
|
|
if self.state == "absent":
|
|
changed = True
|
|
|
|
elif self.state == "present":
|
|
|
|
if self.criteria_drive_count and self.criteria_drive_count < len(self.storage_pool_drives):
|
|
self.module.fail_json(msg="Failed to reduce the size of the storage pool. Array [%s]. Pool [%s]."
|
|
% (self.ssid, self.pool_detail["id"]))
|
|
|
|
if self.criteria_drive_type and self.criteria_drive_type != self.pool_detail["driveMediaType"]:
|
|
self.module.fail_json(msg="Failed! It is not possible to modify storage pool media type."
|
|
" Array [%s]. Pool [%s]." % (self.ssid, self.pool_detail["id"]))
|
|
|
|
if (self.criteria_drive_require_da is not None and self.criteria_drive_require_da !=
|
|
self.pool_detail["protectionInformationCapabilities"]["protectionInformationCapable"]):
|
|
self.module.fail_json(msg="Failed! It is not possible to modify DA-capability. Array [%s]."
|
|
" Pool [%s]." % (self.ssid, self.pool_detail["id"]))
|
|
|
|
# Evaluate current storage pool for required change.
|
|
needs_expansion, estimated_completion_time = self.expand_storage_pool(check_mode=True)
|
|
if needs_expansion:
|
|
changed = True
|
|
if self.migrate_raid_level(check_mode=True):
|
|
changed = True
|
|
if self.secure_storage_pool(check_mode=True):
|
|
changed = True
|
|
if self.set_reserve_drive_count(check_mode=True):
|
|
changed = True
|
|
|
|
elif self.state == "present":
|
|
changed = True
|
|
|
|
# Apply changes to storage array
|
|
msg = "No changes were required for the storage pool [%s]."
|
|
if changed and not self.module.check_mode:
|
|
if self.state == "present":
|
|
if self.erase_secured_drives:
|
|
self.erase_all_available_secured_drives()
|
|
|
|
if self.pool_detail:
|
|
change_list = list()
|
|
|
|
# Expansion needs to occur before raid level migration to account for any sizing needs.
|
|
expanded, estimated_completion_time = self.expand_storage_pool()
|
|
if expanded:
|
|
change_list.append("expanded")
|
|
if self.migrate_raid_level():
|
|
change_list.append("raid migration")
|
|
if self.secure_storage_pool():
|
|
change_list.append("secured")
|
|
if self.set_reserve_drive_count():
|
|
change_list.append("adjusted reserve drive count")
|
|
|
|
if change_list:
|
|
msg = "Following changes have been applied to the storage pool [%s]: " + ", ".join(change_list)
|
|
|
|
if expanded:
|
|
msg += "\nThe expansion operation will complete in an estimated %s minutes."\
|
|
% estimated_completion_time
|
|
else:
|
|
self.create_storage_pool()
|
|
msg = "Storage pool [%s] was created."
|
|
|
|
if self.secure_storage_pool():
|
|
msg = "Storage pool [%s] was created and secured."
|
|
if self.set_reserve_drive_count():
|
|
msg += " Adjusted reserve drive count."
|
|
|
|
elif self.pool_detail:
|
|
self.delete_storage_pool()
|
|
msg = "Storage pool [%s] removed."
|
|
|
|
self.pool_detail = self.storage_pool
|
|
self.module.log(pformat(self.pool_detail))
|
|
self.module.log(msg % self.name)
|
|
self.module.exit_json(msg=msg % self.name, changed=changed, **self.pool_detail)
|
|
|
|
|
|
def main():
|
|
storage_pool = NetAppESeriesStoragePool()
|
|
storage_pool.apply()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|