libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/tests/iotests/mock-environment.h

@@ -225,8 +225,11 @@ class MockEnvironment : public ::testing::Environment
 public:
     enum ServerVersion {
         VERSION_UNKNOWN = 0,
-        VERSION_10 = 1,
-        VERSION_20 = 2
+        VERSION_40 = 4,
+        VERSION_41 = 5,
+        VERSION_45 = 6,
+        VERSION_46 = 7,
+        VERSION_50 = 8
     };
 
     virtual void SetUp();
@@ -273,7 +276,7 @@ public:
      * @param index the index of the node on the mock
      * @param bucket the name of the bucket
      */
-    void failoverNode(int index, std::string bucket = "default");
+    void failoverNode(int index, std::string bucket = "default", bool rebalance = true);
 
     /**
      * Simulate node reconvering. In this case mock will enable server
@@ -373,7 +376,7 @@ public:
 
     static void printSkipMessage(std::string file, int line, std::string reason) {
         std::cerr << "Skipping " << file << ":" << std::dec << line;
-        std::cerr << "(" << reason << ")";
+        std::cerr << " (" << reason << ")";
         std::cerr << std::endl;
     }
 
@@ -431,5 +434,21 @@ private:
         return; \
     }
 
+#define CLUSTER_VERSION_IS_HIGHER_THAN(v)                                                                              \
+    (MockEnvironment::getInstance()->isRealCluster() && MockEnvironment::getInstance()->getServerVersion() >= v)
 
+#define SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(v)                                                                      \
+    if (CLUSTER_VERSION_IS_HIGHER_THAN(v)) {                                                                           \
+        MockEnvironment::printSkipMessage(__FILE__, __LINE__, "needs lower cluster version");                          \
+        return;                                                                                                        \
+    }
+
+#define CLUSTER_VERSION_IS_LOWER_THAN(v)                                                                               \
+    (MockEnvironment::getInstance()->isRealCluster() && MockEnvironment::getInstance()->getServerVersion() < v)
+
+#define SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(v)                                                                       \
+    if (CLUSTER_VERSION_IS_LOWER_THAN(v)) {                                                                            \
+        MockEnvironment::printSkipMessage(__FILE__, __LINE__, "needs higher cluster version");                         \
+        return;                                                                                                        \
+    }
 #endif

data/ext/libcouchbase/tests/iotests/mock-unit-test.h

@@ -24,16 +24,16 @@
 
 class HandleWrap;
 
-#define SKIP_IF_MOCK()                                                  \
-    if (!getenv(LCB_TEST_REALCLUSTER_ENV)) {                            \
-         std::cerr << "Skipping: Need real cluster\n" << std::endl; \
-        return;                                                         \
+#define SKIP_IF_MOCK()                                                                                                 \
+    if (!getenv(LCB_TEST_REALCLUSTER_ENV)) {                                                                           \
+        MockEnvironment::printSkipMessage(__FILE__, __LINE__, "needs real cluster");                                   \
+        return;                                                                                                        \
     }
 
-#define SKIP_UNLESS_MOCK() \
-    if (getenv(LCB_TEST_REALCLUSTER_ENV)) { \
-        std::cerr << "Skipping: Need mock cluster\n" << std::endl; \
-        return; \
+#define SKIP_UNLESS_MOCK()                                                                                             \
+    if (getenv(LCB_TEST_REALCLUSTER_ENV)) {                                                                            \
+        MockEnvironment::printSkipMessage(__FILE__, __LINE__, "needs mock cluster");                                   \
+        return;                                                                                                        \
     }
 
 #define ASSERT_ERRISA(err, et) \

data/ext/libcouchbase/tests/iotests/t_behavior.cc

@@ -201,20 +201,20 @@ TEST_F(Behavior, BadPluginEnvironment)
     setPluginEnv("foobarbaz", "non_existent_symbol");
     err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &info);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(info.v.v0.os_default, EXPECTED_DEFAULT);
-    ASSERT_EQ(info.v.v0.effective, 0);
+    ASSERT_EQ(EXPECTED_DEFAULT, info.v.v0.os_default);
+    ASSERT_EQ(0, info.v.v0.effective);
 
     lcb_t instance2;
-    ASSERT_EQ(lcb_create(&instance2, NULL), LCB_DLOPEN_FAILED);
+    ASSERT_EQ(LCB_DLOPEN_FAILED, lcb_create(&instance2, NULL));
 
     setPluginEnv("foobarbaz", "");
-    ASSERT_EQ(lcb_create(&instance2, NULL), LCB_BAD_ENVIRONMENT);
+    ASSERT_EQ(LCB_BAD_ENVIRONMENT, lcb_create(&instance2, NULL));
 
     // Find a DLL that we know can be loaded, but doesn't have the symbols
     // we need. For windows, we use the unqualified name,
     const char *dllname = TEST_SHARED_OBJECT;
 
     setPluginEnv(dllname, "nonexist-symbol");
-    ASSERT_EQ(lcb_create(&instance2, NULL), LCB_DLSYM_FAILED);
+    ASSERT_EQ(LCB_DLSYM_FAILED, lcb_create(&instance2, NULL));
 
 }

data/ext/libcouchbase/tests/iotests/t_durability.cc

@@ -1056,3 +1056,53 @@ TEST_F(DurabilityUnitTest, testDurStore)
         lcb_log(LOGARGS(instance, WARN), "Test skipped because mock is too fast(!)");
     }
 }
+
+TEST_F(DurabilityUnitTest, testFailoverAndSeqno)
+{
+    SKIP_UNLESS_MOCK();
+
+    // Disable CCCP so that we get streaming updates
+    MockEnvironment *mock = MockEnvironment::getInstance();
+    mock->setCCCP(false);
+
+    HandleWrap hwrap;
+    lcb_t instance;
+    lcb_durability_opts_t opts = { 0 };
+    string key = "key-failover-seqno";
+    Item itm = Item(key, key);
+    KVOperation kvo(&itm);
+
+    createConnection(hwrap);
+    instance = hwrap.getLcb();
+
+    kvo.store(instance);
+
+    defaultOptions(instance, opts);
+    DurabilityOperation dop;
+
+    /* make sure that seqno works on healthy cluster */
+    opts.version = 1;
+    opts.v.v0.pollopts = LCB_DURABILITY_MODE_SEQNO;
+    dop = DurabilityOperation();
+    dop.run(instance, &opts, kvo.result);
+    ASSERT_EQ(LCB_SUCCESS, dop.resp.rc);
+
+    /* failover all nodes but master */
+    lcbvb_CONFIG *vbc;
+    ASSERT_EQ(LCB_SUCCESS, lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_VBCONFIG, &vbc));
+    int vbid, srvix;
+    lcbvb_map_key(vbc, key.c_str(), key.size(), &vbid, &srvix);
+    for (size_t jj = 0; jj < lcbvb_get_nreplicas(vbc); jj++) {
+        int rix = lcbvb_vbreplica(vbc, vbid, jj);
+        mock->failoverNode(rix, "default", false);
+    }
+
+    /* make sure that client gets new configration */
+    instance->bs_state->reset_last_refresh();
+    instance->confmon->stop();
+    instance->bootstrap(lcb::BS_REFRESH_ALWAYS);
+
+    dop = DurabilityOperation();
+    dop.run(instance, &opts, kvo.result);
+    ASSERT_EQ(LCB_DURABILITY_ETOOMANY, dop.resp.rc);
+}

