void RiakTest::AddKey_4()
{
const char* bucket = "test_444";
const char* key = "key_444";
const char* type = "text/plain";
const char* data = "value_444";
riack_object *robj = NULL;
robj = riack_object_alloc(m_riak);
robj->bucket.value = (char*)strdup(bucket);
robj->bucket.len = strlen(bucket);
robj->key.value = (char*)strdup(key);
robj->key.len = strlen(key);
robj->content_count = 1;
robj->content = (riack_content*)malloc(sizeof(riack_content));
memset(robj->content, 0, sizeof(riack_content));
robj->content[0].content_type.value = (char*)strdup(type);
robj->content[0].content_type.len = strlen(type);
robj->content[0].data = (unsigned char*)strdup(data);
robj->content[0].data_len = strlen(data);
riack_put(m_riak, robj, NULL, NULL);
riack_free_object_p(m_riak, &robj);
riack_free_object_p(m_riak, &robj);
}
void RiakTest::AddKey_2()
{
const char* bucket = "test";
const char* key = "key_222";
const char* type = "text/plain";
const char* data = "value_222";
riack_object *robj = NULL;
robj = riack_object_alloc(m_riak);
robj->bucket.value = (char*)strdup(bucket);
robj->bucket.len = strlen(bucket);
robj->key.value = (char*)strdup(key);
robj->key.len = strlen(key);
robj->content_count = 1;
robj->content = (riack_content*)malloc(sizeof(riack_content));
memset(robj->content, 0, sizeof(riack_content));
robj->content[0].content_type.value = (char*)strdup(type);
robj->content[0].content_type.len = strlen(type);
robj->content[0].data = (unsigned char*)strdup(data);
robj->content[0].data_len = strlen(data);
// meta
riack_pair* rpair = (riack_pair*)malloc(sizeof(riack_pair));
memset(rpair, 0, sizeof(riack_pair));
robj->content[0].usermetas = rpair;
robj->content[0].usermeta_count = 1;
raick_set_pair(*rpair, "DATA_STORAGE_TYPE", "VALUE");
riack_put(m_riak, robj, NULL, NULL);
riack_free_object_p(m_riak, &robj);
}
void RiakTest::AddLink()
{
const char* bucket = "rfs";
//const char* key = "f057fbee-d7a4-43a3-b761-163f243730ab";
//const char* key = "90de2941-bbdf-4a4b-8c0d-14d4dc12e649"; //folder
//const char* key = "6d31c25e-ddc0-4bc6-8b96-8f190b279a71";
//const char* key = "root";
const char* key = "1ca3815e-69cb-4054-99a8-b4b28d57e5b9";
riack_string rbucket, rkey;
riack_get_object *obj;
rbucket.len = strlen(bucket);
rbucket.value = (char*)bucket;
rkey.len = strlen(key);
rkey.value = (char*)key;
int ret = riack_get(m_riak, &rbucket, &rkey, NULL, &obj);
riack_link* r_link = obj->object.content->links;
r_link = (riack_link*)realloc(r_link, sizeof(riack_link)*(obj->object.content->link_count + 1));
obj->object.content->links = r_link;
r_link += obj->object.content->link_count;
memset(r_link, 0, sizeof(riack_link));
//r_link->bucket.value = "rfs";
//r_link->bucket.len = strlen("rfs");
r_link->key.value = "85ad7086-a50d-4ac3-a61f-8987df66966c";
r_link->key.len = strlen("85ad7086-a50d-4ac3-a61f-8987df66966c");
r_link->tag.value = "parent";
r_link->tag.len = strlen("parent");
obj->object.content->link_count++;
obj->object.bucket.value = "rfs";
obj->object.bucket.len = 3;
ret = riack_put(m_riak, &(obj->object), NULL, NULL);
ret == RIACK_SUCCESS;
char skey[_MAX_PATH];
char sval[_MAX_PATH];
//int count = obj->object.content->usermeta_count;
//for (int i = 0; i < count; i++)
//{
// riack_pair& r_meta = obj->object.content->usermetas[i];
// memset(skey, 0, _MAX_PATH);
// memset(sval, 0, _MAX_PATH);
// memcpy(skey, r_meta.key.value, r_meta.key.len);
// memcpy(sval, r_meta.value, r_meta.value_len);
// printf("[%s]:%s\n", skey, sval);
//}
}
int riack_put_simple(struct RIACK_CLIENT *client, char* bucket, char* key, uint8_t* data, size_t datalen, char* content_type)
{
int result;
struct RIACK_OBJECT object;
object.bucket.value = bucket;
object.bucket.len = strlen(bucket);
object.key.value = key;
object.key.len = strlen(key);
object.vclock.len = 0;
object.content = (struct RIACK_CONTENT*)RMALLOC(client, sizeof(struct RIACK_CONTENT));
memset(object.content, 0, sizeof(struct RIACK_CONTENT));
object.content[0].content_type.value = content_type;
object.content[0].content_type.len = strlen(content_type);
object.content[0].data_len = datalen;
object.content[0].data = data;
result = riack_put(client, object, 0, (struct RIACK_PUT_PROPERTIES*)0);
RFREE(client, object.content);
return result;
}
void RiakTest::Add_Link_test_111_v2()
{
const char* bucket = "test";
const char* key = "key_111";
const char* type = "text/plain";
const char* data = "value_111";
//const char* bucket = "rfs";
//const char* key = "root";
//const char* type = "text/plain";
//const char* data = "value_111";
riack_string rbucket, rkey;
riack_get_object *robj = NULL;
rbucket.len = strlen(bucket);
rbucket.value = (char*)bucket;
rkey.len = strlen(key);
rkey.value = (char*)key;
int ret = riack_get(m_riak, &rbucket, &rkey, NULL, &robj);
riack_copy_string(robj->object.bucket, rbucket);
riack_copy_string(robj->object.key, rkey);
riack_content& r_content = robj->object.content[0];
riack_link* r_link = r_content.links;
r_content.links = (riack_link*)realloc(r_link, (r_content.link_count + 1)*sizeof(riack_link));
r_link = r_content.links + r_content.link_count;
r_content.link_count += 1;
const char* l_bucket = "test_444";
const char* l_key = "key_444";
const char* l_tag = "parent";
memset(r_link, 0, sizeof(r_link));
riack_set_link(*r_link, l_bucket, l_key, l_tag);
riack_put(m_riak, &(robj->object), NULL, NULL);
riack_free_get_object_p(m_riak, &robj);
}
int test_meta_links_load()
{
RIACK_STRING bucket_posts, bucket_answers;
struct RIACK_GET_OBJECT get_post;
struct RIACK_OBJECT put_post;
struct RIACK_STRING_LINKED_LIST *keys_posts, *current_post, *keys_answers, *current_answer;
bucket_posts.len = strlen(RIAK_TEST_BUCKET_POSTS);
bucket_posts.value = RIAK_TEST_BUCKET_POSTS;
bucket_answers.len = strlen(RIAK_TEST_BUCKET_ANSWERS);
bucket_answers.value = RIAK_TEST_BUCKET_ANSWERS;
// Make random links between posts and comments
if ((riack_list_keys(test_client, bucket_posts, &keys_posts) == RIACK_SUCCESS)&&
(riack_list_keys(test_client, bucket_answers, &keys_answers) == RIACK_SUCCESS)) {
current_post = keys_posts;
current_answer = keys_answers;
while (current_post && current_post->next) {
if (riack_get(test_client, bucket_posts, current_post->string, 0, &get_post) == RIACK_SUCCESS) {
if (get_post.object.content_count == 1) {
memset(&put_post, 0, sizeof(put_post));
put_post.bucket = copy_string(&bucket_posts);
put_post.key = copy_string(¤t_post->string);
put_post.content_count = 1;
put_post.content = copy_content(get_post.object.content);
current_answer = test_make_links(current_answer, get_post.object.content);
if (riack_put(test_client, put_post, 0, 0) != RIACK_SUCCESS) {
return 1;
}
riack_free_object(test_client, &put_post);
}
riack_free_get_object(test_client, &get_post);
}
current_post = current_post->next;
}
}
return 0;
}
void RiakTest::AddKey_1_Link()
{
const char* bucket = "test";
const char* key = "key_111";
const char* type = "text/plain";
const char* data = "value_111";
riack_object *robj = NULL;
robj = riack_object_alloc(m_riak);
robj->bucket.value = (char*)strdup(bucket);
robj->bucket.len = strlen(bucket);
robj->key.value = (char*)strdup(key);
robj->key.len = strlen(key);
robj->content_count = 1;
robj->content = (riack_content*)malloc(sizeof(riack_content));
memset(robj->content, 0, sizeof(riack_content));
robj->content[0].content_type.value = (char*)strdup(type);
robj->content[0].content_type.len = strlen(type);
robj->content[0].data = (unsigned char*)strdup(data);
robj->content[0].data_len = strlen(data);
// link
const char* l_bucket = "test_333";
const char* link = "key_333";
const char* targ = "parent";
robj->content[0].link_count = 1;
riack_link* r_link = (riack_link*)malloc(sizeof(riack_link));
memset(r_link, 0, sizeof(r_link));
robj->content[0].links = r_link;
r_link->bucket.value = (char*)strdup(l_bucket);
r_link->bucket.len = strlen(l_bucket);
r_link->key.len = strlen(link);
r_link->key.value = (char*)strdup(link);
r_link->key.len = strlen(link);
r_link->tag.value = (char*)strdup(targ);
r_link->tag.len = strlen(targ);
riack_put(m_riak, robj, NULL, NULL);
riack_free_object_p(m_riak, &robj);
}
void RiakTest::PutFile()
{
//obj.bucket.value = RIAK_TEST_BUCKET;
//obj.bucket.len = strlen(RIAK_TEST_BUCKET);
//obj.key.value = "test_put2";
//obj.key.len = strlen(obj.key.value);
//obj.vclock.len = 0;
//obj.content_count = 1;
//obj.content = (riack_content*)malloc(sizeof(riack_content));
//memset(obj.content, 0, sizeof(riack_content));
//obj.content[0].content_type.value = "application/json";
//obj.content[0].content_type.len = strlen(obj.content[0].content_type.value);
//obj.content[0].data = (uint8_t*)data;
//obj.content[0].data_len = strlen(data);
const char* bucket = "asdf";
const char* key = "aaaa";
const char* type = "application/json";
const char* data = "{\"testvalue\": \"plappe lappe 2\"}";
riack_object *robj = NULL;
robj = riack_object_alloc(m_riak);
robj->bucket.value = (char*)bucket;
robj->bucket.len = strlen(bucket);
robj->key.value = (char*)key;
robj->key.len = strlen(key);
robj->content_count = 1;
robj->content = (riack_content*)malloc(sizeof(riack_content));
memset(robj->content, 0, sizeof(riack_content));
robj->content[0].content_type.value = (char*)type;
robj->content[0].content_type.len = strlen(type);
robj->content[0].data = (unsigned char*)data;
robj->content[0].data_len = strlen(data);
riack_put(m_riak, robj, NULL, NULL);
riack_free_object_p(m_riak, &robj);
}
void RiakTest::Add_Link_test_111()
{
const char* bucket = "test";
const char* key = "key_111";
const char* type = "text/plain";
const char* data = "value_111";
riack_string rbucket, rkey;
riack_get_object *robj = NULL;
riack_object *nobj = NULL;
rbucket.len = strlen(bucket);
rbucket.value = (char*)bucket;
rkey.len = strlen(key);
rkey.value = (char*)key;
int ret = riack_get(m_riak, &rbucket, &rkey, NULL, &robj);
//riack_content& r_content = robj->object.content[0];
//riack_link* r_link = r_content.links;
//r_content.links = (riack_link*)realloc(r_link, (r_content.link_count + 1)*sizeof(riack_link));
//r_link = &(r_content.links[r_content.link_count]);
//r_content.link_count += 1;
const char* l_bucket = "test_444";
const char* link = "key_444";
const char* targ = "parent";
//memset(r_link, 0, sizeof(r_link));
//r_link->bucket.value = (char*)strdup(l_bucket);
//r_link->bucket.len = strlen(l_bucket);
//r_link->key.len = strlen(link);
//r_link->key.value = (char*)strdup(link);
//r_link->key.len = strlen(link);
//r_link->tag.value = (char*)strdup(targ);
//r_link->tag.len = strlen(targ);
nobj = riack_object_add_link_new(&(robj->object), bucket, key, l_bucket, link, targ);
//{
//
// nobj = riack_object_alloc(m_riak);
// nobj->bucket.value = (char*)strdup(bucket);
// nobj->bucket.len = strlen(bucket);
// nobj->key.value = (char*)strdup(key);
// nobj->key.len = strlen(key);
// nobj->content_count = 1;
// nobj->content = (riack_content*)malloc(sizeof(riack_content));
// memset(nobj->content, 0, sizeof(riack_content));
// nobj->content[0].content_type.value = (char*)strdup(type);
// nobj->content[0].content_type.len = strlen(type);
// nobj->content[0].data = (unsigned char*)strdup(data);
// nobj->content[0].data_len = strlen(data);
// // link
// const char* l_bucket = "test_333";
// const char* link = "key_333";
// const char* targ = "parent";
// nobj->content[0].link_count = 1;
// riack_link* r_link = (riack_link*)malloc(sizeof(riack_link)*nobj->content[0].link_count);
// nobj->content[0].links = r_link;
// memset(r_link, 0, sizeof(r_link));
// r_link->bucket.value = (char*)strdup(l_bucket);
// r_link->bucket.len = strlen(l_bucket);
// r_link->key.len = strlen(link);
// r_link->key.value = (char*)strdup(link);
// r_link->key.len = strlen(link);
// r_link->tag.value = (char*)strdup(targ);
// r_link->tag.len = strlen(targ);
// //l_bucket = "test_444";
// //link = "key_444";
// //r_link++;
// //memset(r_link, 0, sizeof(r_link));
// //r_link->bucket.value = (char*)strdup(l_bucket);
// //r_link->bucket.len = strlen(l_bucket);
// //r_link->key.len = strlen(link);
// //r_link->key.value = (char*)strdup(link);
// //r_link->key.len = strlen(link);
// //r_link->tag.value = (char*)strdup(targ);
// //r_link->tag.len = strlen(targ);
//}
riack_free_get_object_p(m_riak, &robj);
riack_put(m_riak, nobj, NULL, NULL);
riack_free_object_p(m_riak, &nobj);
}
/**
* \brief push tile data to riak
*
* writes the content of mapcache_tile::data to the configured riak instance(s)
* \private \memberof mapcache_cache_riak
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_riak_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
char *key,*content_type;
int error;
int connect_error = RIACK_SUCCESS;
int retries = 3;
struct RIACK_OBJECT object;
struct RIACK_CONTENT content;
struct RIACK_PUT_PROPERTIES properties;
struct RIACK_CLIENT *client;
mapcache_pooled_connection *pc;
mapcache_cache_riak *cache = (mapcache_cache_riak*)pcache;
memset(&content, 0, sizeof(struct RIACK_CONTENT));
memset(&object, 0, sizeof(struct RIACK_OBJECT));
memset(&properties, 0, sizeof(struct RIACK_PUT_PROPERTIES));
//Use Buckets defaults instead of setting the read/write attributes
/*
properties.w_use = 1;
properties.w = 1;
properties.dw_use = 1;
properties.dw = 0;*/
key = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
GC_CHECK_ERROR(ctx);
if (!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
content_type = tile->tileset->format?(tile->tileset->format->mime_type?tile->tileset->format->mime_type:NULL):NULL;
if(!content_type) {
/* compute the content-type */
mapcache_image_format_type t = mapcache_imageio_header_sniff(ctx,tile->encoded_data);
if(t == GC_PNG)
content_type = "image/png";
else if(t == GC_JPEG)
content_type = "image/jpeg";
}
pc = _riak_get_connection(ctx, cache, tile);
GC_CHECK_ERROR(ctx);
client = pc->connection;
// Set up the riak object to put. Need to do this after we get the client connection
object.bucket.value = cache->bucket.value;
object.bucket.len = cache->bucket.len;
object.key.value = key;
object.key.len = strlen(key);
object.vclock.len = 0;
object.content_count = 1;
object.content = &content;
content.content_type.value = content_type;
content.content_type.len = content_type?strlen(content_type):0;
content.data = (uint8_t*)tile->encoded_data->buf;
content.data_len = tile->encoded_data->size;
// If we get an error it is advised that we call reconnect. It also appears
// that every now and then we get an error and need to retry once again to
// get it to work.
do
{
error = riack_put(client, object, 0, &properties);
if (error != RIACK_SUCCESS) {
ctx->log(ctx, MAPCACHE_WARN, "Retry %d in riak_set for tile %s from cache %s due to eror %d", (4 - retries), key, cache->cache.name, error);
for (connect_error = riack_reconnect(client);
connect_error != RIACK_SUCCESS && retries > 0;
connect_error = riack_reconnect(client))
{
--retries;
}
--retries;
}
}
while (error != RIACK_SUCCESS && retries >= 0);
if (connect_error != RIACK_SUCCESS)
mapcache_connection_pool_invalidate_connection(ctx,pc);
else
mapcache_connection_pool_release_connection(ctx,pc);
if (error != RIACK_SUCCESS)
{
ctx->set_error(ctx, 500, "failed to store tile %s to cache %s due to error %d.", key, cache->cache.name, error);
}
}
