mt-libcouchbase 1.4.0

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

@@ -0,0 +1,239 @@
+#include "mctest.h"
+#include "mc/mcreq-flush-inl.h"
+#include "mc/forward.h"
+#include "pktmaker.h"
+
+using namespace PacketMaker;
+using std::vector;
+using std::string;
+
+struct Vars {
+    mc_PACKET *pkt;
+    mc_PIPELINE *pl;
+    nb_IOV iovs[10];
+    mc_IOVINFO ioi;
+    vector<char> reqbuf;
+
+    Vars() {
+        pkt = NULL;
+        pl = NULL;
+        memset(&ioi, 0, sizeof(ioi));
+        memset(&iovs, 0, sizeof(iovs));
+    }
+
+    lcb_error_t requestPacket(mc_CMDQUEUE *cq) {
+        return mc_forward_packet(cq, &ioi, &pkt, &pl, 0);
+    }
+
+    void initInfo() {
+        mc_iovinfo_init(&ioi, iovs, 10);
+    }
+};
+
+class McFwd : public ::testing::Test {};
+
+static void
+setupRequestBuf(vector<char>& out, size_t nkey, size_t nval)
+{
+    string k(nkey, 'K');
+    string v(nval, 'V');
+    StorageRequest sr(k, v);
+    out.clear();
+    sr.serialize(out);
+    EXPECT_EQ(nkey + nval + 24, out.size());
+}
+
+TEST_F(McFwd, testForwardSingle)
+{
+    CQWrap cq;
+    StorageRequest sr(string("fookey"), string("foovalue"));
+
+    mc_IOVINFO iovinfo;
+
+    nb_IOV iovs[10];
+    // Enqueue first packet inside entire body.
+    vector<char> reqbody;
+    sr.serialize(reqbody);
+
+    memset(iovs, 0, sizeof(iovs));
+    memset(&iovinfo, 0, sizeof(iovinfo));
+    mc_iovinfo_init(&iovinfo, iovs, 10);
+    ASSERT_EQ(10, iovinfo.c.niov);
+    ASSERT_EQ(&iovs[0], iovinfo.c.iov);
+    ASSERT_NE(0, reqbody.size());
+
+    iovs->iov_base = &reqbody[0];
+    iovs->iov_len = reqbody.size();
+    iovinfo.total = reqbody.size();
+
+    mc_PACKET *pkt = NULL;
+    mc_PIPELINE *pl = NULL;
+    lcb_error_t rc = mc_forward_packet(&cq, &iovinfo, &pkt, &pl, 0);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_EQ(0, iovinfo.wanted);
+    ASSERT_EQ(reqbody.size(), iovinfo.consumed);
+    ASSERT_EQ(9, iovinfo.c.niov);
+    ASSERT_EQ(0, iovinfo.c.offset);
+    mcreq_sched_fail(&cq);
+}
+
+TEST_F(McFwd, testFragmentedBasic)
+{
+    CQWrap cq;
+    nb_IOV iovs[10];
+    vector<char> reqbuf;
+
+    memset(iovs, 0, sizeof(iovs));
+    setupRequestBuf(reqbuf, 10, 10);
+
+    iovs[0].iov_base = &reqbuf[0];
+    iovs[0].iov_len = 34;
+
+    iovs[1].iov_base = &reqbuf[34];
+    iovs[1].iov_len = 10;
+
+    mc_IOVINFO ioi;
+    memset(&ioi, 0, sizeof(ioi));
+    mc_iovinfo_init(&ioi, iovs, 10);
+    lcb_error_t rc;
+    mc_PACKET *pkt;
+    mc_PIPELINE *pl;
+
+    rc = mc_forward_packet(&cq, &ioi, &pkt, &pl, 0);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_EQ(0, ioi.wanted);
+    ASSERT_EQ(44, ioi.consumed);
+    ASSERT_EQ(0, ioi.c.offset);
+    ASSERT_EQ(8, ioi.c.niov);
+    ASSERT_EQ(0, ioi.c.iov[0].iov_len);
+    mcreq_sched_fail(&cq);
+}
+
+TEST_F(McFwd, testFragmentedHeader) {
+    CQWrap cq;
+    Vars vars;
+
+    setupRequestBuf(vars.reqbuf, 100, 100);
+    vars.iovs[0].iov_base = &vars.reqbuf[0];
+    vars.iovs[0].iov_len = 10;
+
+    vars.iovs[1].iov_base = &vars.reqbuf[10];
+    vars.iovs[1].iov_len = 10;
+
+    vars.iovs[2].iov_base = &vars.reqbuf[20];
+    vars.iovs[2].iov_len = vars.reqbuf.size() - 20;
+    vars.initInfo();
+    ASSERT_EQ(vars.reqbuf.size(), vars.ioi.total);
+
+    lcb_error_t rc = vars.requestPacket(&cq);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_EQ(0, vars.pkt->flags & MCREQ_F_KEY_NOCOPY);
+    ASSERT_EQ(0, vars.ioi.total);
+    ASSERT_EQ(0, vars.ioi.c.offset);
+    ASSERT_EQ(vars.reqbuf.size(), vars.ioi.consumed);
+    ASSERT_EQ(0, vars.ioi.c.iov[0].iov_len);
+    ASSERT_EQ(7, vars.ioi.c.niov);
+
+    mcreq_sched_fail(&cq);
+}
+
+TEST_F(McFwd, testInsufficientHeader)
+{
+    CQWrap cq;
+    Vars vars;
+    lcb_error_t rc;
+
+    setupRequestBuf(vars.reqbuf, 100, 100);
+
+    // Test with no data
+    vars.iovs[0].iov_base = NULL;
+    vars.iovs[0].iov_len = 0;
+    vars.initInfo();
+    rc = vars.requestPacket(&cq);
+    ASSERT_EQ(LCB_INCOMPLETE_PACKET, rc);
+    ASSERT_EQ(24, vars.ioi.wanted);
+
+    // Test with partial (but incomplete header)
+    vars.iovs[0].iov_base = &vars.reqbuf[0];
+    vars.iovs[0].iov_len = 20;
+    vars.initInfo();
+    rc = vars.requestPacket(&cq);
+    ASSERT_EQ(LCB_INCOMPLETE_PACKET, rc);
+    ASSERT_EQ(24, vars.ioi.wanted);
+
+    // Test with full header but partial key
+    vars.iovs[0].iov_base = &vars.reqbuf[0];
+    vars.iovs[0].iov_len = 30;
+    vars.initInfo();
+    rc = vars.requestPacket(&cq);
+    ASSERT_EQ(rc, LCB_INCOMPLETE_PACKET);
+    ASSERT_EQ(vars.reqbuf.size(), vars.ioi.wanted);
+}
+
+TEST_F(McFwd, testMultiValue)
+{
+    CQWrap cq;
+    Vars vars;
+    lcb_error_t rc;
+    setupRequestBuf(vars.reqbuf, 1, 810);
+
+    vars.iovs[0].iov_base = &vars.reqbuf[0];
+    vars.iovs[0].iov_len = 25;
+
+    for (int ii = 1; ii < 10; ii++) {
+        vars.iovs[ii].iov_base = &vars.reqbuf[25 + (ii-1) * 90];
+        vars.iovs[ii].iov_len = 90;
+    }
+
+    vars.initInfo();
+    ASSERT_EQ(835, vars.reqbuf.size());
+    ASSERT_EQ(835, vars.ioi.total);
+
+    rc = vars.requestPacket(&cq);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_NE(0, vars.pkt->flags & MCREQ_F_VALUE_IOV);
+    mcreq_sched_fail(&cq);
+
+    // Eh, let's check these other nifty things. Why not?
+    ASSERT_EQ(0, vars.ioi.wanted);
+    ASSERT_EQ(0, vars.ioi.c.niov);
+}
+
+TEST_F(McFwd, testNoMap)
+{
+    CQWrap cq;
+    lcb_error_t err;
+    protocol_binary_request_header hdr;
+    memset(&hdr, 0, sizeof hdr);
+    hdr.request.magic = PROTOCOL_BINARY_REQ;
+    hdr.request.opcode = 0x50;
+    hdr.request.extlen = 8;
+    hdr.request.bodylen = htonl(8);
+    hdr.request.vbucket = 0;
+    char reqbuf[32] = { 0 };
+    memcpy(reqbuf, hdr.bytes, sizeof hdr.bytes);
+    mc_IOVINFO ioi;
+    nb_IOV iov;
+    iov.iov_base = reqbuf;
+    iov.iov_len = sizeof reqbuf;
+    mc_iovinfo_init(&ioi, &iov, 1);
+
+    mc_PACKET *pkt_tmp;
+    mc_PIPELINE *pl_tmp = cq.pipelines[0];
+    err = mc_forward_packet(&cq, &ioi, &pkt_tmp, &pl_tmp, MC_FWD_OPT_NOMAP);
+
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_NE(0, pkt_tmp->flags & MCREQ_F_UFWD);
+
+    // Get the key
+    const void *key;
+    lcb_SIZE nkey;
+    mcreq_get_key(pkt_tmp, &key, &nkey);
+    ASSERT_EQ(0, nkey);
+
+    // Ensure we have no vBucket stamping
+    protocol_binary_request_header hdr2;
+    mcreq_read_hdr(pkt_tmp, &hdr2);
+    ASSERT_EQ(0, hdr2.request.vbucket);
+    mcreq_sched_fail(&cq);
+}

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

