func compareTestNeedle(t *testing.T, key int64, cookie int32, flag byte, n *needle.Needle, data []byte) (err error) {
if err = n.Parse(); err != nil {
t.Error(err)
return
}
if !bytes.Equal(n.Data, data) {
err = fmt.Errorf("data: %s not match", n.Data)
t.Error(err)
return
}
if n.Cookie != cookie {
err = fmt.Errorf("cookie: %d not match", n.Cookie)
t.Error(err)
return
}
if n.Key != key {
err = fmt.Errorf("key: %d not match", n.Key)
t.Error(err)
return
}
if n.Flag != flag {
err = fmt.Errorf("flag: %d not match", n.Flag)
t.Error(err)
return
}
if n.Size != int32(len(data)) {
err = fmt.Errorf("size: %d not match", n.Size)
t.Error(err)
return
}
return
}
// ReadAt read a needle by specified offset, before call it, must set needle
// TotalSize.
func (b *SuperBlock) ReadAt(n *needle.Needle) (err error) {
if b.LastErr != nil {
return b.LastErr
}
if _, err = b.r.ReadAt(n.Buffer(), needle.BlockOffset(n.Offset)); err == nil {
err = n.Parse()
} else {
b.LastErr = err
}
return
}
func (v *Volume) get(n *needle.Needle) (err error) {
var (
ok bool
nc int64
offset uint32
size int32
key = n.Key
now = time.Now().UnixNano()
)
// pread syscall is atomic, so use rlock
v.lock.RLock()
if nc, ok = v.needles[key]; ok {
if offset, size = needle.Cache(nc); offset != needle.CacheDelOffset {
n.TotalSize = size
err = v.Block.ReadAt(offset, n)
} else {
err = errors.ErrNeedleDeleted
}
} else {
err = errors.ErrNeedleNotExist
}
v.lock.RUnlock()
if err != nil {
return
}
if err = n.Parse(); err != nil {
return
}
if n.Key != key {
return errors.ErrNeedleKey
}
if n.TotalSize != size {
return errors.ErrNeedleSize
}
if log.V(1) {
log.Infof("get needle key: %d, cookie: %d, offset: %d, size: %d", n.Key, n.Cookie, offset, size)
log.Infof("%v\n", n)
}
// needles map may be out-dated, recheck
if n.Flag == needle.FlagDel {
v.lock.Lock()
v.needles[key] = needle.NewCache(needle.CacheDelOffset, size)
v.lock.Unlock()
err = errors.ErrNeedleDeleted
} else {
atomic.AddUint64(&v.Stats.TotalGetProcessed, 1)
atomic.AddUint64(&v.Stats.TotalReadBytes, uint64(size))
atomic.AddUint64(&v.Stats.TotalGetDelay, uint64(time.Now().UnixNano()-now))
}
return
}