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