mt-libcouchbase 1.4.0

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

@@ -0,0 +1,159 @@
+#include "socktest.h"
+#include <lcbio/manager.h>
+using namespace LCBTest;
+using std::string;
+using std::vector;
+class SockMgrTest : public SockTest {
+    void SetUp() {
+        SockTest::SetUp();
+        loop->sockpool->get_options().maxidle = 2;
+        loop->sockpool->get_options().tmoidle = LCB_MS2US(2000);
+    }
+};
+
+TEST_F(SockMgrTest, testBasic)
+{
+    ESocket *sock1 = new ESocket();
+    loop->connectPooled(sock1);
+    lcbio_SOCKET *rawsock = sock1->sock;
+    delete sock1;
+    ESocket *sock2 = new ESocket();
+    loop->connectPooled(sock2);
+    ASSERT_EQ(rawsock, sock2->sock);
+
+    ESocket *sock3 = new ESocket();
+    loop->connectPooled(sock3);
+    ASSERT_NE(rawsock, sock3->sock);
+    delete sock3;
+    delete sock2;
+}
+
+TEST_F(SockMgrTest, testCancellation)
+{
+    lcb_host_t host = {0};
+    loop->populateHost(&host);
+    lcb::io::ConnectionRequest *req = loop->sockpool->get(host, LCB_MS2US(1000), NULL, NULL);
+    ASSERT_FALSE(req == NULL);
+    req->cancel();
+    loop->sockpool->get_options().tmoidle = LCB_MS2US(2);
+    loop->start();
+}
+
+// See if a connection closed when it was idle is returned or not!
+TEST_F(SockMgrTest, testIdleClosed)
+{
+    lcb_socket_t llfd;
+    ESocket *sock1 = new ESocket();
+    loop->connectPooled(sock1);
+    TestConnection *tc = sock1->conn;
+
+    if (loop->iot->model == LCB_IOMODEL_EVENT) {
+        llfd = sock1->ctx->sock->u.fd;
+    } else {
+        llfd = sock1->ctx->sock->u.sd->socket;
+    }
+
+    // Wait unitl it's closed by the server
+    CloseFuture cf(CloseFuture::BEFORE_IO);
+    tc->setClose(&cf);
+    cf.wait();
+
+    delete sock1;
+    // Since shutdown() is TCP level, while send/recv are socket level, we
+    // might need to loop a bit until we get something!
+    int rv = -1, attempts = 0;
+    do {
+        char buf = 0;
+        rv = recv(llfd, &buf, 1, 0);
+    } while (rv != 0 && ++attempts);
+
+    if (attempts) {
+        fprintf(stderr, "Needed to loop more than once! (%d times)\n", attempts);
+    }
+
+    ESocket *sock2 = new ESocket();
+    loop->connectPooled(sock2);
+
+    // We should be able to perform IO on this socket. Write a few bytes
+    string msg("Hello World!");
+    RecvFuture rf(msg.size());
+    FutureBreakCondition fbc(&rf);
+
+    sock2->conn->setRecv(&rf);
+    sock2->put(msg);
+    sock2->schedule();
+
+    loop->setBreakCondition(&fbc);
+    loop->start();
+    rf.wait();
+    ASSERT_TRUE(rf.isOk());
+    delete sock2;
+}
+
+struct PCtxDummy : lcbio_PROTOCTX {
+    int *cVar;
+    bool invoked;
+    bool shouldDelete;
+};
+extern "C" {
+static void protoctx_dtor(lcbio_PROTOCTX *ctx) {
+    PCtxDummy *d = (PCtxDummy *)ctx;
+    if (d->shouldDelete) {
+        delete d;
+    } else {
+        *d->cVar += 1;
+        d->invoked = true;
+    }
+}
+}
+
+TEST_F(SockMgrTest, testMaxIdle)
+{
+    // Assuming maxidle=2 as defined in the beginning
+    int destroyCount = 0;
+    ESocket *socks[4];
+    PCtxDummy *ctxs[4];
+
+    for (int ii = 0; ii < 4; ii++) {
+        ESocket *s = new ESocket();
+        PCtxDummy *pctx = new PCtxDummy();
+
+        pctx->id = LCBIO_PROTOCTX_MAX;
+        pctx->dtor = protoctx_dtor;
+        pctx->cVar = &destroyCount;
+        pctx->invoked = false;
+
+        loop->connectPooled(s);
+        lcbio_protoctx_add(s->sock, pctx);
+
+        socks[ii] = s;
+        ctxs[ii] = pctx;
+    }
+
+    // Assume they're all alive. Now delete them
+    for (int ii = 0; ii < 4; ii++) {
+        delete socks[ii];
+    }
+
+    // We need
+    ASSERT_EQ(2, destroyCount);
+    for (int ii = 0; ii < 4; ii++) {
+        if (ctxs[ii]->invoked) {
+            delete ctxs[ii];
+        } else {
+            ctxs[ii]->shouldDelete = true;
+        }
+    }
+
+    // Ensure subsequent connections can also work!
+    ESocket *otherSocks[8];
+    for (int ii = 0; ii < 8; ii++) {
+        ESocket *s = new ESocket();
+        loop->connectPooled(s);
+        otherSocks[ii] = s;
+        ASSERT_TRUE(s->sock != NULL);
+    }
+    for (int ii = 0; ii < 8; ii++) {
+        delete otherSocks[ii];
+    }
+}

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

