static void setup(char **argv)
{
const char *endpoint;
assert(session == NULL);
assert(mock == NULL);
assert(io == NULL);
io = get_test_io_opts();
if (io == NULL) {
err_exit("Failed to create IO session");
}
mock = start_mock_server(argv);
if (mock == NULL) {
err_exit("Failed to start mock server");
}
endpoint = get_mock_http_server(mock);
session = libcouchbase_create(endpoint, "Administrator", "password", NULL, io);
if (session == NULL) {
err_exit("Failed to create libcouchbase session");
}
(void)libcouchbase_set_error_callback(session, error_callback);
if (libcouchbase_connect(session) != LIBCOUCHBASE_SUCCESS) {
err_exit("Failed to connect to server");
}
libcouchbase_wait(session);
}
static apr_status_t _couchbase_reslist_get_connection(void **conn_, void *params, apr_pool_t *pool) {
mapcache_cache_couchbase *cache = (mapcache_cache_couchbase*)params;
libcouchbase_t *instance = apr_pcalloc(pool,sizeof(libcouchbase_t));
const char *host = cache->host;
const char *username = cache->username;
const char *passwd = cache->password;
const char *bucket = "default";
*instance = libcouchbase_create(host, username, passwd, bucket, NULL);
if (*instance == NULL) {
return APR_EGENERAL;
}
libcouchbase_set_error_callback(*instance, _couchbase_error_callback);
libcouchbase_set_get_callback(*instance, _couchbase_get_callback);
libcouchbase_set_storage_callback(*instance, _couchbase_store_callback);
if (libcouchbase_connect(*instance) != LIBCOUCHBASE_SUCCESS) {
return APR_EGENERAL;
}
/* Wait for the connect to compelete */
libcouchbase_wait(*instance);
*conn_ = instance;
return APR_SUCCESS;
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the couchbase server
* \private \memberof mapcache_cache_couchbase
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_couchbase_get(mapcache_context *ctx, mapcache_tile *tile) {
char *key[1];
size_t keySize[1];
libcouchbase_t *instance;
libcouchbase_error_t error;
getStruct_t request;
key[0] = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
keySize[0] = strlen(key[0]);
tile->encoded_data = mapcache_buffer_create(0, ctx->pool);
libcouchbase_time_t expires = 86400;
if(tile->tileset->auto_expire)
expires = tile->tileset->auto_expire;
instance = _couchbase_get_connection(ctx, tile);
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
request.tileBuffer = tile->encoded_data;
error = libcouchbase_mget(*instance, &request, 1, (const void * const*)key, keySize, &expires);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase cache returned error on mget %s", libcouchbase_strerror(*instance, error));
_couchbase_invalidate_connection(tile, instance);
return MAPCACHE_FAILURE;
}
libcouchbase_wait(*instance);
if(request.error != LIBCOUCHBASE_SUCCESS) {
_couchbase_release_connection(tile, instance);
return MAPCACHE_CACHE_MISS;
}
if (tile->encoded_data->size == 0) {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "couchbase cache returned 0-length data for tile %d %d %d", tile->x, tile->y, tile->z);
return MAPCACHE_FAILURE;
}
apr_time_t now = apr_time_now();
tile->mtime = now;
_couchbase_release_connection(tile, instance);
return MAPCACHE_SUCCESS;
}
void
PLCBA_connect(SV *self)
{
libcouchbase_t instance;
PLCBA_t *async;
PLCB_t *base;
libcouchbase_error_t err;
_mk_common_vars(self, instance, base, async);
if( (err = libcouchbase_connect(instance)) != LIBCOUCHBASE_SUCCESS) {
die("Problem with initial connection: %s (%d)",
libcouchbase_strerror(instance, err), err);
}
libcouchbase_wait(instance);
}
static void _mapcache_cache_couchbase_delete(mapcache_context *ctx, mapcache_tile *tile) {
char *key;
libcouchbase_t *instance;
libcouchbase_error_t error;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
GC_CHECK_ERROR(ctx);
instance = _couchbase_get_connection(ctx, tile);
error = libcouchbase_remove(*instance, 0, key, strlen(key), 0);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to delete key %s: %s", key, libcouchbase_strerror(*instance, error));
}
libcouchbase_wait(*instance);
error = libcouchbase_get_last_error(*instance);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to delete key %s: %s", key, libcouchbase_strerror(*instance, error));
}
_couchbase_release_connection(tile, instance);
}
static int _mapcache_cache_couchbase_has_tile(mapcache_context *ctx, mapcache_tile *tile) {
char *key[1];
libcouchbase_t *instance;
libcouchbase_error_t error;
size_t keySize[1];
getStruct_t request;
key[0] = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
keySize[0] = strlen(key[0]);
instance = _couchbase_get_connection(ctx, tile);
request.tileBuffer = 0;
request.error = LIBCOUCHBASE_KEY_ENOENT;
error = libcouchbase_mget(*instance, &request, 1, (const void * const*)key, keySize, 0);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to get key %s: %s", key, libcouchbase_strerror(*instance, error));
_couchbase_invalidate_connection(tile, instance);
return MAPCACHE_FALSE;
}
libcouchbase_wait(*instance);
error = request.error;
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to get key %s: %s", key, libcouchbase_strerror(*instance, error));
_couchbase_invalidate_connection(tile, instance);
return MAPCACHE_FALSE;
}
_couchbase_release_connection(tile, instance);
return MAPCACHE_TRUE;
}
/**
* \brief push tile data to couchbase
*
* writes the content of mapcache_tile::data to the configured couchbased instance(s)
* \private \memberof mapcache_cache_couchbase
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_couchbase_set(mapcache_context *ctx, mapcache_tile *tile) {
char *key;
libcouchbase_t *instance;
libcouchbase_error_t error;
const int max_retries = 3;
int retries = max_retries;
apr_interval_time_t delay;
/* set expiration to one day if not configured */
libcouchbase_time_t expires = 86400;
if(tile->tileset->auto_expire)
expires = tile->tileset->auto_expire;
mapcache_cache_couchbase *cache = (mapcache_cache_couchbase*)tile->tileset->cache;
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);
}
instance = _couchbase_get_connection(ctx, tile);
GC_CHECK_ERROR(ctx);
do
{
error = libcouchbase_store(*instance, &error, LIBCOUCHBASE_SET, key, strlen(key), tile->encoded_data->buf, tile->encoded_data->size, 0, expires, 0);
if (error != LIBCOUCHBASE_SUCCESS) {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to couchbase cache %s due to eror %s.",
tile->x, tile->y, tile->z, cache->cache.name, libcouchbase_strerror(*instance, error));
return;
}
libcouchbase_wait(*instance);
if (error == LIBCOUCHBASE_ETMPFAIL) {
if (retries > 0) {
delay = 100000 * (1 << (max_retries - retries)); // Do an exponential back off of starting at 100 milliseconds
apr_sleep(delay);
}
else {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to couchbase cache %s due to %s. Maximum number of retries used.",
tile->x, tile->y, tile->z, cache->cache.name, libcouchbase_strerror(*instance, error));
return;
}
--retries;
}
else if (error != LIBCOUCHBASE_SUCCESS) {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to couchbase cache %s due to error %s.",
tile->x, tile->y, tile->z, cache->cache.name, libcouchbase_strerror(*instance, error));
return;
}
}
while (error == LIBCOUCHBASE_ETMPFAIL);
_couchbase_release_connection(tile, instance);
}
void
PLCBA_request(
SV *self,
int cmd, int reqtype,
SV *callcb, SV *cbdata, int cbtype,
AV *params)
{
PLCBA_cmd_t cmdtype;
struct PLCBA_request_st r;
PLCBA_t *async;
libcouchbase_t instance;
PLCB_t *base;
AV *reqav;
PLCBA_cookie_t *cookie;
int nreq, i;
libcouchbase_error_t *errors;
int errcount;
int has_conversion;
SV **tmpsv;
time_t *multi_exp;
void **multi_key;
size_t *multi_nkey;
libcouchbase_error_t err;
libcouchbase_storage_t storop;
_mk_common_vars(self, instance, base, async);
Newxz(cookie, 1, PLCBA_cookie_t);
if(SvTYPE(callcb) == SVt_NULL) {
die("Must have callback for asynchronous request");
}
if(reqtype == PLCBA_REQTYPE_MULTI) {
nreq = av_len(params) + 1;
if(!nreq) {
die("No requests specified");
}
} else {
nreq = 1;
}
cookie->callcb = callcb; SvREFCNT_inc(callcb);
cookie->cbdata = cbdata; SvREFCNT_inc(cbdata);
cookie->cbtype = cbtype;
cookie->results = newHV();
cookie->parent = async;
cookie->remaining = nreq;
/*pseudo-multi system:
Most commands do not have a libcouchbase-level 'multi' implementation, but
nevertheless it's more efficient to allow a 'multi' option from Perl because
sub and xsub overhead is very expensive.
Each operation defines a macro '_do_cbop' which does the following:
1) call the libcouchbase api function appropriate for that operation
2) set the function variable 'err' to the error which ocurred.
the predefined pseudo_perform macro does the rest by doing the following:
1) check to see if the request is multiple or single
in the case of multiple requests, it:
I) fetches the current request AV
II) ensures the request is valid and defined
III) extracts the information from the request into our request_st
structure named 'r'
IV) calls the locally-defined _do_cbop (which sets the error)
V) checks the current value of 'err', if it is not a success, the
error counter is incremented
VI) when the loop has terminated, the error counter is checked again,
and if it is greater than zero, the error dispatcher is called
in the case of a single request, it:
I) treats 'params' as the request AV
II) passes the AV to av2request,
III) calls _do_cbop once, and checks for errors
IV) if there is an erorr, the dispatcher is called
*/
#define _fetch_assert(idx) \
if((tmpsv = av_fetch(params, idx, 0)) == NULL) { \
die("Null request found in request list"); \
} \
if(!SvROK(*tmpsv)) { \
die("Expected reference type in parameter list."); \
} \
av2request(async, cmd, (AV*)(SvRV(*tmpsv)), &r);
#define pseudo_multi_begin \
Newxz(errors, nreq, libcouchbase_error_t); \
errcount = 0;
#define pseudo_multi_maybe_add \
if( (errors[i] = err) != LIBCOUCHBASE_SUCCESS ) \
errcount++;
#define pseudo_multi_end \
if(errcount) \
error_pseudo_multi(async, params, errors, cookie); \
Safefree(errors);
#define pseudo_perform \
if(reqtype == PLCBA_REQTYPE_MULTI) { \
pseudo_multi_begin; \
for(i = 0; i < nreq; i++) { \
_fetch_assert(i); \
_do_cbop(); \
pseudo_multi_maybe_add; \
} \
if(errcount < nreq) { \
libcouchbase_wait(instance); \
} \
} else { \
av2request(async, cmd, params, &r); \
_do_cbop(); \
if(err != LIBCOUCHBASE_SUCCESS) { \
warn("Key %s did not return OK (%d)", r.key, err); \
error_single(async, cookie, r.key, r.nkey, err); \
} else { \
libcouchbase_wait(instance); \
} \
} \
switch(cmd) {
case PLCBA_CMD_GET:
case PLCBA_CMD_TOUCH:
#define _do_cbop(klist, szlist, explist) \
if(cmd == PLCBA_CMD_GET) { \
err = libcouchbase_mget(instance, cookie, nreq, \
(const void* const*)klist, \
(szlist), explist); \
} else { \
err = libcouchbase_mtouch(instance, cookie, nreq, \
(const void* const*)klist, \
szlist, explist); \
}
if(reqtype == PLCBA_REQTYPE_MULTI) {
Newx(multi_key, nreq, void*);
Newx(multi_nkey, nreq, size_t);
Newx(multi_exp, nreq, time_t);
for(i = 0; i < nreq; i++) {
_fetch_assert(i);
multi_key[i] = r.key;
multi_nkey[i] = r.nkey;
multi_exp[i] = r.exp;
}
_do_cbop(multi_key, multi_nkey, multi_exp);
if(err != LIBCOUCHBASE_SUCCESS) {
error_true_multi(
async, cookie, nreq, (const char**)multi_key, multi_nkey, err);
} else {
libcouchbase_wait(instance);
}
Safefree(multi_key);
Safefree(multi_nkey);
Safefree(multi_exp);
} else {
av2request(async, cmd, params, &r);
_do_cbop(&(r.key), &(r.nkey), &(r.exp));
if(err != LIBCOUCHBASE_SUCCESS) {
error_single(async, cookie, r.key, r.nkey, err);
} else {
libcouchbase_wait(instance);
}
}
break;
#undef _do_cbop
case PLCBA_CMD_SET:
case PLCBA_CMD_ADD:
case PLCBA_CMD_REPLACE:
case PLCBA_CMD_APPEND:
case PLCBA_CMD_PREPEND:
storop = async_cmd_to_storop(cmd);
//warn("Storop is %x (cmd=%x)", storop, cmd);
has_conversion = plcba_cmd_needs_conversion(cmd);
#define _do_cbop() \
err = libcouchbase_store(instance, cookie, storop, r.key, r.nkey, \
SvPVX(r.value), r.nvalue, r.store_flags, \
r.exp, r.cas); \
if(has_conversion) { \
plcb_convert_storage_free(base, r.value, r.store_flags); \
}
pseudo_perform;
break;
#undef _do_cbop
case PLCBA_CMD_ARITHMETIC:
#define _do_cbop() \
err = libcouchbase_arithmetic(instance, cookie, r.key, r.nkey, \
r.arithmetic.delta, r.exp, \
r.arithmetic.create, r.arithmetic.initial);
pseudo_perform;
break;
#undef _do_cbop
case PLCBA_CMD_REMOVE:
#define _do_cbop() \
err = libcouchbase_remove(instance, cookie, r.key, r.nkey, r.cas);
pseudo_perform;
break;
#undef _do_cbop
default:
die("Unimplemented!");
}
#undef _fetch_assert
#undef pseudo_multi_begin
#undef pseduo_multi_maybe_add
#undef pseudo_multi_end
#undef pseudo_perform
}
