fork/gdu

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

Julia RyanMake -x respect subvolumes4d478cf

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