class NbPostDevice:
    '''  
    При создании экземпляра мы будем передавать в него все
    данные, что есть у нас в файле
    '''

    def __init__(self, ipaddress, hostname, model, mac_address, interface, siteslug, swroleslug):
        self.ipaddress = ipaddress
        self.hostname = hostname
        self.model = model
        self.mac_address = mac_address
        self.interface = interface
        self.siteslug = siteslug
        self.swroleslug = swroleslug


    def postdevice(self):
    '''
    Метод создаёт новое устройство в Netbox
    '''
        POSTSW = f"{URLNB}/api/dcim/devices/"
        ''' 
        Словарь содержит имя устройства, модель, сайт и роль
        Ещё я добавил описание, что бы потом было видно, что 
        устройство создано скриптом. Его можно убрать, 
        это не повлияет на работу скрипта
        '''
        sw_add = {
            "name": self.hostname,
            "device_type": {
            "model": self.model
            },
            "role": {
            "slug": self.swroleslug
            },
            "site": {
            "slug": self.siteslug
            },
            "description": "Added by script"
        }        
        # делаем POST запрос, передаём в Netbox наш словарь в формате json
        response = requests.post(POSTSW, headers=HEADERS, verify=False, json=sw_add)
        # Если запрос успешный, то возвращаем id созданного устройства
        if response.status_code == 201:
            out_dev = response.json()
            dev_id = out_dev['id']

            return response.status_code, dev_id

        else:
            return response.status_code, 0
    
    def postint(self):
    '''
    Метод для создания интерфейса управления
    Здесь всё аналогично, интерфейс создаётся, 
    на только что созданном устройстве
    В словаре передаём имя устройства и имя интерфейса,
    в примере это vlan4090
    '''
        POSTINT = f"{URLNB}/api/dcim/interfaces/"

        int_add = {
            "device": {
            "name": self.hostname
            },
            "name": self.interface,
            "type": "virtual",
            "enabled": True,
        }

        response = requests.post(POSTINT, headers=HEADERS, verify=False, json=int_add)
        # Если всё хорошо, то возвращаем id интерфейса
        if response.status_code == 201:
            out_int = response.json()
            int_id = out_int['id']

            return response.status_code, int_id

        else:
            return response.status_code, 0


    def postip(self, int_id):
        '''
        Добавляем ip на только что созданный интерфейс.
        Вот для этого и нужно было вернуть id интерфейса,
        на этот id и будем вешать ip адрес
        '''
        POSTIP = f"{URLNB}/api/ipam/ip-addresses/"

        ip_add = {
            "address": self.ipaddress,
            "status": "active",
            "assigned_object_type": "dcim.interface",
            "assigned_object_id": int(int_id)
        }

        response = requests.post(POSTIP, headers=HEADERS, verify=False, json=ip_add)

        return response.status_code


    def postmac(self, int_id):
    '''
    В этом методе создаём мак адрес на интерфейсе
    '''
        POSTMAC = f"{URLNB}/api/dcim/mac-addresses/"

        mac_add = {
            "mac_address": self.mac_address,
            "assigned_object_type": "dcim.interface",
            "assigned_object_id": int(int_id)
        }

        response = requests.post(POSTMAC, headers=HEADERS, verify=False, json=mac_add)

        return response.status_code


    def postmainip(self, dev_id):
    '''
    Здесь делаем ip адрес основным на данном устройвстве.
    Метод не обязательный, но ip адресов может быть много
    на одном устройстве, основной ip показывается
    на первой странице, что удобно, а так же отображается в отдельном поле
    если выдёргивать информацию через API. 
    '''
        POSTMAINIP = f"{URLNB}/api/dcim/devices/{dev_id}/"

        main_ip = {
            "primary_ip4": {
            "address": self.ipaddress
            }
        }

        response = requests.patch(POSTMAINIP, headers=HEADERS, verify=False, json=main_ip)

        return response.status_code

    def postmainmac(self, int_id):
    '''
    Делаем мак адрес основным, причина та же что и с ip.
    Просто удобство для дальнейшей работы с Нетбоксом, 
    по сути метод не обязательный.
    '''
        POSTMAINMAC = f"{URLNB}/api/dcim/interfaces/{int_id}/"

        main_mac = {
            "primary_mac_address": {
            "mac_address": self.mac_address
            }
        }

        response = requests.patch(POSTMAINMAC, headers=HEADERS, verify=False, json=main_mac)

        return response.status_code

