libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/tools/cbc-handlers.h

@@ -203,6 +203,23 @@ protected:
     void run();
 };
 
+class PingHandler : public Handler {
+public:
+    HANDLER_DESCRIPTION("Reach all services on every node and measure response time")
+    HANDLER_USAGE("[OPTIONS ...]")
+    PingHandler() : Handler("ping"), o_details("details") {
+        o_details.description("Render extra details about status of the services");
+    }
+protected:
+    void run();
+    void addOptions() {
+        Handler::addOptions();
+        parser.addOption(o_details);
+    }
+private:
+    cliopts::BoolOption o_details;
+};
+
 class McFlushHandler : public Handler {
 public:
     HANDLER_DESCRIPTION("Flush a memcached bucket")
@@ -280,9 +297,9 @@ private:
 
 class N1qlHandler : public Handler {
 public:
-    N1qlHandler() : Handler("view"), o_args("qarg"), o_opts("qopt"),
-                    o_prepare("prepare") {}
-    HANDLER_DESCRIPTION("Execute a N1QL Query")
+    N1qlHandler() : Handler("query"), o_args("qarg"), o_opts("qopt"),
+        o_prepare("prepare"), o_analytics("analytics") {}
+    HANDLER_DESCRIPTION("Execute a N1QL/Analytics Query")
     HANDLER_USAGE("QUERY [--qarg PARAM1=VALUE1 --qopt PARAM2=VALUE2]")
 
 protected:
@@ -299,15 +316,18 @@ protected:
         o_opts.abbrev('Q');
 
         o_prepare.description("Prepare query before issuing");
+        o_analytics.description("Perform query to analytics service");
 
         parser.addOption(o_args);
         parser.addOption(o_opts);
         parser.addOption(o_prepare);
+        parser.addOption(o_analytics);
     }
 private:
     cliopts::ListOption o_args;
     cliopts::ListOption o_opts;
     cliopts::BoolOption o_prepare;
+    cliopts::BoolOption o_analytics;
 };
 
 class HttpReceiver {

data/ext/libcouchbase/tools/cbc-n1qlback.cc

@@ -122,7 +122,7 @@ private:
 
         last_update = now;
 
-        const char *prefix = use_ansi_codes ? "\x1B[K" : "";
+        const char *prefix;
         const char *final_suffix;
 
         // Only use "ticker" style updates if we're a TTY and we have no

data/ext/libcouchbase/tools/cbc-pillowfight.cc

@@ -118,6 +118,7 @@ public:
         o_writeJson("json"),
         o_templatePairs("template"),
         o_subdoc("subdoc"),
+        o_noop("noop"),
         o_sdPathCount("pathcount"),
         o_populateOnly("populate-only"),
         o_exptime("expiry")
@@ -141,6 +142,7 @@ public:
         o_templatePairs.description("Values for templates to be inserted into user documents");
         o_templatePairs.argdesc("FIELD,MIN,MAX[,SEQUENTIAL]").hide();
         o_subdoc.description("Use subdoc instead of fulldoc operations");
+        o_noop.description("Use NOOP instead of document operations").setDefault(0);
         o_sdPathCount.description("Number of subdoc paths per command").setDefault(1);
         o_populateOnly.description("Exit after documents have been populated");
         o_exptime.description("Set TTL for items").abbrev('e');
@@ -256,6 +258,7 @@ public:
         parser.addOption(o_writeJson);
         parser.addOption(o_templatePairs);
         parser.addOption(o_subdoc);
+        parser.addOption(o_noop);
         parser.addOption(o_sdPathCount);
         parser.addOption(o_populateOnly);
         parser.addOption(o_exptime);
@@ -278,6 +281,7 @@ public:
     bool shouldPauseAtEnd() { return o_pauseAtEnd; }
     bool sequentialAccess() { return o_sequential; }
     bool isSubdoc() { return o_subdoc; }
+    bool isNoop() { return o_noop.result(); }
     unsigned firstKeyOffset() { return o_startAt; }
     uint32_t getNumItems() { return o_numItems; }
     uint32_t getRateLimit() { return o_rateLimit; }
@@ -319,6 +323,7 @@ private:
     // List of template ranges for value generation
     ListOption o_templatePairs;
     BoolOption o_subdoc;
+    BoolOption o_noop;
     UIntOption o_sdPathCount;
 
     // Compound option
@@ -394,17 +399,51 @@ struct NextOp {
     vector<lcb_IOV> m_valuefrags;
     vector<lcb_SDSPEC> m_specs;
     // The mode here is for future use with subdoc
-    enum Mode { STORE, GET, SDSTORE, SDGET };
+    enum Mode { STORE, GET, SDSTORE, SDGET, NOOP };
     Mode m_mode;
 };
 
+class OpGenerator {
+public:
+    OpGenerator(int id): m_id(id) {}
+
+    virtual ~OpGenerator() {};
+    virtual void setNextOp(NextOp& op) = 0;
+    virtual void setValue(NextOp& op) = 0;
+    virtual bool inPopulation() const = 0;
+    virtual const char *getStageString() const = 0;
+
+protected:
+    int m_id;
+};
+
+class NoopGenerator : public OpGenerator {
+public:
+    NoopGenerator(int ix) : OpGenerator(ix) {}
+
+
+    void setNextOp(NextOp& op) {
+        op.m_mode = NextOp::NOOP;
+    }
+
+    void setValue(NextOp&) {}
+
+    bool inPopulation() const {
+        return false;
+    }
+
+    const char *getStageString() const {
+        return "Run";
+    }
+};
+
 /** Stateful, per-thread generator */
-class KeyGenerator {
+class KeyGenerator : public OpGenerator {
 public:
     KeyGenerator(int ix)
-    : m_gencount(0), m_force_sequential(false),
+      : OpGenerator(ix), m_gencount(0), m_force_sequential(false),
       m_in_population(config.shouldPopulate)
-{
+    {
         srand(config.getRandomSeed());
 
         m_genrandom = new SeqGenerator(
@@ -423,7 +462,6 @@ public:
             m_force_sequential = config.sequentialAccess();
         }
 
-        m_id = ix;
         m_local_genstate = config.docgen->createState(config.getNumThreads(), ix);
         if (config.isSubdoc()) {
             m_mode_read = NextOp::SDGET;
@@ -439,6 +477,10 @@ public:
         }
     }
 
+    void setValue(NextOp& op) {
+        m_local_genstate->populateIov(op.m_seqno, op.m_valuefrags);
+    }
+
     void setNextOp(NextOp& op) {
         bool store_override = false;
 
@@ -461,12 +503,12 @@ public:
         if (store_override) {
             // Populate
             op.m_mode = NextOp::STORE;
-            m_local_genstate->populateIov(op.m_seqno, op.m_valuefrags);
+            setValue(op);
 
         } else if (shouldStore(op.m_seqno)) {
             op.m_mode = m_mode_write;
             if (op.m_mode == NextOp::STORE) {
-                m_local_genstate->populateIov(op.m_seqno, op.m_valuefrags);
+                setValue(op);
             } else if (op.m_mode == NextOp::SDSTORE) {
                 op.m_specs.resize(config.sdOpsPerCmd);
                 m_sdgenstate->populateMutate(op.m_seqno, op.m_specs);
@@ -485,6 +527,19 @@ public:
         generateKey(op);
     }
 
+    bool inPopulation() const {
+        return m_in_population;
+    }
+
+    const char *getStageString() const {
+        if (m_in_population) {
+            return "Populate";
+        } else {
+            return "Run";
+        }
+    }
+
+private:
     bool shouldStore(uint32_t seqno) {
         if (config.setprc == 0) {
             return false;
@@ -502,15 +557,7 @@ public:
         op.m_key.assign(config.getKeyPrefix() + buffer);
     }
 
-    const char *getStageString() const {
-        if (m_in_population) {
-            return "Populate";
-        } else {
-            return "Run";
-        }
-    }
 
-private:
     SeqGenerator *m_genrandom;
     SeqGenerator *m_gensequence;
     size_t m_gencount;
@@ -527,18 +574,31 @@ private:
 class ThreadContext
 {
 public:
-    ThreadContext(lcb_t handle, int ix) : kgen(ix), niter(0), instance(handle) {
+    ThreadContext(lcb_t handle, int ix) : niter(0), instance(handle) {
+        if (config.isNoop()) {
+            gen = new NoopGenerator(ix);
+        } else {
+            gen = new KeyGenerator(ix);
+        }
+    }
 
+    ~ThreadContext() {
+        delete gen;
+        gen = NULL;
+    }
+
+    bool inPopulation() {
+        return gen && (gen->inPopulation() || !retryq.empty());
     }
 
     void singleLoop() {
         bool hasItems = false;
-        lcb_sched_enter(instance);
         NextOp opinfo;
         unsigned exptime = config.getExptime();
 
+        lcb_sched_enter(instance);
         for (size_t ii = 0; ii < config.opsPerCycle; ++ii) {
-            kgen.setNextOp(opinfo);
+            gen->setNextOp(opinfo);
 
             switch (opinfo.m_mode) {
             case NextOp::STORE: {
@@ -569,6 +629,11 @@ public:
                 error = lcb_subdoc3(instance, this, &sdcmd);
                 break;
             }
+            case NextOp::NOOP: {
+                lcb_CMDNOOP ncmd = { 0 };
+                error = lcb_noop3(instance, this, &ncmd);
+                break;
+            }
             }
 
             if (error != LCB_SUCCESS) {
@@ -587,6 +652,25 @@ public:
         } else {
             lcb_sched_fail(instance);
         }
+
+        while (!retryq.empty()) {
+            lcb_sched_enter(instance);
+            while (!retryq.empty()) {
+                opinfo = retryq.front();
+                retryq.pop();
+                lcb_CMDSTORE scmd = { 0 };
+                scmd.operation = LCB_SET;
+                scmd.exptime = exptime;
+                LCB_CMD_SET_KEY(&scmd, opinfo.m_key.c_str(), opinfo.m_key.size());
+                LCB_CMD_SET_VALUEIOV(&scmd, &opinfo.m_valuefrags[0], opinfo.m_valuefrags.size());
+                error = lcb_store3(instance, this, &scmd);
+            }
+            lcb_sched_leave(instance);
+            lcb_wait(instance);
+            if (error != LCB_SUCCESS) {
+                log("Operation(s) failed: [0x%x] %s", error, lcb_strerror(instance, error));
+            }
+        }
     }
 
     bool run() {
@@ -594,7 +678,7 @@ public:
             singleLoop();
 
             if (config.isTimings()) {
-                InstanceCookie::dumpTimings(instance, kgen.getStageString());
+                InstanceCookie::dumpTimings(instance, gen->getStageString());
             }
             if (config.params.shouldDump()) {
                 lcb_dump(instance, stderr, LCB_DUMP_ALL);
@@ -606,11 +690,18 @@ public:
         } while (!config.isLoopDone(++niter));
 
         if (config.isTimings()) {
-            InstanceCookie::dumpTimings(instance, kgen.getStageString(), true);
+            InstanceCookie::dumpTimings(instance, gen->getStageString(), true);
         }
         return true;
     }
 
+    void retry(NextOp &op) {
+        if (op.m_mode == NextOp::STORE) {
+            gen->setValue(op);
+        }
+        retryq.push(op);
+    }
+
 #ifndef WIN32
     pthread_t thr;
 #endif
@@ -645,31 +736,39 @@ private:
         previous_time = now;
     }
 
-    KeyGenerator kgen;
+    OpGenerator *gen;
     size_t niter;
     lcb_error_t error;
     lcb_t instance;
+    std::queue<NextOp> retryq;
 };
 
-static void operationCallback(lcb_t, int, const lcb_RESPBASE *resp)
+static void operationCallback(lcb_t, int cbtype, const lcb_RESPBASE *resp)
 {
     ThreadContext *tc;
 
     tc = const_cast<ThreadContext *>(reinterpret_cast<const ThreadContext *>(resp->cookie));
-    tc->setError(resp->rc);
+    if (cbtype == LCB_CALLBACK_STORE && resp->rc != LCB_SUCCESS && tc->inPopulation()) {
+        NextOp op;
+        op.m_mode = NextOp::STORE;
+        op.m_key.assign((char *)resp->key, resp->nkey);
+        op.m_seqno = atoi(op.m_key.c_str());
+        tc->retry(op);
+    } else {
+        tc->setError(resp->rc);
+    }
 
 #ifndef WIN32
     static volatile unsigned long nops = 1;
     static time_t start_time = time(NULL);
-    static int is_tty = isatty(STDOUT_FILENO);
+    static int is_tty = isatty(STDERR_FILENO);
     if (is_tty) {
         if (++nops % 1000 == 0) {
             time_t now = time(NULL);
             time_t nsecs = now - start_time;
             if (!nsecs) { nsecs = 1; }
             unsigned long ops_sec = nops / nsecs;
-            printf("OPS/SEC: %10lu\r", ops_sec);
-            fflush(stdout);
+            fprintf(stderr, "OPS/SEC: %10lu\r", ops_sec);
         }
     }
 #endif
@@ -795,6 +894,7 @@ int main(int argc, char **argv)
         lcb_install_callback3(instance, LCB_CALLBACK_GET, operationCallback);
         lcb_install_callback3(instance, LCB_CALLBACK_SDMUTATE, operationCallback);
         lcb_install_callback3(instance, LCB_CALLBACK_SDLOOKUP, operationCallback);
+        lcb_install_callback3(instance, LCB_CALLBACK_NOOP, operationCallback);
         cp.doCtls(instance);
 
         new InstanceCookie(instance);

data/ext/libcouchbase/tools/cbc-proxy.cc

@@ -0,0 +1,403 @@
+/*
+ *     Copyright 2017 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#define LCB_NO_DEPR_CXX_CTORS
+
+#include "common/my_inttypes.h"
+#include "config.h"
+#include <sys/types.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/vbucket.h>
+#include <libcouchbase/api3.h>
+#include <libcouchbase/pktfwd.h>
+#include <memcached/protocol_binary.h>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cerrno>
+#include <sstream>
+#include <signal.h>
+#include "common/options.h"
+#include "common/histogram.h"
+
+#include "internal.h"
+
+#include <event2/event.h>
+#include <event2/listener.h>
+#include <event2/bufferevent.h>
+#include <event2/buffer.h>
+
+using namespace cbc;
+using namespace cliopts;
+
+static void die(const char *msg)
+{
+    fprintf(stderr, "%s\n", msg);
+    exit(EXIT_FAILURE);
+}
+
+static void good_or_die(lcb_error_t rc, const char *msg = "")
+{
+    if (rc != LCB_SUCCESS) {
+        fprintf(stderr, "%s\n0x%02x: %s\n", msg, rc, lcb_strerror(NULL, rc));
+        exit(EXIT_FAILURE);
+    }
+}
+
+static lcb_t instance = NULL;
+static struct event_base *evbase = NULL;
+static Histogram hg;
+
+#define LOGARGS(lvl) (instance)->settings, "proxy", LCB_LOG_##lvl, __FILE__, __LINE__
+#define CL_LOGFMT "<%s:%s> (cl=%p,fd=%d) "
+#define CL_LOGID(cl) cl->host, cl->port, (void *)cl, cl->fd
+
+class Configuration
+{
+  public:
+    Configuration() : o_trace("trace"), o_port("port")
+    {
+        o_trace.abbrev('t').description("Show packet trace on INFO log level");
+        o_port.abbrev('p').description("Port for proxy").setDefault(11211);
+    }
+
+    ~Configuration()
+    {
+    }
+
+    void addToParser(Parser &parser)
+    {
+        m_params.addToParser(parser);
+        parser.addOption(o_trace);
+        parser.addOption(o_port);
+    }
+
+    void processOptions()
+    {
+    }
+
+    void fillCropts(lcb_create_st &opts)
+    {
+        m_params.fillCropts(opts);
+    }
+    lcb_error_t doCtls()
+    {
+        return m_params.doCtls(instance);
+    }
+    bool useTimings()
+    {
+        return m_params.useTimings();
+    }
+    bool shouldDump()
+    {
+        return m_params.shouldDump();
+    }
+
+    bool isTrace()
+    {
+        return o_trace.result();
+    }
+
+    unsigned port()
+    {
+        return o_port.result();
+    }
+
+  private:
+    ConnParams m_params;
+    BoolOption o_trace;
+    UIntOption o_port;
+};
+
+static Configuration config;
+
+static struct evconnlistener *listener = NULL;
+
+static void cleanup()
+{
+    if (instance) {
+        if (config.shouldDump()) {
+            lcb_dump(instance, stderr, LCB_DUMP_ALL);
+        }
+        if (config.useTimings()) {
+            hg.write();
+        }
+        if (instance) {
+            lcb_destroy(instance);
+        }
+    }
+    if (listener) {
+        evconnlistener_free(listener);
+    }
+    if (evbase) {
+        event_base_free(evbase);
+    }
+}
+
+struct client {
+    int fd;
+    struct bufferevent *bev;
+    char host[NI_MAXHOST + 1];
+    char port[NI_MAXSERV + 1];
+};
+
+static void dump_bytes(const struct client *cl, const char *msg, void *ptr, size_t len)
+{
+    if (!config.isTrace()) {
+        return;
+    }
+
+    int width = 16;
+    const unsigned char *buf = (const unsigned char *)ptr;
+    size_t full_rows = len / width;
+    size_t remainder = len % width;
+    std::stringstream ss;
+
+    ss << msg << ", " << len << " bytes\n"
+                                "             +-------------------------------------------------+\n"
+                                "             |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |\n"
+                                "    +--------+-------------------------------------------------+----------------+";
+
+    unsigned int row = 0;
+    while (row < full_rows) {
+        int row_start_index = row * width;
+        // prefix
+        ss << "\n    |" << std::setw(8) << std::setfill('0') << std::hex << row_start_index << "|";
+        int row_end_index = row_start_index + width;
+        // hex
+        int i = row_start_index;
+        while (i < row_end_index) {
+            ss << " " << std::setw(2) << std::setfill('0') << std::hex << (unsigned int)buf[i++];
+        }
+        ss << " |";
+        // ascii
+        i = row_start_index;
+        while (i < row_end_index) {
+            char b = buf[i++];
+            if ((b <= 0x1f) || (b >= 0x7f)) {
+                ss << '.';
+            } else {
+                ss << b;
+            }
+        }
+        ss << "|";
+        row++;
+    }
+    if (remainder != 0) {
+        int row_start_index = full_rows * width;
+        // prefix
+        ss << "\n    |" << std::setw(8) << std::setfill('0') << std::hex << row_start_index << "|";
+        int row_end_index = row_start_index + remainder;
+        // hex
+        int i = row_start_index;
+        while (i < row_end_index) {
+            ss << " " << std::setw(2) << std::setfill('0') << std::hex << (unsigned int)buf[i++];
+        }
+        i = width - remainder;
+        while (i > 0) {
+            ss << "   ";
+            i--;
+        }
+        ss << " |";
+        // ascii
+        i = row_start_index;
+        while (i < row_end_index) {
+            char b = buf[i++];
+            if ((b <= 0x1f) || (b >= 0x7f)) {
+                ss << '.';
+            } else {
+                ss << b;
+            }
+        }
+        i = width - remainder;
+        while (i > 0) {
+            ss << " ";
+            i--;
+        }
+        ss << "|";
+    }
+    ss << "\n    +--------+-------------------------------------------------+----------------+";
+    lcb_log(LOGARGS(INFO), CL_LOGFMT "%s", CL_LOGID(cl), ss.str().c_str());
+}
+
+static void pktfwd_callback(lcb_t, const void *cookie, lcb_error_t err, lcb_PKTFWDRESP *resp)
+{
+    good_or_die(err, "Failed to forward a packet");
+
+    struct client *cl = (struct client *)cookie;
+    struct evbuffer *output = bufferevent_get_output(cl->bev);
+    for (unsigned ii = 0; ii < resp->nitems; ii++) {
+        dump_bytes(cl, "response", resp->iovs[ii].iov_base, resp->iovs[ii].iov_len);
+        evbuffer_expand(output, resp->iovs[ii].iov_len);
+        evbuffer_add(output, resp->iovs[ii].iov_base, resp->iovs[ii].iov_len);
+    }
+}
+
+static void conn_readcb(struct bufferevent *bev, void *cookie)
+{
+    struct client *cl = (struct client *)cookie;
+    struct evbuffer *input;
+    size_t len;
+
+    input = bufferevent_get_input(bev);
+    len = evbuffer_get_length(input);
+    if (len < 24) {
+        lcb_log(LOGARGS(DEBUG), CL_LOGFMT "not enough data for header", CL_LOGID(cl));
+        return;
+    }
+
+    protocol_binary_request_header header;
+    evbuffer_copyout(input, &header, sizeof(header));
+    lcb_U32 bodylen = ntohl(header.request.bodylen);
+
+    size_t pktlen = sizeof(header) + bodylen;
+    len = evbuffer_get_length(input);
+    if (len < pktlen) {
+        lcb_log(LOGARGS(DEBUG), CL_LOGFMT "not enough data for packet", CL_LOGID(cl));
+        return;
+    }
+    void *pkt = malloc(pktlen);
+    evbuffer_remove(input, pkt, pktlen);
+
+    lcb_sched_enter(instance);
+    lcb_CMDPKTFWD cmd = {0};
+    cmd.vb.vtype = LCB_KV_COPY;
+    cmd.vb.u_buf.contig.bytes = pkt;
+    cmd.vb.u_buf.contig.nbytes = pktlen;
+    dump_bytes(cl, "request", pkt, pktlen);
+    good_or_die(lcb_pktfwd3(instance, cl, &cmd), "Failed to forward packet");
+    lcb_sched_leave(instance);
+}
+
+static void conn_eventcb(struct bufferevent *bev, short events, void *cookie)
+{
+    struct client *cl = (struct client *)cookie;
+
+    if (events & BEV_EVENT_EOF) {
+        lcb_log(LOGARGS(INFO), CL_LOGFMT "connection closed", CL_LOGID(cl));
+        bufferevent_free(bev);
+        delete cl;
+    } else if (events & BEV_EVENT_ERROR) {
+        lcb_log(LOGARGS(ERROR), CL_LOGFMT "got an error on the connection: %s\n", CL_LOGID(cl), strerror(errno));
+        bufferevent_free(bev);
+        delete cl;
+    } else {
+        lcb_log(LOGARGS(DEBUG), CL_LOGFMT "ignore event 0x%02x", CL_LOGID(cl), events);
+    }
+}
+
+static void listener_cb(struct evconnlistener *, evutil_socket_t fd, struct sockaddr *addr, int naddr, void *)
+{
+    struct bufferevent *bev;
+    bev = bufferevent_socket_new(evbase, fd, BEV_OPT_CLOSE_ON_FREE);
+
+    if (!bev) {
+        die("Error constructing bufferevent");
+    }
+
+    struct client *cl = new client();
+    cl->fd = fd;
+    cl->bev = bev;
+    getnameinfo(addr, naddr, cl->host, sizeof(cl->host), cl->port, sizeof(cl->port), NI_NUMERICHOST | NI_NUMERICSERV);
+    bufferevent_setcb(bev, conn_readcb, NULL, conn_eventcb, cl);
+    bufferevent_enable(bev, EV_READ | EV_WRITE);
+    lcb_log(LOGARGS(INFO), CL_LOGFMT "new client connection", CL_LOGID(cl));
+}
+
+static void setup_listener()
+{
+    struct sockaddr_in sin;
+
+    memset(&sin, 0, sizeof(sin));
+    sin.sin_family = AF_INET;
+    sin.sin_port = htons(config.port());
+
+    listener = evconnlistener_new_bind(evbase, listener_cb, NULL, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, -1,
+                                       (struct sockaddr *)&sin, sizeof(sin));
+    if (!listener) {
+        die("Failed to create proxy listener");
+    }
+    lcb_log(LOGARGS(INFO), "Listening incoming proxy connections on port %d", config.port());
+}
+
+static void bootstrap_callback(lcb_t, lcb_error_t err)
+{
+    good_or_die(err, "Failed to bootstrap");
+    lcb_log(LOGARGS(INFO), "connected to Couchbase Server");
+    setup_listener();
+}
+
+static int terminating = 0;
+static void sigint_handler(int)
+{
+    lcb_log(LOGARGS(INFO), "terminating the server");
+    if (!terminating) {
+        event_base_loopbreak(evbase);
+        terminating = 1;
+    }
+}
+
+static void real_main(int argc, char **argv)
+{
+    Parser parser;
+
+    config.addToParser(parser);
+    parser.parse(argc, argv);
+    config.processOptions();
+
+    lcb_create_st cropts;
+    memset(&cropts, 0, sizeof cropts);
+    config.fillCropts(cropts);
+
+    /* bind to external libevent loop */
+    evbase = event_base_new();
+    struct lcb_create_io_ops_st ciops;
+    memset(&ciops, 0, sizeof(ciops));
+    ciops.v.v0.type = LCB_IO_OPS_LIBEVENT;
+    ciops.v.v0.cookie = evbase;
+    good_or_die(lcb_create_io_ops(&cropts.v.v3.io, &ciops), "Failed to create and IO ops strucutre for libevent");
+
+    good_or_die(lcb_create(&instance, &cropts), "Failed to create connection");
+    config.doCtls();
+    lcb_set_bootstrap_callback(instance, bootstrap_callback);
+    lcb_set_pktfwd_callback(instance, pktfwd_callback);
+
+    good_or_die(lcb_connect(instance), "Failed to connect to cluster");
+    if (config.useTimings()) {
+        hg.install(instance, stdout);
+    }
+    std::atexit(cleanup);
+
+    /* setup CTRL-C handler */
+    struct sigaction action;
+    sigemptyset(&action.sa_mask);
+    action.sa_handler = sigint_handler;
+    action.sa_flags = 0;
+    sigaction(SIGINT, &action, NULL);
+
+    event_base_dispatch(evbase);
+}
+
+int main(int argc, char **argv)
+{
+    try {
+        real_main(argc, argv);
+        return 0;
+    } catch (std::exception &exc) {
+        std::cerr << exc.what() << std::endl;
+        exit(EXIT_FAILURE);
+    }
+}