fork/gdu

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

Daniel Mildefix: StoreDir fixes (#644)35cba00

master
5.8 KiB215 linesraw
1package analyze
2
3import (
4	"runtime"
5	"sync"
6	"testing"
7	"time"
8
9	"github.com/dundee/gdu/v5/internal/testdir"
10	"github.com/dundee/gdu/v5/pkg/fs"
11	"github.com/stretchr/testify/assert"
12)
13
14// TestStoredDirUpdateStatsLockedAccessors exercises the same reader/writer mix
15// on a StoredDir that the web UI and TUI produce: stats updates overlapping
16// readers that go through the synchronized accessors. Run with -race to catch
17// any field written outside Dir.m.
18func TestStoredDirUpdateStatsLockedAccessors(t *testing.T) {
19	fin := testdir.CreateTestDir()
20	defer fin()
21
22	analyzer := CreateStoredAnalyzer(t.TempDir())
23	dir := analyzer.AnalyzeDir(
24		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
25	).(*StoredDir)
26	analyzer.GetDone().Wait()
27
28	// Hold the database open for the whole test so every worker shares one
29	// badger instance instead of opening and closing it per call.
30	closeFn := DefaultStorage.Open()
31	defer closeFn()
32
33	// updateStats is idempotent over a static tree, so the concurrent run must
34	// converge on the values a single-threaded run produces.
35	dir.UpdateStats(make(fs.HardLinkedItems))
36	wantCount, wantSize, wantUsage := dir.GetItemCount(), dir.GetSize(), dir.GetUsage()
37
38	const workers = 4
39	const rounds = 25
40
41	var wg sync.WaitGroup
42	for range workers {
43		wg.Add(1)
44		go func() {
45			defer wg.Done()
46			for range rounds {
47				dir.UpdateStats(make(fs.HardLinkedItems))
48				runtime.Gosched()
49			}
50		}()
51
52		wg.Add(1)
53		go func() {
54			defer wg.Done()
55			for range rounds {
56				readLockedStoredDir(dir)
57				runtime.Gosched()
58			}
59		}()
60	}
61	wg.Wait()
62
63	assert.Equal(t, wantCount, dir.GetItemCount())
64	assert.Equal(t, wantSize, dir.GetSize())
65	assert.Equal(t, wantUsage, dir.GetUsage())
66}
67
68// TestStoredDirOpensStorageOnDemandConcurrently drives the same workload with
69// no pinned database handle, so every operation has to open storage itself.
70// Reference counting must let those overlapping opens share one badger
71// instance instead of tripping its exclusive directory lock.
72func TestStoredDirOpensStorageOnDemandConcurrently(t *testing.T) {
73	fin := testdir.CreateTestDir()
74	defer fin()
75
76	analyzer := CreateStoredAnalyzer(t.TempDir())
77	dir := analyzer.AnalyzeDir(
78		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
79	).(*StoredDir)
80	analyzer.GetDone().Wait()
81
82	assert.False(t, DefaultStorage.IsOpen(), "the analyzer should have closed storage on the way out")
83
84	var wg sync.WaitGroup
85	for range 4 {
86		wg.Add(1)
87		go func() {
88			defer wg.Done()
89			for range 5 {
90				dir.UpdateStats(make(fs.HardLinkedItems))
91				readLockedStoredDir(dir)
92				runtime.Gosched()
93			}
94		}()
95	}
96	wg.Wait()
97
98	assert.False(t, DefaultStorage.IsOpen(), "every reference must be released again")
99	assert.Positive(t, dir.GetSize())
100}
101
102// TestStoredDirGetFilesUnderCallerHeldReadLock pins the caller-locked half of
103// the fs.Item contract: tui.(*UI).showDir holds RLock across the whole
104// GetFiles iteration, so loading children lazily must not re-enter Dir.m.
105// sync.RWMutex is not reentrant, so a write lock there self-deadlocks, and
106// even a read lock deadlocks once a writer has queued behind the caller.
107func TestStoredDirGetFilesUnderCallerHeldReadLock(t *testing.T) {
108	fin := testdir.CreateTestDir()
109	defer fin()
110
111	analyzer := CreateStoredAnalyzer(t.TempDir())
112	dir := analyzer.AnalyzeDir(
113		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
114	).(*StoredDir)
115	analyzer.GetDone().Wait()
116
117	dir.UpdateStats(make(fs.HardLinkedItems))
118
119	done := make(chan int, 1)
120	go func() {
121		unlock := dir.RLock()
122		defer unlock()
123
124		// Queue a writer on the very mutex the caller holds for reading, so
125		// the read-lock variant of the bug is covered too.
126		queued := make(chan struct{})
127		go func() {
128			close(queued)
129			dir.SetFlag('!')
130		}()
131		<-queued
132		time.Sleep(50 * time.Millisecond)
133
134		var count int
135		for range dir.GetFiles(fs.SortByName, fs.SortAsc) {
136			count++
137		}
138		done <- count
139	}()
140
141	select {
142	case count := <-done:
143		assert.Positive(t, count)
144	case <-time.After(30 * time.Second):
145		t.Fatal("GetFiles deadlocked while the caller held the directory read lock")
146	}
147}
148
149// readLockedStoredDir mirrors a UI traversal: every scalar accessor plus the
150// file listing, which loads children back out of storage.
151func readLockedStoredDir(dir *StoredDir) {
152	_ = dir.GetName()
153	_ = dir.GetFlag()
154	_ = dir.GetSize()
155	_ = dir.GetUsage()
156	_ = dir.GetMtime()
157	_ = dir.GetItemCount()
158	for item := range dir.GetFiles(fs.SortBySize, fs.SortDesc) {
159		_ = item.GetName()
160		_ = item.GetFlag()
161		_ = item.GetSize()
162		_ = item.GetUsage()
163		_ = item.GetMtime()
164		_ = item.GetItemCount()
165	}
166}
167
168// TestStorageOpenIsReferenceCounted covers the storage contract StoredDir
169// relies on: badger locks its directory, so overlapping Open calls must share
170// one instance and only the last closer may actually close it.
171func TestStorageOpenIsReferenceCounted(t *testing.T) {
172	storage := NewStorage(t.TempDir(), "/some/path")
173
174	outer := storage.Open()
175	assert.True(t, storage.IsOpen())
176
177	inner := storage.Open()
178	inner()
179	assert.True(t, storage.IsOpen(), "inner closer must not close the shared database")
180
181	outer()
182	assert.False(t, storage.IsOpen())
183
184	// closers are idempotent
185	outer()
186	inner()
187	assert.False(t, storage.IsOpen())
188}
189
190// TestStorageOpenConcurrent asserts concurrent Open/close pairs never trip
191// badger's exclusive directory lock, which would panic inside Open.
192func TestStorageOpenConcurrent(t *testing.T) {
193	storage := NewStorage(t.TempDir(), "/some/path")
194
195	pin := storage.Open()
196
197	var wg sync.WaitGroup
198	for range 8 {
199		wg.Add(1)
200		go func() {
201			defer wg.Done()
202			for range 20 {
203				closeFn := storage.Open()
204				assert.True(t, storage.IsOpen())
205				closeFn()
206				runtime.Gosched()
207			}
208		}()
209	}
210	wg.Wait()
211
212	assert.True(t, storage.IsOpen())
213	pin()
214	assert.False(t, storage.IsOpen())
215}