546 lines
19 KiB
Python
546 lines
19 KiB
Python
import logging
|
|
import socket
|
|
import subprocess
|
|
import sys
|
|
from pprint import pprint
|
|
|
|
import netbox_agent.dmidecode as dmidecode
|
|
from netbox_agent.config import config
|
|
from netbox_agent.config import netbox_instance as nb
|
|
from netbox_agent.inventory import Inventory
|
|
from netbox_agent.location import Datacenter, Rack, Tenant
|
|
from netbox_agent.misc import (
|
|
create_netbox_tags,
|
|
get_device_platform,
|
|
get_device_role,
|
|
get_device_type,
|
|
)
|
|
from netbox_agent.network import ServerNetwork
|
|
from netbox_agent.power import PowerSupply
|
|
|
|
|
|
class ServerBase:
|
|
def __init__(self, dmi=None):
|
|
if dmi:
|
|
self.dmi = dmi
|
|
else:
|
|
self.dmi = dmidecode.parse()
|
|
|
|
self.baseboard = dmidecode.get_by_type(self.dmi, "Baseboard")
|
|
self.bios = dmidecode.get_by_type(self.dmi, "BIOS")
|
|
self.chassis = dmidecode.get_by_type(self.dmi, "Chassis")
|
|
self.system = dmidecode.get_by_type(self.dmi, "System")
|
|
self.device_platform = get_device_platform(config.device.platform)
|
|
|
|
self.network = None
|
|
|
|
self.tags = (
|
|
list(set([x.strip() for x in config.device.tags.split(",") if x.strip()]))
|
|
if config.device.tags
|
|
else []
|
|
)
|
|
self.nb_tags = list(create_netbox_tags(self.tags))
|
|
config_cf = set(
|
|
[f.strip() for f in config.device.custom_fields.split(",") if f.strip()]
|
|
)
|
|
self.custom_fields = {}
|
|
self.custom_fields.update(
|
|
dict(
|
|
[
|
|
(k.strip(), v.strip())
|
|
for k, v in [f.split("=", 1) for f in config_cf]
|
|
]
|
|
)
|
|
)
|
|
|
|
def get_tenant(self):
|
|
tenant = Tenant()
|
|
return tenant.get()
|
|
|
|
def get_netbox_tenant(self):
|
|
tenant = self.get_tenant()
|
|
if tenant is None:
|
|
return None
|
|
nb_tenant = nb.tenancy.tenants.get(slug=self.get_tenant())
|
|
return nb_tenant
|
|
|
|
def get_datacenter(self):
|
|
dc = Datacenter()
|
|
return dc.get()
|
|
|
|
def get_netbox_datacenter(self):
|
|
dc = self.get_datacenter()
|
|
if dc is None:
|
|
logging.error("Specifying a datacenter (Site) is mandatory in Netbox")
|
|
sys.exit(1)
|
|
|
|
nb_dc = nb.dcim.sites.get(
|
|
slug=dc,
|
|
)
|
|
if nb_dc is None:
|
|
logging.error("Site (slug: {}) has not been found".format(dc))
|
|
sys.exit(1)
|
|
|
|
return nb_dc
|
|
|
|
def update_netbox_location(self, server):
|
|
dc = self.get_datacenter()
|
|
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 server.rack and nb_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 update_netbox_expansion_location(self, server, expansion):
|
|
update = False
|
|
if expansion.tenant != server.tenant:
|
|
expansion.tenant = server.tenant
|
|
update = True
|
|
if expansion.site != server.site:
|
|
expansion.site = server.site
|
|
update = True
|
|
if expansion.rack != server.rack:
|
|
expansion.rack = server.rack
|
|
update = True
|
|
return update
|
|
|
|
def get_rack(self):
|
|
rack = Rack()
|
|
return rack.get()
|
|
|
|
def get_netbox_rack(self):
|
|
rack = self.get_rack()
|
|
datacenter = self.get_netbox_datacenter()
|
|
if not rack:
|
|
return None
|
|
if rack and not datacenter:
|
|
logging.error("Can't get rack if no datacenter is configured or found")
|
|
sys.exit(1)
|
|
|
|
return nb.dcim.racks.get(
|
|
name=rack,
|
|
site_id=datacenter.id,
|
|
)
|
|
|
|
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_expansion_service_tag(self):
|
|
"""
|
|
Return the virtual Service Tag from dmidecode info host
|
|
with 'expansion'
|
|
"""
|
|
return self.system[0]["Serial Number"].strip() + " expansion"
|
|
|
|
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 get_expansion_product(self):
|
|
raise NotImplementedError
|
|
|
|
def _netbox_create_chassis(self, datacenter, tenant, rack):
|
|
device_type = get_device_type(self.get_chassis())
|
|
device_role = get_device_role(config.device.chassis_role)
|
|
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,
|
|
role=device_role.id,
|
|
site=datacenter.id if datacenter else None,
|
|
tenant=tenant.id if tenant else None,
|
|
rack=rack.id if rack else None,
|
|
tags=[{"name": x} for x in self.tags],
|
|
custom_fields=self.custom_fields,
|
|
)
|
|
return new_chassis
|
|
|
|
def _netbox_create_blade(self, chassis, datacenter, tenant, rack):
|
|
device_role = get_device_role(config.device.blade_role)
|
|
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,
|
|
role=device_role.id,
|
|
device_type=device_type.id,
|
|
parent_device=chassis.id,
|
|
site=datacenter.id if datacenter else None,
|
|
tenant=tenant.id if tenant else None,
|
|
rack=rack.id if rack else None,
|
|
tags=[{"name": x} for x in self.tags],
|
|
custom_fields=self.custom_fields,
|
|
)
|
|
return new_blade
|
|
|
|
def _netbox_create_blade_expansion(self, chassis, datacenter, tenant, rack):
|
|
device_role = get_device_role(config.device.blade_role)
|
|
device_type = get_device_type(self.get_expansion_product())
|
|
serial = self.get_expansion_service_tag()
|
|
hostname = self.get_hostname() + " expansion"
|
|
logging.info(
|
|
"Creating expansion (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,
|
|
role=device_role.id,
|
|
device_type=device_type.id,
|
|
parent_device=chassis.id,
|
|
site=datacenter.id if datacenter else None,
|
|
tenant=tenant.id if tenant else None,
|
|
rack=rack.id if rack else None,
|
|
tags=[{"name": x} for x in self.tags],
|
|
)
|
|
return new_blade
|
|
|
|
def _netbox_deduplicate_server(self):
|
|
serial = self.get_service_tag()
|
|
hostname = self.get_hostname()
|
|
server = nb.dcim.devices.get(name=hostname)
|
|
if server and server.serial != serial:
|
|
server.delete()
|
|
|
|
def _netbox_create_server(self, datacenter, tenant, rack):
|
|
device_role = get_device_role(config.device.server_role)
|
|
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,
|
|
role=device_role.id,
|
|
device_type=device_type.id,
|
|
platform=self.device_platform.id,
|
|
site=datacenter.id if datacenter else None,
|
|
tenant=tenant.id if tenant else None,
|
|
rack=rack.id if rack else None,
|
|
tags=[{"name": x} for x in self.tags],
|
|
)
|
|
return new_server
|
|
|
|
def get_netbox_server(self, expansion=False):
|
|
if expansion is False:
|
|
return nb.dcim.devices.get(serial=self.get_service_tag())
|
|
else:
|
|
return nb.dcim.devices.get(serial=self.get_expansion_service_tag())
|
|
|
|
def _netbox_set_or_update_blade_slot(self, server, chassis, datacenter):
|
|
# before everything check if right chassis
|
|
actual_device_bay = (
|
|
server.parent_device.device_bay if server.parent_device else None
|
|
)
|
|
actual_chassis = actual_device_bay.device if actual_device_bay else None
|
|
slot = self.get_blade_slot()
|
|
if (
|
|
actual_chassis
|
|
and actual_chassis.serial == chassis.serial
|
|
and actual_device_bay.name == slot
|
|
):
|
|
return
|
|
|
|
real_device_bays = nb.dcim.device_bays.filter(
|
|
device_id=chassis.id,
|
|
name=slot,
|
|
)
|
|
real_device_bays = nb.dcim.device_bays.filter(
|
|
device_id=chassis.id,
|
|
name=slot,
|
|
)
|
|
if real_device_bays:
|
|
logging.info(
|
|
"Setting device ({serial}) new slot on {slot} "
|
|
"(Chassis {chassis_serial})..".format(
|
|
serial=server.serial, slot=slot, chassis_serial=chassis.serial
|
|
)
|
|
)
|
|
# reset actual device bay if set
|
|
if actual_device_bay:
|
|
# Forces the evaluation of the installed_device attribute to
|
|
# workaround a bug probably due to lazy loading optimization
|
|
# that prevents the value change detection
|
|
actual_device_bay.installed_device
|
|
actual_device_bay.installed_device = None
|
|
actual_device_bay.save()
|
|
# setup new device bay
|
|
real_device_bay = next(real_device_bays)
|
|
real_device_bay.installed_device = server
|
|
real_device_bay.save()
|
|
else:
|
|
logging.error("Could not find slot {slot} for chassis".format(slot=slot))
|
|
|
|
def _netbox_set_or_update_blade_expansion_slot(
|
|
self, expansion, chassis, datacenter
|
|
):
|
|
# before everything check if right chassis
|
|
actual_device_bay = (
|
|
expansion.parent_device.device_bay if expansion.parent_device else None
|
|
)
|
|
actual_chassis = actual_device_bay.device if actual_device_bay else None
|
|
slot = self.get_blade_expansion_slot()
|
|
if (
|
|
actual_chassis
|
|
and actual_chassis.serial == chassis.serial
|
|
and actual_device_bay.name == slot
|
|
):
|
|
return
|
|
|
|
real_device_bays = nb.dcim.device_bays.filter(
|
|
device_id=chassis.id,
|
|
name=slot,
|
|
)
|
|
if not real_device_bays:
|
|
logging.error(
|
|
"Could not find slot {slot} expansion for chassis".format(slot=slot)
|
|
)
|
|
return
|
|
logging.info(
|
|
"Setting device expansion ({serial}) new slot on {slot} "
|
|
"(Chassis {chassis_serial})..".format(
|
|
serial=expansion.serial, slot=slot, chassis_serial=chassis.serial
|
|
)
|
|
)
|
|
# reset actual device bay if set
|
|
if actual_device_bay:
|
|
# Forces the evaluation of the installed_device attribute to
|
|
# workaround a bug probably due to lazy loading optimization
|
|
# that prevents the value change detection
|
|
actual_device_bay.installed_device
|
|
actual_device_bay.installed_device = None
|
|
actual_device_bay.save()
|
|
# setup new device bay
|
|
real_device_bay = next(real_device_bays)
|
|
real_device_bay.installed_device = expansion
|
|
real_device_bay.save()
|
|
|
|
def netbox_create_or_update(self, config):
|
|
"""
|
|
Netbox method to create or update info about our server/blade
|
|
|
|
Handle:
|
|
* new chassis for a blade
|
|
* new slot for a blade
|
|
* hostname update
|
|
* Network infos
|
|
* Inventory management
|
|
* PSU management
|
|
"""
|
|
datacenter = self.get_netbox_datacenter()
|
|
rack = self.get_netbox_rack()
|
|
tenant = self.get_netbox_tenant()
|
|
|
|
if config.purge_old_devices:
|
|
self._netbox_deduplicate_server()
|
|
|
|
if self.is_blade():
|
|
chassis = nb.dcim.devices.get(serial=self.get_chassis_service_tag())
|
|
# Chassis does not exist
|
|
if not chassis:
|
|
chassis = self._netbox_create_chassis(datacenter, tenant, rack)
|
|
|
|
server = nb.dcim.devices.get(serial=self.get_service_tag())
|
|
if not server:
|
|
server = self._netbox_create_blade(chassis, datacenter, tenant, rack)
|
|
|
|
# Set slot for blade
|
|
self._netbox_set_or_update_blade_slot(server, chassis, datacenter)
|
|
else:
|
|
server = nb.dcim.devices.get(serial=self.get_service_tag())
|
|
if not server:
|
|
server = self._netbox_create_server(datacenter, tenant, rack)
|
|
|
|
logging.debug("Updating Server...")
|
|
# check network cards
|
|
if config.register or config.update_all or config.update_network:
|
|
self.network = ServerNetwork(server=self)
|
|
self.network.create_or_update_netbox_network_cards()
|
|
update_inventory = config.inventory and (
|
|
config.register or config.update_all or config.update_inventory
|
|
)
|
|
# update inventory if feature is enabled
|
|
self.inventory = Inventory(server=self)
|
|
if update_inventory:
|
|
self.inventory.create_or_update()
|
|
# update psu
|
|
if config.register or config.update_all or config.update_psu:
|
|
self.power = PowerSupply(server=self)
|
|
self.power.create_or_update_power_supply()
|
|
self.power.report_power_consumption()
|
|
|
|
expansion = nb.dcim.devices.get(serial=self.get_expansion_service_tag())
|
|
if self.own_expansion_slot() and config.expansion_as_device:
|
|
logging.debug("Update Server expansion...")
|
|
if not expansion:
|
|
expansion = self._netbox_create_blade_expansion(
|
|
chassis, datacenter, tenant, rack
|
|
)
|
|
|
|
# set slot for blade expansion
|
|
self._netbox_set_or_update_blade_expansion_slot(
|
|
expansion, chassis, datacenter
|
|
)
|
|
if update_inventory:
|
|
# Updates expansion inventory
|
|
inventory = Inventory(server=self, update_expansion=True)
|
|
inventory.create_or_update()
|
|
elif self.own_expansion_slot() and expansion:
|
|
expansion.delete()
|
|
expansion = None
|
|
|
|
update = 0
|
|
# for every other specs
|
|
# check hostname
|
|
if server.name != self.get_hostname():
|
|
server.name = self.get_hostname()
|
|
update += 1
|
|
|
|
server_tags = sorted(set([x.name for x in server.tags]))
|
|
tags = sorted(set(self.tags))
|
|
if server_tags != tags:
|
|
new_tags_ids = [x.id for x in self.nb_tags]
|
|
if not config.preserve_tags:
|
|
server.tags = new_tags_ids
|
|
else:
|
|
server_tags_ids = [x.id for x in server.tags]
|
|
server.tags = sorted(set(new_tags_ids + server_tags_ids))
|
|
update += 1
|
|
|
|
if server.custom_fields != self.custom_fields:
|
|
server.custom_fields = self.custom_fields
|
|
update += 1
|
|
|
|
if config.update_all or config.update_location:
|
|
ret, server = self.update_netbox_location(server)
|
|
update += ret
|
|
|
|
if server.platform != self.device_platform:
|
|
server.platform = self.device_platform
|
|
update += 1
|
|
|
|
if update:
|
|
server.save()
|
|
|
|
if expansion:
|
|
update = 0
|
|
expansion_name = server.name + " expansion"
|
|
if expansion.name != expansion_name:
|
|
expansion.name = expansion_name
|
|
update += 1
|
|
if self.update_netbox_expansion_location(server, expansion):
|
|
update += 1
|
|
if update:
|
|
expansion.save()
|
|
logging.debug("Finished updating Server!")
|
|
|
|
def print_debug(self):
|
|
self.network = ServerNetwork(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("Got expansion:", self.own_expansion_slot())
|
|
print("Product Name:", self.get_product_name())
|
|
print("Platform:", self.device_platform)
|
|
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
|
|
|
|
def own_expansion_slot(self):
|
|
"""
|
|
Indicates if the device hosts an expansion card
|
|
"""
|
|
return False
|
|
|
|
def own_gpu_expansion_slot(self):
|
|
"""
|
|
Indicates if the device hosts a GPU expansion card
|
|
"""
|
|
return False
|
|
|
|
def own_drive_expansion_slot(self):
|
|
"""
|
|
Indicates if the device hosts a drive expansion bay
|
|
"""
|
|
return False
|