mt-libcouchbase 1.4.0

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

@@ -0,0 +1,143 @@
+#include "socktest.h"
+using namespace LCBTest;
+using std::string;
+using std::vector;
+
+class SockReentrantTest : public SockTest {};
+
+/**
+ * This file tests various reentrant actions within the socket handlers.
+ */
+class ReadAgainAction : public IOActions {
+public:
+    ReadAgainAction() {
+        callCount = 0;
+        sf = NULL;
+    }
+
+    virtual ~ReadAgainAction(){}
+
+    int callCount;
+    SendFuture *sf;
+    void onRead(ESocket *s, size_t nr) {
+        if (callCount++) {
+            s->parent->stop();
+            return;
+        }
+
+        s->reqrd(nr * 2);
+        sf = new SendFuture(string(nr, '$'));
+        s->conn->setSend(sf);
+        s->schedule();
+    }
+    void onError(ESocket *) {
+        // do nothing
+    }
+};
+
+class CallCountBreakCondition : public BreakCondition {
+public:
+    ReadAgainAction *raa;
+    CallCountBreakCondition(ReadAgainAction *action) {
+        raa = action;
+    }
+protected:
+    bool shouldBreakImpl() { return raa->callCount >= 2; }
+};
+
+TEST_F(SockReentrantTest, testReadAgain)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    SendFuture sf1(string(100, '#'));
+    sock.conn->setSend(&sf1);
+    sock.reqrd(100);
+    sock.schedule();
+
+    ReadAgainAction raa;
+    CallCountBreakCondition bc(&raa);
+    sock.setActions(&raa);
+    loop->setBreakCondition(&bc);
+    loop->start();
+    ASSERT_TRUE(raa.callCount == 2);
+    ASSERT_TRUE(sock.getUnreadSize() >= 200);
+    ASSERT_TRUE(raa.sf != NULL);
+    raa.sf->wait();
+    delete raa.sf;
+}
+
+
+class CloseReadAction : public IOActions {
+public:
+    CloseReadAction() { wasCalled = false; }
+    virtual ~CloseReadAction() {}
+    void onRead(ESocket *s, size_t) {
+        EXPECT_FALSE(wasCalled);
+        wasCalled = true;
+        s->parent->stop();
+        s->close();
+    }
+    void onError(ESocket *) {}
+    bool wasCalled;
+};
+
+class CRABreakCondition : public BreakCondition {
+public:
+    CloseReadAction *cra;
+    CRABreakCondition(CloseReadAction *action) { cra = action; }
+protected:
+    bool shouldBreakImpl() { return cra->wasCalled; }
+};
+
+TEST_F(SockReentrantTest, testCloseOnRead)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    SendFuture sf(string(100, '#'));
+    sock.conn->setSend(&sf);
+    sock.reqrd(1);
+    sock.schedule();
+    CloseReadAction cra;
+    CRABreakCondition bc(&cra);
+    sock.setActions(&cra);
+    loop->setBreakCondition(&bc);
+    loop->start();
+    sf.wait();
+    ASSERT_TRUE(cra.wasCalled);
+}
+
+class CloseWriteAction : public IOActions {
+public:
+    bool wasCalled;
+    CloseWriteAction() { wasCalled = false; }
+    virtual ~CloseWriteAction() { }
+    void onRead(ESocket *s, size_t) {
+        EXPECT_FALSE(wasCalled);
+        wasCalled = true;
+        for (int ii = 0; ii < 100; ii++) {
+            s->put("Hello!");
+            s->schedule();
+        }
+        s->close();
+        s->parent->stop();
+    }
+    void onError(ESocket *){}
+};
+TEST_F(SockReentrantTest, testCloseOnWrite)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    SendFuture sf(string(100, '#'));
+    sock.conn->setSend(&sf);
+    sock.reqrd(1);
+    sock.schedule();
+    CloseWriteAction cwa;
+    sock.setActions(&cwa);
+
+    RecvFuture rf(1);
+    FutureBreakCondition fbc(&rf);
+    loop->setBreakCondition(&fbc);
+    loop->start();
+    sf.wait();
+    ASSERT_TRUE(cwa.wasCalled);
+}

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

