mt-libcouchbase 1.4.0

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

@@ -0,0 +1,156 @@
+#include "iotests.h"
+
+using namespace std;
+class ObseqnoTest : public MockUnitTest {
+};
+
+extern "C" {
+static void storeCb_getstok(lcb_t, int cbtype, const lcb_RESPBASE *rb)
+{
+    EXPECT_EQ(LCB_SUCCESS, rb->rc);
+    const lcb_MUTATION_TOKEN *tmp = lcb_resp_get_mutation_token(cbtype, rb);
+    if (tmp) {
+        *(lcb_MUTATION_TOKEN *)rb->cookie = *tmp;
+    }
+}
+}
+
+static void
+storeGetStok(lcb_t instance, const string& k, const string& v, lcb_MUTATION_TOKEN *st)
+{
+    lcb_RESPCALLBACK oldcb = lcb_get_callback3(instance, LCB_CALLBACK_STORE);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, storeCb_getstok);
+    lcb_sched_enter(instance);
+    lcb_CMDSTORE cmd = { 0 };
+    LCB_CMD_SET_KEY(&cmd, k.c_str(), k.size());
+    LCB_CMD_SET_VALUE(&cmd, v.c_str(), v.size());
+    cmd.operation = LCB_SET;
+
+    lcb_error_t rc = lcb_store3(instance, st, &cmd);
+    EXPECT_EQ(LCB_SUCCESS, rc);
+    lcb_sched_leave(instance);
+    lcb_wait(instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, oldcb);
+}
+
+TEST_F(ObseqnoTest, testFetchImplicit) {
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+    lcb_error_t rc;
+    createConnection(hw, instance);
+    const char *key = "obseqBasic";
+    const char *value = "value";
+
+    rc = lcb_cntl_string(instance, "dur_mutation_tokens", "true");
+    ASSERT_EQ(LCB_SUCCESS, rc);
+
+    lcb_MUTATION_TOKEN st_fetched = { 0 };
+    storeGetStok(instance, key, value, &st_fetched);
+    ASSERT_TRUE(st_fetched.uuid_ != 0);
+
+    lcb_KEYBUF kb;
+    LCB_KREQ_SIMPLE(&kb, key, strlen(key));
+
+    const lcb_MUTATION_TOKEN *ss = lcb_get_mutation_token(instance, &kb, &rc);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_TRUE(ss != NULL);
+    ASSERT_EQ(ss->uuid_, st_fetched.uuid_);
+    ASSERT_EQ(ss->vbid_, st_fetched.vbid_);
+    ASSERT_EQ(ss->seqno_, st_fetched.seqno_);
+}
+
+extern "C" {
+static void
+obseqCallback(lcb_t, int, const lcb_RESPBASE *rb) {
+    lcb_RESPOBSEQNO *pp = (lcb_RESPOBSEQNO *)rb->cookie;
+    *pp = *(const lcb_RESPOBSEQNO *)rb;
+}
+}
+
+static void
+doObserveSeqno(lcb_t instance, const lcb_MUTATION_TOKEN *ss, int server, lcb_RESPOBSEQNO& resp) {
+    lcb_CMDOBSEQNO cmd = { 0 };
+    cmd.vbid = ss->vbid_;
+    cmd.uuid = ss->uuid_;
+    cmd.server_index = server;
+    lcb_error_t rc;
+
+    lcb_sched_enter(instance);
+    rc = lcb_observe_seqno3(instance, &resp, &cmd);
+    if (rc != LCB_SUCCESS) {
+        resp.rc = rc;
+        resp.rflags |= LCB_RESP_F_CLIENTGEN;
+        return;
+    }
+
+    lcb_RESPCALLBACK oldcb = lcb_get_callback3(instance, LCB_CALLBACK_OBSEQNO);
+    lcb_install_callback3(instance, LCB_CALLBACK_OBSEQNO, obseqCallback);
+    lcb_sched_leave(instance);
+    lcb_wait(instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_OBSEQNO, oldcb);
+}
+
+TEST_F(ObseqnoTest, testObserve) {
+    SKIP_UNLESS_MOCK();
+
+    HandleWrap hw;
+    lcb_t instance;
+    createConnection(hw, instance);
+    lcbvb_CONFIG *vbc;
+
+    lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_VBCONFIG, &vbc);
+
+    lcb_MUTATION_TOKEN st_fetched = { 0 };
+    const char *key = "testObserve";
+    const char *value = "value";
+
+    // Get the synctoken
+    storeGetStok(instance, key, value, &st_fetched);
+    ASSERT_TRUE(LCB_MUTATION_TOKEN_ISVALID(&st_fetched));
+
+    for (size_t ii = 0; ii < lcbvb_get_nreplicas(vbc)+1; ii++) {
+        int ix = lcbvb_vbserver(vbc, st_fetched.vbid_, ii);
+        lcb_RESPOBSEQNO resp = { 0 };
+        doObserveSeqno(instance, &st_fetched, ix, resp);
+        ASSERT_EQ(LCB_SUCCESS, resp.rc);
+        ASSERT_EQ(st_fetched.uuid_, resp.cur_uuid);
+        ASSERT_EQ(0, resp.old_uuid);
+//        printf("SEQ_MEM: %lu. SEQ_DISK: %lu\n", resp.mem_seqno, resp.persisted_seqno);
+        ASSERT_GT(resp.mem_seqno, 0);
+        ASSERT_EQ(resp.mem_seqno, resp.persisted_seqno);
+    }
+}
+
+TEST_F(ObseqnoTest, testFailoverFormat) {
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+    createConnection(hw, instance);
+    lcbvb_CONFIG *vbc;
+
+    lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_VBCONFIG, &vbc);
+    const char *key = "testObserve";
+    const char *value = "value";
+
+    lcb_MUTATION_TOKEN st_fetched = { 0 };
+    storeGetStok(instance, key, value, &st_fetched);
+
+    MockEnvironment *env = MockEnvironment::getInstance();
+    env->regenVbCoords();
+
+    // Now we should get a different sequence number
+    lcb_RESPOBSEQNO rr;
+    doObserveSeqno(instance, &st_fetched, lcbvb_vbmaster(vbc, st_fetched.vbid_), rr);
+    ASSERT_EQ(LCB_SUCCESS, rr.rc);
+//    printf("Old UUID: %llu\n", rr.old_uuid);
+//    printf("Cur UUID: %llu\n", rr.cur_uuid);
+    ASSERT_GT(rr.old_uuid, 0);
+    ASSERT_EQ(rr.old_uuid, st_fetched.uuid_);
+    ASSERT_NE(rr.old_uuid, rr.cur_uuid);
+    ASSERT_EQ(rr.old_seqno, st_fetched.seqno_);
+
+}
+
+// TODO: We should add more tests here, but in order to do this, we must
+// first validate the mock.

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

