int riak_pb_get(struct riak_pb_transport *pbtransport,
struct riak_binary *bucket,
struct riak_binary *key,
struct riak_get_options *options,
struct riak_response* response) {
void *msgbuf;
unsigned msglen;
RpbGetReq getmsg = RPB_GET_REQ__INIT;
// probably incorrect, need to memcopy the bucket and key
getmsg.bucket.data = bucket->data;
getmsg.bucket.len = bucket->len;
getmsg.key.data = key->data;
getmsg.key.len = key->len;
// process get options
if(options != 0) {
// TODO
}
msglen = rpb_get_req__get_packed_size (&getmsg);
msgbuf = malloc (msglen);
rpb_get_req__pack (&getmsg, msgbuf);
struct pb_request request;
request.reqid = MSG_RPBGETREQ;
request.msglength = msglen;
request.reqdata = msgbuf;
pbtransport->send_message(pbtransport->transport_data, &request);
free(msgbuf);
struct pb_response pbresponse;
pbresponse.expected_respid = MSG_RPBGETRESP;
int pbr = pbtransport->receive_message(pbtransport->transport_data, &pbresponse);
if(pbr >= 0) {
// decode the PB response etc
RpbGetResp *getresp = rpb_get_resp__unpack(NULL, pbresponse.msglength, pbresponse.respdata);
int i = 0;
if(getresp->n_content > 0) {
response->objects = malloc(sizeof(struct riak_object) * getresp->n_content);
response->object_count = getresp->n_content;
for(i = 0; i < getresp->n_content; i++) {
RpbContent *c = getresp->content[i];
populate_riak_binary(&(response->objects[i].value), c->value.len, c->value.data);
}
}
rpb_get_resp__free_unpacked(getresp, NULL);
free(pbresponse.respdata);
return 0;
} else {
return -1;
}
// TODO: errors!
}
int riack_get(struct RIACK_CLIENT *client,
RIACK_STRING bucket,
RIACK_STRING key,
struct RIACK_GET_PROPERTIES* props,
struct RIACK_GET_OBJECT* result_object)
{
int result;
size_t packed_size;
struct RIACK_PB_MSG msg_req, *msg_resp;
ProtobufCAllocator pb_allocator;
RpbGetReq get_req;
RpbGetResp *get_resp;
uint8_t *request_buffer;
if (!bucket.value || !key.value || key.len == 0 || bucket.len == 0 || !client) {
return RIACK_ERROR_INVALID_INPUT;
}
pb_allocator = riack_pb_allocator(&client->allocator);
result = RIACK_ERROR_COMMUNICATION;
rpb_get_req__init(&get_req);
get_req.key.data = (uint8_t *) key.value;
get_req.key.len = key.len;
get_req.bucket.data = (uint8_t *) bucket.value;
get_req.bucket.len = bucket.len;
riack_set_get_properties(client, props, &get_req);
packed_size = rpb_get_req__get_packed_size(&get_req);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
if (request_buffer) {
rpb_get_req__pack(&get_req, request_buffer);
msg_req.msg_code = mc_RpbGetReq;
msg_req.msg_len = packed_size;
msg_req.msg = request_buffer;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0))
{
if (msg_resp->msg_code == mc_RpbGetResp) {
get_resp = rpb_get_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
if (get_resp) {
riak_set_object_response_values_get(client, result_object, get_resp);
rpb_get_resp__free_unpacked(get_resp, &pb_allocator);
result = RIACK_SUCCESS;
} else {
result = RIACK_FAILED_PB_UNPACK;
}
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
return result;
}
