fork/gdu

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

ShivamB25feat: stop scanning and keep partial results (#606)99a7f2a

master
4.7 KiB163 linesraw
1package analyze
2
3import (
4	"os"
5	"path/filepath"
6	"strconv"
7	"sync"
8	"testing"
9
10	"github.com/dundee/gdu/v5/internal/common"
11	"github.com/dundee/gdu/v5/pkg/fs"
12	"github.com/stretchr/testify/assert"
13)
14
15// createWideTree builds a tree large enough to keep the parallel analyzer busy
16// so that GetCurrentDir can be read while the scan is still appending to it.
17func createWideTree(t *testing.T) (string, func()) {
18	t.Helper()
19	root, err := os.MkdirTemp("", "gdu-preview-race")
20	assert.NoError(t, err)
21	for i := 0; i < 40; i++ {
22		sub := filepath.Join(root, "dir"+strconv.Itoa(i))
23		assert.NoError(t, os.MkdirAll(filepath.Join(sub, "nested"), os.ModePerm))
24		for j := 0; j < 20; j++ {
25			f := filepath.Join(sub, "f"+strconv.Itoa(j))
26			assert.NoError(t, os.WriteFile(f, []byte("data"), 0o600))
27			nf := filepath.Join(sub, "nested", "f"+strconv.Itoa(j))
28			assert.NoError(t, os.WriteFile(nf, []byte("data"), 0o600))
29		}
30	}
31	return root, func() { _ = os.RemoveAll(root) }
32}
33
34// TestPreviewWhileScanning exercises reading and computing stats on the live
35// directory tree while the analyzer is still building it. Run with -race to
36// detect any unsynchronized access between AddFile and the preview readers.
37func TestPreviewWhileScanning(t *testing.T) {
38	root, fin := createWideTree(t)
39	defer fin()
40
41	analyzer := CreateAnalyzer()
42
43	var wg sync.WaitGroup
44	stop := make(chan struct{})
45
46	// concurrently peek at the partial tree, mirroring what the TUI preview does
47	wg.Add(1)
48	go func() {
49		defer wg.Done()
50		for {
51			select {
52			case <-stop:
53				return
54			default:
55			}
56			if cur := analyzer.GetCurrentDir(); cur != nil {
57				cur.UpdateStats(make(fs.HardLinkedItems))
58				var total int64
59				for item := range cur.GetFilesLocked(fs.SortBySize, fs.SortDesc) {
60					total += item.GetSize()
61				}
62				_ = total
63			}
64		}
65	}()
66
67	dir := analyzer.AnalyzeDir(
68		root,
69		func(_, _ string) bool { return false },
70		func(_ string) bool { return false },
71	)
72	close(stop)
73	wg.Wait()
74
75	dir.UpdateStats(make(fs.HardLinkedItems))
76	assert.Equal(t, root, dir.GetPath())
77	// 40 dirs * (20 files + nested dir with 20 files) + nested dirs + root
78	assert.Greater(t, dir.GetItemCount(), int64(40*40))
79
80	// the analyzer exposes a point-in-time snapshot of the returned root
81	var _ common.Analyzer = analyzer
82	assert.Equal(t, dir.GetPath(), analyzer.GetCurrentDir().GetPath())
83}
84
85func TestCurrentDirSnapshotCannotOverwriteLiveStats(t *testing.T) {
86	live := &Dir{
87		File:      &File{Name: "root", Size: 100, Usage: 100},
88		Files:     make(fs.Files, 0, 1),
89		ItemCount: 1,
90	}
91	analyzer := CreateAnalyzer()
92	analyzer.setCurrentDir(live)
93
94	snapshot := analyzer.GetCurrentDir()
95	live.AddFile(&File{Name: "complete", Size: 7, Usage: 5, Parent: live})
96	live.UpdateStats(make(fs.HardLinkedItems))
97	snapshot.UpdateStats(make(fs.HardLinkedItems))
98
99	assert.Equal(t, int64(7), live.GetSize())
100	assert.Equal(t, int64(5), live.GetUsage())
101	assert.Equal(t, int64(2), live.GetItemCount())
102	assert.Empty(t, itemNames(snapshot))
103}
104
105func TestCurrentDirSnapshotPreservesArchiveItems(t *testing.T) {
106	live := &Dir{
107		File:     &File{Name: "root"},
108		BasePath: "/tmp",
109		Files:    make(fs.Files, 0, 2),
110	}
111	zipDir := &ZipDir{
112		Dir: &Dir{
113			File:  &File{Name: "archive.zip", Parent: live},
114			Files: make(fs.Files, 0, 1),
115		},
116		zipPath: "/tmp/archive.zip",
117	}
118	zipDir.Files = append(zipDir.Files, &ZipFile{
119		File:      &File{Name: "inside.zip", Parent: zipDir},
120		zipPath:   "/tmp/archive.zip",
121		inZipPath: "inside.zip",
122	})
123	tarDir := &TarDir{
124		Dir: &Dir{
125			File:  &File{Name: "archive.tar", Parent: live},
126			Files: make(fs.Files, 0, 1),
127		},
128		tarPath: "/tmp/archive.tar",
129	}
130	tarDir.Files = append(tarDir.Files, &TarFile{
131		File:      &File{Name: "inside.tar", Parent: tarDir},
132		tarPath:   "/tmp/archive.tar",
133		inTarPath: "inside.tar",
134	})
135	live.Files = append(live.Files, zipDir, tarDir)
136
137	analyzer := CreateAnalyzer()
138	analyzer.setCurrentDir(live)
139	snapshot := analyzer.GetCurrentDir()
140
141	items := make(map[string]fs.Item)
142	for item := range snapshot.GetFiles(fs.SortByName, fs.SortAsc) {
143		items[item.GetName()] = item
144	}
145	zipSnapshot, ok := items["archive.zip"].(*ZipDir)
146	assert.True(t, ok)
147	assert.Equal(t, zipDir.GetType(), zipSnapshot.GetType())
148	assert.Equal(t, zipDir.GetPath(), zipSnapshot.GetPath())
149	for item := range zipSnapshot.GetFiles(fs.SortByName, fs.SortAsc) {
150		_, isZipFile := item.(*ZipFile)
151		assert.True(t, isZipFile)
152		assert.Equal(t, zipDir.Files[0].GetPath(), item.GetPath())
153	}
154	tarSnapshot, ok := items["archive.tar"].(*TarDir)
155	assert.True(t, ok)
156	assert.Equal(t, tarDir.GetType(), tarSnapshot.GetType())
157	assert.Equal(t, tarDir.GetPath(), tarSnapshot.GetPath())
158	for item := range tarSnapshot.GetFiles(fs.SortByName, fs.SortAsc) {
159		_, isTarFile := item.(*TarFile)
160		assert.True(t, isTarFile)
161		assert.Equal(t, tarDir.Files[0].GetPath(), item.GetPath())
162	}
163}