344 lines
9.5 KiB
Go
344 lines
9.5 KiB
Go
package tui
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/lipgloss"
|
|
|
|
"github.com/illustris/i-am-gcroot/internal/filter"
|
|
"github.com/illustris/i-am-gcroot/internal/roots"
|
|
)
|
|
|
|
var (
|
|
styleHeader = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("12"))
|
|
styleColHeader = lipgloss.NewStyle().Bold(true).Underline(true)
|
|
styleCursor = lipgloss.NewStyle().Reverse(true)
|
|
styleMarked = lipgloss.NewStyle().Foreground(lipgloss.Color("11")).Bold(true)
|
|
styleDim = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
|
|
styleErr = lipgloss.NewStyle().Foreground(lipgloss.Color("9"))
|
|
styleOK = lipgloss.NewStyle().Foreground(lipgloss.Color("10"))
|
|
styleBox = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).Padding(0, 1)
|
|
|
|
kindColor = map[roots.Kind]lipgloss.Color{
|
|
roots.KindIndirect: "14",
|
|
roots.KindProfile: "13",
|
|
roots.KindDirect: "12",
|
|
roots.KindDangling: "9",
|
|
roots.KindRuntime: "8",
|
|
}
|
|
)
|
|
|
|
func (m *Model) View() string {
|
|
if m.quitting {
|
|
return ""
|
|
}
|
|
if m.width == 0 {
|
|
return "loading..."
|
|
}
|
|
switch m.mode {
|
|
case modeHelp:
|
|
return m.overlay(helpText)
|
|
case modeDetails:
|
|
return m.overlay(m.details())
|
|
case modeResults:
|
|
return m.overlay(m.resultsView())
|
|
case modeConfirmDelete:
|
|
return m.overlay(m.confirmView())
|
|
case modeConfirmGC:
|
|
return m.overlay("Run nix-store --gc now?\n\nThis deletes every store path that is no longer reachable from a root.\n\n[y] yes [n] no")
|
|
}
|
|
return m.listView()
|
|
}
|
|
|
|
func (m *Model) overlay(body string) string {
|
|
box := styleBox.Width(min(m.width-4, 120)).Render(body)
|
|
return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, box)
|
|
}
|
|
|
|
const (
|
|
wMark = 2
|
|
wKind = 9
|
|
wOwner = 10
|
|
wAge = 6
|
|
wSize = 8
|
|
)
|
|
|
|
func (m *Model) columns() (link, target int) {
|
|
rest := m.width - wMark - wKind - wOwner - wAge - wSize - 6
|
|
if rest < 20 {
|
|
rest = 20
|
|
}
|
|
target = rest * 2 / 5
|
|
return rest - target, target
|
|
}
|
|
|
|
func (m *Model) listView() string {
|
|
var b strings.Builder
|
|
st := m.set.Status()
|
|
|
|
title := styleHeader.Render("i-am-gcroot")
|
|
info := fmt.Sprintf(" %d roots, %d shown, %d marked (up to %s)", st.Total, len(m.view), len(m.marks), filter.HumanSize(m.markedSize()))
|
|
if m.opts.WebURL != "" {
|
|
info += styleDim.Render(" web: " + m.opts.WebURL)
|
|
}
|
|
b.WriteString(trunc(title+info, m.width+20) + "\n")
|
|
|
|
wl, wt := m.columns()
|
|
hdr := fmt.Sprintf("%-*s %-*s %-*s %*s %*s %-*s %-*s", wMark, "", wKind, "KIND", wOwner, "OWNER", wAge, "AGE", wSize, "CLOSURE", wl, "LINK", wt, "TARGET")
|
|
b.WriteString(styleColHeader.Render(trunc(hdr, m.width)) + "\n")
|
|
|
|
h := m.listHeight()
|
|
now := time.Now()
|
|
for i := m.offset; i < m.offset+h; i++ {
|
|
if i >= len(m.view) {
|
|
b.WriteString("\n")
|
|
continue
|
|
}
|
|
b.WriteString(m.row(&m.view[i], i == m.cursor, wl, wt, now) + "\n")
|
|
}
|
|
|
|
// footer
|
|
sortDir := "asc"
|
|
if m.desc {
|
|
sortDir = "desc"
|
|
}
|
|
hidden := " "
|
|
if m.hidden {
|
|
hidden = "x"
|
|
}
|
|
line := fmt.Sprintf("%s h[%s]hidden sort:%s %s", kindList(m.kinds), hidden, m.sortKey, sortDir)
|
|
if st.Sizing {
|
|
line += fmt.Sprintf(" sizing %d/%d", st.SizesDone, st.SizesTodo)
|
|
}
|
|
if m.scanning {
|
|
line += " scanning..."
|
|
}
|
|
b.WriteString(styleDim.Render(trunc(line, m.width)) + "\n")
|
|
b.WriteString(styleDim.Render(trunc(hints, m.width)) + "\n")
|
|
if a := m.activity(); a != "" {
|
|
b.WriteString(a + "\n")
|
|
}
|
|
if m.mode == modeFilter || m.input.Value() != "" {
|
|
b.WriteString(m.input.View())
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
const hints = "space mark a mark all d delete X delete+collect D dry-run g gc / filter s sort h hidden enter details R results ? help q quit"
|
|
|
|
// activity is the line under the key hints: a running operation, a filter
|
|
// error, or the outcome of the last operation.
|
|
func (m *Model) activity() string {
|
|
switch {
|
|
case m.busy != "":
|
|
return styleMarked.Render(trunc(fmt.Sprintf("%s... %ds", m.busy, int(time.Since(m.since).Seconds())), m.width))
|
|
case m.queryErr != "":
|
|
return styleErr.Render(trunc(m.queryErr, m.width))
|
|
case m.status == "":
|
|
return ""
|
|
case m.statusOK:
|
|
return styleOK.Render(trunc(m.status, m.width))
|
|
}
|
|
return styleErr.Render(trunc(m.status, m.width))
|
|
}
|
|
|
|
func (m *Model) row(r *roots.Root, cursor bool, wl, wt int, now time.Time) string {
|
|
mark := " "
|
|
if m.marks[r.Link] {
|
|
mark = "*"
|
|
} else if r.Protected {
|
|
mark = "!"
|
|
}
|
|
link := r.Link
|
|
if r.Kind == roots.KindRuntime && r.Command != "" {
|
|
link += " " + r.Command
|
|
}
|
|
target := r.TargetName()
|
|
switch {
|
|
case r.Kind == roots.KindRuntime && r.Count > 1:
|
|
target = fmt.Sprintf("(%d paths)", r.Count)
|
|
case r.Kind == roots.KindDangling:
|
|
target = "(missing)"
|
|
case r.Reason != "" && r.Target == "":
|
|
target = "(" + r.Reason + ")"
|
|
}
|
|
size := filter.HumanSize(r.ClosureSize)
|
|
if r.Kind == roots.KindDangling {
|
|
size = "-"
|
|
}
|
|
kind := fmt.Sprintf("%-*s", wKind, r.Kind)
|
|
if !cursor {
|
|
kind = lipgloss.NewStyle().Foreground(kindColor[r.Kind]).Render(kind)
|
|
}
|
|
s := fmt.Sprintf("%-*s %s %-*s %*s %*s %-*s %-*s",
|
|
wMark, mark, kind, wOwner, trunc(r.Owner, wOwner), wAge, filter.HumanAge(r.ModTime, now),
|
|
wSize, size, wl, midTrunc(link, wl), wt, trunc(target, wt))
|
|
switch {
|
|
case cursor:
|
|
return styleCursor.Render(s)
|
|
case m.marks[r.Link]:
|
|
return styleMarked.Render(s)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (m *Model) markedSize() int64 {
|
|
var n int64
|
|
for _, r := range m.all {
|
|
if m.marks[r.Link] && r.ClosureSize > 0 {
|
|
n += r.ClosureSize
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Model) details() string {
|
|
r := m.view[m.cursor]
|
|
var b strings.Builder
|
|
field := func(k, v string) {
|
|
if v != "" {
|
|
fmt.Fprintf(&b, "%s %s\n", styleHeader.Render(fmt.Sprintf("%-12s", k)), v)
|
|
}
|
|
}
|
|
field("kind", string(r.Kind))
|
|
field("link", r.Link)
|
|
field("via", r.Via)
|
|
field("target", r.Target)
|
|
field("owner", fmt.Sprintf("%s (uid %d)", r.Owner, r.UID))
|
|
if !r.ModTime.IsZero() {
|
|
field("modified", r.ModTime.Format(time.RFC3339)+" ("+filter.HumanAge(r.ModTime, time.Now())+" ago)")
|
|
}
|
|
if r.Kind == roots.KindProfile {
|
|
field("profile", r.Profile)
|
|
cur := ""
|
|
if r.Current {
|
|
cur = " (current)"
|
|
}
|
|
field("generation", fmt.Sprintf("%d%s", r.Generation, cur))
|
|
}
|
|
if r.Count > 0 {
|
|
field("store paths", fmt.Sprint(r.Count))
|
|
}
|
|
field("command", r.Command)
|
|
if r.Target != "" {
|
|
field("closure", filter.HumanSize(r.ClosureSize))
|
|
field("nar size", filter.HumanSize(r.NarSize))
|
|
}
|
|
if r.Protected {
|
|
field("protected", r.Reason)
|
|
} else {
|
|
field("note", r.Reason)
|
|
}
|
|
b.WriteString("\n" + styleDim.Render("esc to close"))
|
|
return b.String()
|
|
}
|
|
|
|
func (m *Model) confirmView() string {
|
|
var b strings.Builder
|
|
var size int64
|
|
protected := 0
|
|
for _, r := range m.pending {
|
|
if r.ClosureSize > 0 {
|
|
size += r.ClosureSize
|
|
}
|
|
if r.Protected {
|
|
protected++
|
|
}
|
|
}
|
|
verb := "Delete"
|
|
if m.collect {
|
|
verb = "Delete and garbage collect"
|
|
}
|
|
fmt.Fprintf(&b, "%s %d root(s)? Closures total up to %s (shared paths may stay alive).\n", verb, len(m.pending), filter.HumanSize(size))
|
|
if m.collect {
|
|
b.WriteString(styleDim.Render("Store paths only reachable through these roots are deleted right away.") + "\n")
|
|
}
|
|
b.WriteString("\n")
|
|
show := min(len(m.pending), max(3, m.height-12))
|
|
for _, r := range m.pending[:show] {
|
|
fmt.Fprintf(&b, " %-9s %s\n", r.Kind, r.Link)
|
|
}
|
|
if len(m.pending) > show {
|
|
fmt.Fprintf(&b, " ... and %d more\n", len(m.pending)-show)
|
|
}
|
|
if protected > 0 && !m.opts.Force {
|
|
b.WriteString(styleErr.Render(fmt.Sprintf("\n%d protected root(s) will be skipped (use --force to override).\n", protected)))
|
|
}
|
|
b.WriteString("\n[y] delete [n] cancel")
|
|
return b.String()
|
|
}
|
|
|
|
func (m *Model) resultsView() string {
|
|
var b strings.Builder
|
|
if m.dryRun {
|
|
b.WriteString(styleHeader.Render("Dry run: these actions would be taken") + "\n\n")
|
|
} else {
|
|
b.WriteString(styleHeader.Render("Delete results") + "\n\n")
|
|
}
|
|
if m.collected != "" {
|
|
b.WriteString(m.collected + "\n\n")
|
|
}
|
|
show := min(len(m.results), max(3, m.height-10))
|
|
for _, r := range m.results[:show] {
|
|
if r.OK() {
|
|
b.WriteString(styleOK.Render("ok ") + r.Action + "\n")
|
|
} else {
|
|
b.WriteString(styleErr.Render("fail ") + r.Link + ": " + r.Err + "\n")
|
|
}
|
|
}
|
|
if len(m.results) > show {
|
|
fmt.Fprintf(&b, "... and %d more\n", len(m.results)-show)
|
|
}
|
|
b.WriteString("\n" + styleDim.Render("esc to close"))
|
|
return b.String()
|
|
}
|
|
|
|
const helpText = `Keys
|
|
j/k, up/down, pgup/pgdn, home/end move
|
|
space / x mark/unmark root under cursor
|
|
a / A mark all shown (non-protected) / clear marks
|
|
d delete marked roots (or the one under cursor)
|
|
X delete, then garbage collect just the paths they held
|
|
D dry run: show what delete would do
|
|
g run nix-store --gc
|
|
/ edit filter, enter/esc to leave, esc again clears it
|
|
1-5 toggle kinds: indirect profile direct dangling runtime
|
|
0 reset kind toggles
|
|
h show/hide nix cache roots (~/.cache/nix/...)
|
|
s / S cycle sort key / reverse
|
|
enter details
|
|
R full results of the last delete / dry run
|
|
r rescan
|
|
q quit
|
|
|
|
Filter syntax (terms are ANDed, prefix with - to negate)
|
|
foo /regex/ kind:indirect,dangling owner:me under:/tmp
|
|
older:30d newer:2h size>1G size<10M is:protected is:current is:hidden`
|
|
|
|
func trunc(s string, w int) string {
|
|
if w <= 0 {
|
|
return ""
|
|
}
|
|
r := []rune(s)
|
|
if len(r) <= w {
|
|
return s
|
|
}
|
|
if w == 1 {
|
|
return string(r[:1])
|
|
}
|
|
return string(r[:w-1]) + "~"
|
|
}
|
|
|
|
// midTrunc keeps both ends of a path, which carry the most information.
|
|
func midTrunc(s string, w int) string {
|
|
r := []rune(s)
|
|
if len(r) <= w || w < 5 {
|
|
return trunc(s, w)
|
|
}
|
|
head := (w - 3) / 3
|
|
tail := w - 3 - head
|
|
return string(r[:head]) + "..." + string(r[len(r)-tail:])
|
|
}
|