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 ElementSWVlan(object):
""" class to handle VLAN operations """
def __init__(self):
"""
Setup Ansible parameters and ElementSW connection
"""
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=False, type='str'),
vlan_tag=dict(required=True, type='str'),
svip=dict(required=False, type='str'),
netmask=dict(required=False, type='str'),
gateway=dict(required=False, type='str'),
namespace=dict(required=False, type='bool'),
attributes=dict(required=False, type='dict'),
address_blocks=dict(required=False, type='list')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
if HAS_SF_SDK is False:
self.module.fail_json(
msg="Unable to import the SolidFire Python SDK")
else:
self.elem = netapp_utils.create_sf_connection(module=self.module)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
self.elementsw_helper = NaElementSWModule(self.elem)
# add telemetry attributes
if self.parameters.get('attributes') is not None:
self.parameters['attributes'].update(
self.elementsw_helper.set_element_attributes(
source='na_elementsw_vlan'))
else:
self.parameters[
'attributes'] = self.elementsw_helper.set_element_attributes(
source='na_elementsw_vlan')
def validate_keys(self):
"""
Validate if all required keys are present before creating
"""
required_keys = ['address_blocks', 'svip', 'netmask', 'name']
if all(item in self.parameters.keys()
for item in required_keys) is False:
self.module.fail_json(
msg=
"One or more required fields %s for creating VLAN is missing" %
required_keys)
addr_blk_fields = ['start', 'size']
for address in self.parameters['address_blocks']:
if 'start' not in address or 'size' not in address:
self.module.fail_json(
msg=
"One or more required fields %s for address blocks is missing"
% addr_blk_fields)
def create_network(self):
"""
Add VLAN
"""
try:
self.validate_keys()
create_params = self.parameters.copy()
for key in [
'username', 'hostname', 'password', 'state', 'vlan_tag'
]:
del create_params[key]
self.elem.add_virtual_network(
virtual_network_tag=self.parameters['vlan_tag'],
**create_params)
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error creating VLAN %s" %
self.parameters['vlan_tag'],
exception=to_native(err))
def delete_network(self):
"""
Remove VLAN
"""
try:
self.elem.remove_virtual_network(
virtual_network_tag=self.parameters['vlan_tag'])
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error deleting VLAN %s" %
self.parameters['vlan_tag'],
exception=to_native(err))
def modify_network(self, modify):
"""
Modify the VLAN
"""
try:
self.elem.modify_virtual_network(
virtual_network_tag=self.parameters['vlan_tag'], **modify)
except solidfire.common.ApiServerError as err:
self.module.fail_json(msg="Error modifying VLAN %s" %
self.parameters['vlan_tag'],
exception=to_native(err))
def get_network_details(self):
"""
Check existing VLANs
:return: vlan details if found, None otherwise
:type: dict
"""
vlans = self.elem.list_virtual_networks(
virtual_network_tag=self.parameters['vlan_tag'])
vlan_details = dict()
for vlan in vlans.virtual_networks:
if vlan is not None:
vlan_details['name'] = vlan.name
vlan_details['address_blocks'] = list()
for address in vlan.address_blocks:
vlan_details['address_blocks'].append({
'start': address.start,
'size': address.size
})
vlan_details['svip'] = vlan.svip
vlan_details['gateway'] = vlan.gateway
vlan_details['netmask'] = vlan.netmask
vlan_details['namespace'] = vlan.namespace
vlan_details['attributes'] = dict()
for key in vlan.attributes.__dict__.keys():
vlan_details['attributes'][key] = vlan.attributes.key
return vlan_details
return None
def apply(self):
"""
Call create / delete / modify vlan methods
"""
network = self.get_network_details()
# calling helper to determine action
cd_action = self.na_helper.get_cd_action(network, self.parameters)
modify = self.na_helper.get_modified_attributes(
network, self.parameters)
if cd_action == "create":
self.create_network()
elif cd_action == "delete":
self.delete_network()
elif modify:
self.modify_network(modify)
self.module.exit_json(changed=self.na_helper.changed)