@@ -0,0 +1,80 @@
+#include "socktest.h"
+
+#ifndef LCB_NO_SSL
+
+#include <lcbio/ssl.h>
+using namespace LCBTest;
+using std::string;
+using std::vector;
+
+class SSLTest : public SockTest {
+protected:
+    void SetUp() {
+        lcbio_ssl_global_init();
+        lcb_error_t errp = LCB_SUCCESS;
+        // Initialize the SSL stuff
+
+        SockTest::SetUp();
+        loop->settings->sslopts = LCB_SSL_ENABLED|LCB_SSL_NOVERIFY;
+        loop->settings->ssl_ctx = lcbio_ssl_new(NULL, NULL, NULL, 1, &errp, loop->settings);
+        loop->server->factory = TestServer::sslSocketFactory;
+        EXPECT_FALSE(loop->settings->ssl_ctx == NULL) << lcb_strerror(NULL, errp);
+    }
+
+    void TearDown() {
+        lcbio_ssl_free(loop->settings->ssl_ctx);
+        loop->settings->ssl_ctx = NULL;
+        SockTest::TearDown();
+    }
+};
+
+TEST_F(SSLTest, testBasic)
+{
+    // Copy/pasted from SockConnTest::testBasic
+
+    ESocket sock;
+
+    // We can connect
+    loop->connect(&sock);
+    ASSERT_FALSE(sock.sock == NULL);
+    ASSERT_TRUE(sock.creq == NULL);
+    ASSERT_EQ(1, sock.sock->refcount);
+
+    // We can send data
+    string sendStr("Hello World");
+    RecvFuture rf(sendStr.size());
+    FutureBreakCondition wbc(&rf);
+
+    sock.conn->setRecv(&rf);
+    sock.put(sendStr);
+    sock.schedule();
+    loop->setBreakCondition(&wbc);
+    loop->start();
+    rf.wait();
+    ASSERT_TRUE(rf.isOk());
+    ASSERT_EQ(rf.getString(), sendStr);
+
+    // We can receive data
+    string recvStr("Goodbye World!");
+    SendFuture sf(recvStr);
+    ReadBreakCondition rbc(&sock, recvStr.size());
+    sock.conn->setSend(&sf);
+    sock.reqrd(recvStr.size());
+    sock.schedule();
+    loop->setBreakCondition(&rbc);
+    loop->start();
+    sf.wait();
+    ASSERT_TRUE(sf.isOk());
+    ASSERT_EQ(sock.getReceived(), recvStr);
+
+    // Clean it all up
+    sock.close();
+}
+
+#else
+class SSLTest : public ::testing::Test {};
+TEST_F(SSLTest, DISABLED_testBasic)
+{
+    EXPECT_FALSE(true);
+}
+#endif

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

