518 lines
11 KiB
Go
518 lines
11 KiB
Go
// Package tui implements the interactive terminal interface.
|
|
package tui
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/textinput"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
|
|
"github.com/illustris/i-am-gcroot/internal/filter"
|
|
"github.com/illustris/i-am-gcroot/internal/roots"
|
|
)
|
|
|
|
type mode int
|
|
|
|
const (
|
|
modeNormal mode = iota
|
|
modeFilter
|
|
modeConfirmDelete
|
|
modeConfirmGC
|
|
modeDetails
|
|
modeResults
|
|
modeHelp
|
|
)
|
|
|
|
type Options struct {
|
|
Query string
|
|
Force bool
|
|
WebURL string // shown in the status bar when the web UI runs alongside
|
|
}
|
|
|
|
type Model struct {
|
|
ctx context.Context
|
|
set *roots.Set
|
|
opts Options
|
|
|
|
changed chan struct{}
|
|
|
|
all []roots.Root
|
|
view []roots.Root
|
|
cursor int
|
|
offset int
|
|
marks map[string]bool
|
|
kinds map[roots.Kind]bool
|
|
sortKey filter.SortKey
|
|
desc bool
|
|
hidden bool // show hidden (nix cache) roots
|
|
|
|
input textinput.Model
|
|
query *filter.Query
|
|
queryErr string
|
|
|
|
mode mode
|
|
pending []roots.Root // roots awaiting delete confirmation
|
|
collect bool // run a targeted GC after the pending delete
|
|
dryRun bool
|
|
results []roots.Result
|
|
collected string
|
|
status string
|
|
statusOK bool
|
|
busy string // long running operation, shown on the activity line
|
|
since time.Time
|
|
scanning bool
|
|
width int
|
|
height int
|
|
quitting bool
|
|
}
|
|
|
|
func New(ctx context.Context, set *roots.Set, opts Options) *Model {
|
|
ti := textinput.New()
|
|
ti.Prompt = "/ "
|
|
ti.Placeholder = "filter: text, /re/, kind:, owner:me, under:/tmp, older:30d, size>1G"
|
|
ti.SetValue(opts.Query)
|
|
m := &Model{
|
|
ctx: ctx,
|
|
set: set,
|
|
opts: opts,
|
|
changed: make(chan struct{}, 1),
|
|
marks: map[string]bool{},
|
|
kinds: defaultKinds(),
|
|
input: ti,
|
|
sortKey: filter.SortAge,
|
|
}
|
|
m.query, _ = filter.Parse(opts.Query)
|
|
set.OnChange(func() {
|
|
select {
|
|
case m.changed <- struct{}{}:
|
|
default:
|
|
}
|
|
})
|
|
return m
|
|
}
|
|
|
|
func defaultKinds() map[roots.Kind]bool {
|
|
k := map[roots.Kind]bool{}
|
|
for _, kind := range roots.AllKinds {
|
|
k[kind] = kind != roots.KindRuntime
|
|
}
|
|
return k
|
|
}
|
|
|
|
type changedMsg struct{}
|
|
type tickMsg struct{}
|
|
type refreshedMsg struct{ err error }
|
|
type deletedMsg struct {
|
|
results []roots.Result
|
|
dryRun bool
|
|
collected string // summary of the targeted GC, if one ran
|
|
}
|
|
type gcMsg struct {
|
|
summary string
|
|
err error
|
|
}
|
|
|
|
func (m *Model) waitChange() tea.Cmd {
|
|
return func() tea.Msg {
|
|
select {
|
|
case <-m.changed:
|
|
return changedMsg{}
|
|
case <-m.ctx.Done():
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m *Model) refresh() tea.Cmd {
|
|
m.scanning = true
|
|
return func() tea.Msg { return refreshedMsg{m.set.Refresh(m.ctx)} }
|
|
}
|
|
|
|
// startBusy shows an operation on the activity line with a running timer.
|
|
func (m *Model) startBusy(what string) tea.Cmd {
|
|
m.busy, m.since = what, time.Now()
|
|
return tick()
|
|
}
|
|
|
|
func tick() tea.Cmd {
|
|
return tea.Tick(time.Second, func(time.Time) tea.Msg { return tickMsg{} })
|
|
}
|
|
|
|
func (m *Model) setStatus(s string, ok bool) {
|
|
m.status, m.statusOK = s, ok
|
|
}
|
|
|
|
func (m *Model) Init() tea.Cmd {
|
|
return tea.Batch(m.refresh(), m.waitChange())
|
|
}
|
|
|
|
func (m *Model) reload() {
|
|
m.all = m.set.Snapshot()
|
|
m.apply()
|
|
}
|
|
|
|
func (m *Model) apply() {
|
|
var curLink string
|
|
if m.cursor < len(m.view) {
|
|
curLink = m.view[m.cursor].Link
|
|
}
|
|
m.view = filter.Apply(m.all, m.query, m.kinds, m.hidden, m.sortKey, m.desc)
|
|
m.cursor = 0
|
|
for i := range m.view {
|
|
if m.view[i].Link == curLink {
|
|
m.cursor = i
|
|
break
|
|
}
|
|
}
|
|
// forget marks that are no longer present at all
|
|
present := map[string]bool{}
|
|
for _, r := range m.all {
|
|
present[r.Link] = true
|
|
}
|
|
for l := range m.marks {
|
|
if !present[l] {
|
|
delete(m.marks, l)
|
|
}
|
|
}
|
|
m.clamp()
|
|
}
|
|
|
|
// footerLines is the number of lines below the list: kinds/sort, key hints,
|
|
// the activity line when there is something to report, and the filter.
|
|
func (m *Model) footerLines() int {
|
|
n := 2
|
|
if m.activity() != "" {
|
|
n++
|
|
}
|
|
if m.mode == modeFilter || m.input.Value() != "" {
|
|
n++
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Model) listHeight() int {
|
|
h := m.height - 2 - m.footerLines()
|
|
if h < 1 {
|
|
h = 1
|
|
}
|
|
return h
|
|
}
|
|
|
|
func (m *Model) clamp() {
|
|
if m.cursor >= len(m.view) {
|
|
m.cursor = len(m.view) - 1
|
|
}
|
|
if m.cursor < 0 {
|
|
m.cursor = 0
|
|
}
|
|
h := m.listHeight()
|
|
if m.cursor < m.offset {
|
|
m.offset = m.cursor
|
|
}
|
|
if m.cursor >= m.offset+h {
|
|
m.offset = m.cursor - h + 1
|
|
}
|
|
if m.offset > max(0, len(m.view)-h) {
|
|
m.offset = max(0, len(m.view)-h)
|
|
}
|
|
}
|
|
|
|
// selection returns marked roots, or the root under the cursor if nothing is
|
|
// marked.
|
|
func (m *Model) selection() []roots.Root {
|
|
var out []roots.Root
|
|
for _, r := range m.all {
|
|
if m.marks[r.Link] {
|
|
out = append(out, r)
|
|
}
|
|
}
|
|
if len(out) == 0 && m.cursor < len(m.view) {
|
|
out = append(out, m.view[m.cursor])
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
m.width, m.height = msg.Width, msg.Height
|
|
m.input.Width = max(10, msg.Width-4)
|
|
m.clamp()
|
|
return m, nil
|
|
case changedMsg:
|
|
m.reload()
|
|
return m, m.waitChange()
|
|
case tickMsg:
|
|
if m.busy != "" {
|
|
return m, tick()
|
|
}
|
|
return m, nil
|
|
case refreshedMsg:
|
|
m.scanning = false
|
|
if msg.err != nil {
|
|
m.setStatus("scan failed: "+msg.err.Error(), false)
|
|
}
|
|
m.reload()
|
|
return m, nil
|
|
case deletedMsg:
|
|
m.busy = ""
|
|
m.results = msg.results
|
|
m.dryRun = msg.dryRun
|
|
m.collected = msg.collected
|
|
m.setStatus(m.summarize(msg), true)
|
|
if !msg.dryRun {
|
|
gone := map[string]bool{}
|
|
for _, r := range msg.results {
|
|
if r.OK() {
|
|
gone[r.Link] = true
|
|
delete(m.marks, r.Link)
|
|
} else {
|
|
m.statusOK = false
|
|
}
|
|
}
|
|
m.set.Remove(gone)
|
|
}
|
|
return m, nil
|
|
case gcMsg:
|
|
m.busy = ""
|
|
if msg.err != nil {
|
|
m.setStatus("gc failed: "+msg.err.Error(), false)
|
|
} else {
|
|
m.setStatus("gc: "+msg.summary, true)
|
|
}
|
|
return m, m.refresh()
|
|
case tea.KeyMsg:
|
|
return m.handleKey(msg)
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (m *Model) handleKey(k tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
key := k.String()
|
|
if key == "ctrl+c" {
|
|
m.quitting = true
|
|
return m, tea.Quit
|
|
}
|
|
switch m.mode {
|
|
case modeFilter:
|
|
switch key {
|
|
case "enter", "esc":
|
|
m.mode = modeNormal
|
|
m.input.Blur()
|
|
return m, nil
|
|
}
|
|
var cmd tea.Cmd
|
|
m.input, cmd = m.input.Update(k)
|
|
q, err := filter.Parse(m.input.Value())
|
|
if err != nil {
|
|
m.queryErr = err.Error()
|
|
} else {
|
|
m.queryErr = ""
|
|
m.query = q
|
|
m.apply()
|
|
}
|
|
return m, cmd
|
|
case modeConfirmDelete:
|
|
switch key {
|
|
case "y", "Y":
|
|
m.mode = modeNormal
|
|
rs, opts, collect := m.pending, roots.DeleteOpts{Force: m.opts.Force}, m.collect
|
|
what := fmt.Sprintf("deleting %d root(s)", len(rs))
|
|
if collect {
|
|
what += " and collecting their garbage"
|
|
}
|
|
return m, tea.Batch(m.startBusy(what), func() tea.Msg {
|
|
res := roots.Delete(m.ctx, m.set.Cfg, rs, opts)
|
|
msg := deletedMsg{results: res}
|
|
if collect {
|
|
c, err := roots.Collect(m.ctx, m.set.Cfg, roots.CollectedTargets(res))
|
|
msg.collected = c.String()
|
|
if err != nil {
|
|
msg.collected += "; gc error: " + err.Error()
|
|
}
|
|
}
|
|
// rebuild the list from disk rather than trusting in-memory state
|
|
_ = m.set.Refresh(m.ctx)
|
|
return msg
|
|
})
|
|
case "n", "N", "esc", "q":
|
|
m.mode = modeNormal
|
|
}
|
|
return m, nil
|
|
case modeConfirmGC:
|
|
switch key {
|
|
case "y", "Y":
|
|
m.mode = modeNormal
|
|
return m, tea.Batch(m.startBusy("running nix-store --gc"), func() tea.Msg {
|
|
s, err := roots.GC(m.ctx, m.set.Cfg)
|
|
return gcMsg{s, err}
|
|
})
|
|
case "n", "N", "esc", "q":
|
|
m.mode = modeNormal
|
|
}
|
|
return m, nil
|
|
case modeDetails, modeResults, modeHelp:
|
|
switch key {
|
|
case "esc", "q", "enter", "?":
|
|
m.mode = modeNormal
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
switch key {
|
|
case "q":
|
|
m.quitting = true
|
|
return m, tea.Quit
|
|
case "esc":
|
|
if m.input.Value() != "" {
|
|
m.input.SetValue("")
|
|
m.query, _ = filter.Parse("")
|
|
m.apply()
|
|
}
|
|
case "/":
|
|
m.mode = modeFilter
|
|
return m, m.input.Focus()
|
|
case "up", "k":
|
|
m.cursor--
|
|
case "down", "j":
|
|
m.cursor++
|
|
case "pgup", "ctrl+b":
|
|
m.cursor -= m.listHeight()
|
|
case "pgdown", "ctrl+f":
|
|
m.cursor += m.listHeight()
|
|
case "home":
|
|
m.cursor = 0
|
|
case "end", "G":
|
|
m.cursor = len(m.view) - 1
|
|
case " ", "x":
|
|
if m.cursor < len(m.view) {
|
|
r := m.view[m.cursor]
|
|
if r.Deletable() {
|
|
if m.marks[r.Link] {
|
|
delete(m.marks, r.Link)
|
|
} else {
|
|
m.marks[r.Link] = true
|
|
}
|
|
}
|
|
}
|
|
case "a":
|
|
for _, r := range m.view {
|
|
if r.Deletable() && !r.Protected {
|
|
m.marks[r.Link] = true
|
|
}
|
|
}
|
|
case "A":
|
|
m.marks = map[string]bool{}
|
|
case "1", "2", "3", "4", "5":
|
|
kind := roots.AllKinds[int(key[0]-'1')]
|
|
m.kinds[kind] = !m.kinds[kind]
|
|
if kind == roots.KindRuntime && m.kinds[kind] && !m.set.Status().Runtime {
|
|
m.set.SetRuntime(true)
|
|
m.apply()
|
|
return m, m.refresh()
|
|
}
|
|
m.apply()
|
|
case "0":
|
|
m.kinds = defaultKinds()
|
|
m.apply()
|
|
case "s":
|
|
m.sortKey = (m.sortKey + 1) % filter.SortKey(len(filter.SortNames))
|
|
m.apply()
|
|
case "S":
|
|
m.desc = !m.desc
|
|
m.apply()
|
|
case "r":
|
|
return m, m.refresh()
|
|
case "enter":
|
|
if m.cursor < len(m.view) {
|
|
m.mode = modeDetails
|
|
}
|
|
case "d", "D", "X":
|
|
sel := m.selection()
|
|
if len(sel) == 0 {
|
|
return m, nil
|
|
}
|
|
if key == "D" {
|
|
return m, func() tea.Msg {
|
|
return deletedMsg{results: roots.Delete(m.ctx, m.set.Cfg, sel, roots.DeleteOpts{DryRun: true, Force: m.opts.Force}), dryRun: true}
|
|
}
|
|
}
|
|
if m.busy != "" {
|
|
m.setStatus("wait for "+m.busy+" to finish", false)
|
|
return m, nil
|
|
}
|
|
m.pending = sel
|
|
m.collect = key == "X"
|
|
m.mode = modeConfirmDelete
|
|
case "h":
|
|
m.hidden = !m.hidden
|
|
m.apply()
|
|
case "g":
|
|
if m.busy != "" {
|
|
m.setStatus("wait for "+m.busy+" to finish", false)
|
|
return m, nil
|
|
}
|
|
m.mode = modeConfirmGC
|
|
case "R":
|
|
if m.results != nil {
|
|
m.mode = modeResults
|
|
}
|
|
case "?":
|
|
m.mode = modeHelp
|
|
}
|
|
m.clamp()
|
|
return m, nil
|
|
}
|
|
|
|
func kindList(kinds map[roots.Kind]bool) string {
|
|
var parts []string
|
|
for i, k := range roots.AllKinds {
|
|
mark := " "
|
|
if kinds[k] {
|
|
mark = "x"
|
|
}
|
|
parts = append(parts, fmt.Sprintf("%d[%s]%s", i+1, mark, k))
|
|
}
|
|
return strings.Join(parts, " ")
|
|
}
|
|
|
|
// summarize turns a delete outcome into one status line; R shows the rest.
|
|
func (m *Model) summarize(msg deletedMsg) string {
|
|
var ok, failed []roots.Result
|
|
for _, r := range msg.results {
|
|
if r.OK() {
|
|
ok = append(ok, r)
|
|
} else {
|
|
failed = append(failed, r)
|
|
}
|
|
}
|
|
var s string
|
|
if msg.dryRun {
|
|
s = fmt.Sprintf("dry run: %d action(s)", len(ok))
|
|
if len(ok) > 0 {
|
|
s += ", e.g. " + ok[0].Action
|
|
}
|
|
if len(failed) > 0 {
|
|
s += fmt.Sprintf("; %d would fail", len(failed))
|
|
}
|
|
} else {
|
|
s = fmt.Sprintf("deleted %d/%d root(s)", len(ok), len(msg.results))
|
|
if msg.collected != "" {
|
|
s += "; " + msg.collected
|
|
} else if len(ok) > 0 {
|
|
s += "; g to collect garbage"
|
|
}
|
|
}
|
|
if len(failed) > 0 {
|
|
s += fmt.Sprintf("; failed %s: %s", filepath.Base(failed[0].Link), failed[0].Err)
|
|
if len(failed) > 1 {
|
|
s += fmt.Sprintf(" (+%d more)", len(failed)-1)
|
|
}
|
|
}
|
|
return s + " [R details]"
|
|
}
|