mt-libcouchbase 1.4.0

data/ext/libcouchbase/tests/rdb/t_basic.cc

@@ -0,0 +1,128 @@
+#include "rdbtest.h"
+
+class RopeTest : public ::testing::Test {};
+using std::string;
+
+TEST_F(RopeTest, testBasic)
+{
+    IORope rope;
+    nb_IOV iovs;
+    unsigned niov = rdb_rdstart(&rope, &iovs, 1);
+    ASSERT_EQ(1, niov);
+    ASSERT_FALSE(iovs.iov_base == NULL);
+    ASSERT_GT(iovs.iov_len, 0U);
+
+    memset(iovs.iov_base, 0x66, iovs.iov_len);
+    rdb_rdend(&rope, iovs.iov_len);
+    ASSERT_EQ(iovs.iov_len, rope.usedSize());
+
+    for (unsigned ii = 0; ii < iovs.iov_len; ii++) {
+        unsigned char tmp;
+        rdb_copyread(&rope, &tmp, 1);
+        ASSERT_EQ(0x66, tmp);
+        rdb_consumed(&rope, 1);
+    }
+}
+
+TEST_F(RopeTest, testFragmented)
+{
+    IORope rope(rdb_chunkalloc_new(1));
+    nb_IOV iovs[32];
+    unsigned niov;
+    niov = rdb_rdstart(&rope, iovs, 32);
+    ASSERT_EQ(32, niov);
+
+    string hello("Hello World!");
+    for (unsigned ii = 0; ii < hello.size(); ii++) {
+        memcpy(iovs[ii].iov_base, &hello[ii], 1);
+    }
+
+    rdb_rdend(&rope, hello.size());
+    ASSERT_EQ(hello.size(), rope.usedSize());
+
+    // Now we should be able to extract it properly
+    char tmpbuf[32] = { 0 };
+    rdb_copyread(&rope, tmpbuf, hello.size());
+    ASSERT_STREQ(tmpbuf, hello.c_str());
+
+    /** Can we read contiguously? */
+    nb_IOV iovs2[32];
+    rdb_ROPESEG *backs[32];
+    int nitems;
+
+    nitems = rdb_refread_ex(&rope, iovs2, backs, 32, hello.size());
+    ASSERT_EQ(hello.size(), nitems);
+    for (unsigned ii = 0; ii < hello.size(); ii++) {
+        nb_IOV *cur = iovs2 + ii;
+        ASSERT_EQ(*(char *)cur->iov_base, hello.at(ii));
+        ASSERT_EQ(1, cur->iov_len);
+    }
+
+    // Solidify them?
+    rdb_consolidate(&rope, 5);
+    memset(tmpbuf, 0, sizeof(tmpbuf));
+    ASSERT_EQ(hello.size(), rope.usedSize());
+    rdb_copyread(&rope, tmpbuf, hello.size());
+    ASSERT_STREQ(tmpbuf, hello.c_str());
+
+    nitems = rdb_refread_ex(&rope, iovs2, backs, 32, hello.size());
+    ASSERT_EQ(hello.size()-4, nitems);
+}
+
+// This tests the functionality where we want _subsequent_ reads to be
+// consolidated into a single buffer.
+TEST_F(RopeTest, testConsolidatedReadAhead)
+{
+    IORope ior(rdb_chunkalloc_new(1));
+    ior.rdsize = 256;
+
+    nb_IOV iovs[32];
+    rdb_ROPESEG *segs[32];
+    unsigned niov;
+
+    // Feed 4 bytes into the buffer
+    ior.feed("1234");
+
+    // Make the next 6 bytes consolidated
+    rdb_consolidate(&ior, 6);
+    ior.feed("5678");
+    niov = rdb_refread_ex(&ior, iovs, segs, 3, 8);
+
+    ASSERT_EQ(3, niov);
+    ASSERT_EQ(6, iovs[0].iov_len);
+    ASSERT_EQ(0, memcmp(iovs[0].iov_base, "123456", 6));
+    ASSERT_EQ(*(char *)iovs[1].iov_base, '7');
+    ASSERT_EQ(*(char *)iovs[2].iov_base, '8');
+}
+
+
+// When I was integrating this into LCBIO, I realized this scenario. Trying to
+// figure out what the intended outcome is.
+// Apparently this cannot work because we can't consume a buffer which is also
+// available for reading as this may result in the currently-being-read-into
+// buffer being released.
+TEST_F(RopeTest, DISABLED_testInterleavedReadConsume)
+{
+    IORope ior(rdb_bigalloc_new());
+    ior.rdsize = 256;
+    nb_IOV iov;
+    unsigned niov;
+
+    niov = rdb_rdstart(&ior, &iov, 1);
+    ASSERT_EQ(1, niov);
+    memset(iov.iov_base, '1', 29);
+
+    rdb_rdend(&ior, 29);
+    rdb_consumed(&ior, 24);
+    ASSERT_EQ(5, rdb_get_nused(&ior));
+
+    nb_IOV iov2;
+    niov = rdb_rdstart(&ior, &iov2, 1);
+    ASSERT_EQ(1, niov);
+    ASSERT_EQ(5, rdb_get_nused(&ior));
+
+    rdb_consumed(&ior, 5);
+    ASSERT_EQ(0, rdb_get_nused(&ior));
+
+    rdb_rdend(&ior, 100);
+}

