christianmanivong
332e6090a7
A Supermicro X10DRL-i refuses Redfish without a license (SUM, DCMS or
OOB), even the service root. IPMI answers without one.
- New entry point `ipmi` (napalm_redfish.ipmi.IpmiDriver) on
ManagementControllerDriver, over pyghmi: facts and inventory from the
FRU (serial number, system UUID), the BMC's LAN interface, sensors
(temperatures, fans, power supplies), the power state, the event log
and the BMC firmware. Read-only: no power control, no BMC reset.
Tested against recordings of the X10 with serials, the UUID, MACs and
IPs replaced.
- RedfishDriver.open() no longer fails on a license refusal: get_facts
returns what is known without Redfish, get_device_warnings reports
bmc_license_required with the licenses the BMC names, every other
getter raises. netOrk then shows the reason instead of an offline BMC.
- IpmiDriver is not exported from the package: NAPALM's own
get_network_driver("redfish") takes the first driver class of
napalm_redfish.
222 lines
8.3 KiB
Python
222 lines
8.3 KiB
Python
"""Read-only NAPALM driver for BMCs over IPMI 2.0, for boards that refuse or lack Redfish.
|
|
|
|
IPMI over LAN gives a password hash to anyone who names a valid user (CVE-2013-4786), so
|
|
this is the fallback, not the main path. It only reads: facts and inventory from the FRU,
|
|
sensors, the power state and the system event log. It neither switches the server's power
|
|
nor resets the BMC; those go through Redfish.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from napalm.base.exceptions import ConnectionException
|
|
from napalm_device_types import ManagementControllerDriver
|
|
from pyghmi.ipmi.command import Command
|
|
|
|
_JsonDict = dict[str, Any]
|
|
|
|
#: pyghmi's health bits (pyghmi.constants.Health).
|
|
_WARNING, _CRITICAL, _FAILED = 1, 2, 4
|
|
#: The only interface a BMC reports over IPMI: its own LAN channel.
|
|
_BMC = "bmc"
|
|
|
|
|
|
def _severity(health: int) -> str:
|
|
if health & (_CRITICAL | _FAILED):
|
|
return "Critical"
|
|
if health & _WARNING:
|
|
return "Warning"
|
|
return "OK"
|
|
|
|
|
|
def _supply_present(reading: Any) -> bool:
|
|
return "Present" in (getattr(reading, "states", None) or [])
|
|
|
|
|
|
class IpmiDriver(ManagementControllerDriver):
|
|
"""NAPALM driver for BMCs over IPMI 2.0 (lanplus), read-only."""
|
|
|
|
platform = "ipmi"
|
|
DRIVER_NAME = "ipmi"
|
|
#: IPMI is UDP; discovery probes no UDP, so this driver has no fingerprint.
|
|
default_port = 623
|
|
|
|
def __init__(
|
|
self,
|
|
hostname: str,
|
|
username: str,
|
|
password: str,
|
|
timeout: int = 60,
|
|
optional_args: _JsonDict | None = None,
|
|
) -> None:
|
|
self.hostname = hostname
|
|
self.username = username
|
|
self.password = password
|
|
self.timeout = timeout
|
|
self.optional_args: _JsonDict = optional_args or {}
|
|
self.port = int(self.optional_args.get("port") or self.default_port)
|
|
self._ipmi: Any = None
|
|
|
|
# --- connection ----------------------------------------------------------------------
|
|
|
|
def open(self) -> None:
|
|
try:
|
|
self._ipmi = Command(
|
|
bmc=self.hostname,
|
|
userid=self.username,
|
|
password=self.password,
|
|
port=self.port,
|
|
keepalive=False,
|
|
)
|
|
except Exception as exc:
|
|
raise ConnectionException(f"Cannot connect to IPMI at {self.hostname}: {exc}") \
|
|
from exc
|
|
|
|
def close(self) -> None:
|
|
ipmi, self._ipmi = self._ipmi, None
|
|
if ipmi is not None:
|
|
try:
|
|
ipmi.ipmi_session.logout()
|
|
except Exception: # a session left open times out on the BMC
|
|
pass
|
|
|
|
def is_alive(self) -> _JsonDict:
|
|
return {"is_alive": self._ipmi is not None}
|
|
|
|
def _cmd(self) -> Any:
|
|
if self._ipmi is None:
|
|
raise ConnectionException(f"{self.hostname}: not connected, call open() first")
|
|
return self._ipmi
|
|
|
|
# --- reads ---------------------------------------------------------------------------
|
|
|
|
def _system(self) -> _JsonDict:
|
|
"""The "System" FRU record: manufacturer, product, serial number, UUID."""
|
|
for name, record in self._cmd().get_inventory():
|
|
if name == "System":
|
|
return record or {}
|
|
return {}
|
|
|
|
def _bmc_version(self) -> str:
|
|
for name, info in self._cmd().get_firmware():
|
|
if name == "BMC Version":
|
|
return str(info.get("version") or "")
|
|
return ""
|
|
|
|
def _sensors(self) -> list[Any]:
|
|
return list(self._cmd().get_sensor_data())
|
|
|
|
# --- NAPALM getters ------------------------------------------------------------------
|
|
|
|
def get_facts(self) -> _JsonDict:
|
|
system = self._system()
|
|
return {
|
|
"uptime": -1.0, # IPMI has no uptime
|
|
"vendor": system.get("Manufacturer") or "",
|
|
"model": system.get("Product name") or system.get("Model") or "",
|
|
"hostname": self.hostname,
|
|
"fqdn": self.hostname,
|
|
"os_version": self._bmc_version(),
|
|
"serial_number": system.get("Serial Number") or "",
|
|
"interface_list": [_BMC],
|
|
}
|
|
|
|
def get_interfaces(self) -> _JsonDict:
|
|
net = self._cmd().get_net_configuration()
|
|
source = net.get("ipv4_configuration") or ""
|
|
return {
|
|
_BMC: {
|
|
"is_up": True,
|
|
"is_enabled": True,
|
|
"description": f"BMC LAN ({source})" if source else "BMC LAN",
|
|
"last_flapped": -1.0,
|
|
"speed": -1.0,
|
|
"mtu": -1,
|
|
"mac_address": (net.get("mac_address") or "").lower(),
|
|
}
|
|
}
|
|
|
|
def get_interfaces_ip(self) -> _JsonDict:
|
|
address = self._cmd().get_net_configuration().get("ipv4_address") or ""
|
|
if "/" not in address:
|
|
return {}
|
|
ip, prefix = address.split("/", 1)
|
|
return {_BMC: {"ipv4": {ip: {"prefix_length": int(prefix)}}}}
|
|
|
|
def get_environment(self) -> _JsonDict:
|
|
"""Fans, temperatures and present power supplies from the sensor records; ``cpu`` and
|
|
``memory`` are empty, since a BMC does not know the host OS's load."""
|
|
fans: _JsonDict = {}
|
|
temperature: _JsonDict = {}
|
|
power: _JsonDict = {}
|
|
for reading in self._sensors():
|
|
health = int(getattr(reading, "health", 0) or 0)
|
|
value = getattr(reading, "value", None)
|
|
if reading.type == "Temperature" and value is not None:
|
|
temperature[reading.name] = {
|
|
"temperature": float(value),
|
|
"is_alert": bool(health),
|
|
"is_critical": bool(health & (_CRITICAL | _FAILED)),
|
|
}
|
|
elif reading.type == "Fan" and value is not None:
|
|
fans[reading.name] = {"status": value > 0 and not health}
|
|
elif reading.type == "Power Supply" and _supply_present(reading):
|
|
power[reading.name] = {"status": not health, "capacity": -1.0, "output": -1.0}
|
|
return {"fans": fans, "temperature": temperature, "power": power, "cpu": {}, "memory": {}}
|
|
|
|
# --- role methods --------------------------------------------------------------------
|
|
|
|
def get_power_state(self) -> _JsonDict:
|
|
state = str(self._cmd().get_power().get("powerstate") or "")
|
|
# Read-only: no action is offered.
|
|
return {"state": state.capitalize(), "actions": []}
|
|
|
|
def get_hardware_inventory(self) -> _JsonDict:
|
|
"""What the FRU and the sensor records tell; IPMI lists no CPUs, DIMMs or drives."""
|
|
system = self._system()
|
|
supplies = [
|
|
{
|
|
"slot": reading.name.removesuffix(" Status"),
|
|
"model": "",
|
|
"serial_number": "",
|
|
"capacity_watts": None,
|
|
"status": _severity(int(reading.health or 0))
|
|
if _supply_present(reading) else "Absent",
|
|
}
|
|
for reading in self._sensors()
|
|
if reading.type == "Power Supply"
|
|
]
|
|
return {
|
|
"manufacturer": system.get("Manufacturer") or "",
|
|
"model": system.get("Product name") or system.get("Model") or "",
|
|
"serial_number": system.get("Serial Number") or "",
|
|
"system_uuid": str(system.get("UUID") or "").lower(),
|
|
"cpus": [],
|
|
"memory": [],
|
|
"drives": [],
|
|
"power_supplies": supplies,
|
|
"nics": [],
|
|
}
|
|
|
|
def get_event_log(self, limit: int = 500) -> list[_JsonDict]:
|
|
"""The system event log, newest first."""
|
|
entries = []
|
|
for event in self._cmd().get_event_log():
|
|
component = event.get("component") or ""
|
|
text = event.get("event") or ""
|
|
timecode = event.get("timecode")
|
|
entries.append({
|
|
"id": str(event.get("record_id", "")),
|
|
"timestamp": float(timecode) if timecode else None,
|
|
"severity": _severity(int(event.get("severity") or 0)),
|
|
"message": f"{component}: {text}" if component and text else component or text,
|
|
})
|
|
entries.sort(key=lambda e: (e["timestamp"] is not None, e["timestamp"] or 0.0),
|
|
reverse=True)
|
|
return entries[:limit]
|
|
|
|
def get_firmware_inventory(self) -> list[_JsonDict]:
|
|
version = self._bmc_version()
|
|
return [{"name": "BMC", "version": version, "updateable": None}] if version else []
|