func (cmd *baseMultiCommand) parseResult(ifc command, conn *Connection) error {
// Read socket into receive buffer one record at a time. Do not read entire receive size
// because the receive buffer would be too big.
status := true
for status {
// Read header.
if err := cmd.readBytes(8); err != nil {
return err
}
size := Buffer.BytesToInt64(cmd.dataBuffer, 0)
receiveSize := int(size & 0xFFFFFFFFFFFF)
if receiveSize > 0 {
var err error
if status, err = ifc.parseRecordResults(ifc, receiveSize); err != nil {
return err
}
} else {
status = false
}
}
return nil
}
func (acmd *AdminCommand) readUserBlocks(conn *Connection) (status int, rlist []*UserRoles, err error) {
var list []*UserRoles
for status == 0 {
if _, err = conn.Read(acmd.dataBuffer, 8); err != nil {
return -1, nil, err
}
size := Buffer.BytesToInt64(acmd.dataBuffer, 0)
receiveSize := (size & 0xFFFFFFFFFFFF)
if receiveSize > 0 {
if receiveSize > int64(len(acmd.dataBuffer)) {
acmd.dataBuffer = make([]byte, receiveSize)
}
if _, err = conn.Read(acmd.dataBuffer, int(receiveSize)); err != nil {
return -1, nil, err
}
status, list, err = acmd.parseUsers(int(receiveSize))
if err != nil {
return -1, nil, err
}
rlist = append(rlist, list...)
} else {
break
}
}
return status, rlist, nil
}
func (cmd *singleCommand) emptySocket(conn *Connection) error {
// There should not be any more bytes.
// Empty the socket to be safe.
sz := Buffer.BytesToInt64(cmd.dataBuffer, 0)
headerLength := cmd.dataBuffer[8]
receiveSize := int(sz&0xFFFFFFFFFFFF) - int(headerLength)
// Read remaining message bytes.
if receiveSize > 0 {
if err := cmd.sizeBufferSz(receiveSize); err != nil {
return err
}
if _, err := conn.Read(cmd.dataBuffer, receiveSize); err != nil {
return err
}
}
return nil
}
func (upckr *unpacker) unpackObject() (interface{}, error) {
theType := upckr.buffer[upckr.offset] & 0xff
upckr.offset++
switch theType {
case 0xc0:
return nil, nil
case 0xc3:
return true, nil
case 0xc2:
return false, nil
case 0xca:
val := Buffer.BytesToFloat32(upckr.buffer, upckr.offset)
upckr.offset += 4
return val, nil
case 0xcb:
val := Buffer.BytesToFloat64(upckr.buffer, upckr.offset)
upckr.offset += 8
return val, nil
case 0xcc:
r := upckr.buffer[upckr.offset] & 0xff
upckr.offset++
return int(r), nil
case 0xcd:
val := uint16(Buffer.BytesToInt16(upckr.buffer, upckr.offset))
upckr.offset += 2
return int(val), nil
case 0xce:
val := uint32(Buffer.BytesToInt32(upckr.buffer, upckr.offset))
upckr.offset += 4
if Buffer.Arch64Bits {
return int(val), nil
}
return int64(val), nil
case 0xcf:
val := Buffer.BytesToInt64(upckr.buffer, upckr.offset)
upckr.offset += 8
return uint64(val), nil
case 0xd0:
r := int8(upckr.buffer[upckr.offset])
upckr.offset++
return int(r), nil
case 0xd1:
val := Buffer.BytesToInt16(upckr.buffer, upckr.offset)
upckr.offset += 2
return int(val), nil
case 0xd2:
val := Buffer.BytesToInt32(upckr.buffer, upckr.offset)
upckr.offset += 4
return int(val), nil
case 0xd3:
val := Buffer.BytesToInt64(upckr.buffer, upckr.offset)
upckr.offset += 8
if Buffer.Arch64Bits {
return int(val), nil
}
return int64(val), nil
case 0xda:
count := int(Buffer.BytesToUint16(upckr.buffer, upckr.offset))
upckr.offset += 2
return upckr.unpackBlob(count)
case 0xdb:
count := int(Buffer.BytesToUint32(upckr.buffer, upckr.offset))
upckr.offset += 4
return upckr.unpackBlob(count)
case 0xdc:
count := int(Buffer.BytesToUint16(upckr.buffer, upckr.offset))
upckr.offset += 2
return upckr.unpackList(count)
case 0xdd:
count := int(Buffer.BytesToUint32(upckr.buffer, upckr.offset))
upckr.offset += 4
return upckr.unpackList(count)
case 0xde:
count := int(Buffer.BytesToUint16(upckr.buffer, upckr.offset))
upckr.offset += 2
return upckr.unpackMap(count)
case 0xdf:
count := int(Buffer.BytesToUint32(upckr.buffer, upckr.offset))
upckr.offset += 4
return upckr.unpackMap(count)
default:
if (theType & 0xe0) == 0xa0 {
return upckr.unpackBlob(int(theType & 0x1f))
}
if (theType & 0xf0) == 0x80 {
return upckr.unpackMap(int(theType & 0x0f))
}
if (theType & 0xf0) == 0x90 {
return upckr.unpackList(int(theType & 0x0f))
}
if theType < 0x80 {
return int(theType), nil
}
if theType >= 0xe0 {
return int(int(theType) - 0xe0 - 32), nil
}
}
return nil, NewAerospikeError(SERIALIZE_ERROR)
}
func (cmd *readCommand) parseResult(ifc command, conn *Connection) error {
// Read header.
_, err := conn.Read(cmd.dataBuffer, int(_MSG_TOTAL_HEADER_SIZE))
if err != nil {
Logger.Warn("parse result error: " + err.Error())
return err
}
// A number of these are commented out because we just don't care enough to read
// that section of the header. If we do care, uncomment and check!
sz := Buffer.BytesToInt64(cmd.dataBuffer, 0)
headerLength := int(cmd.dataBuffer[8])
resultCode := ResultCode(cmd.dataBuffer[13] & 0xFF)
generation := int(Buffer.BytesToUint32(cmd.dataBuffer, 14))
expiration := TTL(int(Buffer.BytesToUint32(cmd.dataBuffer, 18)))
fieldCount := int(Buffer.BytesToUint16(cmd.dataBuffer, 26)) // almost certainly 0
opCount := int(Buffer.BytesToUint16(cmd.dataBuffer, 28))
receiveSize := int((sz & 0xFFFFFFFFFFFF) - int64(headerLength))
// Read remaining message bytes.
if receiveSize > 0 {
if err = cmd.sizeBufferSz(receiveSize); err != nil {
return err
}
_, err = conn.Read(cmd.dataBuffer, receiveSize)
if err != nil {
Logger.Warn("parse result error: " + err.Error())
return err
}
}
if resultCode != 0 {
if resultCode == KEY_NOT_FOUND_ERROR && cmd.object == nil {
return nil
}
if resultCode == UDF_BAD_RESPONSE {
cmd.record, _ = cmd.parseRecord(opCount, fieldCount, generation, expiration)
err := cmd.handleUdfError(resultCode)
Logger.Warn("UDF execution error: " + err.Error())
return err
}
return NewAerospikeError(resultCode)
}
if cmd.object == nil {
if opCount == 0 {
// data Bin was not returned.
cmd.record = newRecord(cmd.node, cmd.key, nil, generation, expiration)
return nil
}
cmd.record, err = cmd.parseRecord(opCount, fieldCount, generation, expiration)
if err != nil {
return err
}
} else {
cmd.parseObject(opCount, fieldCount, generation, expiration)
}
return nil
}