@@ -0,0 +1,95 @@
+#include "socktest.h"
+using namespace LCBTest;
+using std::string;
+using std::vector;
+class SockWriteTest : public SockTest {};
+
+/**
+ * This file tests the ability of the sockets to write various pieces
+ * of data.
+ */
+TEST_F(SockWriteTest, testMultiWrite)
+{
+    ESocket sock;
+    loop->connect(&sock);
+
+    string expected("Hello World!");
+    RecvFuture rf(expected.size());
+    FutureBreakCondition wbc(&rf);
+
+    sock.put("Hello "); sock.schedule();
+    sock.put("World"); sock.schedule();
+    sock.put("!"); sock.schedule();
+    sock.schedule();
+
+    sock.conn->setRecv(&rf);
+
+    loop->setBreakCondition(&wbc);
+    loop->start();
+    rf.wait();
+    ASSERT_TRUE(rf.isOk());
+    ASSERT_EQ(expected, rf.getString());
+}
+
+
+/**
+ * Test with a very big write
+ */
+TEST_F(SockWriteTest, testBigWrite)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    string expected(1024*1024*2, '*');
+    RecvFuture rf(expected.size());
+    sock.conn->setRecv(&rf);
+    sock.put(expected);
+    sock.schedule();
+
+    FutureBreakCondition wbc(&rf);
+    loop->setBreakCondition(&wbc);
+    loop->start();
+    rf.wait();
+    ASSERT_TRUE(rf.isOk());
+    ASSERT_EQ(expected, rf.getString());
+}
+
+/**
+ * Write to a broken socket. Because close is not synchronous on both ends
+ * of the connection (even though in this case they are on the same host)
+ * we need to loop until we get an error.
+ */
+TEST_F(SockWriteTest, testBrokenFirstWrite)
+{
+    ESocket sock;
+    loop->connect(&sock);
+
+    while (sock.lasterr == LCB_SUCCESS) {
+        CloseFuture cf(CloseFuture::BEFORE_IO);
+        FlushedBreakCondition fbc(&sock);
+        sock.conn->setClose(&cf);
+        sock.put("This should fail");
+        sock.schedule();
+        loop->setBreakCondition(&fbc);
+        loop->start();
+        cf.wait();
+    }
+}
+
+TEST_F(SockWriteTest, testBrokenMultiWrites)
+{
+    ESocket sock;
+    loop->connect(&sock);
+    while (sock.lasterr == LCB_SUCCESS) {
+        CloseFuture cf(CloseFuture::BEFORE_IO);
+        FlushedBreakCondition fbc(&sock);
+        sock.conn->setClose(&cf);
+
+        for (int ii = 0; ii < 100; ii++) {
+            sock.put("This message should fail");
+            sock.schedule();
+        }
+        loop->setBreakCondition(&fbc);
+        loop->start();
+        cf.wait();
+    }
+}

data/ext/libcouchbase/tests/start_mock.bat

@@ -0,0 +1,15 @@
+@ECHO OFF
+SET lcbdir=%srcdir%
+IF "%lcbdir%"=="" (
+    SET lcbdir=.
+)
+
+SET MOCKPATH=%lcbdir%\tests\CouchbaseMock.jar
+
+java ^
+    -client^
+    -jar "%MOCKPATH%"^
+    --nodes=4^
+    --host=localhost^
+    --port=0^
+    %*

data/ext/libcouchbase/tests/start_mock.sh

@@ -0,0 +1,42 @@
+#! /bin/sh
+#
+#     Copyright 2011 Couchbase, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+# We don't want to run memory debugging on java ;)
+unset LD_PRELOAD
+unset MALLOC_DEBUG
+unset UMEM_DEBUG
+
+# This is a wrapper script to start the Couchbase Mock server.
+# We could have started it directly from the C code, but by using
+# a script it's a bit easier to test it manually ;)
+if [ -z "$srcdir" ]; then
+    srcdir="."
+fi
+
+for p in "$srcdir/tests" "$srcdir" "tests" "."; do
+    if [ -f "$p/CouchbaseMock.jar" ]; then
+        COUCHBASEMOCK="$p/CouchbaseMock.jar"
+    fi
+done
+
+exec java \
+       -client \
+       -jar "$COUCHBASEMOCK" \
+        --nodes=4 \
+        --host=localhost \
+        --port=0 \
+        "$@"

data/ext/libcouchbase/tests/unit_tests.cc

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#include "config.h"
+#include <gtest/gtest.h>
+
+#ifdef NO_COUCHBASEMOCK
+class MockTestsAreDisabled : public ::testing::Test {};
+TEST_F(MockTestsAreDisabled, MockTestsAreDisabled) {
+    fprintf(stderr, "*** WARNING\n");
+    fprintf(stderr, "*** libcouchbase Java Mock tests are disabled\n");
+    fprintf(stderr, "*** Basic memcached functionality (get, set, etc.) \n");
+    fprintf(stderr, "*** will NOT be tested\n");
+}
+#define SETUP_MOCK_ENV()
+#define setup_test_timeout_handler()
+#else
+#include "iotests/iotests.h"
+#define SETUP_MOCK_ENV() ::testing::AddGlobalTestEnvironment(MockEnvironment::getInstance())
+#endif
+
+int main(int argc, char **argv)
+{
+    setvbuf(stdout, NULL, _IOLBF, 2048);
+    setvbuf(stderr, NULL, _IOLBF, 2048);
+    SETUP_MOCK_ENV();
+    ::testing::InitGoogleTest(&argc, argv);
+    setup_test_timeout_handler();
+    return RUN_ALL_TESTS();
+}