data/ext/libcouchbase/tests/iotests/t_eerrs.cc

@@ -22,8 +22,10 @@ protected:
     void checkRetryVerify(uint16_t errcode);
 
     void TearDown() {
-        MockOpFailClearCommand clearCmd(MockEnvironment::getInstance()->getNumNodes());
-        doMockTxn(clearCmd);
+        if (!MockEnvironment::getInstance()->isRealCluster()) {
+            MockOpFailClearCommand clearCmd(MockEnvironment::getInstance()->getNumNodes());
+            doMockTxn(clearCmd);
+        }
         MockUnitTest::TearDown();
     }
 };

data/ext/libcouchbase/tests/iotests/t_errmap.cc

@@ -16,8 +16,10 @@ protected:
     void checkRetryVerify(uint16_t errcode);
 
     void TearDown() {
-        MockOpFailClearCommand clearCmd(MockEnvironment::getInstance()->getNumNodes());
-        doMockTxn(clearCmd);
+        if (!MockEnvironment::getInstance()->isRealCluster()) {
+            MockOpFailClearCommand clearCmd(MockEnvironment::getInstance()->getNumNodes());
+            doMockTxn(clearCmd);
+        }
         MockUnitTest::TearDown();
     }
 };
@@ -152,7 +154,7 @@ void ErrmapUnitTest::checkRetryVerify(uint16_t errcode) {
 #ifdef __APPLE__
     // FIXME: on Jenkins OSX actual expected time does not match actual and mock raises exception like following:
     // VerificationException: Not enough/too many retries. Last TS=1498594892704. Last expected=1498594892728. Diff=24. MaxDiff=20
-    verifyCmd.set("fuzz_ms", 25);
+    verifyCmd.set("fuzz_ms", 35);
 #else
     verifyCmd.set("fuzz_ms", 20);
 #endif
@@ -174,5 +176,6 @@ TEST_F(ErrmapUnitTest, retrySpecLinear) {
 }
 
 TEST_F(ErrmapUnitTest, retrySpecExponential) {
+    SKIP_UNLESS_MOCK();
     checkRetryVerify(ERRCODE_EXPONENTIAL);
 }

data/ext/libcouchbase/tests/iotests/t_lock.cc

@@ -122,12 +122,11 @@ TEST_F(LockUnitTest, testUnlockMissingCas)
     err = lcb_unlock(instance, &reserr, 1, &cmdlist);
     ASSERT_EQ(LCB_SUCCESS, err);
     lcb_wait(instance);
-
-    /**
-     * maybe I mis-understood lock, but isn't it an error to use unlock
-     * without a valid CAS? -
-     */
-    ASSERT_EQ(LCB_ETMPFAIL, reserr);
+    if (CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_50)) {
+        ASSERT_EQ(LCB_EINVAL_MCD, reserr);
+    } else {
+        ASSERT_EQ(LCB_ETMPFAIL, reserr);
+    }
 }
 
 extern "C" {

data/ext/libcouchbase/tests/iotests/t_misc.cc

@@ -715,6 +715,7 @@ TEST_F(MockUnitTest, testEmptyCtx)
 
 TEST_F(MockUnitTest, testMultiCreds)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_50);
     using lcb::Authenticator;
 
     HandleWrap hw;