@@ -0,0 +1,256 @@
+#include "socktest.h"
+#include <netbuf/netbuf.h>
+#include <algorithm>
+using namespace LCBTest;
+using std::string;
+using std::vector;
+using std::list;
+
+/**
+ * These tests cover the various lcbio_PutEx() routines.
+ */
+
+struct WriteBuffer {
+    sllist_node ll;
+    char *buf;
+    const size_t length;
+    bool flushed;
+
+    WriteBuffer(const std::string& s) : length(s.size()){
+        buf = new char[length];
+        memcpy(buf, s.data(), length);
+        flushed = false;
+    }
+
+    ~WriteBuffer() {
+        delete[] buf;
+    }
+};
+
+extern "C" {
+static nb_SIZE
+pdu_callback(void *pdu, nb_SIZE remaining, void *arg)
+{
+    WriteBuffer *wb = (WriteBuffer *) pdu;
+
+    *(size_t *)arg += 1;
+    if (wb->length <= remaining) {
+        wb->flushed = true;
+    }
+    return wb->length;
+}
+}
+
+struct BufList {
+    nb_MGR mgr;
+    BufList() {
+        netbuf_init(&mgr, NULL);
+    }
+
+    ~BufList() {
+        netbuf_cleanup(&mgr);
+    }
+
+    vector<lcb_IOV> getIOV(size_t *nbytes) {
+        nb_IOV iovs[32];
+        vector<lcb_IOV> ret;
+        int niov = 0;
+        *nbytes = netbuf_start_flush(&mgr, iovs, 32, &niov);
+        for (int ii = 0; ii < niov; ii++) {
+            lcb_IOV cur;
+            cur.iov_base = iovs[ii].iov_base;
+            cur.iov_len = iovs[ii].iov_len;
+            ret.push_back(cur);
+        }
+        return ret;
+    }
+
+    void updateFlushed(size_t expected, unsigned n) {
+        size_t pduCount = 0;
+        netbuf_end_flush2(&mgr, n, pdu_callback, 0, &pduCount);
+        size_t nremoved = 0;
+        while (!bufs.empty()) {
+            WriteBuffer *curBuf = bufs.front();
+            if (curBuf->flushed) {
+                bufs.pop_front();
+                delete curBuf;
+                nremoved++;
+            } else {
+                break;
+            }
+        }
+
+        if (expected != n) {
+            netbuf_reset_flush(&mgr);
+        }
+    }
+
+    void append(const std::string &s) {
+        WriteBuffer *wb = new WriteBuffer(s);
+        nb_SPAN span;
+        CREATE_STANDALONE_SPAN(&span, wb->buf, wb->length);
+        netbuf_enqueue_span(&mgr, &span);
+        netbuf_pdu_enqueue(&mgr, wb, 0);
+        bufs.push_back(wb);
+    }
+
+    list<WriteBuffer *> bufs;
+};
+
+class BufActions : public IOActions {
+public:
+    unsigned totalFlushed;
+    BufActions(){ totalFlushed = 0; }
+    BufList buflist;
+    void onFlushReady(ESocket *s) {
+        int ready = 0;
+        size_t nbytes;
+
+        do {
+            vector<lcb_IOV> iovs = buflist.getIOV(&nbytes);
+            if (!nbytes) {
+                break; // nothing left to flush
+            }
+            ready = lcbio_ctx_put_ex(s->ctx, &iovs[0], iovs.size(), nbytes);
+        } while (ready);
+
+        if (nbytes) {
+            lcbio_ctx_wwant(s->ctx);
+            s->schedule();
+        }
+    }
+
+    void onFlushDone(ESocket *s, size_t expected, size_t nr) {
+        totalFlushed += nr;
+        buflist.updateFlushed(expected, nr);
+    }
+};
+
+class MyBreakCondition : public BreakCondition {
+public:
+    BufList *bl;
+    RecvFuture *rf;
+    MyBreakCondition(BufList *buflist, RecvFuture *ft) {
+        bl = buflist;
+        rf = ft;
+    }
+protected:
+    /** break only after we're fully flushed and all the data's been received */
+    bool shouldBreakImpl() {
+        return rf->checkDone() && bl->bufs.empty();
+    }
+};
+
+class SockPutexTest : public SockTest {
+public:
+    ESocket sock;
+    BufActions bufActions;
+    BufList *buflist;
+    void SetUp() {
+        SockTest::SetUp();
+        sock.setActions(&bufActions);
+        loop->connect(&sock);
+        buflist = &bufActions.buflist;
+    }
+    void TearDown() {
+        sock.close();
+        SockTest::TearDown();
+    }
+};
+
+TEST_F(SockPutexTest, testBasic)
+{
+    RecvFuture rf(100);
+    for (int ii = 0; ii < 100; ii++) {
+        buflist->append("@");
+    }
+
+    sock.conn->setRecv(&rf);
+    lcbio_ctx_wwant(sock.ctx);
+    sock.schedule();
+    MyBreakCondition mbc(buflist, &rf);
+    loop->setBreakCondition(&mbc);
+    loop->start();
+    rf.wait();
+    string expected(100, '@');
+    ASSERT_EQ(rf.getString(), expected);
+}
+
+
+TEST_F(SockPutexTest, testBig)
+{
+    const size_t rchunk = 1000, niters = 1000, expected = rchunk * niters;
+
+    // fill up the write buffers
+    for (int ii = 0; ii < niters; ii++) {
+        buflist->append(string(rchunk, '#'));
+    }
+
+    size_t nconsumed = 0;
+    size_t nbufsOrig = buflist->bufs.size();
+
+    /**
+     * Iterate until all the buffers have been flushed and returned to the
+     * caller, and until they have all been received
+     */
+    while (buflist->bufs.empty() == false || nconsumed != expected) {
+        RecvFuture rf(100);
+        FutureBreakCondition fbc(&rf);
+
+        if (nconsumed != expected) {
+            rf.reinit(std::min(rchunk, expected - nconsumed));
+            sock.conn->setRecv(&rf);
+            loop->setBreakCondition(&fbc);
+        }
+
+        if (bufActions.totalFlushed != expected) {
+            // Make the tests run quicker and only send data when it's not
+            // flushed
+            lcbio_ctx_wwant(sock.ctx);
+            sock.schedule();
+            loop->start();
+        }
+
+        if (nconsumed != expected) {
+            rf.wait();
+            ASSERT_TRUE(rf.isOk());
+            loop->setBreakCondition(NULL);
+            nconsumed += rf.getBuf().size();
+        }
+        if (bufActions.totalFlushed == expected) {
+            assert(buflist->bufs.empty());
+        }
+    }
+
+    ASSERT_TRUE(buflist->bufs.empty());
+}
+
+class TClosedBreakCondition : public BreakCondition {
+public:
+    ESocket *s;
+    BufList *bl;
+    TClosedBreakCondition(ESocket *sock, BufList *buflist) {
+        s = sock;
+        bl = buflist;
+    }
+protected:
+    bool shouldBreakImpl() {
+        return bl->bufs.empty();
+    }
+
+};
+TEST_F(SockPutexTest, testClosed)
+{
+    sock.conn->close();
+    TClosedBreakCondition tcb(&sock, buflist);
+
+    while (sock.lasterr == LCB_SUCCESS) {
+        buflist->append(string(100, '$'));
+        lcbio_ctx_wwant(sock.ctx);
+        sock.schedule();
+        loop->setBreakCondition(&tcb);
+        loop->start();
+    }
+
+    ASSERT_TRUE(buflist->bufs.empty());
+}

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