@@ -0,0 +1,321 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 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 "internal.h"
+#include "iotests.h"
+
+class RegressionUnitTest : public MockUnitTest
+{
+};
+
+static bool callbackInvoked = false;
+
+extern "C" {
+    static void get_callback(lcb_t, const void *cookie,
+                             lcb_error_t err, const lcb_get_resp_t *)
+    {
+        EXPECT_EQ(err, LCB_KEY_ENOENT);
+        int *counter_p = reinterpret_cast<int *>(const_cast<void *>(cookie));
+        EXPECT_TRUE(counter_p != NULL);
+        EXPECT_GT(*counter_p, 0);
+        *counter_p -= 1;
+        callbackInvoked = true;
+    }
+
+    static void stats_callback(lcb_t, const void *cookie, lcb_error_t err,
+                               const lcb_server_stat_resp_t *resp)
+    {
+        EXPECT_EQ(err, LCB_SUCCESS);
+        if (resp->v.v0.nkey == 0) {
+            int *counter_p = reinterpret_cast<int *>(const_cast<void *>(cookie));
+            *counter_p -= 1;
+        }
+        callbackInvoked = true;
+    }
+}
+
+TEST_F(RegressionUnitTest, CCBC_150)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    callbackInvoked = false;
+    lcb_set_get_callback(instance, get_callback);
+    lcb_set_stat_callback(instance, stats_callback);
+    lcb_uint32_t tmoval = 15000000;
+    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_OP_TIMEOUT, &tmoval);
+
+    lcb_get_cmd_t getCmd1("testGetMiss1");
+    lcb_get_cmd_t *getCmds[] = { &getCmd1 };
+
+    lcb_server_stats_cmd_t statCmd;
+    lcb_server_stats_cmd_t *statCmds[] = { &statCmd };
+    int ii;
+
+    // Lets spool up a lot of commands in one of the buffers so that we
+    // know we need to search for it a few times when we get responses..
+    int callbackCounter = 1000;
+    void *ptr = &callbackCounter;
+
+    for (ii = 0; ii < 1000; ++ii) {
+        EXPECT_EQ(LCB_SUCCESS, lcb_get(instance, ptr, 1, getCmds));
+    }
+
+    callbackCounter++;
+    EXPECT_EQ(LCB_SUCCESS, lcb_server_stats(instance, ptr, 1, statCmds));
+
+    callbackCounter += 1000;
+    for (ii = 0; ii < 1000; ++ii) {
+        EXPECT_EQ(LCB_SUCCESS, lcb_get(instance, ptr, 1, getCmds));
+    }
+
+    callbackCounter++;
+    EXPECT_EQ(LCB_SUCCESS, lcb_server_stats(instance, ptr, 1, statCmds));
+
+    callbackCounter++;
+    EXPECT_EQ(LCB_SUCCESS, lcb_server_stats(instance, ptr, 1, statCmds));
+
+    EXPECT_EQ(LCB_SUCCESS, lcb_wait(instance));
+    ASSERT_TRUE(callbackInvoked);
+    ASSERT_EQ(0, callbackCounter);
+}
+
+struct ccbc_275_info_st {
+    int call_count;
+    lcb_error_t last_err;
+};
+
+extern "C" {
+static void get_callback_275(lcb_t instance,
+                             const void *cookie,
+                             lcb_error_t err,
+                             const lcb_get_resp_t *)
+{
+    struct ccbc_275_info_st *info = (struct ccbc_275_info_st *)cookie;
+    info->call_count++;
+    info->last_err = err;
+    lcb_breakout(instance);
+}
+
+}
+
+TEST_F(RegressionUnitTest, CCBC_275)
+{
+    SKIP_UNLESS_MOCK();
+    lcb_t instance;
+    lcb_error_t err;
+    struct lcb_create_st crOpts;
+    const char *argv[] = { "--buckets", "protected:secret:couchbase", NULL };
+    MockEnvironment mock_o(argv, "protected"), *mock = &mock_o;
+    struct ccbc_275_info_st info = { 0, LCB_SUCCESS };
+
+    mock->makeConnectParams(crOpts, NULL);
+    crOpts.v.v0.user = "protected";
+    crOpts.v.v0.passwd = "secret";
+    crOpts.v.v0.bucket = "protected";
+    doLcbCreate(&instance, &crOpts, mock);
+
+    err = lcb_connect(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    err = lcb_wait(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    std::string key = "key_CCBC_275";
+    lcb_get_cmd_t cmd, *cmdp;
+    memset(&cmd, 0, sizeof(cmd));
+    cmd.v.v0.key = key.c_str();
+    cmd.v.v0.nkey = key.size();
+    cmdp = &cmd;
+
+    // Set timeout for a short interval
+    lcb_uint32_t tmo_usec = 100000;
+    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_OP_TIMEOUT, &tmo_usec);
+
+    // In the past this issue would result in several symptoms:
+    // (1) the client would crash (ringbuffer_consumed in failout_server)
+    // (2) the client would hang
+    // (3) the subsequent lcb_wait would return immediately.
+    // So far I've managed to reproduce (1), not clear on (2) and (3)
+    mock->hiccupNodes(1000, 1);
+    lcb_set_get_callback(instance, get_callback_275);
+
+    err = lcb_get(instance, &info, 1, &cmdp);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_wait(instance);
+    ASSERT_EQ(1, info.call_count);
+
+    ASSERT_ERRISA(info.last_err, LCB_ERRTYPE_NETWORK);
+
+    // Make sure we've fully purged and disconnected the server
+    struct lcb_cntl_vbinfo_st vbi;
+    memset(&vbi, 0, sizeof(vbi));
+    vbi.v.v0.key = key.c_str();
+    vbi.v.v0.nkey = key.size();
+    err = lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_VBMAP, &vbi);
+    ASSERT_EQ(LCB_SUCCESS, err);
+//    ASSERT_EQ(LCB_CONNSTATE_UNINIT,
+//              instance->servers[vbi.v.v0.server_index].connection.state);
+
+    // Restore the timeout to something sane
+    tmo_usec = 5000000;
+    err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_OP_TIMEOUT, &tmo_usec);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    mock->hiccupNodes(0, 0);
+    info.call_count = 0;
+    err = lcb_get(instance, &info, 1, &cmdp);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_wait(instance);
+    ASSERT_EQ(1, info.call_count);
+
+    ASSERT_EQ(LCB_KEY_ENOENT, info.last_err);
+
+    lcb_destroy(instance);
+}
+
+
+TEST_F(MockUnitTest, testIssue59)
+{
+    // lcb_wait() blocks forever if there is nothing queued
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    lcb_wait(instance);
+    lcb_wait(instance);
+    lcb_wait(instance);
+    lcb_wait(instance);
+    lcb_wait(instance);
+    lcb_wait(instance);
+    lcb_wait(instance);
+    lcb_wait(instance);
+}
+
+
+extern "C" {
+    struct rvbuf {
+        lcb_error_t error;
+        lcb_cas_t cas1;
+        lcb_cas_t cas2;
+        char *bytes;
+        lcb_size_t nbytes;
+        lcb_int32_t counter;
+    };
+
+    static void df_store_callback1(lcb_t instance,
+                                   const void *cookie,
+                                   lcb_storage_t,
+                                   lcb_error_t error,
+                                   const lcb_store_resp_t *)
+    {
+        struct rvbuf *rv = (struct rvbuf *)cookie;
+        rv->error = error;
+        lcb_stop_loop(instance);
+    }
+
+    static void df_store_callback2(lcb_t instance,
+                                   const void *cookie,
+                                   lcb_storage_t,
+                                   lcb_error_t error,
+                                   const lcb_store_resp_t *resp)
+    {
+        struct rvbuf *rv = (struct rvbuf *)cookie;
+        rv->error = error;
+        rv->cas2 = resp->v.v0.cas;
+        lcb_stop_loop(instance);
+    }
+
+    static void df_get_callback(lcb_t instance,
+                                const void *cookie,
+                                lcb_error_t error,
+                                const lcb_get_resp_t *resp)
+    {
+        struct rvbuf *rv = (struct rvbuf *)cookie;
+        const char *value = "{\"bar\"=>1, \"baz\"=>2}";
+        lcb_size_t nvalue = strlen(value);
+        lcb_error_t err;
+
+        rv->error = error;
+        rv->cas1 = resp->v.v0.cas;
+        lcb_store_cmd_t storecmd(LCB_SET, resp->v.v0.key, resp->v.v0.nkey,
+                                 value, nvalue, 0, 0, resp->v.v0.cas);
+        lcb_store_cmd_t *storecmds[] = { &storecmd };
+
+        err = lcb_store(instance, rv, 1, storecmds);
+        ASSERT_EQ(LCB_SUCCESS, err);
+    }
+}
+
+TEST_F(MockUnitTest, testDoubleFreeError)
+{
+    lcb_error_t err;
+    struct rvbuf rv;
+    const char *key = "test_compare_and_swap_async_", *value = "{\"bar\" => 1}";
+    lcb_size_t nkey = strlen(key), nvalue = strlen(value);
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    /* prefill the bucket */
+    (void)lcb_set_store_callback(instance, df_store_callback1);
+
+    lcb_store_cmd_t storecmd(LCB_SET, key, nkey, value, nvalue);
+    lcb_store_cmd_t *storecmds[] = { &storecmd };
+
+    err = lcb_store(instance, &rv, 1, storecmds);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_run_loop(instance);
+    ASSERT_EQ(LCB_SUCCESS, rv.error);
+
+    /* run exercise
+     *
+     * 1. get the valueue and its cas
+     * 2. atomic set new valueue using old cas
+     */
+    (void)lcb_set_store_callback(instance, df_store_callback2);
+    (void)lcb_set_get_callback(instance, df_get_callback);
+
+    lcb_get_cmd_t getcmd(key, nkey);
+    lcb_get_cmd_t *getcmds[] = { &getcmd };
+
+    err = lcb_get(instance, &rv, 1, getcmds);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    rv.cas1 = rv.cas2 = 0;
+    lcb_run_loop(instance);
+    ASSERT_EQ(LCB_SUCCESS, rv.error);
+    ASSERT_GT(rv.cas1, 0);
+    ASSERT_GT(rv.cas2, 0);
+    ASSERT_NE(rv.cas1, rv.cas2);
+}
+
+TEST_F(MockUnitTest, testBrokenFirstNodeInList)
+{
+    MockEnvironment *mock = MockEnvironment::getInstance();
+    lcb_create_st options;
+    mock->makeConnectParams(options, NULL);
+    std::string nodes = options.v.v0.host;
+    nodes = "1.2.3.4:4321;" + nodes;
+    options.v.v0.host = nodes.c_str();
+
+    lcb_t instance;
+    doLcbCreate(&instance, &options, mock);
+    lcb_cntl_setu32(instance, LCB_CNTL_OP_TIMEOUT, LCB_MS2US(200));
+    ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+    lcb_destroy(instance);
+}

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

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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 <libcouchbase/couchbase.h>
+#include <map>
+#include "iotests.h"
+#include "internal.h"
+
+class SchedUnitTests : public MockUnitTest
+{
+};
+
+static bool
+hasPendingOps(lcb_t instance)
+{
+    for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
+        if (instance->get_server(ii)->has_pending()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void
+opCallback(lcb_t, int, const lcb_RESPBASE *rb) {
+    size_t *counter = reinterpret_cast<size_t*>(rb->cookie);
+    *counter += 1;
+}
+
+TEST_F(SchedUnitTests, testSched)
+{
+    HandleWrap hw;
+    lcb_t instance;
+    lcb_error_t rc;
+    size_t counter;
+    createConnection(hw, instance);
+
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, opCallback);
+
+    // lcb_store3
+    lcb_CMDSTORE scmd = { 0 };
+    LCB_CMD_SET_KEY(&scmd, "key", 3);
+    LCB_CMD_SET_VALUE(&scmd, "val", 3);
+    scmd.operation = LCB_SET;
+
+    rc = lcb_store3(instance, &counter, &scmd);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_TRUE(hasPendingOps(instance));
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    ASSERT_FALSE(hasPendingOps(instance));
+
+    lcb_sched_enter(instance);
+    rc = lcb_store3(instance, &counter, &scmd);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_FALSE(hasPendingOps(instance));
+    lcb_sched_leave(instance);
+    ASSERT_TRUE(hasPendingOps(instance));
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    ASSERT_FALSE(hasPendingOps(instance));
+
+    // Try with multiple operations..
+    counter = 0;
+    for (size_t ii = 0; ii < 5; ++ii) {
+        rc = lcb_store3(instance, &counter, &scmd);
+    }
+
+    ASSERT_TRUE(hasPendingOps(instance));
+    lcb_sched_enter(instance);
+    rc = lcb_store3(instance, &counter, &scmd);
+    lcb_sched_fail(instance);
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    ASSERT_EQ(5, counter);
+}