def populate(self):
'''
Obtain and populate the facts
'''
if self._fact_name == 'host_system_info':
try:
check_presence = get_config(self._module, self._url)
self.data = json.loads(check_presence)
except Exception:
stacked_check_presence = get_config(self._module,
self._stacked_url)
self.data = json.loads(stacked_check_presence)
else:
check_presence = get_config(self._module, self._url)
if check_presence:
self.data = json.loads(check_presence)
if self._fact_name == 'switch_specific_system_info':
self.facts['switch_specific_system_info'] = self.data
return
if self._fact_name == 'host_system_info':
self.facts['host_system_info'] = self.data
return
if self._fact_name in self.data.keys():
self.facts[self._fact_name] = self.data[self._fact_name]
def config_vlan_port(module):
params = module.params
# Parameters
if params['vlan_id'] == "":
return {
'msg': "vlan_id cannot be null",
'changed': False,
'failed': True
}
else:
data = {'vlan_id': params['vlan_id']}
if params['port_id'] == "":
return {
'msg': "port_id cannot be null",
'changed': False,
'failed': True
}
else:
data['port_id'] = params['port_id']
data['port_mode'] = params['port_mode']
del_url = "/vlans-ports/" + str(params['vlan_id']) + \
"-" + str(params['port_id'])
# Check if the passed vlan is configured
check_presence = get_config(module, "/vlans/" + str(params['vlan_id']))
if not check_presence:
return {
'msg': 'Cannot configure ports without Vlan configured',
'changed': False,
'failed': True
}
else:
if params['config'] == "create":
check_presence = get_config(module, del_url)
if not check_presence:
url = '/vlans-ports'
method = 'POST'
else:
url = "/vlans-ports/" + str(params['vlan_id']) + \
"-" + str(params['port_id'])
method = 'PUT'
elif params['config'] == "delete":
url = "/vlans-ports/" + str(params['vlan_id']) + \
"-" + str(params['port_id'])
method = 'DELETE'
else:
return {
'msg': 'Valid config options are : create and delete',
'changed': False,
'failed': True
}
result = run_commands(module, url, data, method, check=del_url)
return result
def qos(module):
params = module.params
url = '/qos/policies'
policy_id = params['policy_name'] + '~' + params['policy_type']
check_url = url + '/' + policy_id
if params['state'] == 'create':
data = {
'policy_name': params['policy_name'],
'policy_type': params['policy_type'],
}
method = 'POST'
else:
# Check if qos is applied to any port
qos_url = '/qos/ports-policies'
qos_config = get_config(module, qos_url)
if qos_config:
qos_config = module.from_json(to_text(qos_config))
for config in qos_config['qos_port_policy_element']:
if policy_id == config['policy_id']:
return {
'msg':
'Cannot delete policy {}, active on port {}'.format(
policy_id, config['port_id']),
'change':
False
}
# Check if qos is applied to any port
qos_url = '/qos/vlans-policies'
qos_config = get_config(module, qos_url)
if qos_config:
qos_config = module.from_json(to_text(qos_config))
for config in qos_config['qos_vlan_policy_element']:
if policy_id == config['policy_id']:
return {
'msg':
'Cannot delete policy {}, active on vlan {}'.format(
policy_id, config['vlan_id']),
'change':
False
}
data = {}
method = 'DELETE'
url = check_url
result = run_commands(module, url, data, method, check=check_url)
return result
def config_acl(module):
params = module.params
if params.get('acl_direction') is None:
return {'msg': 'Missing parameter: acl_direction', 'changed': False}
# Check if acl is present
url = "/vlans-access-groups"
acl_type = params['acl_type']
direction = params['acl_direction']
data = {
'vlan_id': params['vlan_id'],
'acl_id': params['acl_id'] + "~" + acl_type,
'direction': direction
}
check_acl = '/acls/' + params['acl_id'] + "~" + acl_type
if not get_config(module, check_acl):
return {
'msg':
'Configure ACL first. {} does not exist'.format(params['acl_id']),
'changed':
False
}
delete_url = "{}/{}-{}~{}-{}".format(url, params['vlan_id'],
params['acl_id'], acl_type, direction)
config_present = False
current_acl = get_config(module, url)
if current_acl:
check_config = module.from_json(to_text(current_acl))
for ele in check_config['acl_vlan_policy_element']:
if ele['uri'] == delete_url:
config_present = ele
if params['config'] == 'create':
if config_present:
ret = {'changed': False}
ret.update(ele)
return ret
else:
result = run_commands(module, url, data, method='POST')
else:
if config_present:
result = run_commands(module, delete_url, method='DELETE')
else:
return {'changed': False, 'failed': False, 'msg': 'Not present'}
return result
def qos(module):
params = module.params
url = '/qos/ports-policies'
qptqos = '~QPT_QOS'
# check qos policy is present
qos_check = '/qos/policies/' + params['qos_policy'] + qptqos
if not get_config(module, qos_check):
return {
'msg':
'Configure QoS policy first. {} does not exist'.format(
params['qos_policy']),
'changed':
False
}
if params['state'] == 'create':
policy_id = params['qos_policy'] + qptqos
port_config = get_config(module, url)
if port_config:
check_config = module.from_json(to_text(port_config))
for ports in check_config['qos_port_policy_element']:
if ports['port_id'] == params['interface'] and \
ports['policy_id'] == policy_id and \
ports['direction'] == params['qos_direction']:
ret = {'changed': False}
ret.update(ports)
return ret
data = {
'port_id': params['interface'],
'policy_id': policy_id,
'direction': params['qos_direction']
}
result = run_commands(module, url, data, 'POST')
else:
url_delete = url + '/' + params['interface'] + '-' + \
params['qos_policy'] + qptqos + '-' + params['qos_direction']
check_url = url + '/' + params['interface'] + '-' + \
params['qos_policy'] + qptqos + '/stats'
result = run_commands(module,
url_delete, {},
'DELETE',
check=check_url)
return result
def config_poe_slot(module):
params = module.params
data = {}
data['slot_name'] = params['slot_name']
data['power_threshold_percentage'] = params['power_threshold_percentage']
# Check if slot_name is null
if params['slot_name'] == "":
return {
'msg': 'slot_name cannot be null',
'changed': False,
'failed': False
}
url = '/slots/' + str(params['slot_name']) + '/poe'
method = 'PUT'
diffSeen = False
check_presence = get_config(module, url)
newdata = json.loads(check_presence)
for key in data:
if not newdata[key] == data[key]:
diffSeen = True
break
if diffSeen:
result = run_commands(module, url, data, method, check=url)
return result
else:
return {'msg': 'Already Configured', 'changed': False, 'failed': False}
def dot1x_port_security(module):
params = module.params
data = {}
data['port_id'] = params['port_id']
if params['port_id'] == "":
return {
'msg': 'Port_id cannot be null',
'changed': False,
'failed': False
}
data['is_port_speed_vsa_enabled'] = params['is_port_speed_vsa_enabled']
data['allow_mbv'] = params['allow_mbv']
data['controlled_direction'] = params['controlled_direction']
data['allow_mixed_users'] = params['allow_mixed_users']
url = '/dot1x/port_security/' + params['port_id']
method = 'PUT'
# Check if authentication is enabled
check_presence = get_config(module, "/dot1x")
if check_presence:
newdata = json.loads(check_presence)
if not newdata["is_dot1x_enabled"]:
return {
'msg': 'Cannot enable port security unless '
'dot1x is enabled',
'changed': False,
'failed': False
}
result = run_commands(module, url, data, method, check=url)
return result
def config_backup(module):
params = module.params
url = '/system/config/cfg_backup_files'
data = {
'file_name': params['file_name'],
'config_type': params['config_type']
}
if params['state'] == 'create':
check_config = get_config(module, url)
if check_config:
check_config = module.from_json(to_text(check_config))
if check_config['collection_result']['total_elements_count'] == 5:
present = False
for config in check_config['config_file_element']:
if config['file_name'] == params['file_name']:
present = True
if not present:
return {
'msg': 'Only five config files are allowed.',
'changed': False
}
result = run_commands(module, url, data, 'POST')
return result
def authenticator_port_reauthenticate(module):
params = module.params
data = {}
data['port_id'] = params['port_id']
if params['port_id'] == "":
return {
'msg': 'Port_id cannot be null',
'changed': False,
'failed': False
}
url = '/dot1x/authenticator/' + params['port_id'] + '/reauthenticate'
method = 'POST'
# Check if authentication is enabled
check_presence = get_config(module, "/dot1x")
if check_presence:
newdata = json.loads(check_presence)
if not newdata["is_dot1x_enabled"]:
return {
'msg': 'Cannot reauthenticate port unless '
'dot1x is enabled',
'changed': False,
'failed': False
}
result = run_commands(module, url, data, method, check=url)
return result
def run_module():
module_args = dict(
interface=dict(type='str', required=True),
description=dict(type='str', required=False),
admin_stat=dict(type='bool', required=False),
qos_policy=dict(type='str', required=False),
qos_direction=dict(type='str',
required=False,
default='QPPD_INBOUND',
choices=['QPPD_INBOUND', 'QPPD_OUTBOUND']),
state=dict(type='str',
required=False,
default='create',
choices=['create', 'delete']),
acl_id=dict(type='str', required=False),
acl_type=dict(type='str',
required=False,
default='AT_STANDARD_IPV4',
choices=[
'AT_STANDARD_IPV4', 'AT_EXTENDED_IPV4',
'AT_CONNECTION_RATE_FILTER'
]),
acl_direction=dict(type='str',
required=False,
choices=['AD_INBOUND', 'AD_OUTBOUND', 'AD_CRF']),
)
module_args.update(arubaoss_argument_spec)
result = dict(changed=False, warnings='Not Supported')
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
if module.check_mode:
module.exit_json(**result)
port_url = '/ports/' + str(module.params['interface'])
check_port = get_config(module, port_url)
if not check_port:
result = {
'msg':
'Port {} not present on device {}'.format(
module.params['interface'], port_url),
'changed':
False
}
else:
try:
if module.params['qos_policy']:
result = qos(module)
elif module.params['acl_id']:
result = acl(module)
else:
result = config_port(module)
except Exception as err:
return module.fail_json(msg=err)
module.exit_json(**result)
def community(module):
params = module.params
url = '/snmp-server/communities'
check_url = url + '/' + params['community_name']
if params['state'] == 'create':
snmp_config = get_config(module, check_url)
if snmp_config:
url = check_url
method = 'PUT'
else:
method = 'POST'
data = {
'access_type': params['access_type'],
'community_name': params['community_name'],
'restricted': params['restricted']
}
else:
url = check_url
method = 'DELETE'
data = {}
result = run_commands(module, url, data, method, check=check_url)
return result
def config_tacacs_server(module):
params = module.params
data = {}
if params['ip_address'] == "" or params['version'] == "":
return {'msg': "IP Address or version cannot be null",
'changed': False, 'failed': False}
else:
data["server_ip"] = {"version": params['version'],
"octets": params['ip_address']}
data["auth_key"] = params['auth_key']
data["is_oobm"] = params['is_oobm']
create_url = '/tacacs_profile/server'
check_url = '/tacacs_profile/server/' + str(params['ip_address'])
if params['config'] == "create":
check_presence = get_config(module, '/tacacs_profile/server/'
+ str(params['ip_address']))
if not check_presence:
url = create_url
method = 'POST'
else:
url = check_url
method = 'PUT'
else:
url = check_url
method = 'DELETE'
result = run_commands(module, url, data, method, check=check_url)
return result
def config_present(module, url, key, value):
check_presence = get_config(module, url)
if check_presence:
newdata = json.loads(check_presence)
if key in newdata.keys():
if newdata[key] == value:
return True
return False
def config_vlan(module):
params = module.params
# Parameters
if params['vlan_id'] == "":
return {
'msg': "vlan_id cannot be null",
'changed': False,
'failed': True
}
else:
data = {'vlan_id': params['vlan_id']}
if params['name'] == "":
data['name'] = "VLAN{}".format(params['vlan_id'])
else:
data['name'] = params['name']
data['status'] = params['status']
data['type'] = params['vlantype']
data['is_jumbo_enabled'] = params['is_jumbo_enabled']
data['is_voice_enabled'] = params['is_voice_enabled']
data['is_dsnoop_enabled'] = params['is_dsnoop_enabled']
firmware = get_firmware(module)
if (firmware[:2] == "YA") or (firmware[:2] == "YB"):
if params['is_dhcp_server_enabled']:
return {
'msg': "option : is_dhcp_server_enabled is not "
"supported on this platform",
'changed': False,
'failed': True
}
else:
data['is_dhcp_server_enabled'] = params['is_dhcp_server_enabled']
config_url = "/vlans/" + str(params['vlan_id'])
if params['config'] == "create":
check_presence = get_config(module, config_url)
if not check_presence:
data['is_management_vlan'] = params['is_management_vlan']
url = "/vlans"
method = 'POST'
else:
url = "/vlans/" + str(params['vlan_id'])
method = 'PUT'
management_vlan = module.from_json(to_text(check_presence))
if params['is_management_vlan'] != \
management_vlan['is_management_vlan']:
data['is_management_vlan'] = params['is_management_vlan']
else:
url = config_url
method = 'DELETE'
result = run_commands(module, url, data, method, check=config_url)
return result
def config_qos(module):
params = module.params
url = '/qos/vlans-policies'
# if no vlan exists
config_vlan(module)
# check qos policy is present
qos_check = '/qos/policies/' + params['qos_policy'] + '~' + 'QPT_QOS'
if not get_config(module, qos_check):
return {
'msg':
'Configure QoS policy first. {} does not exist'.format(
params['qos_policy']),
'changed':
False
}
if params['config'] == 'create':
policy_id = params['qos_policy'] + '~' + 'QPT_QOS'
vlan_config = get_config(module, url)
if vlan_config:
check_config = module.from_json(to_text(vlan_config))
for vlans in check_config['qos_vlan_policy_element']:
if vlans['vlan_id'] == params['vlan_id'] and \
vlans['policy_id'] == policy_id:
ret = {'changed': False}
ret.update(vlans)
return ret
data = {'vlan_id': params['vlan_id'], 'policy_id': policy_id}
result = run_commands(module, url, data, 'POST')
else:
url = url + '/' + str(params['vlan_id']) + '-' + \
params['qos_policy'] + '~' + 'QPT_QOS'
check_url = url + '/stats'
result = run_commands(module, url, {}, 'DELETE', check=check_url)
return result
def populate_facts(self, connection, ansible_facts, data=None):
'''
Obtain and return LACP interfaces Facts
'''
url = '/lacp/port'
check_presence = get_config(self._module, url)
if check_presence:
lacp_interfaces = json.loads(check_presence)
facts = {'lacp_interfaces': lacp_interfaces}
ansible_facts['ansible_network_resources'].update(facts)
return ansible_facts
def populate_facts(self, connection, ansible_facts, data=None):
'''
Obtain and return ACLs Facts
'''
url = '/acls'
check_presence = get_config(self._module, url)
if check_presence:
acls = json.loads(check_presence)
facts = {'acls': acls}
ansible_facts['ansible_network_resources'].update(facts)
return ansible_facts
def populate_facts(self, connection, ansible_facts, data=None):
'''
Obtain and return LLDP Neighbors Facts
'''
url = '/lldp/remote-device'
check_presence = get_config(self._module, url)
if check_presence:
lldp_neighbors = json.loads(check_presence)
facts = {'lldp_neighbors': lldp_neighbors}
ansible_facts['ansible_network_resources'].update(facts)
return ansible_facts
def wait_for_boot(module):
url = '/system/status'
wait = 1
while wait <= 60:
result = get_config(module, url, check_login=False)
if result:
return result
sleep(5)
wait += 1
return False
def config_vlan_dhcpHelperAddress(module):
params = module.params
# Parameters
if params['vlan_id'] == "":
return {
'msg': "vlan_id cannot be null",
'changed': False,
'failed': True
}
else:
data = {'vlan_id': params['vlan_id']}
if params['helper_addresses'] == "":
return {
'msg': "DHCP Helper IP Addr cannot be null",
'changed': False,
'failed': True
}
else:
data['dhcp_helper_address'] = {
'version': params['version'],
'octets': params['helper_addresses']
}
url = "/vlans/dhcp-relay"
del_url = url + '/' + str(params['vlan_id']) + \
'-' + params['helper_addresses']
# Check if the passed vlan is configured
check_presence = get_config(module, "/vlans/" + str(params['vlan_id']))
if not check_presence:
return {
'msg': 'Cannot configure Helper Address without '
'Vlan configured',
'changed': False,
'failed': True
}
else:
if params['config'] == "create":
method = 'POST'
else:
url = del_url
method = 'DELETE'
result = run_commands(module, url, data, method, check=del_url)
return result
def authorization_group(module):
params = module.params
data = {}
# URI
url = "/authorization_group"
get_url = url + "/" + params['group_name'] + "-" + str(params['seq_num'])
if params['config'] == "create":
method = "POST"
else:
method = "DELETE"
url = get_url
data['group_name'] = params['group_name']
data['seq_num'] = params['seq_num']
if method == "POST":
if params['match_cmd'] != "":
data['match_cmd'] = '\"' + params['match_cmd'] + '\"'
else:
data['match_cmd'] = ""
data['cmd_permission'] = params['cmd_permission']
data['is_log_enabled'] = params['is_log_enabled']
check_presence = get_config(module, get_url)
if check_presence:
# Sequence exists
if method == "POST":
return {
'msg': 'The sequence exists.',
'changed': False,
'failed': False
}
else:
# Sequence does not exist
if method == "DELETE":
return {
'msg': 'The sequence does not exist.',
'changed': False,
'failed': False
}
# Config
result = run_commands(module, url, data, method)
return result
def authenticator_port_config(module):
params = module.params
data = {}
data['port_id'] = params['port_id']
if params['port_id'] == "":
return {
'msg': 'Port_id cannot be null',
'changed': False,
'failed': False
}
data['is_authenticator_enabled'] = params['is_authenticator_enabled']
data['control'] = params['control']
data['unauthorized_vlan_id'] = params['unauthorized_vlan_id']
data['client_limit'] = params['client_limit']
data['quiet_period'] = params['quiet_period']
data['tx_period'] = params['tx_period']
data['supplicant_timeout'] = params['supplicant_timeout']
data['server_timeout'] = params['server_timeout']
data['max_requests'] = params['max_requests']
data['reauth_period'] = params['reauth_period']
data['authorized_vlan_id'] = params['authorized_vlan_id']
data['logoff_period'] = params['logoff_period']
data['unauth_period'] = params['unauth_period']
data['cached_reauth_period'] = params['cached_reauth_period']
data['enforce_cache_reauth'] = params['enforce_cache_reauth']
url = '/dot1x/authenticator/' + params['port_id']
method = 'PUT'
# Check if authentication is enabled
check_presence = get_config(module, "/dot1x")
if check_presence:
newdata = json.loads(check_presence)
if not newdata["is_dot1x_enabled"]:
return {
'msg': 'Cannot enable port authentication '
'unless dot1x is enabled',
'changed': False,
'failed': False
}
result = run_commands(module, url, data, method, check=url)
return result
def config_syslog(module):
params = module.params
url = '/syslog/servers'
check_url = url + '/' + params['server_address']
if params['state'] == 'delete':
result = run_commands(module,
check_url,
method='DELETE',
check=check_url)
return result
else:
check_syslog = get_config(module, check_url)
if check_syslog:
method = 'PUT'
url = check_url
else:
method = 'POST'
data = {
'ip_address': {
'octets': params['server_address'],
'version': params['version']
},
'transport_protocol': params['protocol'],
}
protocol = params['protocol']
if params['server_port'] == 0:
if protocol == 'TP_UDP':
port = 514
elif protocol == 'TP_TCP':
port = 1470
elif protocol == 'TP_TLS':
port = 6514
data.update({'port': port})
else:
data.update({'port': params['server_port']})
if params['description']:
data.update({'control_description': params['description']})
result = run_commands(module, url, data, method, check=check_url)
return result
def config_radius_server(module):
params = module.params
data = {}
data["radius_server_id"] = params['radius_server_id']
if params['server_ip'] == "" or params['version'] == "":
return {'msg': "IP Address or version cannot be null",
'changed': False, 'failed': False}
else:
data["address"] = {'version': params['version'],
'octets': params['server_ip']}
if params['shared_secret'] == "":
return {'msg': "Shared secret cannot be null",
'changed': False, 'failed': False}
else:
data["shared_secret"] = params['shared_secret']
data["authentication_port"] = params['authentication_port']
data["accounting_port"] = params['accounting_port']
data["is_dyn_authorization_enabled"] = \
params['is_dyn_authorization_enabled']
data["time_window_type"] = params['time_window_type']
data["time_window"] = params['time_window']
data["is_oobm"] = params['is_oobm']
create_url = '/radius_servers'
check_url = '/radius_servers/' + str(params['radius_server_id'])
if params['config'] == "create":
# Check if it already exists
check_presence = get_config(module, check_url)
if not check_presence:
url = create_url
method = 'POST'
else:
url = check_url
method = 'PUT'
else:
url = check_url
method = 'DELETE'
result = run_commands(module, url, data, method, check=check_url)
return result
def host(module):
params = module.params
url = '/snmp-server/hosts'
for key in ['host_ip', 'version']:
if not params[key]:
return {'msg': 'Missing {} in parameter list'.format(key),
'changed': False}
check_url = url + '/' + params['host_ip'] + '-' + params['community_name']
if params['state'] == 'create':
check_host = get_config(module, check_url)
if check_host:
method = 'PUT'
url = check_url
else:
method = 'POST'
data = {
'host_ip': {
'octets': params['host_ip'],
'version': params['version']
},
'community': params['community_name'],
'trap_level': params['trap_level'],
'informs': params['informs'],
'use_oobm': params['use_oobm'],
}
if params['informs']:
data.update({
'informs': params['informs'],
'inform_timeout': params['inform_timeout'],
'inform_retries': params['inform_retries']
})
else:
data = {}
method = 'DELETE'
url = check_url
result = run_commands(module, url, data, method, check=check_url)
return result
def config_timesync(module):
params = module.params
data = {}
# Parameters
timesyncType = params['timesyncType']
data[timesyncType] = True
# URI
url = "/config/timesync"
method = "PUT"
# Check if timesync is set already
check_presence = get_config(module, "/config/timesync")
newdata = json.loads(check_presence)
if timesyncType == 'ntp' and 'ntp' in newdata:
return {
'msg': 'timesync already set to NTP',
'changed': False,
'failed': False
}
elif timesyncType == 'timep' and 'timep' in newdata:
return {
'msg': 'timesync already set to Timep',
'changed': False,
'failed': False
}
elif timesyncType == 'sntp' and 'sntp' in newdata:
return {
'msg': 'timesync already set to SNTP',
'changed': False,
'failed': False
}
elif timesyncType == 'timep-or-sntp' and 'timep-or-sntp' in newdata:
return {
'msg': 'timesync already set to timep or SNTP',
'changed': False,
'failed': False
}
else:
# Config
result = run_commands(module, url, data, method)
return result
def update_rate_limit_attributes_onPort(module):
params = module.params
data = {}
data['port_id'] = params['port_id']
data['traffic_type'] = params['traffic_type']
data['direction'] = params['direction']
data['rate_limit'] = params['rate_limit']
# Rate limit should be in kbps or percent
if params['rate_limit_in_kbps'] == 0:
data['rate_limit'] = \
{'rate_limit_in_percent': params['rate_limit_in_percent']}
else:
data['rate_limit'] = \
{'rate_limit_in_kbps': params['rate_limit_in_kbps']}
url = '/ports/rate_limit/' + str(params['port_id']) + "-" \
+ str(params['traffic_type']) + "-" + str(params['direction'])
method = 'PUT'
# Idempotency check: Check if already configured
diffSeen = False
check_presence = get_config(module, url)
newdata = json.loads(check_presence)
for key in data:
if not newdata[key] == data[key]:
diffSeen = True
if params['rate_limit_in_percent'] == 0 and \
newdata[key]['rate_limit_in_percent'] is None:
diffSeen = False
if params['rate_limit_in_kbps'] == 0 and \
newdata[key]['rate_limit_in_kbps'] is None:
diffSeen = False
break
if diffSeen:
result = run_commands(module, url, data, method)
return result
else:
return {'msg': 'Already configured', 'changed': False, 'failed': False}
def update_vlan(module):
params = module.params
url = '/loop_protect/vlans/' + str(params['vlan'])
vlan_url = '/vlans/' + str(params['vlan'])
check_vlan = get_config(module, vlan_url)
if not check_vlan:
return {
'msg': 'Vlan {} not configured'.format(params['vlan']),
'changed': False
}
data = {
'vlan_id': params['vlan'],
'is_vlan_loop_protected': params['loop_protected'],
}
result = run_commands(module, url, data, 'PUT', check=url)
return result
def config_poe_port(module):
params = module.params
data = {}
data['port_id'] = params['port_id']
data['is_poe_enabled'] = params['is_poe_enabled']
data['poe_priority'] = params['poe_priority']
data['poe_allocation_method'] = params['poe_allocation_method']
data['port_configured_type'] = params['port_configured_type']
data['pre_standard_detect_enabled'] = params['pre_standard_detect_enabled']
# allocated_power_in_watts can be set only when
# poe_allocation_method is PPAM_VALUE
if params['poe_allocation_method'] == "PPAM_VALUE":
data['allocated_power_in_watts'] = params['allocated_power_in_watts']
# Check if port_id is null
if params['port_id'] == "":
return {
'msg': 'port_id cannot be null',
'changed': False,
'failed': False
}
url = '/ports/' + str(params['port_id']) + '/poe'
method = 'PUT'
diffSeen = False
check_presence = get_config(module, url)
newdata = json.loads(check_presence)
for key in data:
if not newdata[key] == data[key]:
diffSeen = True
break
if diffSeen:
result = run_commands(module, url, data, method, check=url)
return result
else:
return {'msg': 'Already Configured', 'changed': False, 'failed': False}
def wait_to_copy(module):
params = module.params
# file_url = params['file_url'].split('/')
# file_name = file_url[len(file_url)-1]
final_result = ""
wait = 1
while wait <= params['copy_iter']:
check_presence = get_config(module, "/file-transfer/status")
if not check_presence:
final_result = 'FILE TRANSFER CHECK FAILED'
else:
newdata = json.loads(check_presence)
final_result = newdata['status']
if newdata['status'] == 'FTS_IN_PROGRESS':
sleep(10)
wait += 1
continue
else:
break
return final_result