@@ -731,3 +732,46 @@ TEST_F(MockUnitTest, testMultiCreds)
     ASSERT_NE(auth.buckets().end(), res);
     ASSERT_EQ("secret", res->second);
 }
+
+extern "C" {
+static void appendE2BIGcb(lcb_t, int, const lcb_RESPBASE *rb)
+{
+    lcb_error_t *e = (lcb_error_t *)rb->cookie;
+    *e = rb->rc;
+}
+}
+
+TEST_F(MockUnitTest, testAppendE2BIG)
+{
+    HandleWrap hw;
+    lcb_t instance;
+    createConnection(hw, instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, appendE2BIGcb);
+
+    lcb_error_t err, res;
+
+    const char *key = "key";
+    size_t nkey = strlen(key);
+
+    size_t nvalue1 = 20 * 1024 * 1024;
+    void *value1 = malloc(nvalue1);
+    lcb_CMDSTORE scmd = { 0 };
+    scmd.operation = LCB_SET;
+    LCB_CMD_SET_KEY(&scmd, key, nkey);
+    LCB_CMD_SET_VALUE(&scmd, value1, nvalue1);
+    err = lcb_store3(instance, &res, &scmd);
+    lcb_wait(instance);
+    ASSERT_EQ(LCB_SUCCESS, res);
+    free(value1);
+
+    size_t nvalue2 = 1 * 1024 * 1024;
+    void *value2 = malloc(nvalue2);
+    lcb_CMDSTORE acmd = { 0 };
+    acmd.operation = LCB_APPEND;
+    LCB_CMD_SET_KEY(&acmd, key, nkey);
+    LCB_CMD_SET_VALUE(&acmd, value2, nvalue2);
+    err = lcb_store3(instance, &res, &acmd);
+    lcb_wait(instance);
+    ASSERT_EQ(LCB_E2BIG, res);
+    free(value2);
+}

data/ext/libcouchbase/tests/iotests/t_serverops.cc

@@ -148,6 +148,7 @@ extern "C" {
  */
 TEST_F(ServeropsUnitTest, testFlush)
 {
+    SKIP_UNLESS_MOCK();
     lcb_t instance;
     HandleWrap hw;
     createConnection(hw, instance);

data/ext/libcouchbase/tests/iotests/t_subdoc.cc

@@ -295,6 +295,7 @@ verifyPathValue(const char *, const char *, const char *, const char *,
 
 TEST_F(SubdocUnitTest, testSdGetExists)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_45);
     HandleWrap hw;
     lcb_t instance;
     CREATE_SUBDOC_CONNECTION(hw, instance);
@@ -400,6 +401,7 @@ TEST_F(SubdocUnitTest, testSdGetExists)
 
 TEST_F(SubdocUnitTest, testSdStore)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_45);
     HandleWrap hw;
     lcb_t instance;
     CREATE_SUBDOC_CONNECTION(hw, instance);
@@ -490,6 +492,7 @@ TEST_F(SubdocUnitTest, testSdStore)
 }
 
 TEST_F(SubdocUnitTest, testMkdoc) {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_50);
     HandleWrap hw;
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };
@@ -527,6 +530,7 @@ TEST_F(SubdocUnitTest, testMkdoc) {
 
 TEST_F(SubdocUnitTest, testUnique)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_45);
     HandleWrap hw;
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };
@@ -577,6 +581,7 @@ TEST_F(SubdocUnitTest, testUnique)
 
 TEST_F(SubdocUnitTest, testCounter)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_45);
     HandleWrap hw;
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };
@@ -610,6 +615,12 @@ TEST_F(SubdocUnitTest, testCounter)
     spec.sdcmd = LCB_SDCMD_COUNTER;
     LCB_SDSPEC_SET_VALUE(&spec, "1", 1);
     ASSERT_EQ(LCB_SUCCESS, schedwait(instance, &res, &cmd, lcb_subdoc3));
