374 lines
14 KiB
Python
374 lines
14 KiB
Python
from itertools import chain
|
|
import logging
|
|
import os
|
|
import re
|
|
|
|
from netaddr import IPAddress, IPNetwork
|
|
import netifaces
|
|
|
|
from netbox_agent.config import netbox_instance as nb
|
|
from netbox_agent.config import NETWORK_IGNORE_INTERFACES, NETWORK_IGNORE_IPS
|
|
from netbox_agent.ethtool import Ethtool
|
|
from netbox_agent.ipmi import IPMI
|
|
|
|
IFACE_TYPE_100ME_FIXED = 800
|
|
IFACE_TYPE_1GE_FIXED = 1000
|
|
IFACE_TYPE_1GE_GBIC = 1050
|
|
IFACE_TYPE_1GE_SFP = 1100
|
|
IFACE_TYPE_2GE_FIXED = 1120
|
|
IFACE_TYPE_5GE_FIXED = 1130
|
|
IFACE_TYPE_10GE_FIXED = 1150
|
|
IFACE_TYPE_10GE_CX4 = 1170
|
|
IFACE_TYPE_10GE_SFP_PLUS = 1200
|
|
IFACE_TYPE_10GE_XFP = 1300
|
|
IFACE_TYPE_10GE_XENPAK = 1310
|
|
IFACE_TYPE_10GE_X2 = 1320
|
|
IFACE_TYPE_25GE_SFP28 = 1350
|
|
IFACE_TYPE_40GE_QSFP_PLUS = 1400
|
|
IFACE_TYPE_50GE_QSFP28 = 1420
|
|
IFACE_TYPE_100GE_CFP = 1500
|
|
IFACE_TYPE_100GE_CFP2 = 1510
|
|
IFACE_TYPE_100GE_CFP4 = 1520
|
|
IFACE_TYPE_100GE_CPAK = 1550
|
|
IFACE_TYPE_100GE_QSFP28 = 1600
|
|
IFACE_TYPE_200GE_CFP2 = 1650
|
|
IFACE_TYPE_200GE_QSFP56 = 1700
|
|
IFACE_TYPE_400GE_QSFP_DD = 1750
|
|
IFACE_TYPE_OTHER = 32767
|
|
IFACE_TYPE_LAG = 200
|
|
|
|
|
|
class Network():
|
|
def __init__(self, server, *args, **kwargs):
|
|
self.nics = []
|
|
|
|
self.server = server
|
|
self.device = self.server.get_netbox_server()
|
|
self.scan()
|
|
|
|
def scan(self):
|
|
for interface in os.listdir('/sys/class/net/'):
|
|
# ignore if it's not a link (ie: bonding_masters etc)
|
|
if not os.path.islink('/sys/class/net/{}'.format(interface)):
|
|
continue
|
|
|
|
if NETWORK_IGNORE_INTERFACES and \
|
|
re.match(NETWORK_IGNORE_INTERFACES, interface):
|
|
logging.debug('Ignore interface {interface}'.format(interface=interface))
|
|
continue
|
|
|
|
ip_addr = netifaces.ifaddresses(interface).get(netifaces.AF_INET)
|
|
if NETWORK_IGNORE_IPS and ip_addr:
|
|
for i, ip in enumerate(ip_addr):
|
|
if re.match(NETWORK_IGNORE_IPS, ip['addr']):
|
|
ip_addr.pop(i)
|
|
|
|
mac = open('/sys/class/net/{}/address'.format(interface), 'r').read().strip()
|
|
vlan = None
|
|
if len(interface.split('.')) > 1:
|
|
vlan = int(interface.split('.')[1])
|
|
bonding = False
|
|
bonding_slaves = []
|
|
if os.path.isdir('/sys/class/net/{}/bonding'.format(interface)):
|
|
bonding = True
|
|
bonding_slaves = open(
|
|
'/sys/class/net/{}/bonding/slaves'.format(interface)
|
|
).read().split()
|
|
nic = {
|
|
'name': interface,
|
|
'mac': mac if mac != '00:00:00:00:00:00' else None,
|
|
'ip': [
|
|
'{}/{}'.format(
|
|
x['addr'],
|
|
IPAddress(x['netmask']).netmask_bits()
|
|
) for x in ip_addr
|
|
] if ip_addr else None, # FIXME: handle IPv6 addresses
|
|
'ethtool': Ethtool(interface).parse(),
|
|
'vlan': vlan,
|
|
'bonding': bonding,
|
|
'bonding_slaves': bonding_slaves,
|
|
}
|
|
self.nics.append(nic)
|
|
|
|
def _set_bonding_interfaces(self):
|
|
bonding_nics = (x for x in self.nics if x['bonding'])
|
|
for nic in bonding_nics:
|
|
bond_int = self.get_netbox_network_card(nic)
|
|
logging.debug('Setting slave interface for {name}'.format(
|
|
name=bond_int.name
|
|
))
|
|
for slave_int in (
|
|
self.get_netbox_network_card(slave_nic)
|
|
for slave_nic in self.nics
|
|
if slave_nic['name'] in nic['bonding_slaves']):
|
|
if slave_int.lag is None or slave_int.lag.id != bond_int.id:
|
|
logging.debug('Settting interface {name} as slave of {master}'.format(
|
|
name=slave_int.name, master=bond_int.name
|
|
))
|
|
slave_int.lag = bond_int
|
|
slave_int.save()
|
|
else:
|
|
return False
|
|
return True
|
|
|
|
def get_network_cards(self):
|
|
return self.nics
|
|
|
|
def get_netbox_network_card(self, nic):
|
|
if nic['mac'] is None:
|
|
interface = nb.dcim.interfaces.get(
|
|
device_id=self.device.id,
|
|
name=nic['name'],
|
|
)
|
|
else:
|
|
interface = nb.dcim.interfaces.get(
|
|
device_id=self.device.id,
|
|
mac_address=nic['mac'],
|
|
name=nic['name'],
|
|
)
|
|
return interface
|
|
|
|
def get_netbox_network_cards(self):
|
|
return nb.dcim.interfaces.filter(
|
|
device_id=self.device.id,
|
|
mgmt_only=False,
|
|
)
|
|
|
|
def get_netbox_type_for_nic(self, nic):
|
|
if nic.get('bonding'):
|
|
return IFACE_TYPE_LAG
|
|
if nic.get('ethtool') is None:
|
|
return IFACE_TYPE_OTHER
|
|
if nic['ethtool']['speed'] == '10000Mb/s':
|
|
if nic['ethtool']['port'] == 'FIBRE':
|
|
return IFACE_TYPE_10GE_SFP_PLUS
|
|
return IFACE_TYPE_10GE_FIXED
|
|
elif nic['ethtool']['speed'] == '1000Mb/s':
|
|
if nic['ethtool']['port'] == 'FIBRE':
|
|
return IFACE_TYPE_1GE_SFP
|
|
return IFACE_TYPE_1GE_FIXED
|
|
return IFACE_TYPE_OTHER
|
|
|
|
def get_ipmi(self):
|
|
ipmi = IPMI().parse()
|
|
return ipmi
|
|
|
|
def get_netbox_ipmi(self):
|
|
ipmi = self.get_ipmi()
|
|
mac = ipmi['MAC Address']
|
|
return nb.dcim.interfaces.get(
|
|
mac=mac
|
|
)
|
|
|
|
def get_or_create_vlan(self, vlan_id):
|
|
# FIXME: we may need to specify the datacenter
|
|
# since users may have same vlan id in multiple dc
|
|
vlan = nb.ipam.vlans.get(
|
|
vid=vlan_id,
|
|
)
|
|
if vlan is None:
|
|
vlan = nb.ipam.vlans.create(
|
|
name='VLAN {}'.format(vlan_id),
|
|
vid=vlan_id,
|
|
)
|
|
return vlan
|
|
|
|
def reset_vlan_on_interface(self, vlan_id, interface):
|
|
update = False
|
|
if vlan_id is None and \
|
|
(interface.mode is not None or len(interface.tagged_vlans) > 0):
|
|
logging.info('Interface {interface} is not tagged, reseting mode'.format(
|
|
interface=interface))
|
|
update = True
|
|
interface.mode = None
|
|
interface.tagged_vlans = []
|
|
elif vlan_id and (
|
|
interface.mode is None or
|
|
len(interface.tagged_vlans) != 1 or
|
|
interface.tagged_vlans[0].vid != vlan_id):
|
|
logging.info('Resetting VLAN on interface {interface}'.format(
|
|
interface=interface))
|
|
update = True
|
|
nb_vlan = self.get_or_create_vlan(vlan_id)
|
|
interface.mode = 200
|
|
interface.tagged_vlans = [nb_vlan] if nb_vlan else []
|
|
return update, interface
|
|
|
|
def create_or_update_ipmi(self):
|
|
ipmi = self.get_ipmi()
|
|
mac = ipmi['MAC Address']
|
|
ip = ipmi['IP Address']
|
|
netmask = ipmi['Subnet Mask']
|
|
vlan = int(ipmi['802.1q VLAN ID']) if ipmi['802.1q VLAN ID'] != 'Disabled' else None
|
|
address = str(IPNetwork('{}/{}'.format(ip, netmask)))
|
|
|
|
interface = nb.dcim.interfaces.get(
|
|
device_id=self.device.id,
|
|
mgmt_only=True,
|
|
)
|
|
nic = {
|
|
'name': 'IPMI',
|
|
'mac': mac,
|
|
'vlan': vlan,
|
|
'ip': [address],
|
|
}
|
|
if interface is None:
|
|
interface = self.create_netbox_nic(nic, mgmt=True)
|
|
self.create_or_update_netbox_ip_on_interface(address, interface)
|
|
else:
|
|
# let the user chose the name of mgmt ?
|
|
# guess it with manufacturer (IDRAC, ILO, ...) ?
|
|
update = False
|
|
self.create_or_update_netbox_ip_on_interface(address, interface)
|
|
update, interface = self.reset_vlan_on_interface(nic['vlan'], interface)
|
|
if mac.upper() != interface.mac_address:
|
|
logging.info('IPMI mac changed from {old_mac} to {new_mac}'.format(
|
|
old_mac=interface.mac_address, new_mac=mac.upper()))
|
|
interface.mac_address = mac
|
|
update = True
|
|
if update:
|
|
interface.save()
|
|
return interface
|
|
|
|
def create_netbox_nic(self, nic, mgmt=False):
|
|
# TODO: add Optic Vendor, PN and Serial
|
|
type = self.get_netbox_type_for_nic(nic)
|
|
logging.info('Creating NIC {name} ({mac}) on {device}'.format(
|
|
name=nic['name'], mac=nic['mac'], device=self.device.name))
|
|
|
|
nb_vlan = None
|
|
if nic['vlan']:
|
|
nb_vlan = self.get_or_create_vlan(nic['vlan'])
|
|
return nb.dcim.interfaces.create(
|
|
device=self.device.id,
|
|
name=nic['name'],
|
|
mac_address=nic['mac'],
|
|
type=type,
|
|
mode=200 if nic['vlan'] else None,
|
|
tagged_vlans=[nb_vlan.id] if nb_vlan is not None else [],
|
|
mgmt_only=mgmt,
|
|
)
|
|
|
|
def create_or_update_netbox_ip_on_interface(self, ip, interface):
|
|
netbox_ip = nb.ipam.ip_addresses.get(
|
|
address=ip,
|
|
)
|
|
if netbox_ip:
|
|
if netbox_ip.interface is None:
|
|
logging.info('Assigning existing IP {ip} to {interface}'.format(
|
|
ip=ip, interface=interface))
|
|
elif netbox_ip.interface.id != interface.id:
|
|
logging.info(
|
|
'Detected interface change for ip {ip}: old interface is '
|
|
'{old_interface} (id: {old_id}), new interface is {new_interface} '
|
|
' (id: {new_id})'
|
|
.format(
|
|
old_interface=netbox_ip.interface, new_interface=interface,
|
|
old_id=netbox_ip.id, new_id=interface.id, ip=netbox_ip.address
|
|
))
|
|
else:
|
|
return netbox_ip
|
|
netbox_ip.interface = interface
|
|
netbox_ip.save()
|
|
else:
|
|
logging.info('Create new IP {ip} on {interface}'.format(
|
|
ip=ip, interface=interface))
|
|
netbox_ip = nb.ipam.ip_addresses.create(
|
|
address=ip,
|
|
interface=interface.id,
|
|
status=1,
|
|
)
|
|
return netbox_ip
|
|
|
|
def create_netbox_network_cards(self):
|
|
logging.debug('Creating NIC...')
|
|
for nic in self.nics:
|
|
interface = self.get_netbox_network_card(nic)
|
|
# if network doesn't exist we create it
|
|
if not interface:
|
|
new_interface = self.create_netbox_nic(nic)
|
|
if nic['ip']:
|
|
# for each ip, we try to find it
|
|
# assign the device's interface to it
|
|
# or simply create it
|
|
for ip in nic['ip']:
|
|
self.create_or_update_netbox_ip_on_interface(ip, new_interface)
|
|
self._set_bonding_interfaces()
|
|
self.create_or_update_ipmi()
|
|
logging.debug('Finished creating NIC!')
|
|
|
|
def update_netbox_network_cards(self):
|
|
logging.debug('Updating NIC...')
|
|
|
|
# delete unknown interface
|
|
nb_nics = self.get_netbox_network_cards()
|
|
local_nics = [x['name'] for x in self.nics]
|
|
for nic in nb_nics:
|
|
if nic.name not in local_nics:
|
|
logging.info('Deleting netbox interface {name} because not present locally'.format(
|
|
name=nic.name
|
|
))
|
|
nic.delete()
|
|
|
|
# delete IP on netbox that are not known on this server
|
|
netbox_ips = nb.ipam.ip_addresses.filter(
|
|
device_id=self.device.id,
|
|
interface_id=[x.id for x in nb_nics],
|
|
)
|
|
all_local_ips = list(chain.from_iterable([
|
|
x['ip'] for x in self.nics if x['ip'] is not None
|
|
]))
|
|
for netbox_ip in netbox_ips:
|
|
if netbox_ip.address not in all_local_ips:
|
|
logging.info('Unassigning IP {ip} from {interface}'.format(
|
|
ip=netbox_ip.address, interface=netbox_ip.interface))
|
|
netbox_ip.interface = None
|
|
netbox_ip.save()
|
|
|
|
# update each nic
|
|
for nic in self.nics:
|
|
interface = self.get_netbox_network_card(nic)
|
|
if not interface:
|
|
logging.info('Interface {mac_address} not found, creating..'.format(
|
|
mac_address=nic['mac'])
|
|
)
|
|
interface = self.create_netbox_nic(nic)
|
|
|
|
nic_update = False
|
|
if nic['name'] != interface.name:
|
|
nic_update = True
|
|
logging.info('Updating interface {interface} name to: {name}'.format(
|
|
interface=interface, name=nic['name']))
|
|
interface.name = nic['name']
|
|
|
|
nic_update, interface = self.reset_vlan_on_interface(nic['vlan'], interface)
|
|
|
|
type = self.get_netbox_type_for_nic(nic)
|
|
if not interface.type or \
|
|
type != interface.type.value:
|
|
logging.info('Interface type is wrong, resetting')
|
|
nic_update = True
|
|
interface.type = type
|
|
|
|
if interface.lag is not None:
|
|
local_lag_int = next(
|
|
item for item in self.nics if item['name'] == interface.lag.name
|
|
)
|
|
if nic['name'] not in local_lag_int['bonding_slaves']:
|
|
logging.info('Interface has no LAG, resetting')
|
|
nic_update = True
|
|
interface.lag = None
|
|
|
|
if nic['ip']:
|
|
# sync local IPs
|
|
for ip in nic['ip']:
|
|
netbox_ip = nb.ipam.ip_addresses.get(
|
|
address=ip,
|
|
)
|
|
self.create_or_update_netbox_ip_on_interface(ip, interface)
|
|
if nic_update:
|
|
interface.save()
|
|
|
|
self._set_bonding_interfaces()
|
|
self.create_or_update_ipmi()
|
|
logging.debug('Finished updating NIC!')
|