def run(vendor, hostname, user, password, strategy, optional_args, config_file, dry_run):
logger.debug('Getting driver for OS "{driver}"'.format(driver=vendor))
driver = get_network_driver(vendor)
optional_args = parse_optional_args(optional_args)
logger.debug('Connecting to device "{}" with user "{}" and optional_args={}'.format(
hostname, user, optional_args))
with driver(hostname, user, password, optional_args=optional_args) as device:
logger.debug('Strategy for loading configuration is "{strategy}"'.format(strategy=strategy))
if strategy == 'replace':
strategy_method = device.load_replace_candidate
elif strategy == 'merge':
strategy_method = device.load_merge_candidate
logger.debug('Loading configuration file "{config}"'.format(config=config_file))
strategy_method(filename=config_file)
logger.debug('Comparing configuration')
diff = device.compare_config()
if dry_run:
logger.debug('Dry-run. Discarding configuration.')
else:
logger.debug('Committing configuration')
device.commit_config()
logger.debug('Closing session')
return diff
def main():
"""Test NAPALM config merge operations on one of the Cisco routers."""
for a_device in (pynet_rtr1,):
device_type = a_device.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**a_device)
print
print ">>>Device open"
device.open()
print
print ">>>Load config change (merge) - no commit"
device.load_merge_candidate(filename='cisco_merge.txt')
print device.compare_config()
print
print ">>>Discard config change (merge)"
device.discard_config()
print device.compare_config()
print
print ">>>Load config change (merge) - commit"
device.load_merge_candidate(filename='cisco_merge.txt')
print device.compare_config()
device.commit_config()
print
def open_device(credentials, node):
driver = get_network_driver(node.operating_system.lower())
device = driver(
hostname = credentials['ip_address'],
username = credentials['username'],
password = credentials['password'],
optional_args = {'secret': credentials['enable_password']}
)
device.open()
return device
def _do_init(self):
config = self.config
self.host = config.get('host')
self.user = config.get('user')
self.password = config.get('password')
self.optional_args = config.get('driver_args', {})
if ':' not in config['type']:
raise ValueError('napalm requires a subtype')
driver = config['type'].split(':', 2)[1]
cls = get_network_driver(driver)
self.dev = cls(self.host, self.user, self.password, optional_args=self.optional_args)
def main():
for device in device_list:
dtype = device.pop("device_type")
driver = get_network_driver(dtype)
info = driver(**device)
info.open()
print "Facts are:"
facts = info.get_facts()
print facts
print '\n'
print "{hostname}: and {model}:".format(**facts)
def main():
for a_device in (pynet_rtr2, ):
dev_type = a_device.pop("device_type")
driver = get_network_driver(dev_type)
device = driver(**a_device)
print
print ">>>Device open"
device.open()
print
print ">>>Load config change (merge) - no commit"
device.load_merge_candidate(filename="cisco_merge.txt")
print device.compare_config()
def main():
for a_device in (juniper1, juniper2, cisco_rtr1):
device_type = a_device.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**a_device)
print
print ">>>Device open"
device.open()
print "-" * 50
device_facts = device.get_lldp_neighbors()
pp(device_facts)
print
def main():
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
config_file=dict(type='str', required=True),
dev_os=dict(type='str',
required=True,
choices=[
'eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios',
'nxos', 'panos'
]),
commit_changes=dict(type='bool', required=True),
replace_config=dict(type='bool', required=False, default=False),
diff_file=dict(type='str', required=False, default=None),
get_diffs=dict(type='bool', required=False, default=True)),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
config_file = module.params['config_file']
commit_changes = module.params['commit_changes']
replace_config = module.params['replace_config']
diff_file = module.params['diff_file']
get_diffs = module.params['get_diffs']
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: " + str(e))
def init(opts):
'''
Opens the connection with the network device.
'''
proxy_dict = opts.get('proxy', {})
NETWORK_DEVICE['HOSTNAME'] = proxy_dict.get('host') or proxy_dict.get(
'hostname')
NETWORK_DEVICE['USERNAME'] = proxy_dict.get('username') or proxy_dict.get(
'user')
NETWORK_DEVICE['DRIVER_NAME'] = proxy_dict.get('driver') or proxy_dict.get(
'os')
NETWORK_DEVICE['PASSWORD'] = proxy_dict.get('passwd') or proxy_dict.get(
'password') or proxy_dict.get('pass')
NETWORK_DEVICE['TIMEOUT'] = proxy_dict.get('timeout', 60)
NETWORK_DEVICE['OPTIONAL_ARGS'] = proxy_dict.get('optional_args', {})
NETWORK_DEVICE['UP'] = False
_driver_ = napalm_base.get_network_driver(
NETWORK_DEVICE.get('DRIVER_NAME'))
# get driver object form NAPALM
if 'config_lock' not in NETWORK_DEVICE['OPTIONAL_ARGS'].keys():
NETWORK_DEVICE['OPTIONAL_ARGS']['config_lock'] = False
try:
NETWORK_DEVICE['DRIVER'] = _driver_(
NETWORK_DEVICE.get('HOSTNAME', ''),
NETWORK_DEVICE.get('USERNAME', ''),
NETWORK_DEVICE.get('PASSWORD', ''),
timeout=NETWORK_DEVICE['TIMEOUT'],
optional_args=NETWORK_DEVICE['OPTIONAL_ARGS'])
NETWORK_DEVICE.get('DRIVER').open()
# no exception raised here, means connection established
NETWORK_DEVICE['UP'] = True
DETAILS['initialized'] = True
except napalm_base.exceptions.ConnectionException as error:
log.error(
"Cannot connect to {hostname}{port} as {username}. Please check error: {error}"
.format(
hostname=NETWORK_DEVICE.get('HOSTNAME', ''),
port=(':{port}'.format(
port=NETWORK_DEVICE.get('OPTIONAL_ARGS', {}).get('port'))
if NETWORK_DEVICE.get('OPTIONAL_ARGS', {}).get('port')
else ''),
username=NETWORK_DEVICE.get('USERNAME', ''),
error=error))
return True
def main():
for a_device in device_list:
device_type = a_device.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**a_device)
print
print ">>>Device open"
device.open()
print "-" * 50
device_facts = device.get_facts()
print "{hostname}: Model={model}".format(**device_facts)
print
def main():
for device in device_list:
device_type = device.pop('device_type')
driver = get_network_driver(
device_type) # returns a driver class specific to type.
device = driver(**device)
print()
print(">>>Device Open")
device.open()
print("-" * 50)
device_facts = device.get_facts() # this is using a napalm getter.
print("{hostname}: Model={model}".format(
**device_facts)) # can do this with kwargs
def main():
# Uncomment the line below for python2
ips = raw_input("Routers to run through: ")
# Uncomment the line below for python3
# ips = input("Routers to run through (Use a space between each router): ")
ipadd = ips.split()
for ip in ipadd:
print("connecting to router", ip)
driver = get_network_driver('ios')
rtr = driver(ip, 'automate', 'automation')
rtr.open()
#ios_output = rtr.get_config()
pprint(rtr.get_config())
interfaces = rtr.get_interfaces()
pprint(interfaces)
pprint(rtr.get_facts())
def main():
args = build_help(validate=True)
configure_logging(logger, args.debug)
logger.debug('Getting driver for OS "{driver}"'.format(driver=args.vendor))
driver = get_network_driver(args.vendor)
optional_args = parse_optional_args(args.optional_args)
logger.debug('Connecting to device "{}" with user "{}" and optional_args={}'.format(
args.hostname, args.user, optional_args))
with driver(args.hostname, args.user, args.password, optional_args=optional_args) as device:
logger.debug('Generating compliance report')
print(json.dumps(device.compliance_report(args.validation_file), indent=4))
logger.debug('Closing session')
sys.exit(0)
def main():
args = build_help(validate=True)
configure_logging(logger, args.debug)
logger.debug('Getting driver for OS "{driver}"'.format(driver=args.vendor))
driver = get_network_driver(args.vendor)
optional_args = parse_optional_args(args.optional_args)
logger.debug('Connecting to device "{}" with user "{}" and optional_args={}'.format(
args.hostname, args.user, optional_args))
with driver(args.hostname, args.user, args.password, optional_args=optional_args) as device:
logger.debug('Generating compliance report')
print(json.dumps(device.compliance_report(args.validation_file), indent=4))
logger.debug('Closing session')
sys.exit(0)
def main():
module = AnsibleModule(
argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
config_file=dict(type='str', required=True),
dev_os=dict(type='str', required=True, choices=['eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios', 'nxos', 'panos']),
commit_changes=dict(type='bool', required=True),
replace_config=dict(type='bool', required=False, default=False),
diff_file=dict(type='str', required=False, default=None),
get_diffs=dict(type='bool', required=False, default=True)
),
supports_check_mode=True
)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
config_file = module.params['config_file']
commit_changes = module.params['commit_changes']
replace_config = module.params['replace_config']
diff_file = module.params['diff_file']
get_diffs = module.params['get_diffs']
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: " + str(e))
def main():
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
dev_os=dict(type='str',
required=True,
choices=[
'eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios',
'nxos', 'panos'
]),
timeout=dict(type='int', required=False, default=60),
ignore_notimplemented=dict(type='bool', required=False, default=False),
optional_args=dict(type='dict', required=False, default=None),
filter=dict(type='list', required=False, default=['facts']),
),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
filter_list = module.params['filter']
ignore_notimplemented = module.params['ignore_notimplemented']
implementation_errors = []
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
# open device connection
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: " + str(e))
def main():
devices = (device_list.pynet_rtr1, )
napalm_conns = []
for a_device in devices:
device_type = a_device.pop('device_type')
merge_file = a_device.pop('merge_file')
driver = get_network_driver(device_type)
device = driver(**a_device)
napalm_conns.append(device)
print "\n>>> Test Device Open ({})".format(a_device['hostname'])
device.open()
print "\n>>> Rollback last config change.. "
device.rollback()
pprint(device.compare_config())
print '-' * 80
def get_device_instance(module, os_choices):
provider = module.params['provider'] or {}
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) \
or provider.get('host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks,
# since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
optional_args = module.params['optional_args'] or {}
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as err:
module.fail_json(msg="cannot connect to device: {0}".format(str(err)))
return device
def main():
args = build_help(connect_test=True)
configure_logging(logger, args.debug)
logger.debug('Getting driver for OS "{driver}"'.format(driver=args.vendor))
driver = get_network_driver(args.vendor)
optional_args = parse_optional_args(args.optional_args)
logger.debug('Connecting to device "{}" with user "{}" and optional_args={}'.format(
args.hostname, args.user, optional_args))
with driver(args.hostname,
args.user,
args.password,
optional_args=optional_args) as device:
logger.debug('Successfully connected to the device: {}'.format(device.hostname))
print('Successfully connected to the device')
sys.exit(0)
def init(opts):
'''
Opens the connection with the network device.
'''
proxy_dict = opts.get('proxy', {})
NETWORK_DEVICE['HOSTNAME'] = proxy_dict.get('host') or proxy_dict.get('hostname')
NETWORK_DEVICE['USERNAME'] = proxy_dict.get('username') or proxy_dict.get('user')
NETWORK_DEVICE['DRIVER_NAME'] = proxy_dict.get('driver') or proxy_dict.get('os')
NETWORK_DEVICE['PASSWORD'] = proxy_dict.get('passwd') or proxy_dict.get('password') or proxy_dict.get('pass')
NETWORK_DEVICE['TIMEOUT'] = proxy_dict.get('timeout', 60)
NETWORK_DEVICE['OPTIONAL_ARGS'] = proxy_dict.get('optional_args', {})
NETWORK_DEVICE['UP'] = False
_driver_ = napalm_base.get_network_driver(NETWORK_DEVICE.get('DRIVER_NAME'))
# get driver object form NAPALM
if 'config_lock' not in NETWORK_DEVICE['OPTIONAL_ARGS'].keys():
NETWORK_DEVICE['OPTIONAL_ARGS']['config_lock'] = False
try:
NETWORK_DEVICE['DRIVER'] = _driver_(
NETWORK_DEVICE.get('HOSTNAME', ''),
NETWORK_DEVICE.get('USERNAME', ''),
NETWORK_DEVICE.get('PASSWORD', ''),
timeout=NETWORK_DEVICE['TIMEOUT'],
optional_args=NETWORK_DEVICE['OPTIONAL_ARGS']
)
NETWORK_DEVICE.get('DRIVER').open()
# no exception raised here, means connection established
NETWORK_DEVICE['UP'] = True
DETAILS['initialized'] = True
except napalm_base.exceptions.ConnectionException as error:
log.error(
"Cannot connect to {hostname}{port} as {username}. Please check error: {error}".format(
hostname=NETWORK_DEVICE.get('HOSTNAME', ''),
port=(':{port}'.format(port=NETWORK_DEVICE['OPTIONAL_ARGS'])
if NETWORK_DEVICE['OPTIONAL_ARGS'].get('port') else ''),
username=NETWORK_DEVICE.get('USERNAME', ''),
error=error
)
)
return True
def main():
module = AnsibleModule(
argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
dev_os=dict(type='str', required=True, choices=['eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios', 'nxos', 'panos']),
timeout=dict(type='int', required=False, default=60),
ignore_notimplemented=dict(type='bool', required=False, default=False),
optional_args=dict(type='dict', required=False, default=None),
filter=dict(type='list', required=False, default=['facts']),
),
supports_check_mode=True
)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
filter_list = module.params['filter']
ignore_notimplemented = module.params['ignore_notimplemented']
implementation_errors = []
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
# open device connection
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: " + str(e))
def main():
args = build_help(connect_test=True)
configure_logging(logger, args.debug)
logger.debug('Getting driver for OS "{driver}"'.format(driver=args.vendor))
driver = get_network_driver(args.vendor)
optional_args = parse_optional_args(args.optional_args)
logger.debug(
'Connecting to device "{}" with user "{}" and optional_args={}'.format(
device=args.hostname, user=args.user, optional_args=optional_args))
with driver(args.hostname,
args.user,
args.password,
optional_args=optional_args) as device:
logger.debug('Successfully connected to the device: {}'.format(device))
print('Successfully connected to the device')
sys.exit(0)
def main():
"""
Connect to set of network devices using NAPALM (different platforms); print
out the facts.
"""
for a_device in device_list:
device_type = a_device.pop("device_type")
driver = get_network_driver(device_type)
device = driver(**a_device)
print
print ">>>Device open"
device.open()
print "-" * 50
device_facts = device.get_facts()
print "{hostname}: Model={model}".format(**device_facts)
print
def main():
"""
Connect to set of network devices using NAPALM (different platforms); print
out the facts.
"""
for a_device in device_list:
device_type = a_device.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**a_device)
print
print ">>>Device open"
device.open()
print "-" * 50
device_facts = device.get_facts()
print "{hostname}: Model={model}".format(**device_facts)
print
def parse_from_device(module, os_choices):
update_module_provider_data(module)
hostname = module.params['hostname']
username = module.params['username']
password = module.params['password']
timeout = module.params['timeout']
models = module.params['models']
mode = module.params['mode']
profiles = module.params['profiles']
dev_os = module.params['dev_os']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks, since params come can come
# from provider
dev_os = module.params['dev_os']
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: {}".format(e))
def main():
with open("my_devices.yml", "r") as f:
devices = yaml.load(f)
napalm_conns = []
for a_device in devices:
device_type = devices[a_device].pop('device_type')
driver = get_network_driver(device_type)
device = driver(**devices[a_device])
napalm_conns.append(device)
print "\n>>> Test Device Open.."
device.open()
print "\n>>> Facts - Model - {} - {}: ".format(device_type, a_device),
print device.get_facts()["model"]
print '-' * 80
test_methods = ["get_arp_table", "get_interfaces", "get_interface_ip"]
def main():
devices = (device_list.pynet_rtr1, device_list.pynet_rtr2,
device_list.pynet_sw1, device_list.pynet_sw2,
device_list.juniper_srx)
napalm_conns = []
for a_device in devices:
device_type = a_device.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**a_device)
napalm_conns.append(device)
print "\n\n>>> Test Device Open.."
device.open()
print "\n>>> Facts - Model {} {}: ".format(device_type,
a_device['hostname']),
print device.get_facts()["model"]
print '-' * 80
test_methods = ["get_arp_table", "get_interfaces", "get_interface_ip"]
def main():
with open(YAML_FILE) as f:
my_devices = yaml.load(f)
#pprint(my_devices)
pwd = getpass()
print("{:<20} {:<20} {:<20}".format("Device Type", "Hostname", "Model"))
for device_dict in my_devices:
device_dict['password'] = pwd
device_type = device_dict.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**device_dict)
device.open()
facts = device.get_facts()
print('*' * 80)
print("{:<20} {:<20} {:<20}".format(device_type,
device_dict['hostname'],
facts['model']))
print('*' * 80)
print
def main():
devices = (device_list.pynet_rtr1, )
napalm_conns = []
for a_device in devices:
device_type = a_device.pop('device_type')
merge_file = a_device.pop('merge_file')
driver = get_network_driver(device_type)
device = driver(**a_device)
napalm_conns.append(device)
print "\n>>> Test Device Open ({})".format(a_device['hostname'])
device.open()
print "\n>>> Load config change (merge) - no commit.. "
device.load_merge_candidate(filename=merge_file)
pprint(device.compare_config())
print
raw_input('Hit Enter to discard changes: ')
print "\n>>> Discard config change (merge)"
device.discard_config()
pprint(device.compare_config())
print '-' * 80
def test_get_network_driver(self, driver):
"""Check that we can get the desired driver and is instance of NetworkDriver."""
self.assertTrue(issubclass(get_network_driver(driver), NetworkDriver))
optional_args={})
nxos1 = dict(hostname='31.220.71.215',
device_type='nxos',
username='******',
password=password,
optional_args={
'nxos_protocol': 'https',
'port': 8443
})
devices = (cisco_rtr1, arista_sw1, juniper_srx, nxos1)
napalm_conns = []
for a_device in devices:
device_type = a_device.pop('device_type')
driver = get_network_driver(device_type)
device = driver(**a_device)
napalm_conns.append(device)
print()
print("\n\n>>>Test device open")
device.open()
print()
banner = " Facts {} ".format(device_type)
print(banner.center(80, '-'))
pprint(device.get_facts())
print('-' * 80)
print()
raw_input("Hit enter to continue: ")
def test_get_network_driver(self, driver):
"""Check that we can get the desired driver."""
self.assertTrue(get_network_driver(driver))
from napalm_base import get_network_driver
driver = get_network_driver("ios")
ios_r1 = driver("192.168.99.1","user","user123")
ios_r1.open()
r1_facts = ios_r1.get_facts()
print r1_facts
ios_r1.close()
''' ssh and get information about cisco switch using python and napalm '''
# Author: Anubhavsingh Sawdagur
# Created Date: 12 Febuary 2019
import json
from napalm_base import get_network_driver
IP_LIST = [
"192.168.44.110", "192.168.44.111", "192.168.44.121", "192.168.44.122"
]
for IP in IP_LIST:
DRIVER = get_network_driver("ios")
DEVICE = DRIVER(str(IP), "anubhav", "cisco")
DEVICE.open()
print("Connected to " + str(IP))
# ------------------------------------
print("Facts - " + str(IP))
OUTPUT = DEVICE.get_facts()
OUTPUT = json.dumps(OUTPUT, indent=4)
print(OUTPUT)
# ------------------------------------
print("Interfaces - " + str(IP))
OUTPUT = DEVICE.get_interfaces()
OUTPUT = json.dumps(OUTPUT, sort_keys=True, indent=4)
print(OUTPUT)
# ------------------------------------
print("Interfaces IP - " + str(IP))
OUTPUT = DEVICE.get_interfaces_ip()
from json import dumps
from napalm_base import get_network_driver
junos_driver = get_network_driver('junos')
junos_device = {'username': '******', 'password': '******', 'hostname': '172.30.179.95'}
with junos_driver(**junos_device) as junos:
print('-'*60)
print junos.get_bgp_neighbors()
print('-'*60)
print dumps(junos.get_bgp_neighbors(), indent=4)
print('-'*60)
print junos.get_bgp_neighbors()['global']['peers']['192.168.0.4']['uptime']
'''
# python junos_get_bgp_neighbors.py
------------------------------------------------------------
{u'global': {u'router_id': u'192.179.0.95', u'peers': {u'192.168.0.0': {u'is_enabled': True, u'uptime': 4525781, u'remote_as': 104, u'address_family': {u'ipv4': {u'sent_prefixes': 5, u'accepted_prefixes': 5, u'received_prefixes': 5}, u'ipv6': {u'sent_prefixes': -1, u'accepted_prefixes': -1, u'received_prefixes': -1}}, u'remote_id': u'192.179.0.74', u'local_as': 109, u'is_up': True, u'description': u''}, '192.168.0.4': {u'is_enabled': True, u'uptime': 4525784, u'remote_as': 110, u'address_family': {u'ipv4': {u'sent_prefixes': 6, u'accepted_prefixes': 5, u'received_prefixes': 5}, u'ipv6': {u'sent_prefixes': -1, u'accepted_prefixes': -1, u'received_prefixes': -1}}, u'remote_id': u'192.179.0.73', u'local_as': 109, u'is_up': True, u'description': u''}}}}
------------------------------------------------------------
{
"global": {
"router_id": "192.179.0.95",
"peers": {
"192.168.0.0": {
"is_enabled": true,
"uptime": 4525781,
"remote_as": 104,
"address_family": {
"ipv4": {
"sent_prefixes": 5,
def test_get_network_driver(self, driver):
"""Check that we can get the desired driver and is instance of NetworkDriver."""
self.assertTrue(issubclass(get_network_driver(driver), NetworkDriver))
def _get_data_from_device(device):
try:
driver = napalm_base.get_network_driver(device["vendor"])
except napalm_base.exceptions.ModuleImportError as e:
url = "https://napalm.readthedocs.io/en/latest/support/index.html"
logger.error("Can't load the NAPALM driver for vendor '{}': {} - "
"Please be sure the vendor is one of those supported "
"by NAPALM (the 'vendor' argument must be filled "
"with a value taken from the 'Driver Name' row of "
"the table at this URL: {}).".format(
device["vendor"], str(e), url))
return None
connection = driver(hostname=device["hostname"],
username=device.get("username", None),
password=device.get("password", None),
optional_args=device.get("optional_args", {}))
hostname = device["hostname"]
logger.info("Connecting to {}...".format(hostname))
try:
connection.open()
except Exception as e:
logger.error("Can't connect to {}: {}".format(hostname, str(e)))
return None
arp_table = []
logger.info("Getting ARP table from {}...".format(hostname))
try:
arp_table = connection.get_arp_table()
except Exception as e:
logger.error("Can't get ARP table from {}: {}".format(
hostname, str(e)))
return None
ipv6_neighbors_table = []
if not device.get("arp_only", False):
logger.info(
"Getting IPv6 neighbors table from {}...".format(hostname))
try:
ipv6_neighbors_table = connection.get_ipv6_neighbors_table()
except AttributeError as e:
logger.warning("Skipping IPv6 neighbors table: "
"please consult the Caveats section of README")
except Exception as e:
logger.error("Can't get IPv6 neighbors table "
"from {}: {}".format(hostname, str(e)))
return None
bgp_neighbors = {}
logger.info("Getting BGP neighbors from {}...".format(hostname))
try:
bgp_neighbors = connection.get_bgp_neighbors()
except Exception as e:
logger.error("Can't get BGP neighbors from {}: {}".format(
hostname, str(e)))
return None
logger.info("Disconnecting from {}...".format(hostname))
try:
connection.close()
except Exception as e:
logger.warning("Error while disconnecting from {}: {}".format(
hostname, str(e)))
# Normalize data
arp_table = [{
"interface": _["interface"],
"ip": str(ipaddress.ip_address(_["ip"])),
"mac": _["mac"].strip().lower()
} for _ in arp_table]
ipv6_neighbors_table = [{
"interface": _["interface"],
"ip": str(ipaddress.ip_address(_["ip"])),
"mac": _["mac"].strip().lower()
} for _ in ipv6_neighbors_table]
peers = bgp_neighbors["global"]["peers"]
bgp_neighbors = {
"global": {
"peers": {
_.lower(): {
"remote_as": peers[_]["remote_as"],
"description": peers[_]["description"]
}
for _ in peers
}
}
}
return {
"arp": arp_table,
"ipv6_neighbors": ipv6_neighbors_table,
"bgp_neighbors": bgp_neighbors
}
def main():
module = AnsibleModule(
argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
dev_os=dict(type='str', required=True, choices=['eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios', 'nxos']),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(type='dict', required=False, default=None),
filter=dict(type='str', required=False, default='facts'),
),
supports_check_mode=True
)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
filter_list = module.params['filter'].split(',')
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
# open device connection
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except:
module.fail_json(msg="cannot connect to device")
# retreive data from device
facts = {}
try:
for filter in filter_list:
if filter == 'facts':
result = device.get_facts()
facts['facts'] = result
elif filter == 'interfaces':
result = device.get_interfaces()
facts['interfaces'] = result
elif filter == 'interfaces_counter':
result = device.get_interfaces_counter()
facts['interfaces_counter'] = result
elif filter == 'bgp_config':
result = device.get_bgp_config()
facts['bgp_config'] = result
elif filter == 'bgp_neighbors':
result = device.get_bgp_neighbors()
facts['bgp_neighbors'] = result
elif filter == 'bgp_neighbors_detail':
result = device.get_bgp_neighbors_detail()
facts['bgp_neighbors_detail'] = result
elif filter == 'environment':
result = device.get_environment()
facts['environment'] = result
elif filter == 'lldp_neighbors':
result = device.get_lldp_neighbors()
facts['lldp_neighbors'] = result
elif filter == 'lldp_neighbors_detail':
result = device.get_lldp_neighbors_detail()
facts['lldp_neighbors_detail'] = result
else:
module.fail_json(msg="filter not recognized: " + filter)
except:
module.fail_json(msg="cannot retrieve device data")
# close device connection
try:
device.close()
except:
module.fail_json(msg="cannot close device connection")
module.exit_json(ansible_facts=facts)
def test_get_network_driver(self, driver):
"""Check that we can get the desired driver."""
self.assertTrue(get_network_driver(driver))
# NAPALM base
from napalm_base import get_network_driver
import napalm_base.exceptions
from napalm_base.utils import py23_compat
import pytest
import os
BASE_PATH = os.path.dirname(__file__)
driver = get_network_driver("mock")
optional_args = {
"path": os.path.join(BASE_PATH, "test_mock_driver"),
"profile": ["eos"],
}
fail_args = {
"path": os.path.join(BASE_PATH, "test_mock_driver"),
"profile": ["eos"],
"fail_on_open": True,
}
class TestMockDriver(object):
"""Test Mock Driver."""
def test_basic(self):
def main():
os_choices = [
'eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios', 'nxos', 'panos',
'vyos'
]
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=False, aliases=['host']),
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
provider=dict(type='dict', required=False, no_log=True),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
config_file=dict(type='str', required=True),
dev_os=dict(type='str', required=False, choices=os_choices),
commit_changes=dict(type='bool', required=True),
replace_config=dict(type='bool', required=False, default=False),
diff_file=dict(type='str', required=False, default=None),
get_diffs=dict(type='bool', required=False, default=True)),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
provider = module.params['provider'] or {}
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) or provider.get(
'host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) != False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
config_file = module.params['config_file']
commit_changes = module.params['commit_changes']
replace_config = module.params['replace_config']
diff_file = module.params['diff_file']
get_diffs = module.params['get_diffs']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks, since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: " + str(e))
'''
- Allows you to send sample change to an IOS-XR device
- If changes are required these will be printed and deployed
- If no changes are required a message will be printed
- User will be prompted to enter 'COMMIT' or 'Hit Enter' to abort
- If changes are deployed user will be prompted to enter 'ROLLBACK' to revert the change or 'Hit Enter' to keep changes
'''
from napalm_base import get_network_driver
import sys
device_list = ['10.4.37.15', '10.4.37.16']
for ip_address in device_list:
driver = get_network_driver('iosxr')
device = driver(hostname=ip_address, username='******', password='******')
device.open()
device.load_merge_candidate(filename='prefix_list.cfg')
diffs = device.compare_config()
if len(diffs) > 0:
print(diffs)
commit = raw_input(
"Type COMMIT to commit the configuration or hit ENTER to abort: ")
if commit == 'COMMIT':
try:
device.commit_config()
def call_get_network_driver(vendor):
return get_network_driver(vendor)
#!/usr/bin/env python
from getpass import getpass
from pprint import pprint as pp
from napalm_base import get_network_driver
ip_addr = '31.220.69.245'
username = '******'
password = getpass()
optional_args = {}
optional_args['nxos_protocol'] = 'http'
optional_args['port'] = 80
driver = get_network_driver('nxos')
device = driver(ip_addr, username, password, optional_args=optional_args)
print
print(">>>Test device open")
device.open()
print
print(">>>Test get facts")
device_facts = device.get_facts()
pp(device_facts)
print
print(">>>Test get lldp neighbors")
#device_int = device.get_lldp_neighbors()
device_int = device.get_lldp_neighbors_detail()
pp(device_int)
def main():
module = AnsibleModule(
argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
config_file=dict(type='str', required=True),
dev_os=dict(type='str', required=True, choices=['eos', 'junos', 'iosxr', 'fortios', 'ibm', 'ios', 'nxos']),
commit_changes=dict(type='bool', required=True, choices=BOOLEANS),
replace_config=dict(type='bool', required=False, choices=BOOLEANS, default=False),
diff_file=dict(type='str', required=False, default=None),
get_diffs=dict(type='bool', required=False, choices=BOOLEANS, default=True)
),
supports_check_mode=True
)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
config_file = module.params['config_file']
commit_changes = module.params['commit_changes']
replace_config = module.params['replace_config']
diff_file = module.params['diff_file']
get_diffs = module.params['get_diffs']
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except:
module.fail_json(msg="cannot connect to device")
try:
if replace_config:
device.load_replace_candidate(filename=config_file)
else:
device.load_merge_candidate(filename=config_file)
except Exception as e:
module.fail_json(msg="cannot load config. Error:\n{}".format(e))
try:
if get_diffs:
diff = device.compare_config().encode('utf-8')
changed = len(diff) > 0
else:
changed = True
diff = None
if diff_file is not None and get_diffs:
save_to_file(diff, diff_file)
except:
module.fail_json(msg="cannot diff config")
try:
if module.check_mode or not commit_changes:
device.discard_config()
else:
if changed:
device.commit_config()
except Exception as e:
module.fail_json(msg="cannot install config. Error:\n{}".format(e))
try:
device.close()
except:
module.fail_json(msg="cannot close device connection")
module.exit_json(changed=changed, msg=diff)
