Files
rollcall/lab/pve-vbmc/pve_vbmc.py
T
ilkerandClaude Fable 5.1 d9ae89b295
CI / agent (push) Successful in 3s
CI / site (push) Successful in 2s
CI / go (push) Successful in 1m15s
Rollcall: bare-metal commissioning server, agent, image build, lab and CI
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>
2026-10-27 01:29:53 +01:00

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()