Thales Maciel
ea72ea26fe
Replace the shell-only user workflow with `banger` and `bangerd`: Cobra commands, XDG/SQLite-backed state, managed VM and image lifecycle, and a Bubble Tea TUI for browsing and operating VMs.\n\nKeep Firecracker orchestration behind the daemon so VM specs become persistent objects, and add repo entrypoints for building, installing, and documenting the new flow while still delegating rootfs customization to the existing shell tooling.\n\nHarden the control plane around real usage by reclaiming Firecracker API sockets for the user, restarting stale daemons after rebuilds, and returning the correct `vm.create` payload so the CLI and TUI creation flow work reliably.\n\nValidation: `go test ./...`, `make build`, and a host-side smoke test with `./banger vm create --name codex-smoke`.
1385 lines
36 KiB
Go
1385 lines
36 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"banger/internal/api"
|
|
"banger/internal/model"
|
|
"banger/internal/paths"
|
|
"banger/internal/rpc"
|
|
"banger/internal/system"
|
|
|
|
"github.com/charmbracelet/bubbles/help"
|
|
"github.com/charmbracelet/bubbles/key"
|
|
"github.com/charmbracelet/bubbles/spinner"
|
|
"github.com/charmbracelet/bubbles/table"
|
|
"github.com/charmbracelet/bubbles/textinput"
|
|
"github.com/charmbracelet/bubbles/viewport"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/mattn/go-isatty"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
const tuiRefreshInterval = 3 * time.Second
|
|
|
|
type tuiMode int
|
|
|
|
const (
|
|
tuiModeBrowse tuiMode = iota
|
|
tuiModeForm
|
|
tuiModeConfirmDelete
|
|
)
|
|
|
|
type actionKind string
|
|
|
|
const (
|
|
actionCreate actionKind = "create"
|
|
actionEdit actionKind = "edit"
|
|
actionStart actionKind = "start"
|
|
actionStop actionKind = "stop"
|
|
actionRestart actionKind = "restart"
|
|
actionDelete actionKind = "delete"
|
|
actionSSH actionKind = "ssh"
|
|
actionLogs actionKind = "logs"
|
|
)
|
|
|
|
type dataLoadedMsg struct {
|
|
vms []model.VMRecord
|
|
images []model.Image
|
|
focusID string
|
|
err error
|
|
}
|
|
|
|
type statsLoadedMsg struct {
|
|
id string
|
|
stats model.VMStats
|
|
err error
|
|
}
|
|
|
|
type actionResultMsg struct {
|
|
action actionRequest
|
|
focusID string
|
|
status string
|
|
err error
|
|
refresh bool
|
|
}
|
|
|
|
type externalPreparedMsg struct {
|
|
action actionRequest
|
|
command *exec.Cmd
|
|
doneStatus string
|
|
refresh bool
|
|
err error
|
|
}
|
|
|
|
type sudoValidatedMsg struct {
|
|
err error
|
|
}
|
|
|
|
type refreshTickMsg struct{}
|
|
|
|
type actionRequest struct {
|
|
kind actionKind
|
|
id string
|
|
name string
|
|
create api.VMCreateParams
|
|
set api.VMSetParams
|
|
}
|
|
|
|
type browseKeyMap struct {
|
|
refresh key.Binding
|
|
create key.Binding
|
|
edit key.Binding
|
|
start key.Binding
|
|
stop key.Binding
|
|
restart key.Binding
|
|
delete key.Binding
|
|
ssh key.Binding
|
|
logs key.Binding
|
|
help key.Binding
|
|
quit key.Binding
|
|
}
|
|
|
|
func newBrowseKeyMap() browseKeyMap {
|
|
return browseKeyMap{
|
|
refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
|
|
create: key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "create")),
|
|
edit: key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")),
|
|
start: key.NewBinding(key.WithKeys("s"), key.WithHelp("s", "start")),
|
|
stop: key.NewBinding(key.WithKeys("x"), key.WithHelp("x", "stop")),
|
|
restart: key.NewBinding(key.WithKeys("R"), key.WithHelp("R", "restart")),
|
|
delete: key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "delete")),
|
|
ssh: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "ssh")),
|
|
logs: key.NewBinding(key.WithKeys("l"), key.WithHelp("l", "logs")),
|
|
help: key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
|
|
quit: key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")),
|
|
}
|
|
}
|
|
|
|
func (k browseKeyMap) ShortHelp() []key.Binding {
|
|
return []key.Binding{k.refresh, k.create, k.edit, k.start, k.stop, k.delete, k.ssh, k.logs, k.quit}
|
|
}
|
|
|
|
func (k browseKeyMap) FullHelp() [][]key.Binding {
|
|
return [][]key.Binding{
|
|
{k.refresh, k.create, k.edit, k.start, k.stop, k.restart, k.delete},
|
|
{k.ssh, k.logs, k.help, k.quit},
|
|
}
|
|
}
|
|
|
|
type formKeyMap struct {
|
|
next key.Binding
|
|
prev key.Binding
|
|
change key.Binding
|
|
toggle key.Binding
|
|
submit key.Binding
|
|
cancel key.Binding
|
|
}
|
|
|
|
func newFormKeyMap() formKeyMap {
|
|
return formKeyMap{
|
|
next: key.NewBinding(key.WithKeys("tab", "down"), key.WithHelp("tab", "next")),
|
|
prev: key.NewBinding(key.WithKeys("shift+tab", "up"), key.WithHelp("shift+tab", "prev")),
|
|
change: key.NewBinding(key.WithKeys("left", "right"), key.WithHelp("left/right", "change")),
|
|
toggle: key.NewBinding(key.WithKeys(" "), key.WithHelp("space", "toggle")),
|
|
submit: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "save")),
|
|
cancel: key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
|
|
}
|
|
}
|
|
|
|
func (k formKeyMap) ShortHelp() []key.Binding {
|
|
return []key.Binding{k.next, k.change, k.toggle, k.submit, k.cancel}
|
|
}
|
|
|
|
func (k formKeyMap) FullHelp() [][]key.Binding {
|
|
return [][]key.Binding{{k.next, k.prev, k.change}, {k.toggle, k.submit, k.cancel}}
|
|
}
|
|
|
|
type confirmKeyMap struct {
|
|
confirm key.Binding
|
|
cancel key.Binding
|
|
}
|
|
|
|
func newConfirmKeyMap() confirmKeyMap {
|
|
return confirmKeyMap{
|
|
confirm: key.NewBinding(key.WithKeys("enter", "y"), key.WithHelp("enter", "confirm")),
|
|
cancel: key.NewBinding(key.WithKeys("esc", "n"), key.WithHelp("esc", "cancel")),
|
|
}
|
|
}
|
|
|
|
func (k confirmKeyMap) ShortHelp() []key.Binding {
|
|
return []key.Binding{k.confirm, k.cancel}
|
|
}
|
|
|
|
func (k confirmKeyMap) FullHelp() [][]key.Binding {
|
|
return [][]key.Binding{{k.confirm, k.cancel}}
|
|
}
|
|
|
|
type formFieldKind int
|
|
|
|
const (
|
|
formFieldText formFieldKind = iota
|
|
formFieldSelect
|
|
)
|
|
|
|
type formField struct {
|
|
label string
|
|
kind formFieldKind
|
|
input textinput.Model
|
|
options []string
|
|
index int
|
|
}
|
|
|
|
func newTextField(label, value string) formField {
|
|
input := textinput.New()
|
|
input.Prompt = ""
|
|
input.SetValue(value)
|
|
input.CharLimit = 128
|
|
return formField{
|
|
label: label,
|
|
kind: formFieldText,
|
|
input: input,
|
|
}
|
|
}
|
|
|
|
func newSelectField(label string, options []string, index int) formField {
|
|
if len(options) == 0 {
|
|
options = []string{"<none>"}
|
|
index = 0
|
|
}
|
|
if index < 0 || index >= len(options) {
|
|
index = 0
|
|
}
|
|
return formField{
|
|
label: label,
|
|
kind: formFieldSelect,
|
|
options: options,
|
|
index: index,
|
|
}
|
|
}
|
|
|
|
func (f formField) value() string {
|
|
if f.kind == formFieldText {
|
|
return f.input.Value()
|
|
}
|
|
if len(f.options) == 0 {
|
|
return ""
|
|
}
|
|
return f.options[f.index]
|
|
}
|
|
|
|
type vmForm struct {
|
|
mode actionKind
|
|
title string
|
|
submitLabel string
|
|
targetID string
|
|
fields []formField
|
|
focus int
|
|
}
|
|
|
|
func newCreateVMForm(images []model.Image, cfg model.DaemonConfig) *vmForm {
|
|
imageOptions := imageNames(images)
|
|
selectedImage := 0
|
|
if cfg.DefaultImageName != "" {
|
|
for i, name := range imageOptions {
|
|
if name == cfg.DefaultImageName {
|
|
selectedImage = i
|
|
break
|
|
}
|
|
}
|
|
}
|
|
form := &vmForm{
|
|
mode: actionCreate,
|
|
title: "Create VM",
|
|
submitLabel: "Create",
|
|
fields: []formField{
|
|
newTextField("Name", ""),
|
|
newSelectField("Image", imageOptions, selectedImage),
|
|
newTextField("VCPU", strconv.Itoa(model.DefaultVCPUCount)),
|
|
newTextField("Memory (MiB)", strconv.Itoa(model.DefaultMemoryMiB)),
|
|
newTextField("System Overlay", model.FormatSizeBytes(model.DefaultSystemOverlaySize)),
|
|
newTextField("Work Disk", model.FormatSizeBytes(model.DefaultWorkDiskSize)),
|
|
newSelectField("NAT Enabled", []string{"no", "yes"}, 0),
|
|
newSelectField("No Start", []string{"no", "yes"}, 0),
|
|
},
|
|
}
|
|
form.focusField(0)
|
|
return form
|
|
}
|
|
|
|
func newEditVMForm(vm model.VMRecord) *vmForm {
|
|
form := &vmForm{
|
|
mode: actionEdit,
|
|
title: "Edit VM",
|
|
submitLabel: "Save",
|
|
targetID: vm.ID,
|
|
fields: []formField{
|
|
newTextField("VCPU", strconv.Itoa(vm.Spec.VCPUCount)),
|
|
newTextField("Memory (MiB)", strconv.Itoa(vm.Spec.MemoryMiB)),
|
|
newTextField("Work Disk", model.FormatSizeBytes(vm.Spec.WorkDiskSizeBytes)),
|
|
newSelectField("NAT Enabled", []string{"no", "yes"}, boolToIndex(vm.Spec.NATEnabled)),
|
|
},
|
|
}
|
|
form.focusField(0)
|
|
return form
|
|
}
|
|
|
|
func (f *vmForm) focusField(index int) tea.Cmd {
|
|
if len(f.fields) == 0 {
|
|
f.focus = 0
|
|
return nil
|
|
}
|
|
if f.focus >= 0 && f.focus < len(f.fields) && f.fields[f.focus].kind == formFieldText {
|
|
f.fields[f.focus].input.Blur()
|
|
}
|
|
f.focus = wrapIndex(index, len(f.fields))
|
|
if f.fields[f.focus].kind == formFieldText {
|
|
return f.fields[f.focus].input.Focus()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *vmForm) move(delta int) tea.Cmd {
|
|
return f.focusField(f.focus + delta)
|
|
}
|
|
|
|
func (f *vmForm) setWidth(width int) {
|
|
inputWidth := maxInt(12, width-22)
|
|
for i := range f.fields {
|
|
if f.fields[i].kind == formFieldText {
|
|
f.fields[i].input.Width = inputWidth
|
|
}
|
|
}
|
|
}
|
|
|
|
func (f *vmForm) update(msg tea.Msg) tea.Cmd {
|
|
if len(f.fields) == 0 {
|
|
return nil
|
|
}
|
|
if f.fields[f.focus].kind != formFieldText {
|
|
return nil
|
|
}
|
|
var cmd tea.Cmd
|
|
f.fields[f.focus].input, cmd = f.fields[f.focus].input.Update(msg)
|
|
return cmd
|
|
}
|
|
|
|
func (f *vmForm) change(delta int) {
|
|
if len(f.fields) == 0 {
|
|
return
|
|
}
|
|
field := &f.fields[f.focus]
|
|
if field.kind != formFieldSelect || len(field.options) == 0 {
|
|
return
|
|
}
|
|
field.index = wrapIndex(field.index+delta, len(field.options))
|
|
}
|
|
|
|
func (f *vmForm) view(width int) string {
|
|
f.setWidth(width)
|
|
titleStyle := lipgloss.NewStyle().Bold(true)
|
|
labelStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("245"))
|
|
activeStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
|
|
valueStyle := lipgloss.NewStyle().Bold(true)
|
|
|
|
lines := []string{titleStyle.Render(f.title), ""}
|
|
for i := range f.fields {
|
|
marker := " "
|
|
lbl := labelStyle.Render(f.fields[i].label)
|
|
if i == f.focus {
|
|
marker = "> "
|
|
lbl = activeStyle.Render(f.fields[i].label)
|
|
}
|
|
value := ""
|
|
if f.fields[i].kind == formFieldText {
|
|
value = f.fields[i].input.View()
|
|
} else {
|
|
value = valueStyle.Render(f.fields[i].value())
|
|
}
|
|
lines = append(lines, fmt.Sprintf("%s%-16s %s", marker, lbl, value))
|
|
}
|
|
lines = append(lines, "", fmt.Sprintf("Enter %s Esc cancel", strings.ToLower(f.submitLabel)))
|
|
|
|
style := lipgloss.NewStyle().
|
|
Border(lipgloss.NormalBorder()).
|
|
Padding(1, 2).
|
|
Width(maxInt(36, width))
|
|
return style.Render(strings.Join(lines, "\n"))
|
|
}
|
|
|
|
func (f *vmForm) submit() (actionRequest, error) {
|
|
switch f.mode {
|
|
case actionCreate:
|
|
return f.createRequest()
|
|
case actionEdit:
|
|
return f.editRequest()
|
|
default:
|
|
return actionRequest{}, errors.New("unsupported form mode")
|
|
}
|
|
}
|
|
|
|
func (f *vmForm) createRequest() (actionRequest, error) {
|
|
vcpu, err := parsePositiveInt("vcpu", f.fields[2].value())
|
|
if err != nil {
|
|
return actionRequest{}, err
|
|
}
|
|
memory, err := parsePositiveInt("memory", f.fields[3].value())
|
|
if err != nil {
|
|
return actionRequest{}, err
|
|
}
|
|
params := api.VMCreateParams{
|
|
Name: strings.TrimSpace(f.fields[0].value()),
|
|
ImageName: strings.TrimSpace(f.fields[1].value()),
|
|
VCPUCount: vcpu,
|
|
MemoryMiB: memory,
|
|
SystemOverlaySize: strings.TrimSpace(f.fields[4].value()),
|
|
WorkDiskSize: strings.TrimSpace(f.fields[5].value()),
|
|
NATEnabled: isYes(f.fields[6].value()),
|
|
NoStart: isYes(f.fields[7].value()),
|
|
}
|
|
if params.ImageName == "" || params.ImageName == "<none>" {
|
|
return actionRequest{}, errors.New("create requires an image")
|
|
}
|
|
return actionRequest{kind: actionCreate, create: params}, nil
|
|
}
|
|
|
|
func (f *vmForm) editRequest() (actionRequest, error) {
|
|
vcpu, err := parsePositiveInt("vcpu", f.fields[0].value())
|
|
if err != nil {
|
|
return actionRequest{}, err
|
|
}
|
|
memory, err := parsePositiveInt("memory", f.fields[1].value())
|
|
if err != nil {
|
|
return actionRequest{}, err
|
|
}
|
|
params, err := vmSetParamsFromFlags(
|
|
f.targetID,
|
|
vcpu,
|
|
memory,
|
|
strings.TrimSpace(f.fields[2].value()),
|
|
isYes(f.fields[3].value()),
|
|
false,
|
|
)
|
|
if err != nil {
|
|
return actionRequest{}, err
|
|
}
|
|
return actionRequest{
|
|
kind: actionEdit,
|
|
id: f.targetID,
|
|
set: params,
|
|
}, nil
|
|
}
|
|
|
|
type tuiModel struct {
|
|
layout paths.Layout
|
|
cfg model.DaemonConfig
|
|
|
|
width int
|
|
height int
|
|
ready bool
|
|
|
|
loading bool
|
|
busy string
|
|
sudoValidated bool
|
|
|
|
mode tuiMode
|
|
form *vmForm
|
|
pendingAction *actionRequest
|
|
|
|
vms []model.VMRecord
|
|
images []model.Image
|
|
selectedID string
|
|
selectedStats model.VMStats
|
|
statsID string
|
|
statsErr string
|
|
|
|
table table.Model
|
|
detail viewport.Model
|
|
help help.Model
|
|
spinner spinner.Model
|
|
|
|
browseKeys browseKeyMap
|
|
formKeys formKeyMap
|
|
confirmKeys confirmKeyMap
|
|
|
|
lastRefresh time.Time
|
|
statusText string
|
|
statusErr bool
|
|
}
|
|
|
|
func newTUIModel(layout paths.Layout, cfg model.DaemonConfig) tuiModel {
|
|
vmTable := table.New(
|
|
table.WithColumns([]table.Column{
|
|
{Title: "NAME", Width: 18},
|
|
{Title: "STATE", Width: 9},
|
|
{Title: "IP", Width: 14},
|
|
{Title: "VCPU", Width: 4},
|
|
{Title: "MEM", Width: 8},
|
|
{Title: "DISK", Width: 8},
|
|
{Title: "AGE", Width: 12},
|
|
}),
|
|
table.WithRows(nil),
|
|
table.WithFocused(true),
|
|
table.WithHeight(10),
|
|
table.WithWidth(60),
|
|
table.WithKeyMap(tuiTableKeyMap()),
|
|
)
|
|
tableStyles := table.DefaultStyles()
|
|
tableStyles.Header = lipgloss.NewStyle().Bold(true).Padding(0, 1)
|
|
tableStyles.Cell = lipgloss.NewStyle().Padding(0, 1)
|
|
tableStyles.Selected = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("230")).Background(lipgloss.Color("62"))
|
|
vmTable.SetStyles(tableStyles)
|
|
|
|
detail := viewport.New(0, 0)
|
|
detail.Style = lipgloss.NewStyle()
|
|
|
|
spin := spinner.New(spinner.WithSpinner(spinner.Line))
|
|
spin.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("69"))
|
|
|
|
helpView := help.New()
|
|
|
|
return tuiModel{
|
|
layout: layout,
|
|
cfg: cfg,
|
|
table: vmTable,
|
|
detail: detail,
|
|
help: helpView,
|
|
spinner: spin,
|
|
browseKeys: newBrowseKeyMap(),
|
|
formKeys: newFormKeyMap(),
|
|
confirmKeys: newConfirmKeyMap(),
|
|
loading: true,
|
|
statusText: "Loading VMs...",
|
|
}
|
|
}
|
|
|
|
func newTUICommand() *cobra.Command {
|
|
return &cobra.Command{
|
|
Use: "tui",
|
|
Short: "Launch a terminal UI to manage VMs",
|
|
Args: noArgsUsage("usage: banger tui"),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
if !isatty.IsTerminal(os.Stdin.Fd()) || !isatty.IsTerminal(os.Stdout.Fd()) {
|
|
return errors.New("tui requires an interactive terminal")
|
|
}
|
|
layout, cfg, err := ensureDaemon(cmd.Context())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
program := tea.NewProgram(newTUIModel(layout, cfg), tea.WithAltScreen())
|
|
return program.Start()
|
|
},
|
|
}
|
|
}
|
|
|
|
func (m tuiModel) Init() tea.Cmd {
|
|
return tea.Batch(m.spinner.Tick, refreshTickCmd(), fetchDataCmd(m.layout, ""))
|
|
}
|
|
|
|
func (m tuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
var cmds []tea.Cmd
|
|
|
|
if m.loading || m.busy != "" {
|
|
var spinCmd tea.Cmd
|
|
m.spinner, spinCmd = m.spinner.Update(msg)
|
|
cmds = append(cmds, spinCmd)
|
|
}
|
|
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
m.ready = true
|
|
m.width = msg.Width
|
|
m.height = msg.Height
|
|
m.resize()
|
|
case dataLoadedMsg:
|
|
m.loading = false
|
|
if msg.err != nil {
|
|
m.setStatus(msg.err.Error(), true)
|
|
break
|
|
}
|
|
m.images = msg.images
|
|
m.vms = msg.vms
|
|
targetID := m.selectedID
|
|
if msg.focusID != "" {
|
|
targetID = msg.focusID
|
|
}
|
|
m.selectedID = resolveSelectedID(targetID, msg.vms)
|
|
m.lastRefresh = time.Now()
|
|
m.rebuildTable()
|
|
m.setStatus(fmt.Sprintf("Loaded %d VM(s)", len(msg.vms)), false)
|
|
if m.selectedID != "" {
|
|
cmds = append(cmds, fetchStatsCmd(m.layout, m.selectedID))
|
|
} else {
|
|
m.selectedStats = model.VMStats{}
|
|
m.statsID = ""
|
|
m.statsErr = ""
|
|
}
|
|
case statsLoadedMsg:
|
|
if msg.id != m.selectedID {
|
|
break
|
|
}
|
|
if msg.err != nil {
|
|
m.statsErr = msg.err.Error()
|
|
m.setStatus(msg.err.Error(), true)
|
|
break
|
|
}
|
|
m.selectedStats = msg.stats
|
|
m.statsID = msg.id
|
|
m.statsErr = ""
|
|
case actionResultMsg:
|
|
m.busy = ""
|
|
if msg.err != nil {
|
|
if looksLikeSudoExpiry(msg.err) {
|
|
m.sudoValidated = false
|
|
}
|
|
m.setStatus(msg.err.Error(), true)
|
|
break
|
|
}
|
|
if msg.action.kind == actionCreate || msg.action.kind == actionEdit {
|
|
m.form = nil
|
|
m.mode = tuiModeBrowse
|
|
}
|
|
if msg.action.kind == actionDelete {
|
|
m.mode = tuiModeBrowse
|
|
}
|
|
m.setStatus(msg.status, false)
|
|
if msg.refresh {
|
|
m.loading = true
|
|
cmds = append(cmds, m.spinner.Tick, fetchDataCmd(m.layout, msg.focusID))
|
|
}
|
|
case externalPreparedMsg:
|
|
if msg.err != nil {
|
|
m.setStatus(msg.err.Error(), true)
|
|
break
|
|
}
|
|
cmds = append(cmds, tea.ExecProcess(msg.command, func(err error) tea.Msg {
|
|
return actionResultMsg{
|
|
action: msg.action,
|
|
status: msg.doneStatus,
|
|
err: normalizeExecError(err),
|
|
refresh: msg.refresh,
|
|
focusID: m.selectedID,
|
|
}
|
|
}))
|
|
case sudoValidatedMsg:
|
|
if msg.err != nil {
|
|
m.pendingAction = nil
|
|
m.busy = ""
|
|
m.setStatus(msg.err.Error(), true)
|
|
break
|
|
}
|
|
m.sudoValidated = true
|
|
if m.pendingAction != nil {
|
|
action := *m.pendingAction
|
|
m.pendingAction = nil
|
|
m.busy = action.activity()
|
|
cmds = append(cmds, m.spinner.Tick, m.runActionCmd(action))
|
|
}
|
|
case refreshTickMsg:
|
|
cmds = append(cmds, refreshTickCmd())
|
|
if m.busy == "" && m.mode == tuiModeBrowse {
|
|
m.loading = true
|
|
cmds = append(cmds, m.spinner.Tick, fetchDataCmd(m.layout, m.selectedID))
|
|
}
|
|
case tea.KeyMsg:
|
|
switch m.mode {
|
|
case tuiModeBrowse:
|
|
nextModel, extraCmds := m.updateBrowse(msg)
|
|
m = nextModel
|
|
cmds = append(cmds, extraCmds...)
|
|
case tuiModeForm:
|
|
nextModel, extraCmds := m.updateForm(msg)
|
|
m = nextModel
|
|
cmds = append(cmds, extraCmds...)
|
|
case tuiModeConfirmDelete:
|
|
nextModel, extraCmds := m.updateConfirmDelete(msg)
|
|
m = nextModel
|
|
cmds = append(cmds, extraCmds...)
|
|
}
|
|
}
|
|
|
|
m.refreshDetail()
|
|
return m, tea.Batch(cmds...)
|
|
}
|
|
|
|
func (m tuiModel) updateBrowse(msg tea.KeyMsg) (tuiModel, []tea.Cmd) {
|
|
var cmds []tea.Cmd
|
|
switch {
|
|
case key.Matches(msg, m.browseKeys.quit):
|
|
cmds = append(cmds, tea.Quit)
|
|
case key.Matches(msg, m.browseKeys.help):
|
|
m.help.ShowAll = !m.help.ShowAll
|
|
case key.Matches(msg, m.browseKeys.refresh):
|
|
m.loading = true
|
|
cmds = append(cmds, m.spinner.Tick, fetchDataCmd(m.layout, m.selectedID))
|
|
case key.Matches(msg, m.browseKeys.create):
|
|
if len(m.images) == 0 {
|
|
m.setStatus("Create requires at least one image", true)
|
|
return m, cmds
|
|
}
|
|
m.form = newCreateVMForm(m.images, m.cfg)
|
|
m.mode = tuiModeForm
|
|
cmds = append(cmds, m.form.focusField(m.form.focus))
|
|
case key.Matches(msg, m.browseKeys.edit):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
if vm.State == model.VMStateRunning {
|
|
m.setStatus("Stop the VM before editing it", true)
|
|
return m, cmds
|
|
}
|
|
m.form = newEditVMForm(vm)
|
|
m.mode = tuiModeForm
|
|
cmds = append(cmds, m.form.focusField(m.form.focus))
|
|
case key.Matches(msg, m.browseKeys.delete):
|
|
if _, ok := m.selectedVM(); !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
m.mode = tuiModeConfirmDelete
|
|
case key.Matches(msg, m.browseKeys.start):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
if vm.State == model.VMStateRunning {
|
|
m.setStatus("VM is already running", true)
|
|
return m, cmds
|
|
}
|
|
cmds = append(cmds, m.dispatchAction(actionRequest{kind: actionStart, id: vm.ID, name: vm.Name}))
|
|
case key.Matches(msg, m.browseKeys.stop):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
if vm.State != model.VMStateRunning {
|
|
m.setStatus("VM is not running", true)
|
|
return m, cmds
|
|
}
|
|
cmds = append(cmds, m.dispatchAction(actionRequest{kind: actionStop, id: vm.ID, name: vm.Name}))
|
|
case key.Matches(msg, m.browseKeys.restart):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
cmds = append(cmds, m.dispatchAction(actionRequest{kind: actionRestart, id: vm.ID, name: vm.Name}))
|
|
case key.Matches(msg, m.browseKeys.ssh):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
if vm.State != model.VMStateRunning {
|
|
m.setStatus("SSH requires a running VM", true)
|
|
return m, cmds
|
|
}
|
|
cmds = append(cmds, m.runActionCmd(actionRequest{kind: actionSSH, id: vm.ID, name: vm.Name}))
|
|
case key.Matches(msg, m.browseKeys.logs):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.setStatus("No VM selected", true)
|
|
return m, cmds
|
|
}
|
|
cmds = append(cmds, m.runActionCmd(actionRequest{kind: actionLogs, id: vm.ID, name: vm.Name}))
|
|
default:
|
|
if len(m.vms) == 0 {
|
|
return m, cmds
|
|
}
|
|
oldCursor := m.table.Cursor()
|
|
var tableCmd tea.Cmd
|
|
m.table, tableCmd = m.table.Update(msg)
|
|
cmds = append(cmds, tableCmd)
|
|
if m.table.Cursor() != oldCursor {
|
|
if vm, ok := m.selectedVMByCursor(); ok {
|
|
m.selectedID = vm.ID
|
|
m.selectedStats = model.VMStats{}
|
|
m.statsID = ""
|
|
m.statsErr = ""
|
|
cmds = append(cmds, fetchStatsCmd(m.layout, vm.ID))
|
|
}
|
|
}
|
|
}
|
|
return m, cmds
|
|
}
|
|
|
|
func (m tuiModel) updateForm(msg tea.KeyMsg) (tuiModel, []tea.Cmd) {
|
|
var cmds []tea.Cmd
|
|
switch {
|
|
case key.Matches(msg, m.formKeys.cancel):
|
|
m.form = nil
|
|
m.mode = tuiModeBrowse
|
|
case key.Matches(msg, m.formKeys.next):
|
|
cmds = append(cmds, m.form.move(1))
|
|
case key.Matches(msg, m.formKeys.prev):
|
|
cmds = append(cmds, m.form.move(-1))
|
|
case key.Matches(msg, m.formKeys.change):
|
|
switch msg.String() {
|
|
case "left":
|
|
m.form.change(-1)
|
|
case "right":
|
|
m.form.change(1)
|
|
}
|
|
case key.Matches(msg, m.formKeys.toggle):
|
|
m.form.change(1)
|
|
case key.Matches(msg, m.formKeys.submit):
|
|
action, err := m.form.submit()
|
|
if err != nil {
|
|
m.setStatus(err.Error(), true)
|
|
return m, cmds
|
|
}
|
|
cmds = append(cmds, m.dispatchAction(action))
|
|
default:
|
|
cmds = append(cmds, m.form.update(msg))
|
|
}
|
|
return m, cmds
|
|
}
|
|
|
|
func (m tuiModel) updateConfirmDelete(msg tea.KeyMsg) (tuiModel, []tea.Cmd) {
|
|
switch {
|
|
case key.Matches(msg, m.confirmKeys.cancel):
|
|
m.mode = tuiModeBrowse
|
|
return m, nil
|
|
case key.Matches(msg, m.confirmKeys.confirm):
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.mode = tuiModeBrowse
|
|
m.setStatus("No VM selected", true)
|
|
return m, nil
|
|
}
|
|
return m, []tea.Cmd{m.dispatchAction(actionRequest{kind: actionDelete, id: vm.ID, name: vm.Name})}
|
|
default:
|
|
return m, nil
|
|
}
|
|
}
|
|
|
|
func (m tuiModel) View() string {
|
|
if !m.ready {
|
|
return "Loading..."
|
|
}
|
|
header := m.renderHeader()
|
|
body := m.renderBody()
|
|
status := m.renderStatus()
|
|
m.help.Width = m.width
|
|
helpView := m.help.View(m.currentKeyMap())
|
|
return lipgloss.JoinVertical(lipgloss.Left, header, body, status, helpView)
|
|
}
|
|
|
|
func (m tuiModel) currentKeyMap() help.KeyMap {
|
|
switch m.mode {
|
|
case tuiModeForm:
|
|
return m.formKeys
|
|
case tuiModeConfirmDelete:
|
|
return m.confirmKeys
|
|
default:
|
|
return m.browseKeys
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) resize() {
|
|
bodyHeight := m.bodyHeight()
|
|
leftWidth := maxInt(42, (m.width*55)/100)
|
|
if leftWidth > m.width-24 {
|
|
leftWidth = maxInt(24, m.width/2)
|
|
}
|
|
rightWidth := maxInt(24, m.width-leftWidth-1)
|
|
|
|
leftInnerWidth := maxInt(20, leftWidth-4)
|
|
rightInnerWidth := maxInt(20, rightWidth-4)
|
|
panelInnerHeight := maxInt(8, bodyHeight-2)
|
|
|
|
m.table.SetWidth(leftInnerWidth)
|
|
m.table.SetHeight(maxInt(4, panelInnerHeight-2))
|
|
m.detail.Width = rightInnerWidth
|
|
m.detail.Height = maxInt(4, panelInnerHeight-2)
|
|
if m.form != nil {
|
|
m.form.setWidth(maxInt(28, minInt(58, m.width-10)))
|
|
}
|
|
}
|
|
|
|
func (m tuiModel) bodyHeight() int {
|
|
return maxInt(8, m.height-4)
|
|
}
|
|
|
|
func (m tuiModel) renderHeader() string {
|
|
status := "idle"
|
|
if m.loading {
|
|
status = m.spinner.View() + " loading"
|
|
} else if m.busy != "" {
|
|
status = m.spinner.View() + " " + m.busy
|
|
}
|
|
refreshed := "never"
|
|
if !m.lastRefresh.IsZero() {
|
|
refreshed = relativeTime(m.lastRefresh)
|
|
}
|
|
header := fmt.Sprintf("banger tui socket %s %s last refresh %s", filepath.Base(m.layout.SocketPath), status, refreshed)
|
|
return lipgloss.NewStyle().Bold(true).Width(m.width).Render(header)
|
|
}
|
|
|
|
func (m tuiModel) renderBody() string {
|
|
bodyHeight := m.bodyHeight()
|
|
if m.mode == tuiModeForm && m.form != nil {
|
|
return lipgloss.Place(m.width, bodyHeight, lipgloss.Center, lipgloss.Center, m.form.view(minInt(58, m.width-10)))
|
|
}
|
|
if m.mode == tuiModeConfirmDelete {
|
|
return lipgloss.Place(m.width, bodyHeight, lipgloss.Center, lipgloss.Center, m.confirmDeleteView())
|
|
}
|
|
|
|
leftWidth := maxInt(42, (m.width*55)/100)
|
|
if leftWidth > m.width-24 {
|
|
leftWidth = maxInt(24, m.width/2)
|
|
}
|
|
rightWidth := maxInt(24, m.width-leftWidth-1)
|
|
leftInnerWidth := maxInt(20, leftWidth-4)
|
|
rightInnerWidth := maxInt(20, rightWidth-4)
|
|
panelHeight := maxInt(8, bodyHeight-1)
|
|
|
|
leftContent := m.table.View()
|
|
if len(m.vms) == 0 {
|
|
leftContent = "No VMs.\n\nPress c to create one."
|
|
}
|
|
leftPanel := lipgloss.NewStyle().
|
|
Border(lipgloss.NormalBorder()).
|
|
Padding(0, 1).
|
|
Width(leftWidth).
|
|
Height(panelHeight).
|
|
Render(lipgloss.NewStyle().Width(leftInnerWidth).Render(leftContent))
|
|
|
|
rightPanel := lipgloss.NewStyle().
|
|
Border(lipgloss.NormalBorder()).
|
|
Padding(0, 1).
|
|
Width(rightWidth).
|
|
Height(panelHeight).
|
|
Render(lipgloss.NewStyle().Width(rightInnerWidth).Render(m.detail.View()))
|
|
|
|
return lipgloss.JoinHorizontal(lipgloss.Top, leftPanel, rightPanel)
|
|
}
|
|
|
|
func (m tuiModel) confirmDeleteView() string {
|
|
vm, ok := m.selectedVM()
|
|
name := "this VM"
|
|
if ok {
|
|
name = vm.Name
|
|
}
|
|
content := fmt.Sprintf("Delete %s?\n\nThis removes the VM and its persistent state.\n\nEnter confirm Esc cancel", name)
|
|
return lipgloss.NewStyle().
|
|
Border(lipgloss.NormalBorder()).
|
|
Padding(1, 2).
|
|
Width(54).
|
|
Render(content)
|
|
}
|
|
|
|
func (m tuiModel) renderStatus() string {
|
|
if m.statusText == "" {
|
|
return " "
|
|
}
|
|
style := lipgloss.NewStyle().Foreground(lipgloss.Color("70"))
|
|
if m.statusErr {
|
|
style = lipgloss.NewStyle().Foreground(lipgloss.Color("160"))
|
|
}
|
|
return style.Width(m.width).Render(m.statusText)
|
|
}
|
|
|
|
func (m *tuiModel) rebuildTable() {
|
|
rows := make([]table.Row, 0, len(m.vms))
|
|
cursor := 0
|
|
for i, vm := range m.vms {
|
|
rows = append(rows, table.Row{
|
|
vm.Name,
|
|
string(vm.State),
|
|
vm.Runtime.GuestIP,
|
|
strconv.Itoa(vm.Spec.VCPUCount),
|
|
fmt.Sprintf("%dM", vm.Spec.MemoryMiB),
|
|
model.FormatSizeBytes(vm.Spec.WorkDiskSizeBytes),
|
|
relativeTime(vm.CreatedAt),
|
|
})
|
|
if vm.ID == m.selectedID {
|
|
cursor = i
|
|
}
|
|
}
|
|
m.table.SetRows(rows)
|
|
if len(rows) > 0 {
|
|
m.table.SetCursor(cursor)
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) refreshDetail() {
|
|
vm, ok := m.selectedVM()
|
|
if !ok {
|
|
m.detail.SetContent("No VM selected.\n\nUse c to create a VM.")
|
|
return
|
|
}
|
|
stats := vm.Stats
|
|
if m.statsID == vm.ID && !m.selectedStats.CollectedAt.IsZero() {
|
|
stats = m.selectedStats
|
|
}
|
|
lines := []string{
|
|
fmt.Sprintf("Name: %s", vm.Name),
|
|
fmt.Sprintf("State: %s", vm.State),
|
|
fmt.Sprintf("IP: %s", orDash(vm.Runtime.GuestIP)),
|
|
fmt.Sprintf("DNS: %s", orDash(vm.Runtime.DNSName)),
|
|
fmt.Sprintf("Image: %s", shortID(vm.ImageID)),
|
|
"",
|
|
"Config",
|
|
fmt.Sprintf(" vCPU: %d", vm.Spec.VCPUCount),
|
|
fmt.Sprintf(" Memory: %d MiB", vm.Spec.MemoryMiB),
|
|
fmt.Sprintf(" Overlay: %s", model.FormatSizeBytes(vm.Spec.SystemOverlaySizeByte)),
|
|
fmt.Sprintf(" Work disk: %s", model.FormatSizeBytes(vm.Spec.WorkDiskSizeBytes)),
|
|
fmt.Sprintf(" NAT: %s", yesNo(vm.Spec.NATEnabled)),
|
|
"",
|
|
"Usage",
|
|
fmt.Sprintf(" Overlay: %s", formatBytes(stats.SystemOverlayBytes)),
|
|
fmt.Sprintf(" Work disk: %s", formatBytes(stats.WorkDiskBytes)),
|
|
fmt.Sprintf(" CPU: %.1f%%", stats.CPUPercent),
|
|
fmt.Sprintf(" RSS: %s", formatBytes(stats.RSSBytes)),
|
|
fmt.Sprintf(" VSZ: %s", formatBytes(stats.VSZBytes)),
|
|
}
|
|
if !stats.CollectedAt.IsZero() {
|
|
lines = append(lines, fmt.Sprintf(" Updated: %s", stats.CollectedAt.Format(time.RFC3339)))
|
|
}
|
|
lines = append(lines,
|
|
"",
|
|
"Timestamps",
|
|
fmt.Sprintf(" Created: %s", vm.CreatedAt.Format(time.RFC3339)),
|
|
fmt.Sprintf(" Updated: %s", vm.UpdatedAt.Format(time.RFC3339)),
|
|
fmt.Sprintf(" Touched: %s", vm.LastTouchedAt.Format(time.RFC3339)),
|
|
)
|
|
if vm.Runtime.LastError != "" {
|
|
lines = append(lines, "", "Last error", " "+vm.Runtime.LastError)
|
|
}
|
|
if m.statsErr != "" && m.statsID == vm.ID {
|
|
lines = append(lines, "", "Stats error", " "+m.statsErr)
|
|
}
|
|
m.detail.SetContent(strings.Join(lines, "\n"))
|
|
}
|
|
|
|
func (m *tuiModel) setStatus(text string, isErr bool) {
|
|
m.statusText = text
|
|
m.statusErr = isErr
|
|
}
|
|
|
|
func (m tuiModel) selectedVM() (model.VMRecord, bool) {
|
|
for _, vm := range m.vms {
|
|
if vm.ID == m.selectedID {
|
|
return vm, true
|
|
}
|
|
}
|
|
return model.VMRecord{}, false
|
|
}
|
|
|
|
func (m tuiModel) selectedVMByCursor() (model.VMRecord, bool) {
|
|
cursor := m.table.Cursor()
|
|
if cursor < 0 || cursor >= len(m.vms) {
|
|
return model.VMRecord{}, false
|
|
}
|
|
return m.vms[cursor], true
|
|
}
|
|
|
|
func (m *tuiModel) dispatchAction(action actionRequest) tea.Cmd {
|
|
if action.needsSudo() && !m.sudoValidated {
|
|
m.pendingAction = &action
|
|
m.busy = "Authorizing sudo..."
|
|
return tea.ExecProcess(exec.Command("sudo", "-v"), func(err error) tea.Msg {
|
|
return sudoValidatedMsg{err: err}
|
|
})
|
|
}
|
|
m.busy = action.activity()
|
|
return tea.Batch(m.spinner.Tick, m.runActionCmd(action))
|
|
}
|
|
|
|
func (m tuiModel) runActionCmd(action actionRequest) tea.Cmd {
|
|
switch action.kind {
|
|
case actionCreate:
|
|
return createActionCmd(m.layout, action)
|
|
case actionEdit:
|
|
return editActionCmd(m.layout, action)
|
|
case actionStart, actionStop, actionRestart:
|
|
return lifecycleActionCmd(m.layout, action)
|
|
case actionDelete:
|
|
return deleteActionCmd(m.layout, action)
|
|
case actionSSH:
|
|
return prepareSSHCmd(m.layout, m.cfg, action)
|
|
case actionLogs:
|
|
return prepareLogsCmd(m.layout, action)
|
|
default:
|
|
return func() tea.Msg {
|
|
return actionResultMsg{action: action, err: fmt.Errorf("unsupported action %s", action.kind)}
|
|
}
|
|
}
|
|
}
|
|
|
|
func createActionCmd(layout paths.Layout, action actionRequest) tea.Cmd {
|
|
return func() tea.Msg {
|
|
result, err := rpc.Call[api.VMShowResult](context.Background(), layout.SocketPath, "vm.create", action.create)
|
|
if err != nil {
|
|
return actionResultMsg{action: action, err: err}
|
|
}
|
|
return actionResultMsg{
|
|
action: action,
|
|
focusID: result.VM.ID,
|
|
status: fmt.Sprintf("created %s", result.VM.Name),
|
|
refresh: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
func editActionCmd(layout paths.Layout, action actionRequest) tea.Cmd {
|
|
return func() tea.Msg {
|
|
result, err := rpc.Call[api.VMShowResult](context.Background(), layout.SocketPath, "vm.set", action.set)
|
|
if err != nil {
|
|
return actionResultMsg{action: action, err: err}
|
|
}
|
|
return actionResultMsg{
|
|
action: action,
|
|
focusID: result.VM.ID,
|
|
status: fmt.Sprintf("updated %s", result.VM.Name),
|
|
refresh: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
func lifecycleActionCmd(layout paths.Layout, action actionRequest) tea.Cmd {
|
|
method := ""
|
|
status := ""
|
|
switch action.kind {
|
|
case actionStart:
|
|
method = "vm.start"
|
|
status = "started"
|
|
case actionStop:
|
|
method = "vm.stop"
|
|
status = "stopped"
|
|
case actionRestart:
|
|
method = "vm.restart"
|
|
status = "restarted"
|
|
}
|
|
return func() tea.Msg {
|
|
result, err := rpc.Call[api.VMShowResult](context.Background(), layout.SocketPath, method, api.VMRefParams{IDOrName: action.id})
|
|
if err != nil {
|
|
return actionResultMsg{action: action, err: err}
|
|
}
|
|
return actionResultMsg{
|
|
action: action,
|
|
focusID: result.VM.ID,
|
|
status: fmt.Sprintf("%s %s", status, result.VM.Name),
|
|
refresh: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
func deleteActionCmd(layout paths.Layout, action actionRequest) tea.Cmd {
|
|
return func() tea.Msg {
|
|
_, err := rpc.Call[api.VMShowResult](context.Background(), layout.SocketPath, "vm.delete", api.VMRefParams{IDOrName: action.id})
|
|
if err != nil {
|
|
return actionResultMsg{action: action, err: err}
|
|
}
|
|
return actionResultMsg{
|
|
action: action,
|
|
status: fmt.Sprintf("deleted %s", action.name),
|
|
refresh: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
func prepareSSHCmd(layout paths.Layout, cfg model.DaemonConfig, action actionRequest) tea.Cmd {
|
|
return func() tea.Msg {
|
|
result, err := rpc.Call[api.VMSSHResult](context.Background(), layout.SocketPath, "vm.ssh", api.VMRefParams{IDOrName: action.id})
|
|
if err != nil {
|
|
return externalPreparedMsg{action: action, err: err}
|
|
}
|
|
args, err := sshCommandArgs(cfg, result.GuestIP, nil)
|
|
if err != nil {
|
|
return externalPreparedMsg{action: action, err: err}
|
|
}
|
|
return externalPreparedMsg{
|
|
action: action,
|
|
command: exec.Command("ssh", args...),
|
|
doneStatus: fmt.Sprintf("ssh session ended for %s", result.Name),
|
|
refresh: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
func prepareLogsCmd(layout paths.Layout, action actionRequest) tea.Cmd {
|
|
return func() tea.Msg {
|
|
result, err := rpc.Call[api.VMLogsResult](context.Background(), layout.SocketPath, "vm.logs", api.VMRefParams{IDOrName: action.id})
|
|
if err != nil {
|
|
return externalPreparedMsg{action: action, err: err}
|
|
}
|
|
if result.LogPath == "" {
|
|
return externalPreparedMsg{action: action, err: errors.New("vm has no log path")}
|
|
}
|
|
return externalPreparedMsg{
|
|
action: action,
|
|
command: system.TailCommand(result.LogPath, true),
|
|
doneStatus: fmt.Sprintf("closed log view for %s", action.name),
|
|
refresh: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
func fetchDataCmd(layout paths.Layout, focusID string) tea.Cmd {
|
|
return func() tea.Msg {
|
|
vms, err := rpc.Call[api.VMListResult](context.Background(), layout.SocketPath, "vm.list", api.Empty{})
|
|
if err != nil {
|
|
return dataLoadedMsg{err: err, focusID: focusID}
|
|
}
|
|
images, err := rpc.Call[api.ImageListResult](context.Background(), layout.SocketPath, "image.list", api.Empty{})
|
|
if err != nil {
|
|
return dataLoadedMsg{vms: vms.VMs, err: err, focusID: focusID}
|
|
}
|
|
return dataLoadedMsg{vms: vms.VMs, images: images.Images, focusID: focusID}
|
|
}
|
|
}
|
|
|
|
func fetchStatsCmd(layout paths.Layout, id string) tea.Cmd {
|
|
return func() tea.Msg {
|
|
result, err := rpc.Call[api.VMStatsResult](context.Background(), layout.SocketPath, "vm.stats", api.VMRefParams{IDOrName: id})
|
|
if err != nil {
|
|
return statsLoadedMsg{id: id, err: err}
|
|
}
|
|
return statsLoadedMsg{id: id, stats: result.Stats}
|
|
}
|
|
}
|
|
|
|
func refreshTickCmd() tea.Cmd {
|
|
return tea.Tick(tuiRefreshInterval, func(time.Time) tea.Msg {
|
|
return refreshTickMsg{}
|
|
})
|
|
}
|
|
|
|
func resolveSelectedID(targetID string, vms []model.VMRecord) string {
|
|
if len(vms) == 0 {
|
|
return ""
|
|
}
|
|
if targetID != "" {
|
|
for _, vm := range vms {
|
|
if vm.ID == targetID {
|
|
return targetID
|
|
}
|
|
}
|
|
}
|
|
return vms[0].ID
|
|
}
|
|
|
|
func imageNames(images []model.Image) []string {
|
|
names := make([]string, 0, len(images))
|
|
for _, image := range images {
|
|
names = append(names, image.Name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
func tuiTableKeyMap() table.KeyMap {
|
|
return table.KeyMap{
|
|
LineUp: key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("up", "up")),
|
|
LineDown: key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("down", "down")),
|
|
PageUp: key.NewBinding(key.WithKeys("pgup"), key.WithHelp("pgup", "page up")),
|
|
PageDown: key.NewBinding(key.WithKeys("pgdown"), key.WithHelp("pgdn", "page down")),
|
|
HalfPageUp: key.NewBinding(key.WithKeys("ctrl+u"), key.WithHelp("ctrl+u", "half up")),
|
|
HalfPageDown: key.NewBinding(key.WithKeys("ctrl+d"), key.WithHelp("ctrl+d", "half down")),
|
|
GotoTop: key.NewBinding(key.WithKeys("home"), key.WithHelp("home", "top")),
|
|
GotoBottom: key.NewBinding(key.WithKeys("end"), key.WithHelp("end", "bottom")),
|
|
}
|
|
}
|
|
|
|
func (a actionRequest) needsSudo() bool {
|
|
switch a.kind {
|
|
case actionCreate, actionEdit, actionStart, actionStop, actionRestart, actionDelete:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (a actionRequest) activity() string {
|
|
switch a.kind {
|
|
case actionCreate:
|
|
return "Creating VM..."
|
|
case actionEdit:
|
|
return "Saving VM..."
|
|
case actionStart:
|
|
return "Starting VM..."
|
|
case actionStop:
|
|
return "Stopping VM..."
|
|
case actionRestart:
|
|
return "Restarting VM..."
|
|
case actionDelete:
|
|
return "Deleting VM..."
|
|
case actionSSH:
|
|
return "Opening SSH..."
|
|
case actionLogs:
|
|
return "Opening logs..."
|
|
default:
|
|
return "Working..."
|
|
}
|
|
}
|
|
|
|
func parsePositiveInt(label, raw string) (int, error) {
|
|
value, err := strconv.Atoi(strings.TrimSpace(raw))
|
|
if err != nil || value <= 0 {
|
|
return 0, fmt.Errorf("%s must be a positive integer", label)
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func normalizeExecError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
var exitErr *exec.ExitError
|
|
if errors.As(err, &exitErr) && exitErr.ExitCode() == 130 {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
func looksLikeSudoExpiry(err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
text := err.Error()
|
|
return strings.Contains(text, "sudo") || strings.Contains(text, "password is required")
|
|
}
|
|
|
|
func formatBytes(bytes int64) string {
|
|
if bytes <= 0 {
|
|
return "0"
|
|
}
|
|
const (
|
|
kib = 1024
|
|
mib = 1024 * kib
|
|
gib = 1024 * mib
|
|
)
|
|
switch {
|
|
case bytes >= gib:
|
|
return fmt.Sprintf("%.1fG", float64(bytes)/gib)
|
|
case bytes >= mib:
|
|
return fmt.Sprintf("%.1fM", float64(bytes)/mib)
|
|
case bytes >= kib:
|
|
return fmt.Sprintf("%.1fK", float64(bytes)/kib)
|
|
default:
|
|
return strconv.FormatInt(bytes, 10) + "B"
|
|
}
|
|
}
|
|
|
|
func boolToIndex(value bool) int {
|
|
if value {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func yesNo(value bool) string {
|
|
if value {
|
|
return "yes"
|
|
}
|
|
return "no"
|
|
}
|
|
|
|
func isYes(value string) bool {
|
|
return strings.EqualFold(strings.TrimSpace(value), "yes")
|
|
}
|
|
|
|
func orDash(value string) string {
|
|
if strings.TrimSpace(value) == "" {
|
|
return "-"
|
|
}
|
|
return value
|
|
}
|
|
|
|
func wrapIndex(value, length int) int {
|
|
if length <= 0 {
|
|
return 0
|
|
}
|
|
for value < 0 {
|
|
value += length
|
|
}
|
|
return value % length
|
|
}
|
|
|
|
func maxInt(a, b int) int {
|
|
if a > b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func minInt(a, b int) int {
|
|
if a < b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|