static int _mapcache_cache_memcache_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *key;
char *tmpdata;
int rv;
size_t tmpdatasize;
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)pcache;
mapcache_pooled_connection *pc;
struct mapcache_memcache_pooled_connection *mpc;
pc = _mapcache_memcache_get_conn(ctx,cache,tile);
if(GC_HAS_ERROR(ctx))
return MAPCACHE_FALSE;
mpc = pc->connection;
key = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) {
rv = MAPCACHE_FALSE;
goto cleanup;
}
rv = apr_memcache_getp(mpc->memcache,ctx->pool,key,&tmpdata,&tmpdatasize,NULL);
if(rv != APR_SUCCESS) {
rv = MAPCACHE_FALSE;
goto cleanup;
}
if(tmpdatasize == 0) {
rv = MAPCACHE_FALSE;
goto cleanup;
}
rv = MAPCACHE_TRUE;
cleanup:
_mapcache_memcache_release_conn(ctx,pc);
return rv;
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the memcache server
* \private \memberof mapcache_cache_memcache
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_memcache_get(mapcache_context *ctx, mapcache_tile *tile) {
char *key;
int rv;
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)tile->tileset->cache;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
tile->encoded_data = mapcache_buffer_create(0,ctx->pool);
rv = apr_memcache_getp(cache->memcache,ctx->pool,key,(char**)&tile->encoded_data->buf,&tile->encoded_data->size,NULL);
if(rv != APR_SUCCESS) {
return MAPCACHE_CACHE_MISS;
}
if(tile->encoded_data->size == 0) {
ctx->set_error(ctx,500,"memcache cache returned 0-length data for tile %d %d %d\n",tile->x,tile->y,tile->z);
return MAPCACHE_FAILURE;
}
/* extract the tile modification time from the end of the data returned */
memcpy(
&tile->mtime,
&(((char*)tile->encoded_data->buf)[tile->encoded_data->size-sizeof(apr_time_t)]),
sizeof(apr_time_t));
((char*)tile->encoded_data->buf)[tile->encoded_data->size+sizeof(apr_time_t)]='\0';
tile->encoded_data->avail = tile->encoded_data->size;
tile->encoded_data->size -= sizeof(apr_time_t);
return MAPCACHE_SUCCESS;
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the memcache server
* \private \memberof mapcache_cache_memcache
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_memcache_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *key;
int rv;
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)pcache;
mapcache_pooled_connection *pc;
mapcache_buffer *encoded_data;
struct mapcache_memcache_pooled_connection *mpc;
pc = _mapcache_memcache_get_conn(ctx,cache,tile);
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
mpc = pc->connection;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) {
rv = MAPCACHE_FAILURE;
goto cleanup;
}
encoded_data = mapcache_buffer_create(0,ctx->pool);
rv = apr_memcache_getp(mpc->memcache,ctx->pool,key,(char**)&encoded_data->buf,&encoded_data->size,NULL);
if(rv != APR_SUCCESS) {
rv = MAPCACHE_CACHE_MISS;
goto cleanup;
}
if(encoded_data->size == 0) {
ctx->set_error(ctx,500,"memcache cache returned 0-length data for tile %d %d %d\n",tile->x,tile->y,tile->z);
rv = MAPCACHE_FAILURE;
goto cleanup;
}
/* extract the tile modification time from the end of the data returned */
memcpy(
&tile->mtime,
&(((char*)encoded_data->buf)[encoded_data->size-sizeof(apr_time_t)]),
sizeof(apr_time_t));
((char*)encoded_data->buf)[encoded_data->size+sizeof(apr_time_t)]='\0';
encoded_data->avail = encoded_data->size;
encoded_data->size -= sizeof(apr_time_t);
if(((char*)encoded_data->buf)[0] == '#' && encoded_data->size > 1) {
tile->encoded_data = mapcache_empty_png_decode(ctx,tile->grid_link->grid->tile_sx, tile->grid_link->grid->tile_sy ,encoded_data->buf,&tile->nodata);
} else {
tile->encoded_data = encoded_data;
}
rv = MAPCACHE_SUCCESS;
cleanup:
_mapcache_memcache_release_conn(ctx,pc);
return rv;
}
/*
* get a name/value pair from memcache
*/
static apr_byte_t oidc_cache_memcache_get(request_rec *r, const char *section,
const char *key, const char **value) {
oidc_cfg *cfg = ap_get_module_config(r->server->module_config,
&auth_openidc_module);
oidc_cache_cfg_memcache_t *context =
(oidc_cache_cfg_memcache_t *) cfg->cache_cfg;
apr_size_t len = 0;
/* get it */
apr_status_t rv = apr_memcache_getp(context->cache_memcache, r->pool,
oidc_cache_memcache_get_key(r->pool, section, key), (char **) value,
&len, NULL);
if (rv == APR_NOTFOUND) {
/*
* NB: workaround the fact that the apr_memcache returns APR_NOTFOUND if a server has been marked dead
*/
if (oidc_cache_memcache_status(r, context) == FALSE) {
oidc_cache_memcache_log_status_error(r, "apr_memcache_getp", rv);
return FALSE;
}
oidc_debug(r, "apr_memcache_getp: key %s not found in cache",
oidc_cache_memcache_get_key(r->pool, section, key));
return TRUE;
} else if (rv != APR_SUCCESS) {
oidc_cache_memcache_log_status_error(r, "apr_memcache_getp", rv);
return FALSE;
}
/* do sanity checking on the string value */
if ((*value) && (strlen(*value) != len)) {
oidc_error(r,
"apr_memcache_getp returned less bytes than expected: strlen(value) [%zu] != len [%" APR_SIZE_T_FMT "]",
strlen(*value), len);
return FALSE;
}
return TRUE;
}
static int _mapcache_cache_memcache_has_tile(mapcache_context *ctx, mapcache_tile *tile) {
char *key;
char *tmpdata;
int rv;
size_t tmpdatasize;
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)tile->tileset->cache;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
rv = apr_memcache_getp(cache->memcache,ctx->pool,key,&tmpdata,&tmpdatasize,NULL);
if(rv != APR_SUCCESS) {
return MAPCACHE_FALSE;
}
if(tmpdatasize == 0) {
return MAPCACHE_FALSE;
}
return MAPCACHE_TRUE;
}
/* Core functionality of our getter functions: fetch DATA from the memcached
* given by CACHE_VOID and identified by KEY. Indicate success in FOUND and
* use a tempoary sub-pool of POOL for allocations.
*/
static svn_error_t *
memcache_internal_get(char **data,
apr_size_t *size,
svn_boolean_t *found,
void *cache_void,
const void *key,
apr_pool_t *pool)
{
memcache_t *cache = cache_void;
apr_status_t apr_err;
const char *mc_key;
apr_pool_t *subpool;
if (key == NULL)
{
*found = FALSE;
return SVN_NO_ERROR;
}
subpool = svn_pool_create(pool);
SVN_ERR(build_key(&mc_key, cache, key, subpool));
apr_err = apr_memcache_getp(cache->memcache,
pool,
mc_key,
data,
size,
NULL /* ignore flags */);
if (apr_err == APR_NOTFOUND)
{
*found = FALSE;
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
else if (apr_err != APR_SUCCESS || !*data)
return svn_error_wrap_apr(apr_err,
_("Unknown memcached error while reading"));
*found = TRUE;
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/*
* get a name/value pair from memcache
*/
static apr_byte_t oidc_cache_memcache_get(request_rec *r, const char *section,
const char *key, const char **value) {
oidc_debug(r, "enter, section=\"%s\", key=\"%s\"", section, key);
oidc_cfg *cfg = ap_get_module_config(r->server->module_config,
&auth_openidc_module);
oidc_cache_cfg_memcache_t *context =
(oidc_cache_cfg_memcache_t *) cfg->cache_cfg;
apr_size_t len = 0;
/* get it */
apr_status_t rv = apr_memcache_getp(context->cache_memcache, r->pool,
oidc_cache_memcache_get_key(r->pool, section, key), (char **) value,
&len, NULL);
if (rv == APR_NOTFOUND) {
oidc_debug(r, "apr_memcache_getp: key %s not found in cache",
oidc_cache_memcache_get_key(r->pool, section, key));
return FALSE;
} else if (rv != APR_SUCCESS) {
// TODO: error strings ?
oidc_error(r, "apr_memcache_getp returned an error; perhaps your memcache server is not available?");
return FALSE;
}
/* do sanity checking on the string value */
if ((*value) && (strlen(*value) != len)) {
oidc_error(r,
"apr_memcache_getp returned less bytes than expected: strlen(value) [%zu] != len [%" APR_SIZE_T_FMT "]",
strlen(*value), len);
return FALSE;
}
return TRUE;
}
