fork/gdu

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

Daniel Mildefeat: allow scanning multiple directories (#653)34f3996

master
14.0 KiB571 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// showScanProgressModal builds and shows the modal that reports scan progress.
48func (ui *UI) showScanProgressModal(title string) {
49	ui.progress = tview.NewTextView().SetText("Scanning...")
50	ui.progress.SetBorder(true).SetBorderPadding(2, 2, 2, 2)
51	ui.progress.SetTitle(title)
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
77// AnalyzePath analyzes recursively disk usage for given path
78func (ui *UI) AnalyzePath(path string, parentDir fs.Item) error {
79	ui.showScanProgressModal(" Scanning... ")
80
81	ui.scanCancelRequested.Store(false)
82	ui.Analyzer.ResetProgress()
83
84	analyzer := ui.Analyzer
85	doneChan := analyzer.GetDone()
86	go ui.updateProgress(analyzer, doneChan)
87
88	ui.scanStart = time.Now()
89	ui.scanning = true
90	ui.scanCancelled = false
91	go func() {
92		defer debug.FreeOSMemory()
93		currentDir := analyzer.AnalyzeDir(path, ui.CreateIgnoreFunc(), ui.CreateFileTypeFilter())
94
95		if parentDir != nil {
96			currentDir.SetParent(parentDir)
97			// Remove old entry with the same name and add new one
98			parentDir.RemoveFileByName(currentDir.GetName())
99			parentDir.AddFile(currentDir)
100		} else {
101			ui.topDirPath = path
102			ui.topDir = currentDir
103		}
104
105		if ui.IsFilteringFiles() {
106			ui.topDir.UpdateStatsWithFileFiltering(ui.linkedItems)
107		} else {
108			ui.topDir.UpdateStats(ui.linkedItems)
109		}
110
111		ui.app.QueueUpdateDraw(func() {
112			ui.scanning = false
113			ui.scanCancelled = false
114			// remember the longest scan so we can guard against accidental quits
115			if d := time.Since(ui.scanStart); d > ui.scanDuration {
116				ui.scanDuration = d
117			}
118			// the finished scan replaces any mid-scan preview
119			ui.previewing = false
120			ui.previewSavedDir = nil
121			ui.currentDir = currentDir
122			ui.showDir()
123			ui.pages.RemovePage("progress")
124		})
125
126		if ui.done != nil {
127			ui.done <- struct{}{}
128		}
129	}()
130
131	return nil
132}
133
134// AnalyzePaths scans several roots one after another and presents them under a
135// virtual top level dir, so that the rest of the UI keeps working on the single
136// rooted tree it expects.
137//
138// The roots are scanned sequentially rather than concurrently because the
139// analyzer owns a single set of progress channels; each root needs the analyzer
140// reset before it starts, which is also why cancellation has to be tracked
141// separately (ResetProgress clears the analyzer's own cancelled flag).
142func (ui *UI) AnalyzePaths(paths []string) error {
143	if len(paths) == 1 {
144		return ui.AnalyzePath(paths[0], nil)
145	}
146
147	ui.showScanProgressModal(scanProgressTitle(1, len(paths)))
148
149	ui.scanCancelRequested.Store(false)
150	ui.scanStart = time.Now()
151	ui.scanning = true
152	ui.scanCancelled = false
153
154	go func() {
155		defer debug.FreeOSMemory()
156
157		roots := make([]fs.Item, 0, len(paths))
158		for i, path := range paths {
159			if i > 0 {
160				title := scanProgressTitle(i+1, len(paths))
161				ui.app.QueueUpdateDraw(func() {
162					ui.progress.SetTitle(title)
163				})
164			}
165
166			ui.Analyzer.ResetProgress()
167			analyzer := ui.Analyzer
168			go ui.updateProgress(analyzer, analyzer.GetDone())
169
170			roots = append(
171				roots,
172				analyzer.AnalyzeDir(path, ui.CreateIgnoreFunc(), ui.CreateFileTypeFilter()),
173			)
174
175			// keep whatever was scanned so far, as a cancelled single scan does
176			if ui.scanCancelRequested.Load() {
177				break
178			}
179		}
180
181		currentDir := analyze.CreateVirtualRootDir(roots...)
182		ui.topDir = currentDir
183		ui.topDirPath = currentDir.GetPath()
184
185		if ui.IsFilteringFiles() {
186			ui.topDir.UpdateStatsWithFileFiltering(ui.linkedItems)
187		} else {
188			ui.topDir.UpdateStats(ui.linkedItems)
189		}
190
191		ui.app.QueueUpdateDraw(func() {
192			ui.scanning = false
193			ui.scanCancelled = false
194			// remember the longest scan so we can guard against accidental quits
195			if d := time.Since(ui.scanStart); d > ui.scanDuration {
196				ui.scanDuration = d
197			}
198			// the finished scan replaces any mid-scan preview
199			ui.previewing = false
200			ui.previewSavedDir = nil
201			ui.currentDir = currentDir
202			ui.showDir()
203			ui.pages.RemovePage("progress")
204		})
205
206		if ui.done != nil {
207			ui.done <- struct{}{}
208		}
209	}()
210
211	return nil
212}
213
214func scanProgressTitle(current, total int) string {
215	return fmt.Sprintf(" Scanning %d/%d... ", current, total)
216}
217
218// ReadAnalysis reads analysis report from JSON file
219func (ui *UI) ReadAnalysis(input io.Reader) error {
220	ui.progress = tview.NewTextView().SetText("Reading analysis from file...")
221	ui.progress.SetBorder(true).SetBorderPadding(2, 2, 2, 2)
222	ui.progress.SetTitle(" Reading... ")
223	ui.progress.SetDynamicColors(true)
224
225	flex := tview.NewFlex().
226		AddItem(nil, 0, 1, false).
227		AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
228			AddItem(nil, 10, 1, false).
229			AddItem(ui.progress, 8, 1, false).
230			AddItem(nil, 10, 1, false), 0, 50, false).
231		AddItem(nil, 0, 1, false)
232
233	ui.pages.AddPage("progress", flex, true, true)
234
235	go func() {
236		var err error
237		ui.currentDir, err = report.ReadAnalysis(input)
238		if err != nil {
239			ui.app.QueueUpdateDraw(func() {
240				ui.pages.RemovePage("progress")
241				ui.showErr("Error reading file", err)
242			})
243			if ui.done != nil {
244				ui.done <- struct{}{}
245			}
246			return
247		}
248		runtime.GC()
249
250		ui.topDirPath = ui.currentDir.GetPath()
251		ui.topDir = ui.currentDir
252
253		links := make(fs.HardLinkedItems, 10)
254		ui.topDir.UpdateStats(links)
255
256		ui.app.QueueUpdateDraw(func() {
257			ui.showDir()
258			ui.pages.RemovePage("progress")
259		})
260
261		if ui.done != nil {
262			ui.done <- struct{}{}
263		}
264	}()
265
266	return nil
267}
268
269// ReadFromStorage reads analysis data from persistent key-value storage
270func (ui *UI) ReadFromStorage(storagePath, path string) error {
271	storage := analyze.NewStorage(storagePath, path)
272	closeFn := storage.Open()
273	defer closeFn()
274
275	dir, err := storage.GetDirForPath(path)
276	if err != nil {
277		return err
278	}
279
280	ui.currentDir = dir
281	ui.topDirPath = ui.currentDir.GetPath()
282	ui.topDir = ui.currentDir
283
284	ui.showDir()
285	return nil
286}
287
288func (ui *UI) delete(action DeleteAction) {
289	if len(ui.markedRows) > 0 {
290		ui.deleteMarked(action)
291	} else {
292		ui.deleteSelected(action)
293	}
294}
295
296func (ui *UI) deleteSelected(action DeleteAction) {
297	row, column := ui.table.GetSelection()
298	selectedItem := ui.table.GetCell(row, column).GetReference().(fs.Item)
299
300	if ui.deleteInBackground {
301		ui.queueForDeletion([]fs.Item{selectedItem}, action)
302		return
303	}
304
305	acting := action.Acting()
306	modal := tview.NewModal().SetText(
307		cases.Title(language.English).String(acting) +
308			" " +
309			tview.Escape(selectedItem.GetName()) +
310			"...",
311	)
312	ui.pages.AddPage(acting, modal, true, true)
313
314	var currentDir fs.Item
315	var deleteItems []fs.Item
316	if action == ActionEmpty && selectedItem.IsDir() {
317		currentDir = selectedItem
318		for file := range currentDir.GetFiles(fs.SortBySize, fs.SortDesc) {
319			deleteItems = append(deleteItems, file)
320		}
321	} else {
322		currentDir = ui.currentDir
323		deleteItems = append(deleteItems, selectedItem)
324	}
325
326	var deleteFun func(fs.Item, fs.Item) error
327	switch action {
328	case ActionEmpty:
329		if !selectedItem.IsDir() {
330			deleteFun = ui.emptier
331		} else {
332			deleteFun = ui.remover
333		}
334	case ActionMoveToTrash:
335		deleteFun = ui.trasher
336	case ActionDelete:
337		deleteFun = ui.remover
338	}
339	go func() {
340		for _, item := range deleteItems {
341			if err := deleteFun(currentDir, item); err != nil {
342				msg := "Can't " + action.Verb() + " " + tview.Escape(selectedItem.GetName())
343				ui.app.QueueUpdateDraw(func() {
344					ui.pages.RemovePage(acting)
345					ui.showErr(msg, err)
346				})
347				if ui.done != nil {
348					ui.done <- struct{}{}
349				}
350				return
351			}
352		}
353
354		ui.app.QueueUpdateDraw(func() {
355			ui.pages.RemovePage(acting)
356			x, y := ui.table.GetOffset()
357			ui.showDir()
358			ui.table.Select(min(row, ui.table.GetRowCount()-1), 0)
359			ui.table.SetOffset(min(x, ui.table.GetRowCount()-1), y)
360		})
361
362		if ui.done != nil {
363			ui.done <- struct{}{}
364		}
365	}()
366}
367
368func (ui *UI) showInfo() {
369	if ui.currentDir == nil {
370		return
371	}
372
373	var content, numberColor string
374	row, column := ui.table.GetSelection()
375	selectedFile := ui.table.GetCell(row, column).GetReference().(fs.Item)
376
377	if ui.UseColors {
378		numberColor = fmt.Sprintf(
379			"[%s::b]",
380			ui.resultRow.NumberColor,
381		)
382	} else {
383		numberColor = defaultColorBold
384	}
385
386	linesCount := 12
387
388	text := tview.NewTextView().SetDynamicColors(true)
389	text.SetBorder(true).SetBorderPadding(2, 2, 2, 2)
390	text.SetBorderColor(tcell.ColorDefault)
391	text.SetTitle(" Item info ")
392
393	content += "[::b]Name:[::-] "
394	content += tview.Escape(selectedFile.GetName()) + "\n"
395	content += "[::b]Path:[::-] "
396	content += tview.Escape(
397		strings.TrimPrefix(selectedFile.GetPath(), build.RootPathPrefix),
398	) + "\n"
399	content += "[::b]Type:[::-] " + selectedFile.GetType() + "\n"
400
401	// Display symlink target
402	if line := ui.symlinkTargetInfoLine(selectedFile); line != "" {
403		content += line
404		linesCount++
405	}
406
407	content += "\n"
408
409	content += "   [::b]Disk usage:[::-] "
410	content += numberColor + ui.formatSize(selectedFile.GetUsage(), false, true)
411	content += fmt.Sprintf(" (%s%d[-::] B)", numberColor, selectedFile.GetUsage()) + "\n"
412	content += "[::b]Apparent size:[::-] "
413	content += numberColor + ui.formatSize(selectedFile.GetSize(), false, true)
414	content += fmt.Sprintf(" (%s%d[-::] B)", numberColor, selectedFile.GetSize()) + "\n"
415
416	if selectedFile.GetMultiLinkedInode() > 0 {
417		linkedItems := ui.linkedItems[selectedFile.GetMultiLinkedInode()]
418		linesCount += 2 + len(linkedItems)
419		content += "\nHard-linked files:\n"
420		for _, linkedItem := range linkedItems {
421			content += "\t" + linkedItem.GetPath() + "\n"
422		}
423	}
424
425	text.SetText(content)
426
427	flex := tview.NewFlex().
428		AddItem(nil, 0, 1, false).
429		AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
430			AddItem(nil, 0, 1, false).
431			AddItem(text, linesCount, 1, false).
432			AddItem(nil, 0, 1, false), 80, 1, false).
433		AddItem(nil, 0, 1, false)
434
435	ui.pages.AddPage("info", flex, true, true)
436}
437
438// symlinkTargetInfoLine returns the "Target:" info-panel line for a symlink
439// item, or an empty string when symlink-target display is disabled or the item
440// has no symlink target.
441func (ui *UI) symlinkTargetInfoLine(item fs.Item) string {
442	if !ui.showSymlinkTarget {
443		return ""
444	}
445	si, ok := item.(fs.SymlinkItem)
446	if !ok {
447		return ""
448	}
449	target := si.GetSymlinkTarget()
450	if target == "" {
451		return ""
452	}
453	return "[::b]Target:[::-] " + tview.Escape(target) + "\n"
454}
455
456func (ui *UI) openItem() {
457	row, column := ui.table.GetSelection()
458	selectedFile, ok := ui.table.GetCell(row, column).GetReference().(fs.Item)
459	if !ok || selectedFile == ui.currentDir.GetParent() {
460		return
461	}
462
463	openBinary := "xdg-open"
464
465	switch runtime.GOOS {
466	case osDarwin:
467		openBinary = "open"
468	case osWindows:
469		openBinary = "explorer"
470	}
471
472	cmd := exec.Command(openBinary, selectedFile.GetPath())
473	err := cmd.Start()
474	if err != nil {
475		ui.showErr("Error opening", err)
476	}
477}
478
479func (ui *UI) confirmExport() *tview.Form {
480	form := tview.NewForm().
481		AddInputField("File name", "export.json", 30, nil, func(v string) {
482			ui.exportName = v
483		}).
484		AddButton("Export", ui.exportAnalysis).
485		SetButtonsAlign(tview.AlignCenter)
486	form.SetBorder(true).
487		SetTitle(" Export data to JSON ").
488		SetInputCapture(func(key *tcell.EventKey) *tcell.EventKey {
489			if key.Key() == tcell.KeyEsc {
490				ui.pages.RemovePage("export")
491				ui.app.SetFocus(ui.table)
492				return nil
493			}
494			return key
495		})
496	flex := modal(form, 50, 7)
497	ui.pages.AddPage("export", flex, true, true)
498	ui.app.SetFocus(form)
499	return form
500}
501
502func (ui *UI) exportAnalysis() {
503	ui.pages.RemovePage("export")
504
505	// the export format holds exactly one root, so there is nowhere to put the
506	// virtual dir grouping several of them
507	if analyze.IsVirtualRootDir(ui.topDir) {
508		ui.showMessage("Export is not supported when multiple directories are scanned")
509		return
510	}
511
512	text := tview.NewTextView().SetText("Export in progress...").SetTextAlign(tview.AlignCenter)
513	text.SetBorder(true).SetTitle(" Export data to JSON ")
514	flex := modal(text, 50, 3)
515	ui.pages.AddPage("exporting", flex, true, true)
516
517	go func() {
518		var err error
519		defer ui.app.QueueUpdateDraw(func() {
520			ui.pages.RemovePage("exporting")
521			if err == nil {
522				ui.app.SetFocus(ui.table)
523			}
524		})
525		if ui.done != nil {
526			defer func() {
527				ui.done <- struct{}{}
528			}()
529		}
530
531		var buff bytes.Buffer
532
533		buff.Write([]byte(`[1,2,{"progname":"gdu","progver":"`))
534		buff.Write([]byte(build.Version))
535		buff.Write([]byte(`","timestamp":`))
536		buff.Write([]byte(strconv.FormatInt(time.Now().Unix(), 10)))
537		buff.Write([]byte("},\n"))
538
539		file, err := os.Create(ui.exportName)
540		if err != nil {
541			ui.showErrFromGo("Error creating file", err)
542			return
543		}
544		defer file.Close()
545
546		if err = ui.topDir.EncodeJSON(&buff, true, nil); err != nil {
547			ui.showErrFromGo("Error encoding JSON", err)
548			return
549		}
550
551		if _, err = buff.Write([]byte("]\n")); err != nil {
552			ui.showErrFromGo("Error writing to buffer", err)
553			return
554		}
555		if _, err = buff.WriteTo(file); err != nil {
556			ui.showErrFromGo("Error writing to file", err)
557			return
558		}
559	}()
560}
561
562func (ui *UI) isInArchive() bool {
563	if ui.currentDir == nil {
564		return false
565	}
566	if _, ok := ui.currentDir.(*analyze.ZipDir); ok {
567		return true
568	}
569	_, ok := ui.currentDir.(*analyze.TarDir)
570	return ok
571}