'''
Загружаем переменные окружения, что мы прописывали в .env
'''
load_dotenv()
TOKEN_API = os.getenv('API_KEY')
HEADERS = {"Authorization": TOKEN_API}
URLNB = os.getenv('URLNB')
SITE_NAME = os.getenv('SITE_NAME')
IPSCAN = os.getenv('IPSCAN')
SWITCHES_FILE = os.getenv('SWITCHES_FILE')
# Настраиваем логирование
LOGDIR = "./"
LOGNAME = f"log_switch_add_{IPSCAN}.log"

logger = logging.getLogger('SWITCH_ADD')
logger.setLevel(logging.DEBUG)
logfile = logging.handlers.RotatingFileHandler(f'{LOGDIR}{LOGNAME}', mode='w')

logfile.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
logfile.setFormatter(formatter)
logger.addHandler(logfile)

'''
Открываем файл json с нашими коммутаторами, который тоже был
прописан в .еnv
'''
with open(SWITCHES_FILE, 'r') as f:
    dt = f.read()
    switches_from_file = json.loads(dt)

    for sw in switches_from_file:
        '''
        Перебираем список со словарями
        и создаём экземпляр класса со свичём 
        '''
        swadd = NbPostDevice(**sw)

        add_code, dev_id = swadd.postdevice()
        ''' Создаём устройство, если всё Ок, то пишем лог, что всё Ок '''
        if add_code == 201:
            logger.info(f'Устройство ({sw["hostname"]} - {sw["ipaddress"]}) - было добавлено')
        else:
            ''' Если произошла ошибка, то пишем лог об ошибке и завершаем скрипт'''
            logger.error(f'Ошибка добавления ({sw["hostname"]} - {sw["ipaddress"]})')
            break

        add_int, int_id = swadd.postint()
        ''' Создаём интерфейс, если всё Ок то пишем лог, что всё Ок '''
        if add_int == 201:
            logger.info(f'Интерфейс для ({sw["hostname"]} - {sw["ipaddress"]}) - добавлен')
        else:
            ''' Если произошла ошибка, то пишем лог об ошибке и завершаем скрипт '''
            logger.error(f'Ошибка добавления интерфейся для ({sw["hostname"]} - {sw["ipaddress"]})')
            break

        add_ip = swadd.postip(int_id)
        ''' Создаём ip, если всё Ок то пишем лог, что всё Ок '''
        if add_ip == 201:
            logger.info(f'IP адресс для ({sw["hostname"]} - {sw["ipaddress"]}) - добавлен')         
        else:
            ''' Если произошла ошибка, то пишем лог об ошибке и завершаем скрипт '''
            logger.error(f'Ошибка добавления IP ({sw["hostname"]} - {sw["ipaddress"]})')
            break

        add_mac = swadd.postmac(int_id)
        ''' Создаём мак, если всё Ок то пишем лог, что всё Ок '''
        if add_mac == 201:
            logger.info(f'MAC адресс для ({sw["hostname"]} - {sw["mac_address"]}) - добавлен')
        else:
            ''' Если произошла ошибка, то пишем лог об ошибке и завершаем скрипт '''
            logger.error(f'Ошибка добавления MAC ({sw["hostname"]} - {sw["mac_address"]})')
            break

        mainip = swadd.postmainip(dev_id)
        ''' Делаем ip основным, если всё Ок то пишем лог, что всё Ок '''
        if mainip == 200:
            logger.info(f'Основной IP адресс для ({sw["hostname"]} - {sw["ipaddress"]}) - добавлен')
        else:
            ''' Если произошла ошибка, то пишем лог об ошибке и завершаем скрипт '''
            logger.error(f'Ошибка добавления основного IP ({sw["hostname"]} - {sw["ipaddress"]})')
            break

        mainmac = swadd.postmainmac(int_id)
        ''' Делаем мак основным, если всё Ок то пишем лог, что всё Ок '''
        if mainmac == 200:
            logger.info(f'Основной MAC адресс для ({sw["hostname"]} - {sw["mac_address"]}) - добавлен')
        else:
            ''' Если произошла ошибка, то пишем лог об ошибке и завершаем скрипт '''
            logger.error(f'Ошибка добавления основного MAC ({sw["hostname"]} - {sw["mac_address"]})')
            break