data/ext/libcouchbase/tests/rdb/t_bigalloc.cc

@@ -0,0 +1,93 @@
+#include "rdbtest.h"
+#include <rdb/bigalloc.h>
+class BigallocTest : public ::testing::Test {};
+
+TEST_F(BigallocTest, testBasic)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_BIGALLOC *ba = (rdb_BIGALLOC *)a._inner;
+
+    ASSERT_EQ(0, LCB_CLIST_SIZE(&ba->bufs));
+    ASSERT_EQ(0, ba->n_requests);
+    ASSERT_EQ(0, ba->n_toobig);
+    ASSERT_EQ(0, ba->n_toosmall);
+    ASSERT_EQ(RDB_BIGALLOC_ALLOCSZ_MAX, ba->max_blk_alloc);
+    ASSERT_EQ(RDB_BIGALLOC_ALLOCSZ_MIN, ba->min_blk_alloc);
+    ASSERT_EQ(RDB_BIGALLOC_BLKCNT_MAX, ba->max_blk_count);
+    a.release();
+}
+
+TEST_F(BigallocTest, testTooSmall)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_BIGALLOC *ba = (rdb_BIGALLOC *)a._inner;
+
+    size_t first_size = RDB_BIGALLOC_ALLOCSZ_MIN * 2;
+    rdb_ROPESEG *seg = a.alloc(first_size);
+    a.free(seg);
+
+    ASSERT_EQ(1, LCB_CLIST_SIZE(&ba->bufs));
+    ASSERT_EQ(1, ba->n_requests);
+    ASSERT_EQ(0, ba->n_toobig);
+    ASSERT_EQ(0, ba->n_toosmall);
+
+    rdb_ROPESEG *newseg = a.alloc(first_size);
+    ASSERT_EQ(seg, newseg);
+    a.free(newseg);
+
+    size_t smallsize = RDB_BIGALLOC_ALLOCSZ_MIN / 2;
+    while (ba->n_requests < RDB_BIGALLOC_RECHECK_RATE-1) {
+        newseg = a.alloc(smallsize);
+        a.free(newseg);
+        ASSERT_EQ(seg, newseg); // same pooled one
+        ASSERT_EQ(0, seg->nused);
+        ASSERT_EQ(0, seg->start);
+        memset(seg->root, '*', seg->nalloc);
+        seg->start = seg->nalloc;
+    }
+
+    size_t oldmin = ba->min_blk_alloc, oldmax = ba->max_blk_alloc;
+    // Get one more:
+    newseg = a.alloc(smallsize);
+    ASSERT_EQ(oldmin/2, ba->min_blk_alloc);
+    ASSERT_EQ(oldmax/2, ba->max_blk_alloc);
+    a.free(newseg);
+
+    rdb_bigalloc_dump(ba, stdout);
+    a.release();
+}
+
+TEST_F(BigallocTest, testPooled)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_BIGALLOC *ba = (rdb_BIGALLOC *)a._inner;
+    std::vector<rdb_ROPESEG *> segs;
+    size_t allocsize = 1;
+
+    for (unsigned ii = 0; ii < (ba->max_blk_count * 2); ii++) {
+        rdb_ROPESEG *seg = a.alloc(allocsize);
+        segs.push_back(seg);
+    }
+    rdb_bigalloc_dump(ba, stdout);
+
+    for (unsigned ii = 0; ii < segs.size(); ii++) {
+        a.free(segs[ii]);
+    }
+
+    segs.clear();
+    rdb_bigalloc_dump(ba, stdout);
+    ASSERT_EQ(RDB_BIGALLOC_BLKCNT_MAX, LCB_CLIST_SIZE(&ba->bufs));
+    a.release();
+}
+
+TEST_F(BigallocTest, testRealloc)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_ROPESEG *seg = a.alloc(5);
+    // well, we'll see what we have here
+    size_t cursize = seg->nalloc;
+    seg = a.realloc(seg, cursize+1);
+    ASSERT_GT(seg->nalloc, cursize);
+    a.free(seg);
+    a.release();
+}

