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; }