Rollcall: bare-metal commissioning server, agent, image build, lab and CI
CI / agent (push) Successful in 3s
CI / site (push) Successful in 2s
CI / go (push) Successful in 1m15s

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>
This commit is contained in:
ilkerandClaude Fable 5.1 committed 2026-10-27 01:29:53 +01:00
commit d9ae89b295
33 files changed
+3248

No files matched your search

+300
View File
@@ -0,0 +1,300 @@
package main
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io"
"net/http"
"os"
"strings"
"time"
)
type client struct {
base, token string
http *http.Client
}
func newClient() (*client, error) {
base, token := os.Getenv("ROLLCALL_URL"), os.Getenv("ROLLCALL_TOKEN")
if base == "" || token == "" {
if cfg, err := loadConfig(envOr("ROLLCALL_CONFIG", "/etc/rollcall/config.json")); err == nil {
if base == "" {
base = "http://" + strings.Replace(cfg.Listen, "0.0.0.0", "127.0.0.1", 1)
}
if token == "" {
token = cfg.AdminToken
}
}
}
if base == "" || token == "" {
return nil, fmt.Errorf("set ROLLCALL_URL and ROLLCALL_TOKEN (or make the config file readable)")
}
return &client{base: strings.TrimRight(base, "/"), token: token, http: &http.Client{Timeout: 90 * time.Second}}, nil
}
func (c *client) do(method, path string, body any, out any) error {
var rd io.Reader
if body != nil {
b, _ := json.Marshal(body)
rd = bytes.NewReader(b)
}
req, err := http.NewRequest(method, c.base+path, rd)
if err != nil {
return err
}
req.Header.Set("Authorization", "Bearer "+c.token)
req.Header.Set("Content-Type", "application/json")
resp, err := c.http.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
data, _ := io.ReadAll(resp.Body)
if resp.StatusCode >= 400 {
var e apiError
_ = json.Unmarshal(data, &e)
if e.Error == "" {
e.Error = string(data)
}
return fmt.Errorf("%s: %s", resp.Status, e.Error)
}
if out != nil {
return json.Unmarshal(data, out)
}
return nil
}
func human(n float64) string {
units := []string{"B", "K", "M", "G", "T", "P"}
i := 0
for n >= 1024 && i < len(units)-1 {
n /= 1024
i++
}
if i <= 2 {
return fmt.Sprintf("%.0f%s", n, units[i])
}
return fmt.Sprintf("%.1f%s", n, units[i])
}
func runClient(cmd string, args []string) error {
c, err := newClient()
if err != nil {
return err
}
need := func(n int) error {
if len(args) < n {
usage()
}
return nil
}
switch cmd {
case "list":
var ms []Summary
if err := c.do("GET", "/api/v1/machines", nil, &ms); err != nil {
return err
}
f := "%-16s %-12s %-28s %-16s %4s %7s %3s %7s %3s %2s %3s %s\n"
fmt.Printf(f, "ID", "STATE", "MODEL", "SERIAL", "CPU", "RAM", "DSK", "STORAGE", "NIC", "IB", "GPU", "BMC")
for _, m := range ms {
bmc := "-"
if m.BMC != nil {
b := *m.BMC
ok := "FAIL"
if v, _ := b["configured"].(bool); v {
ok = "ok"
}
bmc = fmt.Sprintf("%s (%s,%s)", str(b["address"]), str(b["source"]), ok)
}
model := strings.TrimSpace(deref(m.Manufacturer) + " " + deref(m.Product))
fmt.Printf(f, m.ID, m.State, trunc(model, 28), trunc(deref(m.Serial), 16), m.CPUs, human(m.MemoryBytes),
fmt.Sprint(int(m.Disks)), human(m.StorageBytes), fmt.Sprint(m.NICs), fmt.Sprint(m.IBHCAs), fmt.Sprint(m.GPUs), bmc)
}
case "show":
_ = need(1)
fs := flag.NewFlagSet("show", flag.ExitOnError)
asJSON := fs.Bool("json", false, "raw json")
_ = fs.Parse(args[1:])
var d obj
if err := c.do("GET", "/api/v1/machines/"+args[0], nil, &d); err != nil {
return err
}
if *asJSON {
b, _ := json.MarshalIndent(d, "", " ")
fmt.Println(string(b))
return nil
}
printMachine(d)
case "events":
_ = need(1)
var d obj
if err := c.do("GET", "/api/v1/machines/"+args[0], nil, &d); err != nil {
return err
}
for _, e := range toList(d["events"]) {
fmt.Printf("%s %-24s %s\n", str(dig(e, "ts")), str(dig(e, "event")), str(dig(e, "detail")))
}
case "power":
_ = need(2)
var d obj
if err := c.do("POST", "/api/v1/machines/"+args[0]+"/power", obj{"action": args[1]}, &d); err != nil {
return err
}
fmt.Println(str(d["output"]))
if ok, _ := d["ok"].(bool); !ok {
return fmt.Errorf("ipmitool failed")
}
case "bootdev":
_ = need(2)
var d obj
if err := c.do("POST", "/api/v1/machines/"+args[0]+"/bootdev", obj{"device": args[1]}, &d); err != nil {
return err
}
fmt.Println(str(d["output"]))
case "recommission":
_ = need(1)
q := ""
if len(args) > 1 && args[1] == "-now" {
q = "?now=1"
}
var d obj
if err := c.do("POST", "/api/v1/machines/"+args[0]+"/recommission"+q, nil, &d); err != nil {
return err
}
fmt.Printf("%s -> %s\n", str(d["id"]), str(d["state"]))
if d["ipmi"] != nil {
fmt.Println(str(d["ipmi"]))
}
case "delete":
_ = need(1)
var d obj
if err := c.do("DELETE", "/api/v1/machines/"+args[0], nil, &d); err != nil {
return err
}
fmt.Println("deleted", str(d["deleted"]))
}
return nil
}
func trunc(s string, n int) string {
if len(s) > n {
return s[:n]
}
return s
}
func toList(v any) []any {
l, _ := v.([]any)
return l
}
func printMachine(d obj) {
s, _ := d["summary"].(obj)
inv, _ := d["inventory"].(obj)
sys, _ := inv["system"].(obj)
cpu, _ := inv["cpu"].(obj)
mem, _ := inv["memory"].(obj)
st, _ := inv["storage"].(obj)
fmt.Printf("%s state=%s hostname=%s\n", str(s["id"]), str(s["state"]), str(s["hostname"]))
fmt.Printf(" %s %s S/N %s UUID %s\n", str(sys["system-manufacturer"]), str(sys["system-product-name"]),
str(sys["system-serial-number"]), str(sys["system-uuid"]))
fmt.Printf(" BIOS %s %s (%s) board %s\n", str(sys["bios-vendor"]), str(sys["bios-version"]),
str(sys["bios-release-date"]), str(sys["baseboard-product-name"]))
fmt.Printf(" CPU: %s sockets=%s cores/socket=%s threads=%s numa=%s\n", str(cpu["Model name"]), str(cpu["Socket(s)"]),
str(cpu["Core(s) per socket"]), str(cpu["CPU(s)"]), str(cpu["NUMA node(s)"]))
fmt.Printf(" RAM: %s DIMMs %s/%s\n", human(num(mem["total_bytes"])), str(mem["dimms_populated"]), str(mem["dimm_slots"]))
for _, dv := range toList(mem["dimms"]) {
if d, _ := dv.(obj); d["populated"] == true {
speed := str(d["configured_speed"])
if speed == "" {
speed = str(d["speed"])
}
fmt.Printf(" %-14s %-8s %s %s %s %s\n", str(d["locator"]), str(d["size"]), str(d["type"]), speed,
str(d["manufacturer"]), str(d["part_number"]))
}
}
fmt.Printf(" Storage: %s disks, %s\n", str(st["disk_count"]), human(num(st["total_bytes"])))
for _, dv := range toList(st["disks"]) {
d, _ := dv.(obj)
kind := "hdd"
if d["rota"] == false {
kind = "ssd"
}
fmt.Printf(" %-10s %8s %-5s %-4s %s S/N %s\n", str(d["name"]), human(num(d["size"])), str(d["tran"]), kind,
str(d["model"]), str(d["serial"]))
}
for _, cv := range toList(st["controllers"]) {
c, _ := cv.(obj)
fmt.Printf(" ctrl %s %s %s [%s]\n", str(c["slot"]), str(c["vendor"]), str(c["device"]), str(c["driver"]))
}
fmt.Println(" NICs:")
for _, nv := range toList(inv["network"]) {
n, _ := nv.(obj)
var ips []string
for _, ip := range toList(n["ipv4"]) {
ips = append(ips, str(ip))
}
fmt.Printf(" %-10s %s %-10s %-10s link=%v fw=%s pci=%s %s\n", str(n["name"]), str(n["mac"]), str(n["driver"]),
str(n["speed"]), n["link"], str(n["firmware_version"]), str(n["pci"]), strings.Join(ips, ","))
}
if hcas := toList(dig(inv, "infiniband", "hcas")); len(hcas) > 0 {
fmt.Println(" InfiniBand:")
for _, hv := range hcas {
h, _ := hv.(obj)
for _, pv := range toList(h["ports"]) {
p, _ := pv.(obj)
fmt.Printf(" %s port%s %s %s %s guid=%s fw=%s %s\n", str(h["name"]), str(p["port"]), str(p["link_layer"]),
str(p["state"]), str(p["rate"]), str(h["node_guid"]), str(h["fw_ver"]), str(h["board_id"]))
}
}
}
if g := toList(inv["gpus"]); len(g) > 0 {
fmt.Println(" GPUs/accelerators:")
for _, gv := range g {
x, _ := gv.(obj)
fmt.Printf(" %s %s %s [%s]\n", str(x["slot"]), str(x["vendor"]), str(x["device"]), str(x["driver"]))
}
}
if lldp, ok := inv["lldp"].(obj); ok && len(lldp) > 0 {
fmt.Println(" LLDP neighbors:")
for ifn, ents := range lldp {
for _, e := range asList(ents) {
eo, _ := e.(obj)
ch, _ := eo["chassis"].(obj)
name := "?"
for k := range ch {
name = k
}
fmt.Printf(" %s: %s port %s\n", ifn, name, str(dig(eo, "port", "id", "value")))
}
}
}
b, _ := d["bmc"].(obj)
fmt.Printf(" BMC: source=%s address=%s user=%s configured=%v verified_oob=%v secret_stored=%v\n", str(b["source"]),
str(b["address"]), str(b["user"]), b["configured"], b["verified_oob"], d["has_bmc_secret"])
if b["lan"] != nil {
lb, _ := json.Marshal(b["lan"])
fmt.Printf(" lan: %s\n", lb)
}
if errs := toList(b["errors"]); len(errs) > 0 {
fmt.Printf(" errors: %v\n", errs)
}
if errs := toList(inv["errors"]); len(errs) > 0 {
fmt.Printf(" agent errors: %v\n", errs)
}
var evs []string
for _, e := range toList(d["events"]) {
evs = append(evs, str(dig(e, "event")))
}
fmt.Printf(" events: %s\n", strings.Join(evs, "; "))
}
func asList(v any) []any {
if l, ok := v.([]any); ok {
return l
}
return []any{v}
}