data/ext/libcouchbase/tests/rdb/t_refs.cc

@@ -0,0 +1,112 @@
+#include "rdbtest.h"
+#include "list.h"
+
+class RefTest : public ::testing::Test {};
+
+TEST_F(RefTest, testLifecycle)
+{
+    IORope *ior = new IORope(rdb_chunkalloc_new(4));
+    ior->feed("12345678");
+    ASSERT_EQ(8, ior->usedSize());
+
+    nb_IOV iovs[32];
+    rdb_ROPESEG *segs[32];
+
+    unsigned nseg = rdb_refread_ex(ior, iovs, segs, 32, 8);
+    ASSERT_EQ(2, nseg);
+
+    for (unsigned ii = 0; ii < nseg; ii++) {
+        rdb_seg_ref(segs[ii]);
+        ASSERT_NE(0, segs[ii]->shflags & RDB_ROPESEG_F_USER);
+        ASSERT_NE(0, segs[ii]->shflags & RDB_ROPESEG_F_LIB);
+        ASSERT_EQ(1, segs[ii]->refcnt);
+    }
+
+    // Ensure the memory allocated is removed.
+    delete ior;
+
+    ASSERT_EQ(0, memcmp(iovs[0].iov_base, "1234", 4));
+    ASSERT_EQ(0, memcmp(iovs[1].iov_base, "5678", 4));
+    ASSERT_NE(0, segs[0]->shflags & RDB_ROPESEG_F_USER);
+    ASSERT_EQ(0, segs[0]->shflags & RDB_ROPESEG_F_LIB);
+    rdb_seg_unref(segs[0]);
+    rdb_seg_unref(segs[1]);
+}
+
+// Some more blahblah
+TEST_F(RefTest, testCycle2)
+{
+    IORope *ior = new IORope(rdb_chunkalloc_new(10));
+
+    // Read first 3 bytes
+    ior->feed("1234567890A");
+    ReadPacket rp(ior, 3);
+    ASSERT_EQ(1, rp.segments.size());
+    rp.refSegment(0);
+    rdb_consumed(ior, 3);
+    ASSERT_EQ(rp.asString(), "123");
+
+    // Read another 3 bytes
+    ReadPacket rp2(ior, 3);
+    rp2.refSegment(0);
+    rdb_consumed(ior, 3);
+    ASSERT_EQ(rp2.asString(), "456");
+    ASSERT_EQ(1, rp2.segments.size());
+
+    ASSERT_EQ(rp.segments[0], rp2.segments[0]);
+
+    // Allocate a third one, consuming the rest
+    ReadPacket rp3(ior, 5);
+    ASSERT_EQ(2, rp3.segments.size());
+    ASSERT_EQ(rp.segments[0], rp3.segments[0]);
+    ASSERT_EQ(rp3.asString(), "7890A");
+    rp3.refSegment(1);
+    rdb_consumed(ior, 5);
+
+    delete ior;
+
+    rp.unrefSegment(0);
+    rp2.unrefSegment(0);
+    rp3.unrefSegment(1);
+}
+
+
+// See what happens when we try to consolidate buffers as part of an already
+// referenced segment.
+TEST_F(RefTest, testRefConsolidate)
+{
+    IORope *ior = new IORope(rdb_chunkalloc_new(3));
+    ior->feed("123456789");
+    ReadPacket rp(ior, 3);
+    rp.refSegment(0);
+    rdb_consumed(ior, 3);
+    ASSERT_EQ(RDB_ROPESEG_F_USER, rp.segments[0]->shflags);
+
+    rdb_consolidate(ior, 6);
+    ASSERT_NE(RDB_SEG_FIRST(&ior->recvd), rp.segments[0]);
+    ASSERT_EQ(6, ior->recvd.nused);
+    rdb_consumed(ior, 6);
+    rp.unrefSegment(0);
+    delete ior;
+
+    // however we should be using the same segment otherwise..
+    ior = new IORope(rdb_chunkalloc_new(3));
+    ior->feed("123456789");
+    ReadPacket rp2(ior, 3);
+    char *p = rdb_get_consolidated(ior, 6);
+    ASSERT_EQ(0, memcmp(p, "123456", 6));
+    ASSERT_EQ(RDB_SEG_FIRST(&ior->recvd), rp2.segments[0]);
+    ASSERT_EQ(9, ior->recvd.nused);
+    delete ior;
+
+    ior = new IORope(rdb_chunkalloc_new(6));
+    ior->feed("123456789");
+    ReadPacket rp3(ior, 6);
+    rp3.refSegment(0);
+
+    p = rdb_get_consolidated(ior, 9);
+    ASSERT_EQ(0, memcmp(p, "123456789", 9));
+    ASSERT_EQ(9, ior->recvd.nused);
+    rp3.unrefSegment(0);
+    delete ior;
+}

