func (stor *valueStore) Read(ctx context.Context, keyA, keyB uint64, value []byte) (timestampMicro int64, rvalue []byte, err error) {
var req *asyncValueReadRequest
select {
case req = <-stor.freeReadReqChan:
case <-ctx.Done():
return 0, rvalue, ctx.Err()
}
req.canceled = false
req.req.KeyA = keyA
req.req.KeyB = keyB
select {
case stor.pendingReadReqChan <- req:
case <-ctx.Done():
stor.freeReadReqChan <- req
return 0, rvalue, ctx.Err()
}
var res *asyncValueReadResponse
select {
case res = <-req.resChan:
case <-ctx.Done():
req.canceledLock.Lock()
select {
case <-req.resChan:
default:
req.canceled = true
}
req.canceledLock.Unlock()
return 0, rvalue, ctx.Err()
}
stor.freeReadReqChan <- req
if res.err != nil {
err = res.err
stor.freeReadResChan <- res
return 0, rvalue, err
}
timestampMicro = res.res.TimestampMicro
rvalue = append(rvalue, res.res.Value...)
if res.res.Err == "" {
err = nil
} else {
err = proto.TranslateErrorString(res.res.Err)
}
stor.freeReadResChan <- res
return timestampMicro, rvalue, err
}
func (stor *valueStore) Lookup(ctx context.Context, keyA, keyB uint64) (timestampMicro int64, length uint32, err error) {
var req *asyncValueLookupRequest
select {
case req = <-stor.freeLookupReqChan:
case <-ctx.Done():
return 0, 0, ctx.Err()
}
req.canceled = false
req.req.KeyA = keyA
req.req.KeyB = keyB
select {
case stor.pendingLookupReqChan <- req:
case <-ctx.Done():
stor.freeLookupReqChan <- req
return 0, 0, ctx.Err()
}
var res *asyncValueLookupResponse
select {
case res = <-req.resChan:
case <-ctx.Done():
req.canceledLock.Lock()
select {
case <-req.resChan:
default:
req.canceled = true
}
req.canceledLock.Unlock()
return 0, 0, ctx.Err()
}
stor.freeLookupReqChan <- req
if res.err != nil {
err = res.err
stor.freeLookupResChan <- res
return 0, 0, err
}
timestampMicro = res.res.TimestampMicro
length = res.res.Length
if res.res.Err == "" {
err = nil
} else {
err = proto.TranslateErrorString(res.res.Err)
}
stor.freeLookupResChan <- res
return timestampMicro, length, err
}
func (stor *groupStore) Delete(ctx context.Context, keyA, keyB uint64, childKeyA, childKeyB uint64, timestampMicro int64) (oldTimestampMicro int64, err error) {
var req *asyncGroupDeleteRequest
select {
case req = <-stor.freeDeleteReqChan:
case <-ctx.Done():
return 0, ctx.Err()
}
req.canceled = false
req.req.KeyA = keyA
req.req.KeyB = keyB
req.req.ChildKeyA = childKeyA
req.req.ChildKeyB = childKeyB
req.req.TimestampMicro = timestampMicro
select {
case stor.pendingDeleteReqChan <- req:
case <-ctx.Done():
stor.freeDeleteReqChan <- req
return 0, ctx.Err()
}
var res *asyncGroupDeleteResponse
select {
case res = <-req.resChan:
case <-ctx.Done():
req.canceledLock.Lock()
select {
case <-req.resChan:
default:
req.canceled = true
}
req.canceledLock.Unlock()
return 0, ctx.Err()
}
stor.freeDeleteReqChan <- req
if res.err != nil {
err = res.err
stor.freeDeleteResChan <- res
return 0, err
}
oldTimestampMicro = res.res.TimestampMicro
if res.res.Err == "" {
err = nil
} else {
err = proto.TranslateErrorString(res.res.Err)
}
stor.freeDeleteResChan <- res
return oldTimestampMicro, err
}
func (stor *groupStore) ReadGroup(ctx context.Context, parentKeyA, parentKeyB uint64) (items []store.ReadGroupItem, err error) {
var req *asyncGroupReadGroupRequest
select {
case req = <-stor.freeReadGroupReqChan:
case <-ctx.Done():
return nil, ctx.Err()
}
req.canceled = false
req.req.KeyA = parentKeyA
req.req.KeyB = parentKeyB
select {
case stor.pendingReadGroupReqChan <- req:
case <-ctx.Done():
stor.freeReadGroupReqChan <- req
return nil, ctx.Err()
}
var res *asyncGroupReadGroupResponse
select {
case res = <-req.resChan:
case <-ctx.Done():
req.canceledLock.Lock()
select {
case <-req.resChan:
default:
req.canceled = true
}
req.canceledLock.Unlock()
return nil, ctx.Err()
}
stor.freeReadGroupReqChan <- req
if res.err != nil {
err = res.err
stor.freeReadGroupResChan <- res
return nil, err
}
items = make([]store.ReadGroupItem, len(res.res.Items))
for i, v := range res.res.Items {
items[i].ChildKeyA = v.ChildKeyA
items[i].ChildKeyB = v.ChildKeyB
items[i].TimestampMicro = v.TimestampMicro
items[i].Value = v.Value
}
if res.res.Err == "" {
err = nil
} else {
err = proto.TranslateErrorString(res.res.Err)
}
stor.freeReadGroupResChan <- res
return items, err
}
func (stor *groupStore) Write(ctx context.Context, keyA, keyB uint64, childKeyA, childKeyB uint64, timestampMicro int64, value []byte) (oldTimestampMicro int64, err error) {
var req *asyncGroupWriteRequest
select {
case req = <-stor.freeWriteReqChan:
case <-ctx.Done():
return 0, ctx.Err()
}
req.canceled = false
req.req.KeyA = keyA
req.req.KeyB = keyB
req.req.ChildKeyA = childKeyA
req.req.ChildKeyB = childKeyB
req.req.TimestampMicro = timestampMicro
if len(value) == 0 {
panic(fmt.Sprintf("REMOVEME %s asked to Write a zlv", stor.addr))
}
req.req.Value = value
select {
case stor.pendingWriteReqChan <- req:
case <-ctx.Done():
stor.freeWriteReqChan <- req
return 0, ctx.Err()
}
var res *asyncGroupWriteResponse
select {
case res = <-req.resChan:
case <-ctx.Done():
req.canceledLock.Lock()
select {
case <-req.resChan:
default:
req.canceled = true
}
req.canceledLock.Unlock()
return 0, ctx.Err()
}
stor.freeWriteReqChan <- req
if res.err != nil {
err = res.err
stor.freeWriteResChan <- res
return 0, err
}
oldTimestampMicro = res.res.TimestampMicro
if res.res.Err == "" {
err = nil
} else {
err = proto.TranslateErrorString(res.res.Err)
}
stor.freeWriteResChan <- res
return oldTimestampMicro, err
}