mt-libcouchbase 1.4.0

data/ext/libcouchbase/tests/mc/t_alloc.cc

@@ -0,0 +1,269 @@
+#include "mctest.h"
+
+class McAlloc : public ::testing::Test {
+protected:
+    mc_CMDQUEUE cQueue;
+
+    void setupPipeline(mc_PIPELINE *pipeline) {
+        mcreq_queue_init(&cQueue);
+        mcreq_pipeline_init(pipeline);
+        pipeline->parent = &cQueue;
+    }
+};
+
+TEST_F(McAlloc, testPipelineFreeAlloc)
+{
+    mc_PIPELINE pipeline;
+    memset(&pipeline, 0, sizeof(pipeline));
+    mcreq_pipeline_init(&pipeline);
+    mcreq_pipeline_cleanup(&pipeline);
+}
+
+TEST_F(McAlloc, testPacketFreeAlloc)
+{
+    mc_PIPELINE pipeline;
+    mc_PACKET *copied = NULL;
+    memset(&pipeline, 0, sizeof(pipeline));
+    setupPipeline(&pipeline);
+
+    mc_PACKET *packet = mcreq_allocate_packet(&pipeline);
+    ASSERT_TRUE(packet != NULL);
+
+    mcreq_reserve_header(&pipeline, packet, 24);
+
+    // Check to see that we can also detach a packet and use it after the
+    // other resources have been released
+    copied = mcreq_renew_packet(packet);
+
+
+    mcreq_wipe_packet(&pipeline, packet);
+    mcreq_release_packet(&pipeline, packet);
+    mcreq_pipeline_cleanup(&pipeline);
+
+    // Write to the detached packet. Ensure we don't crash
+    memset(SPAN_BUFFER(&copied->kh_span), 0xff, copied->kh_span.size);
+    mcreq_wipe_packet(NULL, copied);
+    mcreq_release_packet(NULL, copied);
+}
+
+struct dummy_datum {
+    mc_EPKTDATUM base;
+    int refcount;
+};
+extern "C" {
+static void datum_free(mc_EPKTDATUM *epd) {
+    dummy_datum *dd = (dummy_datum *)epd;
+    dd->refcount--;
+}
+}
+
+TEST_F(McAlloc, testExdataAlloc)
+{
+    mc_PIPELINE pipeline;
+    mc_PACKET *copy1, *copy2;
+    setupPipeline(&pipeline);
+    mc_PACKET *packet = mcreq_allocate_packet(&pipeline);
+    mcreq_reserve_header(&pipeline, packet, 24);
+
+    copy1 = mcreq_renew_packet(packet);
+    ASSERT_FALSE((copy1->flags & MCREQ_F_DETACHED) == 0);
+
+    dummy_datum dd;
+    dd.base.key = "Dummy";
+    dd.base.dtorfn = datum_free;
+    dd.refcount = 1;
+    mcreq_epkt_insert((mc_EXPACKET*)copy1, &dd.base);
+    // Find it back
+    mc_EPKTDATUM *epd = mcreq_epkt_find((mc_EXPACKET*)copy1, "Dummy");
+    ASSERT_FALSE(epd == NULL);
+    ASSERT_TRUE(epd == &dd.base);
+
+    copy2 = mcreq_renew_packet(copy1);
+    epd = mcreq_epkt_find((mc_EXPACKET*)copy1, "Dummy");
+    ASSERT_TRUE(epd == NULL);
+    epd = mcreq_epkt_find((mc_EXPACKET*)copy2, "Dummy");
+    ASSERT_FALSE(epd == NULL);
+
+    mcreq_wipe_packet(&pipeline, packet);
+    mcreq_release_packet(&pipeline, packet);
+    mcreq_wipe_packet(NULL, copy1);
+    mcreq_release_packet(NULL, copy1);
+    mcreq_wipe_packet(NULL, copy2);
+    mcreq_release_packet(NULL, copy2);
+    ASSERT_EQ(0, dd.refcount);
+    mcreq_pipeline_cleanup(&pipeline);
+}
+
+
+TEST_F(McAlloc, testKeyAlloc)
+{
+    CQWrap q;
+    mc_PACKET *packet;
+    mc_PIPELINE *pipeline;
+    lcb_CMDBASE cmd;
+
+    protocol_binary_request_header hdr;
+    memset(&cmd, 0, sizeof(cmd));
+    memset(&hdr, 0, sizeof(hdr));
+
+    cmd.key.contig.bytes = const_cast<char *>("Hello");
+    cmd.key.contig.nbytes = 5;
+
+    lcb_error_t ret;
+    ret = mcreq_basic_packet(&q, &cmd, &hdr, 0, &packet, &pipeline, 0);
+    ASSERT_EQ(LCB_SUCCESS, ret);
+    ASSERT_TRUE(packet != NULL);
+    ASSERT_TRUE(pipeline != NULL);
+    ASSERT_EQ(5, ntohs(hdr.request.keylen));
+
+    int vb = lcbvb_k2vb(q.config, "Hello", 5);
+    ASSERT_EQ(vb, ntohs(hdr.request.vbucket));
+
+    // Copy the header
+    memcpy(SPAN_BUFFER(&packet->kh_span), &hdr, sizeof(hdr));
+
+    lcb_VALBUF vreq;
+    memset(&vreq, 0, sizeof(vreq));
+
+    const void *key;
+    lcb_size_t nkey;
+    // Get back the key we just placed inside the header
+    mcreq_get_key(packet, &key, &nkey);
+    ASSERT_EQ(5, nkey);
+    ASSERT_EQ(0, memcmp(key, "Hello", 5));
+
+    mcreq_wipe_packet(pipeline, packet);
+    mcreq_release_packet(pipeline, packet);
+}
+
+TEST_F(McAlloc, testValueAlloc)
+{
+    CQWrap q;
+    mc_PACKET *packet;
+    mc_PIPELINE *pipeline;
+    lcb_CMDBASE cmd;
+    protocol_binary_request_header hdr;
+    lcb_VALBUF vreq;
+
+    memset(&cmd, 0, sizeof(cmd));
+    memset(&hdr, 0, sizeof(hdr));
+    memset(&vreq, 0, sizeof(vreq));
+
+    const char *key = "Hello";
+    const char *value = "World";
+
+
+    lcb_error_t ret;
+    cmd.key.contig.bytes = const_cast<char *>(key);
+    cmd.key.contig.nbytes = 5;
+    vreq.u_buf.contig.bytes = const_cast<char *>(value);
+    vreq.u_buf.contig.nbytes = 5;
+
+    ret = mcreq_basic_packet(&q, &cmd, &hdr, 0, &packet, &pipeline, 0);
+    ASSERT_EQ(LCB_SUCCESS, ret);
+    ret = mcreq_reserve_value(pipeline, packet, &vreq);
+    ASSERT_EQ(ret, LCB_SUCCESS);
+    ASSERT_EQ(packet->flags, MCREQ_F_HASVALUE);
+
+    ASSERT_EQ(0, memcmp(SPAN_BUFFER(&packet->u_value.single), value, 5));
+    ASSERT_NE(SPAN_BUFFER(&packet->u_value.single), value);
+    mcreq_wipe_packet(pipeline, packet);
+    mcreq_release_packet(pipeline, packet);
+
+    // Allocate another packet, but this time, use our own reserved value
+    ret = mcreq_basic_packet(&q, &cmd, &hdr, 0, &packet, &pipeline, 0);
+    ASSERT_EQ(ret, LCB_SUCCESS);
+    vreq.vtype = LCB_KV_CONTIG;
+    ret = mcreq_reserve_value(pipeline, packet, &vreq);
+    ASSERT_EQ(SPAN_BUFFER(&packet->u_value.single), value);
+    ASSERT_EQ(MCREQ_F_HASVALUE|MCREQ_F_VALUE_NOCOPY, packet->flags);
+    mcreq_wipe_packet(pipeline, packet);
+    mcreq_release_packet(pipeline, packet);
+
+
+    nb_IOV iov[2];
+    iov[0].iov_base = (void *)value;
+    iov[0].iov_len = 3;
+    iov[1].iov_base = (void *)(value + 3);
+    iov[1].iov_len = 2;
+
+    vreq.u_buf.multi.iov = (lcb_IOV *)iov;
+    vreq.u_buf.multi.niov = 2;
+    vreq.vtype = LCB_KV_IOV;
+    ret = mcreq_basic_packet(&q, &cmd, &hdr, 0, &packet, &pipeline, 0);
+    ASSERT_EQ(LCB_SUCCESS, ret);
+    ret = mcreq_reserve_value(pipeline, packet, &vreq);
+    ASSERT_EQ(LCB_SUCCESS, ret);
+    ASSERT_EQ(MCREQ_F_HASVALUE|MCREQ_F_VALUE_IOV|MCREQ_F_VALUE_NOCOPY,
+              packet->flags);
+    ASSERT_NE(&iov[0], (nb_IOV *)packet->u_value.multi.iov);
+    ASSERT_EQ(2, packet->u_value.multi.niov);
+    ASSERT_EQ(5, packet->u_value.multi.total_length);
+    mcreq_wipe_packet(pipeline, packet);
+    mcreq_release_packet(pipeline, packet);
+
+    iov[0].iov_base = (void *)value;
+    iov[0].iov_len = 3;
+    iov[1].iov_base = (void *)(value + 3);
+    iov[1].iov_len = 2;
+    vreq.u_buf.multi.iov = (lcb_IOV *)iov;
+    vreq.u_buf.multi.niov = 2;
+    vreq.u_buf.multi.total_length = 0;
+
+    vreq.vtype = LCB_KV_IOVCOPY;
+    ret = mcreq_basic_packet(&q, &cmd, &hdr, 0, &packet, &pipeline, 0);
+    ASSERT_EQ(LCB_SUCCESS, ret);
+
+    ret = mcreq_reserve_value(pipeline, packet, &vreq);
+    ASSERT_EQ(LCB_SUCCESS, ret);
+
+    ASSERT_EQ(MCREQ_F_HASVALUE, packet->flags);
+    ASSERT_EQ(0, memcmp(SPAN_BUFFER(&packet->u_value.single), value, 5));
+    mcreq_wipe_packet(pipeline, packet);
+    mcreq_release_packet(pipeline, packet);
+}
+
+struct ExtraCookie : mc_REQDATAEX {
+    int remaining;
+    ExtraCookie(const mc_REQDATAPROCS& procs_)
+        : mc_REQDATAEX(NULL, procs_, 0), remaining(0) {
+    }
+};
+
+extern "C" {
+static void pkt_dtor(mc_PACKET *pkt) {
+    ExtraCookie *ec = static_cast<ExtraCookie*>(pkt->u_rdata.exdata);
+    ec->remaining--;
+}
+}
+
+TEST_F(McAlloc, testRdataExDtor)
+{
+    CQWrap q;
+    lcb_CMDBASE basecmd;
+    const static mc_REQDATAPROCS procs = { NULL, pkt_dtor };
+    protocol_binary_request_header hdr;
+
+    memset(&hdr, 0, sizeof hdr);
+    memset(&basecmd, 0, sizeof basecmd);
+
+    basecmd.key.contig.bytes = "foo";
+    basecmd.key.contig.nbytes = 3;
+
+    ExtraCookie ec(procs);
+
+    mcreq_sched_enter(&q);
+    for (unsigned ii = 0; ii < 5; ii++) {
+        lcb_error_t err;
+        mc_PIPELINE *pl;
+        mc_PACKET *pkt;
+        err = mcreq_basic_packet(&q, &basecmd, &hdr, 0, &pkt, &pl, 0);
+        ASSERT_EQ(LCB_SUCCESS, err);
+        pkt->flags |= MCREQ_F_REQEXT;
+        pkt->u_rdata.exdata = &ec;
+        mcreq_sched_add(pl, pkt);
+        ec.remaining++;
+    }
+    mcreq_sched_fail(&q);
+    ASSERT_EQ(0, ec.remaining);
+}

