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 }