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>
This commit is contained in:
commit
d9ae89b295
33 files changed
+3248
No files matched your search
@@ -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}
|
||||
}
|
||||
Reference in new issue
Block a user