testPutFullBlock(t, factory)
testTrashUntrash(t, factory)
- testEmptyTrashTrashLifetime3600s(t, factory)
- testEmptyTrashTrashLifetime1s(t, factory)
+ testTrashEmptyTrashUntrash(t, factory)
}
// Put a test block, get it and verify content
bufs.Put(buf)
}
-// With large trashLifetime, perform:
-// Run emptyTrash goroutine with much smaller trashCheckInterval
-// Trash an old block - which either raises ErrNotImplemented or succeeds
-// Untrash - which either raises ErrNotImplemented or succeeds
-// Get - which must find the block
-func testEmptyTrashTrashLifetime3600s(t TB, factory TestableVolumeFactory) {
+func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) {
v := factory(t)
defer v.Teardown()
+ defer func(orig time.Duration) {
+ trashLifetime = orig
+ }(trashLifetime)
- doneEmptyingTrash := make(chan bool)
- defer func() {
- trashLifetime = 0 * time.Second
- doneEmptyingTrash <- true
- }()
+ checkGet := func() error {
+ buf, err := v.Get(TestHash)
+ if err != nil {
+ return err
+ }
+ if bytes.Compare(buf, TestBlock) != 0 {
+ t.Fatalf("Got data %+q, expected %+q", buf, TestBlock)
+ }
+ bufs.Put(buf)
+ return nil
+ }
- trashLifetime = 3600 * time.Second
- trashCheckInterval = 1 * time.Second
+ // First set: EmptyTrash before reaching the trash deadline.
- go emptyTrash(doneEmptyingTrash, trashCheckInterval)
+ trashLifetime = 1 * time.Hour
- // Trash old block
- err := trashUntrashOldBlock(t, v, 2)
+ v.PutRaw(TestHash, TestBlock)
+ v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL))
- // Get is expected to succeed after untrash before EmptyTrash
- // It is still found on readonly volumes
- buf, err := v.Get(TestHash)
+ err := checkGet()
if err != nil {
- if !os.IsNotExist(err) {
- t.Errorf("os.IsNotExist(%v) should have been true", err)
- }
- } else {
- if bytes.Compare(buf, TestBlock) != 0 {
- t.Errorf("Got data %+q, expected %+q", buf, TestBlock)
- }
- bufs.Put(buf)
+ t.Fatal(err)
}
-}
-// With trashLifetime = 1, perform:
-// Run emptyTrash goroutine
-// Trash an old block - which either raises ErrNotImplemented or succeeds
-// Untrash - after emptyTrash goroutine ticks, and hence does not actually untrash
-// Get - which must fail to find the block
-func testEmptyTrashTrashLifetime1s(t TB, factory TestableVolumeFactory) {
- v := factory(t)
- defer v.Teardown()
+ err = v.Trash(TestHash)
+ if err == MethodDisabledError || err == ErrNotImplemented {
+ // Skip the trash tests for read-only volumes, and
+ // volume types that don't support trashLifetime>0.
+ return
+ }
- doneEmptyingTrash := make(chan bool)
- defer func() {
- trashLifetime = 0 * time.Second
- doneEmptyingTrash <- true
- }()
+ err = checkGet()
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("os.IsNotExist(%v) should have been true", err)
+ }
- volumes = append(volumes, v)
+ v.EmptyTrash()
- trashLifetime = 1 * time.Second
- trashCheckInterval = 1 * time.Second
+ // Even after emptying the trash, we can untrash our block
+ // because the deadline hasn't been reached.
+ err = v.Untrash(TestHash)
+ if err != nil {
+ t.Fatal(err)
+ }
+ err = checkGet()
+ if err != nil {
+ t.Fatal(err)
+ }
- go emptyTrash(doneEmptyingTrash, trashCheckInterval)
+ // Untrash should fail if the only block in the trash has
+ // already been untrashed.
+ err = v.Untrash(TestHash)
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("os.IsNotExist(%v) should have been true", err)
+ }
- // Trash old block and untrash a little after first trashCheckInterval
- err := trashUntrashOldBlock(t, v, 3)
+ // The failed Untrash should not interfere with our
+ // already-untrashed copy.
+ err = checkGet()
+ if err != nil {
+ t.Fatal(err)
+ }
- // Get is expected to fail due to EmptyTrash before Untrash
- // It is still found on readonly volumes
- buf, err := v.Get(TestHash)
+ // Second set: EmptyTrash after the trash deadline has passed.
+
+ trashLifetime = 1 * time.Nanosecond
+
+ err = v.Trash(TestHash)
if err != nil {
- if !os.IsNotExist(err) {
- t.Errorf("os.IsNotExist(%v) should have been true", err)
- }
- } else {
- if bytes.Compare(buf, TestBlock) != 0 {
- t.Errorf("Got data %+q, expected %+q", buf, TestBlock)
- }
- bufs.Put(buf)
+ t.Fatal(err)
+ }
+ err = checkGet()
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("os.IsNotExist(%v) should have been true", err)
}
-}
-// Put a block, backdate it, trash it, untrash it after the untrashAfter seconds
-func trashUntrashOldBlock(t TB, v TestableVolume, untrashAfter int) error {
- // put block and backdate it
+ // Even though 1ns has passed, we can untrash because we
+ // haven't called EmptyTrash yet.
+ err = v.Untrash(TestHash)
+ if err != nil {
+ t.Fatal(err)
+ }
+ err = checkGet()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Trash it again, and this time call EmptyTrash so it really
+ // goes away.
+ err = v.Trash(TestHash)
+ err = checkGet()
+ if err == nil || !os.IsNotExist(err) {
+ t.Errorf("os.IsNotExist(%v) should have been true", err)
+ }
+ v.EmptyTrash()
+
+ // Untrash won't find it
+ err = v.Untrash(TestHash)
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("os.IsNotExist(%v) should have been true", err)
+ }
+
+ // Get block won't find it
+ err = checkGet()
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("os.IsNotExist(%v) should have been true", err)
+ }
+
+ // Third set: If the same data block gets written again after
+ // being trashed, and then the trash gets emptied, the newer
+ // un-trashed copy doesn't get deleted along with it.
+
v.PutRaw(TestHash, TestBlock)
v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL))
- buf, err := v.Get(TestHash)
+ trashLifetime = time.Nanosecond
+ err = v.Trash(TestHash)
if err != nil {
t.Fatal(err)
}
- if bytes.Compare(buf, TestBlock) != 0 {
- t.Fatalf("Got data %+q, expected %+q", buf, TestBlock)
+ err = checkGet()
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("os.IsNotExist(%v) should have been true", err)
}
- bufs.Put(buf)
- // Trash
+ v.PutRaw(TestHash, TestBlock)
+ v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL))
+
+ // EmptyTrash should not delete the untrashed copy.
+ v.EmptyTrash()
+ err = checkGet()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Fourth set: If the same data block gets trashed twice with
+ // different deadlines A and C, and then the trash is emptied
+ // at intermediate time B (A < B < C), it is still possible to
+ // untrash the block whose deadline is "C".
+
+ v.PutRaw(TestHash, TestBlock)
+ v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL))
+
+ trashLifetime = time.Nanosecond
err = v.Trash(TestHash)
if err != nil {
- if err != ErrNotImplemented && err != MethodDisabledError {
- t.Fatal(err)
- } else {
- // To test emptyTrash goroutine effectively, we need to give the
- // ticker a couple rounds, adding some sleep time to the test.
- // This delay is unnecessary for volumes that are currently
- // not yet supporting trashLifetime > 0 (this case is already
- // covered in the testTrashUntrash already)
- return err
- }
- } else {
- _, err = v.Get(TestHash)
- if err == nil || !os.IsNotExist(err) {
- t.Fatalf("os.IsNotExist(%v) should have been true", err)
- }
+ t.Fatal(err)
}
- // Untrash after give wait time; it may have been deleted by emptyTrash goroutine
- time.Sleep(time.Duration(untrashAfter) * time.Second)
+ v.PutRaw(TestHash, TestBlock)
+ v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL))
+
+ trashLifetime = time.Hour
+ err = v.Trash(TestHash)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // EmptyTrash should not prevent us from recovering the
+ // time.Hour ("C") trash
+ v.EmptyTrash()
err = v.Untrash(TestHash)
if err != nil {
- if err != ErrNotImplemented && err != MethodDisabledError && err != os.ErrNotExist {
- t.Fatal(err)
- }
+ t.Fatal(err)
+ }
+ err = checkGet()
+ if err != nil {
+ t.Fatal(err)
}
- return err
}
projects / arvados.git / blobdiff