int riak_put(RIAK_CONN * connstruct, char * bucket, char * key, char * data) { RpbPutReq putReq; RpbContent content; RpbPutResp * putResp; RpbErrorResp * errorResp; int reqSize; char * buffer; RIAK_OP command, result; rpb_put_req__init(&putReq); rpb_content__init(&content); putReq.bucket.data = bucket; putReq.bucket.len = strlen(bucket); putReq.key.data = key; putReq.key.len = strlen(key); content.value.data = data; content.value.len = strlen(data); content.links = NULL; content.usermeta = NULL; putReq.content = &content; reqSize = rpb_put_req__get_packed_size(&putReq); buffer = malloc(reqSize); rpb_put_req__pack(&putReq,buffer); command.msgcode = RPB_PUT_REQ; command.msg = buffer; command.length = reqSize+1; result.msg = NULL; connstruct->last_error = RERR_OK; if(riak_exec_op(connstruct, &command, &result)!=0) return 1; /* Received correct response */ if(result.msgcode == RPB_PUT_RESP) { /* not used right now */ /*putResp = rpb_put_resp__unpack(NULL, result.length-1, result.msg); rpb_put_resp__free_unpacked(putResp, NULL);*/ /* Riak reported an error */ } else if(result.msgcode == RPB_ERROR_RESP) { errorResp = rpb_error_resp__unpack(NULL, result.length-1, result.msg); connstruct->last_error = RERR_BUCKET_LIST; riak_copy_error(connstruct, errorResp); rpb_error_resp__free_unpacked(errorResp, NULL); return 1; /* Something really bad happened. :( */ } else { connstruct->last_error = RERR_UNKNOWN; return 1; } return 0; }
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; }
void riack_copy_object_to_rpbputreq(struct RIACK_CLIENT* client, struct RIACK_OBJECT *pobject, RpbPutReq* pput_req) { RpbContent *content; content = (RpbContent*)RMALLOC(client, sizeof(RpbContent)); rpb_content__init(content); riack_copy_content_to_rpbcontent(client, pobject->content, content); pput_req->content = content; pput_req->bucket.len = pobject->bucket.len; pput_req->bucket.data = (uint8_t*)RMALLOC(client, pobject->bucket.len); memcpy(pput_req->bucket.data, pobject->bucket.value, pobject->bucket.len); if (pobject->key.value) { pput_req->has_key = 1; pput_req->key.len = pobject->key.len; pput_req->key.data = (uint8_t*)RMALLOC(client, pobject->key.len); memcpy(pput_req->key.data, pobject->key.value, pobject->key.len); } if (pobject->vclock.len > 0) { pput_req->has_vclock = 1; pput_req->vclock.len = pobject->vclock.len; pput_req->vclock.data = (uint8_t*)RMALLOC(client, pobject->vclock.len); memcpy(pput_req->vclock.data, pobject->vclock.clock, pobject->vclock.len); } }