@@ -0,0 +1,102 @@
+#include "mctest.h"
+#include "mc/mcreq-flush-inl.h"
+#include <vector>
+#include <map>
+
+using std::vector;
+using std::map;
+
+/**
+ * Note that this file doesn't actually do any I/O, but simulates I/O patterns
+ * more realistically than t_flush would. This is basically a more advanced
+ * version which handles multiple I/O models and does stricter checking on
+ * items.
+ */
+
+struct Context {
+    int ncalled;
+    map<void *, int> children;
+    Context() {
+        ncalled = 0;
+    }
+};
+
+struct IOCookie {
+    Context *parent;
+    mc_PACKET *pkt;
+    IOCookie(Context *p) {
+        parent = p;
+        pkt = NULL;
+    }
+};
+
+extern "C" {
+static void failcb(mc_PIPELINE *, mc_PACKET *pkt, lcb_error_t, void*)
+{
+    IOCookie *ioc = (IOCookie *)MCREQ_PKT_COOKIE(pkt);
+    ioc->parent->children[ioc]++;
+    ioc->parent->ncalled++;
+    delete ioc;
+}
+}
+
+class McIOFlush : public ::testing::Test {};
+
+struct FlushInfo {
+    mc_PIPELINE *pipeline;
+    mc_PACKET *pkt;
+    unsigned size;
+};
+
+// Test flushing using an IOCP pattern; with multiple items
+// at the end and the beginning.
+TEST_F(McIOFlush, testIOCPFlush)
+{
+    vector<FlushInfo> flushes;
+    CQWrap cq;
+    const int count = 20;
+    Context ctx;
+
+    for (int ii = 0; ii < count; ii++) {
+        char buf[128];
+        sprintf(buf, "Key_%d", ii);
+        PacketWrap pw;
+        pw.setCopyKey(buf);
+        ASSERT_TRUE(pw.reservePacket(&cq));
+        pw.setHeaderSize();
+        pw.copyHeader();
+
+        IOCookie *c = new IOCookie(&ctx);
+        c->pkt = pw.pkt;
+
+        pw.setCookie(c);
+        mcreq_enqueue_packet(pw.pipeline, pw.pkt);
+
+        nb_IOV iov[1];
+        unsigned toFlush = mcreq_flush_iov_fill(pw.pipeline, iov, 1, NULL);
+
+        FlushInfo fi;
+        fi.pipeline = pw.pipeline;
+        fi.size = toFlush;
+        fi.pkt = pw.pkt;
+
+        flushes.push_back(fi);
+    }
+
+    for (unsigned ii = 0; ii < cq.npipelines; ii++) {
+        mcreq_pipeline_fail(cq.pipelines[ii], LCB_ERROR, failcb, NULL);
+    }
+
+    ASSERT_EQ(count, flushes.size());
+    for (unsigned ii = 0; ii < count; ii++) {
+        FlushInfo& fi = flushes[ii];
+        ASSERT_NE(0, fi.pkt->flags & MCREQ_F_INVOKED);
+        mcreq_flush_done(flushes[ii].pipeline, flushes[ii].size, flushes[ii].size);
+    }
+
+    ASSERT_EQ(count, ctx.ncalled);
+    map<void*,int>::iterator iter = ctx.children.begin();
+    for (; iter != ctx.children.end(); ++iter) {
+        ASSERT_EQ(1, iter->second);
+    }
+}

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

