// AppendVbmaps for a list of `kvaddrs` to vbmap-response.
func (resp *VbmapResponse) AppendVbmaps(kvaddrs []string, vbnos [][]uint16) *VbmapResponse {
for i, kvaddr := range kvaddrs {
resp.Kvaddrs = append(resp.Kvaddrs, kvaddr)
resp.Kvvbnos = append(resp.Kvvbnos, &Vbuckets{Vbnos: c.Vbno16to32(vbnos[i])})
}
return resp
}
// protobufEncode encode payload message into protobuf array of bytes. Return
// `data` can be transported to the other end and decoded back to Payload
// message.
func protobufEncode(payload interface{}) (data []byte, err error) {
pl := protobuf.Payload{
Version: proto.Uint32(uint32(ProtobufVersion())),
}
switch val := payload.(type) {
case []*c.VbKeyVersions:
pl.Vbkeys = make([]*protobuf.VbKeyVersions, 0, len(val))
for _, vb := range val { // for each VbKeyVersions
pvb := &protobuf.VbKeyVersions{
Bucketname: proto.String(vb.Bucket),
Vbucket: proto.Uint32(uint32(vb.Vbucket)),
Vbuuid: proto.Uint64(vb.Vbuuid),
}
pvb.Kvs = make([]*protobuf.KeyVersions, 0, len(vb.Kvs))
for _, kv := range vb.Kvs { // for each mutation
pkv := &protobuf.KeyVersions{
Seqno: proto.Uint64(kv.Seqno),
}
if kv.Docid != nil && len(kv.Docid) > 0 {
pkv.Docid = kv.Docid
}
if len(kv.Uuids) == 0 {
continue
}
l := len(kv.Uuids)
pkv.Uuids = make([]uint64, 0, l)
pkv.Commands = make([]uint32, 0, l)
pkv.Keys = make([][]byte, 0, l)
pkv.Oldkeys = make([][]byte, 0, l)
for i, uuid := range kv.Uuids { // for each key-version
pkv.Uuids = append(pkv.Uuids, uuid)
pkv.Commands = append(pkv.Commands, uint32(kv.Commands[i]))
pkv.Keys = append(pkv.Keys, kv.Keys[i])
pkv.Oldkeys = append(pkv.Oldkeys, kv.Oldkeys[i])
}
pvb.Kvs = append(pvb.Kvs, pkv)
}
pl.Vbkeys = append(pl.Vbkeys, pvb)
}
case *c.VbConnectionMap:
pl.Vbmap = &protobuf.VbConnectionMap{
Bucket: proto.String(val.Bucket),
Vbuuids: val.Vbuuids,
Vbuckets: c.Vbno16to32(val.Vbuckets),
}
}
if err == nil {
data, err = proto.Marshal(&pl)
}
return
}
// - return couchbase SDK error if any.
func (p *Projector) doVbmapRequest(
request *protobuf.VbmapRequest, opaque uint16) ap.MessageMarshaller {
response := &protobuf.VbmapResponse{}
pooln := request.GetPool()
bucketn := request.GetBucket()
kvaddrs := request.GetKvaddrs()
// log this request.
prefix := p.logPrefix
fmsg := "%v ##%x doVbmapRequest() {%q, %q, %v}\n"
logging.Infof(fmsg, prefix, pooln, bucketn, kvaddrs, opaque)
defer logging.Infof("%v ##%x doVbmapRequest() returns ...\n", prefix, opaque)
// get vbmap from bucket connection.
bucket, err := c.ConnectBucket(p.clusterAddr, pooln, bucketn)
if err != nil {
logging.Errorf("%v ##%x ConnectBucket(): %v\n", prefix, opaque, err)
response.Err = protobuf.NewError(err)
return response
}
defer bucket.Close()
bucket.Refresh()
m, err := bucket.GetVBmap(kvaddrs)
if err != nil {
logging.Errorf("%v ##%x GetVBmap(): %v\n", prefix, opaque, err)
response.Err = protobuf.NewError(err)
return response
}
// compose response
response.Kvaddrs = make([]string, 0, len(kvaddrs))
response.Kvvbnos = make([]*protobuf.Vbuckets, 0, len(kvaddrs))
for kvaddr, vbnos := range m {
response.Kvaddrs = append(response.Kvaddrs, kvaddr)
response.Kvvbnos = append(
response.Kvvbnos, &protobuf.Vbuckets{Vbnos: c.Vbno16to32(vbnos)})
}
return response
}
// AppendVbmap for `kvaddr` to vbmap-response.
func (resp *VbmapResponse) AppendVbmap(kvaddr string, vbnos []uint16) *VbmapResponse {
resp.Kvaddrs = append(resp.Kvaddrs, kvaddr)
resp.Kvvbnos = append(resp.Kvvbnos, &Vbuckets{Vbnos: c.Vbno16to32(vbnos)})
return resp
}
