void riak_set_object_response_values(struct RIACK_CLIENT* client, struct RIACK_OBJECT *pobject, RpbPutResp* pput_resp) { size_t content_cnt, i; if (!pput_resp || !pobject) { return; } pobject->bucket.value = 0; pobject->bucket.len = 0; pobject->key.len = 0; pobject->key.value = 0; if (pput_resp->has_key) { RMALLOCCOPY(client, pobject->key.value, pobject->key.len, pput_resp->key.data, pput_resp->key.len); } pobject->vclock.len = 0; pobject->vclock.clock = 0; if (pput_resp->has_vclock) { RMALLOCCOPY(client, pobject->vclock.clock, pobject->vclock.len, pput_resp->vclock.data, pput_resp->vclock.len); } content_cnt = pput_resp->n_content; pobject->content_count = content_cnt; if (content_cnt > 0) { pobject->content = RMALLOC(client, sizeof(struct RIACK_CONTENT)*content_cnt); for (i=0; i<content_cnt; ++i) { riack_copy_rpbcontent_to_content(client, pput_resp->content[i], &pobject->content[i]); } } }
int riack_get_clientid(struct RIACK_CLIENT *client, RIACK_STRING *clientid) { int result; struct RIACK_PB_MSG msg_req, *msg_resp; RpbGetClientIdResp *id_resp; ProtobufCAllocator pb_allocator; pb_allocator = riack_pb_allocator(&client->allocator); msg_req.msg = 0; msg_req.msg_len = 0; msg_req.msg_code = mc_RpbGetClientIdReq; result = RIACK_ERROR_COMMUNICATION; if ((riack_send_message(client, &msg_req) > 0) && (riack_receive_message(client, &msg_resp) > 0)) { if (msg_resp->msg_code == mc_RpbGetClientIdResp) { id_resp = rpb_get_client_id_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg); if (id_resp) { RMALLOCCOPY(client, clientid->value, clientid->len, id_resp->client_id.data, id_resp->client_id.len); rpb_get_client_id_resp__free_unpacked(id_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); } return result; }
static void _list_keys_stream_callback(struct RIACK_CLIENT *client, void *args_raw, RIACK_STRING key) { struct RIACK_STRING_LINKED_LIST **current = (struct RIACK_STRING_LINKED_LIST**)args_raw; RIACK_STRING new_string; assert(current); RMALLOCCOPY(client, new_string.value, new_string.len, key.value, key.len); riack_string_linked_list_add(client, current, new_string); }
void riack_copy_rpbpair_to_pair(riack_client* client, RpbPair* rpc_pair, riack_pair* rpair) { RMALLOCCOPY(client, rpair->key.value, rpair->key.len, rpc_pair->key.data, rpc_pair->key.len); rpair->value_present = (uint8_t) rpc_pair->has_value; if (rpair->value_present) { rpair->value_len = rpc_pair->value.len; rpair->value = (uint8_t*)RMALLOC(client, rpair->value_len); memcpy(rpair->value, rpc_pair->value.data, rpair->value_len); } }
void riak_copy_rpbpair_to_pair(struct RIACK_CLIENT* client, RpbPair* rpc_pair, struct RIACK_PAIR* rpair) { RMALLOCCOPY(client, rpair->key.value, rpair->key.len, rpc_pair->key.data, rpc_pair->key.len); rpair->value_present = rpc_pair->has_value; if (rpair->value_present) { rpair->value_len = rpc_pair->value.len; rpair->value = (uint8_t*)RMALLOC(client, rpair->value_len); memcpy(rpair->value, rpc_pair->value.data, rpair->value_len); } }
/** * Copy a RIACK_LINK structure to a RpbLink structure */ void riack_copy_link_to_rpblink(riack_client* client, riack_link* rlink, RpbLink* rpc_link) { rpb_link__init(rpc_link); if (rlink->bucket.value) { rpc_link->has_bucket = 1; RMALLOCCOPY(client, rpc_link->bucket.data, rpc_link->bucket.len, rlink->bucket.value, rlink->bucket.len); } if (rlink->key.value) { rpc_link->has_key = 1; RMALLOCCOPY(client, rpc_link->key.data, rpc_link->key.len, rlink->key.value, rlink->key.len); } if (rlink->tag.value) { rpc_link->has_tag = 1; RMALLOCCOPY(client, rpc_link->tag.data, rpc_link->tag.len, rlink->tag.value, rlink->tag.len); } }
/** * Copy a RIAK_LINK structure to a RpbLink structure */ void riak_copy_link_to_rpblink(struct RIACK_CLIENT* client, struct RIACK_LINK* rlink, RpbLink* rpc_link) { rpb_link__init(rpc_link); if (rlink->bucket.value) { rpc_link->has_bucket = 1; RMALLOCCOPY(client, rpc_link->bucket.data, rpc_link->bucket.len, rlink->bucket.value, rlink->bucket.len); } if (rlink->key.value) { rpc_link->has_key = 1; RMALLOCCOPY(client, rpc_link->key.data, rpc_link->key.len, rlink->key.value, rlink->key.len); } if (rlink->tag.value) { rpc_link->has_tag = 1; RMALLOCCOPY(client, rpc_link->tag.data, rpc_link->tag.len, rlink->tag.value, rlink->tag.len); } }
void riak_copy_rpblink_to_link(struct RIACK_CLIENT* client, RpbLink* src, struct RIACK_LINK* target) { if (src->has_key) { RMALLOCCOPY(client, target->key.value, target->key.len, src->key.data, src->key.len); } else { target->key.value = 0; target->key.len = 0; } if (src->has_bucket) { RMALLOCCOPY(client, target->bucket.value, target->bucket.len, src->bucket.data, src->bucket.len); } else { target->bucket.value = 0; target->bucket.len = 0; } if (src->has_tag) { RMALLOCCOPY(client, target->tag.value, target->tag.len, src->tag.data, src->tag.len); } else { target->tag.value = 0; target->tag.len = 0; } }
void riack_copy_rpblink_to_link(riack_client* client, RpbLink* src, riack_link* target) { if (src->has_key) { RMALLOCCOPY(client, target->key.value, target->key.len, src->key.data, src->key.len); } else { target->key.value = 0; target->key.len = 0; } if (src->has_bucket) { RMALLOCCOPY(client, target->bucket.value, target->bucket.len, src->bucket.data, src->bucket.len); } else { target->bucket.value = 0; target->bucket.len = 0; } if (src->has_tag) { RMALLOCCOPY(client, target->tag.value, target->tag.len, src->tag.data, src->tag.len); } else { target->tag.value = 0; target->tag.len = 0; } }
int riack_server_info(struct RIACK_CLIENT *client, RIACK_STRING *node, RIACK_STRING* version) { int result; struct RIACK_PB_MSG msg_req, *msg_resp; RpbGetServerInfoResp *response; ProtobufCAllocator pb_allocator; msg_req.msg_code = mc_RpbGetServerInfoReq; msg_req.msg_len = 0; pb_allocator = riack_pb_allocator(&client->allocator); result = RIACK_ERROR_COMMUNICATION; if ((riack_send_message(client, &msg_req) > 0) && (riack_receive_message(client, &msg_resp) > 0)) { if (msg_resp->msg_code == mc_RpbGetServerInfoResp) { response = rpb_get_server_info_resp__unpack(&pb_allocator, msg_req.msg_len, msg_req.msg); if (response->has_node) { RMALLOCCOPY(client, node->value, node->len, response->node.data, response->node.len); } else { node->len = 0; node->value = 0; } if (response->has_server_version) { RMALLOCCOPY(client, version->value, version->len, response->server_version.data, response->server_version.len); } else { version->len = 0; version->value = 0; } // Copy responses rpb_get_server_info_resp__free_unpacked(response, &pb_allocator); result = RIACK_SUCCESS; } else { riack_got_error_response(client, msg_resp); result = RIACK_ERROR_RESPONSE; } riack_message_free(client, &msg_resp); } return result; }
riack_cmd_cb_result riack_2i_query_cb(riack_client *client, RpbIndexResp* response, struct riack_2i_cb_args* args) { size_t keys, i; riack_cmd_cb_result retval; retval = RIACK_CMD_DONE; keys = response->n_keys; // If we have result keys then we are not streaming if (args->result_keys) { (*args->result_keys)->string_count = keys; (*args->result_keys)->strings = RMALLOC(client, sizeof(riack_string) * keys); for (i=0; i<keys; ++i) { RMALLOCCOPY(client, (*args->result_keys)->strings[i].value, (*args->result_keys)->strings[i].len, response->keys[i].data, response->keys[i].len); } } // If streaming if (args->user_cb) { retval = RIACK_CMD_CONTINUE; for (i=0; i<keys; ++i) { riack_string key; key.len = response->keys[i].len; key.value = (char*)response->keys[i].data; args->user_cb(client, args->user_cb_arg, &key); } if (response->has_done && response->done) { retval = RIACK_CMD_DONE; } } if (args->continuation_token && response->has_continuation) { *args->continuation_token = riack_string_alloc(client); RMALLOCCOPY(client, (*args->continuation_token)->value, (*args->continuation_token)->len, response->continuation.data, response->continuation.len); } else if (args->continuation_token) { *args->continuation_token = 0; } return retval; }
/// Copies all optional search parameters to the protobuffers request. void riack_set_optional_search_properties_on_req(riack_client *client, riack_search_optional_params* props, RpbSearchQueryReq* search_req) { size_t cnt; if (!props) { return; } if (props->default_field_present) { search_req->has_df = 1; RMALLOCCOPY(client, search_req->df.data, search_req->df.len, props->default_field.value, props->default_field.len); } if (props->default_operation_present) { search_req->has_op = 1; RMALLOCCOPY(client, search_req->op.data, search_req->op.len, props->default_operation.value, props->default_operation.len); } if (props->filter_present) { search_req->has_filter = 1; RMALLOCCOPY(client, search_req->filter.data, search_req->filter.len, props->filter.value, props->filter.len); } if (props->presort_present) { search_req->has_presort = 1; RMALLOCCOPY(client, search_req->presort.data, search_req->presort.len, props->presort.value, props->presort.len); } if (props->rowlimit_present) { search_req->has_rows = 1; search_req->rows = props->rowlimit; } if (props->sort_present) { search_req->has_sort = 1; RMALLOCCOPY(client, search_req->sort.data, search_req->sort.len, props->sort.value, props->sort.len); } if (props->start_present) { search_req->has_start = 1; search_req->start = props->start; } cnt = props->field_limits_count; search_req->n_fl = cnt; if (cnt > 0) { size_t i; search_req->fl = RMALLOC(client, sizeof(ProtobufCBinaryData) * cnt); for (i = 0; i<cnt; ++i) { RMALLOCCOPY(client, search_req->fl[i].data, search_req->fl[i].len, props->field_limits[i].value, props->field_limits[i].len); } } }
int riack_list_buckets(struct RIACK_CLIENT *client, RIACK_STRING_LIST* bucket_list) { int result; struct RIACK_PB_MSG msg_req; struct RIACK_PB_MSG *msg_resp; RpbListBucketsResp *list_resp; ProtobufCAllocator pb_allocator; size_t i; if (!client || !bucket_list) { return RIACK_ERROR_INVALID_INPUT; } pb_allocator = riack_pb_allocator(&client->allocator); result = RIACK_ERROR_COMMUNICATION; msg_req.msg_code = mc_RpbListBucketsReq; msg_req.msg_len = 0; bucket_list->string_count = 0; if ((riack_send_message(client, &msg_req) > 0)&& (riack_receive_message(client, &msg_resp) > 0)) { if (msg_resp->msg_code == mc_RpbListBucketsResp) { list_resp = rpb_list_buckets_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg); if (list_resp) { bucket_list->string_count = list_resp->n_buckets; bucket_list->strings = (RIACK_STRING*)RMALLOC(client, sizeof(RIACK_STRING) * list_resp->n_buckets); for (i=0; i<list_resp->n_buckets; ++i) { RMALLOCCOPY(client, bucket_list->strings[i].value, bucket_list->strings[i].len, list_resp->buckets[i].data, list_resp->buckets[i].len); } rpb_list_buckets_resp__free_unpacked(list_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); } return result; }
int riack_2i_query(struct RIACK_CLIENT *client, RpbIndexReq* request, RIACK_STRING_LIST* result_keys) { struct RIACK_PB_MSG msg_req, *msg_resp; ProtobufCAllocator pb_allocator; RpbIndexResp *index_resp; int result; size_t packed_size, keys, i; uint8_t *request_buffer; result = RIACK_ERROR_COMMUNICATION; pb_allocator = riack_pb_allocator(&client->allocator); packed_size = rpb_index_req__get_packed_size(request); request_buffer = (uint8_t*)RMALLOC(client, packed_size); if (request_buffer) { rpb_index_req__pack(request, request_buffer); msg_req.msg = request_buffer; msg_req.msg_code = mc_RpbIndexReq; msg_req.msg_len = packed_size; if ((riack_send_message(client, &msg_req) > 0) && (riack_receive_message(client, &msg_resp) > 0)) { if (msg_resp->msg_code == mc_RpbIndexResp) { index_resp = rpb_index_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg); if (index_resp) { keys = index_resp->n_keys; result_keys->string_count = keys; result_keys->strings = RMALLOC(client, sizeof(RIACK_STRING) * keys); for (i=0; i<keys; ++i) { RMALLOCCOPY(client, result_keys->strings[i].value, result_keys->strings[i].len, index_resp->keys[i].data, index_resp->keys[i].len); } rpb_index_resp__free_unpacked(index_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; }
/** * Copy contents of a RpbContent request into a RIAK_CONTENT structure. * Memory is copied so ppbc_content is ok to release after. */ void riack_copy_rpbcontent_to_content(struct RIACK_CLIENT* client, RpbContent *src, struct RIACK_CONTENT *target) { size_t cnt, i; target->data_len = src->value.len; target->data = 0; if (target->data_len > 0) { target->data = (uint8_t*)RMALLOC(client, src->value.len); memcpy(target->data, src->value.data, src->value.len); } target->charset.value = 0; target->charset.len = 0; if (src->has_charset) { RMALLOCCOPY(client, target->charset.value, target->charset.len, src->charset.data, src->charset.len); } target->content_encoding.value = 0; target->content_encoding.len = 0; if (src->has_content_encoding) { RMALLOCCOPY(client, target->content_encoding.value, target->content_encoding.len, src->content_encoding.data, src->content_encoding.len); } target->content_type.value = 0; target->content_type.len = 0; if (src->has_content_type) { RMALLOCCOPY(client, target->content_type.value, target->content_type.len, src->content_type.data, src->content_type.len); } target->vtag.len = 0; target->vtag.value = 0; if (src->has_vtag) { RMALLOCCOPY(client, target->vtag.value, target->vtag.len, src->vtag.data, src->vtag.len); } cnt = src->n_indexes; target->index_count = cnt; if (cnt > 0) { target->indexes = (struct RIACK_PAIR*)RMALLOC(client, sizeof(struct RIACK_PAIR) * cnt); for (i=0; i<cnt; ++i) { riak_copy_rpbpair_to_pair(client, src->indexes[i], &target->indexes[i]); } } cnt = src->n_usermeta; target->usermeta_count = cnt; if (cnt > 0) { target->usermetas = (struct RIACK_PAIR*)RMALLOC(client, sizeof(struct RIACK_PAIR) * cnt); for (i=0; i<cnt; ++i) { riak_copy_rpbpair_to_pair(client, src->usermeta[i], &target->usermetas[i]); } } cnt = src->n_links; target->link_count = cnt; if (cnt > 0) { target->links = (struct RIACK_LINK*)RMALLOC(client, sizeof(struct RIACK_LINK) * cnt); for (i=0; i<cnt; ++i) { riak_copy_rpblink_to_link(client, src->links[i], &target->links[i]); } } target->last_modified_present = src->has_last_mod; target->last_modified = src->last_mod; target->last_modified_usecs_present = src->has_last_mod_usecs; target->last_modified_usecs = src->last_mod_usecs; target->deleted_present = src->has_deleted; target->deleted = src->deleted; }
/** * Copy the content of a RIAK_CONTENT structure to a RpbContent structure * All memory and strings are copied */ void riack_copy_content_to_rpbcontent(struct RIACK_CLIENT* client, struct RIACK_CONTENT *pcontent, RpbContent* ppbc_content) { size_t i; if (pcontent->charset.value) { ppbc_content->has_charset = 1; RMALLOCCOPY(client, ppbc_content->charset.data, ppbc_content->charset.len, pcontent->charset.value, pcontent->charset.len); } if (pcontent->content_encoding.value) { ppbc_content->has_content_encoding = 1; RMALLOCCOPY(client, ppbc_content->content_encoding.data, ppbc_content->content_encoding.len, pcontent->content_encoding.value, pcontent->content_encoding.len); } if (pcontent->content_type.value) { ppbc_content->has_content_type = 1; RMALLOCCOPY(client, ppbc_content->content_type.data, ppbc_content->content_type.len, pcontent->content_type.value, pcontent->content_type.len); } if (pcontent->vtag.value) { ppbc_content->has_vtag = 1; RMALLOCCOPY(client, ppbc_content->vtag.data, ppbc_content->vtag.len, pcontent->vtag.value, pcontent->vtag.len); } ppbc_content->value.len = pcontent->data_len; ppbc_content->value.data = (uint8_t*)RMALLOC(client, pcontent->data_len); memcpy(ppbc_content->value.data, pcontent->data, pcontent->data_len); ppbc_content->n_links = pcontent->link_count; if (pcontent->link_count > 0) { ppbc_content->links = (RpbLink**)RMALLOC(client, sizeof(RpbLink**) * pcontent->link_count); for (i=0; i<pcontent->link_count; ++i) { ppbc_content->links[i] = (RpbLink*)RMALLOC(client, sizeof(RpbLink)); riak_copy_link_to_rpblink(client, &pcontent->links[i], ppbc_content->links[i]); } } ppbc_content->has_last_mod = pcontent->last_modified_present; ppbc_content->last_mod = pcontent->last_modified; ppbc_content->has_last_mod_usecs = pcontent->last_modified_usecs_present; ppbc_content->last_mod_usecs = pcontent->last_modified_usecs; ppbc_content->has_deleted = pcontent->deleted_present; ppbc_content->deleted = pcontent->deleted; ppbc_content->n_usermeta = pcontent->usermeta_count; if (pcontent->usermeta_count > 0) { ppbc_content->usermeta = (RpbPair**)RMALLOC(client, sizeof(RpbPair**) * pcontent->usermeta_count); for (i=0; i<pcontent->usermeta_count; ++i) { ppbc_content->usermeta[i] = (RpbPair*)RMALLOC(client, sizeof(RpbPair)); riak_copy_pair_to_rpbpair(client, &pcontent->usermetas[i], ppbc_content->usermeta[i]); } } ppbc_content->n_indexes = pcontent->index_count; if (pcontent->index_count > 0) { ppbc_content->indexes = (RpbPair**)RMALLOC(client, sizeof(RpbPair**) * pcontent->index_count); for (i=0; i<pcontent->index_count; ++i) { ppbc_content->indexes[i] = (RpbPair*)RMALLOC(client, sizeof(RpbPair)); riak_copy_pair_to_rpbpair(client, &pcontent->indexes[i], ppbc_content->indexes[i]); } } }
RIACK_STRING riack_copy_from_cstring(struct RIACK_CLIENT* client, const char* source) { RIACK_STRING result; RMALLOCCOPY(client, result.value, result.len, source, strlen(source)); return result; }
RIACK_STRING riack_copy_string(struct RIACK_CLIENT* client, RIACK_STRING source) { RIACK_STRING result; RMALLOCCOPY(client, result.value, result.len, source.value, source.len); return result; }
riack_string riack_copy_from_cstring(riack_client* client, const char* source) { riack_string result; RMALLOCCOPY(client, result.value, result.len, source, strlen(source)); return result; }
riack_string riack_copy_string(riack_client* client, riack_string source) { riack_string result; RMALLOCCOPY(client, result.value, result.len, source.value, source.len); return result; }