data/ext/libcouchbase/tests/mc/t_context.cc

@@ -0,0 +1,100 @@
+#include "mctest.h"
+#include "mc/mcreq-flush-inl.h"
+
+class McContext : public ::testing::Test {};
+
+struct CtxCookie {
+    int ncalled;
+    size_t plLength;
+    CtxCookie() : ncalled(0), plLength(0) {}
+};
+
+extern "C" {
+static void failcb(mc_PIPELINE *, mc_PACKET *pkt, lcb_error_t, void *)
+{
+    CtxCookie *cookie = (CtxCookie *)MCREQ_PKT_COOKIE(pkt);
+    cookie->ncalled++;
+    cookie->plLength += mcreq_get_size(pkt);
+}
+}
+
+TEST_F(McContext, testBasicContext)
+{
+    CQWrap cq;
+    CtxCookie cookie;
+
+    mcreq_sched_enter(&cq);
+
+    for (int ii = 0; ii < 20; ii++) {
+        PacketWrap pw;
+        char kbuf[128];
+        sprintf(kbuf, "key_%d", ii);
+        pw.setCopyKey(kbuf);
+
+        ASSERT_TRUE(pw.reservePacket(&cq));
+
+        pw.setHeaderSize();
+        pw.copyHeader();
+        pw.setCookie(&cookie);
+
+        mcreq_sched_add(pw.pipeline, pw.pkt);
+        ASSERT_FALSE(SLLIST_IS_EMPTY(&pw.pipeline->requests) == 0);
+        ASSERT_TRUE(SLLIST_IS_EMPTY(&pw.pipeline->ctxqueued) == 0);
+    }
+
+    mcreq_sched_fail(&cq);
+
+    for (unsigned ii = 0; ii < cq.npipelines; ii++) {
+        unsigned nFail = 0;
+        mc_PIPELINE *pl = cq.pipelines[ii];
+        cookie.plLength = 0;
+
+        nFail = mcreq_pipeline_fail(pl, LCB_ERROR, failcb, NULL);
+        if (!nFail) {
+            continue;
+        }
+
+        nb_IOV iov[50];
+        unsigned toFlush;
+        toFlush = mcreq_flush_iov_fill(pl, iov, 50, NULL);
+        ASSERT_EQ(cookie.plLength, toFlush);
+        mcreq_flush_done(pl, toFlush, toFlush);
+    }
+}
+
+TEST_F(McContext, testFailedContext)
+{
+    CQWrap cq;
+    CtxCookie cookie;
+
+    mcreq_sched_enter(&cq);
+
+    for (int ii = 0; ii < 20; ii++) {
+        PacketWrap pw;
+        char kbuf[128];
+        sprintf(kbuf, "Key_%d", ii);
+        pw.setCopyKey(kbuf);
+
+        ASSERT_TRUE(pw.reservePacket(&cq));
+
+        pw.setHeaderSize();
+        pw.copyHeader();
+        mcreq_sched_add(pw.pipeline, pw.pkt);
+    }
+
+    mcreq_sched_fail(&cq);
+
+    for (unsigned ii = 0; ii < cq.npipelines; ii++) {
+        mc_PIPELINE *pl = cq.pipelines[ii];
+        if (!cq.scheds[pl->index]) {
+            continue;
+        }
+
+
+        ASSERT_TRUE(SLLIST_IS_EMPTY(&pl->requests));
+        ASSERT_TRUE(SLLIST_IS_EMPTY(&pl->ctxqueued));
+
+        nb_IOV iov[1];
+        ASSERT_EQ(0, mcreq_flush_iov_fill(pl, iov, 1, NULL));
+    }
+}

