e789619b34
This patch brings some of the physical and virtual drive attributes as
`custom_fields` to the disks inventory.
The goal is to have this information present to ease disks maintenance
when a drive becomes unavailable and its attributes can't be read anymore
from the RAID controller.
It also helps to standardize the extended disk attributes across the
different manufacturers.
As the disk physical identifers were not available under the correct
format (hexadecimal format using the `xml` output as opposed as `X:Y:Z` format
using the default `list` format), the command line parser has been
refactored to read the `list` format, rather than `xml` one in the
`omreport` raid controller parser.
As the custom fields have to be created prior being able to register
the disks extended attributes, this feature is only activated using the
`--process-virtual-drives` command line parameter, or by setting
`process_virtual_drives` to `true` in the configuration file.
The custom fields to create as `DCIM > inventory item` `Text` are described
below.
NAME LABEL DESCRIPTION
mount_point Mount point Device mount point(s)
pd_identifier Physical disk identifier Physical disk identifier in the RAID controller
vd_array Virtual drive array Virtual drive array the disk is member of
vd_consistency Virtual drive consistency Virtual disk array consistency
vd_device Virtual drive device Virtual drive system device
vd_raid_type Virtual drive RAID Virtual drive array RAID type
vd_size Virtual drive size Virtual drive array size
In the current implementation, the disks attributes ore not updated: if
a disk with the correct serial number is found, it's sufficient to
consider it as up to date.
To force the reprocessing of the disks extended attributes, the
`--force-disk-refresh` command line option can be used: it removes all
existing disks to before populating them with the correct parsing.
Unless this option is specified, the extended attributes won't be
modified unless a disk is replaced.
It is possible to dump the physical/virtual disks map on the filesystem under
the JSON notation to ease or automate disks management. The file path has to
be provided using the `--dump-disks-map` command line parameter.
506 lines
18 KiB
Python
506 lines
18 KiB
Python
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_role, get_device_type
|
|
from netbox_agent.network import ServerNetwork
|
|
from netbox_agent.power import PowerSupply
|
|
from pprint import pprint
|
|
import subprocess
|
|
import logging
|
|
import socket
|
|
import sys
|
|
|
|
|
|
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.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("Specificing 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,
|
|
device_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,
|
|
device_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,
|
|
device_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,
|
|
device_role=device_role.id,
|
|
device_type=device_type.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
|
|
|
|
if sorted(set([x.name for x in server.tags])) != sorted(set(self.tags)):
|
|
server.tags = [x.id for x in self.nb_tags]
|
|
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 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('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
|