X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/12bfd7a65c6635a882cb2e5e419321db100b9d56..0821f5481edd016a3744bb50d97a9e5b99cd1a0f:/services/keepstore/volume_generic_test.go?ds=sidebyside diff --git a/services/keepstore/volume_generic_test.go b/services/keepstore/volume_generic_test.go index 105795c146..bc3e537a89 100644 --- a/services/keepstore/volume_generic_test.go +++ b/services/keepstore/volume_generic_test.go @@ -7,6 +7,7 @@ import ( "os" "regexp" "sort" + "strconv" "strings" "time" @@ -355,10 +356,22 @@ func testIndexTo(t TB, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() + // minMtime and maxMtime are the minimum and maximum + // acceptable values the index can report for our test + // blocks. 1-second precision is acceptable. + minMtime := time.Now().UTC().UnixNano() + minMtime -= minMtime % 1e9 + v.PutRaw(TestHash, TestBlock) v.PutRaw(TestHash2, TestBlock2) v.PutRaw(TestHash3, TestBlock3) + maxMtime := time.Now().UTC().UnixNano() + if maxMtime%1e9 > 0 { + maxMtime -= maxMtime % 1e9 + maxMtime += 1e9 + } + // Blocks whose names aren't Keep hashes should be omitted from // index v.PutRaw("fffffffffnotreallyahashfffffffff", nil) @@ -371,15 +384,21 @@ func testIndexTo(t TB, factory TestableVolumeFactory) { indexRows := strings.Split(string(buf.Bytes()), "\n") sort.Strings(indexRows) sortedIndex := strings.Join(indexRows, "\n") - m, err := regexp.MatchString( - `^\n`+TestHash+`\+\d+ \d+\n`+ - TestHash3+`\+\d+ \d+\n`+ - TestHash2+`\+\d+ \d+$`, - sortedIndex) - if err != nil { - t.Error(err) - } else if !m { + m := regexp.MustCompile( + `^\n` + TestHash + `\+\d+ (\d+)\n` + + TestHash3 + `\+\d+ \d+\n` + + TestHash2 + `\+\d+ \d+$`, + ).FindStringSubmatch(sortedIndex) + if m == nil { t.Errorf("Got index %q for empty prefix", sortedIndex) + } else { + mtime, err := strconv.ParseInt(m[1], 10, 64) + if err != nil { + t.Error(err) + } else if mtime < minMtime || mtime > maxMtime { + t.Errorf("got %d for TestHash timestamp, expected %d <= t <= %d", + mtime, minMtime, maxMtime) + } } for _, prefix := range []string{"f", "f15", "f15ac"} { @@ -396,7 +415,7 @@ func testIndexTo(t TB, factory TestableVolumeFactory) { for _, prefix := range []string{"zero", "zip", "zilch"} { buf = new(bytes.Buffer) - v.IndexTo(prefix, buf) + err := v.IndexTo(prefix, buf) if err != nil { t.Errorf("Got error on IndexTo with no such prefix %v", err.Error()) } else if buf.Len() != 0 { @@ -453,6 +472,27 @@ func testDeleteOldBlock(t TB, factory TestableVolumeFactory) { if _, err := v.Get(TestHash, data); err == nil || !os.IsNotExist(err) { t.Errorf("os.IsNotExist(%v) should have been true", err) } + + _, err := v.Mtime(TestHash) + if err == nil || !os.IsNotExist(err) { + t.Fatalf("os.IsNotExist(%v) should have been true", err) + } + + err = v.Compare(TestHash, TestBlock) + if err == nil || !os.IsNotExist(err) { + t.Fatalf("os.IsNotExist(%v) should have been true", err) + } + + indexBuf := new(bytes.Buffer) + v.IndexTo("", indexBuf) + if strings.Contains(string(indexBuf.Bytes()), TestHash) { + t.Fatalf("Found trashed block in IndexTo") + } + + err = v.Touch(TestHash) + if err == nil || !os.IsNotExist(err) { + t.Fatalf("os.IsNotExist(%v) should have been true", err) + } } // Calling Delete() for a block that does not exist should result in error. @@ -701,7 +741,7 @@ func testTrashUntrash(t TB, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() defer func() { - trashLifetime = 0 * time.Second + trashLifetime = 0 }() trashLifetime = 3600 * time.Second @@ -723,11 +763,11 @@ func testTrashUntrash(t TB, factory TestableVolumeFactory) { err = v.Trash(TestHash) if v.Writable() == false { if err != MethodDisabledError { - t.Error(err) + t.Fatal(err) } } else if err != nil { if err != ErrNotImplemented { - t.Error(err) + t.Fatal(err) } } else { _, err = v.Get(TestHash, buf) @@ -768,12 +808,29 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) { if bytes.Compare(buf[:n], TestBlock) != 0 { t.Fatalf("Got data %+q, expected %+q", buf[:n], TestBlock) } + + _, err = v.Mtime(TestHash) + if err != nil { + return err + } + + err = v.Compare(TestHash, TestBlock) + if err != nil { + return err + } + + indexBuf := new(bytes.Buffer) + v.IndexTo("", indexBuf) + if !strings.Contains(string(indexBuf.Bytes()), TestHash) { + return os.ErrNotExist + } + return nil } // First set: EmptyTrash before reaching the trash deadline. - trashLifetime = 1 * time.Hour + trashLifetime = time.Hour v.PutRaw(TestHash, TestBlock) v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL)) @@ -783,6 +840,7 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) { t.Fatal(err) } + // Trash the block err = v.Trash(TestHash) if err == MethodDisabledError || err == ErrNotImplemented { // Skip the trash tests for read-only volumes, and @@ -795,6 +853,11 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) { t.Fatalf("os.IsNotExist(%v) should have been true", err) } + err = v.Touch(TestHash) + if err == nil || !os.IsNotExist(err) { + t.Fatalf("os.IsNotExist(%v) should have been true", err) + } + v.EmptyTrash() // Even after emptying the trash, we can untrash our block @@ -803,28 +866,41 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) { if err != nil { t.Fatal(err) } + err = checkGet() if err != nil { t.Fatal(err) } - // Untrash should fail if the only block in the trash has - // already been untrashed. + err = v.Touch(TestHash) + if err != nil { + t.Fatal(err) + } + + // Because we Touch'ed, need to backdate again for next set of tests + v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL)) + + // If the only block in the trash has already been untrashed, + // most volumes will fail a subsequent Untrash with a 404, but + // it's also acceptable for Untrash to succeed. err = v.Untrash(TestHash) - if err == nil || !os.IsNotExist(err) { - t.Fatalf("os.IsNotExist(%v) should have been true", err) + if err != nil && !os.IsNotExist(err) { + t.Fatalf("Expected success or os.IsNotExist(), but got: %v", err) } - // The failed Untrash should not interfere with our + // The additional Untrash should not interfere with our // already-untrashed copy. err = checkGet() if err != nil { t.Fatal(err) } + // Untrash might have updated the timestamp, so backdate again + v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL)) + // Second set: EmptyTrash after the trash deadline has passed. - trashLifetime = 1 * time.Nanosecond + trashLifetime = time.Nanosecond err = v.Trash(TestHash) if err != nil { @@ -848,10 +924,12 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) { // Trash it again, and this time call EmptyTrash so it really // goes away. + // (In Azure volumes, un/trash changes Mtime, so first backdate again) + v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL)) err = v.Trash(TestHash) err = checkGet() if err == nil || !os.IsNotExist(err) { - t.Errorf("os.IsNotExist(%v) should have been true", err) + t.Fatalf("os.IsNotExist(%v) should have been true", err) } v.EmptyTrash()