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}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
// Config is /etc/rollcall/config.json.
|
||||
type Config struct {
|
||||
Listen string `json:"listen"` // "10.213.77.1:80"
|
||||
ImageDir string `json:"image_dir"` // live image files (vmlinuz, initrd.img, filesystem.squashfs), served under /rollcall/
|
||||
TFTPRoot string `json:"tftp_root"` // pxelinux.cfg/01-<mac> files are written here
|
||||
DatabaseURL string `json:"database_url"` // postgres://user:pw@host/db
|
||||
MasterKeyFile string `json:"master_key_file"` // 32-byte hex key for AES-GCM at-rest encryption
|
||||
AdminToken string `json:"admin_token"` // bearer token for the management API / web UI
|
||||
AgentToken string `json:"agent_token"` // X-Rollcall-Token for the agent endpoints ("" = open)
|
||||
CommissionAppend string `json:"commission_append"` // kernel cmdline used in generated pxelinux files
|
||||
IPMITool string `json:"ipmitool"` // path, default "ipmitool"
|
||||
BMCHints []BMCHint `json:"bmc_hints"` // out-of-band BMC mapping for machines without in-band IPMI
|
||||
}
|
||||
|
||||
// BMCHint maps a machine MAC to a known BMC (virtual lab nodes).
|
||||
type BMCHint struct {
|
||||
MAC string `json:"mac"`
|
||||
Address string `json:"address"`
|
||||
Port int `json:"port"`
|
||||
User string `json:"user"`
|
||||
Password string `json:"password"`
|
||||
Comment string `json:"comment,omitempty"`
|
||||
}
|
||||
|
||||
func loadConfig(path string) (*Config, error) {
|
||||
b, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c := &Config{Listen: "0.0.0.0:80", IPMITool: "ipmitool", MasterKeyFile: "/etc/rollcall/master.key"}
|
||||
if err := json.Unmarshal(b, c); err != nil {
|
||||
return nil, fmt.Errorf("%s: %w", path, err)
|
||||
}
|
||||
for _, k := range []struct{ v, n string }{{c.ImageDir, "image_dir"}, {c.TFTPRoot, "tftp_root"}, {c.DatabaseURL, "database_url"}, {c.AdminToken, "admin_token"}} {
|
||||
if k.v == "" {
|
||||
return nil, fmt.Errorf("%s: %s is required", path, k.n)
|
||||
}
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Sealer encrypts BMC secrets at rest with AES-256-GCM.
|
||||
type Sealer struct{ aead cipher.AEAD }
|
||||
|
||||
// loadOrCreateKey reads a 32-byte hex key from path, creating it (0600) when absent.
|
||||
func loadOrCreateKey(path string) (*Sealer, error) {
|
||||
b, err := os.ReadFile(path)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
raw := make([]byte, 32)
|
||||
if _, err := rand.Read(raw); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := os.WriteFile(path, []byte(hex.EncodeToString(raw)+"\n"), 0o600); err != nil {
|
||||
return nil, fmt.Errorf("create master key: %w", err)
|
||||
}
|
||||
b = []byte(hex.EncodeToString(raw))
|
||||
} else if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
key, err := hex.DecodeString(strings.TrimSpace(string(b)))
|
||||
if err != nil || len(key) != 32 {
|
||||
return nil, fmt.Errorf("%s: expected 32-byte hex key", path)
|
||||
}
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
aead, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &Sealer{aead: aead}, nil
|
||||
}
|
||||
|
||||
// Seal returns nonce||ciphertext; aad binds the secret to a machine id.
|
||||
func (s *Sealer) Seal(plaintext, aad string) ([]byte, error) {
|
||||
nonce := make([]byte, s.aead.NonceSize())
|
||||
if _, err := rand.Read(nonce); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return append(nonce, s.aead.Seal(nil, nonce, []byte(plaintext), []byte(aad))...), nil
|
||||
}
|
||||
|
||||
func (s *Sealer) Open(blob []byte, aad string) (string, error) {
|
||||
n := s.aead.NonceSize()
|
||||
if len(blob) < n {
|
||||
return "", errors.New("ciphertext too short")
|
||||
}
|
||||
pt, err := s.aead.Open(nil, blob[:n], blob[n:], []byte(aad))
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(pt), nil
|
||||
}
|
||||
|
||||
func randomToken(nbytes int) string {
|
||||
b := make([]byte, nbytes)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return hex.EncodeToString(b)
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
module rollcall
|
||||
|
||||
go 1.24
|
||||
|
||||
require github.com/jackc/pgx/v5 v5.7.5
|
||||
|
||||
require (
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.2 // indirect
|
||||
golang.org/x/crypto v0.37.0 // indirect
|
||||
golang.org/x/sync v0.13.0 // indirect
|
||||
golang.org/x/text v0.24.0 // indirect
|
||||
)
|
||||
@@ -0,0 +1,28 @@
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.7.5 h1:JHGfMnQY+IEtGM63d+NGMjoRpysB2JBwDr5fsngwmJs=
|
||||
github.com/jackc/pgx/v5 v5.7.5/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
|
||||
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
|
||||
golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
|
||||
golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
|
||||
golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
|
||||
golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
|
||||
golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
|
||||
golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
@@ -0,0 +1,69 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// bmcCreds is what the server needs to talk to a machine's BMC.
|
||||
type bmcCreds struct {
|
||||
Address string
|
||||
Port int
|
||||
User string
|
||||
Password string
|
||||
}
|
||||
|
||||
var powerActions = map[string][]string{
|
||||
"status": {"chassis", "power", "status"},
|
||||
"on": {"chassis", "power", "on"},
|
||||
"off": {"chassis", "power", "off"},
|
||||
"soft": {"chassis", "power", "soft"},
|
||||
"cycle": {"chassis", "power", "cycle"},
|
||||
"reset": {"chassis", "power", "reset"},
|
||||
}
|
||||
|
||||
var bootDevices = map[string]bool{"pxe": true, "disk": true, "cdrom": true, "bios": true, "none": true, "safe": true}
|
||||
|
||||
func (a *App) credsFor(m *Machine) (*bmcCreds, error) {
|
||||
if m.BMC == nil || m.bmcSecret == nil {
|
||||
return nil, fmt.Errorf("no BMC credentials stored")
|
||||
}
|
||||
var b struct {
|
||||
Address string `json:"address"`
|
||||
Port int `json:"port"`
|
||||
User string `json:"user"`
|
||||
}
|
||||
if err := json.Unmarshal(m.BMC, &b); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if b.Address == "" || b.User == "" {
|
||||
return nil, fmt.Errorf("BMC record has no address/user")
|
||||
}
|
||||
pw, err := a.sealer.Open(m.bmcSecret, m.ID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("decrypt BMC secret: %w", err)
|
||||
}
|
||||
if b.Port == 0 {
|
||||
b.Port = 623
|
||||
}
|
||||
return &bmcCreds{Address: b.Address, Port: b.Port, User: b.User, Password: pw}, nil
|
||||
}
|
||||
|
||||
// ipmi runs ipmitool server-side; the password never leaves this process.
|
||||
func (a *App) ipmi(ctx context.Context, c *bmcCreds, args ...string) (string, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
||||
defer cancel()
|
||||
full := append([]string{"-I", "lanplus", "-H", c.Address, "-p", strconv.Itoa(c.Port), "-U", c.User, "-E"}, args...)
|
||||
cmd := exec.CommandContext(ctx, a.cfg.IPMITool, full...)
|
||||
cmd.Env = []string{"IPMI_PASSWORD=" + c.Password, "PATH=/usr/sbin:/usr/bin:/sbin:/bin"}
|
||||
var out bytes.Buffer
|
||||
cmd.Stdout, cmd.Stderr = &out, &out
|
||||
err := cmd.Run()
|
||||
return strings.TrimSpace(out.String()), err
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
// rollcall: MAAS-like commissioning server, web UI and CLI in one binary.
|
||||
//
|
||||
// rollcall serve [-config /etc/rollcall/config.json]
|
||||
// rollcall keygen print a random token (admin_token / agent_token)
|
||||
// rollcall list | show ID [-json] | events ID
|
||||
// rollcall power ID status|on|off|soft|cycle|reset
|
||||
// rollcall bootdev ID pxe|disk|cdrom|bios|none
|
||||
// rollcall recommission ID [-now] (-now: bootdev pxe + power cycle via BMC)
|
||||
// rollcall delete ID
|
||||
//
|
||||
// Client commands read ROLLCALL_URL / ROLLCALL_TOKEN, falling back to the
|
||||
// config file when it is readable (so root on the server needs no setup).
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
)
|
||||
|
||||
func usage() {
|
||||
fmt.Fprintln(os.Stderr, `usage:
|
||||
rollcall serve [-config PATH]
|
||||
rollcall keygen
|
||||
rollcall list
|
||||
rollcall show ID [-json]
|
||||
rollcall events ID
|
||||
rollcall power ID status|on|off|soft|cycle|reset
|
||||
rollcall bootdev ID pxe|disk|cdrom|bios|none
|
||||
rollcall recommission ID [-now]
|
||||
rollcall delete ID
|
||||
env: ROLLCALL_URL (default from config listen), ROLLCALL_TOKEN, ROLLCALL_CONFIG`)
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
func main() {
|
||||
log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
|
||||
if len(os.Args) < 2 {
|
||||
usage()
|
||||
}
|
||||
cmd, args := os.Args[1], os.Args[2:]
|
||||
switch cmd {
|
||||
case "serve":
|
||||
fs := flag.NewFlagSet("serve", flag.ExitOnError)
|
||||
cfg := fs.String("config", envOr("ROLLCALL_CONFIG", "/etc/rollcall/config.json"), "config file")
|
||||
_ = fs.Parse(args)
|
||||
if err := serve(*cfg); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
case "keygen":
|
||||
fmt.Println(randomToken(24))
|
||||
case "list", "show", "events", "power", "bootdev", "recommission", "delete":
|
||||
if err := runClient(cmd, args); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "error:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
default:
|
||||
usage()
|
||||
}
|
||||
}
|
||||
|
||||
func envOr(k, d string) string {
|
||||
if v := os.Getenv(k); v != "" {
|
||||
return v
|
||||
}
|
||||
return d
|
||||
}
|
||||
@@ -0,0 +1,533 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/subtle"
|
||||
"embed"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/fs"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
//go:embed web
|
||||
var webFS embed.FS
|
||||
|
||||
type App struct {
|
||||
cfg *Config
|
||||
store *Store
|
||||
sealer *Sealer
|
||||
}
|
||||
|
||||
type apiError struct {
|
||||
Error string `json:"error"`
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, code int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(code)
|
||||
enc := json.NewEncoder(w)
|
||||
enc.SetIndent("", " ")
|
||||
_ = enc.Encode(v)
|
||||
}
|
||||
|
||||
func fail(w http.ResponseWriter, code int, err error) {
|
||||
if errors.Is(err, errNotFound) {
|
||||
code = http.StatusNotFound
|
||||
}
|
||||
writeJSON(w, code, apiError{err.Error()})
|
||||
}
|
||||
|
||||
func tokenEqual(a, b string) bool {
|
||||
return b != "" && subtle.ConstantTimeCompare([]byte(a), []byte(b)) == 1
|
||||
}
|
||||
|
||||
func (a *App) isAdmin(r *http.Request) bool {
|
||||
h := r.Header.Get("Authorization")
|
||||
return strings.HasPrefix(h, "Bearer ") && tokenEqual(strings.TrimPrefix(h, "Bearer "), a.cfg.AdminToken)
|
||||
}
|
||||
|
||||
func (a *App) adminAuth(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
if !a.isAdmin(r) {
|
||||
w.Header().Set("WWW-Authenticate", `Bearer realm="rollcall"`)
|
||||
fail(w, http.StatusUnauthorized, errors.New("admin token required"))
|
||||
return
|
||||
}
|
||||
next(w, r)
|
||||
}
|
||||
}
|
||||
|
||||
func (a *App) agentAuth(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
if a.cfg.AgentToken != "" && !tokenEqual(r.Header.Get("X-Rollcall-Token"), a.cfg.AgentToken) && !a.isAdmin(r) {
|
||||
fail(w, http.StatusUnauthorized, errors.New("agent token required"))
|
||||
return
|
||||
}
|
||||
next(w, r)
|
||||
}
|
||||
}
|
||||
|
||||
func logging(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
rw := &statusWriter{ResponseWriter: w, code: 200}
|
||||
next.ServeHTTP(rw, r)
|
||||
if !strings.HasPrefix(r.URL.Path, "/rollcall/") || rw.code >= 400 {
|
||||
log.Printf("%s %s %s %d %s", r.RemoteAddr, r.Method, r.URL.RequestURI(), rw.code, time.Since(start).Round(time.Millisecond))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
type statusWriter struct {
|
||||
http.ResponseWriter
|
||||
code int
|
||||
}
|
||||
|
||||
func (s *statusWriter) WriteHeader(c int) { s.code = c; s.ResponseWriter.WriteHeader(c) }
|
||||
|
||||
func (a *App) routes() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
// agent endpoints
|
||||
mux.HandleFunc("POST /api/v1/commission", a.agentAuth(a.handleCommission))
|
||||
mux.HandleFunc("GET /api/v1/bmc-hint", a.agentAuth(a.handleHint))
|
||||
// management endpoints
|
||||
mux.HandleFunc("GET /api/v1/machines", a.adminAuth(a.handleList))
|
||||
mux.HandleFunc("GET /api/v1/machines/{id}", a.adminAuth(a.handleGet))
|
||||
mux.HandleFunc("DELETE /api/v1/machines/{id}", a.adminAuth(a.handleDelete))
|
||||
mux.HandleFunc("POST /api/v1/machines/{id}/recommission", a.adminAuth(a.handleRecommission))
|
||||
mux.HandleFunc("GET /api/v1/machines/{id}/power", a.adminAuth(a.handlePower))
|
||||
mux.HandleFunc("POST /api/v1/machines/{id}/power", a.adminAuth(a.handlePower))
|
||||
mux.HandleFunc("POST /api/v1/machines/{id}/bootdev", a.adminAuth(a.handleBootdev))
|
||||
mux.HandleFunc("GET /api/v1/whoami", a.adminAuth(func(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, 200, map[string]any{"ok": true})
|
||||
}))
|
||||
// image files for the live boot (no auth: the kernel/initrd/squashfs must be fetchable)
|
||||
imgDir := a.cfg.ImageDir
|
||||
mux.Handle("GET /rollcall/", http.StripPrefix("/rollcall/", http.FileServer(http.Dir(imgDir))))
|
||||
// embedded web UI
|
||||
sub, _ := fs.Sub(webFS, "web")
|
||||
mux.Handle("GET /", http.FileServer(http.FS(sub)))
|
||||
return logging(mux)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- helpers over inventory JSON
|
||||
|
||||
type obj = map[string]any
|
||||
|
||||
func dig(m any, path ...string) any {
|
||||
cur := m
|
||||
for _, p := range path {
|
||||
mm, ok := cur.(obj)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
cur = mm[p]
|
||||
}
|
||||
return cur
|
||||
}
|
||||
|
||||
func str(v any) string {
|
||||
switch t := v.(type) {
|
||||
case nil:
|
||||
return ""
|
||||
case string:
|
||||
return t
|
||||
case float64:
|
||||
return fmt.Sprintf("%v", t)
|
||||
default:
|
||||
return fmt.Sprintf("%v", t)
|
||||
}
|
||||
}
|
||||
|
||||
func strPtr(v any) *string {
|
||||
s := str(v)
|
||||
if s == "" {
|
||||
return nil
|
||||
}
|
||||
return &s
|
||||
}
|
||||
|
||||
func listLen(v any) int {
|
||||
if l, ok := v.([]any); ok {
|
||||
return len(l)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func normMAC(s string) string { return strings.ToLower(strings.ReplaceAll(s, "-", ":")) }
|
||||
|
||||
var nonAlnum = regexp.MustCompile(`[^a-z0-9]`)
|
||||
|
||||
func machineID(uuid, serial string, macs []string) string {
|
||||
u := strings.ToLower(uuid)
|
||||
if u != "" && u != "00000000-0000-0000-0000-000000000000" && !strings.Contains(u, "not ") {
|
||||
u = strings.ReplaceAll(u, "-", "")
|
||||
if len(u) > 12 {
|
||||
u = u[:12]
|
||||
}
|
||||
return "m-" + u
|
||||
}
|
||||
if s := nonAlnum.ReplaceAllString(strings.ToLower(serial), ""); s != "" && !strings.Contains(strings.ToLower(serial), "not ") {
|
||||
if len(s) > 16 {
|
||||
s = s[:16]
|
||||
}
|
||||
return "m-" + s
|
||||
}
|
||||
if len(macs) > 0 {
|
||||
return "m-" + strings.ReplaceAll(macs[0], ":", "")
|
||||
}
|
||||
return "m-" + randomToken(6)
|
||||
}
|
||||
|
||||
// Summary is the list-view projection of a machine (no secrets, no full inventory).
|
||||
type Summary struct {
|
||||
ID string `json:"id"`
|
||||
State string `json:"state"`
|
||||
Hostname *string `json:"hostname"`
|
||||
Serial *string `json:"serial"`
|
||||
UUID *string `json:"uuid"`
|
||||
Manufacturer *string `json:"manufacturer"`
|
||||
Product *string `json:"product"`
|
||||
FirstSeen time.Time `json:"first_seen"`
|
||||
LastSeen *time.Time `json:"last_seen"`
|
||||
MACs []string `json:"macs"`
|
||||
CPU string `json:"cpu"`
|
||||
CPUs string `json:"cpus"`
|
||||
MemoryBytes float64 `json:"memory_bytes"`
|
||||
Disks float64 `json:"disks"`
|
||||
StorageBytes float64 `json:"storage_bytes"`
|
||||
NICs int `json:"nics"`
|
||||
IBHCAs int `json:"ib_hcas"`
|
||||
GPUs int `json:"gpus"`
|
||||
BMC *obj `json:"bmc"`
|
||||
}
|
||||
|
||||
func num(v any) float64 {
|
||||
f, _ := v.(float64)
|
||||
return f
|
||||
}
|
||||
|
||||
func summarize(m *Machine) Summary {
|
||||
var inv obj
|
||||
_ = json.Unmarshal(m.Inventory, &inv)
|
||||
s := Summary{ID: m.ID, State: m.State, Hostname: m.Hostname, Serial: m.Serial, UUID: m.UUID,
|
||||
Manufacturer: m.Manufacturer, Product: m.Product, FirstSeen: m.FirstSeen, LastSeen: m.LastSeen, MACs: m.MACs,
|
||||
CPU: str(dig(inv, "cpu", "Model name")), CPUs: str(dig(inv, "cpu", "CPU(s)")),
|
||||
MemoryBytes: num(dig(inv, "memory", "total_bytes")), Disks: num(dig(inv, "storage", "disk_count")),
|
||||
StorageBytes: num(dig(inv, "storage", "total_bytes")), NICs: listLen(inv["network"]),
|
||||
IBHCAs: listLen(dig(inv, "infiniband", "hcas")), GPUs: listLen(inv["gpus"])}
|
||||
if m.BMC != nil {
|
||||
var b obj
|
||||
if json.Unmarshal(m.BMC, &b) == nil {
|
||||
s.BMC = &obj{"source": b["source"], "address": b["address"], "user": b["user"],
|
||||
"configured": b["configured"], "verified_oob": b["verified_oob"]}
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- pxelinux per-MAC files
|
||||
|
||||
const commissionedTmpl = `# generated by rollcall %s
|
||||
# machine %s %s %s serial=%s
|
||||
DEFAULT menu.c32
|
||||
PROMPT 0
|
||||
TIMEOUT 150
|
||||
MENU TITLE %s - commissioned (%s %s, S/N %s)
|
||||
|
||||
LABEL poweroff
|
||||
MENU LABEL Commissioned: power off (default in 15s)
|
||||
MENU DEFAULT
|
||||
KERNEL poweroff.c32
|
||||
|
||||
LABEL recommission
|
||||
MENU LABEL Re-run commissioning
|
||||
KERNEL rollcall/vmlinuz
|
||||
INITRD rollcall/initrd.img
|
||||
APPEND %s
|
||||
|
||||
LABEL local
|
||||
MENU LABEL Boot from local disk
|
||||
LOCALBOOT 0
|
||||
`
|
||||
|
||||
func (a *App) pxePath(mac string) string {
|
||||
return filepath.Join(a.cfg.TFTPRoot, "pxelinux.cfg", "01-"+strings.ReplaceAll(normMAC(mac), ":", "-"))
|
||||
}
|
||||
|
||||
func deref(p *string) string {
|
||||
if p == nil {
|
||||
return ""
|
||||
}
|
||||
return *p
|
||||
}
|
||||
|
||||
func (a *App) writePXE(m *Machine) error {
|
||||
man, prod, ser := deref(m.Manufacturer), deref(m.Product), deref(m.Serial)
|
||||
body := fmt.Sprintf(commissionedTmpl, time.Now().Format(time.RFC3339), m.ID, man, prod, ser,
|
||||
m.ID, man, prod, ser, a.cfg.CommissionAppend)
|
||||
for _, mac := range m.MACs {
|
||||
p := a.pxePath(mac)
|
||||
if err := os.WriteFile(p+".tmp", []byte(body), 0o644); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.Rename(p+".tmp", p); err != nil {
|
||||
return err
|
||||
}
|
||||
log.Printf("wrote %s", p)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a *App) removePXE(m *Machine) {
|
||||
for _, mac := range m.MACs {
|
||||
if err := os.Remove(a.pxePath(mac)); err == nil {
|
||||
log.Printf("removed %s", a.pxePath(mac))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- handlers
|
||||
|
||||
func (a *App) handleCommission(w http.ResponseWriter, r *http.Request) {
|
||||
body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 32<<20))
|
||||
if err != nil {
|
||||
fail(w, 400, err)
|
||||
return
|
||||
}
|
||||
var inv obj
|
||||
if err := json.Unmarshal(body, &inv); err != nil {
|
||||
fail(w, 400, fmt.Errorf("bad json: %w", err))
|
||||
return
|
||||
}
|
||||
ident, _ := inv["identity"].(obj)
|
||||
var macs []string
|
||||
if l, ok := ident["macs"].([]any); ok {
|
||||
for _, v := range l {
|
||||
if s := normMAC(str(v)); s != "" {
|
||||
macs = append(macs, s)
|
||||
}
|
||||
}
|
||||
}
|
||||
if boot := normMAC(str(ident["boot_mac"])); boot != "" {
|
||||
for i, mac := range macs {
|
||||
if mac == boot && i != 0 {
|
||||
macs = append([]string{boot}, append(macs[:i], macs[i+1:]...)...)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
m := &Machine{
|
||||
ID: machineID(str(ident["uuid"]), str(ident["serial"]), macs),
|
||||
UUID: strPtr(ident["uuid"]),
|
||||
Serial: strPtr(ident["serial"]),
|
||||
Hostname: strPtr(inv["hostname"]),
|
||||
Manufacturer: strPtr(dig(inv, "system", "system-manufacturer")),
|
||||
Product: strPtr(dig(inv, "system", "system-product-name")),
|
||||
MACs: macs,
|
||||
}
|
||||
// Pull the BMC password out of the payload before anything is persisted.
|
||||
var secret []byte
|
||||
detail := "bmc=none"
|
||||
if bmc, ok := inv["bmc"].(obj); ok {
|
||||
if pw := str(bmc["password"]); pw != "" {
|
||||
secret, err = a.sealer.Seal(pw, m.ID)
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
bmc["password"] = "<stored encrypted>"
|
||||
}
|
||||
m.BMC, _ = json.Marshal(bmc)
|
||||
detail = fmt.Sprintf("bmc=%s:%s configured=%v", str(bmc["source"]), str(bmc["address"]), bmc["configured"])
|
||||
}
|
||||
m.Inventory, _ = json.Marshal(inv)
|
||||
|
||||
isNew, err := a.store.UpsertCommissioned(r.Context(), m, secret)
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
_ = a.store.AddEvent(r.Context(), m.ID, "commissioned", detail)
|
||||
if err := a.writePXE(m); err != nil {
|
||||
log.Printf("pxe write failed for %s: %v", m.ID, err)
|
||||
_ = a.store.AddEvent(r.Context(), m.ID, "pxe-write-failed", err.Error())
|
||||
}
|
||||
log.Printf("commissioned %s new=%v (%s %s, serial %s, %d macs) %s", m.ID, isNew, deref(m.Manufacturer),
|
||||
deref(m.Product), deref(m.Serial), len(macs), detail)
|
||||
writeJSON(w, 200, map[string]any{"id": m.ID, "state": "ready", "new": isNew})
|
||||
}
|
||||
|
||||
func (a *App) handleHint(w http.ResponseWriter, r *http.Request) {
|
||||
want := map[string]bool{}
|
||||
for _, m := range strings.Split(r.URL.Query().Get("macs"), ",") {
|
||||
want[normMAC(m)] = true
|
||||
}
|
||||
for _, h := range a.cfg.BMCHints {
|
||||
if want[normMAC(h.MAC)] {
|
||||
port := h.Port
|
||||
if port == 0 {
|
||||
port = 623
|
||||
}
|
||||
writeJSON(w, 200, obj{"address": h.Address, "port": port, "user": h.User, "password": h.Password})
|
||||
return
|
||||
}
|
||||
}
|
||||
writeJSON(w, 200, obj{})
|
||||
}
|
||||
|
||||
func (a *App) handleList(w http.ResponseWriter, r *http.Request) {
|
||||
ms, err := a.store.List(r.Context())
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
out := make([]Summary, 0, len(ms))
|
||||
for _, m := range ms {
|
||||
out = append(out, summarize(m))
|
||||
}
|
||||
writeJSON(w, 200, out)
|
||||
}
|
||||
|
||||
func (a *App) handleGet(w http.ResponseWriter, r *http.Request) {
|
||||
m, err := a.store.Get(r.Context(), r.PathValue("id"))
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
evs, _ := a.store.Events(r.Context(), m.ID)
|
||||
var bmc, inv any
|
||||
_ = json.Unmarshal(m.BMC, &bmc)
|
||||
_ = json.Unmarshal(m.Inventory, &inv)
|
||||
writeJSON(w, 200, obj{"summary": summarize(m), "bmc": bmc, "has_bmc_secret": m.bmcSecret != nil,
|
||||
"inventory": inv, "events": evs})
|
||||
}
|
||||
|
||||
func (a *App) handleDelete(w http.ResponseWriter, r *http.Request) {
|
||||
m, err := a.store.Get(r.Context(), r.PathValue("id"))
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
a.removePXE(m)
|
||||
if err := a.store.Delete(r.Context(), m.ID); err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
log.Printf("deleted %s", m.ID)
|
||||
writeJSON(w, 200, obj{"deleted": m.ID})
|
||||
}
|
||||
|
||||
func (a *App) handleRecommission(w http.ResponseWriter, r *http.Request) {
|
||||
m, err := a.store.Get(r.Context(), r.PathValue("id"))
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
a.removePXE(m)
|
||||
_ = a.store.SetState(r.Context(), m.ID, "recommission")
|
||||
_ = a.store.AddEvent(r.Context(), m.ID, "recommission requested", "")
|
||||
// optional: power-cycle it right away when the caller asks (?now=1)
|
||||
out := obj{"id": m.ID, "state": "recommission"}
|
||||
if r.URL.Query().Get("now") == "1" {
|
||||
if c, err := a.credsFor(m); err == nil {
|
||||
o, ierr := a.ipmi(r.Context(), c, "chassis", "bootdev", "pxe")
|
||||
o2, ierr2 := a.ipmi(r.Context(), c, "chassis", "power", "cycle")
|
||||
if ierr2 != nil && strings.Contains(o2, "off") { // cycle fails when off; power on instead
|
||||
o2, ierr2 = a.ipmi(r.Context(), c, "chassis", "power", "on")
|
||||
}
|
||||
out["ipmi"] = strings.TrimSpace(o + "\n" + o2)
|
||||
out["ipmi_ok"] = ierr == nil && ierr2 == nil
|
||||
} else {
|
||||
out["ipmi"] = err.Error()
|
||||
}
|
||||
}
|
||||
writeJSON(w, 200, out)
|
||||
}
|
||||
|
||||
func (a *App) handlePower(w http.ResponseWriter, r *http.Request) {
|
||||
m, err := a.store.Get(r.Context(), r.PathValue("id"))
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
action := "status"
|
||||
if r.Method == http.MethodPost {
|
||||
var req struct {
|
||||
Action string `json:"action"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
fail(w, 400, err)
|
||||
return
|
||||
}
|
||||
action = req.Action
|
||||
}
|
||||
args, ok := powerActions[action]
|
||||
if !ok {
|
||||
fail(w, 400, fmt.Errorf("unknown power action %q", action))
|
||||
return
|
||||
}
|
||||
c, err := a.credsFor(m)
|
||||
if err != nil {
|
||||
fail(w, 409, err)
|
||||
return
|
||||
}
|
||||
out, err := a.ipmi(r.Context(), c, args...)
|
||||
if action != "status" {
|
||||
_ = a.store.AddEvent(r.Context(), m.ID, "power "+action, out)
|
||||
}
|
||||
writeJSON(w, 200, obj{"id": m.ID, "action": action, "ok": err == nil, "output": out})
|
||||
}
|
||||
|
||||
func (a *App) handleBootdev(w http.ResponseWriter, r *http.Request) {
|
||||
m, err := a.store.Get(r.Context(), r.PathValue("id"))
|
||||
if err != nil {
|
||||
fail(w, 500, err)
|
||||
return
|
||||
}
|
||||
var req struct {
|
||||
Device string `json:"device"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || !bootDevices[req.Device] {
|
||||
fail(w, 400, fmt.Errorf("device must be one of pxe, disk, cdrom, bios, none, safe"))
|
||||
return
|
||||
}
|
||||
c, err := a.credsFor(m)
|
||||
if err != nil {
|
||||
fail(w, 409, err)
|
||||
return
|
||||
}
|
||||
out, err := a.ipmi(r.Context(), c, "chassis", "bootdev", req.Device)
|
||||
_ = a.store.AddEvent(r.Context(), m.ID, "bootdev "+req.Device, out)
|
||||
writeJSON(w, 200, obj{"id": m.ID, "device": req.Device, "ok": err == nil, "output": out})
|
||||
}
|
||||
|
||||
func serve(cfgPath string) error {
|
||||
cfg, err := loadConfig(cfgPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sealer, err := loadOrCreateKey(cfg.MasterKeyFile)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
store, err := openStore(ctx, cfg.DatabaseURL)
|
||||
cancel()
|
||||
if err != nil {
|
||||
return fmt.Errorf("database: %w", err)
|
||||
}
|
||||
app := &App{cfg: cfg, store: store, sealer: sealer}
|
||||
srv := &http.Server{Addr: cfg.Listen, Handler: app.routes(), ReadHeaderTimeout: 10 * time.Second}
|
||||
log.Printf("rollcall listening on %s (image=%s tftp=%s agent_token=%v)", cfg.Listen, cfg.ImageDir, cfg.TFTPRoot, cfg.AgentToken != "")
|
||||
return srv.ListenAndServe()
|
||||
}
|
||||
@@ -0,0 +1,203 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
const schema = `
|
||||
CREATE TABLE IF NOT EXISTS machines (
|
||||
id text PRIMARY KEY,
|
||||
uuid text,
|
||||
serial text,
|
||||
hostname text,
|
||||
manufacturer text,
|
||||
product text,
|
||||
state text NOT NULL DEFAULT 'new',
|
||||
first_seen timestamptz NOT NULL DEFAULT now(),
|
||||
last_seen timestamptz,
|
||||
commissioned_at timestamptz,
|
||||
macs jsonb NOT NULL DEFAULT '[]',
|
||||
bmc jsonb,
|
||||
bmc_secret bytea,
|
||||
inventory jsonb
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS machines_uuid ON machines(uuid);
|
||||
CREATE INDEX IF NOT EXISTS machines_macs ON machines USING gin(macs);
|
||||
CREATE TABLE IF NOT EXISTS events (
|
||||
id bigserial PRIMARY KEY,
|
||||
ts timestamptz NOT NULL DEFAULT now(),
|
||||
machine_id text NOT NULL,
|
||||
event text NOT NULL,
|
||||
detail text
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS events_machine ON events(machine_id, ts);
|
||||
`
|
||||
|
||||
var errNotFound = errors.New("not found")
|
||||
|
||||
type Store struct{ pool *pgxpool.Pool }
|
||||
|
||||
type Machine struct {
|
||||
ID string `json:"id"`
|
||||
UUID *string `json:"uuid"`
|
||||
Serial *string `json:"serial"`
|
||||
Hostname *string `json:"hostname"`
|
||||
Manufacturer *string `json:"manufacturer"`
|
||||
Product *string `json:"product"`
|
||||
State string `json:"state"`
|
||||
FirstSeen time.Time `json:"first_seen"`
|
||||
LastSeen *time.Time `json:"last_seen"`
|
||||
CommissionedAt *time.Time `json:"commissioned_at"`
|
||||
MACs []string `json:"macs"`
|
||||
BMC json.RawMessage `json:"bmc,omitempty"`
|
||||
Inventory json.RawMessage `json:"inventory,omitempty"`
|
||||
bmcSecret []byte
|
||||
}
|
||||
|
||||
type Event struct {
|
||||
TS time.Time `json:"ts"`
|
||||
Event string `json:"event"`
|
||||
Detail string `json:"detail"`
|
||||
}
|
||||
|
||||
func openStore(ctx context.Context, url string) (*Store, error) {
|
||||
pool, err := pgxpool.New(ctx, url)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, schema); err != nil {
|
||||
return nil, fmt.Errorf("schema: %w", err)
|
||||
}
|
||||
return &Store{pool: pool}, nil
|
||||
}
|
||||
|
||||
const machineCols = `id, uuid, serial, hostname, manufacturer, product, state, first_seen, last_seen,
|
||||
commissioned_at, macs, bmc, bmc_secret, inventory`
|
||||
|
||||
func scanMachine(row pgx.Row, full bool) (*Machine, error) {
|
||||
m := &Machine{}
|
||||
var macs []byte
|
||||
err := row.Scan(&m.ID, &m.UUID, &m.Serial, &m.Hostname, &m.Manufacturer, &m.Product, &m.State,
|
||||
&m.FirstSeen, &m.LastSeen, &m.CommissionedAt, &macs, &m.BMC, &m.bmcSecret, &m.Inventory)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, errNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_ = json.Unmarshal(macs, &m.MACs)
|
||||
if !full {
|
||||
m.Inventory = nil
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (s *Store) List(ctx context.Context) ([]*Machine, error) {
|
||||
rows, err := s.pool.Query(ctx, `SELECT `+machineCols+` FROM machines ORDER BY first_seen`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []*Machine
|
||||
for rows.Next() {
|
||||
m, err := scanMachine(rows, true)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, m)
|
||||
}
|
||||
if out == nil {
|
||||
out = []*Machine{}
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func (s *Store) Get(ctx context.Context, id string) (*Machine, error) {
|
||||
return scanMachine(s.pool.QueryRow(ctx, `SELECT `+machineCols+` FROM machines WHERE id=$1`, id), true)
|
||||
}
|
||||
|
||||
func (s *Store) Events(ctx context.Context, id string) ([]Event, error) {
|
||||
rows, err := s.pool.Query(ctx, `SELECT ts, event, coalesce(detail,'') FROM events WHERE machine_id=$1 ORDER BY ts`, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
evs := []Event{}
|
||||
for rows.Next() {
|
||||
var e Event
|
||||
if err := rows.Scan(&e.TS, &e.Event, &e.Detail); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
evs = append(evs, e)
|
||||
}
|
||||
return evs, rows.Err()
|
||||
}
|
||||
|
||||
func (s *Store) AddEvent(ctx context.Context, id, event, detail string) error {
|
||||
_, err := s.pool.Exec(ctx, `INSERT INTO events(machine_id, event, detail) VALUES ($1,$2,$3)`, id, event, detail)
|
||||
return err
|
||||
}
|
||||
|
||||
// UpsertCommissioned stores a fresh inventory; returns true when the machine was new.
|
||||
func (s *Store) UpsertCommissioned(ctx context.Context, m *Machine, secret []byte) (bool, error) {
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
defer tx.Rollback(ctx)
|
||||
macs, _ := json.Marshal(m.MACs)
|
||||
tag, err := tx.Exec(ctx, `INSERT INTO machines(id, state) VALUES ($1,'new') ON CONFLICT (id) DO NOTHING`, m.ID)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
isNew := tag.RowsAffected() == 1
|
||||
if isNew {
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO events(machine_id, event) VALUES ($1,'enlisted')`, m.ID); err != nil {
|
||||
return false, err
|
||||
}
|
||||
}
|
||||
_, err = tx.Exec(ctx, `UPDATE machines SET uuid=$2, serial=$3, hostname=$4, manufacturer=$5, product=$6,
|
||||
state='ready', last_seen=now(), commissioned_at=now(), macs=$7, bmc=$8, bmc_secret=$9, inventory=$10 WHERE id=$1`,
|
||||
m.ID, m.UUID, m.Serial, m.Hostname, m.Manufacturer, m.Product, macs, m.BMC, secret, m.Inventory)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return isNew, tx.Commit(ctx)
|
||||
}
|
||||
|
||||
func (s *Store) SetState(ctx context.Context, id, state string) error {
|
||||
tag, err := s.pool.Exec(ctx, `UPDATE machines SET state=$2 WHERE id=$1`, id, state)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if tag.RowsAffected() == 0 {
|
||||
return errNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) Delete(ctx context.Context, id string) error {
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback(ctx)
|
||||
if _, err := tx.Exec(ctx, `DELETE FROM events WHERE machine_id=$1`, id); err != nil {
|
||||
return err
|
||||
}
|
||||
tag, err := tx.Exec(ctx, `DELETE FROM machines WHERE id=$1`, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if tag.RowsAffected() == 0 {
|
||||
return errNotFound
|
||||
}
|
||||
return tx.Commit(ctx)
|
||||
}
|
||||
@@ -0,0 +1,158 @@
|
||||
'use strict';
|
||||
const $ = (s, el = document) => el.querySelector(s);
|
||||
const esc = s => String(s ?? '').replace(/[&<>"']/g, c => ({'&':'&','<':'<','>':'>','"':'"',"'":'''}[c]));
|
||||
const human = n => { n = Number(n || 0); const u = ['B','K','M','G','T','P']; let i = 0; while (n >= 1024 && i < u.length - 1) { n /= 1024; i++; } return (i <= 2 ? n.toFixed(0) : n.toFixed(1)) + u[i]; };
|
||||
const ago = ts => { if (!ts) return '-'; const s = (Date.now() - new Date(ts)) / 1000; if (s < 90) return `${s | 0}s ago`; if (s < 5400) return `${(s / 60) | 0}m ago`; if (s < 172800) return `${(s / 3600) | 0}h ago`; return `${(s / 86400) | 0}d ago`; };
|
||||
|
||||
let token = '';
|
||||
try { token = localStorage.getItem('rollcall.token') || ''; } catch (e) { /* storage unavailable */ }
|
||||
let machines = [];
|
||||
let current = null;
|
||||
let timer = null;
|
||||
|
||||
async function api(method, path, body) {
|
||||
const r = await fetch(path, { method, headers: { 'Authorization': 'Bearer ' + token, 'Content-Type': 'application/json' }, body: body ? JSON.stringify(body) : undefined });
|
||||
if (r.status === 401) { askToken(); throw new Error('unauthorized'); }
|
||||
const data = await r.json().catch(() => ({}));
|
||||
if (!r.ok) throw new Error(data.error || r.statusText);
|
||||
return data;
|
||||
}
|
||||
|
||||
function askToken() {
|
||||
const dlg = $('#login');
|
||||
if (!dlg.open) dlg.showModal();
|
||||
}
|
||||
$('#login form').addEventListener('submit', () => {
|
||||
token = $('#token').value.trim();
|
||||
try { localStorage.setItem('rollcall.token', token); } catch (e) { /* ignore */ }
|
||||
$('#token').value = '';
|
||||
loadList();
|
||||
});
|
||||
$('#logout').onclick = () => { token = ''; try { localStorage.removeItem('rollcall.token'); } catch (e) { /* ignore */ } askToken(); };
|
||||
$('#refresh').onclick = () => current ? loadDetail(current) : loadList();
|
||||
$('#filter').oninput = renderList;
|
||||
$('#back').onclick = () => { current = null; $('#detail').hidden = true; $('#list').hidden = false; loadList(); };
|
||||
|
||||
function setStatus(msg, bad) { const el = $('#status'); el.textContent = msg; el.className = bad ? 'bad' : 'muted'; }
|
||||
|
||||
async function loadList() {
|
||||
if (!token) return askToken();
|
||||
try {
|
||||
machines = await api('GET', '/api/v1/machines');
|
||||
setStatus(`updated ${new Date().toLocaleTimeString()}`);
|
||||
renderList();
|
||||
} catch (e) { if (e.message !== 'unauthorized') setStatus(e.message, true); }
|
||||
}
|
||||
|
||||
function renderList() {
|
||||
const q = $('#filter').value.toLowerCase();
|
||||
const rows = machines.filter(m => !q || JSON.stringify([m.id, m.state, m.manufacturer, m.product, m.serial, m.macs, m.hostname]).toLowerCase().includes(q));
|
||||
$('#count').textContent = `${rows.length} / ${machines.length}`;
|
||||
$('#empty').hidden = machines.length > 0;
|
||||
$('#machines tbody').innerHTML = rows.map(m => {
|
||||
const b = m.bmc;
|
||||
const bmc = b ? `<span class="${b.configured ? 'ok' : 'bad'}">${esc(b.address || '-')}</span> <span class="muted">${esc(b.source)}</span>` : '<span class="muted">-</span>';
|
||||
return `<tr data-id="${esc(m.id)}">
|
||||
<td class="mono">${esc(m.id)}</td><td><span class="pill ${esc(m.state)}">${esc(m.state)}</span></td>
|
||||
<td>${esc((m.manufacturer || '') + ' ' + (m.product || ''))}</td><td class="mono">${esc(m.serial || '')}</td>
|
||||
<td class="num">${esc(m.cpus)}</td><td class="num">${human(m.memory_bytes)}</td><td class="num">${m.disks | 0}</td>
|
||||
<td class="num">${human(m.storage_bytes)}</td><td class="num">${m.nics}</td><td class="num">${m.ib_hcas}</td><td class="num">${m.gpus}</td>
|
||||
<td>${bmc}</td><td class="muted">${ago(m.last_seen)}</td></tr>`;
|
||||
}).join('');
|
||||
for (const tr of $('#machines tbody').children) tr.onclick = () => loadDetail(tr.dataset.id);
|
||||
}
|
||||
|
||||
function card(title, inner, wide) { return `<div class="card${wide ? ' wide' : ''}"><h3>${esc(title)}</h3>${inner}</div>`; }
|
||||
function kv(pairs) { return '<dl class="kv">' + pairs.filter(([, v]) => v !== undefined && v !== null && v !== '').map(([k, v]) => `<dt>${esc(k)}</dt><dd>${v}</dd>`).join('') + '</dl>'; }
|
||||
function table(cols, rows) { return rows.length ? `<table><thead><tr>${cols.map(c => `<th>${esc(c)}</th>`).join('')}</tr></thead><tbody>${rows.map(r => `<tr>${r.map(c => `<td>${c ?? ''}</td>`).join('')}</tr>`).join('')}</tbody></table>` : '<span class="muted">none</span>'; }
|
||||
|
||||
async function loadDetail(id) {
|
||||
try {
|
||||
const d = await api('GET', '/api/v1/machines/' + encodeURIComponent(id));
|
||||
current = id;
|
||||
renderDetail(d);
|
||||
$('#list').hidden = true; $('#detail').hidden = false;
|
||||
} catch (e) { if (e.message !== 'unauthorized') setStatus(e.message, true); }
|
||||
}
|
||||
|
||||
function renderDetail(d) {
|
||||
const s = d.summary, inv = d.inventory || {}, sys = inv.system || {}, cpu = inv.cpu || {}, mem = inv.memory || {}, st = inv.storage || {}, b = d.bmc || {};
|
||||
$('#d-title').textContent = `${s.id} ${sys['system-manufacturer'] || ''} ${sys['system-product-name'] || ''}`;
|
||||
$('#d-state').textContent = s.state; $('#d-state').className = 'pill ' + s.state;
|
||||
$('#action-out').textContent = '';
|
||||
const cards = [];
|
||||
cards.push(card('System', kv([
|
||||
['Manufacturer', esc(sys['system-manufacturer'])], ['Product', esc(sys['system-product-name'])], ['Serial', esc(sys['system-serial-number'])],
|
||||
['UUID', `<span class="mono">${esc(sys['system-uuid'])}</span>`], ['SKU', esc(sys['system-sku-number'])],
|
||||
['Board', esc([sys['baseboard-manufacturer'], sys['baseboard-product-name'], sys['baseboard-serial-number']].filter(Boolean).join(' / '))],
|
||||
['Chassis', esc([sys['chassis-type'], sys['chassis-serial-number'], sys['chassis-asset-tag']].filter(Boolean).join(' / '))],
|
||||
['BIOS', esc([sys['bios-vendor'], sys['bios-version'], sys['bios-release-date']].filter(Boolean).join(' '))],
|
||||
['Kernel', esc((inv.kernel || '').split(' (')[0])], ['TPM', esc((inv.tpm || []).join(', ') || 'none')],
|
||||
['Hostname', esc(s.hostname)], ['First seen', esc(new Date(s.first_seen).toLocaleString())], ['Last seen', esc(s.last_seen ? new Date(s.last_seen).toLocaleString() : '')],
|
||||
['Agent run', esc(inv.duration_s ? inv.duration_s + ' s' : '')],
|
||||
])));
|
||||
cards.push(card('CPU', kv([
|
||||
['Model', esc(cpu['Model name'])], ['Sockets', esc(cpu['Socket(s)'])], ['Cores / socket', esc(cpu['Core(s) per socket'])],
|
||||
['Threads / core', esc(cpu['Thread(s) per core'])], ['Logical CPUs', esc(cpu['CPU(s)'])], ['NUMA nodes', esc(cpu['NUMA node(s)'])],
|
||||
['Max MHz', esc(cpu['CPU max MHz'])], ['L3', esc(cpu['L3 cache'])], ['Virtualization', esc(cpu['Virtualization'])],
|
||||
['Features', esc((cpu.features || []).join(' '))],
|
||||
])));
|
||||
cards.push(card(`Memory ${human(mem.total_bytes)} · ${mem.dimms_populated ?? '?'}/${mem.dimm_slots ?? '?'} DIMMs`,
|
||||
table(['Slot', 'Size', 'Type', 'Speed', 'Vendor', 'Part', 'Serial'],
|
||||
(mem.dimms || []).filter(x => x.populated).map(x => [esc(x.locator), esc(x.size), esc(x.type), esc(x.configured_speed || x.speed), esc(x.manufacturer), `<span class="mono">${esc(x.part_number)}</span>`, `<span class="mono">${esc(x.serial)}</span>`]))));
|
||||
cards.push(card(`Storage · ${st.disk_count ?? 0} disks · ${human(st.total_bytes)}`,
|
||||
table(['Dev', 'Size', 'Bus', 'Kind', 'Model', 'Serial', 'FW', 'Health'],
|
||||
(st.disks || []).map(x => { const sm = (st.smart || {})[x.name] || {}; return [esc(x.name), human(x.size), esc(x.tran), x.rota === false ? 'ssd' : 'hdd', esc(x.model), `<span class="mono">${esc(x.serial)}</span>`, esc(sm.firmware), sm.healthy === true ? '<span class="ok">ok</span>' : sm.healthy === false ? '<span class="bad">FAIL</span>' : '']; }))
|
||||
+ (st.controllers && st.controllers.length ? '<p class="muted">Controllers</p>' + table(['PCI', 'Vendor', 'Device', 'Driver'], st.controllers.map(c => [`<span class="mono">${esc(c.slot)}</span>`, esc(c.vendor), esc(c.device), esc(c.driver)])) : ''), true));
|
||||
cards.push(card(`Network · ${(inv.network || []).length} NICs`,
|
||||
table(['If', 'MAC', 'Driver', 'FW', 'Speed', 'Link', 'PCI', 'NUMA', 'VFs', 'IPv4'],
|
||||
(inv.network || []).map(n => [esc(n.name), `<span class="mono">${esc(n.mac)}</span>`, esc(n.driver), esc(n.firmware_version), esc(n.speed), n.link === true ? '<span class="ok">up</span>' : n.link === false ? '<span class="muted">down</span>' : '', `<span class="mono">${esc(n.pci)}</span>`, esc(n.numa_node), esc(n.sriov_totalvfs), esc((n.ipv4 || []).join(' '))])), true));
|
||||
const hcas = (inv.infiniband || {}).hcas || [];
|
||||
if (hcas.length) cards.push(card(`InfiniBand · ${hcas.length} HCAs`,
|
||||
table(['HCA', 'Port', 'Layer', 'State', 'Rate', 'LID', 'Node GUID', 'FW', 'Board', 'PCI'],
|
||||
hcas.flatMap(h => (h.ports || []).map(p => [esc(h.name), esc(p.port), esc(p.link_layer), esc(p.state), esc(p.rate), esc(p.lid), `<span class="mono">${esc(h.node_guid)}</span>`, esc(h.fw_ver), esc(h.board_id), `<span class="mono">${esc(h.pci)}</span>`]))), true));
|
||||
if ((inv.gpus || []).length) cards.push(card('GPUs / accelerators', table(['PCI', 'Vendor', 'Device', 'Driver'], inv.gpus.map(g => [`<span class="mono">${esc(g.slot)}</span>`, esc(g.vendor), esc(g.device), esc(g.driver)]))));
|
||||
if (inv.lldp && Object.keys(inv.lldp).length) {
|
||||
const rows = [];
|
||||
for (const [ifn, ents] of Object.entries(inv.lldp)) for (const e of (Array.isArray(ents) ? ents : [ents])) {
|
||||
const ch = e.chassis || {}; const name = Object.keys(ch)[0] || '?'; const c = ch[name] || {};
|
||||
rows.push([esc(ifn), esc(name), esc((c.descr || '').slice(0, 60)), esc((e.port || {}).id && (e.port.id.value || e.port.id)), esc((e.port || {}).descr), esc((e.vlan || {})['vlan-id'] || (e.vlan || {}).value)]);
|
||||
}
|
||||
cards.push(card('LLDP neighbors (switch ports)', table(['If', 'Switch', 'Descr', 'Port', 'Port descr', 'VLAN'], rows), true));
|
||||
}
|
||||
cards.push(card('BMC', kv([
|
||||
['Source', esc(b.source)], ['Address', `<span class="mono">${esc(b.address)}${b.port && b.port !== 623 ? ':' + esc(b.port) : ''}</span>`], ['MAC', `<span class="mono">${esc(b.mac)}</span>`],
|
||||
['User', esc(b.user)], ['Password', d.has_bmc_secret ? '<span class="ok">stored encrypted on server</span>' : '<span class="bad">none</span>'],
|
||||
['Configured', b.configured ? '<span class="ok">yes</span>' : '<span class="bad">no</span>'], ['Verified OOB', b.verified_oob === true ? '<span class="ok">yes</span>' : b.verified_oob === false ? '<span class="bad">no</span>' : ''],
|
||||
['Channel', esc(b.channel)], ['LAN', b.lan ? `<span class="mono">${esc(JSON.stringify(b.lan))}</span>` : ''],
|
||||
['Firmware', esc((b.mc_info || {})['Firmware Revision'])], ['Manufacturer', esc((b.mc_info || {})['Manufacturer Name'])],
|
||||
['Errors', (b.errors || []).length ? `<span class="bad">${esc(b.errors.join('; '))}</span>` : ''],
|
||||
]) + ((b.users_before || []).length ? '<p class="muted">User table before commissioning</p>' + table(['ID', 'Name', 'Priv', 'IPMI'], b.users_before.map(u => [u.id, esc(u.name), esc(u.priv), u.ipmi_msg ? 'yes' : 'no'])) : '')));
|
||||
cards.push(card('Events', table(['Time', 'Event', 'Detail'], (d.events || []).slice().reverse().map(e => [esc(new Date(e.ts).toLocaleString()), esc(e.event), `<span class="mono">${esc(e.detail)}</span>`]))));
|
||||
if ((inv.pci || []).length) cards.push(card(`PCI devices · ${inv.pci.length}`, table(['Slot', 'Class', 'Vendor', 'Device', 'Driver'], inv.pci.map(p => [`<span class="mono">${esc(p.slot)}</span>`, esc(p.class), esc(p.vendor), esc(p.device), esc(p.driver)])), true));
|
||||
if ((inv.errors || []).length) cards.push(card('Agent errors', `<span class="bad">${esc(inv.errors.join('\n'))}</span>`, true));
|
||||
$('#d-body').innerHTML = cards.join('');
|
||||
$('#d-json').textContent = JSON.stringify(d, null, 1);
|
||||
}
|
||||
|
||||
async function action(fn, label) {
|
||||
const btns = document.querySelectorAll('.actions button');
|
||||
btns.forEach(b => b.disabled = true);
|
||||
$('#action-out').textContent = label + ' …';
|
||||
try { const r = await fn(); $('#action-out').textContent = r; }
|
||||
catch (e) { $('#action-out').textContent = 'error: ' + e.message; }
|
||||
finally { btns.forEach(b => b.disabled = false); }
|
||||
}
|
||||
document.querySelectorAll('[data-power]').forEach(b => b.onclick = () => action(async () => {
|
||||
const r = await api('POST', `/api/v1/machines/${current}/power`, { action: b.dataset.power }); return r.output || (r.ok ? 'ok' : 'failed');
|
||||
}, 'power ' + b.dataset.power));
|
||||
document.querySelectorAll('[data-bootdev]').forEach(b => b.onclick = () => action(async () => {
|
||||
const r = await api('POST', `/api/v1/machines/${current}/bootdev`, { device: b.dataset.bootdev }); return r.output || (r.ok ? 'ok' : 'failed');
|
||||
}, 'bootdev ' + b.dataset.bootdev));
|
||||
$('#recommission').onclick = () => action(async () => { const r = await api('POST', `/api/v1/machines/${current}/recommission`); await loadDetail(current); return `state ${r.state}: next PXE boot runs commissioning`; }, 'recommission');
|
||||
$('#recommission-now').onclick = () => { if (confirm('Remove PXE override, set bootdev=pxe and power-cycle this machine via its BMC?')) action(async () => { const r = await api('POST', `/api/v1/machines/${current}/recommission?now=1`); await loadDetail(current); return r.ipmi || r.state; }, 'recommission now'); };
|
||||
$('#delete').onclick = () => { if (confirm(`Delete ${current}? It will be commissioned again as a new machine on next PXE boot.`)) action(async () => { await api('DELETE', `/api/v1/machines/${current}`); $('#back').click(); return 'deleted'; }, 'delete'); };
|
||||
|
||||
function schedule() { clearInterval(timer); timer = setInterval(() => { if (!current && document.visibilityState === 'visible') loadList(); }, 10000); }
|
||||
schedule();
|
||||
loadList();
|
||||
@@ -0,0 +1,75 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>rollcall</title>
|
||||
<link rel="stylesheet" href="style.css">
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<h1>rollcall <span class="sub">hardware commissioning</span></h1>
|
||||
<div class="hdr-right">
|
||||
<span id="status" class="muted"></span>
|
||||
<button id="refresh" class="btn">Refresh</button>
|
||||
<button id="logout" class="btn ghost" title="forget token">Token</button>
|
||||
</div>
|
||||
</header>
|
||||
|
||||
<dialog id="login">
|
||||
<form method="dialog">
|
||||
<h2>Admin token</h2>
|
||||
<p class="muted">The <code>admin_token</code> from <code>/etc/rollcall/config.json</code>. Stored only in this browser.</p>
|
||||
<input id="token" type="password" autocomplete="off" placeholder="token" required>
|
||||
<menu><button class="btn primary" value="ok">Sign in</button></menu>
|
||||
</form>
|
||||
</dialog>
|
||||
|
||||
<main>
|
||||
<section id="list">
|
||||
<div class="toolbar">
|
||||
<input id="filter" type="search" placeholder="filter: id, model, serial, mac, state…">
|
||||
<span id="count" class="muted"></span>
|
||||
</div>
|
||||
<table id="machines">
|
||||
<thead><tr>
|
||||
<th>ID</th><th>State</th><th>Model</th><th>Serial</th><th class="num">CPU</th><th class="num">RAM</th>
|
||||
<th class="num">Disks</th><th class="num">Storage</th><th class="num">NIC</th><th class="num">IB</th><th class="num">GPU</th>
|
||||
<th>BMC</th><th>Last seen</th>
|
||||
</tr></thead>
|
||||
<tbody></tbody>
|
||||
</table>
|
||||
<p id="empty" class="muted" hidden>No machines yet. PXE-boot an unknown server: it commissions itself and appears here.</p>
|
||||
</section>
|
||||
|
||||
<section id="detail" hidden>
|
||||
<div class="detail-head">
|
||||
<button id="back" class="btn ghost">← Machines</button>
|
||||
<h2 id="d-title"></h2>
|
||||
<span id="d-state" class="pill"></span>
|
||||
</div>
|
||||
<div class="actions">
|
||||
<span class="muted">Power:</span>
|
||||
<button class="btn" data-power="status">Status</button>
|
||||
<button class="btn" data-power="on">On</button>
|
||||
<button class="btn" data-power="off">Off</button>
|
||||
<button class="btn" data-power="soft">Soft off</button>
|
||||
<button class="btn" data-power="cycle">Cycle</button>
|
||||
<button class="btn" data-power="reset">Reset</button>
|
||||
<span class="sep"></span>
|
||||
<span class="muted">Boot:</span>
|
||||
<button class="btn" data-bootdev="pxe">PXE</button>
|
||||
<button class="btn" data-bootdev="disk">Disk</button>
|
||||
<span class="sep"></span>
|
||||
<button id="recommission" class="btn warn">Re-commission</button>
|
||||
<button id="recommission-now" class="btn warn" title="remove per-MAC PXE config, set bootdev pxe and power-cycle via BMC">Re-commission now</button>
|
||||
<button id="delete" class="btn danger">Delete</button>
|
||||
<span id="action-out" class="mono"></span>
|
||||
</div>
|
||||
<div id="d-body" class="grid"></div>
|
||||
<details><summary>Raw JSON</summary><pre id="d-json" class="mono"></pre></details>
|
||||
</section>
|
||||
</main>
|
||||
<script src="app.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,53 @@
|
||||
:root {
|
||||
--bg: #f6f7f9; --panel: #ffffff; --fg: #1d2129; --muted: #6b7280; --line: #e3e6ea;
|
||||
--accent: #2563eb; --accent-fg: #ffffff; --warn: #b45309; --danger: #b91c1c; --ok: #15803d;
|
||||
--pill: #e8eefc; --hover: #f0f4ff; --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
|
||||
}
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root:not([data-theme="light"]) {
|
||||
--bg: #0f1216; --panel: #171b21; --fg: #e6e8eb; --muted: #9aa3ad; --line: #2a3139;
|
||||
--accent: #3b82f6; --pill: #1e2a44; --hover: #1b2230; --warn: #f59e0b; --danger: #ef4444; --ok: #22c55e;
|
||||
}
|
||||
}
|
||||
:root[data-theme="dark"] {
|
||||
--bg: #0f1216; --panel: #171b21; --fg: #e6e8eb; --muted: #9aa3ad; --line: #2a3139;
|
||||
--accent: #3b82f6; --pill: #1e2a44; --hover: #1b2230; --warn: #f59e0b; --danger: #ef4444; --ok: #22c55e;
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body { margin: 0; background: var(--bg); color: var(--fg); font: 14px/1.45 system-ui, -apple-system, Segoe UI, Roboto, sans-serif; }
|
||||
header { display: flex; align-items: center; justify-content: space-between; padding: 12px 16px; border-bottom: 1px solid var(--line); background: var(--panel); position: sticky; top: 0; z-index: 2; gap: 12px; flex-wrap: wrap; }
|
||||
h1 { font-size: 18px; margin: 0; } h1 .sub { font-weight: 400; color: var(--muted); font-size: 13px; margin-left: 8px; }
|
||||
h2 { font-size: 16px; margin: 0; }
|
||||
main { padding: 16px; max-width: 1400px; margin: 0 auto; }
|
||||
.muted { color: var(--muted); } .mono { font-family: var(--mono); font-size: 12px; white-space: pre-wrap; }
|
||||
.btn { border: 1px solid var(--line); background: var(--panel); color: var(--fg); padding: 6px 10px; border-radius: 6px; cursor: pointer; font: inherit; font-size: 13px; }
|
||||
.btn:hover { background: var(--hover); } .btn.primary { background: var(--accent); color: var(--accent-fg); border-color: var(--accent); }
|
||||
.btn.ghost { border-color: transparent; } .btn.warn { color: var(--warn); } .btn.danger { color: var(--danger); }
|
||||
.btn:disabled { opacity: .5; cursor: progress; }
|
||||
.hdr-right { display: flex; gap: 8px; align-items: center; }
|
||||
.toolbar { display: flex; gap: 12px; align-items: center; margin-bottom: 10px; }
|
||||
input[type=search], input[type=password] { padding: 7px 10px; border: 1px solid var(--line); border-radius: 6px; background: var(--panel); color: var(--fg); font: inherit; min-width: 280px; }
|
||||
table { width: 100%; border-collapse: collapse; background: var(--panel); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; }
|
||||
th, td { padding: 8px 10px; text-align: left; border-bottom: 1px solid var(--line); white-space: nowrap; }
|
||||
th { font-weight: 600; color: var(--muted); font-size: 12px; text-transform: uppercase; letter-spacing: .03em; }
|
||||
th.num, td.num { text-align: right; font-variant-numeric: tabular-nums; }
|
||||
tbody tr { cursor: pointer; } tbody tr:hover { background: var(--hover); }
|
||||
.pill { display: inline-block; padding: 2px 8px; border-radius: 999px; background: var(--pill); font-size: 12px; }
|
||||
.pill.ready { color: var(--ok); } .pill.recommission, .pill.new { color: var(--warn); }
|
||||
.ok { color: var(--ok); } .bad { color: var(--danger); }
|
||||
.detail-head { display: flex; gap: 12px; align-items: center; margin-bottom: 10px; }
|
||||
.actions { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; padding: 10px; background: var(--panel); border: 1px solid var(--line); border-radius: 8px; margin-bottom: 14px; }
|
||||
.sep { width: 1px; height: 20px; background: var(--line); margin: 0 6px; }
|
||||
#action-out { margin-left: auto; color: var(--muted); max-width: 50%; }
|
||||
.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(420px, 1fr)); gap: 12px; }
|
||||
.card { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 12px; overflow: auto; }
|
||||
.card.wide { grid-column: 1 / -1; }
|
||||
.card h3 { margin: 0 0 8px; font-size: 13px; text-transform: uppercase; letter-spacing: .03em; color: var(--muted); }
|
||||
.kv { display: grid; grid-template-columns: max-content 1fr; gap: 3px 14px; }
|
||||
.kv dt { color: var(--muted); } .kv dd { margin: 0; word-break: break-all; }
|
||||
.card table { border: none; } .card th, .card td { padding: 4px 8px; font-size: 13px; }
|
||||
details { margin-top: 14px; } summary { cursor: pointer; color: var(--muted); }
|
||||
dialog { border: 1px solid var(--line); border-radius: 10px; background: var(--panel); color: var(--fg); padding: 20px; min-width: 360px; }
|
||||
dialog::backdrop { background: rgba(0,0,0,.45); } dialog menu { padding: 0; margin: 12px 0 0; display: flex; justify-content: flex-end; }
|
||||
dialog input { width: 100%; margin-top: 8px; }
|
||||
@media (max-width: 720px) { main { padding: 16px 16px; } .grid { grid-template-columns: 1fr; } input[type=search] { min-width: 0; width: 100%; } table { display: block; overflow-x: auto; } }
|
||||
Reference in new issue
Block a user