libcouchbase 0.0.1

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,347 @@
+#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.u.cs = 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);
+        lcbio_mgr_put(s);
+    }
+}
+}
+
+void
+ESocket::close()
+{
+    if (!ctx) {
+        return;
+    }
+
+    if (creq.type == LCBIO_CONNREQ_POOLED) {
+        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 = lcbio_mgr_create(settings, iot);
+}
+
+Loop::~Loop()
+{
+    delete breakTimer;
+    delete server;
+    lcbio_mgr_destroy(sockpool);
+    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;
+    sock->parent = this;
+    if (!host) {
+        populateHost(&tmphost);
+        host = &tmphost;
+    }
+    sock->creq.type = LCBIO_CONNREQ_POOLED;
+    sock->creq.u.preq = lcbio_mgr_get(
+            sockpool, 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;
+
+    if (host == NULL) {
+        populateHost(&tmphost);
+        host = &tmphost;
+    }
+
+    sock->parent = this;
+    sock->creq.type = LCBIO_CONNREQ_RAW;
+    sock->creq.u.cs = 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;
+}