@@ -0,0 +1,187 @@
+#include "socktest.h"
+using namespace LCBTest;
+using std::string;
+using std::vector;
+class SockReadTest : public SockTest {};
+namespace {
+
+/**
+ * Set a specific 'rdwant' value. Send data smaller than the want, and then
+ * send some more data.
+ */
+TEST_F(SockReadTest, testWant)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    string expected("Hello World!");
+    SendFuture sf(expected);
+
+    ReadBreakCondition cond(&sock, expected.size());
+
+    sock.reqrd(expected.size() * 2);
+    sock.schedule();
+    sock.conn->setSend(&sf);
+    loop->setBreakCondition(&cond);
+    loop->start();
+    sf.wait();
+    ASSERT_TRUE(cond.didBreak());
+
+    // If everything is right, we should have nothing inside the buffer
+    ASSERT_TRUE(sock.getReceived().empty());
+
+    SendFuture sf2(expected);
+    sock.conn->setSend(&sf2);
+    cond = ReadBreakCondition(&sock, expected.size() * 2);
+    loop->setBreakCondition(&cond);
+    loop->start();
+    sf2.wait();
+    expected += expected;
+    ASSERT_FALSE(sock.getReceived().empty());
+    ASSERT_EQ(expected, sock.getReceived());
+}
+
+// Ensure the 'rdwant' flag is reset when we invoke the callback
+TEST_F(SockReadTest, testWantReset)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    string expected("Hi!!!");
+    sock.reqrd(expected.size());
+    SendFuture sf(expected);
+    ReadBreakCondition rbc(&sock, expected.size());
+    loop->setBreakCondition(&rbc);
+    ASSERT_EQ(expected.size(), sock.ctx->rdwant);
+    sock.schedule();
+    sock.conn->setSend(&sf);
+    loop->start();
+    ASSERT_EQ(0, sock.ctx->rdwant);
+}
+
+/**
+ * We should get an error if the socket is closed before we have data
+ */
+TEST_F(SockReadTest, testBrokenRead)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    CloseFuture cf(CloseFuture::BEFORE_IO);
+    sock.conn->setClose(&cf);
+    sock.reqrd(5000);
+    sock.schedule();
+    ErrorBreakCondition ebc(&sock);
+    loop->setBreakCondition(&ebc);
+    loop->start();
+    cf.wait();
+    ASSERT_TRUE(sock.lasterr == LCB_NETWORK_ERROR ||
+            sock.lasterr == LCB_ESOCKSHUTDOWN);
+}
+
+TEST_F(SockReadTest, testReadAhead)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    string sendStr(200, '$');
+    unsigned wantSize = sendStr.size() / 2;
+    SendFuture sf(sendStr);
+    ReadBreakCondition rbc(&sock, wantSize);
+
+    sock.reqrd(wantSize);
+    sock.conn->setSend(&sf);
+    sock.schedule();
+
+    loop->setBreakCondition(&rbc);
+    loop->start();
+    sf.wait();
+
+    ASSERT_TRUE(sock.getReceived().size() >= wantSize);
+    if (sock.getReceived().size() == wantSize) {
+        fprintf(stderr, "!!! received exactly wantsize. Slow network?\n");
+    }
+}
+
+/**
+ * Test the behavior of an orderly close where all the required data is
+ * consumed.
+ */
+TEST_F(SockReadTest, testOrderlyClose)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    string expected(200, '$');
+
+    SendFuture sf(expected);
+    ReadBreakCondition rbc(&sock, expected.size());
+    CloseFuture cf(CloseFuture::AFTER_IO);
+
+    sock.conn->setSend(&sf);
+    sock.conn->setClose(&cf);
+    loop->setBreakCondition(&rbc);
+    sock.reqrd(expected.size());
+    sock.schedule();
+    loop->start();
+
+    cf.wait();
+    sf.wait();
+
+    ASSERT_EQ(expected, sock.getReceived());
+}
+
+class ChunkReadActions : public IOActions {
+public:
+    int numChunks;
+    vector<char> buffer;
+    void onRead(ESocket *s, size_t nr) {
+        lcbio_CTXRDITER iter;
+        LCBIO_CTX_ITERFOR(s->ctx, &iter, nr) {
+            unsigned nbuf = lcbio_ctx_risize(&iter);
+            void *buf = lcbio_ctx_ribuf(&iter);
+            numChunks++;
+            buffer.insert(buffer.end(), (char *)buf, (char *)buf + nbuf);
+        }
+    }
+
+    ChunkReadActions() : IOActions() {
+        numChunks = 0;
+    }
+};
+
+class CRABreakCondition : public BreakCondition {
+public:
+    ChunkReadActions *cra;
+    int expected;
+    CRABreakCondition(ChunkReadActions *actions, int exp) {
+        cra = actions;
+        expected = exp;
+    }
+
+    bool shouldBreakImpl() {
+        return cra->numChunks >= expected;
+    }
+
+};
+/** Tests the iterator chunking mechanism */
+TEST_F(SockReadTest, testChunkedIter)
+{
+    // Set the chunked allocator
+    ESocket sock;
+    loop->connect(&sock);
+    rdb_challoc(&sock.ctx->ior, rdb_chunkalloc_new(1));
+
+    string toSend(20, '+');
+    SendFuture sf(toSend);
+    sock.conn->setSend(&sf);
+    ChunkReadActions cra;
+    CRABreakCondition bc(&cra, 20);
+
+    sock.setActions(&cra);
+    sock.reqrd(toSend.size());
+    sock.schedule();
+    loop->setBreakCondition(&bc);
+    loop->start();
+
+    ASSERT_EQ(toSend.size(), cra.numChunks);
+    ASSERT_EQ(toSend.size(), cra.buffer.size());
+    ASSERT_EQ(toSend, string(cra.buffer.begin(), cra.buffer.end()));
+    sf.wait();
+}
+}