359 lines
12 KiB
Python
359 lines
12 KiB
Python
import logging
|
|
from pprint import pprint
|
|
import socket
|
|
import subprocess
|
|
|
|
from netbox_agent.config import netbox_instance as nb, config
|
|
import netbox_agent.dmidecode as dmidecode
|
|
from netbox_agent.location import Datacenter, Rack
|
|
from netbox_agent.inventory import Inventory
|
|
from netbox_agent.network import Network
|
|
from netbox_agent.power import PowerSupply
|
|
|
|
|
|
def get_device_role(role):
|
|
device_role = nb.dcim.device_roles.get(
|
|
name=role
|
|
)
|
|
if device_role is None:
|
|
raise Exception('DeviceRole "{}" does not exist, please create it'.format(role))
|
|
return device_role
|
|
|
|
|
|
def get_device_type(type):
|
|
device_type = nb.dcim.device_types.get(
|
|
model=type
|
|
)
|
|
if device_type is None:
|
|
raise Exception('DeviceType "{}" does not exist, please create it'.format(type))
|
|
return device_type
|
|
|
|
|
|
class ServerBase():
|
|
def __init__(self, dmi=None):
|
|
if dmi:
|
|
self.dmi = dmi
|
|
else:
|
|
self.dmi = dmidecode.parse()
|
|
|
|
self.baseboard = self.dmi.get_by_type('Baseboard')
|
|
self.bios = self.dmi.get_by_type('BIOS')
|
|
self.chassis = self.dmi.get_by_type('Chassis')
|
|
self.system = self.dmi.get_by_type('System')
|
|
|
|
self.network = None
|
|
|
|
def get_datacenter(self):
|
|
dc = Datacenter()
|
|
return dc.get()
|
|
|
|
def get_netbox_datacenter(self):
|
|
datacenter = nb.dcim.sites.get(
|
|
slug=self.get_datacenter()
|
|
)
|
|
return datacenter
|
|
|
|
def update_netbox_location(self, server):
|
|
dc = self.get_datacenter()
|
|
rack = self.get_rack()
|
|
nb_rack = self.get_netbox_rack()
|
|
nb_dc = self.get_netbox_datacenter()
|
|
|
|
update = False
|
|
if dc and server.site and server.site.slug != nb_dc.slug:
|
|
logging.info('Datacenter location has changed from {} to {}, updating'.format(
|
|
server.site.slug,
|
|
nb_dc.slug,
|
|
))
|
|
update = True
|
|
server.site = nb_dc.id
|
|
|
|
if rack and server.rack and server.rack.id != nb_rack.id:
|
|
logging.info('Rack location has changed from {} to {}, updating'.format(
|
|
server.rack,
|
|
nb_rack,
|
|
))
|
|
update = True
|
|
server.rack = nb_rack
|
|
if nb_rack is None:
|
|
server.face = None
|
|
server.position = None
|
|
return update, server
|
|
|
|
def get_rack(self):
|
|
rack = Rack()
|
|
return rack.get()
|
|
|
|
def get_netbox_rack(self):
|
|
rack = nb.dcim.racks.get(
|
|
name=self.get_rack(),
|
|
site_id=self.get_netbox_datacenter().id,
|
|
)
|
|
return rack
|
|
|
|
def get_product_name(self):
|
|
"""
|
|
Return the Chassis Name from dmidecode info
|
|
"""
|
|
return self.system[0]['Product Name'].strip()
|
|
|
|
def get_service_tag(self):
|
|
"""
|
|
Return the Service Tag from dmidecode info
|
|
"""
|
|
return self.system[0]['Serial Number'].strip()
|
|
|
|
def get_hostname(self):
|
|
if config.hostname_cmd is None:
|
|
return '{}'.format(socket.gethostname())
|
|
return subprocess.getoutput(config.hostname_cmd)
|
|
|
|
def is_blade(self):
|
|
raise NotImplementedError
|
|
|
|
def get_blade_slot(self):
|
|
raise NotImplementedError
|
|
|
|
def get_chassis(self):
|
|
raise NotImplementedError
|
|
|
|
def get_chassis_name(self):
|
|
raise NotImplementedError
|
|
|
|
def get_chassis_service_tag(self):
|
|
raise NotImplementedError
|
|
|
|
def get_bios_version(self):
|
|
raise NotImplementedError
|
|
|
|
def get_bios_version_attr(self):
|
|
raise NotImplementedError
|
|
|
|
def get_bios_release_date(self):
|
|
raise NotImplementedError
|
|
|
|
def get_power_consumption(self):
|
|
raise NotImplementedError
|
|
|
|
def _netbox_create_blade_chassis(self, datacenter, rack):
|
|
device_type = get_device_type(self.get_chassis())
|
|
device_role = get_device_role('Server Chassis')
|
|
serial = self.get_chassis_service_tag()
|
|
logging.info('Creating chassis blade (serial: {serial})'.format(
|
|
serial=serial))
|
|
new_chassis = nb.dcim.devices.create(
|
|
name=self.get_chassis_name(),
|
|
device_type=device_type.id,
|
|
serial=serial,
|
|
device_role=device_role.id,
|
|
site=datacenter.id if datacenter else None,
|
|
rack=rack.id if rack else None,
|
|
)
|
|
return new_chassis
|
|
|
|
def _netbox_create_blade(self, chassis, datacenter, rack):
|
|
device_role = get_device_role('Blade')
|
|
device_type = get_device_type(self.get_product_name())
|
|
serial = self.get_service_tag()
|
|
hostname = self.get_hostname()
|
|
logging.info(
|
|
'Creating blade (serial: {serial}) {hostname} on chassis {chassis_serial}'.format(
|
|
serial=serial, hostname=hostname, chassis_serial=chassis.serial
|
|
))
|
|
new_blade = nb.dcim.devices.create(
|
|
name=hostname,
|
|
serial=serial,
|
|
device_role=device_role.id,
|
|
device_type=device_type.id,
|
|
parent_device=chassis.id,
|
|
site=datacenter.id if datacenter else None,
|
|
rack=rack.id if rack else None,
|
|
)
|
|
return new_blade
|
|
|
|
def _netbox_set_blade_slot(self, chassis, server):
|
|
slot = self.get_blade_slot()
|
|
# Find the slot and update it with our blade
|
|
device_bays = nb.dcim.device_bays.filter(
|
|
device_id=chassis.id,
|
|
name=slot,
|
|
)
|
|
if len(device_bays) > 0:
|
|
logging.info(
|
|
'Setting device ({serial}) new slot on {slot} '
|
|
'(Chassis {chassis_serial})..'.format(
|
|
serial=server.serial, slot=slot, chassis_serial=chassis.serial
|
|
))
|
|
device_bay = device_bays[0]
|
|
device_bay.installed_device = server
|
|
device_bay.save()
|
|
else:
|
|
logging.error('Could not find slot {slot} for chassis'.format(
|
|
slot=slot
|
|
))
|
|
|
|
def _netbox_create_server(self, datacenter, rack):
|
|
device_role = get_device_role('Server')
|
|
device_type = get_device_type(self.get_product_name())
|
|
if not device_type:
|
|
raise Exception('Chassis "{}" doesn\'t exist'.format(self.get_chassis()))
|
|
serial = self.get_service_tag()
|
|
hostname = self.get_hostname()
|
|
logging.info('Creating server (serial: {serial}) {hostname}'.format(
|
|
serial=serial, hostname=hostname))
|
|
new_server = nb.dcim.devices.create(
|
|
name=hostname,
|
|
serial=serial,
|
|
device_role=device_role.id,
|
|
device_type=device_type.id,
|
|
site=datacenter.id if datacenter else None,
|
|
rack=rack.id if rack else None,
|
|
)
|
|
return new_server
|
|
|
|
def get_netbox_server(self):
|
|
return nb.dcim.devices.get(serial=self.get_service_tag())
|
|
|
|
def netbox_create(self, config):
|
|
logging.debug('Creating Server..')
|
|
datacenter = self.get_netbox_datacenter()
|
|
rack = self.get_netbox_rack()
|
|
if self.is_blade():
|
|
# let's find the blade
|
|
serial = self.get_service_tag()
|
|
blade = nb.dcim.devices.get(serial=serial)
|
|
chassis = nb.dcim.devices.get(serial=self.get_chassis_service_tag())
|
|
# if it doesn't exist, create it
|
|
if not blade:
|
|
# check if the chassis exist before
|
|
# if it doesn't exist, create it
|
|
chassis = nb.dcim.devices.get(
|
|
serial=self.get_chassis_service_tag()
|
|
)
|
|
if not chassis:
|
|
chassis = self._netbox_create_blade_chassis(datacenter, rack)
|
|
|
|
blade = self._netbox_create_blade(chassis, datacenter, rack)
|
|
|
|
# Set slot for blade
|
|
self._netbox_set_blade_slot(chassis, blade)
|
|
else:
|
|
server = nb.dcim.devices.get(serial=self.get_service_tag())
|
|
if not server:
|
|
self._netbox_create_server(datacenter, rack)
|
|
|
|
self.network = Network(server=self)
|
|
self.network.create_netbox_network_cards()
|
|
|
|
self.power = PowerSupply(server=self)
|
|
self.power.create_or_update_power_supply()
|
|
|
|
if config.inventory:
|
|
self.inventory = Inventory(server=self)
|
|
self.inventory.create()
|
|
logging.debug('Server created!')
|
|
|
|
def _netbox_update_chassis_for_blade(self, server, datacenter):
|
|
chassis = server.parent_device.device_bay.device
|
|
device_bay = nb.dcim.device_bays.get(
|
|
server.parent_device.device_bay.id
|
|
)
|
|
|
|
parent_chassis = nb.dcim.devices.get(
|
|
chassis.id
|
|
)
|
|
|
|
netbox_chassis_serial = parent_chassis.serial
|
|
move_device_bay = False
|
|
|
|
# check chassis serial with dmidecode
|
|
if netbox_chassis_serial != self.get_chassis_service_tag():
|
|
move_device_bay = True
|
|
# try to find the new netbox chassis
|
|
chassis = nb.dcim.devices.get(
|
|
serial=self.get_chassis_service_tag()
|
|
)
|
|
if not chassis:
|
|
chassis = self._netbox_create_blade_chassis(datacenter)
|
|
if move_device_bay or device_bay.name != self.get_blade_slot():
|
|
logging.info('Device ({serial}) seems to have moved, reseting old slot..'.format(
|
|
serial=server.serial))
|
|
device_bay.installed_device = None
|
|
device_bay.save()
|
|
|
|
# Set slot for blade
|
|
self._netbox_set_blade_slot(chassis, server)
|
|
|
|
def netbox_update(self, config):
|
|
"""
|
|
Netbox method to update info about our server/blade
|
|
|
|
Handle:
|
|
* new chasis for a blade
|
|
* new slot for a bblade
|
|
* hostname update
|
|
* new network infos
|
|
"""
|
|
logging.debug('Updating Server...')
|
|
|
|
server = nb.dcim.devices.get(serial=self.get_service_tag())
|
|
if not server:
|
|
raise Exception("The server (Serial: {}) isn't yet registered in Netbox, register"
|
|
'it before updating it'.format(self.get_service_tag()))
|
|
update = 0
|
|
if self.is_blade():
|
|
datacenter = self.get_netbox_datacenter()
|
|
# if it's already linked to a chassis
|
|
if server.parent_device:
|
|
self._netbox_update_chassis_for_blade(server, datacenter)
|
|
else:
|
|
logging.info('Blade is not in a chassis, fixing...')
|
|
chassis = nb.dcim.devices.get(
|
|
serial=self.get_chassis_service_tag()
|
|
)
|
|
if not chassis:
|
|
chassis = self._netbox_create_blade_chassis(datacenter)
|
|
# Set slot for blade
|
|
self._netbox_set_blade_slot(chassis, server)
|
|
|
|
# for every other specs
|
|
# check hostname
|
|
if server.name != self.get_hostname():
|
|
update += 1
|
|
server.name = self.get_hostname()
|
|
|
|
if config.update_all or config.update_location:
|
|
ret, server = self.update_netbox_location(server)
|
|
update += ret
|
|
|
|
# check network cards
|
|
if config.update_all or config.update_network:
|
|
self.network = Network(server=self)
|
|
self.network.update_netbox_network_cards()
|
|
# update inventory
|
|
if config.update_all or config.update_inventory:
|
|
self.inventory = Inventory(server=self)
|
|
self.inventory.update()
|
|
# update psu
|
|
if config.update_all or config.update_psu:
|
|
self.power = PowerSupply(server=self)
|
|
self.power.create_or_update_power_supply()
|
|
self.power.report_power_consumption()
|
|
if update:
|
|
server.save()
|
|
logging.debug('Finished updating Server!')
|
|
|
|
def print_debug(self):
|
|
self.network = Network(server=self)
|
|
print('Datacenter:', self.get_datacenter())
|
|
print('Netbox Datacenter:', self.get_netbox_datacenter())
|
|
print('Rack:', self.get_rack())
|
|
print('Netbox Rack:', self.get_netbox_rack())
|
|
print('Is blade:', self.is_blade())
|
|
print('Product Name:', self.get_product_name())
|
|
print('Chassis:', self.get_chassis())
|
|
print('Chassis service tag:', self.get_chassis_service_tag())
|
|
print('Service tag:', self.get_service_tag())
|
|
print('NIC:',)
|
|
pprint(self.network.get_network_cards())
|
|
pass
|