From e3d937320125a711c5a470171649b685a98fac9c Mon Sep 17 00:00:00 2001 From: Ilker Manap Date: Tue, 27 Oct 2026 20:00:51 +0100 Subject: [PATCH] Terminal console: bare `rollcall` in a terminal opens a full-screen UI (llmgw style) - Bubble Tea + lipgloss with the same frame as llmgw: title bar, sidebar, bordered panel, key line, dialog overlay; keyboard only - pages: overview, machines (filter, state filter, multi-select, bulk actions), machine detail, racks with elevation, jobs, events, tags, profiles, OS images - actions: power, boot device, deploy OS, assign/unassign, tags, location, re-commission, release, cancel job, delete; confirmation for destructive ones; per-machine results - connect screen when no server is configured; URL + token saved to ~/.config/rollcall/client.json (0600), also used by the CLI - batched runes outside text fields are handled key by key - rollcall tui -dump WxH renders one screen; first Go tests for rendering and keys - web: unnamed machines show their id instead of the live image's hostname Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 5 + README.md | 24 + cmd/rollcall/client.go | 12 +- cmd/rollcall/go.mod | 26 +- cmd/rollcall/go.sum | 47 +- cmd/rollcall/main.go | 20 +- cmd/rollcall/tui.go | 2015 +++++++++++++++++++++++++++++++++++++ cmd/rollcall/tui_frame.go | 362 +++++++ cmd/rollcall/tui_test.go | 158 +++ cmd/rollcall/web/app.js | 2 +- 10 files changed, 2662 insertions(+), 9 deletions(-) create mode 100644 cmd/rollcall/tui.go create mode 100644 cmd/rollcall/tui_frame.go create mode 100644 cmd/rollcall/tui_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 2d8a864..2993c84 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,11 @@ publish a tag that has no section here. CSV import matched by id/serial/MAC/node name with dry run, rack definitions with height, `list -rack/-room/-building`, location column and chips in the UI, Racks page with elevation views, bulk "Set location…", `.Node.Rack` etc. in templates and tag rules. +- Terminal console: a bare `rollcall` in a terminal opens a full-screen UI in the llmgw style + (Bubble Tea): overview, machines with filter/selection/bulk actions, machine detail, racks + with elevation, jobs, events, tags, profiles, OS images; connect screen that saves + `~/.config/rollcall/client.json`, which the CLI also reads; `rollcall tui -dump` renders one + screen. First Go tests (console rendering and keys). - `rollcall version`; CD-built binary carries `git describe`. - Release notes from `CHANGELOG.md`. diff --git a/README.md b/README.md index 00d51ca..5d6332a 100644 --- a/README.md +++ b/README.md @@ -72,6 +72,30 @@ cd deploy && sudo ./install.sh command line baked into generated PXE files), `bmc_hints` (out-of-band BMC mapping for machines without in-band IPMI, e.g. VMs). +### Console (same binary) + +A bare `rollcall` in a terminal opens a full-screen console, built like the +llmgw one (Bubble Tea): the fleet down the left (Overview, Machines, Racks, +Jobs, Events) and provisioning (Tags, Profiles, OS images), the chosen page on +the right, keys along the bottom. It is keyboard only, so it works on serial +consoles and BMC KVMs. + +* Machines: `/` filter (name, serial, MAC, IP, rack, tag), `s` cycles the state + filter, `Space` selects, `*` selects everything shown, `Enter` opens a + machine, `a` opens the actions for the selection or the current row: power, + boot device, deploy OS, assign/unassign profile, tags, location, + re-commission, release, cancel job, delete. Destructive ones ask first. +* Racks: `Enter` shows the elevation; `Enter` on a unit opens that machine. +* Jobs and events open the machine they belong to; tags, profiles and OS + images show their definition. `r` refreshes (it also refreshes on its own, + every 3 s while a job runs), `?` lists the keys, `q` quits. + +On the server as root it reads `/etc/rollcall/config.json`. Anywhere else it +asks for the server URL and admin token once and keeps them in +`~/.config/rollcall/client.json` (mode 0600), which the CLI then uses as well. +In a pipe or a script a bare `rollcall` prints its help as before. +`rollcall tui -dump 140x40 -page machines -plain` renders one screen to stdout. + ### CLI (same binary) ```sh diff --git a/cmd/rollcall/client.go b/cmd/rollcall/client.go index 59c5b31..65a460d 100644 --- a/cmd/rollcall/client.go +++ b/cmd/rollcall/client.go @@ -32,7 +32,17 @@ func newClient() (*client, error) { } } if base == "" || token == "" { - return nil, fmt.Errorf("set ROLLCALL_URL and ROLLCALL_TOKEN (or make the config file readable)") + if cc, ok := loadClientConf(); ok { + if base == "" { + base = cc.URL + } + if token == "" { + token = cc.Token + } + } + } + if base == "" || token == "" { + return nil, fmt.Errorf("set ROLLCALL_URL and ROLLCALL_TOKEN, make the server config readable, or run rollcall in a terminal to connect") } return &client{base: strings.TrimRight(base, "/"), token: token, http: &http.Client{Timeout: 90 * time.Second}}, nil } diff --git a/cmd/rollcall/go.mod b/cmd/rollcall/go.mod index f8534e4..7a9253a 100644 --- a/cmd/rollcall/go.mod +++ b/cmd/rollcall/go.mod @@ -1,18 +1,38 @@ module rollcall -go 1.24 +go 1.24.2 require ( + github.com/charmbracelet/bubbletea v1.3.10 + github.com/charmbracelet/lipgloss v1.1.0 + github.com/charmbracelet/x/ansi v0.11.6 github.com/jackc/pgx/v5 v5.7.5 + github.com/klauspost/compress v1.18.0 + github.com/mattn/go-isatty v0.0.24 golang.org/x/crypto v0.37.0 ) require ( + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/charmbracelet/colorprofile v0.4.1 // indirect + github.com/charmbracelet/x/cellbuf v0.0.15 // indirect + github.com/charmbracelet/x/term v0.2.2 // indirect + github.com/clipperhouse/displaywidth v0.9.0 // indirect + github.com/clipperhouse/stringish v0.1.1 // indirect + github.com/clipperhouse/uax29/v2 v2.5.0 // indirect + github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect 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 - github.com/klauspost/compress v1.18.0 // indirect + github.com/lucasb-eyer/go-colorful v1.3.0 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.19 // indirect + github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/termenv v0.16.0 // indirect + github.com/rivo/uniseg v0.4.7 // indirect + github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect golang.org/x/sync v0.13.0 // indirect - golang.org/x/sys v0.32.0 // indirect + golang.org/x/sys v0.38.0 // indirect golang.org/x/text v0.24.0 // indirect ) diff --git a/cmd/rollcall/go.sum b/cmd/rollcall/go.sum index abe7afa..cb36d11 100644 --- a/cmd/rollcall/go.sum +++ b/cmd/rollcall/go.sum @@ -1,6 +1,28 @@ +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw= +github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4= +github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk= +github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk= +github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY= +github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30= +github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8= +github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ= +github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI= +github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q= +github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk= +github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI= +github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA= +github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA= +github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs= +github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA= +github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U= +github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g= 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/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4= +github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM= 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= @@ -11,19 +33,40 @@ 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/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag= +github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= +github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw= +github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= +github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= 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/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= 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= +github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= +github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= 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/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI= +golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo= golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610= golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= -golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20= -golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc= +golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o= golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw= golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0= diff --git a/cmd/rollcall/main.go b/cmd/rollcall/main.go index 26d7f11..5c0a455 100644 --- a/cmd/rollcall/main.go +++ b/cmd/rollcall/main.go @@ -24,6 +24,8 @@ var version = "dev" func usage() { _, _ = os.Stderr.WriteString(`usage: + rollcall in a terminal: the full-screen console + rollcall tui [-dump WxH -page P -machine ID -plain] rollcall serve [-config PATH] rollcall version rollcall keygen @@ -51,7 +53,8 @@ func usage() { rollcall location racks | rack NAME -building B -room R [-height 42] rollcall list [-tag T] [-building B] [-room R] [-rack K] (deploy, power and location take tag:NAME instead of ID to act on every machine with that tag) -env: ROLLCALL_URL (default from config listen), ROLLCALL_TOKEN, ROLLCALL_CONFIG +env: ROLLCALL_URL (default from config listen), ROLLCALL_TOKEN, ROLLCALL_CONFIG; + away from the server the console saves URL and token in ~/.config/rollcall/client.json `) os.Exit(2) } @@ -61,10 +64,23 @@ func newFlags(name string) *flag.FlagSet { return flag.NewFlagSet(name, flag.Exi func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) if len(os.Args) < 2 { - usage() + // A bare `rollcall` in a terminal opens the console; in a pipe or a + // script it prints its help, as it always did. + if !interactive() { + usage() + } + if err := runTUI(); err != nil { + log.Fatal(err) + } + return } cmd, args := os.Args[1], os.Args[2:] switch cmd { + case "tui", "console": + if err := tuiDump(args); err != nil { + fmt.Fprintln(os.Stderr, "error:", err) + os.Exit(1) + } case "serve": fs := flag.NewFlagSet("serve", flag.ExitOnError) cfg := fs.String("config", envOr("ROLLCALL_CONFIG", "/etc/rollcall/config.json"), "config file") diff --git a/cmd/rollcall/tui.go b/cmd/rollcall/tui.go new file mode 100644 index 0000000..2416a8e --- /dev/null +++ b/cmd/rollcall/tui.go @@ -0,0 +1,2015 @@ +package main + +// The console: what a bare `rollcall` opens in a terminal. Down the left the +// fleet (overview, machines, racks, jobs, events) and provisioning (tags, +// profiles, OS images); on the right the chosen page, with the same actions as +// the web UI behind `a`. It talks to the server's API like the CLI does, so it +// runs on the server, on a jump host or on a laptop. Anywhere that is not a +// terminal, a bare `rollcall` prints its help as before. + +import ( + "encoding/json" + "errors" + "fmt" + "net/http" + "net/url" + "os" + "path/filepath" + "sort" + "strconv" + "strings" + "time" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/x/ansi" + "github.com/mattn/go-isatty" +) + +func interactive() bool { + return isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stdin.Fd()) && os.Getenv("TERM") != "dumb" +} + +// ---------------------------------------------------------------- client config away from the server + +type clientConf struct { + URL string `json:"url"` + Token string `json:"token"` +} + +func clientConfPath() string { + base := os.Getenv("XDG_CONFIG_HOME") + if base == "" { + home, _ := os.UserHomeDir() + base = filepath.Join(home, ".config") + } + return filepath.Join(base, "rollcall", "client.json") +} + +func loadClientConf() (clientConf, bool) { + var c clientConf + b, err := os.ReadFile(clientConfPath()) + if err != nil || json.Unmarshal(b, &c) != nil || c.URL == "" || c.Token == "" { + return c, false + } + return c, true +} + +func saveClientConf(c clientConf) error { + p := clientConfPath() + if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil { + return err + } + b, _ := json.MarshalIndent(c, "", " ") + return os.WriteFile(p, append(b, '\n'), 0o600) +} + +// ---------------------------------------------------------------- data + +const ( + pOverview = iota + pMachines + pRacks + pJobs + pEvents + pTags + pProfiles + pImages + pCount +) + +var pageLabels = [pCount]string{"Overview", "Machines", "Racks", "Jobs", "Events", "Tags", "Profiles", "OS images"} +var pageNames = [pCount]string{"overview", "machines", "racks", "jobs", "events", "tags", "profiles", "images"} + +type tuiData struct { + machines []Summary + racks []Rack + jobs []*Job + events []MachineEvent + tags []TagDef + profiles []Profile + os []OSImage + at time.Time +} + +type machineDetail struct { + Summary Summary `json:"summary"` + BMC obj `json:"bmc"` + HasBMCSecret bool `json:"has_bmc_secret"` + Inventory obj `json:"inventory"` + Events []Event `json:"events"` + Jobs []*Job `json:"jobs"` +} + +type ( + tuiDataMsg struct { + d tuiData + detail *machineDetail + detailID string + err error + } + tuiTickMsg struct{ gen int } + tuiResultMsg struct{ title, text string } + tuiConnectMsg struct { + c *client + err error + } +) + +// ---------------------------------------------------------------- dialogs + +const ( + fkChoice = iota + fkText + fkToggle +) + +type dlgField struct { + label string + kind int + opts []string // what is shown + vals []string // what is submitted (opts when nil) + idx int + text textField + on bool +} + +func (f dlgField) value() string { + switch f.kind { + case fkChoice: + if f.idx < len(f.vals) { + return f.vals[f.idx] + } + if f.idx < len(f.opts) { + return f.opts[f.idx] + } + case fkText: + return strings.TrimSpace(f.text.Value()) + case fkToggle: + if f.on { + return "1" + } + } + return "" +} + +type menuItem struct { + label string + sep bool // a gap before it + danger bool + run func(m tuiModel) (tuiModel, tea.Cmd) +} + +// tuiDialog is one of: a menu, a form, a yes/no question, or text to read. +type tuiDialog struct { + title string + note string + menu []menuItem + fields []dlgField + confirm string + info string + focus int + okLabel string + onOK func(m tuiModel, f []dlgField) (tuiModel, tea.Cmd) + onYes func(m tuiModel) (tuiModel, tea.Cmd) +} + +func (d *tuiDialog) setFocus(i int) { + for j := range d.fields { + d.fields[j].text.Blur() + } + d.focus = i + if i < len(d.fields) && d.fields[i].kind == fkText { + d.fields[i].text.Focus() + } +} + +func field(fs []dlgField, label string) string { + for _, f := range fs { + if f.label == label { + return f.value() + } + } + return "" +} + +func textInput(label, value, placeholder string) dlgField { + t := newTextField() + t.SetValue(value) + t.Placeholder = placeholder + return dlgField{label: label, kind: fkText, text: t} +} + +func (d *tuiDialog) render(width int) string { + var b strings.Builder + if d.note != "" { + b.WriteString(wrap(d.note, width, "") + "\n\n") + } + switch { + case d.info != "": + b.WriteString(d.info + "\n\n" + sDim.Render("any key closes")) + case d.confirm != "": + b.WriteString(wrap(d.confirm, width, "") + "\n\n" + sDim.Render("Y yes · N no")) + case d.menu != nil: + for i, it := range d.menu { + if it.sep && i > 0 { + b.WriteString("\n") + } + l := it.label + if it.danger { + l = sBad.Render(l) + } + if i == d.focus { + b.WriteString(fSelected.Render("› " + it.label)) + } else { + b.WriteString(" " + l) + } + b.WriteString("\n") + } + b.WriteString("\n" + sDim.Render("↑↓ choose · Enter · Esc cancel")) + default: + lw := 8 + for _, f := range d.fields { + lw = max(lw, len(f.label)+2) + } + for i, f := range d.fields { + label := fmt.Sprintf("%-*s", lw, f.label) + if i == d.focus { + label = fSelected.Render(label) + } else { + label = sDim.Render(label) + } + var v string + switch f.kind { + case fkChoice: + opt := "" + if f.idx < len(f.opts) { + opt = f.opts[f.idx] + } + v = "‹ " + opt + " ›" + if i == d.focus { + v = fSelected.Render(v) + } + case fkText: + v = f.text.View() + case fkToggle: + v = "[ ]" + if f.on { + v = "[x]" + } + if i == d.focus { + v = fSelected.Render(v) + } + } + b.WriteString(label + v + "\n") + } + ok := d.okLabel + if ok == "" { + ok = "OK" + } + b.WriteString("\n" + sDim.Render("Tab/↑↓ field · ←→ choose · Space toggle · Enter "+ok+" · Esc cancel")) + } + return b.String() +} + +// ---------------------------------------------------------------- model + +type tuiModel struct { + c *client + w, h int + spin spinnerModel + d tuiData + loaded bool + err error + fetching bool + gen int + + menu int + inPanel bool + row int + scroll int + + sel map[string]bool + filter textField + filtering bool + stateF string + + detailID string + detail *machineDetail + rackOpen int // index into racks(), -1 = the list + rackRow int + + dlg *tuiDialog + busy string + + connect bool + cURL textField + cTok textField + cFocus int + cErr string +} + +func newTUIModel(c *client) tuiModel { + m := tuiModel{c: c, sel: map[string]bool{}, rackOpen: -1, menu: pOverview} + m.filter = newTextField() + m.filter.Placeholder = "name, serial, MAC, IP, rack, tag…" + return m +} + +func (m tuiModel) Init() tea.Cmd { + if m.connect { + return nil + } + return m.fetch() +} + +func (m tuiModel) fetch() tea.Cmd { + c, id := m.c, m.detailID + return func() tea.Msg { + var d tuiData + var err error + get := func(p string, v any) { + if err == nil { + err = c.do("GET", p, nil, v) + } + } + get("/api/v1/machines", &d.machines) + get("/api/v1/racks", &d.racks) + get("/api/v1/jobs", &d.jobs) + get("/api/v1/events", &d.events) + get("/api/v1/tags", &d.tags) + get("/api/v1/profiles", &d.profiles) + get("/api/v1/os", &d.os) + d.at = time.Now() + var det *machineDetail + if id != "" && err == nil { + det = &machineDetail{} + if e := c.do("GET", "/api/v1/machines/"+id, nil, det); e != nil { + det = nil + } + } + return tuiDataMsg{d: d, detail: det, detailID: id, err: err} + } +} + +// tick schedules the next refresh: fast while something is moving. +func (m *tuiModel) tick() tea.Cmd { + m.gen++ + g := m.gen + iv := 10 * time.Second + for _, s := range m.d.machines { + if s.Job != nil || s.State == "deploying" || s.State == "releasing" { + iv = 3 * time.Second + break + } + } + return tea.Tick(iv, func(time.Time) tea.Msg { return tuiTickMsg{g} }) +} + +func (m tuiModel) refresh() (tuiModel, tea.Cmd) { + m.fetching = true + return m, m.fetch() +} + +func (m tuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case tea.WindowSizeMsg: + m.w, m.h = msg.Width, msg.Height + case spinTickMsg: + if m.busy == "" && !(m.detailID != "" && m.detail == nil) { + return m, nil + } + var cmd tea.Cmd + m.spin, cmd = m.spin.Update(msg) + return m, cmd + case tuiDataMsg: + m.fetching = false + if msg.err != nil { + m.err = msg.err + } else { + m.err, m.d, m.loaded = nil, msg.d, true + } + if msg.detail != nil && msg.detailID == m.detailID { + m.detail = msg.detail + } + m.clamp() + return m, m.tick() + case tuiTickMsg: + if msg.gen != m.gen { + return m, nil + } + if m.busy != "" || m.fetching { + return m, m.tick() + } + mm, cmd := m.refresh() + return mm, cmd + case tuiResultMsg: + m.busy = "" + m.dlg = &tuiDialog{title: msg.title, info: msg.text} + mm, cmd := m.refresh() + return mm, cmd + case tuiConnectMsg: + m.busy = "" + if msg.err != nil { + m.cErr = msg.err.Error() + return m, nil + } + if err := saveClientConf(clientConf{URL: msg.c.base, Token: msg.c.token}); err != nil { + m.cErr = "connected, but could not save " + clientConfPath() + ": " + err.Error() + } + m.c, m.connect = msg.c, false + mm, cmd := m.refresh() + return mm, cmd + case tea.KeyMsg: + return m.key(msg) + } + return m, nil +} + +// ---------------------------------------------------------------- keys + +// textInput says a text field has the keys: typed runes go there whole. +func (m tuiModel) textInput() bool { + return m.connect || m.filtering || (m.dlg != nil && m.dlg.menu == nil && m.dlg.confirm == "" && m.dlg.info == "" && + m.dlg.focus < len(m.dlg.fields) && m.dlg.fields[m.dlg.focus].kind == fkText) +} + +func (m tuiModel) key(k tea.KeyMsg) (tea.Model, tea.Cmd) { + // Keys typed faster than the screen reads them (a paste, a slow link) + // arrive as one message with several runes; outside a text field each is + // a key of its own. + if k.Type == tea.KeyRunes && len(k.Runes) > 1 && !k.Paste && !m.textInput() { + var cmds []tea.Cmd + var mm tea.Model = m + for _, r := range k.Runes { + var cmd tea.Cmd + mm, cmd = mm.(tuiModel).key(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}) + cmds = append(cmds, cmd) + } + return mm, tea.Batch(cmds...) + } + s := k.String() + if s == "ctrl+c" { + return m, tea.Quit + } + if m.connect { + return m.connectKey(k) + } + if m.dlg != nil { + return m.dialogKey(k) + } + if m.busy != "" { + return m, nil + } + if m.filtering { + switch s { + case "enter": + m.filtering = false + m.filter.Blur() + case "esc": + m.filtering = false + m.filter.Blur() + m.filter.SetValue("") + default: + m.filter, _ = m.filter.Update(k) + m.row = 0 + } + return m, nil + } + switch s { + case "q": + return m, tea.Quit + case "r": + mm, cmd := m.refresh() + return mm, cmd + case "?": + m.dlg = &tuiDialog{title: "Keys", info: helpText} + return m, nil + } + if !m.inPanel { + switch s { + case "up", "k": + m.menu = (m.menu - 1 + pCount) % pCount + case "down", "j": + m.menu = (m.menu + 1) % pCount + case "enter", "right", "l", "tab": + m.inPanel, m.row, m.scroll, m.rackOpen = true, 0, 0, -1 + } + return m, nil + } + + // a machine is open + if m.detailID != "" { + switch s { + case "esc", "left", "h", "backspace": + m.detailID, m.detail, m.scroll = "", nil, 0 + case "a": + if m.detail != nil { + m.dlg = m.actionMenu([]string{m.detailID}) + } + default: + m.scrollKey(s) + } + return m, nil + } + + switch m.menu { + case pOverview: + switch s { + case "esc", "left", "h": + m.inPanel = false + default: + m.scrollKey(s) + } + return m, nil + case pRacks: + if m.rackOpen >= 0 { + racks := m.racks() + if m.rackOpen >= len(racks) { + m.rackOpen = -1 + return m, nil + } + height := rackHeight(racks[m.rackOpen]) + switch s { + case "esc", "left", "h": + m.rackOpen = -1 + case "up", "k": + m.rackRow = max(0, m.rackRow-1) + case "down", "j": + m.rackRow = min(height-1, m.rackRow+1) + case "pgup": + m.rackRow = max(0, m.rackRow-10) + case "pgdown": + m.rackRow = min(height-1, m.rackRow+10) + case "enter": + if s, ok := m.rackSlots(racks[m.rackOpen])[height-m.rackRow]; ok { + return m.open(s.ID) + } + } + return m, nil + } + } + + n := m.rowCount() + switch s { + case "esc", "left", "h": + if m.menu == pMachines && (len(m.sel) > 0 || m.filter.Value() != "" || m.stateF != "") { + m.sel, m.stateF = map[string]bool{}, "" + m.filter.SetValue("") + return m, nil + } + m.inPanel = false + case "up", "k": + m.row = max(0, m.row-1) + case "down", "j": + m.row = min(max(0, n-1), m.row+1) + case "pgup": + m.row = max(0, m.row-10) + case "pgdown": + m.row = min(max(0, n-1), m.row+10) + case "home", "g": + m.row = 0 + case "end", "G": + m.row = max(0, n-1) + case "enter": + return m.enter() + } + if m.menu == pMachines { + ms := m.filtered() + switch s { + case " ": + if m.row < len(ms) { + id := ms[m.row].ID + if m.sel[id] { + delete(m.sel, id) + } else { + m.sel[id] = true + } + m.row = min(len(ms)-1, m.row+1) + } + case "*": + all := len(ms) > 0 + for _, x := range ms { + all = all && m.sel[x.ID] + } + for _, x := range ms { + if all { + delete(m.sel, x.ID) + } else { + m.sel[x.ID] = true + } + } + case "/": + m.filtering = true + m.filter.Focus() + case "s": + m.stateF = nextState(m.d.machines, m.stateF) + m.row = 0 + case "a": + var ids []string + for _, x := range m.d.machines { + if m.sel[x.ID] { + ids = append(ids, x.ID) + } + } + if len(ids) == 0 && m.row < len(ms) { + ids = []string{ms[m.row].ID} + } + if len(ids) > 0 { + m.dlg = m.actionMenu(ids) + } + } + } + return m, nil +} + +func (m *tuiModel) scrollKey(s string) { + switch s { + case "up", "k": + m.scroll-- + case "down", "j": + m.scroll++ + case "pgup": + m.scroll -= 10 + case "pgdown": + m.scroll += 10 + case "home", "g": + m.scroll = 0 + } + _, body, _, _ := m.panel() + lines := strings.Count(strings.TrimRight(body, "\n"), "\n") + 1 + m.scroll = min(max(0, m.scroll), max(0, lines-(m.h-4))) +} + +func (m tuiModel) enter() (tea.Model, tea.Cmd) { + switch m.menu { + case pMachines: + if ms := m.filtered(); m.row < len(ms) { + return m.open(ms[m.row].ID) + } + case pRacks: + if m.row < len(m.racks()) { + m.rackOpen, m.rackRow = m.row, 0 + } + case pJobs: + if m.row < len(m.d.jobs) { + return m.open(m.d.jobs[m.row].MachineID) + } + case pEvents: + if m.row < len(m.d.events) { + return m.open(m.d.events[m.row].MachineID) + } + case pTags: + if m.row < len(m.d.tags) { + t := m.d.tags[m.row] + cc := t.CloudConfig + if cc == "" { + cc = sDim.Render("(no cloud-config fragment)") + } + m.dlg = &tuiDialog{title: "Tag " + t.Name, info: fmt.Sprintf("%s\nmatch: %s\noverlays: %s\nmachines: %d\n\n%s", + t.Comment, orDash(t.Match), orDash(strings.Join(t.Overlays, ", ")), t.Machines, limitLines(cc, 30))} + } + case pProfiles: + if m.row < len(m.d.profiles) { + p := m.d.profiles[m.row] + vb, _ := json.MarshalIndent(p.Vars, "", " ") + m.dlg = &tuiDialog{title: "Profile " + p.Name, info: fmt.Sprintf("image: %s\noverlays: %s\nname format: %s\nappend: %s\nvars:\n%s", + p.Image, orDash(strings.Join(p.Overlays, ", ")), p.NameFormat, orDash(p.Append), string(vb))} + } + case pImages: + if m.row < len(m.d.os) { + i := m.d.os[m.row] + var b strings.Builder + if i.Source != nil { + fmt.Fprintf(&b, "%s\nsource: %s\ntrack %s · keep %d\n\n", i.Source.Description, i.Source.URL, i.Source.Track, i.Source.Keep) + } + for _, v := range i.Versions { + cur := " " + if v.Current { + cur = sOK.Render("● ") + } + fmt.Fprintf(&b, "%s%-18s %7s → %7s imported %s\n", cur, v.Version, human(float64(v.Size)), human(float64(v.RawSize)), v.Imported.Local().Format("2006-01-02 15:04")) + } + if len(i.Versions) == 0 { + b.WriteString(sDim.Render("no versions imported — rollcall os sync " + i.Name)) + } + m.dlg = &tuiDialog{title: "OS image " + i.Name, info: strings.TrimRight(b.String(), "\n")} + } + } + return m, nil +} + +func (m tuiModel) open(id string) (tea.Model, tea.Cmd) { + m.detailID, m.detail, m.scroll = id, nil, 0 + m.fetching = true + return m, tea.Batch(m.fetch(), m.spin.Tick) +} + +func (m tuiModel) dialogKey(k tea.KeyMsg) (tea.Model, tea.Cmd) { + d := m.dlg + s := k.String() + switch { + case d.info != "": + m.dlg = nil + return m, nil + case d.confirm != "": + switch s { + case "y", "Y", "enter": + yes := d.onYes + m.dlg = nil + mm, cmd := yes(m) + return mm, cmd + case "n", "N", "esc", "q": + m.dlg = nil + } + return m, nil + case d.menu != nil: + switch s { + case "up", "k": + d.focus = (d.focus - 1 + len(d.menu)) % len(d.menu) + case "down", "j": + d.focus = (d.focus + 1) % len(d.menu) + case "enter": + it := d.menu[d.focus] + m.dlg = nil + mm, cmd := it.run(m) + return mm, cmd + case "esc", "q", "left": + m.dlg = nil + } + return m, nil + } + n := len(d.fields) + switch s { + case "esc": + m.dlg = nil + return m, nil + case "enter": + ok, f := d.onOK, d.fields + m.dlg = nil + mm, cmd := ok(m, f) + return mm, cmd + case "tab", "down": + d.setFocus((d.focus + 1) % n) + return m, nil + case "shift+tab", "up": + d.setFocus((d.focus - 1 + n) % n) + return m, nil + } + f := &d.fields[d.focus] + switch f.kind { + case fkChoice: + switch s { + case "left", "h": + f.idx = (f.idx - 1 + len(f.opts)) % max(1, len(f.opts)) + case "right", "l", " ": + f.idx = (f.idx + 1) % max(1, len(f.opts)) + } + case fkToggle: + if s == " " || s == "left" || s == "right" || s == "x" { + f.on = !f.on + } + case fkText: + f.text, _ = f.text.Update(k) + } + return m, nil +} + +// ---------------------------------------------------------------- actions + +// run does fn for every machine in the background and shows one line per machine. +func (m tuiModel) run(title string, ids []string, fn func(c *client, id string) (string, error)) (tuiModel, tea.Cmd) { + m.busy = title + c := m.c + names := map[string]string{} + for _, x := range m.d.machines { + names[x.ID] = sumName(x) + } + return m, tea.Batch(m.spin.Tick, func() tea.Msg { + var lines []string + for _, id := range ids { + name := names[id] + if name == "" { + name = id + } + out, err := fn(c, id) + if err != nil { + lines = append(lines, sBad.Render("✗ ")+name+" "+oneLine(err.Error())) + } else { + lines = append(lines, sOK.Render("✓ ")+name+" "+oneLine(out)) + } + } + return tuiResultMsg{title: title, text: strings.Join(lines, "\n")} + }) +} + +func oneLine(s string) string { + s = strings.Join(strings.Fields(strings.ReplaceAll(s, "\n", " · ")), " ") + if len(s) > 100 { + s = s[:99] + "…" + } + return s +} + +func apiPost(path string, body any, pick func(obj) string) func(*client, string) (string, error) { + return func(c *client, id string) (string, error) { + var d obj + if err := c.do("POST", "/api/v1/machines/"+id+path, body, &d); err != nil { + return "", err + } + if ok, has := d["ok"].(bool); has && !ok { + return "", errors.New(str(d["output"])) + } + return pick(d), nil + } +} + +func outputOf(d obj) string { return str(d["output"]) } + +func (m tuiModel) ask(title, q string, yes func(tuiModel) (tuiModel, tea.Cmd)) (tuiModel, tea.Cmd) { + m.dlg = &tuiDialog{title: title, confirm: q, onYes: yes} + return m, nil +} + +func (m tuiModel) who(ids []string) string { + if len(ids) == 1 { + for _, x := range m.d.machines { + if x.ID == ids[0] { + return sumName(x) + } + } + return ids[0] + } + return fmt.Sprintf("%d machines", len(ids)) +} + +func (m tuiModel) actionMenu(ids []string) *tuiDialog { + who := m.who(ids) + power := func(action string, danger bool) func(tuiModel) (tuiModel, tea.Cmd) { + do := func(m tuiModel) (tuiModel, tea.Cmd) { + return m.run("power "+action, ids, apiPost("/power", obj{"action": action}, outputOf)) + } + if !danger { + return do + } + return func(m tuiModel) (tuiModel, tea.Cmd) { + return m.ask("Power "+action, fmt.Sprintf("Power %s %s through the BMC?", action, who), do) + } + } + boot := func(dev string) func(tuiModel) (tuiModel, tea.Cmd) { + return func(m tuiModel) (tuiModel, tea.Cmd) { + return m.run("boot device "+dev, ids, apiPost("/bootdev", obj{"device": dev}, outputOf)) + } + } + return &tuiDialog{title: "Actions · " + who, menu: []menuItem{ + {label: "Power on", run: power("on", false)}, + {label: "Power off", run: power("off", true)}, + {label: "Soft off (ACPI)", run: power("soft", true)}, + {label: "Power cycle", run: power("cycle", true)}, + {label: "Reset", run: power("reset", true)}, + {label: "Power status", run: power("status", false)}, + {label: "Boot device: PXE", sep: true, run: boot("pxe")}, + {label: "Boot device: disk", run: boot("disk")}, + {label: "Deploy OS…", sep: true, run: func(m tuiModel) (tuiModel, tea.Cmd) { return m.deployDialog(ids) }}, + {label: "Assign stateless profile…", run: func(m tuiModel) (tuiModel, tea.Cmd) { return m.assignDialog(ids) }}, + {label: "Unassign profile", run: func(m tuiModel) (tuiModel, tea.Cmd) { + return m.ask("Unassign", "Remove the stateless profile from "+who+"? Names and IPs are released.", func(m tuiModel) (tuiModel, tea.Cmd) { + return m.run("unassign", ids, apiPost("/unassign", nil, func(d obj) string { return "state " + str(d["state"]) })) + }) + }}, + {label: "Tags…", sep: true, run: func(m tuiModel) (tuiModel, tea.Cmd) { return m.tagDialog(ids) }}, + {label: "Location…", run: func(m tuiModel) (tuiModel, tea.Cmd) { return m.locationDialog(ids) }}, + {label: "Re-commission on next boot", sep: true, run: func(m tuiModel) (tuiModel, tea.Cmd) { + return m.run("recommission", ids, apiPost("/recommission", nil, func(d obj) string { return "state " + str(d["state"]) })) + }}, + {label: "Re-commission now (BMC)", run: func(m tuiModel) (tuiModel, tea.Cmd) { + return m.ask("Re-commission now", "Set boot device PXE and power-cycle "+who+" into commissioning?", func(m tuiModel) (tuiModel, tea.Cmd) { + return m.run("recommission now", ids, apiPost("/recommission?now=1", nil, func(d obj) string { return str(d["ipmi"]) })) + }) + }}, + {label: "Release (wipe disk)…", run: func(m tuiModel) (tuiModel, tea.Cmd) { return m.releaseDialog(ids) }}, + {label: "Cancel active job", run: func(m tuiModel) (tuiModel, tea.Cmd) { + return m.run("cancel job", ids, apiPost("/jobs/cancel", nil, func(d obj) string { return "job " + str(d["job"]) + " cancelled" })) + }}, + {label: "Delete record", sep: true, danger: true, run: func(m tuiModel) (tuiModel, tea.Cmd) { + return m.ask("Delete", "Delete "+who+"? They are commissioned again as new machines on their next PXE boot.", func(m tuiModel) (tuiModel, tea.Cmd) { + m.detailID, m.detail = "", nil + for _, id := range ids { + delete(m.sel, id) + } + return m.run("delete", ids, func(c *client, id string) (string, error) { + return "deleted", c.do("DELETE", "/api/v1/machines/"+id, nil, nil) + }) + }) + }}, + }} +} + +func (m tuiModel) deployDialog(ids []string) (tuiModel, tea.Cmd) { + var opts, vals []string + for _, i := range m.d.os { + if i.Current != nil { + opts = append(opts, fmt.Sprintf("%s %s (%s)", i.Name, i.Current.Version, human(float64(i.Current.RawSize)))) + vals = append(vals, i.Name) + } + } + if len(opts) == 0 { + m.dlg = &tuiDialog{title: "Deploy", info: "No OS image has a current version.\nImport or sync one first: rollcall os sync"} + return m, nil + } + fields := []dlgField{{label: "OS image", kind: fkChoice, opts: opts, vals: vals}} + if len(ids) == 1 { + dopts, dvals := []string{"auto: smallest disk that fits"}, []string{""} + if m.detail != nil && m.detail.Summary.ID == ids[0] { + for _, dv := range toList(dig(m.detail.Inventory, "storage", "disks")) { + d, _ := dv.(obj) + p := str(d["path"]) + if p == "" { + p = "/dev/" + str(d["name"]) + } + dopts = append(dopts, fmt.Sprintf("%s %s %s", str(d["name"]), human(num(d["size"])), str(d["model"]))) + dvals = append(dvals, p) + } + } + name := "" + for _, x := range m.d.machines { + if x.ID == ids[0] { + name = deref(x.NodeName) + } + } + fields = append(fields, dlgField{label: "Target disk", kind: fkChoice, opts: dopts, vals: dvals}, textInput("Hostname", name, "auto")) + } + fields = append(fields, dlgField{label: "Upgrade on first boot", kind: fkToggle}, dlgField{label: "Power-cycle now", kind: fkToggle, on: true}) + note := "The target disk is wiped. Cloud-config fragments of the machine's tags are applied." + if len(ids) == 1 && (m.detail == nil || m.detail.Summary.ID != ids[0]) { + note += " Open the machine first to pick a disk." + } + m.dlg = &tuiDialog{title: "Deploy OS · " + m.who(ids), note: note, fields: fields, okLabel: "deploy", + onOK: func(m tuiModel, f []dlgField) (tuiModel, tea.Cmd) { + req := obj{"os": field(f, "OS image"), "disk": field(f, "Target disk"), "hostname": field(f, "Hostname"), + "package_upgrade": field(f, "Upgrade on first boot") != "", "boot": field(f, "Power-cycle now") != ""} + return m.run("deploy "+str(req["os"]), ids, apiPost("/deploy", req, func(d obj) string { + return fmt.Sprintf("job %s → %s as %s", str(d["job"]), str(d["disk"]), str(d["hostname"])) + })) + }} + m.dlg.setFocus(0) + return m, nil +} + +func (m tuiModel) assignDialog(ids []string) (tuiModel, tea.Cmd) { + if len(m.d.profiles) == 0 { + m.dlg = &tuiDialog{title: "Assign", info: "No profiles defined yet: rollcall profile add …"} + return m, nil + } + var opts, vals []string + for _, p := range m.d.profiles { + opts = append(opts, p.Name+" ("+p.Image+")") + vals = append(vals, p.Name) + } + fields := []dlgField{{label: "Profile", kind: fkChoice, opts: opts, vals: vals}} + if len(ids) == 1 { + fields = append(fields, textInput("Node name", "", "auto")) + } + fields = append(fields, dlgField{label: "PXE boot now", kind: fkToggle, on: true}) + m.dlg = &tuiDialog{title: "Assign profile · " + m.who(ids), note: "The node boots the profile's image from RAM; the disk is not touched.", fields: fields, okLabel: "assign", + onOK: func(m tuiModel, f []dlgField) (tuiModel, tea.Cmd) { + req := obj{"profile": field(f, "Profile"), "name": field(f, "Node name"), "boot": field(f, "PXE boot now") != ""} + return m.run("assign "+str(req["profile"]), ids, apiPost("/assign", req, func(d obj) string { + return fmt.Sprintf("%s (%s)", str(d["name"]), str(d["mgmt_ip"])) + })) + }} + m.dlg.setFocus(0) + return m, nil +} + +func (m tuiModel) tagDialog(ids []string) (tuiModel, tea.Cmd) { + m.dlg = &tuiDialog{title: "Tags · " + m.who(ids), note: "Space separated. Auto tags (from match rules) cannot be removed here.", + fields: []dlgField{textInput("Add", "", "gpu rack-3"), textInput("Remove", "", "staging")}, okLabel: "apply", + onOK: func(m tuiModel, f []dlgField) (tuiModel, tea.Cmd) { + req := obj{"add": strings.Fields(field(f, "Add")), "remove": strings.Fields(field(f, "Remove"))} + return m.run("tags", ids, apiPost("/tags", req, func(d obj) string { + var t []string + for _, x := range toList(d["effective"]) { + t = append(t, str(x)) + } + return orDash(strings.Join(t, " ")) + })) + }} + m.dlg.setFocus(0) + return m, nil +} + +func (m tuiModel) locationDialog(ids []string) (tuiModel, tea.Cmd) { + var cur Location + if len(ids) == 1 { + for _, x := range m.d.machines { + if x.ID == ids[0] { + cur = x.Location + } + } + } + fields := []dlgField{textInput("Building", cur.Building, ""), textInput("Room", cur.Room, ""), textInput("Rack", cur.Rack, "")} + unit := "" + if cur.Unit > 0 { + unit = strconv.Itoa(cur.Unit) + } + if len(ids) == 1 { + fields = append(fields, textInput("Rack unit", unit, "lowest U"), textInput("Asset tag", cur.AssetTag, "")) + } else { + fields = append(fields, textInput("First rack unit", "", "optional: stacked upwards")) + } + m.dlg = &tuiDialog{title: "Location · " + m.who(ids), note: "Empty fields clear the value. A rack is created on first use (42U).", fields: fields, okLabel: "save", + onOK: func(m tuiModel, f []dlgField) (tuiModel, tea.Cmd) { + u, _ := strconv.Atoi(strings.TrimPrefix(strings.ToUpper(field(f, "First rack unit")), "U")) + next := u + return m.run("location", ids, func(c *client, id string) (string, error) { + req := obj{"building": field(f, "Building"), "room": field(f, "Room"), "rack": field(f, "Rack")} + if len(ids) == 1 { + n, _ := strconv.Atoi(strings.TrimPrefix(strings.ToUpper(field(f, "Rack unit")), "U")) + req["unit"], req["asset_tag"] = n, field(f, "Asset tag") + } else if next > 0 { + req["unit"] = next + next++ + } + var d struct { + Location Location `json:"location"` + } + if err := c.do("POST", "/api/v1/machines/"+id+"/location", req, &d); err != nil { + return "", err + } + return orDash(d.Location.String()), nil + }) + }} + m.dlg.setFocus(0) + return m, nil +} + +func (m tuiModel) releaseDialog(ids []string) (tuiModel, tea.Cmd) { + m.dlg = &tuiDialog{title: "Release · " + m.who(ids), note: "The OS disk is wiped and the machine returns to ready.", + fields: []dlgField{ + {label: "Wipe", kind: fkChoice, opts: []string{"quick: signatures + first/last 64 MiB", "full: discard or zero the whole disk"}, vals: []string{"quick", "full"}}, + {label: "Power-cycle now", kind: fkToggle, on: true}, + }, okLabel: "release", + onOK: func(m tuiModel, f []dlgField) (tuiModel, tea.Cmd) { + req := obj{"wipe": field(f, "Wipe"), "boot": field(f, "Power-cycle now") != ""} + return m.run("release", ids, apiPost("/release", req, func(d obj) string { return "job " + str(d["job"]) })) + }} + m.dlg.setFocus(0) + return m, nil +} + +// ---------------------------------------------------------------- connect screen + +func (m tuiModel) connectKey(k tea.KeyMsg) (tea.Model, tea.Cmd) { + if m.busy != "" { + return m, nil + } + switch k.String() { + case "esc": + return m, tea.Quit + case "tab", "down", "up", "shift+tab": + m.cFocus = 1 - m.cFocus + case "enter": + u := strings.TrimRight(strings.TrimSpace(m.cURL.Value()), "/") + if !strings.Contains(u, "://") { + u = "http://" + u + } + if _, err := url.Parse(u); err != nil || strings.TrimSpace(m.cTok.Value()) == "" { + m.cErr = "a server URL and the admin token are needed" + return m, nil + } + c := &client{base: u, token: strings.TrimSpace(m.cTok.Value()), http: &http.Client{Timeout: 90 * time.Second}} + m.busy, m.cErr = "connecting", "" + return m, tea.Batch(m.spin.Tick, func() tea.Msg { + return tuiConnectMsg{c: c, err: c.do("GET", "/api/v1/whoami", nil, nil)} + }) + default: + if m.cFocus == 0 { + m.cURL, _ = m.cURL.Update(k) + } else { + m.cTok, _ = m.cTok.Update(k) + } + } + if m.cFocus == 0 { + m.cURL.Focus() + m.cTok.Blur() + } else { + m.cTok.Focus() + m.cURL.Blur() + } + return m, nil +} + +func (m tuiModel) connectView() string { + host, _ := os.Hostname() + body := "\n" + wrap(" No rollcall server is configured for this user. On the server itself, run rollcall as root and it reads /etc/rollcall/config.json. From anywhere else, give the server's URL and its admin token; they are kept in "+clientConfPath()+" (mode 0600).", max(40, m.w-navWidth-10), " ") + + "\n\n" + wrap(" Installing a new server: see deploy/install.sh in the repository.", max(40, m.w-navWidth-10), " ") + var d strings.Builder + lab := func(i int, s string) string { + if m.cFocus == i { + return fSelected.Render(fmt.Sprintf("%-8s", s)) + } + return sDim.Render(fmt.Sprintf("%-8s", s)) + } + d.WriteString(lab(0, "Server") + m.cURL.View() + "\n") + d.WriteString(lab(1, "Token") + m.cTok.View() + "\n") + if m.busy != "" { + d.WriteString("\n" + m.spin.View() + " connecting…") + } else if m.cErr != "" { + d.WriteString("\n" + sBad.Render(wrap(m.cErr, 60, ""))) + } + d.WriteString("\n\n" + sDim.Render("Tab field · Enter connect · Esc quit")) + return frame{Width: m.w, Height: m.h, Title: "rollcall", Where: host, + Nav: []navItem{{Label: "Connect", State: "current"}}, PanelTitle: "Connect", Body: body, + Keys: "Tab field · Enter connect · Esc quit", Dialog: d.String(), DialogTitle: "rollcall server"}.render() +} + +// ---------------------------------------------------------------- view + +const helpText = `Sidebar ↑↓ page · Enter/→ open +Lists ↑↓ PgUp PgDn Home End · Enter open · Esc/← back +Machines Space select · * select all shown · / filter · s state + a actions (on the selection, or the current row) +Machine ↑↓ PgUp PgDn scroll · a actions · Esc back +Racks Enter elevation · ↑↓ unit · Enter open machine +Everywhere r refresh · ? keys · q quit` + +func (m tuiModel) View() string { + if m.w == 0 { + return "" + } + if m.connect { + return m.connectView() + } + where := strings.TrimPrefix(strings.TrimPrefix(m.c.base, "http://"), "https://") + if m.err != nil { + where = sBad.Render("! "+oneLine(m.err.Error())) + " · " + where + } else if m.loaded { + where += " · " + m.d.at.Format("15:04:05") + } + nav := []navItem{{Label: "Fleet", Heading: true}} + for i := 0; i < pCount; i++ { + if i == pTags { + nav = append(nav, navItem{Heading: true}, navItem{Label: "Provisioning", Heading: true}) + } + label := pageLabels[i] + switch i { + case pMachines: + label += fmt.Sprintf(" (%d)", len(m.d.machines)) + case pJobs: + if n := activeJobs(m.d.jobs); n > 0 { + label += fmt.Sprintf(" (%d)", n) + } + } + nav = append(nav, navItem{Label: label, Current: i == m.menu && !m.inPanel, Dim: false}) + if i == m.menu && m.inPanel { + nav[len(nav)-1].State = "current" + } + } + title, body, keys, selLine := m.panel() + scroll := m.scroll + if selLine >= 0 { + inner := m.h - 4 + scroll = 0 + if selLine >= inner-1 { + scroll = selLine - inner + 2 + } + } + f := frame{Width: m.w, Height: m.h, Title: "rollcall", Where: where, Nav: nav, PanelTitle: title, Body: body, Scroll: scroll, Keys: keys} + switch { + case m.dlg != nil: + f.DialogTitle, f.Dialog = m.dlg.title, m.dlg.render(min(70, m.w-16)) + case m.busy != "": + f.DialogTitle, f.Dialog = m.busy, m.spin.View()+" working…" + } + return f.render() +} + +// panel is the right-hand side: title, body, keys and the line of the +// selected row (-1 when the body scrolls freely). +func (m tuiModel) panel() (string, string, string, int) { + pw := max(40, m.w-navWidth-6) + if !m.loaded { + if m.err != nil { + return "rollcall", "\n " + sBad.Render(wrap(m.err.Error(), pw-4, " ")) + "\n\n " + sDim.Render("r retry · q quit"), "r retry · q quit", -1 + } + return "rollcall", "\n " + m.spin.View() + " loading…", "q quit", -1 + } + if m.detailID != "" { + return m.detailPanel(pw) + } + side := "↑↓ page · Enter/→ open · r refresh · ? keys · q quit" + list := "↑↓ row · Enter open · Esc back · r refresh · ? keys · q quit" + switch m.menu { + case pMachines: + t, b, k, s := m.machinesPanel(pw) + if !m.inPanel { + k = side + } + return t, b, k, s + case pRacks: + if m.rackOpen >= 0 { + return m.elevationPanel(pw) + } + k := "↑↓ rack · Enter elevation · Esc back · q quit" + if !m.inPanel { + k = side + } + return "Racks", m.racksBody(pw), k, m.sel0(3) + case pJobs: + return "Jobs", m.jobsBody(pw), pick(m.inPanel, list, side), m.sel0(3) + case pEvents: + return "Events", m.eventsBody(pw), pick(m.inPanel, list, side), m.sel0(1) + case pTags: + return "Tags", m.tagsBody(pw), pick(m.inPanel, list, side), m.sel0(1) + case pProfiles: + return "Profiles", m.profilesBody(pw), pick(m.inPanel, list, side), m.sel0(1) + case pImages: + return "OS images", m.imagesBody(pw), pick(m.inPanel, list, side), m.sel0(1) + } + return "Overview", m.overviewBody(pw), pick(m.inPanel, "↑↓ scroll · Esc back · r refresh · ? keys · q quit", side), -1 +} + +func (m tuiModel) sel0(head int) int { + if !m.inPanel { + return -1 + } + return m.row + head + 1 +} + +func pick(b bool, x, y string) string { + if b { + return x + } + return y +} + +func (m tuiModel) rowCount() int { + switch m.menu { + case pMachines: + return len(m.filtered()) + case pRacks: + return len(m.racks()) + case pJobs: + return len(m.d.jobs) + case pEvents: + return len(m.d.events) + case pTags: + return len(m.d.tags) + case pProfiles: + return len(m.d.profiles) + case pImages: + return len(m.d.os) + } + return 0 +} + +func (m *tuiModel) clamp() { + if n := m.rowCount(); m.row >= n { + m.row = max(0, n-1) + } + for id := range m.sel { + found := false + for _, x := range m.d.machines { + found = found || x.ID == id + } + if !found { + delete(m.sel, id) + } + } +} + +// ---------------------------------------------------------------- helpers + +func sumName(s Summary) string { + if n := deref(s.NodeName); n != "" { + return n + } + return s.ID +} + +func orDash(s string) string { + if strings.TrimSpace(s) == "" { + return "—" + } + return s +} + +func limitLines(s string, n int) string { + l := strings.Split(s, "\n") + if len(l) > n { + return strings.Join(l[:n], "\n") + "\n" + sDim.Render(fmt.Sprintf("… %d more lines", len(l)-n)) + } + return s +} + +func agoT(t time.Time) string { + if t.IsZero() { + return "-" + } + s := time.Since(t) + switch { + case s < 90*time.Second: + return fmt.Sprintf("%ds", int(s.Seconds())) + case s < 90*time.Minute: + return fmt.Sprintf("%dm", int(s.Minutes())) + case s < 48*time.Hour: + return fmt.Sprintf("%dh", int(s.Hours())) + } + return fmt.Sprintf("%dd", int(s.Hours()/24)) +} + +func agoP(t *time.Time) string { + if t == nil { + return "-" + } + return agoT(*t) +} + +func stateStyled(s string) string { + switch { + case s == "ready" || s == "deployed" || s == "booted" || s == "done": + return sOK.Render(s) + case strings.HasSuffix(s, "failed"): + return sBad.Render(s) + case s == "deploying" || s == "releasing" || s == "stateless" || s == "recommission" || s == "new" || s == "running" || s == "pending": + return sWarn.Render(s) + case s == "cancelled": + return sDim.Render(s) + } + return s +} + +func progressOf(j *Job) (pct float64, phase, msg string) { + var p obj + _ = json.Unmarshal(j.Progress, &p) + return num(p["pct"]), str(p["phase"]), str(p["msg"]) +} + +func jobActive(j *Job) bool { return j != nil && (j.State == "pending" || j.State == "running") } + +func activeJobs(js []*Job) int { + n := 0 + for _, j := range js { + if jobActive(j) { + n++ + } + } + return n +} + +func bar(pct float64, w int) string { + n := min(w, max(0, int(pct/100*float64(w)+0.5))) + return sTitle.Render(strings.Repeat("█", n)) + sDim.Render(strings.Repeat("░", w-n)) +} + +func stateCell(s Summary) string { + if s.Job != nil { + pct, _, _ := progressOf(s.Job) + return stateStyled(s.State) + fmt.Sprintf(" %3.0f%%", pct) + } + return stateStyled(s.State) +} + +func hwSummary(s Summary) string { + p := []string{s.CPUs + "c", human(s.MemoryBytes)} + if s.Disks > 0 { + p = append(p, fmt.Sprintf("%d×%s", int(s.Disks), human(s.StorageBytes))) + } + if s.GPUs > 0 { + p = append(p, fmt.Sprintf("%dGPU", s.GPUs)) + } + if s.IBHCAs > 0 { + p = append(p, fmt.Sprintf("%dIB", s.IBHCAs)) + } + return strings.Join(p, " ") +} + +func locShort(l Location) string { + if l.Rack == "" { + return orDash(strings.Join(nonEmpty(l.Building, l.Room), "/")) + } + s := l.Rack + if l.Unit > 0 { + s += fmt.Sprintf(" U%d", l.Unit) + } + if l.Room != "" { + s = l.Room + "/" + s + } + return s +} + +func nonEmpty(xs ...string) []string { + var out []string + for _, x := range xs { + if strings.TrimSpace(x) != "" { + out = append(out, strings.TrimSpace(x)) + } + } + return out +} + +func roleOf(s Summary) string { + if s.Profile != nil { + return *s.Profile + } + if s.OS != nil { + return *s.OS + } + return "—" +} + +func nextState(ms []Summary, cur string) string { + set := map[string]bool{} + for _, x := range ms { + set[x.State] = true + } + states := sortedKeys(set) + if cur == "" { + if len(states) > 0 { + return states[0] + } + return "" + } + for i, s := range states { + if s == cur && i+1 < len(states) { + return states[i+1] + } + } + return "" +} + +func (m tuiModel) filtered() []Summary { + q := strings.ToLower(strings.TrimSpace(m.filter.Value())) + var out []Summary + for _, s := range m.d.machines { + if m.stateF != "" && s.State != m.stateF { + continue + } + if q != "" { + hay := strings.ToLower(strings.Join(append(append([]string{s.ID, s.State, sumName(s), deref(s.Serial), deref(s.Manufacturer), deref(s.Product), + deref(s.MgmtIP), roleOf(s), s.Location.String(), s.Location.AssetTag}, s.MACs...), s.Tags...), " ")) + if s.BMC != nil { + hay += " " + str((*s.BMC)["address"]) + } + if !strings.Contains(hay, q) { + continue + } + } + out = append(out, s) + } + sort.SliceStable(out, func(i, j int) bool { return sumName(out[i]) < sumName(out[j]) }) + return out +} + +// racks merges rack definitions with racks only mentioned by machines. +func (m tuiModel) racks() []Rack { + key := func(b, r, n string) string { return b + "\x00" + r + "\x00" + n } + byKey := map[string]*Rack{} + var out []*Rack + for i := range m.d.racks { + r := m.d.racks[i] + r.Machines = 0 + byKey[key(r.Building, r.Room, r.Name)] = &r + out = append(out, &r) + } + for _, s := range m.d.machines { + l := s.Location + if l.Rack == "" { + continue + } + k := key(l.Building, l.Room, l.Rack) + r := byKey[k] + if r == nil { + r = &Rack{Building: l.Building, Room: l.Room, Name: l.Rack, Height: 42} + byKey[k] = r + out = append(out, r) + } + r.Machines++ + } + sort.Slice(out, func(i, j int) bool { + return key(out[i].Building, out[i].Room, out[i].Name) < key(out[j].Building, out[j].Room, out[j].Name) + }) + res := make([]Rack, len(out)) + for i, r := range out { + res[i] = *r + } + return res +} + +func rackHeight(r Rack) int { + if r.Height <= 0 { + return 42 + } + return r.Height +} + +func (m tuiModel) rackSlots(r Rack) map[int]Summary { + out := map[int]Summary{} + for _, s := range m.d.machines { + l := s.Location + if l.Rack == r.Name && l.Room == r.Room && l.Building == r.Building && l.Unit > 0 { + out[l.Unit] = s + } + } + return out +} + +// ---------------------------------------------------------------- pages + +func (m tuiModel) overviewBody(pw int) string { + var b strings.Builder + by := map[string]int{} + for _, s := range m.d.machines { + by[s.State]++ + } + var parts []string + for _, st := range sortedKeys(func() map[string]bool { + x := map[string]bool{} + for k := range by { + x[k] = true + } + return x + }()) { + parts = append(parts, fmt.Sprintf("%s %d", stateStyled(st), by[st])) + } + fmt.Fprintf(&b, "\n %s %s\n", sBold.Render(fmt.Sprintf("%d machines", len(m.d.machines))), strings.Join(parts, " · ")) + racks := m.racks() + placed := 0 + for _, s := range m.d.machines { + if s.Location.Rack != "" { + placed++ + } + } + fmt.Fprintf(&b, " %s\n", sDim.Render(fmt.Sprintf("%d racks · %d placed · %d without location", len(racks), placed, len(m.d.machines)-placed))) + + b.WriteString("\n " + sTitle.Render("Active jobs") + "\n") + var active []*Job + for _, j := range m.d.jobs { + if jobActive(j) { + active = append(active, j) + } + } + if len(active) == 0 { + b.WriteString(" " + sDim.Render("none") + "\n") + } + for _, j := range active { + pct, phase, msg := progressOf(j) + sp := j.spec() + fmt.Fprintf(&b, " %-12s %-8s %s %3.0f%% %s %s\n", m.machineName(j.MachineID), j.Kind, bar(pct, 20), pct, phase, sDim.Render(sp.OS+" "+oneLine(msg))) + } + + b.WriteString("\n " + sTitle.Render("Attention") + "\n") + attn := 0 + note := func(cond bool, s string) { + if cond { + attn++ + b.WriteString(" " + s + "\n") + } + } + nobmc, silent := 0, 0 + for _, s := range m.d.machines { + if s.BMC == nil || (*s.BMC)["configured"] != true { + nobmc++ + } + if (s.State == "booted" || s.State == "stateless") && s.LastSeen != nil && time.Since(*s.LastSeen) > 15*time.Minute { + silent++ + } + } + failed := 0 + for _, j := range m.d.jobs { + if j.State == "failed" { + failed++ + } + } + note(nobmc > 0, sBad.Render(fmt.Sprintf("%d machine(s) without a configured BMC", nobmc))) + note(silent > 0, sWarn.Render(fmt.Sprintf("%d stateless node(s) silent for more than 15 minutes", silent))) + note(failed > 0, sBad.Render(fmt.Sprintf("%d failed job(s) among the last 100", failed))) + for _, i := range m.d.os { + note(i.Warning != "", sWarn.Render("OS image "+i.Name+": "+i.Warning)) + } + if attn == 0 { + b.WriteString(" " + sOK.Render("nothing") + "\n") + } + + b.WriteString("\n " + sTitle.Render("Recent events") + "\n") + var rows [][]string + for i, e := range m.d.events { + if i >= 15 { + break + } + rows = append(rows, []string{agoT(e.TS), m.machineName(e.MachineID), e.Event.Event, sDim.Render(oneLine(e.Detail))}) + } + b.WriteString(table([]string{"When", "Machine", "Event", "Detail"}, rows, -1, pw-2, false)) + return b.String() +} + +func (m tuiModel) machineName(id string) string { + for _, s := range m.d.machines { + if s.ID == id { + return sumName(s) + } + } + return id +} + +func (m tuiModel) machinesPanel(pw int) (string, string, string, int) { + ms := m.filtered() + head := []string{fmt.Sprintf("%d of %d", len(ms), len(m.d.machines))} + head = append(head, "state "+pick(m.stateF == "", "all", stateStyled(m.stateF))+sDim.Render(" (s)")) + switch { + case m.filtering: + head = append(head, "filter "+m.filter.View()) + case m.filter.Value() != "": + head = append(head, "filter "+sBold.Render(m.filter.Value())+sDim.Render(" (/)")) + default: + head = append(head, sDim.Render("/ filter")) + } + if n := len(m.sel); n > 0 { + head = append(head, sTitle.Render(fmt.Sprintf("%d selected", n))+sDim.Render(" (a acts on them, Esc clears)")) + } + var rows [][]string + for _, s := range ms { + mark := " " + if m.sel[s.ID] { + mark = sTitle.Render("●") + } + bmc := sDim.Render("—") + if s.BMC != nil { + b := *s.BMC + dot := sBad.Render("●") + if b["configured"] == true { + dot = sOK.Render("●") + } + bmc = dot + " " + str(b["address"]) + } + rows = append(rows, []string{mark, sumName(s), stateCell(s), locShort(s.Location), roleOf(s), truncateWidth(strings.Join(s.Tags, ","), 22), + truncateWidth(strings.TrimSpace(deref(s.Manufacturer)+" "+deref(s.Product)), 22), hwSummary(s), bmc, agoP(s.LastSeen)}) + } + body := " " + strings.Join(head, sDim.Render(" · ")) + "\n\n" + + table([]string{" ", "Machine", "State", "Location", "Profile/OS", "Tags", "Model", "Hardware", "BMC", "Seen"}, rows, m.row, pw-2, m.inPanel) + keys := "↑↓ row · Enter open · Space select · * all · / filter · s state · a actions · Esc back · q quit" + sel := -1 + if m.inPanel { + sel = m.row + 3 + } + return "Machines", body, keys, sel +} + +func (m tuiModel) detailPanel(pw int) (string, string, string, int) { + keys := "↑↓ PgUp/PgDn scroll · a actions · Esc back · r refresh · q quit" + d := m.detail + if d == nil { + return "Machine", "\n " + m.spin.View() + " loading " + m.detailID, keys, -1 + } + s := d.Summary + inv := d.Inventory + sys, _ := inv["system"].(obj) + cpu, _ := inv["cpu"].(obj) + mem, _ := inv["memory"].(obj) + st, _ := inv["storage"].(obj) + bmc := d.BMC + var b strings.Builder + w := func(f string, a ...any) { fmt.Fprintf(&b, f+"\n", a...) } + kv := func(k, v string) { + if strings.TrimSpace(ansi.Strip(v)) != "" { + w(" %s %s", sDim.Render(fmt.Sprintf("%-16s", k)), v) + } + } + sec := func(t string) { w(""); w(" %s", sTitle.Render(t)) } + + w("") + w(" %s %s %s", sBold.Render(sumName(s)), stateStyled(s.State), sDim.Render(s.ID)) + w(" %s", sDim.Render(strings.Join(nonEmpty(str(sys["system-manufacturer"])+" "+str(sys["system-product-name"]), "S/N "+deref(s.Serial), hwSummary(s)), " · "))) + + sec("Role") + if s.OS != nil { + kv("OS on disk", fmt.Sprintf("%s %s · deployed %s", *s.OS, sDim.Render(deref(s.OSVersion)), timeStr(s.DeployedAt))) + if s.DeployedAt != nil { + kv("Phoned home", pick(s.BootedAt != nil, sOK.Render(timeStr(s.BootedAt)), sDim.Render("not yet"))) + } + } + if s.Profile != nil { + kv("Profile", *s.Profile+" · booted "+pick(s.BootedAt != nil, timeStr(s.BootedAt), "not yet")) + } + kv("Node name", deref(s.NodeName)) + kv("Management IP", deref(s.MgmtIP)) + kv("IB IP", deref(s.IBIP)) + loc := orDash(s.Location.String()) + if s.Location.AssetTag != "" { + loc += " · asset " + s.Location.AssetTag + } + kv("Location", loc) + var tags []string + for _, t := range s.Tags { + if hasTag(s.ManualTags, t) { + tags = append(tags, t) + } else { + tags = append(tags, sDim.Render(t+"(auto)")) + } + } + kv("Tags", orDash(strings.Join(tags, " "))) + if bmc != nil { + dot := sBad.Render("●") + if bmc["configured"] == true { + dot = sOK.Render("●") + } + kv("BMC", fmt.Sprintf("%s %s %s · %s", dot, str(bmc["address"]), str(bmc["user"]), pick(d.HasBMCSecret, "credentials stored", sBad.Render("no credentials")))) + } else { + kv("BMC", sBad.Render("none")) + } + + job := s.Job + if job == nil && len(d.Jobs) > 0 { + job = d.Jobs[0] + } + if job != nil { + sec("Job") + sp := job.spec() + kv("Job", fmt.Sprintf("%s %s %s %s/%s → %s", job.ID, job.Kind, stateStyled(job.State), sp.OS, sp.Version, sp.Disk)) + if jobActive(job) { + pct, phase, msg := progressOf(job) + kv("Progress", fmt.Sprintf("%s %3.0f%% %s %s", bar(pct, 30), pct, phase, sDim.Render(oneLine(msg)))) + } + kv("Started", timeStr(job.Started)) + kv("Finished", timeStr(job.Finished)) + if job.Error != nil { + kv("Error", sBad.Render(*job.Error)) + } + } + + sec("Hardware") + kv("CPU", fmt.Sprintf("%s · %s × %s × %s = %s threads · %s NUMA", str(cpu["Model name"]), str(cpu["Socket(s)"]), str(cpu["Core(s) per socket"]), + str(cpu["Thread(s) per core"]), str(cpu["CPU(s)"]), str(cpu["NUMA node(s)"]))) + kv("Memory", fmt.Sprintf("%s · %s/%s DIMMs", human(num(mem["total_bytes"])), str(mem["dimms_populated"]), str(mem["dimm_slots"]))) + kv("BIOS", strings.Join(nonEmpty(str(sys["bios-vendor"]), str(sys["bios-version"]), str(sys["bios-release-date"])), " ")) + kv("UUID", str(sys["system-uuid"])) + kv("First seen", s.FirstSeen.Local().Format("2006-01-02 15:04")) + kv("Last seen", timeStr(s.LastSeen)) + + sec(fmt.Sprintf("Storage · %s disks · %s", str(st["disk_count"]), human(num(st["total_bytes"])))) + var rows [][]string + smart, _ := st["smart"].(obj) + for _, dv := range toList(st["disks"]) { + x, _ := dv.(obj) + kind := "hdd" + if x["rota"] == false { + kind = "ssd" + } + health := "" + if sm, ok := smart[str(x["name"])].(obj); ok { + switch sm["healthy"] { + case true: + health = sOK.Render("ok") + case false: + health = sBad.Render("FAIL") + } + } + rows = append(rows, []string{str(x["name"]), human(num(x["size"])), str(x["tran"]), kind, str(x["model"]), str(x["serial"]), health}) + } + b.WriteString(table([]string{"Dev", "Size", "Bus", "Kind", "Model", "Serial", "Health"}, rows, -1, pw-4, false)) + + sec(fmt.Sprintf("Network · %d NICs", len(toList(inv["network"])))) + rows = nil + lldp, _ := inv["lldp"].(obj) + for _, nv := range toList(inv["network"]) { + n, _ := nv.(obj) + link := "" + switch n["link"] { + case true: + link = sOK.Render("up") + case false: + link = sDim.Render("down") + } + sw := "" + for _, e := range asList(lldp[str(n["name"])]) { + eo, _ := e.(obj) + ch, _ := eo["chassis"].(obj) + for k := range ch { + sw = k + } + sw += " " + str(dig(eo, "port", "id", "value")) + } + rows = append(rows, []string{str(n["name"]), str(n["mac"]), str(n["driver"]), str(n["speed"]), link, strings.TrimSpace(sw)}) + } + b.WriteString(table([]string{"If", "MAC", "Driver", "Speed", "Link", "Switch port"}, rows, -1, pw-4, false)) + if hcas := toList(dig(inv, "infiniband", "hcas")); len(hcas) > 0 { + sec(fmt.Sprintf("InfiniBand · %d HCAs", len(hcas))) + rows = nil + for _, hv := range hcas { + h, _ := hv.(obj) + for _, pv := range toList(h["ports"]) { + p, _ := pv.(obj) + rows = append(rows, []string{str(h["name"]), str(p["port"]), str(p["state"]), str(p["rate"]), str(h["node_guid"]), str(h["fw_ver"])}) + } + } + b.WriteString(table([]string{"HCA", "Port", "State", "Rate", "Node GUID", "FW"}, rows, -1, pw-4, false)) + } + + sec("Recent events") + rows = nil + for i := len(d.Events) - 1; i >= 0 && len(rows) < 15; i-- { + e := d.Events[i] + rows = append(rows, []string{agoT(e.TS), e.Event, sDim.Render(oneLine(e.Detail))}) + } + b.WriteString(table([]string{"When", "Event", "Detail"}, rows, -1, pw-4, false)) + return "Machine · " + sumName(s), b.String(), keys, -1 +} + +func timeStr(t *time.Time) string { + if t == nil || t.IsZero() { + return "" + } + return t.Local().Format("2006-01-02 15:04") +} + +func (m tuiModel) racksBody(pw int) string { + racks := m.racks() + var rows [][]string + for _, r := range racks { + used := len(m.rackSlots(r)) + rows = append(rows, []string{r.Building, r.Room, sBold.Render(r.Name), fmt.Sprintf("%dU", rackHeight(r)), fmt.Sprint(r.Machines), + fmt.Sprintf("%s %d/%d U", bar(float64(used)*100/float64(rackHeight(r)), 10), used, rackHeight(r)), r.Comment}) + } + unplaced := 0 + for _, s := range m.d.machines { + if s.Location.Rack == "" { + unplaced++ + } + } + head := fmt.Sprintf(" %d racks · %d machines without a rack", len(racks), unplaced) + if len(racks) == 0 { + head += "\n " + sDim.Render("Set locations with a on a machine (Location…) or: rollcall location import racks.csv") + } + return head + "\n\n" + table([]string{"Building", "Room", "Rack", "Height", "Machines", "Used", "Comment"}, rows, m.row, pw-2, m.inPanel) +} + +func (m tuiModel) elevationPanel(pw int) (string, string, string, int) { + racks := m.racks() + r := racks[m.rackOpen] + H := rackHeight(r) + slots := m.rackSlots(r) + var b strings.Builder + fmt.Fprintf(&b, " %s %s · %dU · %d machines\n\n", sBold.Render(r.Name), sDim.Render(strings.Join(nonEmpty(r.Building, r.Room), " / ")), H, r.Machines) + for i := 0; i < H; i++ { + u := H - i + line := "" + if s, ok := slots[u]; ok { + line = fmt.Sprintf("%-14s %s %s", sumName(s), stateStyled(s.State), sDim.Render(roleOf(s)+" · "+hwSummary(s))) + } + row := fmt.Sprintf("%3d │ %s", u, line) + if i == m.rackRow { + row = fBar.Render(ansi.Strip(row) + strings.Repeat(" ", max(0, pw-4-ansi.StringWidth(ansi.Strip(row))))) + } + b.WriteString(" " + row + "\n") + } + var noU []string + for _, s := range m.d.machines { + if s.Location.Rack == r.Name && s.Location.Room == r.Room && s.Location.Building == r.Building && s.Location.Unit == 0 { + noU = append(noU, sumName(s)) + } + } + if len(noU) > 0 { + b.WriteString("\n " + sDim.Render("no unit: "+strings.Join(noU, ", ")) + "\n") + } + return "Rack " + r.Name, b.String(), "↑↓ unit · Enter open machine · Esc back · q quit", m.rackRow + 2 +} + +func (m tuiModel) jobsBody(pw int) string { + var rows [][]string + for _, j := range m.d.jobs { + sp := j.spec() + prog := "" + if jobActive(j) { + pct, phase, _ := progressOf(j) + prog = fmt.Sprintf("%s %3.0f%% %s", bar(pct, 12), pct, phase) + } else if j.Finished != nil && j.Started != nil { + prog = sDim.Render(j.Finished.Sub(*j.Started).Round(time.Second).String()) + } + e := "" + if j.Error != nil { + e = sBad.Render(oneLine(*j.Error)) + } + rows = append(rows, []string{m.machineName(j.MachineID), j.ID, j.Kind, stateStyled(j.State), strings.TrimSpace(sp.OS + " " + sDim.Render(sp.Version) + " → " + sp.Disk), prog, agoT(j.Created), e}) + } + return fmt.Sprintf(" %d active · %d shown", activeJobs(m.d.jobs), len(m.d.jobs)) + "\n\n" + + table([]string{"Machine", "Job", "Kind", "State", "Target", "Progress", "Created", "Error"}, rows, m.row, pw-2, m.inPanel) +} + +func (m tuiModel) eventsBody(pw int) string { + var rows [][]string + for _, e := range m.d.events { + rows = append(rows, []string{agoT(e.TS), m.machineName(e.MachineID), e.Event.Event, sDim.Render(oneLine(e.Detail))}) + } + return table([]string{"When", "Machine", "Event", "Detail"}, rows, m.row, pw-2, m.inPanel) +} + +func (m tuiModel) tagsBody(pw int) string { + var rows [][]string + for _, t := range m.d.tags { + cc := "" + if t.CloudConfig != "" { + cc = fmt.Sprintf("%d lines", strings.Count(t.CloudConfig, "\n")+1) + } + rows = append(rows, []string{t.Name, fmt.Sprint(t.Machines), t.Match, cc, strings.Join(t.Overlays, ","), t.Comment}) + } + return table([]string{"Tag", "Machines", "Match rule", "Cloud-config", "Overlays", "Comment"}, rows, m.row, pw-2, m.inPanel) +} + +func (m tuiModel) profilesBody(pw int) string { + var rows [][]string + for _, p := range m.d.profiles { + n := 0 + for _, s := range m.d.machines { + if deref(s.Profile) == p.Name { + n++ + } + } + rows = append(rows, []string{p.Name, p.Image, strings.Join(p.Overlays, ","), p.NameFormat, fmt.Sprint(n), p.Append}) + } + return table([]string{"Profile", "Root image", "Overlays", "Names", "Nodes", "Kernel append"}, rows, m.row, pw-2, m.inPanel) +} + +func (m tuiModel) imagesBody(pw int) string { + var rows [][]string + for _, i := range m.d.os { + cur, size, raw, imp, fam, track := "—", "", "", "", "", "" + if i.Source != nil { + fam, track = i.Source.Family, i.Source.Track + } + if c := i.Current; c != nil { + cur, size, raw, imp = c.Version, human(float64(c.Size)), human(float64(c.RawSize)), agoT(c.Imported) + if fam == "" { + fam = c.Family + } + } + status := sOK.Render("ok") + if i.Warning != "" { + status = sWarn.Render(i.Warning) + } + rows = append(rows, []string{i.Name, cur, fam, size, raw, imp, track, fmt.Sprint(len(i.Versions)), status}) + } + return table([]string{"OS", "Current", "Family", "Size", "Disk", "Imported", "Track", "Versions", "Status"}, rows, m.row, pw-2, m.inPanel) +} + +// ---------------------------------------------------------------- entry points + +func runTUI() error { + c, err := newClient() + m := newTUIModel(c) + if err != nil { + m.connect = true + m.cURL, m.cTok = newTextField(), newTextField() + m.cURL.Placeholder = "http://10.0.0.234" + m.cTok.Mask = true + if cc, ok := loadClientConf(); ok { + m.cURL.SetValue(cc.URL) + } + m.cURL.Focus() + } + _, err = tea.NewProgram(m, tea.WithAltScreen()).Run() + return err +} + +// tuiDump renders one screen to stdout (for checks and bug reports). +func tuiDump(args []string) error { + fs := newFlags("tui") + size := fs.String("dump", "", "render one frame of WIDTHxHEIGHT to stdout and exit") + page := fs.String("page", "overview", "page: "+strings.Join(pageNames[:], ", ")) + id := fs.String("machine", "", "open this machine") + rack := fs.Int("rack", -1, "open this rack (index on the Racks page)") + actions := fs.Bool("actions", false, "show the actions menu (with -machine)") + plain := fs.Bool("plain", false, "no colours") + _ = fs.Parse(args) + if *size == "" { + return runTUI() + } + var w, h int + if _, err := fmt.Sscanf(*size, "%dx%d", &w, &h); err != nil { + return fmt.Errorf("-dump wants WIDTHxHEIGHT") + } + c, err := newClient() + if err != nil { + return err + } + m := newTUIModel(c) + m.detailID = *id + for i, n := range pageNames { + if n == *page { + m.menu = i + } + } + m.inPanel, m.rackOpen = true, *rack + msg := m.fetch()() + mm, _ := m.Update(msg) + m = mm.(tuiModel) + m.w, m.h = w, h + if *actions && m.detailID != "" { + m.dlg = m.actionMenu([]string{m.detailID}) + } + out := m.View() + if *plain { + out = ansi.Strip(out) + } + fmt.Println(out) + return nil +} diff --git a/cmd/rollcall/tui_frame.go b/cmd/rollcall/tui_frame.go new file mode 100644 index 0000000..b16a9bd --- /dev/null +++ b/cmd/rollcall/tui_frame.go @@ -0,0 +1,362 @@ +package main + +// The frame every full-screen rollcall screen is drawn in, the same design as +// llmgw's: a title bar, a sidebar on the left, the content in a bordered panel +// on the right, the keys along the bottom, and a dialog over it all when one is +// open. Keyboard only: these screens run on serial consoles and BMC KVMs as +// often as in a desktop terminal. +// +// The two widgets are written here rather than taken from bubbles: its +// packages ask the terminal for its colours as they load, which would make +// every CLI subcommand wait on a terminal that never answers. + +import ( + "strings" + "time" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" + "github.com/charmbracelet/x/ansi" +) + +var ( + tuiAccent = lipgloss.AdaptiveColor{Light: "#0B7F7D", Dark: "#3FC2BC"} + tuiOK = lipgloss.AdaptiveColor{Light: "#1F8A4C", Dark: "#6FD3A6"} + tuiWarn = lipgloss.AdaptiveColor{Light: "#A15C00", Dark: "#E9B35A"} + tuiBad = lipgloss.AdaptiveColor{Light: "#B42318", Dark: "#F07C6C"} + tuiDim = lipgloss.AdaptiveColor{Light: "#56696C", Dark: "#8FA5A4"} + + sTitle = lipgloss.NewStyle().Bold(true).Foreground(tuiAccent) + sBold = lipgloss.NewStyle().Bold(true) + sDim = lipgloss.NewStyle().Foreground(tuiDim) + sOK = lipgloss.NewStyle().Foreground(tuiOK) + sWarn = lipgloss.NewStyle().Foreground(tuiWarn) + sBad = lipgloss.NewStyle().Foreground(tuiBad) + + fBar = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.AdaptiveColor{Light: "#FFFFFF", Dark: "#0B1B1B"}).Background(tuiAccent) + fBorder = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(tuiDim) + fFocus = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(tuiAccent) + fKeys = lipgloss.NewStyle().Foreground(tuiDim) + fSelected = lipgloss.NewStyle().Bold(true).Foreground(tuiAccent) + fDialog = lipgloss.NewStyle().Border(lipgloss.DoubleBorder()).BorderForeground(tuiAccent).Padding(1, 2) +) + +const navWidth = 22 + +// navItem is one line of the sidebar. +type navItem struct { + Label string + State string // "done", "current", "todo" for steps; "" for menu entries + Current bool + Dim bool + Heading bool // a title between groups, not an entry +} + +type frame struct { + Width, Height int + Title string // left of the title bar + Where string // right of the title bar + Nav []navItem + PanelTitle string + Body string + Scroll int // body lines scrolled off the top + Keys string + Dialog string + DialogTitle string +} + +// render draws the whole screen, exactly Width by Height. +func (f frame) render() string { + w, h := max(f.Width, 60), max(f.Height, 16) + + title := " " + f.Title + right := version + " " + if f.Where != "" { + right = f.Where + " · " + right + } + gap := max(1, w-ansi.StringWidth(title)-ansi.StringWidth(right)) + bar := fBar.Render(truncateWidth(title+strings.Repeat(" ", gap)+right, w)) + + ph := h - 2 + inner := ph - 2 + + var navLines []string + cur := 0 + for _, it := range f.Nav { + mark := " " + label := it.Label + if it.Heading { + navLines = append(navLines, sDim.Render(label)) + continue + } + if it.Current || it.State == "current" { + cur = len(navLines) + } + switch { + case it.State == "done": + mark = sOK.Render("✓ ") + case it.State == "current", it.Current: + mark = fSelected.Render("› ") + label = fSelected.Render(label) + case it.Dim || it.State == "todo": + label = sDim.Render(label) + } + navLines = append(navLines, truncateWidth(mark+label, navWidth-2)) + } + if len(navLines) > inner { + total := len(navLines) + top := min(max(0, cur-inner/2), total-inner) + navLines = append([]string{}, navLines[top:top+inner]...) + if top > 0 { + navLines[0] = sDim.Render(" ↑ more") + } + if top+inner < total { + navLines[inner-1] = sDim.Render(" ↓ more") + } + } + left := box(fBorder, "", strings.Join(navLines, "\n"), navWidth, inner) + + pw := w - navWidth - 2 - 2 + lines := strings.Split(strings.TrimRight(f.Body, "\n"), "\n") + scroll := min(max(f.Scroll, 0), max(0, len(lines)-inner)) + visible := lines[scroll:] + if len(visible) > inner { + visible = visible[:inner] + visible[inner-1] = sDim.Render(" ↓ more — PgDn") + } + for i := range visible { + visible[i] = truncateWidth(visible[i], pw) + } + panelTitle := f.PanelTitle + if scroll > 0 { + panelTitle += " ↑" + } + main := box(fFocus, panelTitle, strings.Join(visible, "\n"), pw, inner) + + keys := fKeys.Render(" " + truncateWidth(f.Keys, w-2)) + screen := bar + "\n" + lipgloss.JoinHorizontal(lipgloss.Top, left, main) + "\n" + keys + + if f.Dialog != "" { + dw := min(w-8, max(50, maxLineWidth(f.Dialog)+6)) + d := fDialog.Width(dw).Render(f.Dialog) + if f.DialogTitle != "" { + d = titled(d, f.DialogTitle) + } + screen = overlay(screen, d, w, h) + } + return screen +} + +func box(style lipgloss.Style, title, content string, width, height int) string { + b := style.Width(width).Height(height).Render(content) + if title == "" { + return b + } + return titled(b, title) +} + +// titled sets " title " into a box's top border, after its corner. +func titled(b, title string) string { + lines := strings.Split(b, "\n") + if len(lines) == 0 { + return b + } + top := lines[0] + t := " " + title + " " + tw := ansi.StringWidth(t) + if ansi.StringWidth(top) < tw+4 { + return b + } + lines[0] = ansi.Truncate(top, 2, "") + sTitle.Render(t) + ansi.TruncateLeft(top, 2+tw, "") + return strings.Join(lines, "\n") +} + +// overlay draws top over the middle of base, both w by h. +func overlay(base, top string, w, h int) string { + bl := strings.Split(base, "\n") + tl := strings.Split(top, "\n") + tw := maxLineWidth(top) + x := max(0, (w-tw)/2) + y := max(0, (h-len(tl))/2) + for i, l := range tl { + row := y + i + if row >= len(bl) { + break + } + under := bl[row] + left := ansi.Truncate(under, x, "") + if pad := x - ansi.StringWidth(left); pad > 0 { + left += strings.Repeat(" ", pad) + } + right := ansi.TruncateLeft(under, x+ansi.StringWidth(l), "") + bl[row] = left + l + right + } + return strings.Join(bl, "\n") +} + +func maxLineWidth(s string) int { + n := 0 + for _, l := range strings.Split(s, "\n") { + n = max(n, ansi.StringWidth(l)) + } + return n +} + +// truncateWidth cuts a line, colours and all, to w cells. +func truncateWidth(s string, w int) string { + if ansi.StringWidth(s) <= w { + return s + } + return ansi.Truncate(s, max(w-1, 0), "…") +} + +// table draws rows under a header in columns as wide as they need, cut to +// width; the selected row is shown reversed when the panel has the focus. +func table(headers []string, rows [][]string, selected int, width int, focused bool) string { + widths := make([]int, len(headers)) + for i, h := range headers { + widths[i] = ansi.StringWidth(h) + } + for _, r := range rows { + for i := range headers { + if i < len(r) { + widths[i] = min(max(widths[i], ansi.StringWidth(r[i])), 40) + } + } + } + line := func(cells []string) string { + var b strings.Builder + for i := range headers { + c := "" + if i < len(cells) { + c = truncateWidth(cells[i], widths[i]) + } + b.WriteString(c) + if i < len(headers)-1 { + b.WriteString(strings.Repeat(" ", widths[i]-ansi.StringWidth(c)+2)) + } + } + return truncateWidth(b.String(), width) + } + var b strings.Builder + b.WriteString(" " + lipgloss.NewStyle().Bold(true).Foreground(tuiDim).Render(line(headers)) + "\n") + for i, r := range rows { + l := line(r) + switch { + case i == selected && focused: + plain := ansi.Strip(l) + pad := max(0, width-ansi.StringWidth(plain)) + l = fBar.Render(plain + strings.Repeat(" ", pad)) + case i == selected: + l = sBold.Render(ansi.Strip(l)) + } + b.WriteString(" " + l + "\n") + } + if len(rows) == 0 { + b.WriteString(" " + sDim.Render("nothing yet") + "\n") + } + return b.String() +} + +// wrap breaks text at spaces to width; continuation lines start with indent. +func wrap(s string, width int, indent string) string { + if width < 10 { + return s + } + var out []string + for _, para := range strings.Split(s, "\n") { + line := "" + for _, word := range strings.Fields(para) { + if line != "" && ansi.StringWidth(line)+1+ansi.StringWidth(word) > width { + out = append(out, line) + line = indent + word + continue + } + if line == "" { + line = word + } else { + line += " " + word + } + } + out = append(out, line) + } + return strings.Join(out, "\n") +} + +// ---------------------------------------------------------------- widgets + +type spinTickMsg struct{} + +var spinFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"} + +type spinnerModel struct{ frame int } + +func (s spinnerModel) Tick() tea.Msg { return spinTickMsg{} } + +func (s spinnerModel) Update(msg tea.Msg) (spinnerModel, tea.Cmd) { + if _, ok := msg.(spinTickMsg); !ok { + return s, nil + } + s.frame = (s.frame + 1) % len(spinFrames) + return s, tea.Tick(100*time.Millisecond, func(time.Time) tea.Msg { return spinTickMsg{} }) +} + +func (s spinnerModel) View() string { return sTitle.Render(spinFrames[s.frame]) } + +// textField is one line of text typed at its end: all a form here needs. +type textField struct { + value []rune + focused bool + Prompt string + Placeholder string + CharLimit int + Mask bool // a password +} + +func newTextField() textField { return textField{} } + +func (f *textField) SetValue(s string) { f.value = []rune(s) } +func (f textField) Value() string { return string(f.value) } +func (f *textField) Focus() { f.focused = true } +func (f *textField) Blur() { f.focused = false } + +func (f textField) Update(msg tea.Msg) (textField, tea.Cmd) { + k, ok := msg.(tea.KeyMsg) + if !ok || !f.focused { + return f, nil + } + switch k.Type { + case tea.KeyRunes, tea.KeySpace: + r := k.Runes + if k.Type == tea.KeySpace { + r = []rune{' '} + } + for _, c := range r { + if f.CharLimit == 0 || len(f.value) < f.CharLimit { + f.value = append(f.value, c) + } + } + case tea.KeyBackspace: + if len(f.value) > 0 { + f.value = f.value[:len(f.value)-1] + } + case tea.KeyCtrlU: + f.value = nil + } + return f, nil +} + +func (f textField) View() string { + text := string(f.value) + if f.Mask { + text = strings.Repeat("•", len(f.value)) + } + shown := text + if text == "" && f.Placeholder != "" { + shown = sDim.Render(f.Placeholder) + } + if f.focused { + shown += "█" + } + return f.Prompt + shown +} diff --git a/cmd/rollcall/tui_test.go b/cmd/rollcall/tui_test.go new file mode 100644 index 0000000..d833cdb --- /dev/null +++ b/cmd/rollcall/tui_test.go @@ -0,0 +1,158 @@ +package main + +import ( + "encoding/json" + "strings" + "testing" + "time" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/x/ansi" +) + +// fakeModel is a console with a small fleet loaded, no server needed. +func fakeModel(t *testing.T, w, h int) tuiModel { + t.Helper() + now := time.Now() + sp, _ := json.Marshal(DeploySpec{OS: "rocky-9", Version: "20261027-92c206", Disk: "/dev/sda"}) + prog := json.RawMessage(`{"phase":"writing","pct":42,"msg":"42% of 552 MiB"}`) + job := &Job{ID: "j-1", MachineID: "m-a", Kind: "deploy", State: "running", Spec: sp, Progress: prog, Created: now} + name, os, ip := "node001", "rocky-9", "10.0.0.50" + bmc := obj{"address": "10.0.0.11", "configured": true} + m := newTUIModel(&client{base: "http://test"}) + m.w, m.h = w, h + m.loaded = true + m.d = tuiData{at: now, + machines: []Summary{ + {ID: "m-a", State: "deploying", NodeName: &name, OS: &os, MgmtIP: &ip, CPUs: "64", MemoryBytes: 512 << 30, Disks: 2, StorageBytes: 8 << 40, GPUs: 4, IBHCAs: 2, + BMC: &bmc, Tags: []string{"gpu", "rack-3"}, ManualTags: []string{"rack-3"}, AutoTags: []string{"gpu"}, Job: job, LastSeen: &now, + Location: Location{Building: "DC1", Room: "Hall A", Rack: "R12", Unit: 24}}, + {ID: "m-b", State: "ready", CPUs: "32", MemoryBytes: 256 << 30, LastSeen: &now}, + }, + racks: []Rack{{Building: "DC1", Room: "Hall A", Name: "R12", Height: 42}}, + jobs: []*Job{job}, + events: []MachineEvent{{Event: Event{TS: now, Event: "deploy started", Detail: "job=j-1"}, MachineID: "m-a"}}, + tags: []TagDef{{Name: "gpu", Match: "{{ gt .Node.GPUs 0 }}", CloudConfig: "#cloud-config\npackages: [x]", Machines: 1}}, + os: []OSImage{{Name: "rocky-9", Current: &OSMeta{Version: "20261027-92c206", Size: 553 << 20, RawSize: 10 << 30, Imported: now}}}, + } + return m +} + +func TestTUIPagesRender(t *testing.T) { + for _, size := range [][2]int{{140, 40}, {80, 24}, {60, 16}} { + for page := 0; page < pCount; page++ { + m := fakeModel(t, size[0], size[1]) + m.menu, m.inPanel = page, true + out := ansi.Strip(m.View()) + lines := strings.Split(out, "\n") + if len(lines) != max(size[1], 16) { + t.Errorf("%dx%d %s: %d lines", size[0], size[1], pageNames[page], len(lines)) + } + for i, l := range lines { + if w := ansi.StringWidth(l); w > max(size[0], 60) { + t.Errorf("%dx%d %s: line %d is %d wide", size[0], size[1], pageNames[page], i, w) + } + } + if !strings.Contains(out, pageLabels[page]) { + t.Errorf("%s: label missing", pageNames[page]) + } + } + } +} + +func TestTUIMachinesListAndFilter(t *testing.T) { + m := fakeModel(t, 160, 30) + m.menu, m.inPanel = pMachines, true + out := ansi.Strip(m.View()) + for _, want := range []string{"node001", "deploying 42%", "Hall A/R12 U24", "64c 512.0G 2×8.0T 4GPU 2IB", "m-b"} { + if !strings.Contains(out, want) { + t.Errorf("machines page lacks %q", want) + } + } + m.filter.SetValue("r12") + if got := len(m.filtered()); got != 1 { + t.Errorf("filter r12: %d machines, want 1", got) + } + m.filter.SetValue("") + m.stateF = "ready" + if got := m.filtered(); len(got) != 1 || got[0].ID != "m-b" { + t.Errorf("state filter: %+v", got) + } +} + +func TestTUIKeysSelectionAndActions(t *testing.T) { + m := fakeModel(t, 140, 40) + press := func(s string) { + var k tea.KeyMsg + switch s { + case "enter": + k = tea.KeyMsg{Type: tea.KeyEnter} + case "esc": + k = tea.KeyMsg{Type: tea.KeyEsc} + case " ": + k = tea.KeyMsg{Type: tea.KeySpace} + default: + k = tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)} + } + mm, _ := m.Update(k) + m = mm.(tuiModel) + } + press("j") // Machines + press("enter") + if !m.inPanel || m.menu != pMachines { + t.Fatalf("not in the machines panel: menu=%d inPanel=%v", m.menu, m.inPanel) + } + press(" ") + press(" ") + if len(m.sel) != 2 { + t.Fatalf("selected %d, want 2", len(m.sel)) + } + press("a") + if m.dlg == nil || !strings.Contains(m.dlg.title, "2 machines") { + t.Fatalf("actions dialog for the selection not open: %+v", m.dlg) + } + out := ansi.Strip(m.View()) + for _, want := range []string{"Power cycle", "Deploy OS…", "Location…", "Delete record"} { + if !strings.Contains(out, want) { + t.Errorf("actions menu lacks %q", want) + } + } + // Deploy OS… opens a form with the OS image choice + for i, it := range m.dlg.menu { + if it.label == "Deploy OS…" { + m.dlg.focus = i + } + } + press("enter") + if m.dlg == nil || len(m.dlg.fields) == 0 || m.dlg.fields[0].value() != "rocky-9" { + t.Fatalf("deploy form not open with rocky-9: %+v", m.dlg) + } + press("esc") + press("esc") // clears the selection + if len(m.sel) != 0 { + t.Errorf("Esc did not clear the selection") + } +} + +func TestTUIBatchedRunes(t *testing.T) { + m := fakeModel(t, 140, 40) + mm, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("jj")}) + if got := mm.(tuiModel).menu; got != pRacks { + t.Errorf("\"jj\" in one message moved to page %d, want %d (Racks)", got, pRacks) + } + m.filtering = true + m.filter.Focus() + mm, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("r12")}) + if got := mm.(tuiModel).filter.Value(); got != "r12" { + t.Errorf("typed into the filter: %q, want r12", got) + } +} + +func TestTUIRackElevation(t *testing.T) { + m := fakeModel(t, 120, 60) + m.menu, m.inPanel, m.rackOpen = pRacks, true, 0 + out := ansi.Strip(m.View()) + if !strings.Contains(out, "24 │ node001") { + t.Errorf("elevation lacks node001 at U24:\n%s", out) + } +} diff --git a/cmd/rollcall/web/app.js b/cmd/rollcall/web/app.js index e1e1fc4..37a0b85 100644 --- a/cmd/rollcall/web/app.js +++ b/cmd/rollcall/web/app.js @@ -7,7 +7,7 @@ const human = n => { n = Number(n || 0); const u = ['B', 'K', 'M', 'G', 'T', 'P' const ago = ts => { if (!ts) return '-'; const s = (Date.now() - new Date(ts)) / 1000; if (s < 90) return `${s | 0}s`; if (s < 5400) return `${(s / 60) | 0}m`; if (s < 172800) return `${(s / 3600) | 0}h`; return `${(s / 86400) | 0}d`; }; const when = ts => ts ? new Date(ts).toLocaleString() : ''; const pill = (s, extra = '') => `${esc(s)}${extra}`; -const nameOf = m => m.node_name || m.hostname || m.id; +const nameOf = m => m.node_name || m.id; // ---------------------------------------------------------------- state let token = '';