static ENGINE_ERROR_CODE mock_aggregate_stats(ENGINE_HANDLE* handle,
const void* cookie,
void (*callback)(void*, void*),
void *vptr)
{
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->aggregate_stats((ENGINE_HANDLE*)me->the_engine, c,
callback, vptr)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
static ENGINE_ERROR_CODE mock_remove(ENGINE_HANDLE* handle,
const void* cookie,
const void* key,
const size_t nkey,
uint64_t cas,
uint16_t vbucket)
{
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->remove((ENGINE_HANDLE*)me->the_engine, c, key,
nkey, cas, vbucket)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
static ENGINE_ERROR_CODE mock_unknown_command(ENGINE_HANDLE* handle,
const void* cookie,
protocol_binary_request_header *request,
ADD_RESPONSE response)
{
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->unknown_command((ENGINE_HANDLE*)me->the_engine, c,
request, response)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
static ENGINE_ERROR_CODE mock_get_stats(ENGINE_HANDLE* handle,
const void* cookie,
const char* stat_key,
int nkey,
ADD_STAT add_stat)
{
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->get_stats((ENGINE_HANDLE*)me->the_engine, c, stat_key,
nkey, add_stat)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
static ENGINE_ERROR_CODE mock_tap_notify(ENGINE_HANDLE* handle,
const void *cookie,
void *engine_specific,
uint16_t nengine,
uint8_t ttl,
uint16_t tap_flags,
tap_event_t tap_event,
uint32_t tap_seqno,
const void *key,
size_t nkey,
uint32_t flags,
uint32_t exptime,
uint64_t cas,
const void *data,
size_t ndata,
uint16_t vbucket) {
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->tap_notify((ENGINE_HANDLE*)me->the_engine, c,
engine_specific, nengine, ttl, tap_flags,
tap_event, tap_seqno, key, nkey, flags,
exptime, cas, data, ndata, vbucket)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
static ENGINE_ERROR_CODE mock_arithmetic(ENGINE_HANDLE* handle,
const void* cookie,
const void* key,
const int nkey,
const bool increment,
const bool create,
const uint64_t delta,
const uint64_t initial,
const int flags,
const rel_time_t exptime,
uint64_t *cas,
uint64_t *result,
uint16_t vbucket) {
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->arithmetic((ENGINE_HANDLE*)me->the_engine, c, key,
nkey, increment, create,
delta, initial, flags, exptime,
cas, result, vbucket)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
static ENGINE_ERROR_CODE mock_allocate(ENGINE_HANDLE* handle,
const void* cookie,
item **item,
const void* key,
const size_t nkey,
const size_t nbytes,
const int flags,
const rel_time_t exptime) {
struct mock_engine *me = get_handle(handle);
struct mock_connstruct *c = (void*)cookie;
if (c == NULL) {
c = (void*)create_mock_cookie();
}
c->nblocks = 0;
ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
pthread_mutex_lock(&c->mutex);
while (ret == ENGINE_SUCCESS &&
(ret = me->the_engine->allocate((ENGINE_HANDLE*)me->the_engine, c,
item, key, nkey,
nbytes, flags,
exptime)) == ENGINE_EWOULDBLOCK &&
c->handle_ewouldblock)
{
++c->nblocks;
pthread_cond_wait(&c->cond, &c->mutex);
ret = c->status;
}
pthread_mutex_unlock(&c->mutex);
if (c != cookie) {
destroy_mock_cookie(c);
}
return ret;
}
