closes #7179
[arvados.git] / services / keepstore / volume_generic_test.go
1 package main
2
3 import (
4         "bytes"
5         "os"
6         "regexp"
7         "sort"
8         "strings"
9         "testing"
10         "time"
11 )
12
13 // A TestableVolumeFactory returns a new TestableVolume. The factory
14 // function, and the TestableVolume it returns, can use "t" to write
15 // logs, fail the current test, etc.
16 type TestableVolumeFactory func(t *testing.T) TestableVolume
17
18 // DoGenericVolumeTests runs a set of tests that every TestableVolume
19 // is expected to pass. It calls factory to create a new TestableVolume
20 // for each test case, to avoid leaking state between tests.
21 func DoGenericVolumeTests(t *testing.T, factory TestableVolumeFactory) {
22         testGet(t, factory)
23         testGetNoSuchBlock(t, factory)
24
25         testCompareSameContent(t, factory)
26         testCompareWithDifferentContent(t, factory)
27         testCompareWithBadData(t, factory)
28
29         testPutBlockWithSameContent(t, factory)
30         testPutBlockWithDifferentContent(t, factory)
31         testPutMultipleBlocks(t, factory)
32
33         testPutAndTouch(t, factory)
34         testTouchNoSuchBlock(t, factory)
35
36         testMtimeNoSuchBlock(t, factory)
37
38         testIndexTo(t, factory)
39
40         testDeleteNewBlock(t, factory)
41         testDeleteOldBlock(t, factory)
42         testDeleteNoSuchBlock(t, factory)
43
44         testStatus(t, factory)
45
46         testString(t, factory)
47
48         testUpdateReadOnly(t, factory)
49
50         testGetConcurrent(t, factory)
51         testPutConcurrent(t, factory)
52 }
53
54 // Put a test block, get it and verify content
55 // Test should pass for both writable and read-only volumes
56 func testGet(t *testing.T, factory TestableVolumeFactory) {
57         v := factory(t)
58         defer v.Teardown()
59
60         v.PutRaw(TestHash, TestBlock)
61
62         buf, err := v.Get(TestHash)
63         if err != nil {
64                 t.Error(err)
65         }
66
67         bufs.Put(buf)
68
69         if bytes.Compare(buf, TestBlock) != 0 {
70                 t.Errorf("expected %s, got %s", string(TestBlock), string(buf))
71         }
72 }
73
74 // Invoke get on a block that does not exist in volume; should result in error
75 // Test should pass for both writable and read-only volumes
76 func testGetNoSuchBlock(t *testing.T, factory TestableVolumeFactory) {
77         v := factory(t)
78         defer v.Teardown()
79
80         if _, err := v.Get(TestHash2); err == nil {
81                 t.Errorf("Expected error while getting non-existing block %v", TestHash2)
82         }
83 }
84
85 // Put a test block and compare the locator with same content
86 // Test should pass for both writable and read-only volumes
87 func testCompareSameContent(t *testing.T, factory TestableVolumeFactory) {
88         v := factory(t)
89         defer v.Teardown()
90
91         v.PutRaw(TestHash, TestBlock)
92
93         // Compare the block locator with same content
94         err := v.Compare(TestHash, TestBlock)
95         if err != nil {
96                 t.Errorf("Got err %q, expected nil", err)
97         }
98 }
99
100 // Put a test block and compare the locator with a different content
101 // Expect error due to collision
102 // Test should pass for both writable and read-only volumes
103 func testCompareWithDifferentContent(t *testing.T, factory TestableVolumeFactory) {
104         v := factory(t)
105         defer v.Teardown()
106
107         v.PutRaw(TestHash, TestBlock)
108
109         // Compare the block locator with different content; collision
110         err := v.Compare(TestHash, []byte("baddata"))
111         if err == nil {
112                 t.Errorf("Expected error due to collision")
113         }
114 }
115
116 // Put a test block with bad data (hash does not match, but Put does not verify)
117 // Compare the locator with good data whose hash matches with locator
118 // Expect error due to corruption.
119 // Test should pass for both writable and read-only volumes
120 func testCompareWithBadData(t *testing.T, factory TestableVolumeFactory) {
121         v := factory(t)
122         defer v.Teardown()
123
124         v.PutRaw(TestHash, []byte("baddata"))
125
126         err := v.Compare(TestHash, TestBlock)
127         if err == nil {
128                 t.Errorf("Expected error due to corruption")
129         }
130 }
131
132 // Put a block and put again with same content
133 // Test is intended for only writable volumes
134 func testPutBlockWithSameContent(t *testing.T, factory TestableVolumeFactory) {
135         v := factory(t)
136         defer v.Teardown()
137
138         if v.Writable() == false {
139                 return
140         }
141
142         err := v.Put(TestHash, TestBlock)
143         if err != nil {
144                 t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err)
145         }
146
147         err = v.Put(TestHash, TestBlock)
148         if err != nil {
149                 t.Errorf("Got err putting block second time %q: %q, expected nil", TestBlock, err)
150         }
151 }
152
153 // Put a block and put again with different content
154 // Test is intended for only writable volumes
155 func testPutBlockWithDifferentContent(t *testing.T, factory TestableVolumeFactory) {
156         v := factory(t)
157         defer v.Teardown()
158
159         if v.Writable() == false {
160                 return
161         }
162
163         err := v.Put(TestHash, TestBlock)
164         if err != nil {
165                 t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err)
166         }
167
168         putErr := v.Put(TestHash, TestBlock2)
169         buf, getErr := v.Get(TestHash)
170         if putErr == nil {
171                 // Put must not return a nil error unless it has
172                 // overwritten the existing data.
173                 if bytes.Compare(buf, TestBlock2) != 0 {
174                         t.Errorf("Put succeeded but Get returned %+v, expected %+v", buf, TestBlock2)
175                 }
176         } else {
177                 // It is permissible for Put to fail, but it must
178                 // leave us with either the original data, the new
179                 // data, or nothing at all.
180                 if getErr == nil && bytes.Compare(buf, TestBlock) != 0 && bytes.Compare(buf, TestBlock2) != 0 {
181                         t.Errorf("Put failed but Get returned %+v, which is neither %+v nor %+v", buf, TestBlock, TestBlock2)
182                 }
183         }
184         if getErr == nil {
185                 bufs.Put(buf)
186         }
187 }
188
189 // Put and get multiple blocks
190 // Test is intended for only writable volumes
191 func testPutMultipleBlocks(t *testing.T, factory TestableVolumeFactory) {
192         v := factory(t)
193         defer v.Teardown()
194
195         if v.Writable() == false {
196                 return
197         }
198
199         err := v.Put(TestHash, TestBlock)
200         if err != nil {
201                 t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err)
202         }
203
204         err = v.Put(TestHash2, TestBlock2)
205         if err != nil {
206                 t.Errorf("Got err putting block %q: %q, expected nil", TestBlock2, err)
207         }
208
209         err = v.Put(TestHash3, TestBlock3)
210         if err != nil {
211                 t.Errorf("Got err putting block %q: %q, expected nil", TestBlock3, err)
212         }
213
214         data, err := v.Get(TestHash)
215         if err != nil {
216                 t.Error(err)
217         } else if bytes.Compare(data, TestBlock) != 0 {
218                 t.Errorf("Block present, but content is incorrect: Expected: %v  Found: %v", data, TestBlock)
219         }
220         bufs.Put(data)
221
222         data, err = v.Get(TestHash2)
223         if err != nil {
224                 t.Error(err)
225         } else if bytes.Compare(data, TestBlock2) != 0 {
226                 t.Errorf("Block present, but content is incorrect: Expected: %v  Found: %v", data, TestBlock2)
227         }
228         bufs.Put(data)
229
230         data, err = v.Get(TestHash3)
231         if err != nil {
232                 t.Error(err)
233         } else if bytes.Compare(data, TestBlock3) != 0 {
234                 t.Errorf("Block present, but content is incorrect: Expected: %v  Found: %v", data, TestBlock3)
235         }
236         bufs.Put(data)
237 }
238
239 // testPutAndTouch
240 //   Test that when applying PUT to a block that already exists,
241 //   the block's modification time is updated.
242 // Test is intended for only writable volumes
243 func testPutAndTouch(t *testing.T, factory TestableVolumeFactory) {
244         v := factory(t)
245         defer v.Teardown()
246
247         if v.Writable() == false {
248                 return
249         }
250
251         if err := v.Put(TestHash, TestBlock); err != nil {
252                 t.Error(err)
253         }
254
255         // We'll verify { t0 < threshold < t1 }, where t0 is the
256         // existing block's timestamp on disk before Put() and t1 is
257         // its timestamp after Put().
258         threshold := time.Now().Add(-time.Second)
259
260         // Set the stored block's mtime far enough in the past that we
261         // can see the difference between "timestamp didn't change"
262         // and "timestamp granularity is too low".
263         v.TouchWithDate(TestHash, time.Now().Add(-20*time.Second))
264
265         // Make sure v.Mtime() agrees the above Utime really worked.
266         if t0, err := v.Mtime(TestHash); err != nil || t0.IsZero() || !t0.Before(threshold) {
267                 t.Errorf("Setting mtime failed: %v, %v", t0, err)
268         }
269
270         // Write the same block again.
271         if err := v.Put(TestHash, TestBlock); err != nil {
272                 t.Error(err)
273         }
274
275         // Verify threshold < t1
276         if t1, err := v.Mtime(TestHash); err != nil {
277                 t.Error(err)
278         } else if t1.Before(threshold) {
279                 t.Errorf("t1 %v should be >= threshold %v after v.Put ", t1, threshold)
280         }
281 }
282
283 // Touching a non-existing block should result in error.
284 // Test should pass for both writable and read-only volumes
285 func testTouchNoSuchBlock(t *testing.T, factory TestableVolumeFactory) {
286         v := factory(t)
287         defer v.Teardown()
288
289         if err := v.Touch(TestHash); err == nil {
290                 t.Error("Expected error when attempted to touch a non-existing block")
291         }
292 }
293
294 // Invoking Mtime on a non-existing block should result in error.
295 // Test should pass for both writable and read-only volumes
296 func testMtimeNoSuchBlock(t *testing.T, factory TestableVolumeFactory) {
297         v := factory(t)
298         defer v.Teardown()
299
300         if _, err := v.Mtime("12345678901234567890123456789012"); err == nil {
301                 t.Error("Expected error when updating Mtime on a non-existing block")
302         }
303 }
304
305 // Put a few blocks and invoke IndexTo with:
306 // * no prefix
307 // * with a prefix
308 // * with no such prefix
309 // Test should pass for both writable and read-only volumes
310 func testIndexTo(t *testing.T, factory TestableVolumeFactory) {
311         v := factory(t)
312         defer v.Teardown()
313
314         v.PutRaw(TestHash, TestBlock)
315         v.PutRaw(TestHash2, TestBlock2)
316         v.PutRaw(TestHash3, TestBlock3)
317
318         buf := new(bytes.Buffer)
319         v.IndexTo("", buf)
320         indexRows := strings.Split(string(buf.Bytes()), "\n")
321         sort.Strings(indexRows)
322         sortedIndex := strings.Join(indexRows, "\n")
323         m, err := regexp.MatchString(
324                 `^\n`+TestHash+`\+\d+ \d+\n`+
325                         TestHash3+`\+\d+ \d+\n`+
326                         TestHash2+`\+\d+ \d+$`,
327                 sortedIndex)
328         if err != nil {
329                 t.Error(err)
330         } else if !m {
331                 t.Errorf("Got index %q for empty prefix", sortedIndex)
332         }
333
334         for _, prefix := range []string{"f", "f15", "f15ac"} {
335                 buf = new(bytes.Buffer)
336                 v.IndexTo(prefix, buf)
337
338                 m, err := regexp.MatchString(`^`+TestHash2+`\+\d+ \d+\n$`, string(buf.Bytes()))
339                 if err != nil {
340                         t.Error(err)
341                 } else if !m {
342                         t.Errorf("Got index %q for prefix %s", string(buf.Bytes()), prefix)
343                 }
344         }
345
346         for _, prefix := range []string{"zero", "zip", "zilch"} {
347                 buf = new(bytes.Buffer)
348                 v.IndexTo(prefix, buf)
349                 if err != nil {
350                         t.Errorf("Got error on IndexTo with no such prefix %v", err.Error())
351                 } else if buf.Len() != 0 {
352                         t.Errorf("Expected empty list for IndexTo with no such prefix %s", prefix)
353                 }
354         }
355 }
356
357 // Calling Delete() for a block immediately after writing it (not old enough)
358 // should neither delete the data nor return an error.
359 // Test is intended for only writable volumes
360 func testDeleteNewBlock(t *testing.T, factory TestableVolumeFactory) {
361         v := factory(t)
362         defer v.Teardown()
363
364         if v.Writable() == false {
365                 return
366         }
367
368         v.Put(TestHash, TestBlock)
369
370         if err := v.Delete(TestHash); err != nil {
371                 t.Error(err)
372         }
373         data, err := v.Get(TestHash)
374         if err != nil {
375                 t.Error(err)
376         } else if bytes.Compare(data, TestBlock) != 0 {
377                 t.Error("Block still present, but content is incorrect: %+v != %+v", data, TestBlock)
378         }
379         bufs.Put(data)
380 }
381
382 // Calling Delete() for a block with a timestamp older than
383 // blob_signature_ttl seconds in the past should delete the data.
384 // Test is intended for only writable volumes
385 func testDeleteOldBlock(t *testing.T, factory TestableVolumeFactory) {
386         v := factory(t)
387         defer v.Teardown()
388
389         if v.Writable() == false {
390                 return
391         }
392
393         v.Put(TestHash, TestBlock)
394         v.TouchWithDate(TestHash, time.Now().Add(-2*blob_signature_ttl*time.Second))
395
396         if err := v.Delete(TestHash); err != nil {
397                 t.Error(err)
398         }
399         if _, err := v.Get(TestHash); err == nil || !os.IsNotExist(err) {
400                 t.Errorf("os.IsNotExist(%v) should have been true", err.Error())
401         }
402 }
403
404 // Calling Delete() for a block that does not exist should result in error.
405 // Test should pass for both writable and read-only volumes
406 func testDeleteNoSuchBlock(t *testing.T, factory TestableVolumeFactory) {
407         v := factory(t)
408         defer v.Teardown()
409
410         if err := v.Delete(TestHash2); err == nil {
411                 t.Errorf("Expected error when attempting to delete a non-existing block")
412         }
413 }
414
415 // Invoke Status and verify that VolumeStatus is returned
416 // Test should pass for both writable and read-only volumes
417 func testStatus(t *testing.T, factory TestableVolumeFactory) {
418         v := factory(t)
419         defer v.Teardown()
420
421         // Get node status and make a basic sanity check.
422         status := v.Status()
423         if status.DeviceNum == 0 {
424                 t.Errorf("uninitialized device_num in %v", status)
425         }
426
427         if status.BytesFree == 0 {
428                 t.Errorf("uninitialized bytes_free in %v", status)
429         }
430
431         if status.BytesUsed == 0 {
432                 t.Errorf("uninitialized bytes_used in %v", status)
433         }
434 }
435
436 // Invoke String for the volume; expect non-empty result
437 // Test should pass for both writable and read-only volumes
438 func testString(t *testing.T, factory TestableVolumeFactory) {
439         v := factory(t)
440         defer v.Teardown()
441
442         if id := v.String(); len(id) == 0 {
443                 t.Error("Got empty string for v.String()")
444         }
445 }
446
447 // Putting, updating, touching, and deleting blocks from a read-only volume result in error.
448 // Test is intended for only read-only volumes
449 func testUpdateReadOnly(t *testing.T, factory TestableVolumeFactory) {
450         v := factory(t)
451         defer v.Teardown()
452
453         if v.Writable() == true {
454                 return
455         }
456
457         v.PutRaw(TestHash, TestBlock)
458
459         // Get from read-only volume should succeed
460         _, err := v.Get(TestHash)
461         if err != nil {
462                 t.Errorf("got err %v, expected nil", err)
463         }
464
465         // Put a new block to read-only volume should result in error
466         err = v.Put(TestHash2, TestBlock2)
467         if err == nil {
468                 t.Errorf("Expected error when putting block in a read-only volume")
469         }
470         _, err = v.Get(TestHash2)
471         if err == nil {
472                 t.Errorf("Expected error when getting block whose put in read-only volume failed")
473         }
474
475         // Touch a block in read-only volume should result in error
476         err = v.Touch(TestHash)
477         if err == nil {
478                 t.Errorf("Expected error when touching block in a read-only volume")
479         }
480
481         // Delete a block from a read-only volume should result in error
482         err = v.Delete(TestHash)
483         if err == nil {
484                 t.Errorf("Expected error when deleting block from a read-only volume")
485         }
486
487         // Overwriting an existing block in read-only volume should result in error
488         err = v.Put(TestHash, TestBlock)
489         if err == nil {
490                 t.Errorf("Expected error when putting block in a read-only volume")
491         }
492 }
493
494 // Launch concurrent Gets
495 // Test should pass for both writable and read-only volumes
496 func testGetConcurrent(t *testing.T, factory TestableVolumeFactory) {
497         v := factory(t)
498         defer v.Teardown()
499
500         v.PutRaw(TestHash, TestBlock)
501         v.PutRaw(TestHash2, TestBlock2)
502         v.PutRaw(TestHash3, TestBlock3)
503
504         sem := make(chan int)
505         go func(sem chan int) {
506                 buf, err := v.Get(TestHash)
507                 if err != nil {
508                         t.Errorf("err1: %v", err)
509                 }
510                 bufs.Put(buf)
511                 if bytes.Compare(buf, TestBlock) != 0 {
512                         t.Errorf("buf should be %s, is %s", string(TestBlock), string(buf))
513                 }
514                 sem <- 1
515         }(sem)
516
517         go func(sem chan int) {
518                 buf, err := v.Get(TestHash2)
519                 if err != nil {
520                         t.Errorf("err2: %v", err)
521                 }
522                 bufs.Put(buf)
523                 if bytes.Compare(buf, TestBlock2) != 0 {
524                         t.Errorf("buf should be %s, is %s", string(TestBlock2), string(buf))
525                 }
526                 sem <- 1
527         }(sem)
528
529         go func(sem chan int) {
530                 buf, err := v.Get(TestHash3)
531                 if err != nil {
532                         t.Errorf("err3: %v", err)
533                 }
534                 bufs.Put(buf)
535                 if bytes.Compare(buf, TestBlock3) != 0 {
536                         t.Errorf("buf should be %s, is %s", string(TestBlock3), string(buf))
537                 }
538                 sem <- 1
539         }(sem)
540
541         // Wait for all goroutines to finish
542         for done := 0; done < 3; {
543                 done += <-sem
544         }
545 }
546
547 // Launch concurrent Puts
548 // Test is intended for only writable volumes
549 func testPutConcurrent(t *testing.T, factory TestableVolumeFactory) {
550         v := factory(t)
551         defer v.Teardown()
552
553         if v.Writable() == false {
554                 return
555         }
556
557         sem := make(chan int)
558         go func(sem chan int) {
559                 err := v.Put(TestHash, TestBlock)
560                 if err != nil {
561                         t.Errorf("err1: %v", err)
562                 }
563                 sem <- 1
564         }(sem)
565
566         go func(sem chan int) {
567                 err := v.Put(TestHash2, TestBlock2)
568                 if err != nil {
569                         t.Errorf("err2: %v", err)
570                 }
571                 sem <- 1
572         }(sem)
573
574         go func(sem chan int) {
575                 err := v.Put(TestHash3, TestBlock3)
576                 if err != nil {
577                         t.Errorf("err3: %v", err)
578                 }
579                 sem <- 1
580         }(sem)
581
582         // Wait for all goroutines to finish
583         for done := 0; done < 3; {
584                 done += <-sem
585         }
586
587         // Double check that we actually wrote the blocks we expected to write.
588         buf, err := v.Get(TestHash)
589         if err != nil {
590                 t.Errorf("Get #1: %v", err)
591         }
592         bufs.Put(buf)
593         if bytes.Compare(buf, TestBlock) != 0 {
594                 t.Errorf("Get #1: expected %s, got %s", string(TestBlock), string(buf))
595         }
596
597         buf, err = v.Get(TestHash2)
598         if err != nil {
599                 t.Errorf("Get #2: %v", err)
600         }
601         bufs.Put(buf)
602         if bytes.Compare(buf, TestBlock2) != 0 {
603                 t.Errorf("Get #2: expected %s, got %s", string(TestBlock2), string(buf))
604         }
605
606         buf, err = v.Get(TestHash3)
607         if err != nil {
608                 t.Errorf("Get #3: %v", err)
609         }
610         bufs.Put(buf)
611         if bytes.Compare(buf, TestBlock3) != 0 {
612                 t.Errorf("Get #3: expected %s, got %s", string(TestBlock3), string(buf))
613         }
614 }