int riak_pb_put(struct riak_pb_transport *pbtransport, struct riak_object *riak_obj, struct riak_put_options *options, struct riak_response *response) { void *msgbuf; unsigned msglen; RpbPutReq putmsg = RPB_PUT_REQ__INIT; putmsg.bucket.data = malloc(riak_obj->bucket.len); memcpy(&putmsg.bucket.data, &riak_obj->bucket.data, riak_obj->bucket.len); putmsg.bucket.len = riak_obj->bucket.len; // TODO: key may not be present putmsg.has_key=1; putmsg.key.data = malloc(riak_obj->key.len); memcpy(&putmsg.key.data, &riak_obj->key.data, riak_obj->key.len); putmsg.key.len = riak_obj->key.len; RpbContent *content = malloc(sizeof(RpbContent)); rpb_content__init(content); putmsg.content = content; content->value.len = riak_obj->value.len; content->value.data = (uint8_t*)malloc(riak_obj->value.len); memcpy(&putmsg.content->value.data, &riak_obj->value.data, riak_obj->value.len); // process get options if(options != 0) { // TODO } msglen = rpb_put_req__get_packed_size (&putmsg); msgbuf = malloc (msglen); rpb_put_req__pack (&putmsg, msgbuf); struct pb_request request; request.reqid = MSG_RPBPUTREQ; request.msglength = msglen; request.reqdata = msgbuf; pbtransport->send_message(pbtransport->transport_data, &request); free(msgbuf); struct pb_response pbresponse; pbresponse.expected_respid = MSG_RPBPUTRESP; int pbr = pbtransport->receive_message(pbtransport->transport_data, &pbresponse); if(pbr >= 0) { // decode the PB response etc RpbPutResp *putresp = rpb_put_resp__unpack(NULL, pbresponse.msglength, pbresponse.respdata); rpb_put_resp__free_unpacked(putresp, NULL); free(pbresponse.respdata); return 0; } else { return -1; } /// TODO: errors! return 0; }
int riack_put(struct RIACK_CLIENT *client, struct RIACK_OBJECT object, struct RIACK_OBJECT* preturned_object, struct RIACK_PUT_PROPERTIES* properties) { int result; size_t packed_size; struct RIACK_PB_MSG msg_req, *msg_resp; ProtobufCAllocator pb_allocator; RpbPutReq put_req; RpbPutResp *put_resp; uint8_t *request_buffer; if (!client || !object.bucket.value) { return RIACK_ERROR_INVALID_INPUT; } pb_allocator = riack_pb_allocator(&client->allocator); result = RIACK_ERROR_COMMUNICATION; rpb_put_req__init(&put_req); riack_copy_object_to_rpbputreq(client, &object, &put_req); riack_set_object_properties(properties, &put_req); packed_size = rpb_put_req__get_packed_size(&put_req); request_buffer = (uint8_t*)RMALLOC(client, packed_size); if (request_buffer) { rpb_put_req__pack(&put_req, request_buffer); msg_req.msg_code = mc_RpbPutReq; 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_RpbPutResp) { result = RIACK_SUCCESS; if (preturned_object) { put_resp = rpb_put_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg); if (put_resp) { riak_set_object_response_values(client, preturned_object, put_resp); rpb_put_resp__free_unpacked(put_resp, &pb_allocator); } 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); } riack_free_copied_rpb_put_req(client, &put_req); return result; }