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