import subprocess
import re
import json
import os
from dotenv import load_dotenv


class SwitchSnmpGet:
    '''
    Класс для получения данных по SNMP
    принимаем ip и snmp community 
    '''
    def __init__(self, ipaddress, snmp_com):
        self.ipaddress = ipaddress
        self.snmp_com = snmp_com


    def getsysdescr(self):
        ''' 
        Класс для получения модели коммутатора по SNMP
        '''
        sysdescroid = '1.3.6.1.2.1.1.1'
        parse_snmp = 'STRING: (?P<snmpout>.+)'
        sysdescr = 'unknown'

        process = subprocess.Popen(['snmpwalk', '-c', self.snmp_com, '-v2c', self.ipaddress, sysdescroid], stdout=subprocess.PIPE)

        while True:
            output = process.stdout.readline()

            if output == b'' and process.poll() is not None:
                break
            if output:
                outsnmp = output.decode('utf-8')
                match = re.search(parse_snmp, outsnmp)

                if match:
                    sysdescr = match.group('snmpout')

        return sysdescr


    def getsysname(self):
        ''' 
        Получает hostname через snmp 
        '''
        sysnameoid = '1.3.6.1.2.1.1.5'
        parse_snmp = 'STRING: (?P<snmpout>.+)'
        sysname = 'unknown'

        process = subprocess.Popen(['snmpwalk', '-c', self.snmp_com, '-v2c', self.ipaddress, sysnameoid], stdout=subprocess.PIPE)

        while True:
            output = process.stdout.readline()

            if output == b'' and process.poll() is not None:
                break
            if output:
                outsnmp = output.decode('utf-8')
                match = re.search(parse_snmp, outsnmp)

                if match:
                    sysname = match.group('snmpout')

        return sysname

''' 
Регулярка для определения ip, мака и вендора
в зависимости от дистрибутива linux, возможно придётся редактировать
у меня работало на Debian
'''
parseout = (r'for (?P<ipaddress>\d+.\d+.\d+.\d+)'
            r'|MAC Address: (?P<mac>\S+) \((?P<vendor>.+)\)')

# Загружаем переменные окружения с настройками
load_dotenv()
IPSCAN = os.getenv('IPSCAN')
NETMASK = os.getenv('NETMASK')
SNMP_COM = os.getenv('SNMP_COM')
INTERFACE = os.getenv('INTERFACE')
SITE_SLUG = os.getenv('SITE_SLUG')
SWROLESLUG = os.getenv('SWROLESLUG')

NETWORK = IPSCAN + NETMASK
ipaddress = ''

# Командой 'nmap -sP -n' запрускаем сканирование сети, только пинги, без портов
cmd_for_scan = f'nmap -sP -n {NETWORK}'
cmd = cmd_for_scan.split()

process = subprocess.Popen(cmd, stdout=subprocess.PIPE)

result_list = []

while True:
    '''
    Запускаем сканирование, при удачном обнаружении устройства
    опрашиваем его по SNMP и создаём словарь
    полученный словарь добавляем в список
    '''
    output = process.stdout.readline()
    if output == b'' and process.poll() is not None:
        break
    if output:
        outlist = output.strip().decode('utf-8')
        match = re.search(parseout, outlist)
        '''
        Здесь я исключил попадание в словарь устройств
        с которых nmap не смог определить вендора и не показывал мак
        у меня это сервера, их добавлять буду отдельно
        '''
        if match:
            if match.lastgroup == 'ipaddress':
                ipaddress = match.group(match.lastgroup)
            else:
                mac_address = match.group('mac').lower()
                vendor = match.group('vendor')
                get_model = SwitchSnmpGet(ipaddress, SNMP_COM)

                result_dict = {
                    'ipaddress': ipaddress+NETMASK,
                    'interface': INTERFACE,
                    'mac_address': mac_address,
                    'vendor': vendor,
                    'model': get_model.getsysdescr(),
                    'hostname': get_model.getsysname(),
                    'siteslug': SITE_SLUG,
                    'swroleslug': SWROLESLUG,
                    }
                result_list.append(result_dict)

# Сохраняем в файл json
with open(f'nmap_{IPSCAN}.json', 'w') as f:
    json.dump(result_list, f, sort_keys=True, indent=2)

