# Copyright: (c) 2020, Dell Technologies
# Apache License version 2.0 (see MODULE-LICENSE or http://www.apache.org/licenses/LICENSE-2.0.txt)
"""Ansible module for managing storage pool on Unity"""
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = r'''
module: storagepool
version_added: '1.1.0'
short_description: Manage storage pool on Unity
description:
- Managing storage pool on Unity storage system contains the operations
Get details of storage pool,
Create a storage pool,
Modify storage pool.
extends_documentation_fragment:
- dellemc.unity.unity
author:
- Ambuj Dubey (@AmbujDube) <ansible.team@dell.com>
options:
pool_name:
description:
- Name of the storage pool, unique in the storage system.
type: str
pool_id:
description:
- Unique identifier of the pool instance.
type: str
new_pool_name:
description:
- New name of the storage pool, unique in the storage system.
type: str
pool_description:
description:
- The description of the storage pool.
type: str
fast_cache:
description:
- Indicates whether the fast cache is enabled for the storage pool.
- C(Enabled) - FAST Cache is enabled for the pool.
- C(Disabled) - FAST Cache is disabled for the pool.
choices: [enabled, disabled]
type: str
fast_vp:
description:
- Indicates whether to enable scheduled data relocations for the pool.
- C(Enabled) - Enabled scheduled data relocations for the pool.
- C(Disabled) - Disabled scheduled data relocations for the pool.
choices: [enabled, disabled]
type: str
raid_groups:
description:
- Parameters to create RAID group from the disks and add it to the pool.
type: dict
suboptions:
disk_group_id:
description:
- Id of the disk group.
type: str
disk_num:
description:
- Number of disks.
type: int
raid_type:
description:
- RAID group types or RAID levels.
choices: [None, RAID5, RAID0, RAID1, RAID3, RAID10, RAID6, Mixed, Automatic]
type: str
stripe_width :
description:
- RAID group stripe widths, including parity or mirror disks.
choices: ['BEST_FIT', '2', '4', '5', '6', '8', '9', '10', '12', '13', '14', '16']
type: str
alert_threshold:
description:
- Threshold at which the system will generate alerts about the free space in the pool, specified as a percentage.
- Minimum threshold limit is 50.
- Maximum threshold limit is 84.
type: int
is_harvest_enabled:
description:
- Enable/Disable automatic deletion of snapshots based on pool space usage.
type: bool
pool_harvest_high_threshold:
description:
- Max threshold for space used in pool beyond which the system automatically starts deleting snapshots in the pool.
- Applies when the automatic deletion of snapshots based on pool space usage is enabled for the system and pool.
- Minimum pool harvest high threshold value is 1.
- Maximum pool harvest high threshold value is 99.
type: float
pool_harvest_low_threshold:
description:
- Min threshold for space used in pool below which the system automatically stops deletion of snapshots in the pool.
- Applies when the automatic deletion of snapshots based on pool space usage is enabled for the system and pool.
- Minimum pool harvest low threshold value is 0.
- Maximum pool harvest low threshold value is 98.
type: float
is_snap_harvest_enabled:
description:
- Enable/Disable automatic deletion of snapshots based on pool space usage.
type: bool
snap_harvest_high_threshold:
description:
- Max threshold for space used in snapshot beyond which the system automatically starts deleting snapshots in the pool.
- Applies when the automatic deletion of snapshots based on pool space usage is enabled for the pool.
- Minimum snap harvest high threshold value is 1.
- Maximum snap harvest high threshold value is 99.
type: float
snap_harvest_low_threshold:
description:
- Min threshold for space used in snapshot below which the system will stop automatically deleting snapshots in the pool.
- Applies when the automatic deletion of snapshots based on pool space usage is enabled for the pool.
- Minimum snap harvest low threshold value is 0.
- Maximum snap harvest low threshold value is 98.
type: float
pool_type:
description:
- Indicates storage pool type.
choices: [TRADITIONAL, DYNAMIC]
type: str
state:
description:
- Define whether the storage pool should exist or not.
- C(Present) - indicates that the storage pool should exist on the system.
- C(Absent) - indicates that the storage pool should not exist on the system.
choices: [absent, present]
type: str
required: true
notes:
- Deletion of storage pool is not allowed through Ansible module.
- The I(check_mode) is not supported.
'''
EXAMPLES = r'''
- name: Get Storage pool details using pool_name
dellemc.unity.storagepool:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
pool_name: "{{pool_name}}"
state: "present"
- name: Get Storage pool details using pool_id
dellemc.unity.storagepool:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
pool_id: "{{pool_id}}"
state: "present"
- name: Modify Storage pool attributes using pool_name
dellemc.unity.storagepool:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
pool_name: "{{pool_name}}"
new_pool_name: "{{new_pool_name}}"
pool_description: "{{pool_description}}"
fast_cache: "{{fast_cache_enabled}}"
fast_vp: "{{fast_vp_enabled}}"
state: "present"
- name: Modify Storage pool attributes using pool_id
dellemc.unity.storagepool:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
pool_id: "{{pool_id}}"
new_pool_name: "{{new_pool_name}}"
pool_description: "{{pool_description}}"
fast_cache: "{{fast_cache_enabled}}"
fast_vp: "{{fast_vp_enabled}}"
state: "present"
- name: Create a StoragePool
dellemc.unity.storagepool:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
pool_name: "Test"
pool_description: "test pool"
raid_groups:
disk_group_id : "dg_16"
disk_num : 2
raid_type : "RAID10"
stripe_width : "BEST_FIT"
alert_threshold : 50
is_harvest_enabled : True
pool_harvest_high_threshold : 60
pool_harvest_low_threshold : 40
is_snap_harvest_enabled : True
snap_harvest_high_threshold : 70
snap_harvest_low_threshold : 50
fast_vp: "enabled"
fast_cache: "enabled"
pool_type : "DYNAMIC"
state: "present"
'''
RETURN = r'''
changed:
description: Whether or not the storage pool has changed.
returned: always
type: bool
sample: True
storage_pool_details:
description: The storage pool details.
returned: When storage pool exists.
type: dict
contains:
id:
description: Pool id, unique identifier of the pool.
type: str
name:
description: Pool name, unique in the storage system.
type: str
is_fast_cache_enabled:
description: Indicates whether the fast cache is enabled for the storage
pool.
true - FAST Cache is enabled for the pool.
false - FAST Cache is disabled for the pool.
type: bool
is_fast_vp_enabled:
description: Indicates whether to enable scheduled data relocations
for the storage pool.
true - Enabled scheduled data relocations for the pool.
false - Disabled scheduled data relocations for the pool.
type: bool
size_free_with_unit:
description: Indicates size_free with its appropriate unit
in human readable form.
type: str
size_subscribed_with_unit:
description: Indicates size_subscribed with its appropriate unit in
human readable form.
type: str
size_total_with_unit:
description: Indicates size_total with its appropriate unit in human
readable form.
type: str
size_used_with_unit:
description: Indicates size_used with its appropriate unit in human
readable form.
type: str
snap_size_subscribed_with_unit:
description: Indicates snap_size_subscribed with its
appropriate unit in human readable form.
type: str
snap_size_used_with_unit:
description: Indicates snap_size_used with its
appropriate unit in human readable form.
type: str
drives:
description: Indicates information about the drives
associated with the storage pool.
type: list
contains:
id:
description: Unique identifier of the drive.
type: str
name:
description: Indicates name of the drive.
type: str
size:
description: Indicates size of the drive.
type: str
disk_technology:
description: Indicates disk technology of the drive.
type: str
tier_type:
description: Indicates tier type of the drive.
type: str
sample: {
"alert_threshold": 50,
"creation_time": "2022-03-08 14:05:32+00:00",
"description": "",
"drives": [
{
"disk_technology": "SAS",
"id": "dpe_disk_22",
"name": "DPE Drive 22",
"size": 590860984320,
"tier_type": "PERFORMANCE"
},
{
"disk_technology": "SAS",
"id": "dpe_disk_23",
"name": "DPE Drive 23",
"size": 590860984320,
"tier_type": "PERFORMANCE"
},
{
"disk_technology": "SAS",
"id": "dpe_disk_24",
"name": "DPE Drive 24",
"size": 590860984320,
"tier_type": "PERFORMANCE"
}
],
"existed": true,
"harvest_state": "UsageHarvestStateEnum.IDLE",
"hash": 8744642897210,
"health": {
"UnityHealth": {
"hash": 8744642799842
}
},
"id": "pool_280",
"is_all_flash": false,
"is_empty": false,
"is_fast_cache_enabled": false,
"is_fast_vp_enabled": false,
"is_harvest_enabled": true,
"is_snap_harvest_enabled": true,
"metadata_size_subscribed": 105763569664,
"metadata_size_used": 57176752128,
"name": "test_pool",
"object_id": 12884902146,
"pool_fast_vp": {
"UnityPoolFastVp": {
"hash": 8744647518980
}
},
"pool_space_harvest_high_threshold": 59.0,
"pool_space_harvest_low_threshold": 40.0,
"pool_type": "StoragePoolTypeEnum.DYNAMIC",
"raid_type": "RaidTypeEnum.RAID10",
"rebalance_progress": null,
"size_free": 470030483456,
"size_free_with_unit": "437.75 GB",
"size_subscribed": 447215820800,
"size_subscribed_with_unit": "416.5 GB",
"size_total": 574720311296,
"size_total_with_unit": "535.25 GB",
"size_used": 76838068224,
"size_used_with_unit": "71.56 GB",
"snap_size_subscribed": 128851369984,
"snap_size_subscribed_with_unit": "120.0 GB",
"snap_size_used": 2351104,
"snap_size_used_with_unit": "2.24 MB",
"snap_space_harvest_high_threshold": 80.0,
"snap_space_harvest_low_threshold": 60.0,
"tiers": {
"UnityPoolTierList": [
{
"disk_count": [
0,
3,
0
],
"existed": true,
"hash": 8744643017382,
"name": [
"Extreme Performance",
"Performance",
"Capacity"
],
"pool_units": [
null,
{
"UnityPoolUnitList": [
{
"UnityPoolUnit": {
"hash": 8744642786759,
"id": "rg_4"
}
},
{
"UnityPoolUnit": {
"hash": 8744642786795,
"id": "rg_5"
}
}
]
},
null
],
"raid_type": [
"RaidTypeEnum.NONE",
"RaidTypeEnum.RAID10",
"RaidTypeEnum.NONE"
],
"size_free": [
0,
470030483456,
0
],
"size_moving_down": [
0,
0,
0
],
"size_moving_up": [
0,
0,
0
],
"size_moving_within": [
0,
0,
0
],
"size_total": [
0,
574720311296,
0
],
"size_used": [
0,
104689827840,
0
],
"stripe_width": [
null,
"RaidStripeWidthEnum._2",
null
],
"tier_type": [
"TierTypeEnum.EXTREME_PERFORMANCE",
"TierTypeEnum.PERFORMANCE",
"TierTypeEnum.CAPACITY"
]
}
]
}
}
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.unity.plugins.module_utils.storage.dell \
import utils
import logging
LOG = utils.get_logger('storagepool')
application_type = "Ansible/1.6.0"
class StoragePool(object):
"""Class with storage pool operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_unity_management_host_parameters()
self.module_params.update(get_storagepool_parameters())
mutually_exclusive = [['pool_name', 'pool_id']]
required_one_of = [['pool_name', 'pool_id']]
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False,
mutually_exclusive=mutually_exclusive,
required_one_of=required_one_of)
utils.ensure_required_libs(self.module)
self.conn = utils.\
get_unity_unisphere_connection(self.module.params, application_type)
def get_details(self, pool_id=None, pool_name=None):
""" Get storage pool details"""
try:
api_response = self.conn.get_pool(_id=pool_id, name=pool_name)
details = api_response._get_properties()
is_fast_vp_enabled = api_response._get_property_from_raw(
'pool_fast_vp').is_schedule_enabled
details['is_fast_vp_enabled'] = is_fast_vp_enabled
details['size_free_with_unit'] = utils.\
convert_size_with_unit(int(details['size_free']))
details['size_subscribed_with_unit'] = utils.\
convert_size_with_unit(int(details['size_subscribed']))
details['size_total_with_unit'] = utils.\
convert_size_with_unit(int(details['size_total']))
details['size_used_with_unit'] = utils.\
convert_size_with_unit(int(details['size_used']))
details['snap_size_subscribed_with_unit'] = utils.\
convert_size_with_unit(int(details['snap_size_subscribed']))
details['snap_size_used_with_unit'] = utils.\
convert_size_with_unit(int(details['snap_size_used']))
pool_instance = utils.UnityPool.get(self.conn._cli, details['id'])
pool_tier_list = []
pool_tier_list.append((pool_instance.tiers)._get_properties())
pool_tier_dict = {}
pool_tier_dict['UnityPoolTierList'] = pool_tier_list
details['tiers'] = pool_tier_dict
return details
except Exception as e:
error = str(e)
check_list = ['not found', 'no attribute']
if any(ele in error for ele in check_list):
error_message = "pool details are not found"
LOG.info(error_message)
return None
error_message = 'Get details of storage pool failed with ' \
'error: {0}'.format(str(e))
LOG.error(error_message)
self.module.fail_json(msg=error_message)
def is_pool_modification_required(self, storage_pool_details):
""" Check if attributes of storage pool needs to be modified
"""
try:
if self.module.params['new_pool_name'] and \
self.module.params['new_pool_name'] != \
storage_pool_details['name']:
return True
if self.module.params['pool_description'] is not None and \
self.module.params['pool_description'] != \
storage_pool_details['description']:
return True
if self.module.params['fast_cache']:
if (self.module.params['fast_cache'] == "enabled" and
not storage_pool_details['is_fast_cache_enabled']) or\
(self.module.params['fast_cache'] == "disabled" and storage_pool_details['is_fast_cache_enabled']):
return True
if self.module.params['fast_vp']:
if (self.module.params['fast_vp'] == "enabled" and
not storage_pool_details['is_fast_vp_enabled']) or \
(self.module.params['fast_vp'] == "disabled" and
storage_pool_details['is_fast_vp_enabled']):
return True
LOG.info("modify not required")
return False
except Exception as e:
error_message = 'Failed to determine if any modification'\
'required for pool attributes with error: {0}'.format(str(e))
LOG.error(error_message)
self.module.fail_json(msg=error_message)
def pool_modify(self, id, new_pool_name,
pool_description, fast_cache, fast_vp):
""" Modify attributes of storage pool """
pool_obj = utils.UnityPool.get(self.conn._cli, id)
try:
pool_obj.modify(name=new_pool_name, description=pool_description,
is_fast_cache_enabled=fast_cache,
is_fastvp_enabled=fast_vp)
new_storage_pool_details = self.get_details(pool_id=id,
pool_name=None)
LOG.info("Modification Successful")
return new_storage_pool_details
except Exception as e:
if self.module.params['pool_id']:
pool_identifier = self.module.params['pool_id']
else:
pool_identifier = self.module.params['pool_name']
error_message = 'Modify attributes of storage pool {0} ' \
'failed with error: {1}'.format(pool_identifier, str(e))
LOG.error(error_message)
self.module.fail_json(msg=error_message)
def get_pool_drives(self, pool_id=None, pool_name=None):
""" Get pool drives attached to pool"""
pool_identifier = pool_id or pool_name
pool_drives_list = []
try:
drive_instances = utils.UnityDiskList.get(self.conn._cli)
if drive_instances:
for drive in drive_instances:
if drive.pool and (drive.pool.id == pool_identifier or drive.pool.name == pool_identifier):
pool_drive = {"id": drive.id, "name": drive.name, "size": drive.size,
"disk_technology": drive.disk_technology.name,
"tier_type": drive.tier_type.name}
pool_drives_list.append(pool_drive)
LOG.info("Successfully retrieved pool drive details")
return pool_drives_list
except Exception as e:
error_message = 'Get details of pool drives failed with ' \
'error: {0}'.format(str(e))
LOG.error(error_message)
self.module.fail_json(msg=error_message)
def get_raid_type_enum(self, raid_type):
""" Get raid_type_enum.
:param raid_type: The raid_type
:return: raid_type enum
"""
if raid_type in utils.RaidTypeEnum.__members__:
return utils.RaidTypeEnum[raid_type]
else:
errormsg = "Invalid choice %s for Raid Type" % raid_type
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
def get_raid_stripe_width_enum(self, stripe_width):
""" Get raid_stripe_width enum.
:param stripe_width: The raid_stripe_width
:return: raid_stripe_width enum
"""
if stripe_width != "BEST_FIT":
stripe_width = "_" + stripe_width
if stripe_width in utils.RaidStripeWidthEnum.__members__:
return utils.RaidStripeWidthEnum[stripe_width]
else:
errormsg = "Invalid choice %s for stripe width" % stripe_width
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
def get_pool_type_enum(self, pool_type):
""" Get the storage pool_type enum.
:param pool_type: The pool_type
:return: pool_type enum
"""
if pool_type == "TRADITIONAL":
return 1
elif pool_type == "DYNAMIC":
return 2
else:
errormsg = "Invalid choice %s for Storage Pool Type" % pool_type
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
def get_raid_groups(self, raid_groups):
""" Get the raid groups for creating pool"""
try:
disk_obj = utils.UnityDiskGroup.get(self.conn._cli, _id=raid_groups['disk_group_id'])
disk_num = raid_groups['disk_num']
raid_type = raid_groups['raid_type']
raid_type = self.get_raid_type_enum(raid_type) \
if raid_type else None
stripe_width = raid_groups['stripe_width']
stripe_width = self.get_raid_stripe_width_enum(stripe_width) \
if stripe_width else None
raid_group = utils.RaidGroupParameter(disk_group=disk_obj,
disk_num=disk_num, raid_type=raid_type,
stripe_width=stripe_width)
raid_groups = [raid_group]
return raid_groups
except Exception as e:
error_message = 'Failed to create storage pool with error: %s' % str(e)
LOG.error(error_message)
self.module.fail_json(msg=error_message)
def validate_create_pool_params(self, alert_threshold=None,
pool_harvest_high_threshold=None,
pool_harvest_low_threshold=None,
snap_harvest_high_threshold=None,
snap_harvest_low_threshold=None):
""" Validates params for creating pool"""
if alert_threshold and (alert_threshold < 50 or alert_threshold > 84):
errormsg = "Alert threshold is not in the allowed value range of 50 - 84"
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
if pool_harvest_high_threshold and (pool_harvest_high_threshold < 1 or pool_harvest_high_threshold > 99):
errormsg = "Pool harvest high threshold is not in the allowed value range of 1 - 99"
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
if pool_harvest_low_threshold and (pool_harvest_low_threshold < 0 or pool_harvest_low_threshold > 98):
errormsg = "Pool harvest low threshold is not in the allowed value range of 0 - 98"
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
if snap_harvest_high_threshold and (snap_harvest_high_threshold < 1 or snap_harvest_high_threshold > 99):
errormsg = "Snap harvest high threshold is not in the allowed value range of 1 - 99"
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
if snap_harvest_low_threshold and (snap_harvest_low_threshold < 0 or snap_harvest_low_threshold > 98):
errormsg = "Snap harvest low threshold is not in the allowed value range of 0 - 98"
LOG.error(errormsg)
self.module.fail_json(msg=errormsg)
def create_pool(self, name, raid_groups):
""" Creates a StoragePool"""
try:
pool_obj = utils.UnityPool.get(self.conn._cli)
pool_description = self.module.params['pool_description']
raid_groups = self.get_raid_groups(raid_groups) \
if raid_groups else None
alert_threshold = self.module.params['alert_threshold']
pool_harvest_high_threshold = None
pool_harvest_low_threshold = None
snap_harvest_high_threshold = None
snap_harvest_low_threshold = None
is_harvest_enabled = self.module.params['is_harvest_enabled']
if is_harvest_enabled:
pool_harvest_high_threshold = self.module.params['pool_harvest_high_threshold']
pool_harvest_low_threshold = self.module.params['pool_harvest_low_threshold']
is_snap_harvest_enabled = self.module.params['is_snap_harvest_enabled']
if is_snap_harvest_enabled:
snap_harvest_high_threshold = self.module.params['snap_harvest_high_threshold']
snap_harvest_low_threshold = self.module.params['snap_harvest_low_threshold']
self.validate_create_pool_params(alert_threshold=alert_threshold,
pool_harvest_high_threshold=pool_harvest_high_threshold,
pool_harvest_low_threshold=pool_harvest_low_threshold,
snap_harvest_high_threshold=snap_harvest_high_threshold,
snap_harvest_low_threshold=snap_harvest_low_threshold)
pool_type = self.module.params['pool_type']
pool_type = self.get_pool_type_enum(pool_type) \
if pool_type else None
fast_vp = self.module.params['fast_vp']
if fast_vp:
if fast_vp == "enabled":
fast_vp = True
else:
fast_vp = False
pool_obj.create(self.conn._cli, name=name, description=pool_description, raid_groups=raid_groups,
alert_threshold=alert_threshold,
is_harvest_enabled=is_harvest_enabled,
is_snap_harvest_enabled=is_snap_harvest_enabled,
pool_harvest_high_threshold=pool_harvest_high_threshold,
pool_harvest_low_threshold=pool_harvest_low_threshold,
snap_harvest_high_threshold=snap_harvest_high_threshold,
snap_harvest_low_threshold=snap_harvest_low_threshold,
is_fastvp_enabled=fast_vp,
pool_type=pool_type)
LOG.info("Creation of storage pool successful")
storage_pool_details = self.get_details(pool_name=name)
changed = True
return changed, storage_pool_details
except Exception as e:
error_message = 'Failed to create storage pool with error: %s' % str(e)
LOG.error(error_message)
self.module.fail_json(msg=error_message)
def perform_module_operation(self):
"""
Perform different actions on storage pool module based on parameters
chosen in playbook
"""
pool_name = self.module.params['pool_name']
pool_id = self.module.params['pool_id']
new_pool_name = self.module.params['new_pool_name']
pool_description = self.module.params['pool_description']
fast_cache = self.module.params['fast_cache']
fast_vp = self.module.params['fast_vp']
state = self.module.params['state']
raid_groups = self.module.params['raid_groups']
if fast_cache:
if fast_cache == "enabled":
fast_cache = True
else:
fast_cache = False
if fast_vp:
if fast_vp == "enabled":
fast_vp = True
else:
fast_vp = False
# result is a dictionary that contains changed status and storage pool details
result = dict(
changed=False,
storage_pool_details={}
)
storage_pool_details = self.get_details(pool_id, pool_name)
result['storage_pool_details'] = storage_pool_details
if state == 'absent' and storage_pool_details:
error_message = 'Deletion of storage pool is not allowed through'\
' Ansible module'
LOG.error(error_message)
self.module.fail_json(msg=error_message)
# Create storage pool
if state == 'present' and not storage_pool_details:
if pool_name is not None and len(pool_name) != 0:
result['changed'], storage_pool_details \
= self.create_pool(name=pool_name, raid_groups=raid_groups)
result['storage_pool_details'] = storage_pool_details
else:
error_message = 'The parameter pool_name length is 0. It'\
' is too short. The min length is 1'
LOG.error(error_message)
self.module.fail_json(msg=error_message)
# Get pool drive details
if result['storage_pool_details']:
result['storage_pool_details']['drives'] = self.get_pool_drives(pool_id=pool_id, pool_name=pool_name)
if state == 'present' and storage_pool_details:
if new_pool_name is not None and len(new_pool_name) == 0:
error_message = 'The parameter new_pool_name length is 0. It'\
' is too short. The min length is 1'
LOG.error(error_message)
self.module.fail_json(msg=error_message)
pool_modify_flag = self.\
is_pool_modification_required(storage_pool_details)
LOG.info("Storage pool modification flag %s",
str(pool_modify_flag))
if pool_modify_flag:
result['storage_pool_details'] = \
self.pool_modify(storage_pool_details['id'], new_pool_name,
pool_description, fast_cache, fast_vp)
result['changed'] = True
self.module.exit_json(**result)
def get_storagepool_parameters():
"""This method provides parameters required for the ansible storage pool
module on Unity"""
return dict(
pool_name=dict(required=False, type='str'),
pool_id=dict(required=False, type='str'),
new_pool_name=dict(required=False, type='str'),
pool_description=dict(required=False, type='str'),
fast_cache=dict(required=False, type='str', choices=['enabled',
'disabled']),
fast_vp=dict(required=False, type='str', choices=['enabled',
'disabled']),
state=dict(required=True, type='str', choices=['present', 'absent']),
raid_groups=dict(required=False, type='dict', options=dict(
disk_group_id=dict(required=False, type='str'),
disk_num=dict(required=False, type='int'),
raid_type=dict(required=False, type='str', choices=['None', 'RAID5', 'RAID0', 'RAID1', 'RAID3', 'RAID10',
'RAID6', 'Mixed', 'Automatic']),
stripe_width=dict(required=False, type='str', choices=['BEST_FIT', '2', '4', '5',
'6', '8', '9', '10', '12', '13', '14', '16']))),
alert_threshold=dict(required=False, type='int'),
is_harvest_enabled=dict(required=False, type='bool'),
pool_harvest_high_threshold=dict(required=False, type='float'),
pool_harvest_low_threshold=dict(required=False, type='float'),
is_snap_harvest_enabled=dict(required=False, type='bool'),
snap_harvest_high_threshold=dict(required=False, type='float'),
snap_harvest_low_threshold=dict(required=False, type='float'),
pool_type=dict(required=False, type='str', choices=['TRADITIONAL', 'DYNAMIC'])
)
def main():
""" Create Unity storage pool object and perform action on it
based on user input from playbook"""
obj = StoragePool()
obj.perform_module_operation()
if __name__ == '__main__':
main()