diff --git a/nb-dt-import.py b/nb-dt-import.py deleted file mode 100755 index 7e55e17..0000000 --- a/nb-dt-import.py +++ /dev/null @@ -1,816 +0,0 @@ -#!/usr/bin/env python3 -from collections import Counter -from datetime import datetime -import yaml -import pynetbox -import glob -import os -import re -import requests - -import settings - -counter = Counter( - added=0, - updated=0, - manufacturer=0, - module_added=0, - module_port_added=0, -) - -def determine_features(nb): - '''Automatically determine the netbox features available. - - Currently only checks for existence of module-types. - - Args: - nb: pynetbox API instance - - Returns: - None - - Raises: - None - ''' - - # nb.version should be the version in the form '3.2' - nb_ver = [int(x) for x in nb.version.split('.')] - - # Later than 3.2 - # Might want to check for the module-types entry as well? - if nb_ver[0] > 3 or (nb_ver[0] == 3 and nb_ver[1] >= 2): - settings.NETBOX_FEATURES['modules'] = True - - - - -def slugFormat(name): - return re.sub('\W+','-', name.lower()) - -YAML_EXTENSIONS = ['yml', 'yaml'] - -def getFiles(vendors=None): - - files = [] - discoveredVendors = [] - base_path = f'{settings.REPO_PATH}/device-types/' - if vendors: - for r, d, f in os.walk(base_path): - for folder in d: - for vendor in vendors: - if vendor.lower() == folder.lower(): - discoveredVendors.append({'name': folder, - 'slug': slugFormat(folder)}) - for extension in YAML_EXTENSIONS: - files.extend(glob.glob(base_path + folder + f'/*.{extension}')) - else: - for r, d, f in os.walk(base_path): - for folder in d: - if folder.lower() != "Testing": - discoveredVendors.append({'name': folder, - 'slug': slugFormat(folder)}) - for extension in YAML_EXTENSIONS: - files.extend(glob.glob(base_path + f'[!Testing]*/*.{extension}')) - return files, discoveredVendors - -def get_files_modules(vendors=None): - '''Get files list for modules. - - Args: - vendors: List of vendors to sync or None to sync all vendors. - - Returns: - A 2-tuple of: - - list of filenames found - - list of vendors found - - ''' - - files = [] - discoveredVendors = [] - base_path = f'{settings.REPO_PATH}/module-types/' - if vendors: - for r, d, f in os.walk(base_path): - for folder in d: - for vendor in vendors: - if vendor.lower() == folder.lower(): - discoveredVendors.append({'name': folder, - 'slug': slugFormat(folder)}) - for extension in YAML_EXTENSIONS: - files.extend( - glob.glob( - base_path + folder + f'/*.{extension}' - ) - ) - else: - for r, d, f in os.walk(base_path): - for folder in d: - if folder.lower() != "Testing": - discoveredVendors.append({'name': folder, - 'slug': slugFormat(folder)}) - for extension in YAML_EXTENSIONS: - files.extend(glob.glob(base_path + f'[!Testing]*/*.{extension}')) - - return files, discoveredVendors - -def readYAMl(files, **kwargs): - slugs = kwargs.get('slugs', None) - deviceTypes = [] - manufacturers = [] - for file in files: - with open(file, 'r') as stream: - try: - data = yaml.safe_load(stream) - except yaml.YAMLError as exc: - print(exc) - continue - manufacturer = data['manufacturer'] - data['manufacturer'] = {} - data['manufacturer']['name'] = manufacturer - data['manufacturer']['slug'] = slugFormat(manufacturer) - - if slugs and data['slug'] not in slugs: - print(f"Skipping {data['model']}") - continue - - deviceTypes.append(data) - manufacturers.append(manufacturer) - return deviceTypes - -def read_yaml_modules(files, **kwargs): - - slugs = kwargs.get('slugs', None) - module_types = [] - manufacturers = [] - for file in files: - with open(file, 'r') as stream: - try: - data = yaml.safe_load(stream) - except yaml.YAMLError as exc: - print(exc) - continue - manufacturer = data['manufacturer'] - data['manufacturer'] = {} - data['manufacturer']['name'] = manufacturer - data['manufacturer']['slug'] = slugFormat(manufacturer) - - if slugs and data['slug'] not in slugs: - print(f"Skipping {data['model']}") - continue - - module_types.append(data) - manufacturers.append(manufacturer) - return module_types - -def createManufacturers(vendors, nb): - all_manufacturers = {str(item): item for item in nb.dcim.manufacturers.all()} - need_manufacturers = [] - for vendor in vendors: - try: - manGet = all_manufacturers[vendor["name"]] - print(f'Manufacturer Exists: {manGet.name} - {manGet.id}') - except KeyError: - need_manufacturers.append(vendor) - - if not need_manufacturers: - return - - try: - manSuccess = nb.dcim.manufacturers.create(need_manufacturers) - for man in manSuccess: - print(f'Manufacturer Created: {man.name} - ' - + f'{man.id}') - counter.update({'manufacturer': 1}) - except pynetbox.RequestError as e: - print(e.error) - - -def createInterfaces(interfaces, deviceType, nb): - all_interfaces = {str(item): item for item in nb.dcim.interface_templates.filter(devicetype_id=deviceType)} - need_interfaces = [] - for interface in interfaces: - try: - ifGet = all_interfaces[interface["name"]] - print(f'Interface Template Exists: {ifGet.name} - {ifGet.type}' - + f' - {ifGet.device_type.id} - {ifGet.id}') - except KeyError: - interface['device_type'] = deviceType - need_interfaces.append(interface) - - if not need_interfaces: - return - - try: - ifSuccess = nb.dcim.interface_templates.create(need_interfaces) - for intf in ifSuccess: - print(f'Interface Template Created: {intf.name} - ' - + f'{intf.type} - {intf.device_type.id} - ' - + f'{intf.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_interfaces(interfaces, module_type, nb): - all_interfaces = {str(item): item for item in nb.dcim.interface_templates.filter(moduletype_id=module_type)} - need_interfaces = [] - for interface in interfaces: - try: - if_res = all_interfaces[interface["name"]] - print(f'Interface Template Exists: {if_res.name} - {if_res.type}' - + f' - {if_res.module_type.id} - {if_res.id}') - except KeyError: - interface['module_type'] = module_type - need_interfaces.append(interface) - - if not need_interfaces: - return - - try: - ifSuccess = nb.dcim.interface_templates.create(need_interfaces) - for intf in ifSuccess: - print(f'Interface Template Created: {intf.name} - ' - + f'{intf.type} - {intf.module_type.id} - ' - + f'{intf.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def createConsolePorts(consoleports, deviceType, nb): - all_consoleports = {str(item): item for item in nb.dcim.console_port_templates.filter(devicetype_id=deviceType)} - need_consoleports = [] - for consoleport in consoleports: - try: - cpGet = all_consoleports[consoleport["name"]] - print(f'Console Port Template Exists: {cpGet.name} - ' - + f'{cpGet.type} - {cpGet.device_type.id} - {cpGet.id}') - except KeyError: - consoleport['device_type'] = deviceType - need_consoleports.append(consoleport) - - if not need_consoleports: - return - - try: - cpSuccess = nb.dcim.console_port_templates.create(need_consoleports) - for port in cpSuccess: - print(f'Console Port Created: {port.name} - ' - + f'{port.type} - {port.device_type.id} - ' - + f'{port.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_console_ports(consoleports, module_type, nb): - - all_consoleports = {str(item): item for item in nb.dcim.console_port_templates.filter(moduletype_id=module_type)} - need_consoleports = [] - for consoleport in consoleports: - try: - cpGet = all_consoleports[consoleport["name"]] - print(f'Console Port Template Exists: {cpGet.name} - ' - + f'{cpGet.type} - {cpGet.module_type.id} - {cpGet.id}') - except KeyError: - consoleport['module_type'] = module_type - need_consoleports.append(consoleport) - - if not need_consoleports: - return - - try: - cpSuccess = nb.dcim.console_port_templates.create(need_consoleports) - for port in cpSuccess: - print(f'Console Port Created: {port.name} - {port.type} - ' + - f'{port.module_type.id} - {port.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(f"Error creating module console port: {e.error}") - -def createPowerPorts(powerports, deviceType, nb): - all_power_ports = {str(item): item for item in nb.dcim.power_port_templates.filter(devicetype_id=deviceType)} - need_power_ports = [] - for powerport in powerports: - try: - ppGet = all_power_ports[powerport["name"]] - print(f'Power Port Template Exists: {ppGet.name} - ' - + f'{ppGet.type} - {ppGet.device_type.id} - {ppGet.id}') - except KeyError: - powerport['device_type'] = deviceType - need_power_ports.append(powerport) - - if not need_power_ports: - return - - try: - ppSuccess = nb.dcim.power_port_templates.create(need_power_ports) - for pp in ppSuccess: - print(f'Interface Template Created: {pp.name} - ' - + f'{pp.type} - {pp.device_type.id} - ' - + f'{pp.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_power_ports(powerports, module_type, nb): - all_power_ports = {str(item): item for item in nb.dcim.power_port_templates.filter(moduletype_id=module_type)} - need_power_ports = [] - for powerport in powerports: - try: - ppGet = all_power_ports[powerport["name"]] - print(f'Power Port Template Exists: {ppGet.name} - ' + - f'{ppGet.type} - {ppGet.module_type.id} - {ppGet.id}') - except KeyError: - powerport['module_type'] = module_type - need_power_ports.append(powerport) - - if not need_power_ports: - return - - try: - ppSuccess = nb.dcim.power_port_templates.create(need_power_ports) - for pp in ppSuccess: - print(f'Power port template created: {pp.name} - ' - + f'{pp.type} - {pp.module_type.id} - {pp.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def createConsoleServerPorts(consoleserverports, deviceType, nb): - all_consoleserverports = {str(item): item for item in nb.dcim.console_server_port_templates.filter(devicetype_id=deviceType)} - need_consoleserverports = [] - for csport in consoleserverports: - try: - cspGet = all_consoleserverports[csport["name"]] - print(f'Console Server Port Template Exists: {cspGet.name} - ' - + f'{cspGet.type} - {cspGet.device_type.id} - ' - + f'{cspGet.id}') - except KeyError: - csport['device_type'] = deviceType - need_consoleserverports.append(csport) - - if not need_consoleserverports: - return - - try: - cspSuccess = nb.dcim.console_server_port_templates.create( - need_consoleserverports) - for csp in cspSuccess: - print(f'Console Server Port Created: {csp.name} - ' - + f'{csp.type} - {csp.device_type.id} - ' - + f'{csp.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_console_server_ports(consoleserverports, module_type, nb): - all_consoleserverports = {str(item): item for item in nb.dcim.console_server_port_templates.filter(moduletype_id=module_type)} - need_consoleserverports = [] - for csport in consoleserverports: - try: - cspGet = all_consoleserverports[csport["name"]] - print(f'Console Server Port Template Exists: {cspGet.name} - ' - + f'{cspGet.type} - {cspGet.module_type.id} - ' - + f'{cspGet.id}') - except KeyError: - csport['module_type'] = module_type - need_consoleserverports.append(csport) - - if not need_consoleserverports: - return - - try: - cspSuccess = nb.dcim.console_server_port_templates.create( - need_consoleserverports) - for csp in cspSuccess: - print(f'Console Server Port Created: {csp.name} - ' - + f'{csp.type} - {csp.module_type.id} - ' - + f'{csp.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def createFrontPorts(frontports, deviceType, nb): - all_frontports = {str(item): item for item in nb.dcim.front_port_templates.filter(devicetype_id=deviceType)} - need_frontports = [] - for frontport in frontports: - try: - fpGet = all_frontports[frontport["name"]] - print(f'Front Port Template Exists: {fpGet.name} - ' - + f'{fpGet.type} - {fpGet.device_type.id} - {fpGet.id}') - except KeyError: - frontport['device_type'] = deviceType - need_frontports.append(frontport) - - if not need_frontports: - return - - all_rearports = {str(item): item for item in nb.dcim.rear_port_templates.filter(devicetype_id=deviceType)} - for port in need_frontports: - try: - rpGet = all_rearports[port["rear_port"]] - port['rear_port'] = rpGet.id - except KeyError: - print(f'Could not find Rear Port for Front Port: {port["name"]} - ' - + f'{port["type"]} - {deviceType}') - - try: - fpSuccess = nb.dcim.front_port_templates.create(need_frontports) - for fp in fpSuccess: - print(f'Front Port Created: {fp.name} - ' - + f'{fp.type} - {fp.device_type.id} - ' - + f'{fp.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_front_ports(frontports, module_type, nb): - all_frontports = {str(item): item for item in nb.dcim.front_port_templates.filter(moduletype_id=module_type)} - need_frontports = [] - for frontport in frontports: - try: - fpGet = all_frontports[frontport["name"]] - print(f'Front Port Template Exists: {fpGet.name} - ' - + f'{fpGet.type} - {fpGet.module_type.id} - {fpGet.id}') - except KeyError: - frontport['module_type'] = module_type - need_frontports.append(frontport) - - if not need_frontports: - return - - all_rearports = {str(item): item for item in nb.dcim.rear_port_templates.filter(moduletype_id=module_type)} - for port in need_frontports: - try: - rpGet = all_rearports[port["rear_port"]] - port['rear_port'] = rpGet.id - except KeyError: - print(f'Could not find Rear Port for Front Port: {port["name"]} - ' - + f'{port["type"]} - {module_type}') - - try: - fpSuccess = nb.dcim.front_port_templates.create(need_frontports) - for fp in fpSuccess: - print(f'Front Port Created: {fp.name} - ' - + f'{fp.type} - {fp.module_type.id} - ' - + f'{fp.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def createRearPorts(rearports, deviceType, nb): - all_rearports = {str(item): item for item in nb.dcim.rear_port_templates.filter(devicetype_id=deviceType)} - need_rearports = [] - for rearport in rearports: - try: - rpGet = all_rearports[rearport["name"]] - print(f'Rear Port Template Exists: {rpGet.name} - {rpGet.type}' - + f' - {rpGet.device_type.id} - {rpGet.id}') - except KeyError: - rearport['device_type'] = deviceType - need_rearports.append(rearport) - - if not need_rearports: - return - - try: - rpSuccess = nb.dcim.rear_port_templates.create( - need_rearports) - for rp in rpSuccess: - print(f'Rear Port Created: {rp.name} - {rp.type}' - + f' - {rp.device_type.id} - {rp.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_rear_ports(rearports, module_type, nb): - all_rearports = {str(item): item for item in nb.dcim.rear_port_templates.filter(moduletype_id=module_type)} - need_rearports = [] - for rearport in rearports: - try: - rpGet = all_rearports[rearport["name"]] - print(f'Rear Port Template Exists: {rpGet.name} - {rpGet.type}' - + f' - {rpGet.module_type.id} - {rpGet.id}') - except KeyError: - rearport['module_type'] = module_type - need_rearports.append(rearport) - - if not need_rearports: - return - - try: - rpSuccess = nb.dcim.rear_port_templates.create( - need_rearports) - for rp in rpSuccess: - print(f'Rear Port Created: {rp.name} - {rp.type}' - + f' - {rp.module_type.id} - {rp.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def createDeviceBays(devicebays, deviceType, nb): - all_devicebays = {str(item): item for item in nb.dcim.device_bay_templates.filter(devicetype_id=deviceType)} - need_devicebays = [] - for devicebay in devicebays: - try: - dbGet = all_devicebays[devicebay["name"]] - print(f'Device Bay Template Exists: {dbGet.name} - ' - + f'{dbGet.device_type.id} - {dbGet.id}') - except KeyError: - devicebay['device_type'] = deviceType - need_devicebays.append(devicebay) - - if not need_devicebays: - return - - try: - dbSuccess = nb.dcim.device_bay_templates.create(need_devicebays) - for db in dbSuccess: - print(f'Device Bay Created: {db.name} - ' - + f'{db.device_type.id} - {db.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - - -def create_module_bays(module_bays, device_type, nb): - '''Create module bays. - - Args: - module_bays: parsed YAML module_bays section. - device_type: the device type instance from netbox. - nb: Netbox API instance - ''' - all_module_bays = { - str(item): item for item in nb.dcim.module_bay_templates.filter( - devicetype_id=device_type - ) - } - need_module_bays = [] - for module_bay in module_bays: - try: - dbGet = all_module_bays[module_bay["name"]] - print(f'Module Bay Template Exists: {dbGet.name} - ' - + f'{dbGet.device_type.id} - {dbGet.id}') - except KeyError: - module_bay['device_type'] = device_type - need_module_bays.append(module_bay) - - if not need_module_bays: - return - - try: - module_bay_res = nb.dcim.module_bay_templates.create(need_module_bays) - for module_bay in module_bay_res: - print(f'Module Bay Created: {module_bay.name} - ' - + f'{module_bay.device_type.id} - {module_bay.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - - -def createPowerOutlets(poweroutlets, deviceType, nb): - all_poweroutlets = {str(item): item for item in nb.dcim.power_outlet_templates.filter(devicetype_id=deviceType)} - need_poweroutlets = [] - for poweroutlet in poweroutlets: - try: - poGet = all_poweroutlets[poweroutlet["name"]] - print(f'Power Outlet Template Exists: {poGet.name} - ' - + f'{poGet.type} - {poGet.device_type.id} - {poGet.id}') - except KeyError: - poweroutlet["device_type"] = deviceType - need_poweroutlets.append(poweroutlet) - - if not need_poweroutlets: - return - - all_power_ports = {str(item): item for item in nb.dcim.power_port_templates.filter(devicetype_id=deviceType)} - for outlet in need_poweroutlets: - try: - ppGet = all_power_ports[outlet["power_port"]] - outlet['power_port'] = ppGet.id - except KeyError: - pass - - try: - poSuccess = nb.dcim.power_outlet_templates.create( - need_poweroutlets) - for po in poSuccess: - print(f'Power Outlet Created: {po.name} - ' - + f'{po.type} - {po.device_type.id} - ' - + f'{po.id}') - counter.update({'updated': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def create_module_power_outlets(poweroutlets, module_type, nb): - '''Create missing module power outlets. - - Args: - poweroutlets: YAML power outlet data. - module_type: Netbox module_type instance. - nb: pynetbox API instance. - - Returns: - None - - Raises: - None - ''' - all_poweroutlets = {str(item): item for item in nb.dcim.power_outlet_templates.filter(moduletype_id=module_type)} - need_poweroutlets = [] - for poweroutlet in poweroutlets: - try: - poGet = all_poweroutlets[poweroutlet["name"]] - print(f'Power Outlet Template Exists: {poGet.name} - {poGet.type}' - + f' - {poGet.module_type.id} - {poGet.id}') - except KeyError: - poweroutlet["module_type"] = module_type - need_poweroutlets.append(poweroutlet) - - if not need_poweroutlets: - return - - all_power_ports = {str(item): item for item in nb.dcim.\ - power_port_templates.filter(moduletype_id=module_type)} - for outlet in need_poweroutlets: - try: - ppGet = all_power_ports[outlet["power_port"]] - outlet['power_port'] = ppGet.id - except KeyError: - pass - - try: - poSuccess = nb.dcim.power_outlet_templates.create( - need_poweroutlets) - for po in poSuccess: - print(f'Power Outlet Created: {po.name} - ' - + f'{po.type} - {po.module_type.id} - ' - + f'{po.id}') - counter.update({'module_port_added': 1}) - except pynetbox.RequestError as e: - print(e.error) - -def createDeviceTypes(deviceTypes, nb): - all_device_types = {str(item): item for item in nb.dcim.device_types.all()} - for deviceType in deviceTypes: - try: - dt = all_device_types[deviceType["model"]] - print(f'Device Type Exists: {dt.manufacturer.name} - ' - + f'{dt.model} - {dt.id}') - except KeyError: - try: - dt = nb.dcim.device_types.create(deviceType) - counter.update({'added': 1}) - print(f'Device Type Created: {dt.manufacturer.name} - ' - + f'{dt.model} - {dt.id}') - except pynetbox.RequestError as e: - print(e.error) - - if "interfaces" in deviceType: - createInterfaces(deviceType["interfaces"], - dt.id, nb) - if "power-ports" in deviceType: - createPowerPorts(deviceType["power-ports"], - dt.id, nb) - if "power-port" in deviceType: - createPowerPorts(deviceType["power-port"], - dt.id, nb) - if "console-ports" in deviceType: - createConsolePorts(deviceType["console-ports"], - dt.id, nb) - if "power-outlets" in deviceType: - createPowerOutlets(deviceType["power-outlets"], - dt.id, nb) - if "console-server-ports" in deviceType: - createConsoleServerPorts( - deviceType["console-server-ports"], dt.id, nb) - if "rear-ports" in deviceType: - createRearPorts(deviceType["rear-ports"], - dt.id, nb) - if "front-ports" in deviceType: - createFrontPorts(deviceType["front-ports"], - dt.id, nb) - if "device-bays" in deviceType: - createDeviceBays(deviceType["device-bays"], - dt.id, nb) - if settings.NETBOX_FEATURES['modules'] and 'module-bays' in deviceType: - create_module_bays(deviceType['module-bays'], - dt.id, nb) - -def create_module_types(module_types, nb): - '''Create missing module types. - - Args: - module_types: yaml data from repo. - nb: pynetbox API instance - - Returns: - None - ''' - - all_module_types = {} - for curr_nb_mt in nb.dcim.module_types.all(): - if curr_nb_mt.manufacturer.slug not in all_module_types: - all_module_types[curr_nb_mt.manufacturer.slug] = {} - - all_module_types[curr_nb_mt.manufacturer.slug][curr_nb_mt.model] = curr_nb_mt - - - for curr_mt in module_types: - try: - module_type_res = all_module_types[curr_mt['manufacturer']['slug']][curr_mt["model"]] - print(f'Module Type Exists: {module_type_res.manufacturer.name} - ' - + f'{module_type_res.model} - {module_type_res.id}') - except KeyError: - try: - module_type_res = nb.dcim.module_types.create(curr_mt) - counter.update({'module_added': 1}) - print(f'Module Type Created: {module_type_res.manufacturer.name} - ' - + f'{module_type_res.model} - {module_type_res.id}') - except pynetbox.RequestError as exce: - print(f"Error '{exce.error}' creating module type: " + - f"{curr_mt}") - - #module_type_res = all_module_types[curr_mt['manufacturer']['slug']][curr_mt["model"]] - - if "interfaces" in curr_mt: - create_module_interfaces(curr_mt["interfaces"], - module_type_res.id, nb) - if "power-ports" in curr_mt: - create_module_power_ports(curr_mt["power-ports"], - module_type_res.id, nb) - if "console-ports" in curr_mt: - create_module_console_ports(curr_mt["console-ports"], - module_type_res.id, nb) - if "power-outlets" in curr_mt: # No current entries to test - create_module_power_outlets(curr_mt["power-outlets"], - module_type_res.id, nb) - if "console-server-ports" in curr_mt: # No current entries to test - create_module_console_server_ports(curr_mt["console-server-ports"], - module_type_res.id, nb) - if "rear-ports" in curr_mt: - create_module_rear_ports(curr_mt["rear-ports"], - module_type_res.id, nb) - if "front-ports" in curr_mt: - create_module_front_ports(curr_mt["front-ports"], - module_type_res.id, nb) - -def main(): - - cwd = os.getcwd() - startTime = datetime.now() - args = settings.args - - nbUrl = settings.NETBOX_URL - nbToken = settings.NETBOX_TOKEN - nb = pynetbox.api(nbUrl, token=nbToken) - - try: - determine_features(nb) - except requests.exceptions.SSLError as ssl_exception: - if not settings.IGNORE_SSL_ERRORS: - settings.handle.exception("SSLError", settings.IGNORE_SSL_ERRORS, ssl_exception) - print("IGNORE_SSL_ERRORS is True, catching exception and disabling SSL verification.") - requests.packages.urllib3.disable_warnings() - nb.http_session.verify = False - determine_features(nb) - - if not args.vendors: - print("No Vendors Specified, Gathering All Device-Types") - files, vendors = getFiles() - else: - print("Vendor Specified, Gathering All Matching Device-Types") - files, vendors = getFiles(args.vendors) - - - print(str(len(vendors)) + " Vendors Found") - deviceTypes = readYAMl(files, slugs=args.slugs) - print(str(len(deviceTypes)) + " Device-Types Found") - createManufacturers(vendors, nb) - createDeviceTypes(deviceTypes, nb) - - if settings.NETBOX_FEATURES['modules']: - if not args.vendors: - print("No Vendors Specified, Gathering All Module-Types") - files, vendors = get_files_modules() - else: - print("Vendor Specified, Gathering All Matching Module-Types") - files, vendors = get_files_modules(args.vendors) - - - print(str(len(vendors)) + " Module Vendors Found") - module_types = read_yaml_modules(files, slugs=args.slugs) - print(str(len(module_types)) + " Module-Types Found") - createManufacturers(vendors, nb) - create_module_types(module_types, nb) - - print('---') - print('Script took {} to run'.format(datetime.now() - startTime)) - print('{} devices created'.format(counter['added'])) - print('{} interfaces/ports updated'.format(counter['updated'])) - print('{} manufacturers created'.format(counter['manufacturer'])) - if settings.NETBOX_FEATURES['modules']: - print(f"{counter['module_added']} modules created") - print(f"{counter['module_port_added']} module interface / ports created") - -if __name__ == "__main__": - main()