def interconnect(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
remove_domains = get_config().get("remove_domains")
interco_pusher = NetboxInterconnectionsPusher(
netbox_api, remove_domains=remove_domains)
print("Finding neighbours and interconnecting…")
interco_result = interco_pusher.push(importers=parsed_args.importers,
threads=parsed_args.threads,
overwrite=parsed_args.overwrite)
print("{} interconnection(s) applied".format(interco_result["done"]))
if interco_result["errors_device"]:
logger.error("Error getting neighbours on %s device(s)",
interco_result["errors_device"])
if interco_result["errors_interco"]:
logger.error("Error pushing %s interconnection(s)",
interco_result["errors_interco"])
def parse_filter_yaml_def(filter_yaml, creds=None):
netbox_api = NetboxAPI(**get_config()["netbox"])
devices = {}
with open(filter_yaml) as filter_yaml_str:
yml = yaml.safe_load(filter_yaml_str)
platforms_js = netbox_api.get("dcim/platforms")
platforms = {}
for platform in platforms_js["results"]:
if platform["napalm_driver"]:
if platform["napalm_driver"]:
platforms[platform["id"]] = {
"napalm_driver": platform["napalm_driver"],
"napalm_args": platform["napalm_args"]
}
if not platforms:
raise Exception("Not for one platform napalm_driver is not "
"defined")
devlist = netbox_api.get("dcim/devices/", params=yml["filter"])
for device in devlist["results"]:
if not device.get("platform") or \
not platforms.get(device["platform"]["id"]):
continue
try:
if device["primary_ip"].get("address"):
dev = device["primary_ip"].get("address").split("/")[0]
else:
dev = device["name"]
devices[device["name"]] = DeviceImporter(
dev,
napalm_driver_name=platforms[
device["platform"]["id"]
]["napalm_driver"],
napalm_optional_args=platforms[
device["platform"]["id"]
]["napalm_args"],
creds=creds,
discovery_protocol=yml["discovery_protocol"].get(
platforms[device["platform"]["id"]]
)
)
except Exception as e:
logger.error(
"Cannot connect to device %s: %s", device["name"], e
)
return devices
def fix_vrf(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
ip_mapper = NetboxMapper(netbox_api, "ipam", "ip-addresses")
prefixes_mapper = NetboxMapper(netbox_api, "ipam", "prefixes")
for i in tqdm(ip_mapper.get()):
try:
p = next(prefixes_mapper.get(within_include=i.address))
if p.vrf != i.vrf:
print(i.address)
i.vrf = p.vrf
try:
i.put()
except Exception as e:
logger.error("Error with IP %s", i.address)
logger.exception(e)
except StopIteration:
continue
def _multithreaded_devices_polling(importers, threads=10, overwrite=False):
importers = importers.copy()
netbox_api = NetboxAPI(**get_config()["netbox"])
with ThreadPoolExecutor(max_workers=threads) as executor:
futures = {}
for host, importer in importers.items():
future = executor.submit(_poll_and_push, netbox_api, host,
importer, overwrite)
futures[future] = host
futures_with_progress = tqdm(concurrent.futures.as_completed(futures),
total=len(futures))
for future in futures_with_progress:
host = futures[future]
try:
yield host, future.result()
importers.pop(host)
except Exception as e:
logger.error("Error when polling device %s: %s", host, e)
def push_devices(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
manufacturers = create_manufacturers(netbox_api)
if parsed_args.types:
try:
create_device_types(
netbox_api,
parse_yaml_file(parsed_args.types),
manufacturers,
)
except requests.exceptions.HTTPError as e:
print(e.response.json())
raise
create_devices(netbox_api,
parse_yaml_file(parsed_args.devices),
threads=parsed_args.threads,
role_id=parsed_args.role,
site_id=parsed_args.site)
def print_orphans(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
devices_mapper = NetboxMapper(netbox_api, "dcim", "devices")
threads = parsed_args.threads
if parsed_args.device_role_id:
iter_devices = devices_mapper.get(role_id=parsed_args.device_role_id,
limit=threads)
else:
iter_devices = devices_mapper.get(limit=threads)
with ThreadPoolExecutor(max_workers=threads) as executor:
futures = {}
for d in tqdm.tqdm(iter_devices):
future = executor.submit(connection_present_for_device, d,
netbox_api)
futures[future] = d
for f in concurrent.futures.as_completed(futures):
if not f.result():
print(futures[f].name)
def print_orphans(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
for p in get_orphans(netbox_api):
print(p)