class ElementSWQosPolicy(object):
"""
Element Software QOS Policy
"""
def __init__(self):
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str'),
qos=dict(required=False, type='dict'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
# Set up state variables
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
self.qos_policy_id = None
if HAS_SF_SDK is False:
self.module.fail_json(msg="Unable to import the SolidFire Python SDK")
else:
self.sfe = netapp_utils.create_sf_connection(module=self.module)
self.elementsw_helper = NaElementSWModule(self.sfe)
# add telemetry attributes
self.attributes = self.elementsw_helper.set_element_attributes(source='na_elementsw_qos_policy')
def get_qos_policy(self, name):
"""
Get QOS Policy
"""
policy, error = self.elementsw_helper.get_qos_policy(name)
if error is not None:
self.module.fail_json(msg=error, exception=traceback.format_exc())
return policy
def create_qos_policy(self, name, qos):
"""
Create the QOS Policy
"""
try:
self.sfe.create_qos_policy(name=name, qos=qos)
except (solidfire.common.ApiServerError, solidfire.common.ApiConnectionError) as exc:
self.module.fail_json(msg="Error creating qos policy: %s: %s" %
(name, to_native(exc)), exception=traceback.format_exc())
def update_qos_policy(self, qos_policy_id, modify, name=None):
"""
Update the QOS Policy if the policy already exists
"""
options = dict(
qos_policy_id=qos_policy_id
)
if name is not None:
options['name'] = name
if 'qos' in modify:
options['qos'] = modify['qos']
try:
self.sfe.modify_qos_policy(**options)
except (solidfire.common.ApiServerError, solidfire.common.ApiConnectionError) as exc:
self.module.fail_json(msg="Error updating qos policy: %s: %s" %
(self.parameters['from_name'] if name is not None else self.parameters['name'], to_native(exc)),
exception=traceback.format_exc())
def delete_qos_policy(self, qos_policy_id):
"""
Delete the QOS Policy
"""
try:
self.sfe.delete_qos_policy(qos_policy_id=qos_policy_id)
except (solidfire.common.ApiServerError, solidfire.common.ApiConnectionError) as exc:
self.module.fail_json(msg="Error deleting qos policy: %s: %s" %
(self.parameters['name'], to_native(exc)), exception=traceback.format_exc())
def apply(self):
"""
Process the create/delete/rename/modify actions for qos policy on the Element Software Cluster
"""
modify = dict()
current = self.get_qos_policy(self.parameters['name'])
qos_policy_id = None if current is None else current['qos_policy_id']
cd_action = self.na_helper.get_cd_action(current, self.parameters)
modify = self.na_helper.get_modified_attributes(current, self.parameters)
if cd_action == 'create' and self.parameters.get('from_name') is not None:
from_qos_policy = self.get_qos_policy(self.parameters['from_name'])
if from_qos_policy is None:
self.module.fail_json(msg="Error renaming qos policy, no existing policy with name/id: %s" % self.parameters['from_name'])
cd_action = 'rename'
qos_policy_id = from_qos_policy['qos_policy_id']
self.na_helper.changed = True
modify = self.na_helper.get_modified_attributes(from_qos_policy, self.parameters)
if cd_action == 'create' and 'qos' not in self.parameters:
self.module.fail_json(msg="Error creating qos policy: %s, 'qos:' option is required" % self.parameters['name'])
if not self.module.check_mode:
if cd_action == 'create':
self.create_qos_policy(self.parameters['name'], self.parameters['qos'])
elif cd_action == 'delete':
self.delete_qos_policy(qos_policy_id)
elif cd_action == 'rename':
self.update_qos_policy(qos_policy_id, modify, name=self.parameters['name'])
elif modify:
self.update_qos_policy(qos_policy_id, modify)
self.module.exit_json(changed=self.na_helper.changed)
class ElementSWVolume(object):
"""
Contains methods to parse arguments,
derive details of ElementSW objects
and send requests to ElementOS via
the ElementSW SDK
"""
def __init__(self):
"""
Parse arguments, setup state variables,
check paramenters and ensure SDK is installed
"""
self._size_unit_map = netapp_utils.SF_BYTE_MAP
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
name=dict(required=True, type='str'),
account_id=dict(required=True),
enable512e=dict(required=False, type='bool', aliases=['enable512emulation']),
qos=dict(required=False, type='dict', default=None),
qos_policy_name=dict(required=False, type='str', default=None),
attributes=dict(required=False, type='dict', default=None),
size=dict(type='int'),
size_unit=dict(default='gb',
choices=['bytes', 'b', 'kb', 'mb', 'gb', 'tb',
'pb', 'eb', 'zb', 'yb'], type='str'),
access=dict(required=False, type='str', default=None,
choices=['readOnly', 'readWrite', 'locked', 'replicationTarget']),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_if=[
('state', 'present', ['size', 'enable512e'])
],
mutually_exclusive=[
('qos', 'qos_policy_name'),
],
supports_check_mode=True
)
param = self.module.params
# set up state variables
self.state = param['state']
self.name = param['name']
self.account_id = param['account_id']
self.enable512e = param['enable512e']
self.qos = param['qos']
self.qos_policy_name = param['qos_policy_name']
self.attributes = param['attributes']
self.access = param['access']
self.size_unit = param['size_unit']
if param['size'] is not None:
self.size = param['size'] * self._size_unit_map[self.size_unit]
else:
self.size = None
if HAS_SF_SDK is False:
self.module.fail_json(msg="Unable to import the ElementSW Python SDK")
else:
try:
self.sfe = netapp_utils.create_sf_connection(module=self.module)
except solidfire.common.ApiServerError:
self.module.fail_json(msg="Unable to create the connection")
self.elementsw_helper = NaElementSWModule(self.sfe)
# add telemetry attributes
if self.attributes is not None:
self.attributes.update(self.elementsw_helper.set_element_attributes(source='na_elementsw_volume'))
else:
self.attributes = self.elementsw_helper.set_element_attributes(source='na_elementsw_volume')
def get_account_id(self):
"""
Return account id if found
"""
try:
# Update and return self.account_id
self.account_id = self.elementsw_helper.account_exists(self.account_id)
except Exception as err:
self.module.fail_json(msg="Error: account_id %s does not exist" % self.account_id, exception=to_native(err))
return self.account_id
def get_qos_policy(self, name):
"""
Get QOS Policy
"""
policy, error = self.elementsw_helper.get_qos_policy(name)
if error is not None:
self.module.fail_json(msg=error)
return policy
def get_volume(self):
"""
Return volume details if found
"""
# Get volume details
volume_id = self.elementsw_helper.volume_exists(self.name, self.account_id)
if volume_id is not None:
# Return volume_details
volume_details = self.elementsw_helper.get_volume(volume_id)
if volume_details is not None:
return volume_details
return None
def create_volume(self, qos_policy_id):
"""
Create Volume
:return: True if created, False if fails
"""
options = dict(
name=self.name,
account_id=self.account_id,
total_size=self.size,
enable512e=self.enable512e,
attributes=self.attributes
)
if qos_policy_id is not None:
options['qos_policy_id'] = qos_policy_id
if self.qos is not None:
options['qos'] = self.qos
try:
self.sfe.create_volume(**options)
except Exception as err:
self.module.fail_json(msg="Error provisioning volume: %s of size: %s" % (self.name, self.size),
exception=to_native(err))
def delete_volume(self, volume_id):
"""
Delete and purge the volume using volume id
:return: Success : True , Failed : False
"""
try:
self.sfe.delete_volume(volume_id=volume_id)
self.sfe.purge_deleted_volume(volume_id=volume_id)
# Delete method will delete and also purge the volume instead of moving the volume state to inactive.
except Exception as err:
# Throwing the exact error message instead of generic error message
self.module.fail_json(msg='Error deleting volume: %s, %s' % (str(volume_id), to_native(err)),
exception=to_native(err))
def update_volume(self, volume_id, qos_policy_id):
"""
Update the volume with the specified param
:return: Success : True, Failed : False
"""
options = dict(
attributes=self.attributes
)
if self.access is not None:
options['access'] = self.access
if self.account_id is not None:
options['account_id'] = self.account_id
if self.qos is not None:
options['qos'] = self.qos
if qos_policy_id is not None:
options['qos_policy_id'] = qos_policy_id
if self.size is not None:
options['total_size'] = self.size
try:
self.sfe.modify_volume(volume_id, **options)
except Exception as err:
# Throwing the exact error message instead of generic error message
self.module.fail_json(msg='Error updating volume: %s, %s' % (str(volume_id), to_native(err)),
exception=to_native(err))
def apply(self):
# Perform pre-checks, call functions and exit
changed = False
qos_policy_id = None
action = None
self.get_account_id()
volume_detail = self.get_volume()
if self.state == 'present' and self.qos_policy_name is not None:
policy = self.get_qos_policy(self.qos_policy_name)
if policy is None:
error = 'Cannot find qos policy with name/id: %s' % self.qos_policy_name
self.module.fail_json(msg=error)
qos_policy_id = policy['qos_policy_id']
if volume_detail:
volume_id = volume_detail.volume_id
if self.state == 'absent':
action = 'delete'
elif self.state == 'present':
# Checking all the params for update operation
if self.access is not None and volume_detail.access != self.access:
action = 'update'
if self.account_id is not None and volume_detail.account_id != self.account_id:
action = 'update'
if qos_policy_id is not None and volume_detail.qos_policy_id != qos_policy_id:
# volume_detail.qos_policy_id may be None if no policy is associated with the volume
action = 'update'
if self.qos is not None and volume_detail.qos_policy_id is not None:
# remove qos_policy
action = 'update'
if self.qos is not None:
# Actual volume_detail.qos has ['burst_iops', 'burst_time', 'curve', 'max_iops', 'min_iops'] keys.
# As only minOPS, maxOPS, burstOPS is important to consider, checking only these values.
volume_qos = vars(volume_detail.qos)
if volume_qos['min_iops'] != self.qos['minIOPS'] or volume_qos['max_iops'] != self.qos['maxIOPS'] \
or volume_qos['burst_iops'] != self.qos['burstIOPS']:
action = 'update'
if self.size is not None and volume_detail.total_size is not None and volume_detail.total_size != self.size:
size_difference = abs(float(volume_detail.total_size - self.size))
# Change size only if difference is bigger than 0.001
if size_difference / self.size > 0.001:
action = 'update'
if self.attributes is not None and volume_detail.attributes != self.attributes:
action = 'update'
elif self.state == 'present':
action = 'create'
result_message = ""
if action is not None:
changed = True
if self.module.check_mode:
result_message = "Check mode, skipping changes"
else:
if action == 'create':
self.create_volume(qos_policy_id)
result_message = "Volume created"
elif action == 'update':
self.update_volume(volume_id, qos_policy_id)
result_message = "Volume updated"
elif action == 'delete':
self.delete_volume(volume_id)
result_message = "Volume deleted"
self.module.exit_json(changed=changed, msg=result_message)