import os
import json
import requests
import logging
import logging.handlers
from dotenv import load_dotenv


class NbCheckDevice:
    ''' 
    Передаём все имеющиеся в словаре ключи
    '''

    def __init__(self, ipaddress, hostname, model, mac_address, interface, siteslug, swroleslug):
        self.ipaddress = ipaddress
        self.hostname = hostname
        self.model = model
        self.mac_address = mac_address
        self.interface = interface
        self.swroleslug = swroleslug
        self.siteslug = siteslug


    def getdevice(self):
        '''
        Делаем запрос в Нетбок по имени хоста
        Если такого хоста нет, то делаем запрос по модели
        '''
        URLSW = f"{URLNB}/api/dcim/devices/?name="
        
        response = requests.get(URLSW+self.hostname, headers=HEADERS, verify=False)
        device_list = json.loads(json.dumps(response.json()))

        if device_list['count'] > 0:
            swmodel = False

            return device_list['count'], swmodel

        else:
            URLMODEL = f'{URLNB}/api/dcim/device-types/?model='
            swmodel = False

            response = requests.get(URLMODEL+self.model, headers=HEADERS, verify=False)
            model_list = json.loads(json.dumps(response.json()))

            if model_list['count'] > 0:
                for ml in model_list['results']:
                    swmodel = ml['model']

                return 0, swmodel

            else:
                return 0, swmodel

# загружаем переменные окружения с настройками
load_dotenv()

TOKEN_API = os.getenv('API_KEY')
HEADERS = {"Authorization": TOKEN_API}
URLNB = os.getenv('URLNB')
SWPOST = f'{URLNB}/api/dcim/devices/'
CHECK_FILE = os.getenv('CHECK_FILE')
IPSCAN = os.getenv('IPSCAN')
# Заморачиваемся с логами
LOGDIR = "./"
LOGNAME = f"log_switch_check_{IPSCAN}.log"

logger = logging.getLogger('SWITCH_CHECK')
logger.setLevel(logging.DEBUG)
logfile = logging.handlers.RotatingFileHandler(f'{LOGDIR}{LOGNAME}', mode='w')

logfile.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
logfile.setFormatter(formatter)
logger.addHandler(logfile)


with open(CHECK_FILE, 'r') as f:
    '''
    Открываем файл который создал предыдущий скрипт
    '''
    dt = f.read()
    switches_from_file = json.loads(dt)

    # Данные списки будем наполнять словарями
    unknown_devices = [] # Устройства у которых есть ключи со значение unknown
    exist_devices = [] # Устройства которые уже добавлены в Нетбокс
    none_model = [] # Устройства для которых не создана модель
    add_devices = [] # Устройства которые можно добавить в Нетбокс

    for l in switches_from_file:
        ''' Проверяем коммутатор в Нетбоксе и пишем логи '''
        _ = l.pop('vendor') # Убираем ключ vendor, больше он нам не нужен
        if l['hostname'] == 'unknown' or l['model'] == 'unknown' == 'unknown':
            logger.info(f'Коммутатор ({l["ipaddress"]}) нужно будет добавить руками')
            unknown_devices.append(l)
        else:
            device = NbCheckDevice(**l)
            device_count, swmodel = device.getdevice()
            if device_count > 0:
                logger.info(f'Коммутатор ({l["ipaddress"]}) уже есть в НетБоксе')
                exist_devices.append(l)
            elif swmodel == False:
                logger.info(f'Для коммутатора ({l["ipaddress"]}) нужно создать модель')
                none_model.append(l)
            else:
                logger.info(f'Коммутатор ({l["ipaddress"]}, {swmodel}) можно добавить скриптом')
                switch_model = {'model': swmodel}
                add_devices.append({**l, **switch_model})

# Пишем полученные списки в файлы
with open(f'unknown_{CHECK_FILE}', 'w') as f:
    json.dump(unknown_devices, f, sort_keys=True, indent=2)

with open(f'exist_{CHECK_FILE}', 'w') as f:
    json.dump(exist_devices, f, sort_keys=True, indent=2)

with open(f'none_model_{CHECK_FILE}', 'w') as f:
    json.dump(none_model, f, sort_keys=True, indent=2)

with open(f'add_{CHECK_FILE}', 'w') as f:
    json.dump(add_devices, f, sort_keys=True, indent=2)