mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-11-20 03:13:53 +01:00
* storage: reject a streamed read whose record id or size differs The header probe before a streamed read returned not-found only when both the record's id and its size differed from the index entry, so a record of another needle with the same size passed and its data was streamed under the requested key until the final checksum check. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * storage: refuse a needle blob whose header names another needle WriteNeedleBlob compared only the blob header's size with the size it was asked to index. A blob read from an offset that has since moved to another record of the same size was appended and indexed under the wrong key. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * volume(rs): refuse a needle blob whose header names another needle Mirror of the Go check: write_needle_blob_and_index compared only the blob header's size, so a blob of another needle with the same size was appended and indexed under the requested key. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * volume(rs): report not-found when a streamed read's record is another needle The meta read ahead of a streamed reply took the id from the record header without comparing it with the requested key. Return not-found when the index entry resolves to another needle, as the Go header probe does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * storage: check the requested id after a meta-only read ReadNeedleMeta overwrites n.Id with the record's header id, so a meta-only read through an index entry that resolves to another needle returned that needle's metadata, and the streamed-read probe that follows compared the record with itself. Return not-found when the header names another needle, as the Rust meta read does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test: copy a needle blob to another volume, not under another key WriteNeedleBlob now refuses a blob whose header names another needle, so the round trip writes the blob under its own id into a second volume and checks that storing it under another key is refused. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * storage: compare the streamed header with a deleted entry's record size A deleted index entry stores the negated size, so a read-deleted stream compared the positive header size with a negative one and missed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
620 lines
19 KiB
Go
620 lines
19 KiB
Go
package storage
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/seaweedfs/seaweedfs/weed/stats"
|
|
"github.com/seaweedfs/seaweedfs/weed/storage/backend"
|
|
"github.com/seaweedfs/seaweedfs/weed/storage/needle"
|
|
"github.com/seaweedfs/seaweedfs/weed/storage/super_block"
|
|
"github.com/seaweedfs/seaweedfs/weed/storage/types"
|
|
"github.com/seaweedfs/seaweedfs/weed/util"
|
|
)
|
|
|
|
func TestSearchVolumesWithDeletedNeedles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 1, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
count := 20
|
|
|
|
for i := 1; i < count; i++ {
|
|
n := newRandomNeedle(uint64(i))
|
|
_, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
for i := 1; i < 15; i++ {
|
|
n := newEmptyNeedle(uint64(i))
|
|
err := v.nm.Put(n.Id, types.Offset{}, types.TombstoneFileSize)
|
|
if err != nil {
|
|
t.Fatalf("delete needle %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
ts1 := time.Now().UnixNano()
|
|
|
|
for i := 15; i < count; i++ {
|
|
n := newEmptyNeedle(uint64(i))
|
|
_, err := v.doDeleteRequest(n)
|
|
if err != nil {
|
|
t.Fatalf("delete needle %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
offset, isLast, err := v.BinarySearchByAppendAtNs(uint64(ts1))
|
|
if err != nil {
|
|
t.Fatalf("lookup by ts: %v", err)
|
|
}
|
|
fmt.Printf("offset: %v, isLast: %v\n", offset.ToActualOffset(), isLast)
|
|
|
|
}
|
|
|
|
func isFileExist(path string) (bool, error) {
|
|
if _, err := os.Stat(path); err == nil {
|
|
return true, nil
|
|
} else if errors.Is(err, os.ErrNotExist) {
|
|
return false, nil
|
|
} else {
|
|
return false, err
|
|
}
|
|
}
|
|
|
|
func assertFileExist(t *testing.T, expected bool, path string) {
|
|
exist, err := isFileExist(path)
|
|
if err != nil {
|
|
t.Fatalf("isFileExist: %v", err)
|
|
}
|
|
assert.Equal(t, expected, exist)
|
|
}
|
|
|
|
func TestDestroyEmptyVolumeWithOnlyEmpty(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 1, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
path := v.DataBackend.Name()
|
|
|
|
// should can Destroy empty volume with onlyEmpty
|
|
assertFileExist(t, true, path)
|
|
err = v.Destroy(true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("destroy volume: %v", err)
|
|
}
|
|
assertFileExist(t, false, path)
|
|
}
|
|
|
|
func TestDestroyEmptyVolumeWithoutOnlyEmpty(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 1, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
path := v.DataBackend.Name()
|
|
|
|
// should can Destroy empty volume without onlyEmpty
|
|
assertFileExist(t, true, path)
|
|
err = v.Destroy(false, false, false)
|
|
if err != nil {
|
|
t.Fatalf("destroy volume: %v", err)
|
|
}
|
|
assertFileExist(t, false, path)
|
|
}
|
|
|
|
func TestDestroyNonemptyVolumeWithOnlyEmpty(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 1, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
path := v.DataBackend.Name()
|
|
|
|
// should return "volume not empty" error and do not delete file when Destroy non-empty volume
|
|
_, _, _, err = v.writeNeedle2(newRandomNeedle(1), true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
assert.Equal(t, uint64(1), v.FileCount())
|
|
|
|
assertFileExist(t, true, path)
|
|
err = v.Destroy(true, false, false)
|
|
assert.EqualError(t, err, "volume not empty")
|
|
assertFileExist(t, true, path)
|
|
|
|
// should keep working after "volume not empty"
|
|
_, _, _, err = v.writeNeedle2(newRandomNeedle(2), true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
|
|
assert.Equal(t, uint64(2), v.FileCount())
|
|
}
|
|
|
|
func TestDestroyNonemptyVolumeWithoutOnlyEmpty(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 1, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
path := v.DataBackend.Name()
|
|
|
|
// should can Destroy non-empty volume without onlyEmpty
|
|
_, _, _, err = v.writeNeedle2(newRandomNeedle(1), true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
assert.Equal(t, uint64(1), v.FileCount())
|
|
|
|
assertFileExist(t, true, path)
|
|
err = v.Destroy(false, false, false)
|
|
if err != nil {
|
|
t.Fatalf("destroy volume: %v", err)
|
|
}
|
|
assertFileExist(t, false, path)
|
|
}
|
|
|
|
// Pre-fix: the blob was appended to .dat, then rejected by SortedFileNeedleMap.Put.
|
|
func TestWriteNeedleBlobRejectedOnReadOnlyVolume(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
blob, err := v.ReadNeedleBlob(int64(offset), n.Size)
|
|
if err != nil {
|
|
t.Fatalf("read needle blob: %v", err)
|
|
}
|
|
if err := v.PersistReadOnly(true, false); err != nil {
|
|
t.Fatalf("persist read-only: %v", err)
|
|
}
|
|
v.Close()
|
|
|
|
v, err = NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume reload: %v", err)
|
|
}
|
|
defer v.Close()
|
|
if _, ok := v.nm.(*SortedFileNeedleMap); !ok {
|
|
t.Fatalf("reloaded read-only volume should use SortedFileNeedleMap, got %T", v.nm)
|
|
}
|
|
|
|
datSizeBefore, _, _ := v.DataBackend.GetStat()
|
|
|
|
err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), withNeedleId(blob, 2), n.Size)
|
|
if err == nil {
|
|
t.Fatalf("expected WriteNeedleBlob to be rejected on a read-only volume")
|
|
}
|
|
if errors.Is(err, os.ErrInvalid) {
|
|
t.Errorf("WriteNeedleBlob should fail with a read-only error, not the needle map's os.ErrInvalid: %v", err)
|
|
}
|
|
|
|
datSizeAfter, _, _ := v.DataBackend.GetStat()
|
|
if datSizeAfter != datSizeBefore {
|
|
t.Errorf("read-only volume .dat grew from %d to %d, leaving an unindexed needle", datSizeBefore, datSizeAfter)
|
|
}
|
|
}
|
|
|
|
// A size disagreeing with the blob's own header indexes the needle at the wrong
|
|
// length and, on v3, stamps the append timestamp into the middle of the needle.
|
|
func TestWriteNeedleBlobRejectsSizeMismatch(t *testing.T) {
|
|
dir := t.TempDir()
|
|
location := NewDiskLocation(dir, 10, util.MinFreeSpace{}, dir, "", nil, stats.DefaultDiskIOProbeConfig())
|
|
defer location.Close()
|
|
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
location.SetVolume(7, v)
|
|
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
blob, err := v.ReadNeedleBlob(int64(offset), n.Size)
|
|
if err != nil {
|
|
t.Fatalf("read needle blob: %v", err)
|
|
}
|
|
|
|
datSizeBefore, _, _ := v.DataBackend.GetStat()
|
|
|
|
// types.Size(n.DataSize) is what needle.Append reports, and what a caller
|
|
// following the payload-size convention would send.
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), withNeedleId(blob, 2), types.Size(n.DataSize)); err == nil {
|
|
t.Fatal("expected WriteNeedleBlob to reject a size that disagrees with the blob header")
|
|
}
|
|
|
|
datSizeAfter, _, _ := v.DataBackend.GetStat()
|
|
if datSizeAfter != datSizeBefore {
|
|
t.Errorf(".dat grew from %d to %d on a rejected blob", datSizeBefore, datSizeAfter)
|
|
}
|
|
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), withNeedleId(blob, 2), n.Size); err != nil {
|
|
t.Fatalf("write needle blob with the header size: %v", err)
|
|
}
|
|
}
|
|
|
|
// A negative size reaches make() in needle.ReadNeedleBlob, and the blob RPCs
|
|
// have no recover, so one request took down the volume server.
|
|
func TestReadNeedleBlobRejectsNegativeSize(t *testing.T) {
|
|
dir := t.TempDir()
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
|
|
for _, size := range []types.Size{types.TombstoneFileSize, -100, math.MinInt32} {
|
|
t.Run(fmt.Sprintf("size %d", size), func(t *testing.T) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ReadNeedleBlob panicked: %v", r)
|
|
}
|
|
}()
|
|
if _, err := v.ReadNeedleBlob(int64(offset), size); err == nil {
|
|
t.Error("expected ReadNeedleBlob to reject a negative size")
|
|
}
|
|
})
|
|
}
|
|
|
|
// Only negative sizes are rejected: size 0 is what a delete record carries.
|
|
for _, size := range []types.Size{0, n.Size} {
|
|
if _, err := v.ReadNeedleBlob(int64(offset), size); err != nil {
|
|
t.Errorf("ReadNeedleBlob with size %d: %v", size, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// The blob header carries the same negative size, so only the sign is wrong.
|
|
func TestWriteNeedleBlobRejectsNegativeSize(t *testing.T) {
|
|
for _, size := range []types.Size{types.TombstoneFileSize, -5} {
|
|
t.Run(fmt.Sprintf("size %d", size), func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
blob, err := v.ReadNeedleBlob(int64(offset), n.Size)
|
|
if err != nil {
|
|
t.Fatalf("read needle blob: %v", err)
|
|
}
|
|
// Make the header agree with the size, so only the sign is wrong.
|
|
types.SizeToBytes(blob[types.NeedleHeaderSize-types.SizeSize:types.NeedleHeaderSize], size)
|
|
|
|
datSizeBefore, _, _ := v.DataBackend.GetStat()
|
|
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), withNeedleId(blob, 2), size); err == nil {
|
|
t.Error("expected WriteNeedleBlob to reject a negative size")
|
|
}
|
|
|
|
datSizeAfter, _, _ := v.DataBackend.GetStat()
|
|
if datSizeAfter != datSizeBefore {
|
|
t.Errorf(".dat grew from %d to %d on a rejected blob", datSizeBefore, datSizeAfter)
|
|
}
|
|
if nv, ok := v.nm.Get(types.Uint64ToNeedleId(2)); ok {
|
|
t.Errorf("needle 2 was indexed with size %d", nv.Size)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A blob shorter or longer than its record size leaves .dat off the record grid:
|
|
// later writes index at truncated offsets, or a scan reads the leftover bytes as
|
|
// the next record.
|
|
func TestWriteNeedleBlobRejectsLengthMismatch(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
mutate func(blob []byte) []byte
|
|
}{
|
|
{"one byte too long", func(blob []byte) []byte { return append(blob, 0) }},
|
|
{"one byte short", func(blob []byte) []byte { return blob[:len(blob)-1] }},
|
|
{"8 bytes too long", func(blob []byte) []byte { return append(blob, make([]byte, 8)...) }},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
blob, err := v.ReadNeedleBlob(int64(offset), n.Size)
|
|
if err != nil {
|
|
t.Fatalf("read needle blob: %v", err)
|
|
}
|
|
datSizeBefore, _, _ := v.DataBackend.GetStat()
|
|
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), tc.mutate(withNeedleId(blob, 2)), n.Size); err == nil {
|
|
t.Error("expected WriteNeedleBlob to reject a blob whose length does not match its size")
|
|
}
|
|
|
|
datSizeAfter, _, _ := v.DataBackend.GetStat()
|
|
if datSizeAfter != datSizeBefore {
|
|
t.Errorf(".dat grew from %d to %d on a rejected blob", datSizeBefore, datSizeAfter)
|
|
}
|
|
|
|
next := newRandomNeedle(3)
|
|
if _, _, _, err = v.writeNeedle2(next, true, false, false); err != nil {
|
|
t.Fatalf("write needle 3: %v", err)
|
|
}
|
|
got := newEmptyNeedle(3)
|
|
if _, err = v.readNeedle(got, nil, nil); err != nil {
|
|
t.Fatalf("read back needle 3: %v", err)
|
|
}
|
|
if !bytes.Equal(got.Data, next.Data) {
|
|
t.Error("needle 3 read back with different data")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// The checks must pass what the real callers send: a needle's own record and the
|
|
// size-0 record a delete leaves.
|
|
func TestWriteNeedleBlobRoundTrip(t *testing.T) {
|
|
dir := t.TempDir()
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
blob, err := v.ReadNeedleBlob(int64(offset), n.Size)
|
|
if err != nil {
|
|
t.Fatalf("read needle blob: %v", err)
|
|
}
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), withNeedleId(blob, 2), n.Size); err != nil {
|
|
t.Fatalf("write needle blob: %v", err)
|
|
}
|
|
got := newEmptyNeedle(2)
|
|
if _, err = v.readNeedle(got, nil, nil); err != nil {
|
|
t.Fatalf("read back needle 2: %v", err)
|
|
}
|
|
if !bytes.Equal(got.Data, n.Data) {
|
|
t.Error("needle 2 read back with different data")
|
|
}
|
|
|
|
deleteOffset, _, _ := v.DataBackend.GetStat()
|
|
if _, err = v.doDeleteRequest(newEmptyNeedle(1)); err != nil {
|
|
t.Fatalf("delete needle 1: %v", err)
|
|
}
|
|
deleteRecord, err := v.ReadNeedleBlob(deleteOffset, 0)
|
|
if err != nil {
|
|
t.Fatalf("read delete record: %v", err)
|
|
}
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(3), withNeedleId(deleteRecord, 3), 0); err != nil {
|
|
t.Fatalf("write size-0 needle blob: %v", err)
|
|
}
|
|
|
|
next := newRandomNeedle(4)
|
|
if _, _, _, err = v.writeNeedle2(next, true, false, false); err != nil {
|
|
t.Fatalf("write needle 4: %v", err)
|
|
}
|
|
got = newEmptyNeedle(4)
|
|
if _, err = v.readNeedle(got, nil, nil); err != nil {
|
|
t.Fatalf("read back needle 4: %v", err)
|
|
}
|
|
if !bytes.Equal(got.Data, next.Data) {
|
|
t.Error("needle 4 read back with different data")
|
|
}
|
|
}
|
|
|
|
// A write that already assembled the needle and holds the volume write lock
|
|
// must still refuse append once the volume is readonly — no 201/204, nothing
|
|
// in .dat/.idx.
|
|
func TestDoWriteRequestRefusesReadOnlyBeforeAppend(t *testing.T) {
|
|
dir := t.TempDir()
|
|
v, err := NewVolume(dir, dir, "", 21, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
seed := newRandomNeedle(1)
|
|
if _, _, _, err = v.writeNeedle2(seed, true, false, false); err != nil {
|
|
t.Fatalf("seed write: %v", err)
|
|
}
|
|
datBefore, _, err := v.DataBackend.GetStat()
|
|
if err != nil {
|
|
t.Fatalf("stat dat: %v", err)
|
|
}
|
|
idxBefore := v.nm.IndexFileSize()
|
|
|
|
n := newRandomNeedle(99)
|
|
v.dataFileAccessLock.Lock()
|
|
v.noWriteLock.Lock()
|
|
v.noWriteOrDelete = true
|
|
v.noWriteLock.Unlock()
|
|
_, _, isUnchanged, writeErr := v.doWriteRequest(n, true, false)
|
|
v.dataFileAccessLock.Unlock()
|
|
|
|
if writeErr == nil {
|
|
t.Fatal("expected read-only error")
|
|
}
|
|
if isUnchanged {
|
|
t.Fatal("read-only write must not report unchanged (HTTP 204)")
|
|
}
|
|
if _, found := v.nm.Get(n.Id); found {
|
|
t.Fatal("needle must not land in .idx")
|
|
}
|
|
datAfter, _, err := v.DataBackend.GetStat()
|
|
if err != nil {
|
|
t.Fatalf("stat dat after: %v", err)
|
|
}
|
|
if datAfter != datBefore {
|
|
t.Fatalf("dat size %d -> %d; needle must not append", datBefore, datAfter)
|
|
}
|
|
if v.nm.IndexFileSize() != idxBefore {
|
|
t.Fatalf("idx size changed; needle must not index")
|
|
}
|
|
}
|
|
|
|
type syncCountingBackend struct {
|
|
backend.BackendStorageFile
|
|
syncs atomic.Int64
|
|
}
|
|
|
|
func (b *syncCountingBackend) Sync() error {
|
|
b.syncs.Add(1)
|
|
return b.BackendStorageFile.Sync()
|
|
}
|
|
|
|
// A drained queue used to flush whatever it held, turning durable writes into
|
|
// one fsync per request at low concurrency. With a batch window configured, a
|
|
// straggler that lands inside the window joins the same sync.
|
|
func TestSyncBatchDefersFlushForStragglers(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
counting := &syncCountingBackend{BackendStorageFile: v.DataBackend}
|
|
v.DataBackend = counting
|
|
writeBytes := int64(needle.GetActualSize(16, v.Version()))
|
|
v.location = &DiskLocation{syncBatch: SyncBatchOption{
|
|
MinBytes: writeBytes * 2,
|
|
MinRequests: syncBatchMaxRequests,
|
|
Wait: time.Minute,
|
|
}}
|
|
|
|
armed := make(chan chan time.Time, 4)
|
|
prevAfter := syncBatchAfter
|
|
syncBatchAfter = func(time.Duration) <-chan time.Time {
|
|
window := make(chan time.Time, 1)
|
|
armed <- window
|
|
return window
|
|
}
|
|
defer func() { syncBatchAfter = prevAfter }()
|
|
|
|
done := make(chan error, 3)
|
|
writeAsync := func(id uint64) {
|
|
n := new(needle.Needle)
|
|
n.Data = make([]byte, 16)
|
|
n.Checksum = needle.NewCRC(n.Data)
|
|
n.Id = types.Uint64ToNeedleId(id)
|
|
_, _, _, writeErr := v.writeNeedle2(n, true, true, false)
|
|
done <- writeErr
|
|
}
|
|
windowFor := func(id uint64) chan time.Time {
|
|
go writeAsync(id)
|
|
window := <-armed
|
|
select {
|
|
case <-done:
|
|
t.Fatalf("write %d flushed while its batch window was still open", id)
|
|
default:
|
|
}
|
|
return window
|
|
}
|
|
|
|
windowFor(1)
|
|
// the straggler fills the batch to MinBytes, closing the window early
|
|
go writeAsync(2)
|
|
for i := 0; i < 2; i++ {
|
|
if writeErr := <-done; writeErr != nil {
|
|
t.Fatalf("write needle: %v", writeErr)
|
|
}
|
|
}
|
|
if syncs := counting.syncs.Load(); syncs != 1 {
|
|
t.Fatalf("expected both writes to share one .dat sync, got %d", syncs)
|
|
}
|
|
|
|
window := windowFor(3)
|
|
window <- time.Now()
|
|
if writeErr := <-done; writeErr != nil {
|
|
t.Fatalf("write needle: %v", writeErr)
|
|
}
|
|
if syncs := counting.syncs.Load(); syncs != 2 {
|
|
t.Fatalf("expected a lone write to take its own sync, got %d total", syncs)
|
|
}
|
|
}
|
|
|
|
// withNeedleId returns a copy of blob whose header names needle id.
|
|
func withNeedleId(blob []byte, id uint64) []byte {
|
|
out := append([]byte(nil), blob...)
|
|
types.NeedleIdToBytes(out[types.CookieSize:types.CookieSize+types.NeedleIdSize], types.Uint64ToNeedleId(id))
|
|
return out
|
|
}
|
|
|
|
func TestWriteNeedleBlobRejectsAnotherNeedlesBlob(t *testing.T) {
|
|
dir := t.TempDir()
|
|
v, err := NewVolume(dir, dir, "", 7, NeedleMapInMemory, &super_block.ReplicaPlacement{}, &needle.TTL{}, 0, needle.GetCurrentVersion(), 0, 0)
|
|
if err != nil {
|
|
t.Fatalf("volume creation: %v", err)
|
|
}
|
|
defer v.Close()
|
|
|
|
n := newRandomNeedle(1)
|
|
offset, _, _, err := v.writeNeedle2(n, true, false, false)
|
|
if err != nil {
|
|
t.Fatalf("write needle: %v", err)
|
|
}
|
|
blob, err := v.ReadNeedleBlob(int64(offset), n.Size)
|
|
if err != nil {
|
|
t.Fatalf("read needle blob: %v", err)
|
|
}
|
|
datSizeBefore, _, _ := v.DataBackend.GetStat()
|
|
if err = v.WriteNeedleBlob(types.Uint64ToNeedleId(2), blob, n.Size); err == nil {
|
|
t.Fatal("needle 1's blob was stored under key 2")
|
|
}
|
|
if datSizeAfter, _, _ := v.DataBackend.GetStat(); datSizeAfter != datSizeBefore {
|
|
t.Errorf("rejected blob grew .dat from %d to %d bytes", datSizeBefore, datSizeAfter)
|
|
}
|
|
if _, ok := v.nm.Get(types.Uint64ToNeedleId(2)); ok {
|
|
t.Error("rejected blob was indexed under key 2")
|
|
}
|
|
}
|