static void _mapcache_cache_bdb_set(mapcache_context *ctx, mapcache_tile *tile) {
DBT key,data;
int ret;
mapcache_cache_bdb *cache = (mapcache_cache_bdb*)tile->tileset->cache;
char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL);
struct bdb_env *benv = _bdb_get_conn(ctx,tile,0);
GC_CHECK_ERROR(ctx);
apr_time_t now = apr_time_now();
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
mapcache_buffer_append(tile->encoded_data,sizeof(apr_time_t),&now);
key.data = skey;
key.size = strlen(skey)+1;
data.data = tile->encoded_data->buf;
data.size = tile->encoded_data->size;
ret = benv->db->put(benv->db,NULL,&key,&data,0);
tile->encoded_data->size -= sizeof(apr_time_t);
if(ret != 0) {
ctx->set_error(ctx,500,"dbd backend failed on tile_set: %s", db_strerror(ret));
} else {
ret = benv->db->sync(benv->db,0);
if(ret)
ctx->set_error(ctx,500,"bdb backend sync failure on tile_set: %s",db_strerror(ret));
}
_bdb_release_conn(ctx,tile,benv);
}
static void _couchbase_get_callback(libcouchbase_t instance,
const void *cookie,
libcouchbase_error_t error,
const void *key, libcouchbase_size_t nkey,
const void *bytes, libcouchbase_size_t nbytes,
libcouchbase_uint32_t flags, libcouchbase_cas_t cas)
{
(void)instance;
(void)key;
(void)nkey;
(void)flags;
(void)cas;
if (cookie)
{
getStruct_t *request = (getStruct_t*)cookie;
request->error = error;
if (error == LIBCOUCHBASE_SUCCESS && request->tileBuffer)
{
mapcache_buffer_append(request->tileBuffer, nbytes, (void*)bytes);
}
}
}
static void _mapcache_cache_tc_set(mapcache_context *ctx, mapcache_tile *tile)
{
struct tc_conn conn;
mapcache_cache_tc *cache = (mapcache_cache_tc*)tile->tileset->cache;
char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL);
apr_time_t now = apr_time_now();
conn = _tc_get_conn(ctx,tile,0);
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);
}
mapcache_buffer_append(tile->encoded_data,sizeof(apr_time_t),&now);
if(!tcbdbput(conn.bdb, skey, strlen(skey), tile->encoded_data->buf, tile->encoded_data->size)) {
int ecode = tcbdbecode(conn.bdb);
ctx->set_error(ctx,500, "tokyocabinet put error: %s\n",tcbdberrmsg(ecode));
}
_tc_release_conn(ctx,tile,conn);
}
size_t _mapcache_curl_memory_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
mapcache_buffer *buffer = (mapcache_buffer*)data;
size_t realsize = size * nmemb;
return mapcache_buffer_append(buffer, realsize, ptr);
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the riak server
* \private \memberof mapcache_cache_riak
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_riak_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
int error;
int connect_error = RIACK_SUCCESS;
int retries = 3;
RIACK_STRING key;
struct RIACK_GET_OBJECT obj;
struct RIACK_GET_PROPERTIES properties;
struct RIACK_CLIENT *client;
mapcache_pooled_connection *pc;
mapcache_cache_riak *cache = (mapcache_cache_riak*)pcache;
memset(&properties, 0, sizeof(struct RIACK_GET_PROPERTIES));
//Use Buckets defaults instead of setting the read/write attributes
/*
properties.r_use = 1;
properties.r = 1;
*/
key.value = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
key.len = strlen(key.value);
tile->encoded_data = mapcache_buffer_create(0, ctx->pool);
pc = _riak_get_connection(ctx, cache, tile);
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
client = pc->connection;
// 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_get(client, cache->bucket, key, &properties, &obj);
if (error != RIACK_SUCCESS) {
ctx->log(ctx, MAPCACHE_WARN, "Retry %d in riak_get for tile %s from cache %s due to error %d", (4-retries), key.value, 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 (error != RIACK_SUCCESS)
{
if (connect_error != RIACK_SUCCESS)
mapcache_connection_pool_invalidate_connection(ctx,pc);
else
mapcache_connection_pool_release_connection(ctx,pc);
ctx->set_error(ctx, 500, "Failed to get tile %s from cache %s due to error %d", key.value, cache->cache.name, error);
return MAPCACHE_FAILURE;
}
// Check if tile exists. If it doesn't we need to return CACHE_MISS or things go wrong.
// Mapcache doesn't appear to use the has_tile function and uses _get instead so we need
// to do this sort of test here instead of erroring.
if (obj.object.content_count < 1 || obj.object.content[0].data_len == 0) {
riack_free_get_object(client, &obj); // Need to free the object here as well.
mapcache_connection_pool_release_connection(ctx,pc);
return MAPCACHE_CACHE_MISS;
}
// Copy the data into the buffer
mapcache_buffer_append(tile->encoded_data, obj.object.content[0].data_len, obj.object.content[0].data);
riack_free_get_object(client, &obj); // riack_get allocates the returned object so we need to deallocate it.
mapcache_connection_pool_release_connection(ctx,pc);
return MAPCACHE_SUCCESS;
}
void _mapcache_imageio_png_write_func(png_structp png_ptr, png_bytep data, png_size_t length) {
mapcache_buffer_append((mapcache_buffer*)png_get_io_ptr(png_ptr),length,data);
}