archive
/
ansible
mirror of https://github.com/ansible/ansible.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

update eos_eapi module with new enhancements

Browse Source 
* add support for vrf configurations
* add support for configing the qos value for eapi
* add config argument to specify the device running-config

Tested on EOS 4.15.4F
pull/18777/head
Peter Sprygada 8 years ago committed by Matt Clay
parent 5e5698dc9e
commit 0f4446166b
1 changed files with 305 additions and 229 deletions
Show Stats Download Patch File Download Diff File

534
lib/ansible/modules/network/eos/eos_eapi.py
Unescape Escape View File

@ -21,8 +21,8 @@ DOCUMENTATION = """
--- ---
module: eos_eapi module: eos_eapi
version_added: "2.1" version_added: "2.1"
author: "Chris Houseknecht (@chouseknecht)" author: "Peter Sprygada (@privateip)"
short_description: Manage and configure eAPI. short_description: Manage and configure Arista EOS eAPI.
requirements: requirements:
- "EOS v4.12 or greater" - "EOS v4.12 or greater"
description: description:
@ -35,259 +35,335 @@ description:
- Requires EOS v4.12 or greater. - Requires EOS v4.12 or greater.
extends_documentation_fragment: eos extends_documentation_fragment: eos
options: options:
state: http:
description: description:
- A state of I(started) will - The C(http) argument controls the operating state of the HTTP
enable eAPI access, and a state of I(stopped) will transport protocol when eAPI is present in the running-config.
disable or shutdown all eAPI access. When the value is set to True, the HTTP protocol is enabled and
choices: when the value is set to False, the HTTP protocol is disabled.
- started By default, when eAPI is first configured, the HTTP protocol is
- stopped disabled.
required: false required: false
default: started default: yes
http_port: choices: ['yes', 'no']
description: aliases: ['enable_http']
- Port on which the HTTP server will listen. http_port:
required: false description:
default: 80 - Configures the HTTP port that will listen for connections when
https_port: the HTTP transport protocol is enabled. This argument accepts
description: integer values in the valid range of 1 to 65535.
- Port on which the HTTPS server will listen. required: false
required: false default: 80
default: 443 https:
local_http_port: description:
description: - The C(https) argument controls the operating state of the HTTPS
- Port on which the local HTTP server will listen. transport protocol when eAPI is present in the running-config.
required: false When the value is set to True, the HTTPS protocol is enabled and
default: 8080 when the value is set to False, the HTTPS protocol is disabled.
http: By default, when eAPI is first configured, the HTTPS protocol is
description: enabled.
- Enable HTTP server access. required: false
required: false default: yes
default: true choices: ['yes', 'no']
choices: aliases: ['enable_http']
- yes https_port:
- no description:
aliases: - Configures the HTTP port that will listen for connections when
- enable_http the HTTP transport protocol is enabled. This argument accepts
https: integer values in the valid range of 1 to 65535.
description: required: false
- Enable HTTPS server access. default: 443
required: false local_http:
default: true description:
choices: - The C(local_http) argument controls the operating state of the
- yes local HTTP transport protocol when eAPI is present in the
- no running-config. When the value is set to True, the HTTP protocol
aliases: is enabled and restricted to connections from localhost only. When
- enable_https the value is set to False, the HTTP local protocol is disabled.
local_http: - Note is value is independent of the C(http) argument
description: required: false
- Enable local HTTP server access. default: false
required: false choices: ['yes', 'no']
default: false aliases: ['enable_local_http']
choices: local_http_port:
- yes description:
- no - Configures the HTTP port that will listen for connections when
aliases: the HTTP transport protocol is enabled. This argument accepts
- enable_local_http integer values in the valid range of 1 to 65535.
socket: required: false
description: default: 8080
- Enable Unix socket server access. socket:
required: false description:
default: false - The C(socket) argument controls the operating state of the UNIX
choices: Domain Socket used to receive eAPI requests. When the value
- yes of this argument is set to True, the UDS will listen for eAPI
- no requests. When the value is set to False, the UDS will not be
aliases: available to handle requests. By default when eAPI is first
- enable_socket configured, the UDS is disabled.
required: false
default: false
choices: ['yes', 'no']
aliases: ['enable_socket']
vrf:
description:
- The C(vrf) argument will configure eAPI to listen for connections
in the specified VRF. By default, eAPI transports will listen
for connections in the global table. This value requires the
VRF to already be created otherwise the task will fail.
required: false
default: default
version_added: "2.2"
qos:
description:
- The C(qos) argument configures the IP DSCP value to assign to
eAPI response packets. This argument accepts integer values
in the valid IP DSCP range of 0 to 63.
required: false
default: 0
version_added: "2.2"
config:
description:
- The module, by default, will connect to the remote device and
retrieve the current running-config to use as a base for comparing
against the contents of source. There are times when it is not
desirable to have the task get the current running-config for
every task in a playbook. The I(config) argument allows the
implementer to pass in the configuration to use as the base
config for comparison.
required: false
default: nul
version_added: "2.2"
state:
description:
- The C(state) argument controls the operational state of eAPI
on the remote device. When this argument is set to C(started),
eAPI is enabled to receive requests and when this argument is
C(stopped), eAPI is disabled and will not receive requests.
required: false
default: started
choices: ['started', 'stopped']
""" """
EXAMPLES = """ EXAMPLES = """
- name: Enable eAPI access with default configuration # Note: examples below use the following provider dict to handle
eos_eapi: # transport and authentication to the node.
state: started vars:
provider: {{ provider }} cli:
host: "{{ inventory_hostname }}"
- name: Enable eAPI with no HTTP, HTTPS at port 9443, local HTTP at port 80, and socket enabled username: admin
eos_eapi: password: admin
state: started
http: false - name: Enable eAPI access with default configuration
https_port: 9443 eos_eapi:
local_http: yes state: started
local_http_port: 80 provider: {{ cli }}
socket: yes
provider: {{ provider }} - name: Enable eAPI with no HTTP, HTTPS at port 9443, local HTTP at port 80, and socket enabled
eos_eapi:
- name: Shutdown eAPI access state: started
eos_eapi: http: false
state: stopped https_port: 9443
provider: {{ provider }} local_http: yes
local_http_port: 80
socket: yes
provider: {{ cli }}
- name: Shutdown eAPI access
eos_eapi:
state: stopped
provider: {{ cli }}
""" """
RETURN = """ RETURN = """
changed: updates:
description: description:
- Indicates if commands were sent to the device. - Set of commands to be executed on remote device
returned: always returned: always
type: boolean type: list
sample: false sample: ['management api http-commands', 'shutdown']
urls:
commands: description: Hash of URL endpoints eAPI is listening on per interface
description: returned: when eAPI is started
- Set of commands to be executed on remote device type: dict
returned: always sample: {'Management1': ['http://172.26.10.1:80']}
type: list
sample: [
'management api http-commands',
'shutdown'
]
_config:
description:
- Configuration found on the device prior to executing any commands.
returned: always
type: object
sample: {...}
""" """
import re
import time
def http_commands(protocol, port, enable, config):
from ansible.module_utils.netcfg import NetworkConfig, dumps
started_config = config['{0}Server'.format(protocol)] from ansible.module_utils.eos import NetworkModule, NetworkError
commands = [] from ansible.module_utils.basic import get_exception
changed = False
PRIVATE_KEYS_RE = re.compile('__.+__')
if started_config.get('running'):
if not enable:
# turn off server def invoke(name, *args, **kwargs):
commands.append('no protocol {0}'.format(protocol)) func = globals().get(name)
changed = True if func:
elif started_config.get('port') != port: return func(*args, **kwargs)
# update the port
commands.append('protocol {0} port {1}'.format(protocol, port)) def started(module, commands):
changed = True commands.append('no shutdown')
elif not started_config.get('running') and enable: setters = set()
# turn on server for key, value in module.argument_spec.iteritems():
commands.append('protocol {0} port {1}'.format(protocol, port)) if module.params[key] is not None:
changed = True setter = value.get('setter') or 'set_%s' % key
if setter not in setters:
return commands, changed setters.add(setter)
invoke(setter, module, commands)
def execute_commands(module, commands): def stopped(module, commands):
commands.append('shutdown')
if not module.params.get('check_mode'):
module.configure(commands) def set_protocol_http(module, commands):
port = module.params['http_port']
if not 1 <= port <= 65535:
def config_server(module): module.fail_json(msg='http_port must be between 1 and 65535')
elif module.params['http'] is True:
state = module.params.get('state') commands.append('protocol http port %s' % port)
local_http_port = module.params.get('local_http_port') elif module.params['http'] is False:
socket= module.params.get('socket') commands.append('no protocol http')
local_http = module.params.get('local_http')
config = module.from_json(module.execute(['show management api http-commands | json'])[0]) def set_protocol_https(module, commands):
result = dict(changed=False, _config=config, commands=[]) port = module.params['https_port']
commands = [ if not 1 <= port <= 65535:
'management api http-commands' module.fail_json(msg='https_port must be between 1 and 65535')
] elif module.params['https'] is True:
commands.append('protocol https port %s' % port)
if not config.get('enabled'): elif module.params['https'] is False:
if state == 'started': commands.append('no protocol https')
# turn on eAPI access
commands.append('no shutdown') def set_local_http(module, commands):
result['changed'] = True port = module.params['local_http_port']
else: if not 1 <= port <= 65535:
# state is stopped. nothing to do module.fail_json(msg='local_http_port must be between 1 and 65535')
return result elif module.params['local_http'] is True:
commands.append('protocol http localhost port %s' % port)
if config.get('enabled') and state == 'stopped': elif module.params['local_http'] is False:
# turn off eAPI access and exit commands.append('no protocol http localhost port 8080')
commands.append('shutdown')
result['changed'] = True def set_socket(module, commands):
result['commands'] = commands if module.params['socket'] is True:
execute_commands(module, commands)
return result
# http and https
for protocol in ['http', 'https']:
cmds, chg = http_commands(protocol, module.params['{0}_port'.format(protocol)],
module.params['{0}'.format(protocol)], config)
if chg:
commands += cmds
result['changed'] = True
# local HTTP
if config.get('localHttpServer').get('running'):
if not local_http:
# turn off local http server
commands.append('no protocol http localhost')
result['changed'] = True
elif config.get('localHttpServer').get('port') != local_http_port:
# update the local http port
commands.append('protocol http localhost port {0}'.format(local_http_port))
result['changed'] = True
if not config.get('localHttpServer').get('running') and local_http:
# turn on local http server
commands.append('protocol http localhost port {0}'.format(local_http_port))
result['changed'] = True
# socket server
if config.get('unixSocketServer').get('running') and not socket:
# turn off unix socket
commands.append('no protocol unix-socket')
result['changed'] = True
if not config.get('unixSocketServer').get('running') and socket:
# turn on unix socket
commands.append('protocol unix-socket') commands.append('protocol unix-socket')
result['changed'] = True elif module.params['socket'] is False:
commands.append('no protocol unix-socket')
if len(commands) > 1:
# something requires change
execute_commands(module, commands)
result['commands'] = commands
return result def set_vrf(module, commands):
vrf = module.params['vrf']
if vrf != 'default':
resp = module.cli(['show vrf'])
if vrf not in resp[0]:
module.fail_json(msg="vrf '%s' is not configured" % vrf)
commands.append('vrf %s' % vrf)
def set_qos(module, commands):
if not 0 <= module.params['qos'] <= 63:
module.fail_json(msg='qos must be between 0 and 63')
commands.append('qos dscp %s' % module.params['qos'])
def get_config(module):
contents = module.params['config']
if not contents:
cmd = 'show running-config all section management api http-commands'
contents = module.cli([cmd])
config = NetworkConfig(indent=3, contents=contents[0])
return config
def load_config(module, commands, result):
session = 'ansible_%s' % int(time.time())
commit = not module.check_mode
diff = module.config.load_config(commands, session=session, commit=commit)
# once the configuration is done, remove the config session and
# remove the session name from the result
module.cli(['no configure session %s' % session])
result['diff'] = dict(prepared=diff)
result['changed'] = diff is not None
def load(module, commands, result):
candidate = NetworkConfig(indent=3)
candidate.add(commands, parents=['management api http-commands'])
config = get_config(module)
configobjs = candidate.difference(config)
if configobjs:
commands = dumps(configobjs, 'commands').split('\n')
result['updates'] = commands
load_config(module, commands, result)
def clean_result(result):
# strip out any keys that have two leading and two trailing
# underscore characters
for key in result.keys():
if PRIVATE_KEYS_RE.match(key):
del result[key]
def collect_facts(module, result):
resp = module.cli(['show management api http-commands'], output='json')
facts = dict(eos_eapi_urls=dict())
for each in resp[0]['urls']:
intf, url = each.split(' : ')
key = str(intf).strip()
if key not in facts['eos_eapi_urls']:
facts['eos_eapi_urls'][key] = list()
facts['eos_eapi_urls'][key].append(str(url).strip())
result['ansible_facts'] = facts
def check_version(module):
config = module.from_json(module.execute(['show version | json'])[0])
versions = config['version'].split('.')
if int(versions[0]) < 4 or int(versions[1]) < 12:
module.fail_json(msg="Device version {0} does not support eAPI. eAPI was introduced in EOS 4.12.")
def main(): def main():
""" main entry point for module execution """ main entry point for module execution
""" """
argument_spec = dict( argument_spec = dict(
state=dict(default='started', choices=['stopped','started']), http=dict(aliases=['enable_http'], default=False, type='bool', setter='set_protocol_http'),
http_port=dict(default=80, type='int'), http_port=dict(default=80, type='int', setter='set_protocol_http'),
https_port=dict(default=443, type='int'),
local_http_port=dict(default=8080, type='int'), https=dict(aliases=['enable_https'], default=True, type='bool', setter='set_protocol_https'),
http=dict(aliases=['enable_http'], default=True, type='bool'), https_port=dict(default=443, type='int', setter='set_protocol_https'),
https=dict(aliases=['enable_https'], default=True, type='bool'),
local_http=dict(aliases=['enable_local_http'], default=False, type='bool', setter='set_local_http'),
local_http_port=dict(default=8080, type='int', setter='set_local_http'),
socket=dict(aliases=['enable_socket'], default=False, type='bool'), socket=dict(aliases=['enable_socket'], default=False, type='bool'),
local_http=dict(aliases=['enable_local_http'], default=False, type='bool'),
vrf=dict(default='default'),
qos=dict(default=0, type='int'),
config=dict(),
# Only allow use of transport cli when configuring eAPI # Only allow use of transport cli when configuring eAPI
transport=dict(required=True, choices=['cli']) transport=dict(required=True, choices=['cli']),
state=dict(default='started', choices=['stopped', 'started']),
) )
module = get_module(argument_spec=argument_spec, module = NetworkModule(argument_spec=argument_spec,
supports_check_mode=True) connect_on_load=False,
supports_check_mode=True)
state = module.params['state']
warnings = list()
result = dict(changed=False, warnings=warnings)
check_version(module) commands = list()
invoke(state, module, commands)
result = config_server(module) try:
load(module, commands, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
return module.exit_json(**result) collect_facts(module, result)
clean_result(result)
module.exit_json(**result)
from ansible.module_utils.basic import *
from ansible.module_utils.shell import *
from ansible.module_utils.eos import *
if __name__ == '__main__': if __name__ == '__main__':
main() main()

Write Preview
Loading…
Cancel
Save