Using libcouchbase in async mode

Disappointed I didn't see any replies to this....

So, started ripping through the library source code...

To further refine my question:

If I do:

if ((io = libcouchbase_create_io_ops(LIBCOUCHBASE_IO_OPS_DEFAULT, NULL, NULL) ) == NULL ) {
fprintf(stderr, "Failed to create io\n");
exit(EXIT_FAILURE);
}

if ((handle = libcouchbase_create(host, username, password, bucket, io)) == NULL){
/* Failed to create the handle */
fprintf(stderr, "Failed to create instance\n");
exit(EXIT_FAILURE);
}

..... lots of stuff, including setting up my own events to libevent

// Start libevent event loop
io->run_event_loop(io);

Can I indeed use ((struct libevent_cookie *)iops->cookie)->base as the handle to libevent for
my own event/callback purposes for code that has nothing to do with couchbase?

Michael

Here is how I finally got it to work

#include < stdlib.h >
#include < stdio.h >
#include < string.h >
#include < event.h >
#include < stdbool.h >
#include < libcouchbase/couchbase.h >

static struct event_base * base = NULL;
static libcouchbase_t * handle = NULL;
static bool done = false;

static void error_callback( libcouchbase_t instance, libcouchbase_error_t error, const char *errinfo )
{
fprintf( stderr, "%s", libcouchbase_strerror( instance, error ) );
if ( errinfo )
fprintf( stderr, ": %s", errinfo );
fprintf( stderr, "\n" );
exit( EXIT_FAILURE );
}

void timer_cb( int fd, short event, void *arg )
{
char key[80];
static int n = 0;
int nkey;

if ( n++ > 100 ) {
done = true;
return;
}

printf( "cb_func called %d times so far.\n", n );

/* Add store events to the queue */
nkey = sprintf( key, "%d", n );
libcouchbase_store( *handle, NULL, LIBCOUCHBASE_SET, key, nkey, &n, sizeof(n), 0, 0, 0 );

printf("cb_func call done\n");
}

static void storage_callback( libcouchbase_t instance, const void *cookie, libcouchbase_storage_t operation,
libcouchbase_error_t error, const void *key, size_t nkey, uint64_t cas )
{
static struct event ev;
static struct timeval tv;

if ( error != LIBCOUCHBASE_SUCCESS ) {
fprintf( stderr, "Failed to store \"" );
fwrite( key, nkey, 1, stderr );
fprintf( stderr, "\"\n" );
exit( EXIT_FAILURE );
}

/* libevent api to start a timer */
tv.tv_sec = 0;
tv.tv_usec = 0;
event_set( &ev, -1, 0, timer_cb, NULL );
event_base_set( base, &ev );
event_add( &ev, &tv );
}

void timer_end_cb( int fd, short event, void *arg )
{
static struct event ev_end;
static struct timeval tv_end;

/* We have seen all responses */
if ( done )
exit( EXIT_SUCCESS );

/* libevent api to start a timer */
tv_end.tv_sec = 1;
tv_end.tv_usec = 0;
event_set( &ev_end, -1, 0, timer_end_cb, NULL );
event_base_set( base, &ev_end );
event_add( &ev_end, &tv_end );
}

static void free_resources( void )
{
/* Free the instance */
if ( handle ) {
libcouchbase_destroy( *handle );
free( handle );
}

/* Free the base, since we created it */
if ( base )
event_base_free( base );
}

int main( int argc, char **argv )
{
const char *host = NULL; /* Use localhost:8091 */
const char *username = NULL; /* No user specified */
const char *password = NULL; /* No password specified */
const char *bucket = NULL; /* use default bucket */
static libcouchbase_io_opt_t *io = NULL;
struct event ev, ev_end;
struct timeval tv, tv_end;

atexit( free_resources );

if ( ( base = event_base_new() ) == NULL ) {
fprintf( stderr, "Failed to create base\n" );
exit( EXIT_FAILURE );
}

if ( ( io = libcouchbase_create_io_ops( LIBCOUCHBASE_IO_OPS_DEFAULT, base, NULL ) ) == NULL ) {
fprintf( stderr, "Failed to create io\n" );
exit( EXIT_FAILURE );
}

if ( ( handle = malloc( sizeof( libcouchbase_t ) ) ) == NULL ) {
fprintf( stderr, "malloc() failed\n" );
exit( EXIT_FAILURE );
}
memset( handle, 0, sizeof( libcouchbase_t ) );

if ( ( *handle = libcouchbase_create(host, username, password, bucket, io ) ) == NULL ){
fprintf( stderr, "Failed to create instance\n" );
exit( EXIT_FAILURE );
}

libcouchbase_set_error_callback( *handle, error_callback );
libcouchbase_set_storage_callback( *handle, storage_callback );

libcouchbase_connect( *handle );
libcouchbase_wait( *handle );

/* libevent api to start a timer */
tv.tv_sec = 0;
tv.tv_usec = 0;
event_set( &ev, -1, 0, timer_cb, NULL );
event_base_set( base, &ev );
event_add( &ev, &tv );

tv_end.tv_sec = 1;
tv_end.tv_usec = 0;
event_set( &ev_end, -1, 0, timer_end_cb, NULL );
event_base_set( base, &ev_end );
event_add( &ev_end, &tv_end );

/* Spark libevent - we won't be back until the loop is stopped */
event_base_loop( base, 0 );

return 0;
}

I hope this might help somebody sometime because nobody helped me.

Hi,

I will look at this code better, since I'm stuck with the same problem. I have a heavy threaded application that needs to write/read to couchbase. I can't find a single place how to drive the event loop... And using the wait function doesn't cut it for me.

Hi guys, sorry for late response, but I wrote simple eample of how to integrate libcouchbase with your own application which possibly has own event framework.

https://github.com/avsej/libev-couchbase-example

In this example initially you have echo server built on libev on step and on step two it have libcouchbase integrated and using event stuff from host application. I'm using libev here because we've wrote libcouchbase plugin for it, but it could be any other framework if you'll will implement couple of functions in plugin

Update. The code was written 20 days ago before recent libcouchbase release, so there could be trivial compile errors. I will fix them in couple of hours today

Hi guys, I actually have a question in another extreme. How to use it in the sync mode? From the website, I read this: "The simplest is to use the synchronous interface over the asynch internals of the library." But I cannot find an example, nor in the header files.
Any lights on sync examples?

Thanks

We have example for synchronous mode too:

https://github.com/couchbase/libcouchbase/blob/master/example/syncmode/m...

Note although, that this approach still requires callbacks, but I think it won't be very complex to generalize them and wrap into single calls.