frostfs-node/lib/test/bucket.go

145 lines
2.1 KiB
Go
Raw Normal View History

package test
import (
"sync"
"github.com/mr-tron/base58"
"github.com/nspcc-dev/neofs-api-go/object"
"github.com/nspcc-dev/neofs-node/internal"
"github.com/nspcc-dev/neofs-node/lib/core"
)
type (
testBucket struct {
sync.RWMutex
items map[string][]byte
}
)
const (
errOverflow = internal.Error("overflow")
errNotFound = internal.Error("not found")
)
// Bucket constructs test core.Bucket implementation.
func Bucket() core.Bucket {
return &testBucket{
items: make(map[string][]byte),
}
}
func (t *testBucket) Get(key []byte) ([]byte, error) {
t.Lock()
defer t.Unlock()
val, ok := t.items[base58.Encode(key)]
if !ok {
return nil, core.ErrNotFound
}
return val, nil
}
func (t *testBucket) Set(key, value []byte) error {
t.Lock()
defer t.Unlock()
t.items[base58.Encode(key)] = value
return nil
}
func (t *testBucket) Del(key []byte) error {
t.RLock()
defer t.RUnlock()
delete(t.items, base58.Encode(key))
return nil
}
func (t *testBucket) Has(key []byte) bool {
t.RLock()
defer t.RUnlock()
_, ok := t.items[base58.Encode(key)]
return ok
}
func (t *testBucket) Size() (res int64) {
t.RLock()
defer t.RUnlock()
for _, v := range t.items {
res += int64(len(v))
}
return
}
func (t *testBucket) List() ([][]byte, error) {
t.Lock()
defer t.Unlock()
res := make([][]byte, 0)
for k := range t.items {
sk, err := base58.Decode(k)
if err != nil {
return nil, err
}
res = append(res, sk)
}
return res, nil
}
func (t *testBucket) Iterate(f core.FilterHandler) error {
t.RLock()
defer t.RUnlock()
for k, v := range t.items {
key, err := base58.Decode(k)
if err != nil {
continue
}
if !f(key, v) {
return core.ErrIteratingAborted
}
}
return nil
}
func (t *testBucket) Close() error {
t.Lock()
defer t.Unlock()
for k := range t.items {
delete(t.items, k)
}
return nil
}
func (t *testBucket) PRead(key []byte, rng object.Range) ([]byte, error) {
t.RLock()
defer t.RUnlock()
k := base58.Encode(key)
v, ok := t.items[k]
if !ok {
return nil, errNotFound
}
if rng.Offset+rng.Length > uint64(len(v)) {
return nil, errOverflow
}
return v[rng.Offset : rng.Offset+rng.Length], nil
}