data/ext/libcouchbase/tests/mc/t_flush.cc

@@ -0,0 +1,185 @@
+#include "mctest.h"
+#include "mc/mcreq-flush-inl.h"
+
+class McFlush : public ::testing::Test {};
+
+struct MyCookie {
+    int ncalled;
+    void *exp_kbuf;
+    MyCookie() : ncalled(0), exp_kbuf(NULL) {}
+};
+
+extern "C" {
+static void
+buf_free_callback(mc_PIPELINE *, const void *cookie, void *kbuf, void *vbuf)
+{
+    MyCookie *ck = (MyCookie *)cookie;
+    EXPECT_TRUE(kbuf == ck->exp_kbuf);
+    ck->ncalled++;
+}
+}
+
+TEST_F(McFlush, testBasicFlush)
+{
+    CQWrap cq;
+    PacketWrap pw;
+
+    cq.setBufFreeCallback(buf_free_callback);
+    pw.setContigKey("1234");
+    ASSERT_TRUE(pw.reservePacket(&cq));
+
+    MyCookie cookie;
+    cookie.exp_kbuf = pw.pktbuf;
+
+    pw.setCookie(&cookie);
+    pw.setHeaderSize();
+    pw.copyHeader();
+    mcreq_enqueue_packet(pw.pipeline, pw.pkt);
+    mcreq_packet_handled(pw.pipeline, pw.pkt);
+
+    nb_IOV iovs[10];
+
+    unsigned toFlush = mcreq_flush_iov_fill(pw.pipeline, iovs, 10, NULL);
+    EXPECT_EQ(28, toFlush);
+    mcreq_flush_done(pw.pipeline, 8, toFlush);
+
+    toFlush = mcreq_flush_iov_fill(pw.pipeline, iovs, 10, NULL);
+    EXPECT_EQ(20, toFlush);
+    mcreq_flush_done(pw.pipeline, toFlush, toFlush);
+
+    toFlush = mcreq_flush_iov_fill(pw.pipeline, iovs, 10, NULL);
+    ASSERT_EQ(0, toFlush);
+    ASSERT_EQ(1, cookie.ncalled);
+}
+
+TEST_F(McFlush, testFlushedUnhandled)
+{
+    CQWrap cq;
+    PacketWrap pw;
+    cq.setBufFreeCallback(buf_free_callback);
+    pw.setContigKey("1234");
+
+    MyCookie cookie;
+    cookie.exp_kbuf = pw.pktbuf;
+
+    ASSERT_TRUE(pw.reservePacket(&cq));
+    pw.setCookie(&cookie);
+    pw.setHeaderSize();
+    pw.copyHeader();
+
+    mcreq_enqueue_packet(pw.pipeline, pw.pkt);
+
+    nb_IOV iovs[10];
+    unsigned toFlush = mcreq_flush_iov_fill(pw.pipeline, iovs, 10, NULL);
+    ASSERT_EQ(28, toFlush);
+    mcreq_flush_done(pw.pipeline, toFlush, toFlush);
+
+    ASSERT_EQ(0, cookie.ncalled);
+    ASSERT_NE(0, pw.pkt->flags & MCREQ_F_FLUSHED);
+
+    ASSERT_EQ(pw.pkt, mcreq_pipeline_remove(pw.pipeline, pw.pkt->opaque));
+    mcreq_packet_handled(pw.pipeline, pw.pkt);
+    ASSERT_EQ(1, cookie.ncalled);
+}
+
+TEST_F(McFlush, testFlushCopy)
+{
+    CQWrap cq;
+    PacketWrap pw;
+    cq.setBufFreeCallback(buf_free_callback);
+    pw.setCopyKey("Hello");
+    ASSERT_TRUE(pw.reservePacket(&cq));
+
+    MyCookie cookie;
+    pw.setHeaderSize();
+    pw.copyHeader();
+    pw.setCookie(&cookie);
+    mcreq_enqueue_packet(pw.pipeline, pw.pkt);
+
+    nb_IOV iov[10];
+    unsigned int toFlush = mcreq_flush_iov_fill(pw.pipeline, iov, 10, NULL);
+    mcreq_flush_done(pw.pipeline, toFlush, toFlush);
+    mcreq_pipeline_remove(pw.pipeline, pw.pkt->opaque);
+    mcreq_packet_handled(pw.pipeline, pw.pkt);
+    ASSERT_EQ(0, cookie.ncalled);
+}
+
+
+TEST_F(McFlush, testMultiFlush)
+{
+    CQWrap cq;
+    int counter = 0;
+    const int nitems = 10;
+    MyCookie **cookies;
+
+    cookies = new MyCookie*[nitems];
+    PacketWrap **pws = new PacketWrap*[nitems];
+    cq.setBufFreeCallback(buf_free_callback);
+
+    for (int ii = 0; ii < nitems; ii++) {
+        PacketWrap *pw = new PacketWrap;
+        pws[ii] = pw;
+        char curkey[128];
+        sprintf(curkey, "Key_%d", ii);
+        pw->setContigKey(curkey);
+
+        cookies[ii] = new MyCookie;
+        cookies[ii]->exp_kbuf = pw->pktbuf;
+
+        ASSERT_TRUE(pw->reservePacket(&cq));
+
+        pw->setCookie(cookies[ii]);
+        mcreq_enqueue_packet(pw->pipeline, pw->pkt);
+        pw->setHeaderSize();
+        pw->copyHeader();
+        mcreq_packet_handled(pw->pipeline, pw->pkt);
+        mcreq_pipeline_remove(pw->pipeline, pw->pkt->opaque);
+    }
+
+    for (unsigned ii = 0; ii < cq.npipelines; ii++) {
+        mc_PIPELINE *pipeline = cq.pipelines[ii];
+        nb_IOV iov[10];
+        unsigned toFlush = mcreq_flush_iov_fill(pipeline, iov, 10, NULL);
+        if (toFlush) {
+            mcreq_flush_done(pipeline, toFlush, toFlush);
+        }
+    }
+
+    for (int ii = 0; ii < nitems; ii++) {
+        ASSERT_EQ(1, cookies[ii]->ncalled);
+        delete cookies[ii];
+        delete pws[ii];
+    }
+    delete[] cookies;
+    delete[] pws;
+}
+
+TEST_F(McFlush, testPartialFlush)
+{
+    CQWrap cq;
+    PacketWrap pw;
+    MyCookie cookie;
+
+    cq.setBufFreeCallback(buf_free_callback);
+    pw.setContigKey("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    ASSERT_TRUE(pw.reservePacket(&cq));
+    pw.setCookie(&cookie);
+    cookie.exp_kbuf = pw.pktbuf;
+    pw.setHeaderSize();
+    pw.copyHeader();
+    mcreq_enqueue_packet(pw.pipeline, pw.pkt);
+
+    nb_IOV iov[1];
+    unsigned int toFlush = 0;
+    do {
+        toFlush = mcreq_flush_iov_fill(pw.pipeline, iov, 1, NULL);
+        if (toFlush) {
+            mcreq_flush_done(pw.pipeline, 1, toFlush);
+        }
+    } while (toFlush > 0);
+
+    ASSERT_NE(0, pw.pkt->flags & MCREQ_F_FLUSHED);
+    mcreq_pipeline_remove(pw.pipeline, pw.pkt->opaque);
+    mcreq_packet_handled(pw.pipeline, pw.pkt);
+    ASSERT_EQ(1, cookie.ncalled);
+}