diff --git a/README.md b/README.md index 7bb4735c..03483362 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ This script will clone a copy of the `netbox-community/devicetype-library` repos 1. This script is written in Python, so lets setup a virtual environment. ``` -git clone https://github.com/minitriga/Netbox-Device-Type-Library-Import +git clone https://github.com/minitriga/Netbox-Device-Type-Library-Import cd Netbox-Device-Type-Library-Import python3 -m venv venv source venv/bin/activate @@ -38,12 +38,18 @@ Finally, we are able to execute the script and import some device templates! ## 🔌 Usage -To use the script, simply execute the script as follows. Make sure you're still in the activated virtual environment we created before. +To use the script, simply execute the script as follows. Make sure you're still in the activated virtual environment we created before. (Mac/Linux users) ``` ./nb-dt-import.py ``` +For windows users, execute this slightly modifiied file in the same activated environment as before. + +``` +./nb-dt-import_windows.py +``` + This will clone the latest master branch from the `netbox-community/devicetype-library` from Github and install it into the `repo` subdirectory. If this directory already exists, it will perform a `git pull` to update the reposity instead. Next, it will loop over every manufacturer and every device of every manufacturer and begin checking if your Netbox install already has them, and if not, creates them. It will skip preexisting manufacturers, devices, interfaces, etc. so as to not end up with duplicate entries in your Netbox instance. @@ -58,7 +64,7 @@ To import only device by APC, for example: ./nb-dt-import.py --vendors apc ``` -`--vendors` can also accept a comma separated list of vendors if you want to import multiple. +`--vendors` can also accept a comma separated list of vendors if you want to import multiple. ``` ./nb-dt-import.py --vendors apc,juniper @@ -66,9 +72,9 @@ To import only device by APC, for example: ## Docker build -It's possible to use this project as a docker container. +It's possible to use this project as a docker container. -To build : +To build : ``` docker build -t netbox-devicetype-import-library . @@ -80,7 +86,7 @@ Alternatively you can pull a pre-built image from Github Container Registry (ghc docker pull ghcr.io/minitriga/netbox-device-type-library-import ``` -The container supports the following env var as configuration : +The container supports the following env var as configuration : - `REPO_URL`, the repo to look for device types (defaults to _https://github.com/netbox-community/devicetype-library.git_) - `REPO_BRANCH`, the branch to check out if appropriate, defaults to master. @@ -88,7 +94,7 @@ The container supports the following env var as configuration : - `NETBOX_TOKEN`, token for accessing netbox - `VENDORS`, a comma-separated list of vendors to import (defaults to None) -To run : +To run : ``` docker run -e "NETBOX_URL=http://netbox:8080/" -e "NETBOX_TOKEN=98765434567890" ghcr.io/minitriga/netbox-device-type-library-import diff --git a/nb-dt-import_windows.py b/nb-dt-import_windows.py new file mode 100644 index 00000000..23125bea --- /dev/null +++ b/nb-dt-import_windows.py @@ -0,0 +1,859 @@ +#!/usr/bin/env python +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, 'rb') 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()