+    ASSERT_SD_ERR(res, LCB_SUBDOC_VALUE_CANTINSERT);
+
+    // Try to increment by 0
+    spec.sdcmd = LCB_SDCMD_COUNTER;
+    LCB_SDSPEC_SET_VALUE(&spec, "0", 1);
+    ASSERT_EQ(LCB_SUCCESS, schedwait(instance, &res, &cmd, lcb_subdoc3));
     ASSERT_SD_ERR(res, LCB_SUBDOC_BAD_DELTA);
 
     // Try to use an already large number (so the number is too big on the server)
@@ -653,6 +664,7 @@ TEST_F(SubdocUnitTest, testCounter)
 
 TEST_F(SubdocUnitTest, testMultiLookup)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_45);
     HandleWrap hw;
     lcb_t instance;
     CREATE_SUBDOC_CONNECTION(hw, instance);
@@ -724,6 +736,7 @@ TEST_F(SubdocUnitTest, testMultiLookup)
 
 TEST_F(SubdocUnitTest, testMultiMutations)
 {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_45);
     HandleWrap hw;
     lcb_t instance;
     CREATE_SUBDOC_CONNECTION(hw, instance);
@@ -789,9 +802,24 @@ TEST_F(SubdocUnitTest, testMultiMutations)
     ASSERT_EQ(1, mr.size());
     ASSERT_EQ(LCB_SUBDOC_PATH_ENOENT, mr.results[0].rc);
     ASSERT_EQ(1, mr.results[0].index);
+
+    /* check if lcb_subdoc3 can detect mutation, and allow setting exptime */
+    specs.clear();
+    mcmd.multimode = 0;
+    mcmd.exptime = 42;
+
+    LCB_SDSPEC_INIT(&spec, LCB_SDCMD_DICT_UPSERT, "tmpPath", strlen("tmpPath"), "null", 4);
+    specs.push_back(spec);
+    mcmd.specs = &specs[0];
+    mcmd.nspecs = specs.size();
+    ASSERT_EQ(LCB_SUCCESS, schedwait(instance, &mr, &mcmd, lcb_subdoc3));
+    ASSERT_EQ(LCB_SUCCESS, mr.rc);
+    ASSERT_EQ(1, mr.size());
+    ASSERT_EQ(LCB_SUCCESS, mr.results[0].rc);
 }
 
 TEST_F(SubdocUnitTest, testGetCount) {
+    SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_50);
     HandleWrap hw;
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };

data/ext/libcouchbase/tests/iotests/t_views.cc

@@ -34,14 +34,15 @@ ViewsUnitTest::connectBeerSample(HandleWrap& hw, lcb_t& instance, bool first)
     MockEnvironment::getInstance()->makeConnectParams(crparams, NULL);
     crparamsAdmin = crparams;
 
-    // We could do CCCP if we really cared.. but it's simpler and makes
-    // the logs cleaner.
     crparams.v.v2.bucket = "beer-sample";
-    crparams.v.v2.user = "beer-sample";
-    crparams.v.v2.mchosts = NULL;
-    lcb_config_transport_t transports[] = {
-            LCB_CONFIG_TRANSPORT_HTTP, LCB_CONFIG_TRANSPORT_LIST_END };
-    crparams.v.v2.transports = transports;
+    if (!CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_50)) {
+        // We could do CCCP if we really cared.. but it's simpler and makes
+        // the logs cleaner.
+        crparams.v.v2.user = "beer-sample";
+        crparams.v.v2.mchosts = NULL;
+        lcb_config_transport_t transports[] = {LCB_CONFIG_TRANSPORT_HTTP, LCB_CONFIG_TRANSPORT_LIST_END};
+        crparams.v.v2.transports = transports;
+    }
 
     // See if we can connect:
     lcb_error_t rv = tryCreateConnection(hw, instance, crparams);