data/ext/libcouchbase/tests/socktests/socktest.cc

@@ -0,0 +1,344 @@
+#undef NDEBUG
+#include "socktest.h"
+#include <lcbio/ssl.h>
+using std::list;
+
+extern "C" {
+static void
+ctx_error(lcbio_CTX *ctx, lcb_error_t err)
+{
+    ESocket *s = (ESocket *) lcbio_ctx_data(ctx);
+    s->lasterr = err;
+    s->actions->onError(s);
+    s->parent->stop();
+}
+
+static void
+ctx_read(lcbio_CTX *ctx, unsigned nr)
+{
+    ESocket *s = (ESocket *) lcbio_ctx_data(ctx);
+    s->actions->onRead(s, nr);
+}
+
+static void
+conn_cb(lcbio_SOCKET *sock, void *data, lcb_error_t err, lcbio_OSERR oserr)
+{
+    ESocket *mysock = (ESocket *)data;
+    mysock->assign(sock, err);
+    mysock->parent->stop();
+    mysock->syserr = oserr;
+    mysock->callCount++;
+}
+
+static void
+ctx_flush_ready(lcbio_CTX *ctx)
+{
+    ESocket *s = (ESocket *) lcbio_ctx_data(ctx);
+    s->actions->onFlushReady(s);
+}
+
+static void
+ctx_flush_done(lcbio_CTX *ctx, unsigned expected, unsigned nr)
+{
+    ESocket *s = (ESocket *) lcbio_ctx_data(ctx);
+    s->actions->onFlushDone(s, expected, nr);
+}
+}
+
+void
+IOActions::onError(ESocket *)
+{
+    // noop for now
+}
+
+void
+IOActions::onRead(ESocket *s, size_t nr)
+{
+    lcbio_CTXRDITER iter;
+    LCBIO_CTX_ITERFOR(s->ctx, &iter, nr) {
+        char *curbuf = (char *)lcbio_ctx_ribuf(&iter);
+        unsigned nbuf = lcbio_ctx_risize(&iter);
+        s->readbuf.insert(s->readbuf.end(), curbuf, curbuf + nbuf);
+    }
+}
+
+IOActions ESocket::defaultActions;
+
+void
+ESocket::assign(lcbio_SOCKET *s, lcb_error_t err)
+{
+    creq = NULL;
+    if (s == NULL) {
+        lasterr = err;
+        return;
+    }
+
+    err = lcbio_sslify_if_needed(s, s->settings);
+    if (err != LCB_SUCCESS) {
+        lasterr = err;
+        return;
+    }
+
+    lcbio_CTXPROCS procs;
+    procs.cb_err = ctx_error;
+    procs.cb_read = ctx_read;
+    procs.cb_flush_done = ctx_flush_done;
+    procs.cb_flush_ready = ctx_flush_ready;
+    sock = s;
+    ctx = lcbio_ctx_new(s, this, &procs);
+}
+
+extern "C" {
+static void
+close_cb(lcbio_SOCKET *s, int reusable, void *arg)
+{
+    (void)arg;
+    if (reusable) {
+        lcbio_ref(s);
+        lcb::io::Pool::put(s);
+    }
+}
+}
+
+void
+ESocket::close()
+{
+    if (!ctx) {
+        return;
+    }
+
+    if (lcb::io::Pool::is_from_pool(ctx->sock)) {
+        lcbio_ctx_close(ctx, close_cb, NULL);
+    } else {
+        lcbio_ctx_close(ctx, NULL, NULL);
+    }
+
+    sock = NULL;
+    ctx = NULL;
+}
+
+class BreakTimer : public Timer {
+public:
+    BreakTimer(Loop *l) : Timer(l->iot) {
+        this->loop = l;
+    }
+
+    void expired() {
+        if (!loop->bcond) {
+            return;
+        }
+        if (loop->bcond->shouldBreak()) {
+            loop->stop();
+        } else {
+            loop->scheduleBreak();
+        }
+    }
+    virtual ~BreakTimer() { }
+private:
+    Loop *loop;
+};
+
+Loop::Loop()
+{
+    io = NULL;
+
+    lcb_error_t rc = lcb_create_io_ops(&io, NULL);
+    assert(rc == LCB_SUCCESS);
+    assert(io != NULL);
+    iot = lcbio_table_new(io);
+    settings = lcb_settings_new();
+    settings->logger = lcb_init_console_logger();
+    server = new TestServer();
+    breakTimer = new BreakTimer(this);
+    bcond = NULL;
+    sockpool = new lcb::io::Pool(settings, iot);
+}
+
+Loop::~Loop()
+{
+    delete breakTimer;
+    delete server;
+    sockpool->shutdown();
+    lcbio_table_unref(iot);
+    lcb_destroy_io_ops(io);
+    lcb_settings_unref(settings);
+}
+
+void
+Loop::scheduleBreak()
+{
+    breakTimer->schedule(2); // 2ms
+}
+
+void
+Loop::cancelBreak()
+{
+    breakTimer->cancel();
+}
+
+void
+Loop::start()
+{
+    if (bcond) {
+        scheduleBreak();
+    }
+    IOT_START(iot);
+    cancelBreak();
+    bcond = NULL;
+}
+
+void
+Loop::stop()
+{
+    cancelBreak();
+    IOT_STOP(iot);
+}
+
+void
+Loop::initSockCommon(ESocket *sock)
+{
+    // Find the peer..
+    struct sockaddr_in *addr = (struct sockaddr_in *)&sock->sock->info->sa_local;
+    uint16_t port = ntohs(addr->sin_port);
+    sock->conn = server->findConnection(port);
+}
+
+void
+Loop::connectPooled(ESocket *sock, lcb_host_t *host, unsigned mstmo)
+{
+    lcb_host_t tmphost = {0};
+    sock->parent = this;
+    if (!host) {
+        populateHost(&tmphost);
+        host = &tmphost;
+    }
+    sock->creq = sockpool->get(*host, LCB_MS2US(mstmo), conn_cb, sock);
+    start();
+    if (sock->sock) {
+        initSockCommon(sock);
+    }
+}
+
+void
+Loop::connect(ESocket *sock, lcb_host_t *host, unsigned mstmo)
+{
+    lcb_host_t tmphost = {0};
+
+    if (host == NULL) {
+        populateHost(&tmphost);
+        host = &tmphost;
+    }
+
+    sock->parent = this;
+    sock->creq = lcbio_connect(
+            iot, settings, host, LCB_MS2US(mstmo), conn_cb, sock);
+
+    start();
+
+    if (sock->sock) {
+        initSockCommon(sock);
+    }
+}
+
+void
+Loop::populateHost(lcb_host_t *host)
+{
+    strcpy(host->host, server->getHostString().c_str());
+    strcpy(host->port, server->getPortString().c_str());
+}
+
+extern "C" {
+static void timerCallback(void *arg)
+{
+    Timer *tm = (Timer *)arg;
+    tm->expired();
+}
+}
+
+Timer::Timer(lcbio_TABLE *iot)
+{
+    timer = lcbio_timer_new(iot, this, timerCallback);
+}
+
+Timer::~Timer()
+{
+    destroy();
+}
+
+void
+Timer::destroy()
+{
+    lcbio_timer_destroy(timer);
+    timer = NULL;
+}
+
+void
+Timer::cancel()
+{
+    lcbio_timer_disarm(timer);
+}
+
+void
+Timer::schedule(unsigned ms)
+{
+    lcbio_timer_rearm(timer, LCB_MS2US(ms));
+}
+
+void
+Timer::signal()
+{
+    schedule(0);
+}
+
+// Conditions
+BreakCondition::BreakCondition()
+{
+    broke = false;
+}
+
+bool
+BreakCondition::shouldBreak()
+{
+    if (shouldBreakImpl()) {
+        broke = true;
+        return true;
+    }
+    return false;
+}
+
+bool
+FlushedBreakCondition::shouldBreakImpl()
+{
+    lcbio_CTX *ctx = sock->ctx;
+    if (ctx->npending) {
+        return false;
+    }
+
+    if (ctx->output && ctx->output->rb.nbytes == 0) {
+        return true;
+    }
+    return false;
+}
+
+bool
+ReadBreakCondition::shouldBreakImpl()
+{
+    lcbio_CTX *ctx = sock->ctx;
+    unsigned unread = rdb_get_nused(&ctx->ior);
+    return unread + sock->getReceived().size() >= expected;
+}
+
+extern "C" {
+static void
+dtor_cb(lcbio_CTX *ctx)
+{
+    CtxCloseBreakCondition *bc = (CtxCloseBreakCondition *)lcbio_ctx_data(ctx);
+    bc->gotDtor();
+}
+}
+void
+CtxCloseBreakCondition::closeCtx()
+{
+    lcbio_ctx_close_ex(s->ctx, NULL, NULL, dtor_cb, this);
+    s->ctx = NULL;
+}