@@ -0,0 +1,173 @@
+#include <stdio.h>
+#include "mctest.h"
+#include "mc/iovcursor-inl.h"
+#include "mc/forward.h"
+class McIOVC : public ::testing::Test
+{
+};
+
+TEST_F(McIOVC, testPeekCopy)
+{
+    nb_IOV iov;
+    iov.iov_base = (void*)"ABCDEF";
+    iov.iov_len = strlen((const char*)iov.iov_base);
+    mc_IOVINFO cursor;
+    mc_IOVCURSOR *mincur = &cursor.c;
+    mc_iovinfo_init(&cursor, &iov, 1);
+
+    // basic sanity
+    ASSERT_EQ(0, mincur->offset);
+    ASSERT_EQ(6, cursor.total);
+    ASSERT_EQ(1, mincur->niov);
+    ASSERT_EQ(&iov, mincur->iov);
+
+    char buf[256] = { 0 };
+    // test basic peek
+    iovcursor_peek(mincur, buf, 3, 0);
+    ASSERT_STREQ("ABC", buf);
+
+    memset(buf, 0, sizeof buf);
+    iovcursor_peek(mincur, buf, 3, 3);
+    ASSERT_STREQ("DEF", buf);
+
+    memset(buf, 0, sizeof buf);
+    iovcursor_peek(mincur, buf, 1, 5);
+    ASSERT_STREQ("F", buf);
+}
+
+TEST_F(McIOVC, testPeekEx)
+{
+    nb_IOV iov[3];
+    iov[0].iov_base = (void*)"ABC";
+    iov[0].iov_len = 3;
+    iov[1].iov_base = (void*)"DEF";
+    iov[1].iov_len = 3;
+    iov[2].iov_base = (void*)"GHI";
+    iov[2].iov_len = 3;
+
+    iovcursor_STATUS status;
+    mc_IOVINFO cursor;
+    mc_IOVCURSOR *mincur = &cursor.c;
+    mc_iovinfo_init(&cursor, iov, 3);
+
+    const char *contigptr;
+    char cptgt[256] = { 0 };
+
+    // Simple case
+    status = iovcursor_peek_ex(mincur, cptgt, NULL, 9, 0);
+    ASSERT_EQ(IOVCURSOR_STATUS_BUFCOPY_OK, status);
+    ASSERT_STREQ("ABCDEFGHI", cptgt);
+
+    memset(cptgt, 0, sizeof cptgt);
+    status = iovcursor_peek_ex(mincur, cptgt, &contigptr, 9, 0);
+    ASSERT_EQ(IOVCURSOR_STATUS_BUFCOPY_OK, status);
+    ASSERT_STREQ("ABCDEFGHI", cptgt);
+    ASSERT_TRUE(contigptr == NULL);
+
+    status = iovcursor_peek_ex(mincur, NULL, &contigptr, 9, 0);
+    ASSERT_EQ(IOVCURSOR_STATUS_FRAGMENTED, status);
+    ASSERT_TRUE(contigptr == NULL);
+
+    // Contiguous pointer
+    memset(cptgt, 0, sizeof cptgt);
+    status = iovcursor_peek_ex(mincur, NULL, &contigptr, 3, 0);
+    ASSERT_EQ(IOVCURSOR_STATUS_CONTIGPTR_OK, status);
+    ASSERT_EQ('\0', cptgt[0]);
+    memcpy(cptgt, contigptr, 3);
+    ASSERT_STREQ("ABC", cptgt);
+
+    // With offsets: CDE
+    contigptr = (char *)0x1;
+    memset(cptgt, 0, sizeof cptgt);
+    status = iovcursor_peek_ex(mincur, cptgt, &contigptr, 3, 2);
+    ASSERT_EQ(IOVCURSOR_STATUS_BUFCOPY_OK, status);
+    ASSERT_STREQ("CDE", cptgt);
+    ASSERT_TRUE(contigptr == NULL);
+}
+
+TEST_F(McIOVC, testAdvCopy)
+{
+    nb_IOV iov[3];
+    iov[0].iov_base = (void*)"ABC";
+    iov[0].iov_len = 3;
+    iov[1].iov_base = (void*)"DEF";
+    iov[1].iov_len = 3;
+    iov[2].iov_base = (void*)"GHI";
+    iov[2].iov_len = 3;
+    mc_IOVINFO cursor;
+    mc_IOVCURSOR *mincur = &cursor.c;
+
+    mc_iovinfo_init(&cursor, iov, 3);
+    char tgt[256];
+
+    iovcursor_adv_copy(mincur, tgt, 1);
+    ASSERT_EQ('A', tgt[0]);
+    ASSERT_EQ(1, mincur->offset);
+    memset(tgt, 0, sizeof tgt);
+
+    iovcursor_adv_copy(mincur, tgt, 2);
+    ASSERT_STREQ("BC", tgt);
+    ASSERT_EQ(0, mincur->offset);
+    ASSERT_EQ(2, mincur->niov);
+
+    // Reset the iovs
+    memset(tgt, 0, sizeof tgt);
+    mc_iovinfo_init(&cursor, iov, 3);
+    iovcursor_adv_copy(mincur, tgt, 4);
+    ASSERT_STREQ("ABCD", tgt);
+    ASSERT_EQ(2, mincur->niov);
+    ASSERT_EQ(1, mincur->offset);
+
+    // Read the rest?
+    memset(tgt, 0, sizeof tgt);
+    iovcursor_adv_copy(mincur, tgt, 5);
+    ASSERT_STREQ("EFGHI", tgt);
+    ASSERT_EQ(0, mincur->niov);
+    ASSERT_EQ(0, mincur->offset);
+}
+
+TEST_F(McIOVC, testAdvIovalloc)
+{
+    nb_IOV *iov_p;
+    unsigned niov;
+
+    nb_IOV iov[5];
+    iov[0].iov_base = (void*)"ABC";
+    iov[0].iov_len = 3;
+
+    iov[1].iov_base = (void*)"DEF";
+    iov[1].iov_len = 3;
+
+    iov[2].iov_base = (void*)"GHI";
+    iov[2].iov_len = 3;
+
+    iov[3].iov_base = (void *)"JKL";
+    iov[3].iov_len = 3;
+
+    iov[4].iov_base = (void *)"MNO";
+    iov[4].iov_len = 3;
+
+    mc_IOVINFO cursor;
+    mc_IOVCURSOR *mincur = &cursor.c;
+    mc_iovinfo_init(&cursor, iov, 5);
+
+    char tgt[256] = { 0 };
+    // Copy the first 4 fragments
+    iovcursor_adv_copy(mincur, tgt, 4);
+    ASSERT_STREQ("ABCD", tgt);
+
+    // Now the IOVs payload: { EF, GHI, JK }
+    iovcursor_adv_iovalloc(mincur, 7, &iov_p, &niov);
+    ASSERT_FALSE(iov_p == NULL);
+    ASSERT_EQ(3, niov);
+
+    // make a small cursor based on the current one, why not?
+    mc_IOVCURSOR mini;
+    mini.offset = 0;
+    mini.iov = iov_p;
+    mini.niov = niov;
+    memset(tgt, 0, sizeof tgt);
+    iovcursor_adv_copy(&mini, tgt, 7);
+    ASSERT_STREQ("EFGHIJK", tgt);
+    free(iov_p);
+}