fork/gdu

git clone https://git.julia.blue/fork/gdu

Julia RyanRestore cursor pos on rescan98ee348

ignore
11.7 KiB485 linesraw
1package tui
2
3import (
4	"bytes"
5	"fmt"
6	"io"
7	"os"
8	"os/exec"
9	"runtime"
10	"runtime/debug"
11	"strconv"
12	"strings"
13	"time"
14
15	"golang.org/x/text/cases"
16	"golang.org/x/text/language"
17
18	"github.com/gdamore/tcell/v2"
19	"github.com/rivo/tview"
20
21	"github.com/dundee/gdu/v5/build"
22	"github.com/dundee/gdu/v5/pkg/analyze"
23	"github.com/dundee/gdu/v5/pkg/device"
24	"github.com/dundee/gdu/v5/pkg/fs"
25	"github.com/dundee/gdu/v5/report"
26)
27
28const (
29	defaultLinesCount = 500
30	linesThreshold    = 20
31)
32
33// ListDevices lists mounted devices and shows their disk usage
34func (ui *UI) ListDevices(getter device.DevicesInfoGetter) error {
35	var err error
36	ui.getter = getter
37	ui.devices, err = getter.GetDevicesInfo()
38	if err != nil {
39		return err
40	}
41
42	ui.showDevices()
43
44	return nil
45}
46
47// AnalyzePath analyzes recursively disk usage for given path
48func (ui *UI) AnalyzePath(path string, parentDir fs.Item) error {
49	ui.progress = tview.NewTextView().SetText("Scanning...")
50	ui.progress.SetBorder(true).SetBorderPadding(2, 2, 2, 2)
51	ui.progress.SetTitle(" Scanning... ")
52	ui.progress.SetDynamicColors(true)
53
54	innerFlex := tview.NewFlex().SetDirection(tview.FlexRow).
55		AddItem(nil, 0, 1, false).
56		AddItem(ui.progress, 8, 1, false)
57
58	if ui.currentDeviceSize > 0 && ui.showDiskProgressBar {
59		ui.progressBar = NewProgressBar()
60		ui.progressBar.SetBorder(true)
61		ui.progressBar.SetTitle(" Progress ")
62		ui.progressBar.SetUseColor(ui.UseColors)
63		innerFlex.AddItem(ui.progressBar, 3, 1, false)
64	}
65
66	innerFlex.AddItem(nil, 0, 1, false)
67
68	flex := tview.NewFlex().
69		AddItem(nil, 0, 1, false).
70		AddItem(innerFlex, 0, 50, false).
71		AddItem(nil, 0, 1, false)
72
73	ui.pages.AddPage("progress", flex, true, true)
74	ui.progressFlex = flex
75
76	ui.Analyzer.ResetProgress()
77
78	analyzer := ui.Analyzer
79	doneChan := analyzer.GetDone()
80	go ui.updateProgress(analyzer, doneChan)
81
82	ui.scanStart = time.Now()
83	ui.scanning = true
84	ui.scanCancelled = false
85
86	restoreSelection := ui.restoreSelection
87	restoreRow := ui.restoreRow
88	restoreOffsetX := ui.restoreOffsetX
89	restoreOffsetY := ui.restoreOffsetY
90	ui.restoreSelection = false
91
92	go func() {
93		defer debug.FreeOSMemory()
94		currentDir := analyzer.AnalyzeDir(path, ui.CreateIgnoreFunc(), ui.CreateFileTypeFilter())
95
96		if parentDir != nil {
97			currentDir.SetParent(parentDir)
98			// Remove old entry with the same name and add new one
99			parentDir.RemoveFileByName(currentDir.GetName())
100			parentDir.AddFile(currentDir)
101		} else {
102			ui.topDirPath = path
103			ui.topDir = currentDir
104		}
105
106		if ui.IsFilteringFiles() {
107			ui.topDir.UpdateStatsWithFileFiltering(ui.linkedItems)
108		} else {
109			ui.topDir.UpdateStats(ui.linkedItems)
110		}
111
112		ui.app.QueueUpdateDraw(func() {
113			ui.scanning = false
114			ui.scanCancelled = false
115			// remember the longest scan so we can guard against accidental quits
116			if d := time.Since(ui.scanStart); d > ui.scanDuration {
117				ui.scanDuration = d
118			}
119			// the finished scan replaces any mid-scan preview
120			ui.previewing = false
121			ui.previewSavedDir = nil
122			ui.currentDir = currentDir
123			ui.showDir()
124			if restoreSelection {
125				ui.table.Select(min(restoreRow, ui.table.GetRowCount()-1), 0)
126				ui.table.SetOffset(min(restoreOffsetX, ui.table.GetRowCount()-1), restoreOffsetY)
127			}
128			ui.pages.RemovePage("progress")
129		})
130
131		if ui.done != nil {
132			ui.done <- struct{}{}
133		}
134	}()
135
136	return nil
137}
138
139// ReadAnalysis reads analysis report from JSON file
140func (ui *UI) ReadAnalysis(input io.Reader) error {
141	ui.progress = tview.NewTextView().SetText("Reading analysis from file...")
142	ui.progress.SetBorder(true).SetBorderPadding(2, 2, 2, 2)
143	ui.progress.SetTitle(" Reading... ")
144	ui.progress.SetDynamicColors(true)
145
146	flex := tview.NewFlex().
147		AddItem(nil, 0, 1, false).
148		AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
149			AddItem(nil, 10, 1, false).
150			AddItem(ui.progress, 8, 1, false).
151			AddItem(nil, 10, 1, false), 0, 50, false).
152		AddItem(nil, 0, 1, false)
153
154	ui.pages.AddPage("progress", flex, true, true)
155
156	go func() {
157		var err error
158		ui.currentDir, err = report.ReadAnalysis(input)
159		if err != nil {
160			ui.app.QueueUpdateDraw(func() {
161				ui.pages.RemovePage("progress")
162				ui.showErr("Error reading file", err)
163			})
164			if ui.done != nil {
165				ui.done <- struct{}{}
166			}
167			return
168		}
169		runtime.GC()
170
171		ui.topDirPath = ui.currentDir.GetPath()
172		ui.topDir = ui.currentDir
173
174		links := make(fs.HardLinkedItems, 10)
175		ui.topDir.UpdateStats(links)
176
177		ui.app.QueueUpdateDraw(func() {
178			ui.showDir()
179			ui.pages.RemovePage("progress")
180		})
181
182		if ui.done != nil {
183			ui.done <- struct{}{}
184		}
185	}()
186
187	return nil
188}
189
190// ReadFromStorage reads analysis data from persistent key-value storage
191func (ui *UI) ReadFromStorage(storagePath, path string) error {
192	storage := analyze.NewStorage(storagePath, path)
193	closeFn := storage.Open()
194	defer closeFn()
195
196	dir, err := storage.GetDirForPath(path)
197	if err != nil {
198		return err
199	}
200
201	ui.currentDir = dir
202	ui.topDirPath = ui.currentDir.GetPath()
203	ui.topDir = ui.currentDir
204
205	ui.showDir()
206	return nil
207}
208
209func (ui *UI) delete(action DeleteAction) {
210	if len(ui.markedRows) > 0 {
211		ui.deleteMarked(action)
212	} else {
213		ui.deleteSelected(action)
214	}
215}
216
217func (ui *UI) deleteSelected(action DeleteAction) {
218	row, column := ui.table.GetSelection()
219	selectedItem := ui.table.GetCell(row, column).GetReference().(fs.Item)
220
221	if ui.deleteInBackground {
222		ui.queueForDeletion([]fs.Item{selectedItem}, action)
223		return
224	}
225
226	acting := action.Acting()
227	modal := tview.NewModal().SetText(
228		cases.Title(language.English).String(acting) +
229			" " +
230			tview.Escape(selectedItem.GetName()) +
231			"...",
232	)
233	ui.pages.AddPage(acting, modal, true, true)
234
235	var currentDir fs.Item
236	var deleteItems []fs.Item
237	if action == ActionEmpty && selectedItem.IsDir() {
238		currentDir = selectedItem
239		for file := range currentDir.GetFiles(fs.SortBySize, fs.SortDesc) {
240			deleteItems = append(deleteItems, file)
241		}
242	} else {
243		currentDir = ui.currentDir
244		deleteItems = append(deleteItems, selectedItem)
245	}
246
247	var deleteFun func(fs.Item, fs.Item) error
248	switch action {
249	case ActionEmpty:
250		if !selectedItem.IsDir() {
251			deleteFun = ui.emptier
252		} else {
253			deleteFun = ui.remover
254		}
255	case ActionMoveToTrash:
256		deleteFun = ui.trasher
257	case ActionDelete:
258		deleteFun = ui.remover
259	}
260	go func() {
261		for _, item := range deleteItems {
262			if err := deleteFun(currentDir, item); err != nil {
263				msg := "Can't " + action.Verb() + " " + tview.Escape(selectedItem.GetName())
264				ui.app.QueueUpdateDraw(func() {
265					ui.pages.RemovePage(acting)
266					ui.showErr(msg, err)
267				})
268				if ui.done != nil {
269					ui.done <- struct{}{}
270				}
271				return
272			}
273		}
274
275		ui.app.QueueUpdateDraw(func() {
276			ui.pages.RemovePage(acting)
277			x, y := ui.table.GetOffset()
278			ui.showDir()
279			ui.table.Select(min(row, ui.table.GetRowCount()-1), 0)
280			ui.table.SetOffset(min(x, ui.table.GetRowCount()-1), y)
281		})
282
283		if ui.done != nil {
284			ui.done <- struct{}{}
285		}
286	}()
287}
288
289func (ui *UI) showInfo() {
290	if ui.currentDir == nil {
291		return
292	}
293
294	var content, numberColor string
295	row, column := ui.table.GetSelection()
296	selectedFile := ui.table.GetCell(row, column).GetReference().(fs.Item)
297
298	if ui.UseColors {
299		numberColor = fmt.Sprintf(
300			"[%s::b]",
301			ui.resultRow.NumberColor,
302		)
303	} else {
304		numberColor = defaultColorBold
305	}
306
307	linesCount := 12
308
309	text := tview.NewTextView().SetDynamicColors(true)
310	text.SetBorder(true).SetBorderPadding(2, 2, 2, 2)
311	text.SetBorderColor(tcell.ColorDefault)
312	text.SetTitle(" Item info ")
313
314	content += "[::b]Name:[::-] "
315	content += tview.Escape(selectedFile.GetName()) + "\n"
316	content += "[::b]Path:[::-] "
317	content += tview.Escape(
318		strings.TrimPrefix(selectedFile.GetPath(), build.RootPathPrefix),
319	) + "\n"
320	content += "[::b]Type:[::-] " + selectedFile.GetType() + "\n"
321
322	// Display symlink target
323	if line := ui.symlinkTargetInfoLine(selectedFile); line != "" {
324		content += line
325		linesCount++
326	}
327
328	content += "\n"
329
330	content += "   [::b]Disk usage:[::-] "
331	content += numberColor + ui.formatSize(selectedFile.GetUsage(), false, true)
332	content += fmt.Sprintf(" (%s%d[-::] B)", numberColor, selectedFile.GetUsage()) + "\n"
333	content += "[::b]Apparent size:[::-] "
334	content += numberColor + ui.formatSize(selectedFile.GetSize(), false, true)
335	content += fmt.Sprintf(" (%s%d[-::] B)", numberColor, selectedFile.GetSize()) + "\n"
336
337	if selectedFile.GetMultiLinkedInode() > 0 {
338		linkedItems := ui.linkedItems[selectedFile.GetMultiLinkedInode()]
339		linesCount += 2 + len(linkedItems)
340		content += "\nHard-linked files:\n"
341		for _, linkedItem := range linkedItems {
342			content += "\t" + linkedItem.GetPath() + "\n"
343		}
344	}
345
346	text.SetText(content)
347
348	flex := tview.NewFlex().
349		AddItem(nil, 0, 1, false).
350		AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
351			AddItem(nil, 0, 1, false).
352			AddItem(text, linesCount, 1, false).
353			AddItem(nil, 0, 1, false), 80, 1, false).
354		AddItem(nil, 0, 1, false)
355
356	ui.pages.AddPage("info", flex, true, true)
357}
358
359// symlinkTargetInfoLine returns the "Target:" info-panel line for a symlink
360// item, or an empty string when symlink-target display is disabled or the item
361// has no symlink target.
362func (ui *UI) symlinkTargetInfoLine(item fs.Item) string {
363	if !ui.showSymlinkTarget {
364		return ""
365	}
366	si, ok := item.(fs.SymlinkItem)
367	if !ok {
368		return ""
369	}
370	target := si.GetSymlinkTarget()
371	if target == "" {
372		return ""
373	}
374	return "[::b]Target:[::-] " + tview.Escape(target) + "\n"
375}
376
377func (ui *UI) openItem() {
378	row, column := ui.table.GetSelection()
379	selectedFile, ok := ui.table.GetCell(row, column).GetReference().(fs.Item)
380	if !ok || selectedFile == ui.currentDir.GetParent() {
381		return
382	}
383
384	openBinary := "xdg-open"
385
386	switch runtime.GOOS {
387	case "darwin":
388		openBinary = "open"
389	case "windows":
390		openBinary = "explorer"
391	}
392
393	cmd := exec.Command(openBinary, selectedFile.GetPath())
394	err := cmd.Start()
395	if err != nil {
396		ui.showErr("Error opening", err)
397	}
398}
399
400func (ui *UI) confirmExport() *tview.Form {
401	form := tview.NewForm().
402		AddInputField("File name", "export.json", 30, nil, func(v string) {
403			ui.exportName = v
404		}).
405		AddButton("Export", ui.exportAnalysis).
406		SetButtonsAlign(tview.AlignCenter)
407	form.SetBorder(true).
408		SetTitle(" Export data to JSON ").
409		SetInputCapture(func(key *tcell.EventKey) *tcell.EventKey {
410			if key.Key() == tcell.KeyEsc {
411				ui.pages.RemovePage("export")
412				ui.app.SetFocus(ui.table)
413				return nil
414			}
415			return key
416		})
417	flex := modal(form, 50, 7)
418	ui.pages.AddPage("export", flex, true, true)
419	ui.app.SetFocus(form)
420	return form
421}
422
423func (ui *UI) exportAnalysis() {
424	ui.pages.RemovePage("export")
425
426	text := tview.NewTextView().SetText("Export in progress...").SetTextAlign(tview.AlignCenter)
427	text.SetBorder(true).SetTitle(" Export data to JSON ")
428	flex := modal(text, 50, 3)
429	ui.pages.AddPage("exporting", flex, true, true)
430
431	go func() {
432		var err error
433		defer ui.app.QueueUpdateDraw(func() {
434			ui.pages.RemovePage("exporting")
435			if err == nil {
436				ui.app.SetFocus(ui.table)
437			}
438		})
439		if ui.done != nil {
440			defer func() {
441				ui.done <- struct{}{}
442			}()
443		}
444
445		var buff bytes.Buffer
446
447		buff.Write([]byte(`[1,2,{"progname":"gdu","progver":"`))
448		buff.Write([]byte(build.Version))
449		buff.Write([]byte(`","timestamp":`))
450		buff.Write([]byte(strconv.FormatInt(time.Now().Unix(), 10)))
451		buff.Write([]byte("},\n"))
452
453		file, err := os.Create(ui.exportName)
454		if err != nil {
455			ui.showErrFromGo("Error creating file", err)
456			return
457		}
458		defer file.Close()
459
460		if err = ui.topDir.EncodeJSON(&buff, true, nil); err != nil {
461			ui.showErrFromGo("Error encoding JSON", err)
462			return
463		}
464
465		if _, err = buff.Write([]byte("]\n")); err != nil {
466			ui.showErrFromGo("Error writing to buffer", err)
467			return
468		}
469		if _, err = buff.WriteTo(file); err != nil {
470			ui.showErrFromGo("Error writing to file", err)
471			return
472		}
473	}()
474}
475
476func (ui *UI) isInArchive() bool {
477	if ui.currentDir == nil {
478		return false
479	}
480	if _, ok := ui.currentDir.(*analyze.ZipDir); ok {
481		return true
482	}
483	_, ok := ui.currentDir.(*analyze.TarDir)
484	return ok
485}