libcouchbase 0.0.1

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

@@ -0,0 +1,193 @@
+#include <gtest/gtest.h>
+#include <lcbht/lcbht.h>
+#include <sstream>
+#include <map>
+#include "settings.h"
+
+using std::string;
+
+class HtparseTest : public ::testing::Test {
+};
+
+TEST_F(HtparseTest, testBasic)
+{
+    lcb_settings *settings = lcb_settings_new();
+    // Allocate a parser
+    lcbht_pPARSER parser = lcbht_new(settings);
+    ASSERT_FALSE(parser == NULL);
+
+    // Feed the parser some stuff
+    lcbht_RESPSTATE state;
+
+    string buf;
+    buf = "HTTP/1.0 200 OK\r\n";
+
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(0, state);
+
+    buf = "Connec";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(0, state);
+    buf = "tion: Keep-Alive\r\n";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(0, state);
+    buf += "Content-Length: 5\r\n\r\n";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(LCBHT_S_HEADER|LCBHT_S_HTSTATUS, state);
+
+    lcbht_RESPONSE *resp = lcbht_get_response(parser);
+    ASSERT_EQ(200, resp->status);
+
+    // Add some data into the body
+    buf = "H";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_STREQ("H", resp->body.base);
+
+    buf = "ello";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_STREQ("Hello", resp->body.base);
+
+    // Now find the header
+
+    lcbht_free(parser);
+    lcb_settings_unref(settings);
+}
+
+TEST_F(HtparseTest, testHeaderFunctions)
+{
+    lcb_settings *settings = lcb_settings_new();
+    lcbht_pPARSER parser = lcbht_new(settings);
+
+    string buf = "HTTP/1.0 200 OK\r\n"
+            "Connection: keep-alive\r\n"
+            "X-Server: dummy/1.0\r\n"
+            "Content-Type: application/json\r\n"
+            "Content-Length: 0\r\n"
+            "\r\n";
+    lcbht_RESPSTATE state;
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+
+    lcbht_RESPONSE *resp = lcbht_get_response(parser);
+    // Now fine the header value stuff
+    ASSERT_STREQ("keep-alive", lcbht_get_resphdr(resp, "Connection"));
+    ASSERT_STREQ("dummy/1.0", lcbht_get_resphdr(resp, "X-Server"));
+    ASSERT_STREQ("application/json", lcbht_get_resphdr(resp, "Content-Type"));
+
+    using std::map;
+    map<string,string> hdrmap;
+    char **hdrlist = lcbht_make_resphdrlist(resp);
+    for (char **cur = hdrlist; *cur != NULL; cur += 2) {
+        string k = cur[0];
+        string v = cur[1];
+        hdrmap[k] = v;
+        free(cur[0]);
+        free(cur[1]);
+    }
+    free(hdrlist);
+
+    ASSERT_EQ("keep-alive", hdrmap["Connection"]);
+    ASSERT_EQ("dummy/1.0", hdrmap["X-Server"]);
+    ASSERT_EQ("application/json", hdrmap["Content-Type"]);
+
+    lcbht_free(parser);
+    lcb_settings_unref(settings);
+}
+
+TEST_F(HtparseTest, testParseErrors)
+{
+    lcb_settings *settings = lcb_settings_new();
+    lcbht_pPARSER parser = lcbht_new(settings);
+
+    string buf = "blahblahblah";
+    lcbht_RESPSTATE state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_ERROR);
+    lcbht_free(parser);
+    lcb_settings_unref(settings);
+}
+
+
+TEST_F(HtparseTest, testParseExtended)
+{
+    lcb_settings *settings = lcb_settings_new();
+    lcbht_pPARSER parser = lcbht_new(settings);
+    lcbht_RESPONSE *resp;
+
+    const char *body;
+    unsigned nbody, nused;
+
+    string buf = "HTTP/1.0 200 OK\r\n"
+            "Connection: keep-alive\r\n"
+            "Content-Length: 5\r\n";
+
+    lcbht_RESPSTATE state;
+    state = lcbht_parse_ex(parser, buf.c_str(), buf.size(), &nused, &nbody, &body);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(NULL, body);
+    ASSERT_EQ(buf.size(), nused);
+    ASSERT_EQ(0, nbody);
+
+    resp = lcbht_get_response(parser);
+    buf = "\r\nHello";
+    // Feed the buffer
+    state = lcbht_parse_ex(parser, buf.c_str(), buf.size(), &nused, &nbody, &body);
+    ASSERT_EQ(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(5, nbody);
+    ASSERT_FALSE(NULL == body);
+    ASSERT_STREQ("Hello", body);
+    ASSERT_EQ(buf.size()-1, nused);
+
+    size_t off = nused;
+
+    // Parse again
+    state = lcbht_parse_ex(parser, buf.c_str()+off, buf.size()-off, &nused, &nbody, &body);
+    ASSERT_EQ(nused, buf.size()-off);
+    ASSERT_TRUE(body == NULL);
+    ASSERT_EQ(0, nbody);
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(0, resp->body.nused);
+
+    lcbht_free(parser);
+    lcb_settings_unref(settings);
+}
+
+TEST_F(HtparseTest, testCanKeepalive)
+{
+    lcb_settings *settings = lcb_settings_new();
+    lcbht_pPARSER parser = lcbht_new(settings);
+    string buf = "HTTP/1.0 200 OK\r\n"
+            "Content-Length: 0\r\n"
+            "\r\n";
+    lcbht_RESPSTATE state;
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(0, lcbht_can_keepalive(parser));
+
+    // Use HTTP/1.1 with Connection: close
+    lcbht_reset(parser);
+    buf = "HTTP/1.1 200 OK\r\n"
+            "Content-Length: 0\r\n"
+            "Connection: close\r\n"
+            "\r\n";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(0, lcbht_can_keepalive(parser));
+
+    lcbht_reset(parser);
+    // Default HTTP/1.1
+    buf = "HTTP/1.1 200 OK\r\n"
+            "Content-Length: 0\r\n"
+            "\r\n";
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_NE(0, lcbht_can_keepalive(parser));
+
+    lcbht_free(parser);
+    lcb_settings_unref(settings);
+}

data/ext/libcouchbase/tests/ioserver/connection.cc

@@ -0,0 +1,166 @@
+#include "ioserver.h"
+#include <cassert>
+#include <algorithm>
+
+using namespace LCBTest;
+
+extern "C" {
+static void
+client_runfunc(void *arg)
+{
+    TestConnection *conn = (TestConnection *)arg;
+    conn->_doRun();
+}
+}
+
+void TestConnection::_doRun() { run(); }
+
+void
+TestConnection::setCommon(void *src, void **target)
+{
+    mutex.lock();
+    assert(*target == NULL);
+    *target = src;
+    char dummy = 0;
+    ctlfd_user->send(&dummy, 1);
+    mutex.unlock();
+}
+
+void
+TestConnection::sendData()
+{
+    f_send->startUpdate();
+    do {
+#ifdef _WIN32
+        const char *outbuf;
+#else
+        void *outbuf;
+#endif
+        size_t n = f_send->getBuf((void**)&outbuf);
+        size_t nw = datasock->send(outbuf, n);
+        if (nw < 0) {
+            f_send->bail();
+        } else {
+            f_send->setSent(nw);
+        }
+    } while (!f_send->shouldEnd());
+    f_send->endUpdate();
+    f_send = NULL;
+}
+
+void
+TestConnection::recvData()
+{
+    f_recv->startUpdate();
+    char buf[32768];
+
+    do {
+        size_t required = f_recv->getRequired();
+        size_t rdsize = std::min(required, sizeof(buf));
+        ssize_t nr = datasock->recv(buf, rdsize);
+        if (nr < 0) {
+            f_recv->bail();
+        } else {
+            f_recv->setReceived(buf, nr);
+        }
+    } while (!f_recv->shouldEnd());
+
+    f_recv->endUpdate();
+    f_recv = NULL;
+}
+
+void
+TestConnection::handleClose()
+{
+    f_close->startUpdate();
+    datasock->close();
+    f_close->setDone();
+    f_close->endUpdate();
+    f_close = NULL;
+}
+
+void
+TestConnection::run()
+{
+    char dummy = 0;
+    mutex.lock();
+    ctlfd_loop = ctlfd_lsn->acceptClient();
+    initcond.signal();
+    mutex.unlock();
+
+    while (::recv(*ctlfd_loop, &dummy, 1, 0) == 1) {
+        mutex.lock();
+        if (f_close && f_close->getType() == CloseFuture::BEFORE_IO) {
+            handleClose();
+        }
+
+        if (f_send) {
+            sendData();
+        }
+        if (f_recv) {
+            recvData();
+        }
+
+        if (f_close && f_close->getType() == CloseFuture::AFTER_IO) {
+            handleClose();
+        }
+        mutex.unlock();
+    }
+
+    mutex.lock();
+    if (f_recv) {
+        f_recv->updateFailed();
+        f_recv = NULL;
+    }
+    if (f_send) {
+        f_send->updateFailed();
+        f_send = NULL;
+    }
+    if (f_close) {
+        f_close->updateFailed();
+        f_close = NULL;
+    }
+    mutex.unlock();
+}
+
+TestConnection::TestConnection(TestServer *server, SockFD *newsock)
+{
+    datasock = newsock;
+    datasock->loadRemoteAddr();
+    ctlfd_lsn = SockFD::newListener();
+    ctlfd_loop = NULL;
+
+    f_send = NULL;
+    f_recv = NULL;
+    f_close = NULL;
+    parent = server;
+
+    thr = new Thread(client_runfunc, this);
+    ctlfd_user = SockFD::newClient(ctlfd_lsn);
+    ctlfd_user->setNodelay(true);
+
+    mutex.lock();
+    while (!ctlfd_loop) {
+        initcond.wait(mutex);
+    }
+    mutex.unlock();
+}
+
+TestConnection::~TestConnection()
+{
+    ctlfd_loop->close();
+    ctlfd_user->close();
+    ctlfd_lsn->close();
+    datasock->close();
+    // We don't want to explicitly call join() here since that
+    // gets called in the destructor.  This is unncessary
+    // and broken on musl.
+    // thr->join();
+    delete thr;
+    mutex.close();
+    initcond.close();
+    delete ctlfd_loop;
+    delete ctlfd_user;
+    delete ctlfd_lsn;
+    delete datasock;
+}

data/ext/libcouchbase/tests/ioserver/future.cc

@@ -0,0 +1,50 @@
+#include "ioserver.h"
+using namespace LCBTest;
+
+Future::Future()
+{
+    failed = false;
+}
+
+void
+Future::wait()
+{
+    mutex.lock();
+    while (!isDone() && !failed) {
+        cond.wait(mutex);
+    }
+    mutex.unlock();
+}
+
+Future::~Future()
+{
+    mutex.close();
+    cond.close();
+}
+
+void
+Future::startUpdate()
+{
+    mutex.lock();
+}
+
+void
+Future::endUpdate()
+{
+    if (shouldEnd()) {
+        cond.signal();
+    }
+    mutex.unlock();
+}
+
+bool
+Future::checkDone()
+{
+    bool ret;
+    if (!mutex.tryLock()) {
+        return false;
+    }
+    ret = isDone();
+    mutex.unlock();
+    return ret;
+}

data/ext/libcouchbase/tests/ioserver/ioserver.cc

@@ -0,0 +1,104 @@
+#include <cassert>
+#include <sys/types.h>
+#include "ioserver.h"
+using namespace LCBTest;
+using std::list;
+
+extern "C" {
+static void
+server_runfunc(void *arg)
+{
+    TestServer *server = (TestServer *)arg;
+    server->run();
+}
+}
+
+void
+TestServer::run()
+{
+    while (!closed) {
+        struct sockaddr_in newaddr;
+        socklen_t naddr = sizeof(newaddr);
+        int newsock = accept(*lsn, (struct sockaddr *)&newaddr, &naddr);
+
+        if (newsock == -1) {
+            break;
+        }
+
+        TestConnection *newconn = new TestConnection(this, factory(newsock));
+        startConnection(newconn);
+    }
+}
+
+void
+TestServer::startConnection(TestConnection *conn)
+{
+    mutex.lock();
+    if (isClosed()) {
+        conn->close();
+        delete conn;
+    } else {
+        conns.push_back(conn);
+    }
+    mutex.unlock();
+}
+
+TestServer::TestServer()
+{
+    lsn = SockFD::newListener();
+    closed = false;
+    factory = plainSocketFactory;
+
+    // Now spin up a thread to start the accept loop
+    thr = new Thread(server_runfunc, this);
+}
+
+TestServer::~TestServer()
+{
+    close();
+    mutex.lock();
+    std::list<TestConnection*>::iterator iter = conns.begin();
+    for (; iter != conns.end(); ++iter) {
+        (*iter)->close();
+        delete *iter;
+    }
+    mutex.unlock();
+    // We don't want to explicitly call join() here since that
+    // gets called in the destructor.  This is unncessary
+    // and broken on musl.
+    // thr->join();
+    delete thr;
+    mutex.close();
+    delete lsn;
+}
+
+std::string
+TestServer::getPortString()
+{
+    char buf[4096];
+    sprintf(buf, "%d", lsn->getLocalPort());
+    return std::string(buf);
+}
+
+TestConnection *
+TestServer::findConnection(uint16_t port)
+{
+    TestConnection *ret = NULL;
+    list<TestConnection *>::iterator iter;
+
+    while (ret == NULL) {
+        sched_yield();
+        mutex.lock();
+        iter = conns.begin();
+
+        for (; iter != conns.end(); ++iter) {
+            if ((*iter)->getPeerPort() == port) {
+                ret = *iter;
+                break;
+            }
+        }
+        mutex.unlock();
+    };
+
+    return ret;
+}