def main():
spec = dict(
src=dict(type='path', required=True, aliases=['package']),
version=dict(),
reboot=dict(type='bool', default=True),
no_copy=dict(default=False, type='bool'),
force=dict(type='bool', default=False),
transport=dict(default='netconf', choices=['netconf'])
)
module = NetworkModule(argument_spec=spec,
supports_check_mode=True)
if not HAS_SW:
module.fail_json(msg='Missing jnpr.junos.utils.sw module')
result = dict(changed=False)
do_upgrade = module.params['force'] or False
if not module.params['force']:
has_ver = module.connection.get_facts().get('version')
wants_ver = module.params['version']
do_upgrade = has_ver != wants_ver
if do_upgrade:
if not module.check_mode:
install_package(module)
result['changed'] = True
module.exit_json(**result)
def main():
""" Main entry point for AnsibleModule
"""
spec = dict(
config=dict(type='bool'),
config_format=dict(default='text', choices=['xml', 'text']),
transport=dict(default='netconf', choices=['netconf'])
)
module = NetworkModule(argument_spec=spec,
supports_check_mode=True)
result = dict(changed=False)
facts = module.connection.get_facts()
if '2RE' in facts:
facts['has_2RE'] = facts['2RE']
del facts['2RE']
facts['version_info'] = dict(facts['version_info'])
if module.params['config'] is True:
config_format = module.params['config_format']
resp_config = module.config.get_config(config_format=config_format)
if config_format in ['text']:
facts['config'] = resp_config
elif config_format == "xml":
facts['config'] = xml_to_string(resp_config)
facts['config_json'] = xml_to_json(resp_config)
result['ansible_facts'] = facts
module.exit_json(**result)
def main():
spec = dict(
commands=dict(type='list', required=True),
wait_for=dict(type='list'),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int')
)
module = NetworkModule(argument_spec=spec,
connect_on_load=False,
supports_check_mode=True)
commands = module.params['commands']
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
for cmd in commands:
if module.check_mode and not cmd.startswith('show'):
warnings.append('only show commands are supported when using '
'check mode, not executing `%s`' % cmd)
else:
if cmd.startswith('conf'):
module.fail_json(msg='dellos10_command does not support running '
'config mode commands. Please use '
'dellos10_config instead')
runner.add_command(cmd)
for item in conditionals:
runner.add_conditional(item)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc))
result = dict(changed=False)
result['stdout'] = list()
for cmd in commands:
try:
output = runner.get_command(cmd)
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(required=True),
force=dict(default=False, type='bool'),
include_defaults=dict(default=False, type='bool'),
backup=dict(default=False, type='bool'),
replace=dict(default=False, type='bool'),
config=dict()
)
mutually_exclusive = [('config', 'backup'), ('config', 'force')]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
replace = module.params['replace']
commands = list()
running = None
result = dict(changed=False)
candidate = NetworkConfig(contents=module.params['src'], indent=3)
if replace:
if module.params['transport'] == 'cli':
module.fail_json(msg='config replace is only supported over eapi')
commands = str(candidate).split('\n')
else:
contents = get_config(module)
if contents:
running = NetworkConfig(contents=contents, indent=3)
result['_backup'] = contents
if not module.params['force']:
commands = candidate.difference((running or list()))
commands = dumps(commands, 'commands').split('\n')
commands = [str(c) for c in commands if c]
else:
commands = str(candidate).split('\n')
commands = filter_exit(commands)
if commands:
if not module.check_mode:
response = module.config.load_config(commands, replace=replace,
commit=True)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
http=dict(aliases=['enable_http'], default=False, type='bool', setter='set_protocol_http'),
http_port=dict(default=80, type='int', setter='set_protocol_http'),
https=dict(aliases=['enable_https'], default=True, type='bool', setter='set_protocol_https'),
https_port=dict(default=443, type='int', setter='set_protocol_https'),
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'),
vrf=dict(default='default'),
config=dict(),
# Only allow use of transport cli when configuring eAPI
transport=dict(default='cli', choices=['cli']),
state=dict(default='started', choices=['stopped', 'started']),
)
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
supports_check_mode=True)
state = module.params['state']
result = dict(changed=False)
commands = list()
instance = get_instance(module)
invoke(state, module, instance, commands)
try:
load(module, instance, commands, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
collect_facts(module, result)
clean_result(result)
module.exit_json(**result)
def main():
spec = dict(gather_subset=dict(default=["!config"], type="list"))
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params["gather_subset"]
runable_subsets = set()
exclude_subsets = set()
for subset in gather_subset:
if subset == "all":
runable_subsets.update(VALID_SUBSETS)
continue
if subset.startswith("!"):
subset = subset[1:]
if subset == "all":
exclude_subsets.update(VALID_SUBSETS)
continue
exclude = True
else:
exclude = False
if subset not in VALID_SUBSETS:
module.fail_json(msg="Bad subset")
if exclude:
exclude_subsets.add(subset)
else:
runable_subsets.add(subset)
if not runable_subsets:
runable_subsets.update(VALID_SUBSETS)
runable_subsets.difference_update(exclude_subsets)
runable_subsets.add("default")
facts = dict()
facts["gather_subset"] = list(runable_subsets)
runner = CommandRunner(module)
instances = list()
for key in runable_subsets:
instances.append(FACT_SUBSETS[key](runner))
runner.run()
try:
for inst in instances:
inst.populate()
facts.update(inst.facts)
except Exception:
module.exit_json(out=module.from_json(runner.items))
ansible_facts = dict()
for key, value in facts.items():
key = "ansible_net_%s" % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts)
def main():
argument_spec = dict(
lines=dict(aliases=['commands'], required=True, type='list'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(default='line', choices=['line', 'strict', 'exact']),
replace=dict(default='line', choices=['line', 'block']),
force=dict(default=False, type='bool'),
config=dict()
)
module = NetworkModule(argument_spec=argument_spec,
supports_check_mode=True)
lines = module.params['lines']
before = module.params['before']
after = module.params['after']
match = module.params['match']
replace = module.params['replace']
result = dict(changed=False)
candidate = NetworkConfig(indent=1)
candidate.add(lines)
acl_name = parse_acl_name(module)
if not module.params['force']:
contents = get_config(module, acl_name)
config = NetworkConfig(indent=1, contents=contents)
commands = candidate.difference(config)
commands = dumps(commands, 'commands').split('\n')
commands = [str(c) for c in commands if c]
else:
commands = str(candidate).split('\n')
if commands:
if not module.check_mode:
response = module.config(commands)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(type='path'),
lines=dict(aliases=['commands'], type='list'),
parents=dict(type='list'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(default='line', choices=['line', 'strict', 'exact', 'none']),
replace=dict(default='line', choices=['line', 'block']),
config=dict(),
defaults=dict(type='bool', default=False),
passwords=dict(type='bool', default=False),
backup=dict(type='bool', default=False),
save=dict(type='bool', default=False),
)
mutually_exclusive = [('lines', 'src'), ('defaults', 'passwords')]
required_if = [('match', 'strict', ['lines']),
('match', 'exact', ['lines']),
('replace', 'block', ['lines'])]
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
mutually_exclusive=mutually_exclusive,
required_if=required_if,
supports_check_mode=True)
result = dict(changed=False)
if module.params['backup']:
result['__backup__'] = module.config.get_config()
try:
run(module, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
lines=dict(type='list'),
src=dict(type='path'),
src_format=dict(choices=['xml', 'text', 'set', 'json']),
# update operations
replace=dict(default=False, type='bool'),
confirm=dict(default=0, type='int'),
comment=dict(default=DEFAULT_COMMENT),
# config operations
backup=dict(type='bool', default=False),
rollback=dict(type='int'),
zeroize=dict(default=False, type='bool'),
transport=dict(default='netconf', choices=['netconf'])
)
mutually_exclusive = [('lines', 'rollback'), ('lines', 'zeroize'),
('rollback', 'zeroize'), ('lines', 'src'),
('src', 'zeroize'), ('src', 'rollback')]
required_if = [('replace', True, ['src'])]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
required_if=required_if,
supports_check_mode=True)
result = dict(changed=False)
if module.params['backup']:
result['__backup__'] = module.config.get_config()
try:
run(module, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(),
force=dict(default=False, type='bool'),
include_defaults=dict(default=True, type='bool'),
backup=dict(default=False, type='bool'),
config=dict(),
)
mutually_exclusive = [('config', 'backup'), ('config', 'force')]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
result = dict(changed=False)
candidate = NetworkConfig(contents=module.params['src'], indent=2)
contents = get_config(module)
if contents:
config = NetworkConfig(contents=contents, indent=2)
result['_backup'] = str(contents)
if not module.params['force']:
commands = candidate.difference(config)
commands = dumps(commands, 'commands').split('\n')
commands = [str(c) for c in commands if c]
else:
commands = str(candidate).split('\n')
if commands:
if not module.check_mode:
response = module.config(commands)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(),
force=dict(default=False, type='bool'),
backup=dict(default=False, type='bool'),
config=dict(),
)
mutually_exclusive = [('config', 'backup'), ('config', 'force')]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
result = dict(changed=False)
candidate = Dellos6NetworkConfig(contents=module.params['src'], indent=0)
contents = get_config(module)
if contents:
config = Dellos6NetworkConfig(contents=contents[0], indent=0)
result['_backup'] = contents[0]
commands = list()
if not module.params['force']:
commands = dumps(candidate.difference(config), 'commands')
else:
commands = str(candidate)
if commands:
commands = commands.split('\n')
if not module.check_mode:
response = module.config(commands)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(type='path'),
lines=dict(aliases=['commands'], type='list'),
parents=dict(type='list'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(default='line', choices=['line', 'strict', 'exact',
'none']),
replace=dict(default='line', choices=['line', 'block']),
# this argument is deprecated in favor of setting match: none
# it will be removed in a future version
force=dict(default=False, type='bool'),
config=dict(),
defaults=dict(type='bool', default=False),
backup=dict(type='bool', default=False),
save=dict(type='bool', default=False),
)
mutually_exclusive = [('lines', 'src')]
required_if = [('match', 'strict', ['lines']),
('match', 'exact', ['lines']),
('replace', 'block', ['lines'])]
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
mutually_exclusive=mutually_exclusive,
required_if=required_if,
supports_check_mode=True)
if module.params['force'] is True:
module.params['match'] = 'none'
warnings = list()
check_args(module, warnings)
result = dict(changed=False, warnings=warnings)
if module.params['backup']:
result['__backup__'] = module.config.get_config()
try:
run(module, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
module.exit_json(**result)
def __init__(self, **kwargs):
""" Class init """
# module
argument_spec = kwargs["argument_spec"]
self.spec = argument_spec
self.module = NetworkModule(
argument_spec=self.spec, connect_on_load=False, supports_check_mode=True)
# config
self.cur_cfg = dict()
# module args
self.state = self.module.params['state']
self.contact = self.module.params['contact']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
def main():
argument_spec = dict(
src=dict(required=True, type='path'),
confirm=dict(default=0, type='int'),
comment=dict(default=DEFAULT_COMMENT),
action=dict(default='merge', choices=['merge', 'overwrite', 'replace']),
config_format=dict(choices=['text', 'set', 'xml']),
backup=dict(default=False, type='bool'),
transport=dict(default='netconf', choices=['netconf'])
)
module = NetworkModule(argument_spec=argument_spec,
supports_check_mode=True)
comment = module.params['comment']
confirm = module.params['confirm']
commit = not module.check_mode
replace = False
overwrite = False
action = module.params['action']
if action == 'overwrite':
overwrite = True
elif action == 'replace':
replace = True
src = module.params['src']
fmt = module.params['config_format']
if action == 'overwrite' and fmt == 'set':
module.fail_json(msg="overwrite cannot be used when format is "
"set per junos-pyez documentation")
results = dict(changed=False)
results['_backup'] = unicode(module.config.get_config()).strip()
try:
diff = module.config.load_config(src, commit=commit, replace=replace,
confirm=confirm, comment=comment, config_format=fmt)
if diff:
results['changed'] = True
results['diff'] = dict(prepared=diff)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
module.exit_json(**results)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(required=True),
force=dict(default=False, type='bool'),
include_defaults=dict(default=False, type='bool'),
backup=dict(default=False, type='bool'),
replace=dict(default=False, type='bool'),
config=dict()
)
mutually_exclusive = [('config', 'backup'), ('config', 'force')]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
replace = module.params['replace']
commands = list()
running = None
result = dict(changed=False)
candidate = NetworkConfig(contents=module.params['src'], indent=3)
if replace:
if module.params['transport'] == 'cli':
module.fail_json(msg='config replace is only supported over eapi')
commands = str(candidate).split('\n')
else:
contents = get_config(module)
if contents:
running = NetworkConfig(contents=contents, indent=3)
result['_backup'] = contents
if not module.params['force']:
commands = candidate.difference((running or list()))
commands = dumps(commands, 'commands').split('\n')
commands = [str(c) for c in commands if c]
else:
commands = str(candidate).split('\n')
commands = filter_exit(commands)
if commands:
if not module.check_mode:
response = module.config.load_config(commands, replace=replace,
commit=True)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
http=dict(aliases=['enable_http'],
default=False,
type='bool',
setter='set_protocol_http'),
http_port=dict(default=80, type='int', setter='set_protocol_http'),
https=dict(aliases=['enable_https'],
default=True,
type='bool',
setter='set_protocol_https'),
https_port=dict(default=443, type='int', setter='set_protocol_https'),
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'),
vrf=dict(default='default'),
config=dict(),
# Only allow use of transport cli when configuring eAPI
transport=dict(default='cli', choices=['cli']),
state=dict(default='started', choices=['stopped', 'started']),
)
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
supports_check_mode=True)
state = module.params['state']
result = dict(changed=False)
commands = list()
instance = get_instance(module)
invoke(state, module, instance, commands)
try:
load(module, instance, commands, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
collect_facts(module, result)
clean_result(result)
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(type='path'),
lines=dict(aliases=['commands'], type='list'),
parents=dict(type='list'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(default='line', choices=['line', 'strict', 'exact',
'none']),
replace=dict(default='line', choices=['line', 'block']),
config=dict(),
defaults=dict(type='bool', default=False),
backup=dict(type='bool', default=False),
save=dict(type='bool', default=False),
)
mutually_exclusive = [('lines', 'src')]
required_if = [('match', 'strict', ['lines']),
('match', 'exact', ['lines']),
('replace', 'block', ['lines'])]
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
mutually_exclusive=mutually_exclusive,
required_if=required_if,
supports_check_mode=True)
warnings = list()
result = dict(changed=False, warnings=warnings)
if module.params['backup']:
result['__backup__'] = module.config.get_config()
try:
run(module, result)
except NetworkError:
exc = get_exception()
config_fail(module, msg=get_cli_exception(exc), **exc.kwargs)
config_exit(module, **result)
def main():
"""main entry point for module execution
"""
argument_spec = dict(netconf_port=dict(type='int',
default=830,
aliases=['listens_on']),
state=dict(default='present',
choices=['present', 'absent']),
transport=dict(default='cli', choices=['cli']))
module = NetworkModule(argument_spec=argument_spec,
supports_check_mode=True)
state = module.params['state']
port = module.params['netconf_port']
result = dict(changed=False)
instance = get_instance(module)
if state == 'present' and instance.get('state') == 'absent':
commands = 'set system services netconf ssh port %s' % port
elif state == 'present' and port != instance.get('port'):
commands = 'set system services netconf ssh port %s' % port
elif state == 'absent' and instance.get('state') == 'present':
commands = 'delete system services netconf'
else:
commands = None
if commands:
if not module.check_mode:
try:
comment = 'configuration updated by junos_netconf'
module.config(commands, comment=comment)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
result['changed'] = True
result['commands'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
lines=dict(type='list'),
src=dict(type='path'),
src_format=dict(choices=['xml', 'text', 'set', 'json']),
# update operations
update=dict(default='merge', choices=['merge', 'overwrite', 'replace']),
replace=dict(default=False, type='bool'),
confirm=dict(default=0, type='int'),
comment=dict(default=DEFAULT_COMMENT),
# config operations
backup=dict(type='bool', default=False),
rollback=dict(type='int'),
zeroize=dict(default=False, type='bool'),
transport=dict(default='netconf', choices=['netconf'])
)
mutually_exclusive = [('lines', 'rollback'), ('lines', 'zeroize'),
('rollback', 'zeroize'), ('lines', 'src'),
('src', 'zeroize'), ('src', 'rollback'),
('update', 'replace')]
required_if = [('replace', True, ['src']),
('update', 'merge', ['src', 'lines'], True),
('update', 'overwrite', ['src', 'lines'], True),
('update', 'replace', ['src', 'lines'], True)]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
required_if=required_if,
supports_check_mode=True)
result = dict(changed=False)
if module.params['backup']:
result['__backup__'] = module.config.get_config()
try:
run(module, result)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
module.exit_json(**result)
def main():
argument_spec = dict(lines=dict(aliases=['commands'],
required=True,
type='list'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(default='line',
choices=['line', 'strict', 'exact']),
replace=dict(default='line',
choices=['line', 'block']),
force=dict(default=False, type='bool'),
config=dict())
module = NetworkModule(argument_spec=argument_spec,
supports_check_mode=True)
lines = module.params['lines']
before = module.params['before']
after = module.params['after']
match = module.params['match']
replace = module.params['replace']
candidate = NetworkConfig(indent=1)
candidate.add(lines)
module.filter = check_input_acl(lines, module)
if not module.params['force']:
contents = get_config(module)
config = NetworkConfig(indent=1, contents=contents)
commands = candidate.difference(config)
commands = dumps(commands, 'commands').split('\n')
else:
commands = str(candidate).split('\n')
if commands:
if not module.check_mode:
commands = [str(c) for c in commands if c]
response = module.config(commands)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
"""main entry point for module execution
"""
argument_spec = dict(
netconf_port=dict(type='int', default=830, aliases=['listens_on']),
state=dict(default='present', choices=['present', 'absent']),
transport=dict(default='cli', choices=['cli'])
)
module = NetworkModule(argument_spec=argument_spec,
supports_check_mode=True)
state = module.params['state']
port = module.params['netconf_port']
result = dict(changed=False)
instance = get_instance(module)
if state == 'present' and instance.get('state') == 'absent':
commands = 'set system services netconf ssh port %s' % port
elif state == 'present' and port != instance.get('port'):
commands = 'set system services netconf ssh port %s' % port
elif state == 'absent' and instance.get('state') == 'present':
commands = 'delete system services netconf'
else:
commands = None
if commands:
if not module.check_mode:
try:
comment = 'configuration updated by junos_netconf'
module.config(commands, comment=comment)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
result['changed'] = True
result['commands'] = commands
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(type='str'),
force=dict(default=False, type='bool'),
backup=dict(default=False, type='bool'),
config=dict(type='dict'),
)
mutually_exclusive = [('config', 'backup'), ('config', 'force')]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
if not module.params['transport'] and not HAS_OPS:
module.fail_json(msg='unable to import ops.dc library')
result = dict(changed=False)
contents = get_config(module)
result['_backup'] = contents
if module.params['transport'] in ['ssh', 'rest']:
config = contents
try:
src = module.from_json(module.params['src'])
except ValueError:
module.fail_json(
msg='unable to load src due to json parsing error')
changeset = diff(src, config)
candidate = merge(changeset, config)
updates = dict()
for path, key, new_value, old_value in changeset:
path = '%s.%s' % ('.'.join(path), key)
updates[path] = str(new_value)
result['updates'] = updates
if changeset:
if not module.check_mode:
module.config(config)
result['changed'] = True
else:
candidate = NetworkConfig(contents=module.params['src'], indent=4)
if contents:
config = NetworkConfig(contents=contents, indent=4)
if not module.params['force']:
commands = candidate.difference(config)
commands = dumps(commands, 'commands').split('\n')
commands = [str(c) for c in commands if c]
else:
commands = str(candidate).split('\n')
if commands:
if not module.check_mode:
response = module.config(commands)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
class EthTrunk(object):
"""
Manages Eth-Trunk interfaces.
"""
def __init__(self, argument_spec):
self.spec = argument_spec
self.module = None
self.netconf = None
self.__init_module__()
# module input info
self.trunk_id = self.module.params['trunk_id']
self.mode = self.module.params['mode']
self.min_links = self.module.params['min_links']
self.hash_type = self.module.params['hash_type']
self.members = self.module.params['members']
self.state = self.module.params['state']
self.force = self.module.params['force']
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.port = self.module.params['port']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
# interface info
self.trunk_info = dict()
# init netconf connect
self.__init_netconf__()
def __init_module__(self):
""" init module """
self.module = NetworkModule(
argument_spec=self.spec, supports_check_mode=True)
def __init_netconf__(self):
""" init netconf """
if not HAS_NCCLIENT:
raise Exception("the ncclient library is required")
self.netconf = get_netconf(host=self.host,
port=self.port,
username=self.username,
password=self.module.params['password'])
if not self.netconf:
self.module.fail_json(msg='Error: netconf init failed')
def check_response(self, con_obj, xml_name):
"""Check if response message is already succeed."""
xml_str = con_obj.xml
if "<ok/>" not in xml_str:
self.module.fail_json(msg='Error: %s failed.' % xml_name)
def netconf_get_config(self, xml_str):
""" netconf get config """
try:
con_obj = self.netconf.get_config(filter=xml_str)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' % err.message.replace("\r\n", ""))
return con_obj
def netconf_set_config(self, xml_str, xml_name):
""" netconf set config """
try:
con_obj = self.netconf.set_config(config=xml_str)
self.check_response(con_obj, xml_name)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' % err.message.replace("\r\n", ""))
return con_obj
def netconf_set_action(self, xml_str, xml_name):
""" netconf set config """
try:
con_obj = self.netconf.execute_action(action=xml_str)
self.check_response(con_obj, xml_name)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' % err.message.replace("\r\n", ""))
return con_obj
def get_trunk_dict(self, trunk_id):
""" get one interface attributes dict."""
trunk_info = dict()
conf_str = CE_NC_GET_TRUNK % trunk_id
con_obj = self.netconf_get_config(conf_str)
if "<data/>" in con_obj.xml:
return trunk_info
# get trunk base info
base = re.findall(
r'.*<ifName>(.*)</ifName>.*\s*'
r'<minUpNum>(.*)</minUpNum>.*\s*'
r'<maxUpNum>(.*)</maxUpNum>.*\s*'
r'<trunkType>(.*)</trunkType>.*\s*'
r'<hashType>(.*)</hashType>.*\s*'
r'<workMode>(.*)</workMode>.*\s*'
r'<upMemberIfNum>(.*)</upMemberIfNum>.*\s*'
r'<memberIfNum>(.*)</memberIfNum>.*', con_obj.xml)
if base:
trunk_info = dict(ifName=base[0][0],
trunkId=base[0][0].lower().replace("eth-trunk", "").replace(" ", ""),
minUpNum=base[0][1],
maxUpNum=base[0][2],
trunkType=base[0][3],
hashType=base[0][4],
workMode=base[0][5],
upMemberIfNum=base[0][6],
memberIfNum=base[0][7])
# get trunk member interface info
member = re.findall(
r'.*<memberIfName>(.*)</memberIfName>.*\s*'
r'<memberIfState>(.*)</memberIfState>.*', con_obj.xml)
trunk_info["TrunkMemberIfs"] = list()
for mem in member:
trunk_info["TrunkMemberIfs"].append(
dict(memberIfName=mem[0], memberIfState=mem[1]))
return trunk_info
def is_member_exist(self, ifname):
"""is trunk member exist"""
if not self.trunk_info["TrunkMemberIfs"]:
return False
for mem in self.trunk_info["TrunkMemberIfs"]:
if ifname.replace(" ", "").upper() == mem["memberIfName"].replace(" ", "").upper():
return True
return False
def get_mode_xml_str(self):
"""trunk mode netconf xml fromat string"""
return MODE_CLI2XML.get(self.mode)
def get_hash_type_xml_str(self):
"""trunk hash type netconf xml format string"""
return HASH_CLI2XML.get(self.hash_type)
def create_eth_trunk(self):
"""Create Eth-Trunk interface"""
xml_str = CE_NC_XML_CREATE_TRUNK % self.trunk_id
self.updates_cmd.append("interface Eth-Trunk %s" % self.trunk_id)
if self.hash_type:
self.updates_cmd.append("load-balance %s" % self.hash_type)
xml_str += CE_NC_XML_MERGE_HASHTYPE % (self.trunk_id, self.get_hash_type_xml_str())
if self.mode:
self.updates_cmd.append("mode %s" % self.mode)
xml_str += CE_NC_XML_MERGE_WORKMODE % (self.trunk_id, self.get_mode_xml_str())
if self.min_links:
self.updates_cmd.append("least active-linknumber %s" % self.min_links)
xml_str += CE_NC_XML_MERGE_MINUPNUM % (self.trunk_id, self.min_links)
if self.members:
mem_xml = ""
for mem in self.members:
mem_xml += CE_NC_XML_MERGE_MEMBER % mem.upper()
self.updates_cmd.append("interface %s" % mem)
self.updates_cmd.append("eth-trunk %s" % self.trunk_id)
xml_str += CE_NC_XML_BUILD_MEMBER_CFG % (self.trunk_id, mem_xml)
cfg_xml = CE_NC_XML_BUILD_TRUNK_CFG % xml_str
self.netconf_set_config(cfg_xml, "CREATE_TRUNK")
self.changed = True
def delete_eth_trunk(self):
"""Delete Eth-Trunk interface and remove all member"""
if not self.trunk_info:
return
xml_str = ""
mem_str = ""
if self.trunk_info["TrunkMemberIfs"]:
for mem in self.trunk_info["TrunkMemberIfs"]:
mem_str += CE_NC_XML_DELETE_MEMBER % mem["memberIfName"]
self.updates_cmd.append("interface %s" % mem["memberIfName"])
self.updates_cmd.append("undo eth-trunk")
if mem_str:
xml_str += CE_NC_XML_BUILD_MEMBER_CFG % (self.trunk_id, mem_str)
xml_str += CE_NC_XML_DELETE_TRUNK % self.trunk_id
self.updates_cmd.append("undo interface Eth-Trunk %s" % self.trunk_id)
cfg_xml = CE_NC_XML_BUILD_TRUNK_CFG % xml_str
self.netconf_set_config(cfg_xml, "DELETE_TRUNK")
self.changed = True
def remove_member(self):
"""delete trunk member"""
if not self.members:
return
change = False
mem_xml = ""
xml_str = ""
for mem in self.members:
if self.is_member_exist(mem):
mem_xml += CE_NC_XML_DELETE_MEMBER % mem.upper()
self.updates_cmd.append("interface %s" % mem)
self.updates_cmd.append("undo eth-trunk")
if mem_xml:
xml_str += CE_NC_XML_BUILD_MEMBER_CFG % (self.trunk_id, mem_xml)
change = True
if not change:
return
cfg_xml = CE_NC_XML_BUILD_TRUNK_CFG % xml_str
self.netconf_set_config(cfg_xml, "REMOVE_TRUNK_MEMBER")
self.changed = True
def merge_eth_trunk(self):
"""Create or merge Eth-Trunk"""
change = False
xml_str = ""
self.updates_cmd.append("interface Eth-Trunk %s" % self.trunk_id)
if self.hash_type and self.get_hash_type_xml_str() != self.trunk_info["hashType"]:
self.updates_cmd.append("load-balance %s" %
self.hash_type)
xml_str += CE_NC_XML_MERGE_HASHTYPE % (
self.trunk_id, self.get_hash_type_xml_str())
change = True
if self.min_links and self.min_links != self.trunk_info["minUpNum"]:
self.updates_cmd.append(
"least active-linknumber %s" % self.min_links)
xml_str += CE_NC_XML_MERGE_MINUPNUM % (
self.trunk_id, self.min_links)
change = True
if self.mode and self.get_mode_xml_str() != self.trunk_info["workMode"]:
self.updates_cmd.append("mode %s" % self.mode)
xml_str += CE_NC_XML_MERGE_WORKMODE % (
self.trunk_id, self.get_mode_xml_str())
change = True
if not change:
self.updates_cmd.pop() # remove 'interface Eth-Trunk' command
# deal force:
# When true it forces Eth-Trunk members to match
# what is declared in the members param.
if self.force == "true" and self.trunk_info["TrunkMemberIfs"]:
mem_xml = ""
for mem in self.trunk_info["TrunkMemberIfs"]:
if not self.members or mem["memberIfName"].replace(" ", "").upper() not in self.members:
mem_xml += CE_NC_XML_DELETE_MEMBER % mem["memberIfName"]
self.updates_cmd.append("interface %s" % mem["memberIfName"])
self.updates_cmd.append("undo eth-trunk")
if mem_xml:
xml_str += CE_NC_XML_BUILD_MEMBER_CFG % (self.trunk_id, mem_xml)
change = True
if self.members:
mem_xml = ""
for mem in self.members:
if not self.is_member_exist(mem):
mem_xml += CE_NC_XML_MERGE_MEMBER % mem.upper()
self.updates_cmd.append("interface %s" % mem)
self.updates_cmd.append("eth-trunk %s" % self.trunk_id)
if mem_xml:
xml_str += CE_NC_XML_BUILD_MEMBER_CFG % (
self.trunk_id, mem_xml)
change = True
if not change:
return
cfg_xml = CE_NC_XML_BUILD_TRUNK_CFG % xml_str
self.netconf_set_config(cfg_xml, "MERGE_TRUNK")
self.changed = True
def check_params(self):
"""Check all input params"""
# trunk_id check
if not self.trunk_id.isdigit():
self.module.fail_json(msg='The parameter of trunk_id is invalid.')
# min_links check
if self.min_links and not self.min_links.isdigit():
self.module.fail_json(msg='The parameter of min_links is invalid.')
# members check and convert members to upper
if self.members:
for mem in self.members:
if not get_interface_type(mem.replace(" ", "")):
self.module.fail_json(
msg='The parameter of members is invalid.')
for mem_id in range(len(self.members)):
self.members[mem_id] = self.members[mem_id].replace(" ", "").upper()
def get_proposed(self):
"""get proposed info"""
self.proposed["trunk_id"] = self.trunk_id
self.proposed["mode"] = self.mode
if self.min_links:
self.proposed["min_links"] = self.min_links
self.proposed["hash_type"] = self.hash_type
if self.members:
self.proposed["members"] = self.members
self.proposed["state"] = self.state
self.proposed["force"] = self.force
def get_existing(self):
"""get existing info"""
if not self.trunk_info:
return
self.existing["trunk_id"] = self.trunk_info["trunkId"]
self.existing["min_links"] = self.trunk_info["minUpNum"]
self.existing["hash_type"] = hash_type_xml_to_cli_str(self.trunk_info["hashType"])
self.existing["mode"] = mode_xml_to_cli_str(self.trunk_info["workMode"])
self.existing["members_detail"] = self.trunk_info["TrunkMemberIfs"]
def get_end_state(self):
"""get end state info"""
trunk_info = self.get_trunk_dict(self.trunk_id)
if not trunk_info:
return
self.end_state["trunk_id"] = trunk_info["trunkId"]
self.end_state["min_links"] = trunk_info["minUpNum"]
self.end_state["hash_type"] = hash_type_xml_to_cli_str(trunk_info["hashType"])
self.end_state["mode"] = mode_xml_to_cli_str(trunk_info["workMode"])
self.end_state["members_detail"] = trunk_info["TrunkMemberIfs"]
def work(self):
"""worker"""
self.check_params()
self.trunk_info = self.get_trunk_dict(self.trunk_id)
self.get_existing()
self.get_proposed()
# deal present or absent
if self.state == "present":
if not self.trunk_info:
# create
self.create_eth_trunk()
else:
# merge trunk
self.merge_eth_trunk()
else:
if self.trunk_info:
if not self.members:
# remove all members and delete trunk
self.delete_eth_trunk()
else:
# remove some trunk members
self.remove_member()
else:
self.module.fail_json(msg='Error: Eth-Trunk does not exist.')
self.get_end_state()
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.module.exit_json(**self.results)
def init_module(self):
"""init module"""
self.module = NetworkModule(
argument_spec=self.spec, connect_on_load=False, supports_check_mode=True)
class VxlanArp(object):
"""
Manages arp attributes of VXLAN.
"""
def __init__(self, argument_spec):
self.spec = argument_spec
self.module = None
self.init_module()
# module input info
self.evn_bgp = self.module.params['evn_bgp']
self.evn_source_ip = self.module.params['evn_source_ip']
self.evn_peer_ip = self.module.params['evn_peer_ip']
self.evn_server = self.module.params['evn_server']
self.evn_reflect_client = self.module.params['evn_reflect_client']
self.vbdif_name = self.module.params['vbdif_name']
self.arp_collect_host = self.module.params['arp_collect_host']
self.host_collect_protocol = self.module.params[
'host_collect_protocol']
self.bridge_domain_id = self.module.params['bridge_domain_id']
self.arp_suppress = self.module.params['arp_suppress']
self.state = self.module.params['state']
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.port = self.module.params['port']
# state
self.config = "" # current config
self.changed = False
self.updates_cmd = list()
self.commands = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
def init_module(self):
"""init module"""
self.module = NetworkModule(
argument_spec=self.spec, connect_on_load=False, supports_check_mode=True)
def cli_load_config(self, commands):
"""load config by cli"""
if not self.module.check_mode:
try:
self.module.config.load_config(commands)
except NetworkError:
err = get_cli_exception()
self.module.fail_json(msg=err)
def get_current_config(self):
"""get current configuration"""
config = ""
exp = " | ignore-case section include evn bgp|host collect protocol bgp"
if self.vbdif_name:
exp += "|^interface %s$" % self.vbdif_name
if self.bridge_domain_id:
exp += "|^bridge-domain %s$" % self.bridge_domain_id
config = self.module.config.get_config(
include_defaults=False, regular=exp)
return config
def cli_add_command(self, command, undo=False):
"""add command to self.update_cmd and self.commands"""
if undo and command.lower() not in ["quit", "return"]:
cmd = "undo " + command
else:
cmd = command
self.commands.append(cmd) # set to device
if command.lower() not in ["quit", "return"]:
self.updates_cmd.append(cmd) # show updates result
def config_bridge_domain(self):
"""manage bridge domain configuration"""
if not self.bridge_domain_id:
return
# bridge-domain bd-id
# [undo] arp broadcast-suppress enable
cmd = "bridge-domain %s" % self.bridge_domain_id
if not is_config_exist(self.config, cmd):
self.module.fail_json(msg="Error: Bridge domain is not exist.")
cmd = "arp broadcast-suppress enable"
exist = is_config_exist(self.config, cmd)
if self.arp_suppress == "enable" and not exist:
self.cli_add_command("bridge-domain %s" % self.bridge_domain_id)
self.cli_add_command(cmd)
self.cli_add_command("quit")
elif self.arp_suppress == "disable" and exist:
self.cli_add_command("bridge-domain %s" % self.bridge_domain_id)
self.cli_add_command(cmd, undo=True)
self.cli_add_command("quit")
def config_evn_bgp(self):
"""enables EVN BGP and configure evn bgp command"""
evn_bgp_view = False
evn_bgp_enable = False
cmd = "evn bgp"
exist = is_config_exist(self.config, cmd)
if self.evn_bgp == "enable" or exist:
evn_bgp_enable = True
# [undo] evn bgp
if self.evn_bgp:
if self.evn_bgp == "enable" and not exist:
self.cli_add_command(cmd)
evn_bgp_view = True
elif self.evn_bgp == "disable" and exist:
self.cli_add_command(cmd, undo=True)
return
# [undo] source-address ip-address
if evn_bgp_enable and self.evn_source_ip:
cmd = "source-address %s" % self.evn_source_ip
exist = is_config_exist(self.config, cmd)
if self.state == "present" and not exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd)
elif self.state == "absent" and exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd, undo=True)
# [undo] peer ip-address
# [undo] peer ipv4-address reflect-client
if evn_bgp_enable and self.evn_peer_ip:
cmd = "peer %s" % self.evn_peer_ip
exist = is_config_exist(self.config, cmd)
if self.state == "present":
if not exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd)
if self.evn_reflect_client == "true":
self.cli_add_command(
"peer %s reflect-client" % self.evn_peer_ip)
else:
if self.evn_reflect_client:
cmd = "peer %s reflect-client" % self.evn_peer_ip
exist = is_config_exist(self.config, cmd)
if self.evn_reflect_client == "true" and not exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd)
elif self.evn_reflect_client == "false" and exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd, undo=True)
else:
if exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd, undo=True)
# [undo] server enable
if evn_bgp_enable and self.evn_server:
cmd = "server enable"
exist = is_config_exist(self.config, cmd)
if self.evn_server == "enable" and not exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd)
elif self.evn_server == "disable" and exist:
if not evn_bgp_view:
self.cli_add_command("evn bgp")
evn_bgp_view = True
self.cli_add_command(cmd, undo=True)
if evn_bgp_view:
self.cli_add_command("quit")
def config_vbdif(self):
"""configure command at the VBDIF interface view"""
# interface vbdif bd-id
# [undo] arp collect host enable
cmd = "interface %s" % self.vbdif_name.lower().capitalize()
exist = is_config_exist(self.config, cmd)
if not exist:
self.module.fail_json(
msg="Error: Interface %s is not exist." % self.vbdif_name)
cmd = "arp collect host enable"
exist = is_config_exist(self.config, cmd)
if self.arp_collect_host == "enable" and not exist:
self.cli_add_command("interface %s" %
self.vbdif_name.lower().capitalize())
self.cli_add_command(cmd)
self.cli_add_command("quit")
elif self.arp_collect_host == "disable" and exist:
self.cli_add_command("interface %s" %
self.vbdif_name.lower().capitalize())
self.cli_add_command(cmd, undo=True)
self.cli_add_command("quit")
def config_host_collect_protocal(self):
"""Enable EVN BGP or BGP EVPN to advertise host information"""
# [undo] host collect protocol bgp
cmd = "host collect protocol bgp"
exist = is_config_exist(self.config, cmd)
if self.state == "present":
if self.host_collect_protocol == "bgp" and not exist:
self.cli_add_command(cmd)
elif self.host_collect_protocol == "none" and exist:
self.cli_add_command(cmd, undo=True)
else:
if self.host_collect_protocol == "bgp" and exist:
self.cli_add_command(cmd, undo=True)
def is_valid_vbdif(self, ifname):
"""check is interface vbdif is valid"""
if not ifname.upper().startswith('VBDIF'):
return False
bdid = self.vbdif_name.replace(" ", "").upper().replace("VBDIF", "")
if not bdid.isdigit():
return False
if int(bdid) < 1 or int(bdid) > 16777215:
return False
return True
def check_params(self):
"""Check all input params"""
# bridge domain id check
if self.bridge_domain_id:
if not self.bridge_domain_id.isdigit():
self.module.fail_json(
msg="Error: Bridge domain id is not digit.")
if int(self.bridge_domain_id) < 1 or int(self.bridge_domain_id) > 16777215:
self.module.fail_json(
msg="Error: Bridge domain id is not in the range from 1 to 16777215.")
# evn_source_ip check
if self.evn_source_ip:
if not is_valid_v4addr(self.evn_source_ip):
self.module.fail_json(msg="Error: evn_source_ip is invalid.")
# evn_peer_ip check
if self.evn_peer_ip:
if not is_valid_v4addr(self.evn_peer_ip):
self.module.fail_json(msg="Error: evn_peer_ip is invalid.")
# vbdif_name check
if self.vbdif_name:
self.vbdif_name = self.vbdif_name.replace(
" ", "").lower().capitalize()
if not self.is_valid_vbdif(self.vbdif_name):
self.module.fail_json(msg="Error: vbdif_name is invalid.")
# vbdif_name and arp_collect_host must set at the same time
if bool(self.vbdif_name) != bool(self.arp_collect_host):
self.module.fail_json(
msg="Error: vbdif_name and arp_collect_host must set at the same time.")
# bridge_domain_id and arp_suppress must set at the same time
if bool(self.bridge_domain_id) != bool(self.arp_suppress):
self.module.fail_json(
msg="Error: bridge_domain_id and arp_suppress must set at the same time.")
# evn_reflect_client and evn_peer_ip must set at the same time
if self.evn_reflect_client and not self.evn_peer_ip:
self.module.fail_json(
msg="Error: evn_reflect_client and evn_peer_ip must set at the same time.")
# evn_server and evn_reflect_client can not set at the same time
if self.evn_server == "enable" and self.evn_reflect_client == "true":
self.module.fail_json(
msg="Error: evn_server and evn_reflect_client can not set at the same time.")
def get_proposed(self):
"""get proposed info"""
if self.evn_bgp:
self.proposed["evn_bgp"] = self.evn_bgp
if self.evn_source_ip:
self.proposed["evn_source_ip"] = self.evn_source_ip
if self.evn_peer_ip:
self.proposed["evn_peer_ip"] = self.evn_peer_ip
if self.evn_server:
self.proposed["evn_server"] = self.evn_server
if self.evn_reflect_client:
self.proposed["evn_reflect_client"] = self.evn_reflect_client
if self.arp_collect_host:
self.proposed["arp_collect_host"] = self.arp_collect_host
if self.host_collect_protocol:
self.proposed["host_collect_protocol"] = self.host_collect_protocol
if self.arp_suppress:
self.proposed["arp_suppress"] = self.arp_suppress
if self.vbdif_name:
self.proposed["vbdif_name"] = self.evn_peer_ip
if self.bridge_domain_id:
self.proposed["bridge_domain_id"] = self.bridge_domain_id
self.proposed["state"] = self.state
def get_existing(self):
"""get existing info"""
evn_bgp_exist = is_config_exist(self.config, "evn bgp")
if evn_bgp_exist:
self.existing["evn_bgp"] = "enable"
else:
self.existing["evn_bgp"] = "disable"
if evn_bgp_exist:
if is_config_exist(self.config, "server enable"):
self.existing["evn_server"] = "enable"
else:
self.existing["evn_server"] = "disable"
self.existing["evn_source_ip"] = get_evn_srouce(self.config)
self.existing["evn_peer_ip"] = get_evn_peers(self.config)
self.existing["evn_reflect_client"] = get_evn_reflect_client(
self.config)
if is_config_exist(self.config, "arp collect host enable"):
self.existing["host_collect_protocol"] = "enable"
else:
self.existing["host_collect_protocol"] = "disable"
if is_config_exist(self.config, "host collect protocol bgp"):
self.existing["host_collect_protocol"] = "bgp"
else:
self.existing["host_collect_protocol"] = None
if is_config_exist(self.config, "arp broadcast-suppress enable"):
self.existing["arp_suppress"] = "enable"
else:
self.existing["arp_suppress"] = "disable"
def get_end_state(self):
"""get end state info"""
config = self.get_current_config()
evn_bgp_exist = is_config_exist(config, "evn bgp")
if evn_bgp_exist:
self.end_state["evn_bgp"] = "enable"
else:
self.end_state["evn_bgp"] = "disable"
if evn_bgp_exist:
if is_config_exist(config, "server enable"):
self.end_state["evn_server"] = "enable"
else:
self.end_state["evn_server"] = "disable"
self.end_state["evn_source_ip"] = get_evn_srouce(config)
self.end_state["evn_peer_ip"] = get_evn_peers(config)
self.end_state[
"evn_reflect_client"] = get_evn_reflect_client(config)
if is_config_exist(config, "arp collect host enable"):
self.end_state["host_collect_protocol"] = "enable"
else:
self.end_state["host_collect_protocol"] = "disable"
if is_config_exist(config, "host collect protocol bgp"):
self.end_state["host_collect_protocol"] = "bgp"
else:
self.end_state["host_collect_protocol"] = None
if is_config_exist(config, "arp broadcast-suppress enable"):
self.end_state["arp_suppress"] = "enable"
else:
self.end_state["arp_suppress"] = "disable"
def work(self):
"""worker"""
self.check_params()
self.config = self.get_current_config()
self.get_existing()
self.get_proposed()
# deal present or absent
if self.evn_bgp or self.evn_server or self.evn_peer_ip or self.evn_source_ip:
self.config_evn_bgp()
if self.vbdif_name and self.arp_collect_host:
self.config_vbdif()
if self.host_collect_protocol:
self.config_host_collect_protocal()
if self.bridge_domain_id and self.arp_suppress:
self.config_bridge_domain()
if self.commands:
self.cli_load_config(self.commands)
self.changed = True
self.get_end_state()
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.module.exit_json(**self.results)
def main():
spec = dict(
gather_subset=dict(default=['!config'], type='list')
)
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params['gather_subset']
runable_subsets = set()
exclude_subsets = set()
for subset in gather_subset:
if subset == 'all':
runable_subsets.update(VALID_SUBSETS)
continue
if subset.startswith('!'):
subset = subset[1:]
if subset == 'all':
exclude_subsets.update(VALID_SUBSETS)
continue
exclude = True
else:
exclude = False
if subset not in VALID_SUBSETS:
module.fail_json(msg='Bad subset')
if exclude:
exclude_subsets.add(subset)
else:
runable_subsets.add(subset)
if not runable_subsets:
runable_subsets.update(VALID_SUBSETS)
runable_subsets.difference_update(exclude_subsets)
runable_subsets.add('default')
facts = dict()
facts['gather_subset'] = list(runable_subsets)
runner = CommandRunner(module)
instances = list()
for key in runable_subsets:
instances.append(FACT_SUBSETS[key](module, runner))
try:
runner.run()
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
try:
for inst in instances:
inst.populate()
facts.update(inst.facts)
except Exception:
raise
module.exit_json(out=module.from_json(runner.items))
ansible_facts = dict()
for key, value in iteritems(facts):
# this is to maintain capability with nxos_facts 2.1
if key.startswith('_'):
ansible_facts[key[1:]] = value
else:
key = 'ansible_net_%s' % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts)
class Dldp(object):
"""Manage global dldp configration"""
def __init__(self, argument_spec):
self.spec = argument_spec
self.module = None
self.netconf = None
self.init_module()
# dldp global configration info
self.enable = self.module.params['enable'] or None
self.work_mode = self.module.params['work_mode'] or None
self.internal = self.module.params['time_interval'] or None
self.reset = self.module.params['reset'] or None
self.auth_mode = self.module.params['auth_mode']
self.auth_pwd = self.module.params['auth_pwd']
self.dldp_conf = dict()
self.same_conf = False
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.port = self.module.params['port']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = list()
self.end_state = list()
# init netconf connect
self.init_netconf()
def check_config_if_same(self):
"""judge whether current config is the same as what we excepted"""
if self.enable and self.enable != self.dldp_conf['dldpEnable']:
return False
if self.internal and self.internal != self.dldp_conf['dldpInterval']:
return False
work_mode = 'normal'
if self.dldp_conf['dldpWorkMode'] == 'dldpEnhance':
work_mode = 'enhance'
if self.work_mode and self.work_mode != work_mode:
return False
if self.auth_mode:
if self.auth_mode != 'none':
return False
if self.auth_mode == 'none' and self.dldp_conf[
'dldpAuthMode'] != 'dldpAuthNone':
return False
if self.reset and self.reset == 'true':
return False
return True
def check_params(self):
"""Check all input params"""
if (self.auth_mode and self.auth_mode != 'none' and not self.auth_pwd) \
or (self.auth_pwd and not self.auth_mode):
self.module.fail_json(
msg=
"Error: auth_mode and auth_pwd must both exist or not exist.")
if self.dldp_conf['dldpEnable'] == 'false' and not self.enable:
if self.work_mode or self.reset or self.internal or self.auth_mode:
self.module.fail_json(
msg="Error: when DLDP is already disabled globally, "
"work_mode, time_internal auth_mode and reset parameters are not "
"expected to configure.")
if self.enable == 'false' and (self.work_mode or self.internal
or self.reset or self.auth_mode):
self.module.fail_json(
msg="Error: when using enable=false, work_mode, "
"time_internal auth_mode and reset parameters are not expected "
"to configure.")
if self.internal:
if not self.internal.isdigit():
self.module.fail_json(
msg='Error: time_interval must be digit.')
if int(self.internal) < 1 or int(self.internal) > 100:
self.module.fail_json(
msg=
'Error: The value of time_internal should be between 1 and 100.'
)
if self.auth_pwd:
if '?' in self.auth_pwd:
self.module.fail_json(
msg=
'Error: The auth_pwd string excludes a question mark (?).')
if (len(self.auth_pwd) != 24) and (len(self.auth_pwd) != 32) and (len(self.auth_pwd) != 48) and \
(len(self.auth_pwd) != 108) and (len(self.auth_pwd) != 128):
if (len(self.auth_pwd) < 1) or (len(self.auth_pwd) > 16):
self.module.fail_json(
msg=
'Error: The value is a string of 1 to 16 case-sensitive plaintexts or 24/32/48/108/128 '
'case-sensitive encrypted characters.')
def init_module(self):
"""init module object"""
self.module = NetworkModule(argument_spec=self.spec,
supports_check_mode=True)
def init_netconf(self):
"""init netconf interface"""
if HAS_NCCLIENT:
self.netconf = get_netconf(host=self.host,
port=self.port,
username=self.username,
password=self.module.params['password'])
if not self.netconf:
self.module.fail_json(msg='Error: netconf init failed')
else:
self.module.fail_json(
msg='Error: No ncclient package, please install it.')
def check_response(self, con_obj, xml_name):
"""Check if response message is already succeed"""
xml_str = con_obj.xml
if "<ok/>" not in xml_str:
self.module.fail_json(msg='Error: %s failed.' % xml_name)
def netconf_get_config(self, xml_str):
"""netconf get config"""
try:
con_obj = self.netconf.get_config(filter=xml_str)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' %
err.message.replace("\r\n", ""))
return con_obj
def netconf_set_config(self, xml_str, xml_name):
"""netconf set config"""
try:
con_obj = self.netconf.set_config(config=xml_str)
self.check_response(con_obj, xml_name)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' %
err.message.replace("\r\n", ""))
return con_obj
def netconf_set_action(self, xml_str, xml_name):
"""netconf set action"""
try:
con_obj = self.netconf.execute_action(action=xml_str)
self.check_response(con_obj, xml_name)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' %
err.message.replace("\r\n", ""))
return con_obj
def get_dldp_exist_config(self):
"""get current dldp existed configuration"""
dldp_conf = dict()
xml_str = CE_NC_GET_GLOBAL_DLDP_CONFIG
con_obj = self.netconf_get_config(xml_str)
if "<data/>" in con_obj.xml:
return dldp_conf
xml_str = con_obj.xml.replace('\r', '').replace('\n', '').\
replace('xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"', "").\
replace('xmlns="http://www.huawei.com/netconf/vrp"', "")
# get global dldp info
root = ElementTree.fromstring(xml_str)
topo = root.find("data/dldp/dldpSys")
if not topo:
self.module.fail_json(
msg="Error: Get current DLDP configration failed.")
for eles in topo:
if eles.tag in [
"dldpEnable", "dldpInterval", "dldpWorkMode",
"dldpAuthMode"
]:
dldp_conf[eles.tag] = eles.text
return dldp_conf
def config_global_dldp(self):
"""config global dldp"""
if self.same_conf:
return
enable = self.enable
if not self.enable:
enable = self.dldp_conf['dldpEnable']
internal = self.internal
if not self.internal:
internal = self.dldp_conf['dldpInterval']
work_mode = self.work_mode
if not self.work_mode:
work_mode = self.dldp_conf['dldpWorkMode']
if work_mode == 'enhance' or work_mode == 'dldpEnhance':
work_mode = 'dldpEnhance'
else:
work_mode = 'dldpNormal'
auth_mode = self.auth_mode
if not self.auth_mode:
auth_mode = self.dldp_conf['dldpAuthMode']
if auth_mode == 'md5':
auth_mode = 'dldpAuthMD5'
elif auth_mode == 'simple':
auth_mode = 'dldpAuthSimple'
elif auth_mode == 'sha':
auth_mode = 'dldpAuthSHA'
elif auth_mode == 'hmac-sha256':
auth_mode = 'dldpAuthHMAC-SHA256'
elif auth_mode == 'none':
auth_mode = 'dldpAuthNone'
xml_str = CE_NC_MERGE_DLDP_GLOBAL_CONFIG_HEAD % (enable, internal,
work_mode)
if self.auth_mode:
if self.auth_mode == 'none':
xml_str += "<dldpAuthMode>dldpAuthNone</dldpAuthMode>"
else:
xml_str += "<dldpAuthMode>%s</dldpAuthMode>" % auth_mode
xml_str += "<dldpPasswords>%s</dldpPasswords>" % self.auth_pwd
xml_str += CE_NC_MERGE_DLDP_GLOBAL_CONFIG_TAIL
self.netconf_set_config(xml_str, "MERGE_DLDP_GLOBAL_CONFIG")
if self.reset == 'true':
xml_str = CE_NC_ACTION_RESET_DLDP
self.netconf_set_action(xml_str, "ACTION_RESET_DLDP")
self.changed = True
def get_existing(self):
"""get existing info"""
dldp_conf = dict()
dldp_conf['enable'] = self.dldp_conf.get('dldpEnable', None)
dldp_conf['time_interval'] = self.dldp_conf.get('dldpInterval', None)
work_mode = self.dldp_conf.get('dldpWorkMode', None)
if work_mode == 'dldpEnhance':
dldp_conf['work_mode'] = 'enhance'
else:
dldp_conf['work_mode'] = 'normal'
auth_mode = self.dldp_conf.get('dldpAuthMode', None)
if auth_mode == 'dldpAuthNone':
dldp_conf['auth_mode'] = 'none'
elif auth_mode == 'dldpAuthSimple':
dldp_conf['auth_mode'] = 'simple'
elif auth_mode == 'dldpAuthMD5':
dldp_conf['auth_mode'] = 'md5'
elif auth_mode == 'dldpAuthSHA':
dldp_conf['auth_mode'] = 'sha'
else:
dldp_conf['auth_mode'] = 'hmac-sha256'
dldp_conf['reset'] = 'false'
self.existing = copy.deepcopy(dldp_conf)
def get_proposed(self):
"""get proposed result"""
self.proposed = dict(enable=self.enable,
work_mode=self.work_mode,
time_interval=self.internal,
reset=self.reset,
auth_mode=self.auth_mode,
auth_pwd=self.auth_pwd)
def get_update_cmd(self):
"""get update commands"""
if self.same_conf:
return
if self.enable and self.enable != self.dldp_conf['dldpEnable']:
if self.enable == 'true':
self.updates_cmd.append("dldp enable")
elif self.enable == 'false':
self.updates_cmd.append("undo dldp enable")
return
work_mode = 'normal'
if self.dldp_conf['dldpWorkMode'] == 'dldpEnhance':
work_mode = 'enhance'
if self.work_mode and self.work_mode != work_mode:
if self.work_mode == 'enhance':
self.updates_cmd.append("dldp work-mode enhance")
else:
self.updates_cmd.append("dldp work-mode normal")
if self.internal and self.internal != self.dldp_conf['dldpInterval']:
self.updates_cmd.append("dldp interval %s" % self.internal)
if self.auth_mode:
if self.auth_mode == 'none':
self.updates_cmd.append("undo dldp authentication-mode")
else:
self.updates_cmd.append("dldp authentication-mode %s %s" %
(self.auth_mode, self.auth_pwd))
if self.reset and self.reset == 'true':
self.updates_cmd.append('dldp reset')
def get_end_state(self):
"""get end state info"""
dldp_conf = dict()
self.dldp_conf = self.get_dldp_exist_config()
dldp_conf['enable'] = self.dldp_conf.get('dldpEnable', None)
dldp_conf['time_interval'] = self.dldp_conf.get('dldpInterval', None)
work_mode = self.dldp_conf.get('dldpWorkMode', None)
if work_mode == 'dldpEnhance':
dldp_conf['work_mode'] = 'enhance'
else:
dldp_conf['work_mode'] = 'normal'
auth_mode = self.dldp_conf.get('dldpAuthMode', None)
if auth_mode == 'dldpAuthNone':
dldp_conf['auth_mode'] = 'none'
elif auth_mode == 'dldpAuthSimple':
dldp_conf['auth_mode'] = 'simple'
elif auth_mode == 'dldpAuthMD5':
dldp_conf['auth_mode'] = 'md5'
elif auth_mode == 'dldpAuthSHA':
dldp_conf['auth_mode'] = 'sha'
else:
dldp_conf['auth_mode'] = 'hmac-sha256'
dldp_conf['reset'] = 'false'
if self.reset == 'true':
dldp_conf['reset'] = 'true'
self.end_state = copy.deepcopy(dldp_conf)
def show_result(self):
"""show result"""
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.module.exit_json(**self.results)
def work(self):
"""worker"""
self.dldp_conf = self.get_dldp_exist_config()
self.check_params()
self.same_conf = self.check_config_if_same()
self.get_existing()
self.get_proposed()
self.config_global_dldp()
self.get_update_cmd()
self.get_end_state()
self.show_result()
def init_module(self):
""" init_module"""
self.module = NetworkModule(
argument_spec=self.spec, supports_check_mode=True)
def main():
"""main entry point for Ansible module
"""
spec = dict(
commands=dict(type="list"),
rpcs=dict(type="list"),
display=dict(default="xml", choices=["text", "xml"], aliases=["format", "output"]),
wait_for=dict(type="list", aliases=["waitfor"]),
match=dict(default="all", choices=["all", "any"]),
retries=dict(default=10, type="int"),
interval=dict(default=1, type="int"),
transport=dict(default="netconf", choices=["netconf"]),
)
mutually_exclusive = [("commands", "rpcs")]
module = NetworkModule(argument_spec=spec, mutually_exclusive=mutually_exclusive, supports_check_mode=True)
commands = list()
for key in VALID_KEYS.keys():
commands.extend(list(parse(module, key)))
conditionals = module.params["wait_for"] or list()
warnings = list()
runner = CommandRunner(module)
for cmd in commands:
if module.check_mode and not cmd["command"].startswith("show"):
warnings.append(
"only show commands are supported when using " "check mode, not executing `%s`" % cmd["command"]
)
else:
if cmd["command"].startswith("co"):
module.fail_json(
msg="junos_command does not support running "
"config mode commands. Please use "
"junos_config instead"
)
try:
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
warnings.append("duplicate command detected: %s" % cmd)
try:
for item in conditionals:
runner.add_conditional(item)
except (ValueError, AddConditionError):
exc = get_exception()
module.fail_json(msg=str(exc), condition=exc.condition)
runner.retries = module.params["retries"]
runner.interval = module.params["interval"]
runner.match = module.params["match"]
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc))
result = dict(changed=False, stdout=list())
for cmd in commands:
try:
output = runner.get_command(cmd["command"], cmd.get("output"))
except ValueError:
output = "command not executed due to check_mode, see warnings"
result["stdout"].append(output)
result["warnings"] = warnings
result["stdout_lines"] = list(to_lines(result["stdout"]))
module.exit_json(**result)
def main():
"""main entry point for Ansible module
"""
spec = dict(
commands=dict(type='list'),
rpcs=dict(type='list'),
display=dict(default='xml', choices=['text', 'xml'],
aliases=['format', 'output']),
wait_for=dict(type='list', aliases=['waitfor']),
match=dict(default='all', choices=['all', 'any']),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int'),
transport=dict(default='netconf', choices=['netconf'])
)
mutually_exclusive = [('commands', 'rpcs')]
module = NetworkModule(argument_spec=spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
commands = list()
for key in VALID_KEYS.keys():
commands.extend(list(parse(module, key)))
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
for cmd in commands:
if module.check_mode and not cmd['command'].startswith('show'):
warnings.append('only show commands are supported when using '
'check mode, not executing `%s`' % cmd['command'])
else:
if cmd['command'].startswith('co'):
module.fail_json(msg='junos_command does not support running '
'config mode commands. Please use '
'junos_config instead')
try:
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
warnings.append('duplicate command detected: %s' % cmd)
try:
for item in conditionals:
runner.add_conditional(item)
except (ValueError, AddConditionError):
exc = get_exception()
module.fail_json(msg=str(exc), condition=exc.condition)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
runner.match = module.params['match']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc))
result = dict(changed=False, stdout=list())
for cmd in commands:
try:
output = runner.get_command(cmd['command'], cmd.get('output'))
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
def init_module(self):
""" init_module"""
self.module = NetworkModule(argument_spec=self.spec, supports_check_mode=True,
mutually_exclusive=self.mutually_exclusive)
def main():
spec = dict(commands=dict(type='list', required=True),
wait_for=dict(type='list'),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int'))
module = NetworkModule(argument_spec=spec,
connect_on_load=False,
supports_check_mode=True)
commands = list(parse_commands(module))
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
for cmd in commands:
if module.check_mode and not cmd['command'].startswith('show'):
warnings.append('only show commands are supported when using '
'check mode, not executing `%s`' % cmd)
else:
if cmd['command'].startswith('conf'):
module.fail_json(
msg='dellos6_command does not support running '
'config mode commands. Please use '
'dellos6_config instead')
try:
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
warnings.append('duplicate command detected: %s' % cmd)
for item in conditionals:
runner.add_conditional(item)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc))
result = dict(changed=False)
result['stdout'] = list()
for cmd in commands:
try:
output = runner.get_command(cmd['command'])
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
def main():
"""main entry point for Ansible module
"""
spec = dict(
commands=dict(type='list'),
rpcs=dict(type='list'),
display=dict(default='xml', choices=['text', 'xml'],
aliases=['format', 'output']),
wait_for=dict(type='list', aliases=['waitfor']),
match=dict(default='all', choices=['all', 'any']),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int'),
transport=dict(default='netconf', choices=['netconf'])
)
mutually_exclusive = [('commands', 'rpcs')]
module = NetworkModule(argument_spec=spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
commands = list()
for key in VALID_KEYS.keys():
commands.extend(list(parse(module, key)))
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
for cmd in commands:
if module.check_mode and not cmd['command'].startswith('show'):
warnings.append('only show commands are supported when using '
'check mode, not executing `%s`' % cmd['command'])
else:
if cmd['command'].startswith('co'):
module.fail_json(msg='junos_command does not support running '
'config mode commands. Please use '
'junos_config instead')
try:
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
warnings.append('duplicate command detected: %s' % cmd)
try:
for item in conditionals:
runner.add_conditional(item)
except (ValueError, AddConditionError):
exc = get_exception()
module.fail_json(msg=str(exc), condition=exc.condition)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
runner.match = module.params['match']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc))
result = dict(changed=False, stdout=list())
for cmd in commands:
try:
output = runner.get_command(cmd['command'], cmd.get('output'))
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
class CE_Interface(object):
"""CE_Interface"""
def __init__(
self,
argument_spec,
):
self.start_time = datetime.datetime.now()
self.end_time = None
self.spec = argument_spec
self.module = None
self.nc = None
self.init_module()
# interface info
self.interface = self.module.params['interface']
self.interface_type = self.module.params['interface_type']
self.admin_state = self.module.params['admin_state']
self.description = self.module.params['description']
self.mode = self.module.params['mode']
self.state = self.module.params['state']
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.password = self.module.params['password']
self.port = self.module.params['port']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
self.intfs_info = dict() # all type interface info
self.intf_info = dict() # one interface info
self.intf_type = None # loopback tunnel ...
# init netconf connect
self.init_netconf()
def init_module(self):
"""init_module"""
self.module = NetworkModule(argument_spec=self.spec,
supports_check_mode=True)
def init_netconf(self):
"""init_netconf"""
if not HAS_NCCLIENT:
raise Exception("the ncclient library is required")
self.nc = get_netconf(host=self.host,
port=self.port,
username=self.username,
password=self.password)
if not self.nc:
self.module.fail_json(msg='Error: netconf init failed')
def check_response(self, con_obj, xml_name):
"""Check if response message is already succeed."""
xml_str = con_obj.xml
if "<ok/>" not in xml_str:
self.module.fail_json(msg='Error: %s failed.' % xml_name)
def build_config_xml(self, xmlstr):
"""build_config_xml"""
return '<config> ' + xmlstr + ' </config>'
def get_interfaces_dict(self):
""" get interfaces attributes dict."""
intfs_info = dict()
conf_str = CE_NC_GET_INTFS
try:
con_obj = self.nc.get_config(filter=conf_str)
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
if "<data/>" in con_obj.xml:
return intfs_info
intf = re.findall(
r'.*<ifName>(.*)</ifName>.*\s*<ifPhyType>(.*)</ifPhyType>.*\s*'
r'<ifNumber>(.*)</ifNumber>.*\s*<ifDescr>(.*)</ifDescr>.*\s*'
r'<isL2SwitchPort>(.*)</isL2SwitchPort>.*\s*<ifAdminStatus>'
r'(.*)</ifAdminStatus>.*\s*<ifMtu>(.*)</ifMtu>.*', con_obj.xml)
for i in range(len(intf)):
if intf[i][1]:
if not intfs_info.get(intf[i][1].lower()):
# new interface type list
intfs_info[intf[i][1].lower()] = list()
intfs_info[intf[i][1].lower()].append\
(dict(ifName=intf[i][0], ifPhyType=intf[i][1],
ifNumber=intf[i][2], ifDescr=intf[i][3],
isL2SwitchPort=intf[i][4],
ifAdminStatus=intf[i][5],
ifMtu=intf[i][6]))
return intfs_info
def get_interface_dict(self, ifname):
""" get one interface attributes dict."""
intf_info = dict()
conf_str = CE_NC_GET_INTF % ifname
try:
con_obj = self.nc.get_config(filter=conf_str)
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
if "<data/>" in con_obj.xml:
return intf_info
intf = re.findall(
r'.*<ifName>(.*)</ifName>.*\s*'
r'<ifPhyType>(.*)</ifPhyType>.*\s*'
r'<ifNumber>(.*)</ifNumber>.*\s*'
r'<ifDescr>(.*)</ifDescr>.*\s*'
r'<isL2SwitchPort>(.*)</isL2SwitchPort>.*\s*'
r'<ifAdminStatus>(.*)</ifAdminStatus>.*\s*'
r'<ifMtu>(.*)</ifMtu>.*', con_obj.xml)
if intf:
intf_info = dict(ifName=intf[0][0],
ifPhyType=intf[0][1],
ifNumber=intf[0][2],
ifDescr=intf[0][3],
isL2SwitchPort=intf[0][4],
ifAdminStatus=intf[0][5],
ifMtu=intf[0][6])
return intf_info
def get_interface_type(self, interface):
"""Gets the type of interface, such as 10GE, ETH-TRUNK, VLANIF..."""
if interface is None:
return None
iftype = None
if interface.upper().startswith('GE'):
iftype = 'ge'
elif interface.upper().startswith('10GE'):
iftype = '10ge'
elif interface.upper().startswith('25GE'):
iftype = '25ge'
elif interface.upper().startswith('4X10GE'):
iftype = '4x10ge'
elif interface.upper().startswith('40GE'):
iftype = '40ge'
elif interface.upper().startswith('100GE'):
iftype = '100ge'
elif interface.upper().startswith('VLANIF'):
iftype = 'vlanif'
elif interface.upper().startswith('LOOPBACK'):
iftype = 'loopback'
elif interface.upper().startswith('METH'):
iftype = 'meth'
elif interface.upper().startswith('ETH-TRUNK'):
iftype = 'eth-trunk'
elif interface.upper().startswith('VBDIF'):
iftype = 'vbdif'
elif interface.upper().startswith('NVE'):
iftype = 'nve'
elif interface.upper().startswith('TUNNEL'):
iftype = 'tunnel'
elif interface.upper().startswith('ETHERNET'):
iftype = 'ethernet'
elif interface.upper().startswith('FCOE-PORT'):
iftype = 'fcoe-port'
elif interface.upper().startswith('FABRIC-PORT'):
iftype = 'fabric-port'
elif interface.upper().startswith('STACK-PORT'):
iftype = 'stack-Port'
elif interface.upper().startswith('NULL'):
iftype = 'null'
else:
return None
return iftype.lower()
def is_admin_state_enable(self, iftype):
"""admin state disable: loopback nve"""
if iftype in admin_state_type:
return True
else:
return False
def is_portswitch_enalbe(self, iftype):
""""is portswitch? """
if iftype in switch_port_type:
return True
else:
return False
def is_create_enalbe(self, iftype):
"""is_create_enalbe"""
return True
def is_delete_enable(self, iftype):
"""is_delete_enable"""
return True
def create_interface(self, ifname, descritption, admin_state, mode):
"""Create interface."""
self.updates_cmd.append("interface %s" % ifname)
if not descritption:
descritption = ''
else:
self.updates_cmd.append("descritption %s" % descritption)
xmlstr = CE_NC_XML_CREATE_INTF % (ifname, descritption)
if admin_state and self.is_admin_state_enable(self.intf_type):
xmlstr += CE_NC_XML_MERGE_INTF_STATUS % (ifname, admin_state)
if admin_state == 'up':
self.updates_cmd.append("undo shutdown")
else:
self.updates_cmd.append("shutdown")
if mode and self.is_portswitch_enalbe(self.intf_type):
if mode == "layer2":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'enable')
self.updates_cmd.append('portswitch')
elif mode == "layer3":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'disable')
self.updates_cmd.append('undo portswitch')
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "CREATE_INTF")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def delete_interface(self, ifname):
""" Delete interface."""
xmlstr = CE_NC_XML_DELETE_INTF % ifname
conf_str = self.build_config_xml(xmlstr)
self.updates_cmd.append('undo interface %s' % ifname)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "DELETE_INTF")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def delete_interfaces(self, iftype):
""" Delete interfaces with type."""
xmlstr = ''
intfs_list = self.intfs_info.get(iftype.lower())
if not intfs_list:
return
for i in range(len(intfs_list)):
xmlstr += CE_NC_XML_DELETE_INTF % intfs_list[i]['ifName']
self.updates_cmd.append('undo interface %s' %
intfs_list[i]['ifName'])
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "DELETE_INTFS")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def merge_interface(self, ifname, descritption, admin_state, mode):
""" Merge interface attributes."""
xmlstr = ''
change = False
self.updates_cmd.append("interface %s" % ifname)
if descritption and self.intf_info["ifDescr"] != descritption:
xmlstr += CE_NC_XML_MERGE_INTF_DES % (ifname, descritption)
self.updates_cmd.append("descritption %s" % descritption)
change = True
if admin_state and self.is_admin_state_enable(self.intf_type) \
and self.intf_info["ifAdminStatus"] != admin_state:
xmlstr += CE_NC_XML_MERGE_INTF_STATUS % (ifname, admin_state)
change = True
if admin_state == "up":
self.updates_cmd.append("undo shutdown")
else:
self.updates_cmd.append("shutdown")
if self.is_portswitch_enalbe(self.intf_type):
if mode == "layer2" and self.intf_info["isL2SwitchPort"] != "true":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'enable')
self.updates_cmd.append("portswitch")
change = True
elif mode == "layer3" \
and self.intf_info["isL2SwitchPort"] != "false":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'disable')
self.updates_cmd.append("undo portswitch")
change = True
if not change:
return
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "MERGE_INTF_ATTR")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def merge_interfaces(self, iftype, descritption, admin_state, mode):
""" Merge interface attributes by type."""
xmlstr = ''
change = False
intfs_list = self.intfs_info.get(iftype.lower())
if not intfs_list:
return
for i in range(len(intfs_list)):
if_change = False
self.updates_cmd.append("interface %s" % intfs_list[i]['ifName'])
if descritption and intfs_list[i]["ifDescr"] != descritption:
xmlstr += CE_NC_XML_MERGE_INTF_DES % (intfs_list[i]['ifName'],
descritption)
self.updates_cmd.append("descritption %s" % descritption)
if_change = True
if admin_state and self.is_admin_state_enable(self.intf_type)\
and intfs_list[i]["ifAdminStatus"] != admin_state:
xmlstr += CE_NC_XML_MERGE_INTF_STATUS % (
intfs_list[i]['ifName'], admin_state)
if_change = True
if admin_state == "up":
self.updates_cmd.append("undo shutdown")
else:
self.updates_cmd.append("shutdown")
if self.is_portswitch_enalbe(self.intf_type):
if mode == "layer2" \
and intfs_list[i]["isL2SwitchPort"] != "true":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (
intfs_list[i]['ifName'], 'enable')
self.updates_cmd.append("portswitch")
if_change = True
elif mode == "layer3" \
and intfs_list[i]["isL2SwitchPort"] != "false":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (
intfs_list[i]['ifName'], 'disable')
self.updates_cmd.append("undo portswitch")
if_change = True
if if_change:
change = True
else:
self.updates_cmd.pop()
if not change:
return
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "MERGE_INTFS_ATTR")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def default_interface(self, ifname, default_all=False):
"""default_interface"""
change = False
xmlstr = ""
self.updates_cmd.append("interface %s" % ifname)
# set descritption default
if self.intf_info["ifDescr"]:
xmlstr += CE_NC_XML_MERGE_INTF_DES % (ifname, '')
self.updates_cmd.append("undo descritption")
change = True
# set admin_status default
if self.is_admin_state_enable(self.intf_type) \
and self.intf_info["ifAdminStatus"] != 'up':
xmlstr += CE_NC_XML_MERGE_INTF_STATUS % (ifname, 'up')
self.updates_cmd.append("undo shutdown")
change = True
# set portswitch default
if self.is_portswitch_enalbe(self.intf_type) \
and self.intf_info["isL2SwitchPort"] != "true":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'enable')
self.updates_cmd.append("portswitch")
change = True
if not change:
return
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "SET_INTF_DEFAULT")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def default_interfaces(self, iftype, default_all=False):
""" Set interface config to default by type."""
change = False
xmlstr = ''
intfs_list = self.intfs_info.get(iftype.lower())
if not intfs_list:
return
for i in range(len(intfs_list)):
if_change = False
self.updates_cmd.append("interface %s" % intfs_list[i]['ifName'])
# set descritption default
if intfs_list[i]['ifDescr']:
xmlstr += CE_NC_XML_MERGE_INTF_DES % (intfs_list[i]['ifName'],
'')
self.updates_cmd.append("undo descritption")
if_change = True
# set admin_status default
if self.is_admin_state_enable(self.intf_type) \
and intfs_list[i]["ifAdminStatus"] != 'up':
xmlstr += CE_NC_XML_MERGE_INTF_STATUS % (
intfs_list[i]['ifName'], 'up')
self.updates_cmd.append("undo shutdown")
if_change = True
# set portswitch default
if self.is_portswitch_enalbe(self.intf_type) \
and intfs_list[i]["isL2SwitchPort"] != "true":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (
intfs_list[i]['ifName'], 'enable')
self.updates_cmd.append("portswitch")
if_change = True
if if_change:
change = True
else:
self.updates_cmd.pop()
if not change:
return
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "SET_INTFS_DEFAULT")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def check_params(self):
"""Check all input params"""
if not self.interface and not self.interface_type:
self.module.fail_json(
msg='Error: Interface or interface_type must be set.')
if self.interface and self.interface_type:
self.module.fail_json(msg='Error: Interface or interface_type'
' can not be set at the same time.')
# interface type check
if self.interface:
self.intf_type = self.get_interface_type(self.interface)
if not self.intf_type:
self.module.fail_json(msg='Error: interface name of %s'
' is error.' % self.interface)
elif self.interface_type:
self.intf_type = self.get_interface_type(self.interface_type)
if not self.intf_type or self.intf_type != self.interface_type.replace(
" ", "").lower():
self.module.fail_json(msg='Error: interface type of %s'
' is error.' % self.interface_type)
if not self.intf_type:
self.module.fail_json(
msg='Error: interface or interface type %s is error.')
# shutdown check
if not self.is_admin_state_enable(self.intf_type) \
and self.state == "present" and self.admin_state == "down":
self.module.fail_json(msg='Error: The %s interface can not'
' be shutdown.' % self.intf_type)
# absent check
if not self.is_delete_enable(
self.intf_type) and self.state == "absent":
self.module.fail_json(msg='Error: The %s interface can not'
' be delete.' % self.intf_type)
# port switch mode check
if not self.is_portswitch_enalbe(self.intf_type)\
and self.mode and self.state == "present":
self.module.fail_json(msg='Error: The %s interface can not manage'
' Layer 2 or Layer 3 state.' %
self.intf_type)
# check description len
if self.description:
if len(self.description) > 242 \
or len(self.description.replace(' ', '')) < 1:
self.module.fail_json(msg='Error: interface description '
'is not in the range from 1 to 242.')
def get_proposed(self):
"""get_proposed"""
self.proposed['state'] = self.state
if self.interface:
self.proposed["interface"] = self.interface
if self.interface_type:
self.proposed["interface_type"] = self.interface_type
if self.state == 'present':
if self.description:
self.proposed["description"] = self.description
if self.mode:
self.proposed["mode"] = self.mode
if self.admin_state:
self.proposed["admin_state"] = self.admin_state
elif self.state == 'default':
if self.description:
self.proposed["description"] = ""
if self.is_admin_state_enable(self.intf_type) and self.admin_state:
self.proposed["admin_state"] = self.admin_state
if self.is_portswitch_enalbe(self.intf_type) and self.mode:
self.proposed["mode"] = self.mode
def get_existing(self):
"""get_existing"""
if self.intf_info:
self.existing["interface"] = self.intf_info["ifName"]
if self.is_admin_state_enable(self.intf_type):
self.existing["admin_state"] = self.intf_info["ifAdminStatus"]
self.existing["description"] = self.intf_info["ifDescr"]
if self.is_portswitch_enalbe(self.intf_type):
if self.intf_info["isL2SwitchPort"] == "true":
self.existing["mode"] = "layer2"
else:
self.existing["mode"] = "layer3"
def get_end_state(self):
"""get_end_state"""
if self.intf_info:
end_info = self.get_interface_dict(self.interface)
if end_info:
self.end_state["interface"] = end_info["ifName"]
if self.is_admin_state_enable(self.intf_type):
self.end_state["admin_state"] = end_info["ifAdminStatus"]
self.end_state["description"] = end_info["ifDescr"]
if self.is_portswitch_enalbe(self.intf_type):
if end_info["isL2SwitchPort"] == "true":
self.end_state["mode"] = "layer2"
else:
self.end_state["mode"] = "layer3"
def work(self):
"""worker"""
self.check_params()
# single interface config
if self.interface:
self.intf_info = self.get_interface_dict(self.interface)
self.get_existing()
if self.state == 'present':
if not self.intf_info:
# create interface
self.create_interface\
(self.interface,
self.description,
self.admin_state,
self.mode)
else:
# merge interface
if self.description or self.admin_state or self.mode:
self.merge_interface\
(self.interface,
self.description,
self.admin_state,
self.mode)
elif self.state == 'absent':
if self.intf_info:
# delete interface
self.delete_interface(self.interface)
else:
# interface does not exists
self.module.fail_json(
msg='Error: interface does not exists.')
else: # default
if not self.intf_info:
# error, interface does not exists
self.module.fail_json(
msg='Error: interface does not exists.')
else:
self.default_interface(self.interface)
# interface type config
else:
self.intfs_info = self.get_interfaces_dict()
self.get_existing()
if self.state == 'present':
if self.intfs_info.get(self.intf_type.lower()):
if self.description or self.admin_state or self.mode:
self.merge_interfaces\
(self.intf_type,
self.description,
self.admin_state,
self.mode)
elif self.state == 'absent':
# delete all interface of this type
if self.intfs_info.get(self.intf_type.lower()):
self.delete_interfaces(self.intf_type)
else:
# set interfaces config to default
if self.intfs_info.get(self.intf_type.lower()):
self.default_interfaces(self.intf_type)
else:
self.module.fail_json(
msg='Error: no interface in this type.')
self.get_proposed()
self.get_end_state()
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.end_time = datetime.datetime.now()
self.results['execute_time'] = str(self.end_time - self.start_time)
self.module.exit_json(**self.results)
def main():
spec = dict(
gather_subset=dict(default=['!config'], type='list')
)
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params['gather_subset']
runable_subsets = set()
exclude_subsets = set()
for subset in gather_subset:
if subset == 'all':
runable_subsets.update(VALID_SUBSETS)
continue
if subset.startswith('!'):
subset = subset[1:]
if subset == 'all':
exclude_subsets.update(VALID_SUBSETS)
continue
exclude = True
else:
exclude = False
if subset not in VALID_SUBSETS:
module.fail_json(msg='Bad subset')
if exclude:
exclude_subsets.add(subset)
else:
runable_subsets.add(subset)
if not runable_subsets:
runable_subsets.update(VALID_SUBSETS)
runable_subsets.difference_update(exclude_subsets)
runable_subsets.add('default')
facts = dict()
facts['gather_subset'] = list(runable_subsets)
instances = list()
for key in runable_subsets:
instances.append(FACT_SUBSETS[key](module))
failed_commands = list()
try:
for inst in instances:
inst.populate()
failed_commands.extend(inst.failed_commands)
facts.update(inst.facts)
except Exception:
exc = get_exception()
module.fail_json(msg=str(exc))
ansible_facts = dict()
for key, value in iteritems(facts):
key = 'ansible_net_%s' % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts, failed_commands=failed_commands)
def main():
spec = dict(
# { command: <str>, output: <str>, prompt: <str>, response: <str> }
commands=dict(type='list', required=True),
wait_for=dict(type='list', aliases=['waitfor']),
match=dict(default='all', choices=['any', 'all']),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int')
)
module = NetworkModule(argument_spec=spec,
supports_check_mode=True)
commands = list(parse_commands(module))
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
try:
# This tries to detect command mode.
runner.add_command('tmsh')
runner.run()
shell = "bash"
except NetworkError:
shell = "tmsh"
# Resets the runner because raised exceptions do not remove the
# erroneous commands
module.disconnect()
runner.commands = []
runner.module.cli._commands = []
for cmd in commands:
cmd = strip_tmsh_prefix(cmd)
if module.check_mode and not is_config_mode_command(cmd):
warnings.append('only show or list commands are supported when '
'using check mode, not executing `%s`'
% cmd['command'])
else:
if is_config_mode_command(cmd):
module.fail_json(msg='bigip_command does not support running '
'config mode commands. Please use '
'bigip_config instead')
try:
if shell == 'tmsh':
disable_pager = dict(
output=None,
command='modify cli preference pager disabled'
)
runner.add_command(**disable_pager)
runner.add_command(**cmd)
else:
disable_pager = dict(
output=None,
command='tmsh modify cli preference pager disabled'
)
cmd['command'] = 'tmsh ' + cmd['command']
runner.add_command(**disable_pager)
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
warnings.append('duplicate command detected: %s' % cmd)
try:
for item in conditionals:
runner.add_conditional(item)
except AddConditionError:
exc = get_exception()
module.fail_json(msg=str(exc), condition=exc.condition)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
runner.match = module.params['match']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
result = dict(changed=False)
result['stdout'] = list()
for cmd in commands:
try:
output = runner.get_command(cmd['command'], cmd.get('output'))
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
def main():
spec = dict(gather_subset=dict(default=['!config'], type='list'))
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params['gather_subset']
runable_subsets = set()
exclude_subsets = set()
for subset in gather_subset:
if subset == 'all':
runable_subsets.update(VALID_SUBSETS)
continue
if subset.startswith('!'):
subset = subset[1:]
if subset == 'all':
exclude_subsets.update(VALID_SUBSETS)
continue
exclude = True
else:
exclude = False
if subset not in VALID_SUBSETS:
module.fail_json(msg='Bad subset')
if exclude:
exclude_subsets.add(subset)
else:
runable_subsets.add(subset)
if not runable_subsets:
runable_subsets.update(VALID_SUBSETS)
runable_subsets.difference_update(exclude_subsets)
runable_subsets.add('default')
facts = dict()
facts['gather_subset'] = list(runable_subsets)
runner = CommandRunner(module)
instances = list()
for key in runable_subsets:
runs = FACT_SUBSETS[key](runner)
instances.append(runs)
runner.run()
try:
for inst in instances:
inst.populate()
facts.update(inst.facts)
except Exception:
module.exit_json(out=module.from_json(runner.items))
ansible_facts = dict()
for key, value in facts.iteritems():
key = 'ansible_net_%s' % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts)
class CE_MTU(object):
""" CE_MTU"""
def __init__(self, argument_spec, ):
self.start_time = datetime.datetime.now()
self.end_time = None
self.spec = argument_spec
self.module = None
self.nc = None
self.init_module()
# interface info
self.interface = self.module.params['interface']
self.mtu = self.module.params['mtu']
self.state = self.module.params['state']
self.jbfMax = self.module.params['jumbo_max'] or None
self.jbfMin = self.module.params['jumbo_min'] or None
self.jbfConfig = list()
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.port = self.module.params['port']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
self.intf_info = dict() # one interface info
self.intf_type = None # loopback tunnel ...
# init netconf connect
self.init_netconf()
def init_module(self):
""" init_module"""
self.module = NetworkModule(
argument_spec=self.spec, supports_check_mode=True)
def init_netconf(self):
""" init_netconf"""
if HAS_NCCLIENT:
self.nc = get_netconf(host=self.host, port=self.port,
username=self.username,
password=self.module.params['password'])
else:
self.module.fail_json(
msg='Error: No ncclient package, please install it.')
def check_response(self, con_obj, xml_name):
"""Check if response message is already succeed."""
xml_str = con_obj.xml
if "<ok/>" not in xml_str:
self.module.fail_json(msg='Error: %s failed.' % xml_name)
def build_config_xml(self, xmlstr):
""" build_config_xml"""
return '<config> ' + xmlstr + ' </config>'
def get_interface_dict(self, ifname):
""" get one interface attributes dict."""
intf_info = dict()
conf_str = CE_NC_GET_INTF % ifname
try:
con_obj = self.nc.get_config(filter=conf_str)
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
if "<data/>" in con_obj.xml:
return intf_info
intf = re.findall(
r'.*<ifName>(.*)</ifName>.*\s*'
r'<isL2SwitchPort>(.*)</isL2SwitchPort>.*\s*'
r'<ifMtu>(.*)</ifMtu>.*', con_obj.xml)
if intf:
intf_info = dict(ifName=intf[0][0],
isL2SwitchPort=intf[0][1],
ifMtu=intf[0][2])
return intf_info
def get_interface_type(self, interface):
"""Gets the type of interface, such as 10GE, ETH-TRUNK, VLANIF..."""
if interface is None:
return None
iftype = None
if interface.upper().startswith('GE'):
iftype = 'ge'
elif interface.upper().startswith('10GE'):
iftype = '10ge'
elif interface.upper().startswith('25GE'):
iftype = '25ge'
elif interface.upper().startswith('4X10GE'):
iftype = '4x10ge'
elif interface.upper().startswith('40GE'):
iftype = '40ge'
elif interface.upper().startswith('100GE'):
iftype = '100ge'
elif interface.upper().startswith('VLANIF'):
iftype = 'vlanif'
elif interface.upper().startswith('LOOPBACK'):
iftype = 'loopback'
elif interface.upper().startswith('METH'):
iftype = 'meth'
elif interface.upper().startswith('ETH-TRUNK'):
iftype = 'eth-trunk'
elif interface.upper().startswith('VBDIF'):
iftype = 'vbdif'
elif interface.upper().startswith('NVE'):
iftype = 'nve'
elif interface.upper().startswith('TUNNEL'):
iftype = 'tunnel'
elif interface.upper().startswith('ETHERNET'):
iftype = 'ethernet'
elif interface.upper().startswith('FCOE-PORT'):
iftype = 'fcoe-port'
elif interface.upper().startswith('FABRIC-PORT'):
iftype = 'fabric-port'
elif interface.upper().startswith('STACK-PORT'):
iftype = 'stack-Port'
elif interface.upper().startswith('NULL'):
iftype = 'null'
else:
return None
return iftype.lower()
def is_portswitch_enalbe(self, iftype):
""""[undo] portswitch"""
type_list = ['ge', '10ge', '25ge',
'4x10ge', '40ge', '100ge', 'eth-trunk']
if iftype in type_list:
return True
else:
return False
def prase_jumboframe_para(self, configStr):
""" prase_jumboframe_para"""
interface_cli = "interface %s" % self.interface
if configStr.find(interface_cli) == -1:
self.module.fail_json(
msg='Interface does not exist.')
npos1 = configStr.index(interface_cli)
npos2 = configStr.index('#', npos1)
configStrTmp = configStr[npos1:npos2]
try:
npos3 = configStrTmp.index('jumboframe enable')
except ValueError:
# return default vale
return [9216, 1518]
npos4 = configStrTmp.index('\n', npos3)
configStrTmp = configStrTmp[npos3:npos4]
return re.findall(r'([0-9]+)', configStrTmp)
def excute_command(self, commands):
""" excute_command"""
runner = CommandRunner(self.module)
for cmd in commands:
try:
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
self.module.fail_json(
msg='duplicate command detected: %s' % cmd)
runner.retries = self.module.params['retries']
runner.interval = self.module.params['interval']
runner.match = self.module.params['match']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
self.module.fail_json(
msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
self.module.fail_json(
msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
self.module.fail_json(msg=str(exc), **exc.kwargs)
for cmd in commands:
try:
output = runner.get_command(cmd['command'], cmd.get('output'))
except ValueError:
self.module.fail_json(
msg='command not executed due to check_mode, see warnings')
return output
def get_jumboframe_config(self):
""" get_jumboframe_config"""
commands = list()
cmd = {'output': None, 'command': 'display current-configuration'}
commands.append(cmd)
output = self.excute_command(commands)
return self.prase_jumboframe_para(output)
def set_jumboframe(self):
""" set_jumboframe"""
if self.state == "present":
if not self.jbfMax or not self.jbfMin:
return
jbfValue = self.get_jumboframe_config()
self.jbfConfig = copy.deepcopy(jbfValue)
if len(jbfValue) == 1:
jbfValue.append("1518")
self.jbfConfig.append("1518")
if not self.jbfMax:
return
if (len(jbfValue) > 2) or (len(jbfValue) == 0):
self.module.fail_json(
msg='Error: Get jubmoframe config value num error.')
if (self.jbfMin is None):
if (jbfValue[0] == self.jbfMax):
return
else:
if (jbfValue[0] == self.jbfMax) \
and (jbfValue[1] == self.jbfMin):
return
if (jbfValue[0] != self.jbfMax):
jbfValue[0] = self.jbfMax
if (jbfValue[1] != self.jbfMin) and (self.jbfMin is not None):
jbfValue[1] = self.jbfMin
else:
jbfValue.pop(1)
else:
jbfValue = self.get_jumboframe_config()
self.jbfConfig = copy.deepcopy(jbfValue)
if (jbfValue == [9216, 1518]):
return
jbfValue = [9216, 1518]
# excute commands
commands = list()
cmd1 = {'output': None, 'command': 'system-view'}
commands.append(cmd1)
cmd2 = {'output': None, 'command': ''}
cmd2['command'] = "interface %s" % self.interface
commands.append(cmd2)
if len(jbfValue) == 2:
self.jbf_cli = "jumboframe enable %s %s" % (
jbfValue[0], jbfValue[1])
else:
self.jbf_cli = "jumboframe enable %s" % (jbfValue[0])
cmd3 = {'output': None, 'command': ''}
cmd3['command'] = self.jbf_cli
commands.append(cmd3)
cmd4 = {'output': None, 'command': ''}
cmd4['command'] = 'commit'
commands.append(cmd4)
self.excute_command(commands)
self.changed = True
if self.state == "present":
if self.jbfMin:
self.updates_cmd.append(
"jumboframe enable %s %s" % (self.jbfMax, self.jbfMin))
else:
self.updates_cmd.append("jumboframe enable %s" % (self.jbfMax))
else:
self.updates_cmd.append("undo jumboframe enable")
return
def merge_interface(self, ifname, mtu):
""" Merge interface mtu."""
xmlstr = ''
change = False
self.updates_cmd.append("interface %s" % ifname)
if self.state == "present":
if mtu and self.intf_info["ifMtu"] != mtu:
xmlstr += CE_NC_XML_MERGE_INTF_MTU % (ifname, mtu)
self.updates_cmd.append("mtu %s" % mtu)
change = True
else:
if self.intf_info["ifMtu"] != '1500':
xmlstr += CE_NC_XML_MERGE_INTF_MTU % (ifname, '1500')
self.updates_cmd.append("undo mtu")
change = True
if not change:
return
conf_str = self.build_config_xml(xmlstr)
try:
con_obj = self.nc.set_config(config=conf_str)
self.check_response(con_obj, "MERGE_INTF_MTU")
self.changed = True
except RPCError as e:
self.module.fail_json(msg='Error: %s' % e.message)
def IsInterfaceSupportSetJumboframe(self, interface):
if interface is None:
return False
support_flag = False
if interface.upper().startswith('GE'):
support_flag = True
elif interface.upper().startswith('10GE'):
support_flag = True
elif interface.upper().startswith('25GE'):
support_flag = True
elif interface.upper().startswith('4X10GE'):
support_flag = True
elif interface.upper().startswith('40GE'):
support_flag = True
elif interface.upper().startswith('100GE'):
support_flag = True
else:
support_flag = False
return support_flag
def check_params(self):
"""Check all input params"""
# interface type check
if self.interface:
self.intf_type = self.get_interface_type(self.interface)
if not self.intf_type:
self.module.fail_json(
msg='Error: Interface name of %s '
'is error.' % self.interface)
if not self.intf_type:
self.module.fail_json(
msg='Error: Interface %s is error.')
# mtu check mtu
if self.mtu:
if not self.mtu.isdigit():
self.module.fail_json(msg='Error: Mtu is invalid.')
# check mtu range
if int(self.mtu) < 46 or int(self.mtu) > 9600:
self.module.fail_json(
msg='Error: Mtu is not in the range from 46 to 9600.')
# get interface info
self.intf_info = self.get_interface_dict(self.interface)
if not self.intf_info:
self.module.fail_json(msg='Error: interface does not exists.')
# check interface
if self.intf_info['isL2SwitchPort'] == 'true':
self.module.fail_json(msg='Error: L2Switch Port can not set mtu.')
# check interface can set jumbo frame
if self.state == 'present':
if self.jbfMax:
if not self.IsInterfaceSupportSetJumboframe(self.interface):
self.module.fail_json(
msg='Error: Interface %s does not support jumboframe set.' % self.interface)
if not self.jbfMax.isdigit():
self.module.fail_json(msg='Error: Max jumboframe is not digit.')
if (int(self.jbfMax) > 12288) or (int(self.jbfMax) < 1536):
self.module.fail_json(
msg='Error: Max jumboframe is between 1536 to 12288.')
if self.jbfMin:
if not self.jbfMin.isdigit():
self.module.fail_json(
msg='Error: Min jumboframe is not digit.')
if not self.jbfMax:
self.module.fail_json(
msg='Error: please specify max jumboframe value.')
if (int(self.jbfMin) > self.jbfMax) or (int(self.jbfMin) < 1518):
self.module.fail_json(
msg='Error: Min jumboframe is between '
'1518 to jumboframe max value.')
if self.jbfMin is not None:
if self.jbfMax is None:
self.module.fail_json(
msg='Error: please input MAX jumboframe '
'value.')
def get_proposed(self):
""" get_proposed"""
self.proposed['state'] = self.state
if self.interface:
self.proposed["interface"] = self.interface
if self.state == 'present':
if self.mtu:
self.proposed["mtu"] = self.mtu
if self.jbfMax:
if self.jbfMin:
self.proposed["jumboframe"] = "jumboframe enable %s %s" % (
self.jbfMax, self.jbfMin)
else:
self.proposed[
"jumboframe"] = "jumboframe enable %s %s" % (self.jbfMax, 1518)
def get_existing(self):
""" get_existing"""
if self.intf_info:
self.existing["interface"] = self.intf_info["ifName"]
self.existing["mtu"] = self.intf_info["ifMtu"]
if self.intf_info:
if not self.existing["interface"]:
self.existing["interface"] = self.interface
if len(self.jbfConfig) != 2:
return
self.existing["jumboframe"] = "jumboframe enable %s %s" % (
self.jbfConfig[0], self.jbfConfig[1])
def get_end_state(self):
""" get_end_state"""
if self.intf_info:
end_info = self.get_interface_dict(self.interface)
if end_info:
self.end_state["interface"] = end_info["ifName"]
self.end_state["mtu"] = end_info["ifMtu"]
if self.intf_info:
if not self.end_state["interface"]:
self.end_state["interface"] = self.interface
if self.state == 'absent':
self.end_state["jumboframe"] = "jumboframe enable %s %s" % (
9216, 1518)
elif not self.jbfMax and not self.jbfMin:
if len(self.jbfConfig) != 2:
return
self.end_state["jumboframe"] = "jumboframe enable %s %s" % (
self.jbfConfig[0], self.jbfConfig[1])
elif self.jbfMin:
self.end_state["jumboframe"] = "jumboframe enable %s %s" % (
self.jbfMax, self.jbfMin)
else:
self.end_state[
"jumboframe"] = "jumboframe enable %s %s" % (self.jbfMax, 1518)
def work(self):
"""worker"""
self.check_params()
self.get_proposed()
self.merge_interface(self.interface, self.mtu)
self.set_jumboframe()
self.get_existing()
self.get_end_state()
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.end_time = datetime.datetime.now()
self.results['execute_time'] = str(self.end_time - self.start_time)
self.module.exit_json(**self.results)
def main():
""" Module main function """
argument_spec = dict(
state=dict(choices=['present', 'absent'], default='present'),
acl_number=dict(type='str'),
usm_user_name=dict(type='str'),
remote_engine_id=dict(type='str'),
user_group=dict(type='str'),
auth_protocol=dict(choices=['noAuth', 'md5', 'sha']),
auth_key=dict(type='str', no_log=True),
priv_protocol=dict(choices=[
'noPriv', 'des56', '3des168', 'aes128', 'aes192', 'aes256'
]),
priv_key=dict(type='str', no_log=True),
aaa_local_user=dict(type='str'))
if not HAS_NCCLIENT:
raise Exception("the ncclient library is required")
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
supports_check_mode=True)
changed = False
proposed = dict()
existing = dict()
end_state = dict()
updates = []
state = module.params['state']
host = module.params['host']
port = module.params['port']
username = module.params['username']
password = module.params['password']
acl_number = module.params['acl_number']
usm_user_name = module.params['usm_user_name']
remote_engine_id = module.params['remote_engine_id']
user_group = module.params['user_group']
auth_protocol = module.params['auth_protocol']
auth_key = module.params['auth_key']
priv_protocol = module.params['priv_protocol']
priv_key = module.params['priv_key']
aaa_local_user = module.params['aaa_local_user']
snmp_user_obj = SnmpUser(host=host,
port=port,
username=username,
password=password)
if not snmp_user_obj:
module.fail_json(msg='Error: Init module failed.')
# get proposed
proposed["state"] = state
if acl_number:
proposed["acl_number"] = acl_number
if usm_user_name:
proposed["usm_user_name"] = usm_user_name
if remote_engine_id:
proposed["remote_engine_id"] = remote_engine_id
if user_group:
proposed["user_group"] = user_group
if auth_protocol:
proposed["auth_protocol"] = auth_protocol
if auth_key:
proposed["auth_key"] = auth_key
if priv_protocol:
proposed["priv_protocol"] = priv_protocol
if priv_key:
proposed["priv_key"] = priv_key
if aaa_local_user:
proposed["aaa_local_user"] = aaa_local_user
snmp_v3_usm_user_rst = snmp_user_obj.check_snmp_v3_usm_user_args(
module=module)
snmp_v3_local_user_rst = snmp_user_obj.check_snmp_v3_local_user_args(
module=module)
snmp_user_obj.get_snmp_local_engine(module=module)
# state exist snmp v3 user config
exist_tmp = dict()
for item in snmp_v3_usm_user_rst:
if item != "need_cfg":
exist_tmp[item] = snmp_v3_usm_user_rst[item]
if exist_tmp:
existing["snmp usm user"] = exist_tmp
exist_tmp = dict()
for item in snmp_v3_local_user_rst:
if item != "need_cfg":
exist_tmp[item] = snmp_v3_local_user_rst[item]
if exist_tmp:
existing["snmp local user"] = exist_tmp
if state == "present":
if snmp_v3_usm_user_rst["need_cfg"]:
if len(snmp_v3_usm_user_rst["usm_user_info"]) != 0:
cmd = snmp_user_obj.merge_snmp_v3_usm_user(module=module)
changed = True
updates.append(cmd)
else:
cmd = snmp_user_obj.create_snmp_v3_usm_user(module=module)
changed = True
updates.append(cmd)
if snmp_v3_local_user_rst["need_cfg"]:
if len(snmp_v3_local_user_rst["local_user_info"]) != 0:
cmd = snmp_user_obj.merge_snmp_v3_local_user(module=module)
changed = True
updates.append(cmd)
else:
cmd = snmp_user_obj.create_snmp_v3_local_user(module=module)
changed = True
updates.append(cmd)
else:
if snmp_v3_usm_user_rst["need_cfg"]:
cmd = snmp_user_obj.delete_snmp_v3_usm_user(module=module)
changed = True
updates.append(cmd)
if snmp_v3_local_user_rst["need_cfg"]:
cmd = snmp_user_obj.delete_snmp_v3_local_user(module=module)
changed = True
updates.append(cmd)
# state exist snmp v3 user config
snmp_v3_usm_user_rst = snmp_user_obj.check_snmp_v3_usm_user_args(
module=module)
end_tmp = dict()
for item in snmp_v3_usm_user_rst:
if item != "need_cfg":
end_tmp[item] = snmp_v3_usm_user_rst[item]
if end_tmp:
end_state["snmp usm user"] = end_tmp
snmp_v3_local_user_rst = snmp_user_obj.check_snmp_v3_local_user_args(
module=module)
end_tmp = dict()
for item in snmp_v3_local_user_rst:
if item != "need_cfg":
end_tmp[item] = snmp_v3_local_user_rst[item]
if end_tmp:
end_state["snmp local user"] = end_tmp
results = dict()
results['proposed'] = proposed
results['existing'] = existing
results['changed'] = changed
results['end_state'] = end_state
results['updates'] = updates
module.exit_json(**results)
def main():
spec = dict(
# { command: <str>, output: <str>, prompt: <str>, response: <str> }
commands=dict(type='list', required=True),
wait_for=dict(type='list', aliases=['waitfor']),
match=dict(default='all', choices=['all', 'any']),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int')
)
module = NetworkModule(argument_spec=spec,
supports_check_mode=True)
commands = list(parse_commands(module))
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
for cmd in commands:
if module.check_mode and not cmd['command'].startswith('show'):
warnings.append('only show commands are supported when using '
'check mode, not executing `%s`' % cmd['command'])
else:
if cmd['command'].startswith('conf'):
module.fail_json(msg='eos_command does not support running '
'config mode commands. Please use '
'eos_config instead')
try:
runner.add_command(**cmd)
except AddCommandError:
exc = get_exception()
warnings.append('duplicate command detected: %s' % cmd)
try:
for item in conditionals:
runner.add_conditional(item)
except AddConditionError:
exc = get_exception()
module.fail_json(msg=str(exc), condition=exc.condition)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
runner.match = module.params['match']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
result = dict(changed=False, stdout=list())
for cmd in commands:
try:
output = runner.get_command(cmd['command'], cmd.get('output'))
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
def main():
spec = dict(gather_subset=dict(default=['!config'], type='list'))
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params['gather_subset']
runable_subsets = set()
exclude_subsets = set()
for subset in gather_subset:
if subset == 'all':
runable_subsets.update(VALID_SUBSETS)
continue
if subset.startswith('!'):
subset = subset[1:]
if subset == 'all':
exclude_subsets.update(VALID_SUBSETS)
continue
exclude = True
else:
exclude = False
if subset not in VALID_SUBSETS:
module.fail_json(msg='Bad subset')
if exclude:
exclude_subsets.add(subset)
else:
runable_subsets.add(subset)
if not runable_subsets:
runable_subsets.update(VALID_SUBSETS)
runable_subsets.difference_update(exclude_subsets)
runable_subsets.add('default')
facts = dict()
facts['gather_subset'] = list(runable_subsets)
instances = list()
for key in runable_subsets:
instances.append(FACT_SUBSETS[key](module))
failed_commands = list()
try:
for inst in instances:
inst.populate()
failed_commands.extend(inst.failed_commands)
facts.update(inst.facts)
except Exception as exc:
module.fail_json(msg=to_native(exc), exception=traceback.format_exc())
ansible_facts = dict()
for key, value in iteritems(facts):
key = 'ansible_net_%s' % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts,
failed_commands=failed_commands)
def main():
argument_spec = dict(lines=dict(aliases=['commands'], type='list'),
parents=dict(type='list'),
src=dict(type='path'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(
default='line',
choices=['line', 'strict', 'exact', 'none']),
replace=dict(default='line',
choices=['line', 'block']),
update_config=dict(type='bool', default=False),
backup_config=dict(type='bool', default=False))
argument_spec.update(ios_argument_spec)
mutually_exclusive = [('lines', 'src')]
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
module.check_mode = not module.params['update_config']
parents = module.params['parents'] or list()
match = module.params['match']
replace = module.params['replace']
warnings = list()
invoke('check_args', module, warnings)
result = dict(changed=False, saved=False)
candidate = get_candidate(module)
if module.params['match'] != 'none':
config = get_config(module)
configobjs = candidate.difference(config, match=match, replace=replace)
else:
configobjs = candidate.items
if module.params['backup_config']:
result['__backup__'] = module.cli('show running-config')[0]
commands = list()
if configobjs:
commands = dumps(configobjs, 'commands')
commands = commands.split('\n')
if module.params['before']:
commands[:0] = module.params['before']
if module.params['after']:
commands.extend(module.params['after'])
if not module.check_mode:
response = load_config(module, commands, nodiff=True)
result.update(**response)
result['changed'] = True
result['updates'] = commands
result['connected'] = module.connected
module.exit_json(**result)
def main():
argument_spec = dict(lines=dict(aliases=['commands'], type='list'),
parents=dict(type='list'),
src=dict(type='path'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(
default='line',
choices=['line', 'strict', 'exact', 'none']),
replace=dict(default='line',
choices=['line', 'block']),
update=dict(choices=['merge', 'check'],
default='merge'),
save=dict(type='bool', default=False),
config=dict(),
backup=dict(type='bool', default=False))
mutually_exclusive = [('lines', 'src')]
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
parents = module.params['parents'] or list()
match = module.params['match']
replace = module.params['replace']
result = dict(changed=False, saved=False)
candidate = get_candidate(module)
if match != 'none':
config = get_config(module)
if parents:
contents = get_sublevel_config(config, module)
config = NetworkConfig(contents=contents, indent=1)
configobjs = candidate.difference(config, match=match, replace=replace)
else:
configobjs = candidate.items
if module.params['backup']:
result['__backup__'] = module.cli('show running-config')[0]
commands = list()
if configobjs:
commands = dumps(configobjs, 'commands')
commands = commands.split('\n')
if module.params['before']:
commands[:0] = module.params['before']
if module.params['after']:
commands.extend(module.params['after'])
if not module.check_mode and module.params['update'] == 'merge':
response = module.config.load_config(commands)
result['responses'] = response
if module.params['save']:
module.config.save_config()
result['saved'] = True
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
spec = dict(
# { command: <str>, output: <str>, prompt: <str>, response: <str> }
commands=dict(type='list', required=True),
wait_for=dict(type='list', aliases=['waitfor']),
match=dict(default='all', choices=['any', 'all']),
retries=dict(default=10, type='int'),
interval=dict(default=1, type='int')
)
module = NetworkModule(argument_spec=spec,
supports_check_mode=True)
commands = list(parse_commands(module))
conditionals = module.params['wait_for'] or list()
warnings = list()
runner = CommandRunner(module)
try:
# This tries to detect command mode.
runner.add_command('tmsh')
runner.run()
shell = "bash"
except NetworkError:
shell = "tmsh"
# Resets the runner because raised exceptions do not remove the
# erroneous commands
module.disconnect()
runner.commands = []
runner.module.cli._commands = []
for cmd in commands:
cmd = strip_tmsh_prefix(cmd)
if module.check_mode and not is_config_mode_command(cmd):
warnings.append('only show or list commands are supported when '
'using check mode, not executing `%s`'
% cmd['command'])
else:
if is_config_mode_command(cmd):
module.fail_json(msg='bigip_command does not support running '
'config mode commands. Please use '
'bigip_config instead')
try:
if shell == 'tmsh':
disable_pager = dict(
output=None,
command='modify cli preference pager disabled'
)
runner.add_command(**disable_pager)
runner.add_command(**cmd)
else:
disable_pager = dict(
output=None,
command='tmsh modify cli preference pager disabled'
)
cmd['command'] = 'tmsh ' + cmd['command']
runner.add_command(**disable_pager)
runner.add_command(**cmd)
except AddCommandError:
warnings.append('Duplicate command detected: %s' % cmd)
try:
for item in conditionals:
runner.add_conditional(item)
except AddConditionError:
exc = get_exception()
module.fail_json(msg=str(exc), condition=exc.condition)
runner.retries = module.params['retries']
runner.interval = module.params['interval']
runner.match = module.params['match']
try:
runner.run()
except FailedConditionsError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditions=exc.failed_conditions)
except FailedConditionalError:
exc = get_exception()
module.fail_json(msg=str(exc), failed_conditional=exc.failed_conditional)
except NetworkError:
exc = get_exception()
module.fail_json(msg=str(exc), **exc.kwargs)
result = dict(changed=False)
result['stdout'] = list()
for cmd in commands:
try:
output = runner.get_command(cmd['command'], cmd.get('output'))
except ValueError:
output = 'command not executed due to check_mode, see warnings'
result['stdout'].append(output)
result['warnings'] = warnings
result['stdout_lines'] = list(to_lines(result['stdout']))
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
src=dict(type='str'),
force=dict(default=False, type='bool'),
backup=dict(default=False, type='bool'),
config=dict(type='dict'),
)
mutually_exclusive = [('config', 'backup'), ('config', 'force')]
module = NetworkModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
if not module.params['transport'] and not HAS_OPS:
module.fail_json(msg='unable to import ops.dc library')
result = dict(changed=False)
contents = get_config(module)
result['_backup'] = contents
if module.params['transport'] in ['ssh', 'rest']:
config = contents
try:
src = module.from_json(module.params['src'])
except ValueError:
module.fail_json(msg='unable to load src due to json parsing error')
changeset = diff(src, config)
candidate = merge(changeset, config)
updates = dict()
for path, key, new_value, old_value in changeset:
path = '%s.%s' % ('.'.join(path), key)
updates[path] = str(new_value)
result['updates'] = updates
if changeset:
if not module.check_mode:
module.config(config)
result['changed'] = True
else:
candidate = NetworkConfig(contents=module.params['src'], indent=4)
if contents:
config = NetworkConfig(contents=contents, indent=4)
if not module.params['force']:
commands = candidate.difference(config)
commands = dumps(commands, 'commands').split('\n')
commands = [str(c) for c in commands if c]
else:
commands = str(candidate).split('\n')
if commands:
if not module.check_mode:
response = module.config(commands)
result['responses'] = response
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def main():
spec = dict(
gather_subset=dict(default=['!config'], type='list'),
# the next two arguments are legacy from pre 2.2 ops_facts
# these will be deprecated and ultimately removed
config=dict(default=False, type='bool'),
endpoints=dict(type='list'),
transport=dict(default='cli', choices=['cli', 'rest'])
)
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params['gather_subset']
warnings = list()
check_args(module, warnings)
runable_subsets = set()
exclude_subsets = set()
for subset in gather_subset:
if subset == 'all':
runable_subsets.update(VALID_SUBSETS)
continue
if subset.startswith('!'):
subset = subset[1:]
if subset == 'all':
exclude_subsets.update(VALID_SUBSETS)
continue
exclude = True
else:
exclude = False
if subset not in VALID_SUBSETS:
module.fail_json(msg='Bad subset')
if exclude:
exclude_subsets.add(subset)
else:
runable_subsets.add(subset)
if not runable_subsets:
runable_subsets.update(VALID_SUBSETS)
runable_subsets.difference_update(exclude_subsets)
runable_subsets.add('default')
runable_subsets.add('legacy')
facts = dict()
facts['gather_subset'] = list(runable_subsets)
runner = CommandRunner(module)
instances = list()
for key in runable_subsets:
instances.append(FACT_SUBSETS[key](module, runner))
if module.params['transport'] == 'cli':
runner.run()
try:
for inst in instances:
inst.populate()
facts.update(inst.facts)
except Exception:
module.exit_json(out=module.from_json(runner.items))
ansible_facts = dict()
for key, value in iteritems(facts):
# this is to maintain capability with ops_facts 2.1
if key.startswith('_'):
ansible_facts[key[1:]] = value
else:
key = 'ansible_net_%s' % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts, warnings=warnings)
class EvpnBgpRr(object):
"""Manange RR in BGP-EVPN address family view"""
def __init__(self, argument_spec):
self.spec = argument_spec
self.module = None
self.__init_module__()
# RR configuration parameters
self.as_number = self.module.params['as_number']
self.bgp_instance = self.module.params['bgp_instance']
self.peer_type = self.module.params['peer_type']
self.peer = self.module.params['peer']
self.bgp_evpn_enable = self.module.params['bgp_evpn_enable']
self.reflect_client = self.module.params['reflect_client']
self.policy_vpn_target = self.module.params['policy_vpn_target']
self.commands = list()
self.config = None
self.bgp_evpn_config = ""
self.cur_config = dict()
self.conf_exist = False
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.password = self.module.params['password']
self.port = self.module.params['port']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
def __init_module__(self):
"""init module"""
self.module = NetworkModule(argument_spec=self.spec,
connect_on_load=False,
supports_check_mode=True)
def cli_load_config(self, commands):
"""load config by cli"""
if not self.module.check_mode:
try:
self.module.config.load_config(commands)
except NetworkError:
err = get_cli_exception()
self.module.fail_json(msg=err)
def is_bgp_view_exist(self):
"""judge whether BGP view has existed"""
if self.bgp_instance:
view_cmd = "bgp %s instance %s" % (self.as_number,
self.bgp_instance)
else:
view_cmd = "bgp %s" % self.as_number
return is_config_exist(self.config, view_cmd)
def is_l2vpn_family_evpn_exist(self):
"""judge whether BGP-EVPN address family view has existed"""
view_cmd = "l2vpn-family evpn"
return is_config_exist(self.config, view_cmd)
def is_reflect_client_exist(self):
"""judge whether reflect client is configured"""
view_cmd = "peer %s reflect-client" % self.peer
return is_config_exist(self.bgp_evpn_config, view_cmd)
def is_policy_vpn_target_exist(self):
"""judge whether the VPN-Target filtering is enabled"""
view_cmd = "undo policy vpn-target"
if is_config_exist(self.bgp_evpn_config, view_cmd):
return False
else:
return True
def get_config_in_bgp_view(self):
"""get configuration in BGP view"""
exp = " | section include"
if self.as_number:
if self.bgp_instance:
exp += " bgp %s instance %s" % (self.as_number,
self.bgp_instance)
else:
exp += " bgp %s" % self.as_number
return self.module.config.get_config(include_defaults=False,
regular=exp)
def get_config_in_bgp_evpn_view(self):
"""get configuration in BGP_EVPN view"""
self.bgp_evpn_config = ""
if not self.config:
return ""
index = self.config.find("l2vpn-family evpn")
if index == -1:
return ""
return self.config[index:]
def get_current_config(self):
"""get current configuration"""
if not self.as_number:
self.module.fail_json(
msg='Error: The value of as-number cannot be empty.')
self.cur_config['bgp_exist'] = False
self.cur_config['bgp_evpn_enable'] = 'false'
self.cur_config['reflect_client'] = 'false'
self.cur_config['policy_vpn_target'] = 'false'
self.cur_config['peer_type'] = None
self.cur_config['peer'] = None
self.config = self.get_config_in_bgp_view()
if not self.is_bgp_view_exist():
return
self.cur_config['bgp_exist'] = True
if not self.is_l2vpn_family_evpn_exist():
return
self.cur_config['bgp_evpn_enable'] = 'true'
self.bgp_evpn_config = self.get_config_in_bgp_evpn_view()
if self.is_reflect_client_exist():
self.cur_config['reflect_client'] = 'true'
self.cur_config['peer_type'] = self.peer_type
self.cur_config['peer'] = self.peer
if self.is_policy_vpn_target_exist():
self.cur_config['policy_vpn_target'] = 'true'
def get_existing(self):
"""get existing config"""
self.existing = dict(
as_number=self.as_number,
bgp_instance=self.bgp_instance,
peer_type=self.cur_config['peer_type'],
peer=self.cur_config['peer'],
bgp_evpn_enable=self.cur_config['bgp_evpn_enable'],
reflect_client=self.cur_config['reflect_client'],
policy_vpn_target=self.cur_config['policy_vpn_target'])
def get_proposed(self):
"""get proposed config"""
self.proposed = dict(as_number=self.as_number,
bgp_instance=self.bgp_instance,
peer_type=self.peer_type,
peer=self.peer,
bgp_evpn_enable=self.bgp_evpn_enable,
reflect_client=self.reflect_client,
policy_vpn_target=self.policy_vpn_target)
def get_end_state(self):
"""get end config"""
self.get_current_config()
self.end_state = dict(
as_number=self.as_number,
bgp_instance=self.bgp_instance,
peer_type=self.cur_config['peer_type'],
peer=self.cur_config['peer'],
bgp_evpn_enable=self.cur_config['bgp_evpn_enable'],
reflect_client=self.cur_config['reflect_client'],
policy_vpn_target=self.cur_config['policy_vpn_target'])
def show_result(self):
""" show result"""
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.module.exit_json(**self.results)
def judge_if_config_exist(self):
""" judge whether configuration has existed"""
if self.bgp_evpn_enable and self.bgp_evpn_enable != self.cur_config[
'bgp_evpn_enable']:
return False
if self.bgp_evpn_enable == 'false' and self.cur_config[
'bgp_evpn_enable'] == 'false':
return True
if self.reflect_client and self.reflect_client == 'true':
if self.peer_type and self.peer_type != self.cur_config[
'peer_type']:
return False
if self.peer and self.peer != self.cur_config['peer']:
return False
if self.reflect_client and self.reflect_client != self.cur_config[
'reflect_client']:
return False
if self.policy_vpn_target and self.policy_vpn_target != self.cur_config[
'policy_vpn_target']:
return False
return True
def cli_add_command(self, command, undo=False):
"""add command to self.update_cmd and self.commands"""
if undo and command.lower() not in ["quit", "return"]:
cmd = "undo " + command
else:
cmd = command
self.commands.append(cmd) # set to device
if command.lower() not in ["quit", "return"]:
self.updates_cmd.append(cmd) # show updates result
def config_rr(self):
"""configure RR"""
if self.conf_exist:
return
if self.bgp_instance:
view_cmd = "bgp %s instance %s" % (self.as_number,
self.bgp_instance)
else:
view_cmd = "bgp %s" % self.as_number
self.cli_add_command(view_cmd)
if self.bgp_evpn_enable == 'false':
self.cli_add_command(" undo l2vpn-family evpn")
else:
self.cli_add_command(" l2vpn-family evpn")
if self.reflect_client and self.reflect_client != self.cur_config[
'reflect_client']:
if self.reflect_client == 'true':
self.cli_add_command(" peer %s enable" % self.peer)
self.cli_add_command(" peer %s reflect-client" %
self.peer)
else:
self.cli_add_command(" undo peer %s reflect-client" %
self.peer)
self.cli_add_command(" undo peer %s enable" % self.peer)
if self.cur_config['bgp_evpn_enable'] == 'true':
if self.policy_vpn_target and self.policy_vpn_target != self.cur_config[
'policy_vpn_target']:
if self.policy_vpn_target == 'true':
self.cli_add_command(" policy vpn-target")
else:
self.cli_add_command(" undo policy vpn-target")
else:
if self.policy_vpn_target and self.policy_vpn_target == 'false':
self.cli_add_command(" undo policy vpn-target")
if self.commands:
self.cli_load_config(self.commands)
self.changed = True
def check_is_ipv4_addr(self):
"""check ipaddress validate"""
rule1 = r'(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.'
rule2 = r'(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])'
ipv4_regex = '%s%s%s%s%s%s' % ('^', rule1, rule1, rule1, rule2, '$')
return bool(re.match(ipv4_regex, self.peer))
def check_params(self):
"""Check all input params"""
if self.cur_config['bgp_exist'] == 'false':
self.module.fail_json(msg="Error: BGP view doesnot exist.")
if self.bgp_instance:
if len(self.bgp_instance) < 1 or len(self.bgp_instance) > 31:
self.module.fail_json(
msg=
"Error: The length of BGP instance-name must be between 1 or a string of 1 to and 31."
)
if self.as_number:
if len(self.as_number) > 11 or len(self.as_number) == 0:
self.module.fail_json(
msg='Error: The len of as_number %s is out of [1 - 11].' %
self.as_number)
tmp_dict1 = dict(peer_type=self.peer_type,
peer=self.peer,
reflect_client=self.reflect_client)
tmp_dict2 = dict((k, v) for k, v in tmp_dict1.items() if v is not None)
if len(tmp_dict2) != 0 and len(tmp_dict2) != 3:
self.module.fail_json(
msg=
'Error: The peer, peer_type, and reflect_client arguments must all exist or not exist.'
)
if self.peer_type:
if self.peer_type == 'ipv4_address' and not self.check_is_ipv4_addr(
):
self.module.fail_json(msg='Error: Illegal IPv4 address.')
elif self.peer_type == 'group_name' and self.check_is_ipv4_addr():
self.module.fail_json(
msg='Error: Ip address cannot be configured as group-name.'
)
def work(self):
"""excute task"""
self.get_current_config()
self.check_params()
self.get_existing()
self.get_proposed()
self.conf_exist = self.judge_if_config_exist()
self.config_rr()
self.get_end_state()
self.show_result()
class Ntp(object):
"""ntp class"""
def __init__(self, argument_spec):
self.start_time = datetime.datetime.now()
self.end_time = None
self.spec = argument_spec
self.module = None
self.netconf = None
self.mutually_exclusive = [('server', 'peer')]
self.init_module()
# ntp configration info
self.server = self.module.params['server'] or None
self.peer = self.module.params['peer'] or None
self.key_id = self.module.params['key_id']
self.is_preferred = self.module.params['is_preferred']
self.vpn_name = self.module.params['vpn_name']
self.interface = self.module.params['source_int'] or ""
self.state = self.module.params['state']
self.ntp_conf = dict()
self.conf_exsit = False
self.ip_ver = 'IPv4'
# host info
self.host = self.module.params['host']
self.username = self.module.params['username']
self.port = self.module.params['port']
if self.server:
self.peer_type = 'Server'
self.address = self.server
elif self.peer:
self.peer_type = 'Peer'
self.address = self.peer
else:
self.peer_type = None
self.address = None
self.check_params()
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = list()
self.end_state = list()
# init netconf connect
self.init_netconf()
self.init_data()
def init_data(self):
""" init_data"""
if self.interface is not None:
self.interface = self.interface.lower()
if not self.key_id:
self.key_id = ""
if not self.is_preferred:
self.is_preferred = 'false'
def init_module(self):
""" init_module"""
self.module = NetworkModule(argument_spec=self.spec, supports_check_mode=True,
mutually_exclusive=self.mutually_exclusive)
def init_netconf(self):
""" init_netconf"""
if HAS_NCCLIENT:
self.netconf = get_netconf(host=self.host, port=self.port,
username=self.username,
password=self.module.params['password'])
else:
self.module.fail_json(
msg='Error: No ncclient package, please install it.')
def check_ipaddr_validate(self):
""" check_ipaddr_validate"""
rule1 = r'(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.'
rule2 = r'(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])'
ipv4_regex = '%s%s%s%s%s%s' % ('^', rule1, rule1, rule1, rule2, '$')
ipv6_regex = '^(?:[a-fA-F0-9]{1,4}:){7}[a-fA-F0-9]{1,4}$'
flag = False
if bool(re.match(ipv4_regex, self.address)):
flag = True
self.ip_ver = "IPv4"
if not self.ntp_ucast_ipv4_validate():
flag = False
elif bool(re.match(ipv6_regex, self.address)):
flag = True
self.ip_ver = "IPv6"
else:
flag = True
self.ip_ver = "IPv6"
if not flag:
if self.peer_type == "Server":
self.module.fail_json(msg='Illegal server ip-address.')
else:
self.module.fail_json(msg='Illegal peer ip-address.')
def ntp_ucast_ipv4_validate(self):
"""ntp_ucast_ipv4_validate"""
addr_list = re.findall(r'(.*)\.(.*)\.(.*)\.(.*)', self.address)
if not addr_list:
self.module.fail_json(msg='Match ip-address fail.')
value = ((long(addr_list[0][0])) * 0x1000000) + (long(addr_list[0][1])\
* 0x10000) + (long(addr_list[0][2]) * 0x100) + (long(addr_list[0][3]))
if (value & (0xff000000) == 0x7f000000) or (value & (0xF0000000) == 0xF0000000) \
or (value & (0xF0000000) == 0xE0000000) or (value == 0):
return False
return True
def check_params(self):
"""Check all input params"""
# check interface type
if self.interface:
intf_type = get_interface_type(self.interface)
if not intf_type:
self.module.fail_json(
msg='Error: Interface name of %s '
'is error.' % self.interface)
if not self.server and not self.peer:
self.module.fail_json(
msg='Please supply the server or peer parameter')
if self.vpn_name:
if (len(self.vpn_name) < 1) or (len(self.vpn_name) > 31):
self.module.fail_json(
msg='VPN name length is beetween 1 and 31.')
if self.address:
self.check_ipaddr_validate()
def check_response(self, con_obj, xml_name):
"""Check if response message is already succeed."""
xml_str = con_obj.xml
if "<ok/>" not in xml_str:
self.module.fail_json(msg='Error: %s failed.' % xml_name)
def netconf_get_config(self, xml_str):
""" netconf get config """
try:
con_obj = self.netconf.get_config(filter=xml_str)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' % err.message.replace("\r\n", ""))
return con_obj
def netconf_set_config(self, xml_str, xml_name):
""" netconf set config """
try:
con_obj = self.netconf.set_config(config=xml_str)
self.check_response(con_obj, xml_name)
except RPCError:
err = sys.exc_info()[1]
self.module.fail_json(msg='Error: %s' % err.message.replace("\r\n", ""))
return con_obj
def set_ntp(self, *args):
"""configure ntp parameters"""
if self.state == 'present':
if self.ip_ver == 'IPv4':
xml_str = CE_NC_MERGE_NTP_CONFIG % (
args[0], args[1], '::', args[2], args[3], args[4], args[5], args[6])
elif self.ip_ver == 'IPv6':
xml_str = CE_NC_MERGE_NTP_CONFIG % (
args[0], '0.0.0.0', args[1], args[2], args[3], args[4], args[5], args[6])
self.netconf_set_config(xml_str, "NTP_CORE_CONFIG")
else:
if self.ip_ver == 'IPv4':
xml_str = CE_NC_DELETE_NTP_CONFIG % (
args[0], args[1], '::', args[2], args[3])
elif self.ip_ver == 'IPv6':
xml_str = CE_NC_DELETE_NTP_CONFIG % (
args[0], '0.0.0.0', args[1], args[2], args[3])
self.netconf_set_config(xml_str, "UNDO_NTP_CORE_CONFIG")
def config_ntp(self):
"""config ntp"""
if self.state == "present":
if self.address and not self.conf_exsit:
self.set_ntp(self.ip_ver, self.address, self.peer_type,
self.vpn_name, self.key_id, self.is_preferred, self.interface)
self.changed = True
else:
if self.address:
self.set_ntp(self.ip_ver, self.address,
self.peer_type, self.vpn_name, '', '', '')
self.changed = True
def show_result(self):
"""show_result"""
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
if self.changed:
self.results['updates'] = self.updates_cmd
else:
self.results['updates'] = list()
self.end_time = datetime.datetime.now()
self.results['execute_time'] = str(self.end_time - self.start_time)
self.module.exit_json(**self.results)
def get_ntp_exist_config(self):
"""get ntp existed config"""
ntp_config = list()
conf_str = CE_NC_GET_NTP_CONFIG
con_obj = self.netconf_get_config(conf_str)
if "<data/>" in con_obj.xml:
return ntp_config
xml_str = con_obj.xml.replace('\r', '').replace('\n', '').\
replace('xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"', "").\
replace('xmlns="http://www.huawei.com/netconf/vrp"', "")
# get all ntp config info
root = ElementTree.fromstring(xml_str)
ntpsite = root.findall("data/ntp/ntpUCastCfgs/ntpUCastCfg")
for nexthop in ntpsite:
ntp_dict = dict()
for ele in nexthop:
if ele.tag in ["addrFamily", "vpnName", "ifName", "ipv4Addr",
"ipv6Addr", "type", "isPreferred", "keyId"]:
ntp_dict[ele.tag] = ele.text
ip_addr = ntp_dict['ipv6Addr']
if ntp_dict['addrFamily'] == "IPv4":
ip_addr = ntp_dict['ipv4Addr']
if ntp_dict['ifName'] is None:
ntp_dict['ifName'] = ""
if self.state == "present":
key_id = ntp_dict['keyId'] or ""
cur_ntp_cfg = dict(vpn_name=ntp_dict['vpnName'], source_int=ntp_dict['ifName'].lower(), address=ip_addr,
peer_type=ntp_dict['type'], prefer=ntp_dict['isPreferred'], key_id=key_id)
exp_ntp_cfg = dict(vpn_name=self.vpn_name, source_int=self.interface.lower(), address=self.address,
peer_type=self.peer_type, prefer=self.is_preferred, key_id=self.key_id)
if cmp(cur_ntp_cfg, exp_ntp_cfg) == 0:
self.conf_exsit = True
vpn_name = ntp_dict['vpnName']
if ntp_dict['vpnName'] == "_public_":
vpn_name = None
if_name = ntp_dict['ifName']
if if_name == "":
if_name = None
if self.peer_type == 'Server':
ntp_config.append(dict(vpn_name=vpn_name,
source_int=if_name, server=ip_addr,
is_preferred=ntp_dict['isPreferred'], key_id=ntp_dict['keyId']))
else:
ntp_config.append(dict(vpn_name=vpn_name,
source_int=if_name, peer=ip_addr,
is_preferred=ntp_dict['isPreferred'], key_id=ntp_dict['keyId']))
return ntp_config
def get_existing(self):
"""get existing info"""
if self.address:
self.existing = self.get_ntp_exist_config()
def get_proposed(self):
"""get proposed info"""
if self.address:
vpn_name = self.vpn_name
if vpn_name == "_public_":
vpn_name = None
if_name = self.interface
if if_name == "":
if_name = None
key_id = self.key_id
if key_id == "":
key_id = None
if self.peer_type == 'Server':
self.proposed = dict(state=self.state, vpn_name=vpn_name,
source_int=if_name, server=self.address,
is_preferred=self.is_preferred, key_id=key_id)
else:
self.proposed = dict(state=self.state, vpn_name=vpn_name,
source_int=if_name, peer=self.address,
is_preferred=self.is_preferred, key_id=key_id)
def get_end_state(self):
"""get end state info"""
if self.address:
self.end_state = self.get_ntp_exist_config()
def get_update_cmd(self):
"""get_update_cmd"""
if self.conf_exsit:
return
cli_str = ""
if self.state == "present":
if self.address:
if self.peer_type == 'Server':
if self.ip_ver == "IPv4":
cli_str = "%s %s" % (
"ntp unicast-server", self.address)
else:
cli_str = "%s %s" % (
"ntp unicast-server ipv6", self.address)
elif self.peer_type == 'Peer':
if self.ip_ver == "IPv4":
cli_str = "%s %s" % ("ntp unicast-peer", self.address)
else:
cli_str = "%s %s" % (
"ntp unicast-peer ipv6", self.address)
if self.key_id:
cli_str = "%s %s %s" % (
cli_str, "authentication-keyid", self.key_id)
if self.interface:
cli_str = "%s %s %s" % (
cli_str, "source-interface", self.interface)
if (self.vpn_name) and (self.vpn_name != '_public_'):
cli_str = "%s %s %s" % (
cli_str, "vpn-instance", self.vpn_name)
if self.is_preferred == "true":
cli_str = "%s %s" % (cli_str, "preferred")
else:
if self.address:
if self.peer_type == 'Server':
if self.ip_ver == "IPv4":
cli_str = "%s %s" % (
"undo ntp unicast-server", self.address)
else:
cli_str = "%s %s" % (
"undo ntp unicast-server ipv6", self.address)
elif self.peer_type == 'Peer':
if self.ip_ver == "IPv4":
cli_str = "%s %s" % (
"undo ntp unicast-peer", self.address)
else:
cli_str = "%s %s" % (
"undo ntp unicast-peer ipv6", self.address)
if (self.vpn_name) and (self.vpn_name != '_public_'):
cli_str = "%s %s" % (cli_str, self.vpn_name)
self.updates_cmd.append(cli_str)
def work(self):
"""work"""
self.get_existing()
self.get_proposed()
self.config_ntp()
self.get_update_cmd()
self.get_end_state()
self.show_result()
def main():
argument_spec = dict(
lines=dict(aliases=['commands'], type='list'),
parents=dict(type='list'),
src=dict(type='path'),
before=dict(type='list'),
after=dict(type='list'),
match=dict(default='line',
choices=['line', 'strict', 'exact', 'none']),
replace=dict(default='line', choices=['line', 'block']),
update=dict(choices=['merge', 'check'], default='merge'),
save=dict(type='bool', default=False),
config=dict(),
backup=dict(type='bool', default=False)
)
mutually_exclusive = [('lines', 'src')]
module = NetworkModule(argument_spec=argument_spec,
connect_on_load=False,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
parents = module.params['parents'] or list()
match = module.params['match']
replace = module.params['replace']
result = dict(changed=False, saved=False)
candidate = get_candidate(module)
if match != 'none':
config = get_config(module)
if parents:
config = get_sublevel_config(config, module)
configobjs = candidate.difference(config, match=match, replace=replace)
else:
configobjs = candidate.items
if module.params['backup']:
result['__backup__'] = module.cli('show running-config')[0]
commands = list()
if configobjs:
commands = dumps(configobjs, 'commands')
commands = commands.split('\n')
if module.params['before']:
commands[:0] = module.params['before']
if module.params['after']:
commands.extend(module.params['after'])
if not module.check_mode and module.params['update'] == 'merge':
response = module.config.load_config(commands)
result['responses'] = response
if module.params['save']:
module.config.save_config()
result['saved'] = True
result['changed'] = True
result['updates'] = commands
module.exit_json(**result)
def get_network_module(**kwargs):
try:
return get_module(**kwargs)
except NameError:
return NetworkModule(**kwargs)
class SnmpLocation(object):
""" Manages SNMP location configuration """
def __init__(self, **kwargs):
""" Class init """
# module
argument_spec = kwargs["argument_spec"]
self.spec = argument_spec
self.module = NetworkModule(argument_spec=self.spec,
connect_on_load=False,
supports_check_mode=True)
# config
self.cur_cfg = dict()
# module args
self.state = self.module.params['state']
self.location = self.module.params['location']
# state
self.changed = False
self.updates_cmd = list()
self.results = dict()
self.proposed = dict()
self.existing = dict()
self.end_state = dict()
def check_args(self):
""" Check invalid args """
if self.location:
if len(self.location) > 255 or len(self.location) < 1:
self.module.fail_json(
msg='Error: The len of location %s is out of [1 - 255].' %
self.location)
else:
self.module.fail_json(msg='Error: The len of location is 0.')
def get_proposed(self):
""" Get proposed state """
self.proposed["state"] = self.state
if self.location:
self.proposed["location"] = self.location
def get_existing(self):
""" Get existing state """
tmp_cfg = self.cli_get_config()
if tmp_cfg:
temp_data = tmp_cfg.split(r"location ")
self.cur_cfg["location"] = temp_data[1]
self.existing["location"] = temp_data[1]
def get_end_state(self):
""" Get end state """
tmp_cfg = self.cli_get_config()
if tmp_cfg:
temp_data = tmp_cfg.split(r"location ")
self.end_state["location"] = temp_data[1]
def cli_load_config(self, commands):
""" Load config by cli """
if not self.module.check_mode:
try:
self.module.config.load_config(commands)
except NetworkError:
err = get_cli_exception()
self.module.fail_json(msg=err)
def cli_get_config(self):
""" Get config by cli """
regular = "| include snmp | include location"
tmp_cfg = self.module.config.get_config(include_all=True,
regular=regular)
return tmp_cfg
def set_config(self):
""" Set configure by cli """
cmd = "snmp-agent sys-info location %s" % self.location
self.updates_cmd.append(cmd)
self.cli_load_config(cmd)
self.changed = True
def undo_config(self):
""" Undo configure by cli """
cmd = "undo snmp-agent sys-info location"
self.updates_cmd.append(cmd)
self.cli_load_config(cmd)
self.changed = True
def work(self):
""" Main work function """
self.check_args()
self.get_proposed()
self.get_existing()
if self.state == "present":
if "location" in self.cur_cfg.keys(
) and self.location == self.cur_cfg["location"]:
pass
else:
self.set_config()
else:
if "location" in self.cur_cfg.keys(
) and self.location == self.cur_cfg["location"]:
self.undo_config()
self.get_end_state()
self.results['changed'] = self.changed
self.results['proposed'] = self.proposed
self.results['existing'] = self.existing
self.results['end_state'] = self.end_state
self.results['updates'] = self.updates_cmd
self.module.exit_json(**self.results)