@@ -147,8 +148,12 @@ struct ViewInfo {
                 cJSON *cj = cJSON_Parse(resp->value);
                 ASSERT_FALSE(cj == NULL);
                 cJSON *jTotal = cJSON_GetObjectItem(cj, "total_rows");
-                ASSERT_FALSE(jTotal == NULL);
-                totalRows = jTotal->valueint;
+                if (jTotal != NULL) {
+                    totalRows = jTotal->valueint;
+                } else {
+                    // Reduce responses might skip total_rows
+                    totalRows = rows.size();
+                }
                 cJSON_Delete(cj);
             }
             if (resp->htresp) {
@@ -274,8 +279,8 @@ TEST_F(ViewsUnitTest, testReduce) {
     rc = lcb_view_query(instance, &vi, &vq);
     ASSERT_EQ(LCB_SUCCESS, rc);
     lcb_wait(instance);
-    ASSERT_EQ(1411, vi.totalRows);
     ASSERT_EQ(1, vi.rows.size());
+    ASSERT_STREQ("1411", vi.rows[0].value.c_str());
 
     vi.clear();
     // Try with include_docs
@@ -401,5 +406,12 @@ TEST_F(ViewsUnitTest, testBackslashDocid)
     lcb_wait(instance);
     ASSERT_EQ(1, vi.rows.size());
     ASSERT_EQ(doc.size(), vi.rows[0].docContents.nvalue);
+
+    removeKey(instance, key);
+    vi.clear();
+    rc = lcb_view_query(instance, &vi, &cmd);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    lcb_wait(instance);
+    ASSERT_EQ(0, vi.rows.size());
 }
 }

data/ext/libcouchbase/tools/CMakeLists.txt

@@ -19,6 +19,13 @@ TARGET_LINK_LIBRARIES(cbc-n1qlback couchbase)
 INSTALL(TARGETS cbc cbc-pillowfight cbc-n1qlback
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
+FIND_PACKAGE(OpenSSL)
+IF(OPENSSL_FOUND AND (NOT LCB_NO_SSL))
+    INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
+    ADD_DEFINITIONS(${OPENSSL_DEFINITIONS})
+    TARGET_LINK_LIBRARIES(cbc ${OPENSSL_LIBRARIES})
+ENDIF()
+
 # Set this before INSTALL_PDBS in order to set the correct output name
 IF(MSVC)
     SET_TARGET_PROPERTIES(cbc PROPERTIES DEBUG_OUTPUT_NAME cbc_d)
@@ -38,9 +45,22 @@ IF(NOT WIN32)
     ADD_LIBRARY(linenoise OBJECT ${T_LINENOSE_SRC})
     SET_TARGET_PROPERTIES(linenoise PROPERTIES COMPILE_FLAGS "${LCB_CORE_CFLAGS}")
 
+    ADD_EXECUTABLE(cbc-subdoc cbc-subdoc.cc $<TARGET_OBJECTS:lcbtools> $<TARGET_OBJECTS:cliopts> $<TARGET_OBJECTS:linenoise>)
+    TARGET_LINK_LIBRARIES(cbc-subdoc couchbase)
+    INSTALL(TARGETS cbc-subdoc RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    SET_SOURCE_FILES_PROPERTIES(cbc-subdoc.cc PROPERTIES COMPILE_FLAGS "${LCB_CORE_CXXFLAGS}")
+
+    IF(HAVE_LIBEVENT2)
+      INCLUDE_DIRECTORIES(AFTER ${LIBEVENT_INCLUDE_DIR})
+      ADD_EXECUTABLE(cbc-proxy cbc-proxy.cc $<TARGET_OBJECTS:lcbtools> $<TARGET_OBJECTS:cliopts>)
+      TARGET_LINK_LIBRARIES(cbc-proxy couchbase ${LIBEVENT_LIBRARIES})
+      INSTALL(TARGETS cbc-proxy RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+      SET_SOURCE_FILES_PROPERTIES(cbc-proxy.cc PROPERTIES COMPILE_FLAGS "${LCB_CORE_CXXFLAGS}")
+    ENDIF()
+
     LIST(APPEND CBC_SUBCOMMANDS
         cat create observe observe-seqno incr decr mcflush hash lock
-        unlock rm stats version verbosity view n1ql admin
+        unlock rm stats version verbosity view n1ql admin ping
         bucket-create bucket-delete bucket-flush connstr write-config strerror
         touch role-list user-list user-upsert user-delete)