data/ext/libcouchbase/tests/vbucket/confdata/bad.json

@@ -0,0 +1,101 @@
+{
+  "rev": 5,
+  "name": "bucket-1",
+  "uri": "/pools/default/buckets/bucket-1?bucket_uuid=37e1c1dfc17d74c80c5e3cbbacf57069",
+  "streamingUri": "/pools/default/bucketsStreaming/bucket-1?bucket_uuid=37e1c1dfc17d74c80c5e3cbbacf57069",
+  "nodes": [
+    {
+      "couchApiBase": "http://10.0.0.233:8092/bucket-1%2B37e1c1dfc17d74c80c5e3cbbacf57069",
+      "hostname": "10.0.0.233:8091",
+      "ports": {
+        "proxy": 11211,
+        "direct": 11210
+      }
+    },
+    {
+      "couchApiBase": "http://10.0.0.234:8092/bucket-1%2B37e1c1dfc17d74c80c5e3cbbacf57069",
+      "hostname": "10.0.0.234:8091",
+      "ports": {
+        "proxy": 11211,
+        "direct": 11210
+      }
+    },
+    {
+      "couchApiBase": "http://10.0.0.250:8092/bucket-1%2B37e1c1dfc17d74c80c5e3cbbacf57069",
+      "hostname": "10.0.0.250:8091",
+      "ports": {
+        "proxy": 11211,
+        "direct": 11210
+      }
+    }
+  ],
+  "nodesExt": [
+    {
+      "services": {
+        "mgmt": 8091,
+        "capi": 8092,
+        "meta": 10000,
+        "capiSSL": 18092,
+        "mgmtSSL": 18091,
+        "kv": 11210,
+        "projector": 9999,
+        "kvSSL": 11207,
+        "moxi": 11211
+      },
+      "hostname": "10.0.0.233"
+    },
+    {
+      "services": {
+        "mgmt": 8091,
+        "capi": 8092,
+        "meta": 10000,
+        "capiSSL": 18092,
+        "mgmtSSL": 18091,
+        "kv": 11210,
+        "projector": 9999,
+        "kvSSL": 11207,
+        "moxi": 11211
+      },
+      "hostname": "10.0.0.234"
+    },
+    {
+      "services": {
+        "mgmt": 8091,
+        "capi": 8092,
+        "meta": 10000,
+        "capiSSL": 18092,
+        "mgmtSSL": 18091,
+        "kv": 11210,
+        "projector": 9999,
+        "kvSSL": 11207,
+        "moxi": 11211
+      },
+      "thisNode": true,
+      "hostname": "10.0.0.250"
+    }
+  ],
+  "nodeLocator": "vbucket",
+  "uuid": "37e1c1dfc17d74c80c5e3cbbacf57069",
+  "ddocs": {
+    "uri": "/pools/default/buckets/bucket-1/ddocs"
+  },
+  "vBucketServerMap": {
+    "hashAlgorithm": "CRC",
+    "numReplicas": 1,
+    "serverList": [
+      "10.0.0.233:11210",
+      "10.0.0.234:11210",
+      "10.0.0.250:11210"
+    ],
+    "vBucketMap": []
+  },
+  "bucketCapabilitiesVer": "",
+  "bucketCapabilities": [
+    "cbhello",
+    "touch",
+    "couchapi",
+    "cccp",
+    "xdcrCheckpointing",
+    "nodesExt"
+  ]
+}