Go server (API, embedded web UI, CLI) backed by PostgreSQL with AES-GCM sealed BMC secrets; Debian live commissioning agent and live-build recipe; Proxmox lab with pve-vbmc virtual BMCs; Gitea workflows for CI, releases and deployment; project website. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
161 lines
5.5 KiB
Python
161 lines
5.5 KiB
Python
#!/usr/bin/env python3
|
|
"""pve-vbmc: minimal virtual BMC (IPMI-over-LAN) for Proxmox VE VMs.
|
|
|
|
One process serves one VM. It speaks IPMI 2.0 LAN via pyghmi and translates
|
|
chassis power / boot-device commands into Proxmox API calls.
|
|
|
|
Supported ipmitool commands:
|
|
power status|on|off|soft|cycle|reset
|
|
chassis bootdev pxe|disk|cdrom|none
|
|
chassis status, mc info, mc guid
|
|
"""
|
|
import argparse
|
|
import ipaddress
|
|
import json
|
|
import logging
|
|
import sys
|
|
import time
|
|
import uuid
|
|
|
|
import requests
|
|
import urllib3
|
|
from pyghmi.ipmi.bmc import Bmc
|
|
|
|
log = logging.getLogger("pve-vbmc")
|
|
|
|
|
|
class PveBmc(Bmc):
|
|
def __init__(self, cfg, entry):
|
|
self.api = cfg["api"].rstrip("/")
|
|
self.node = cfg["node"]
|
|
self.vmid = int(entry["vmid"])
|
|
self.http = requests.Session()
|
|
self.http.headers["Authorization"] = "PVEAPIToken=" + cfg["token"]
|
|
self.http.verify = cfg.get("verify_tls", False)
|
|
if not self.http.verify:
|
|
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
|
self.bootdev = "default"
|
|
self.guid = uuid.uuid5(uuid.NAMESPACE_DNS, f"pve-vbmc-{self.node}-{self.vmid}")
|
|
|
|
addr = ipaddress.ip_address(entry["address"])
|
|
listen = f"::ffff:{addr}" if addr.version == 4 else str(addr)
|
|
authdata = {entry.get("user", cfg.get("user", "admin")):
|
|
entry.get("password", cfg.get("password", "password"))}
|
|
super().__init__(authdata, port=int(entry.get("port", 623)), address=listen)
|
|
log.info("BMC for VM %s listening on %s:%s", self.vmid, addr, entry.get("port", 623))
|
|
|
|
# --- Proxmox API helpers -------------------------------------------------
|
|
def _url(self, path):
|
|
return f"{self.api}/api2/json/nodes/{self.node}/qemu/{self.vmid}/{path}"
|
|
|
|
def _get(self, path):
|
|
r = self.http.get(self._url(path), timeout=10)
|
|
r.raise_for_status()
|
|
return r.json()["data"]
|
|
|
|
def _post(self, path, **data):
|
|
r = self.http.post(self._url(path), data=data, timeout=30)
|
|
r.raise_for_status()
|
|
return r.json()["data"]
|
|
|
|
def _put(self, path, **data):
|
|
r = self.http.put(self._url(path), data=data, timeout=30)
|
|
r.raise_for_status()
|
|
return r.json()["data"]
|
|
|
|
def _wait_task(self, upid, timeout=60):
|
|
url = f"{self.api}/api2/json/nodes/{self.node}/tasks/{upid}/status"
|
|
for _ in range(timeout * 2):
|
|
r = self.http.get(url, timeout=10)
|
|
r.raise_for_status()
|
|
if r.json()["data"]["status"] == "stopped":
|
|
return r.json()["data"].get("exitstatus")
|
|
time.sleep(0.5)
|
|
return "timeout"
|
|
|
|
# --- pyghmi Bmc interface -------------------------------------------------
|
|
def get_system_guid(self):
|
|
return self.guid
|
|
|
|
def get_power_state(self):
|
|
return "on" if self._get("status/current")["status"] == "running" else "off"
|
|
|
|
def is_active(self):
|
|
return self.get_power_state() == "on"
|
|
|
|
def power_on(self):
|
|
if self.get_power_state() == "off":
|
|
log.info("VM %s: power on", self.vmid)
|
|
self._post("status/start")
|
|
|
|
def power_off(self):
|
|
if self.get_power_state() == "on":
|
|
log.info("VM %s: power off (hard)", self.vmid)
|
|
self._post("status/stop")
|
|
|
|
def power_shutdown(self):
|
|
log.info("VM %s: soft shutdown", self.vmid)
|
|
self._post("status/shutdown", forceStop=1, timeout=60)
|
|
|
|
def power_reset(self):
|
|
if self.get_power_state() == "on":
|
|
log.info("VM %s: reset", self.vmid)
|
|
self._post("status/reset")
|
|
else:
|
|
self.power_on()
|
|
|
|
def power_cycle(self):
|
|
log.info("VM %s: power cycle", self.vmid)
|
|
if self.get_power_state() == "on":
|
|
self._wait_task(self._post("status/stop"))
|
|
self._post("status/start")
|
|
|
|
def cold_reset(self):
|
|
return 0 # BMC reset is a no-op
|
|
|
|
def pulse_diag(self):
|
|
raise NotImplementedError
|
|
|
|
def get_boot_device(self):
|
|
return self.bootdev
|
|
|
|
def set_boot_device(self, bootdevice):
|
|
cfg = self._get("config")
|
|
disks = [k for k in ("scsi0", "virtio0", "sata0", "ide0") if k in cfg]
|
|
cds = sorted(k for k, v in cfg.items() if "media=cdrom" in str(v))
|
|
nets = sorted(k for k in cfg if k.startswith("net") and k[3:].isdigit())
|
|
if bootdevice == "network":
|
|
order = nets + disks + cds
|
|
elif bootdevice == "hd":
|
|
order = disks + nets + cds
|
|
elif bootdevice == "optical":
|
|
order = cds + disks + nets
|
|
else: # default / none / safe / setup ...
|
|
order = disks + cds + nets
|
|
if order:
|
|
log.info("VM %s: bootdev %s -> order=%s", self.vmid, bootdevice, ";".join(order))
|
|
self._put("config", boot="order=" + ";".join(order))
|
|
self.bootdev = bootdevice
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument("--config", default="/etc/pve-vbmc/config.json")
|
|
ap.add_argument("--vmid", type=int, required=True)
|
|
ap.add_argument("--debug", action="store_true")
|
|
args = ap.parse_args()
|
|
logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO,
|
|
format="%(asctime)s %(name)s %(levelname)s %(message)s")
|
|
with open(args.config) as f:
|
|
cfg = json.load(f)
|
|
entry = next((b for b in cfg["bmcs"] if int(b["vmid"]) == args.vmid), None)
|
|
if entry is None:
|
|
log.error("vmid %s not in config", args.vmid)
|
|
sys.exit(2)
|
|
bmc = PveBmc(cfg, entry)
|
|
bmc.listen()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|