libcouchbase 0.3.3 → 1.0.0

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

@@ -902,7 +902,6 @@ TEST_F(DurabilityUnitTest, testOptionValidation)
     HandleWrap hw;
     lcb_t instance;
     lcb_U16 persist = 0, replicate = 0;
-    int options;
     lcb_error_t rc;
 
     createConnection(hw, instance);

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

@@ -0,0 +1,119 @@
+#include "config.h"
+#include "iotests.h"
+#include "internal.h"
+
+class EerrsUnitTest : public MockUnitTest {
+protected:
+    virtual void createEerrConnection(HandleWrap& hw, lcb_t& instance) {
+        MockEnvironment::getInstance()->createConnection(hw, instance);
+        ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+        lcb_wait(instance);
+        ASSERT_EQ(LCB_SUCCESS, lcb_get_bootstrap_status(instance));
+    }
+
+    void enableEnhancedErrors() {
+        MockEnvironment::getInstance()->setEnhancedErrors(true);
+    }
+
+    void disableEnhancedErrors() {
+        MockEnvironment::getInstance()->setEnhancedErrors(false);
+    }
+
+    void checkRetryVerify(uint16_t errcode);
+
+    void TearDown() {
+        MockOpFailClearCommand clearCmd(MockEnvironment::getInstance()->getNumNodes());
+        doMockTxn(clearCmd);
+        MockUnitTest::TearDown();
+    }
+};
+
+struct EerrsCookie {
+    lcb_error_t rc;
+    bool called;
+    char *err_ref;
+    char *err_ctx;
+
+    void reset() {
+        rc = LCB_SUCCESS;
+        called = false;
+        free(err_ref);
+        err_ref = NULL;
+        free(err_ctx);
+        err_ctx = NULL;
+    }
+    EerrsCookie() : rc(LCB_SUCCESS), called(false), err_ref(NULL), err_ctx(NULL) {
+    }
+
+    ~EerrsCookie() {
+        free(err_ref);
+        free(err_ctx);
+    }
+};
+
+extern "C" {
+static void opcb(lcb_t, int cbtype, const lcb_RESPBASE* rb) {
+    EerrsCookie *cookie = reinterpret_cast<EerrsCookie*>(rb->cookie);
+    cookie->called = true;
+    cookie->rc = rb->rc;
+
+    const char *ref = lcb_resp_get_error_ref(cbtype, rb);
+    if (ref != NULL) {
+        cookie->err_ref = strdup(ref);
+    }
+
+    const char *ctx = lcb_resp_get_error_context(cbtype, rb);
+    if (ctx != NULL) {
+        cookie->err_ctx = strdup(ctx);
+    }
+}
+}
+
+TEST_F(EerrsUnitTest, testInCallbackWhenEnabled) {
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+
+    enableEnhancedErrors();
+    createEerrConnection(hw, instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_DEFAULT, opcb);
+
+    EerrsCookie cookie;
+
+    std::string key("hello");
+    lcb_CMDGET cmd = { 0 };
+    LCB_CMD_SET_KEY(&cmd, key.c_str(), key.size());
+    cmd.lock = 10;
+    lcb_get3(instance, &cookie, &cmd);
+
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_KEY_ENOENT, cookie.rc);
+    ASSERT_NE((char *)NULL, cookie.err_ref);
+    ASSERT_EQ(36, strlen(cookie.err_ref)); // java.util.UUID generates 36-bytes long strings
+    ASSERT_STREQ("Failed to lookup item", cookie.err_ctx);
+}
+
+
+TEST_F(EerrsUnitTest, testInCallbackWhenDisabled) {
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+
+    disableEnhancedErrors();
+    createEerrConnection(hw, instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_DEFAULT, opcb);
+
+    EerrsCookie cookie;
+
+    std::string key("hello");
+    lcb_CMDGET cmd = { 0 };
+    LCB_CMD_SET_KEY(&cmd, key.c_str(), key.size());
+    cmd.lock = 10;
+    lcb_get3(instance, &cookie, &cmd);
+
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ((char *)NULL, cookie.err_ref);
+    ASSERT_EQ((char *)NULL, cookie.err_ctx);
+}

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

@@ -0,0 +1,178 @@
+#include "config.h"
+#include "iotests.h"
+#include "internal.h"
+#include <map>
+
+class ErrmapUnitTest : public MockUnitTest {
+protected:
+    virtual void createErrmapConnection(HandleWrap& hw, lcb_t& instance) {
+        MockEnvironment::getInstance()->createConnection(hw, instance);
+        ASSERT_EQ(LCB_SUCCESS, lcb_cntl_string(instance, "enable_errmap", "true"));
+        ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+        lcb_wait(instance);
+        ASSERT_EQ(LCB_SUCCESS, lcb_get_bootstrap_status(instance));
+    }
+
+    void checkRetryVerify(uint16_t errcode);
+
+    void TearDown() {
+        MockOpFailClearCommand clearCmd(MockEnvironment::getInstance()->getNumNodes());
+        doMockTxn(clearCmd);
+        MockUnitTest::TearDown();
+    }
+};
+
+struct ResultCookie {
+    lcb_error_t rc;
+    bool called;
+
+    void reset() {
+        rc = LCB_SUCCESS;
+        called = false;
+    }
+    ResultCookie() : rc(LCB_SUCCESS), called(false) {
+    }
+};
+
+extern "C" {
+static void opcb(lcb_t,int,const lcb_RESPBASE* rb) {
+    ResultCookie *cookie = reinterpret_cast<ResultCookie*>(rb->cookie);
+    cookie->called = true;
+    cookie->rc = rb->rc;
+}
+}
+
+TEST_F(ErrmapUnitTest, hasRecognizedErrors) {
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+
+    createErrmapConnection(hw, instance);
+
+    // Test the actual error map..
+    using namespace lcb;
+    const errmap::ErrorMap& em = *instance->settings->errmap;
+    const errmap::Error& err = em.getError(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
+    ASSERT_TRUE(err.isValid());
+    ASSERT_TRUE(err.hasAttribute(errmap::CONSTRAINT_FAILURE));
+}
+
+TEST_F(ErrmapUnitTest, closesOnUnrecognizedError) {
+    // For now, EINTERNAL is an error code we don't know!
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+    createErrmapConnection(hw, instance);
+
+    const char *key = "key";
+    lcb_CMDSTORE scmd = { 0 };
+    LCB_CMD_SET_KEY(&scmd, key, strlen(key));
+    LCB_CMD_SET_VALUE(&scmd, "val", 3);
+
+    ResultCookie cookie;
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, opcb);
+    ASSERT_EQ(LCB_SUCCESS, lcb_store3(instance, &cookie, &scmd));
+    lcb_wait(instance);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    MockCommand cmd(MockCommand::OPFAIL);
+
+    // Determine the server
+    int srvix = instance->map_key(key);
+
+    cmd.set("server", srvix);
+    cmd.set("code", PROTOCOL_BINARY_RESPONSE_EINTERNAL); // Invalidate the connection!
+    cmd.set("count", 1);
+    doMockTxn(cmd);
+
+    cookie.reset();
+    ASSERT_EQ(LCB_SUCCESS, lcb_store3(instance, &cookie, &scmd));
+    lcb_wait(instance);
+
+    ASSERT_TRUE(cookie.called);
+    ASSERT_NE(LCB_SUCCESS, cookie.rc);
+
+    cookie.reset();
+    ASSERT_EQ(LCB_SUCCESS, lcb_store3(instance, &cookie, &scmd));
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+
+    // Note, we can't determine what the actual error here is. It would be nice
+    // if we were able to reconnect and retry the other commands, but right now
+    // detecting a failed connection is better than having no detection at all:
+    //
+    // ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+}
+
+void ErrmapUnitTest::checkRetryVerify(uint16_t errcode) {
+    HandleWrap hw;
+    lcb_t instance;
+    createErrmapConnection(hw, instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_DEFAULT, opcb);
+
+    ResultCookie cookie;
+
+    std::string key("hello");
+    lcb_CMDSTORE scmd = { 0 };
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUE(&scmd, "Val", 3);
+
+    // Store the item once to ensure the server is actually connected
+    // (we don't want opfail to be active during negotiation).
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    // Figure out the server this key belongs to.
+    int srvix = instance->map_key(key);
+
+    MockCommand cmd(MockCommand::START_RETRY_VERIFY);
+    cmd.set("idx", srvix);
+    cmd.set("bucket", instance->get_bucketname());
+    doMockTxn(cmd);
+
+    // Set up opfail
+    MockOpfailCommand failCmd(errcode, srvix, -1, instance->get_bucketname());
+    doMockTxn(failCmd);
+
+    // Run the command!
+    cookie.reset();
+    lcb_error_t rc = lcb_store3(instance, &cookie, &scmd);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    lcb_wait(instance);
+
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_GENERIC_TMPERR, cookie.rc);
+
+    // Check that we executed correctly:
+    MockBucketCommand verifyCmd(MockCommand::CHECK_RETRY_VERIFY, srvix, instance->get_bucketname());
+    verifyCmd.set("opcode", PROTOCOL_BINARY_CMD_SET);
+    verifyCmd.set("errcode", 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);
+#else
+    verifyCmd.set("fuzz_ms", 20);
+#endif
+    doMockTxn(verifyCmd);
+}
+
+static const uint16_t ERRCODE_CONSTANT = 0x7ff0;
+static const uint16_t ERRCODE_LINEAR = 0x7ff1;
+static const uint16_t ERRCODE_EXPONENTIAL = 0x7ff2;
+
+TEST_F(ErrmapUnitTest, retrySpecConstant) {
+    SKIP_UNLESS_MOCK();
+    checkRetryVerify(ERRCODE_CONSTANT);
+}
+
+TEST_F(ErrmapUnitTest, retrySpecLinear) {
+    SKIP_UNLESS_MOCK();
+    checkRetryVerify(ERRCODE_LINEAR);
+}
+
+TEST_F(ErrmapUnitTest, retrySpecExponential) {
+    checkRetryVerify(ERRCODE_EXPONENTIAL);
+}

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

@@ -293,7 +293,7 @@ TEST_F(MockUnitTest, testGetHostInfo)
     map<string,bool> smap;
 
     // Ensure we only get unique nodes
-    for (size_t ii = 0; ii < lcb_get_num_nodes(instance); ii++) {
+    for (lcb_S32 ii = 0; ii < lcb_get_num_nodes(instance); ii++) {
         const char *cur = lcb_get_node(instance, LCB_NODE_DATA, ii);
         ASSERT_FALSE(cur == NULL);
         ASSERT_FALSE(smap[cur]);
@@ -435,7 +435,7 @@ TEST_F(MockUnitTest, testCtls)
     lcbvb_CONFIG *cfg = ctlGet<lcbvb_CONFIG*>(instance, LCB_CNTL_VBCONFIG);
     // Do we have a way to verify this?
     ASSERT_FALSE(cfg == NULL);
-    ASSERT_GT(cfg->nsrv, 0);
+    ASSERT_GT(cfg->nsrv, (unsigned int)0);
 
     lcb_io_opt_t io = ctlGet<lcb_io_opt_t>(instance, LCB_CNTL_IOPS);
     ASSERT_TRUE(io == instance->getIOT()->p);
@@ -517,7 +517,7 @@ TEST_F(MockUnitTest, testCtls)
 
     ctlGetSet<int>(instance, LCB_CNTL_DETAILED_ERRCODES, 1);
     ctlGetSet<lcb_U32>(instance, LCB_CNTL_RETRY_INTERVAL, UINT_MAX);
-    ctlGetSet<float>(instance, LCB_CNTL_RETRY_BACKOFF, 3.4);
+    ctlGetSet<float>(instance, LCB_CNTL_RETRY_BACKOFF, (float)3.4);
     ctlGetSet<lcb_SIZE>(instance, LCB_CNTL_HTTP_POOLSIZE, UINT_MAX);
     ctlGetSet<int>(instance, LCB_CNTL_HTTP_REFRESH_CONFIG_ON_ERROR, 0);
 

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

@@ -506,7 +506,7 @@ TEST_F(MockUnitTest, testSaslMechs)
     doLcbCreate(&instance, &crParams, protectedEnv);
 
     // Make the socket pool disallow idle connections
-    instance->memd_sockpool->maxidle = 0;
+    instance->memd_sockpool->get_options().maxidle = 0;
 
     err = lcb_connect(instance);
     ASSERT_EQ(LCB_SUCCESS, err);

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

@@ -96,7 +96,6 @@ TEST_F(ObseqnoTest, testObserve) {
 
     HandleWrap hw;
     lcb_t instance;
-    lcb_error_t rc;
     createConnection(hw, instance);
     lcbvb_CONFIG *vbc;
 

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

@@ -22,7 +22,7 @@
 
 namespace std {
 inline ostream& operator<<(ostream& os, const lcb_error_t& rc) {
-    os << "LcbError<";
+    os << "LcbError <0x";
     os << std::hex << static_cast<unsigned>(rc);
     os << " (";
     os << lcb_strerror(NULL, rc);
@@ -300,7 +300,6 @@ TEST_F(SubdocUnitTest, testSdGetExists)
     CREATE_SUBDOC_CONNECTION(hw, instance);
 
     MultiResult res;
-    lcb_error_t rc;
     lcb_SDSPEC spec = { 0 };
     lcb_CMDSUBDOC cmd = { 0 };
     LCB_CMD_SET_KEY(&cmd, key.c_str(), key.size());
@@ -403,7 +402,6 @@ TEST_F(SubdocUnitTest, testSdStore)
 {
     HandleWrap hw;
     lcb_t instance;
-    lcb_error_t rc;
     CREATE_SUBDOC_CONNECTION(hw, instance);
     lcb_CMDSUBDOC cmd = { 0 };
     lcb_SDSPEC spec = { 0 };
@@ -495,7 +493,7 @@ TEST_F(SubdocUnitTest, testMkdoc) {
     HandleWrap hw;
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };
-    lcb_SDSPEC spec = { 0 };
+    lcb_SDSPEC spec[2] = {{0}};
     MultiResult res;
 
     CREATE_SUBDOC_CONNECTION(hw, instance);
@@ -504,16 +502,27 @@ TEST_F(SubdocUnitTest, testMkdoc) {
     removeKey(instance, key);
 
     LCB_CMD_SET_KEY(&cmd, key.c_str(), key.size());
-    cmd.specs = &spec;
+    cmd.specs = spec;
     cmd.nspecs = 1;
+    cmd.cmdflags = LCB_CMDSUBDOC_F_UPSERT_DOC;
 
-    LCB_SDSPEC_SET_PATH(&spec, "pth", 3);
-    LCB_SDSPEC_SET_VALUE(&spec, "123", 3);
-    spec.options |= LCB_SDSPEC_F_MKDOCUMENT;
-    spec.sdcmd = LCB_SDCMD_DICT_UPSERT;
+    LCB_SDSPEC_SET_PATH(&spec[0], "pth", 3);
+    LCB_SDSPEC_SET_VALUE(&spec[0], "123", 3);
+    spec[0].sdcmd = LCB_SDCMD_DICT_UPSERT;
 
     ASSERT_EQ(LCB_SUCCESS, schedwait(instance, &res, &cmd, lcb_subdoc3));
+
     ASSERT_PATHVAL_EQ("123", instance, key, "pth");
+
+    removeKey(instance, key);
+    LCB_SDSPEC_SET_PATH(&spec[1], "pth2", 4);
+    LCB_SDSPEC_SET_VALUE(&spec[1], "456", 3);
+    spec[1].sdcmd = LCB_SDCMD_DICT_UPSERT;
+    cmd.nspecs = 2;
+    ASSERT_EQ(LCB_SUCCESS, schedwait(instance, &res, &cmd, lcb_subdoc3));
+
+    ASSERT_PATHVAL_EQ("123", instance, key, "pth");
+    ASSERT_PATHVAL_EQ("456", instance, key, "pth2");
 }
 
 TEST_F(SubdocUnitTest, testUnique)
@@ -572,7 +581,6 @@ TEST_F(SubdocUnitTest, testCounter)
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };
     lcb_SDSPEC spec = { 0 };
-    lcb_error_t rc;
     MultiResult res;
 
     CREATE_SUBDOC_CONNECTION(hw, instance);
@@ -788,7 +796,6 @@ TEST_F(SubdocUnitTest, testGetCount) {
     lcb_t instance;
     lcb_CMDSUBDOC cmd = { 0 };
     lcb_SDSPEC spec = { 0 };
-    lcb_error_t rc;
     MultiResult mres;
 
     CREATE_SUBDOC_CONNECTION(hw, instance);

data/ext/libcouchbase/tests/mc/t_alloc.cc

@@ -223,15 +223,16 @@ TEST_F(McAlloc, testValueAlloc)
     mcreq_release_packet(pipeline, packet);
 }
 
-struct ExtraCookie {
-    mc_REQDATAEX base;
+struct ExtraCookie : mc_REQDATAEX {
     int remaining;
+    ExtraCookie(const mc_REQDATAPROCS& procs_)
+        : mc_REQDATAEX(NULL, procs_, 0), remaining(0) {
+    }
 };
 
 extern "C" {
 static void pkt_dtor(mc_PACKET *pkt) {
-    mc_REQDATAEX *rd = pkt->u_rdata.exdata;
-    ExtraCookie *ec = (ExtraCookie *)rd;
+    ExtraCookie *ec = static_cast<ExtraCookie*>(pkt->u_rdata.exdata);
     ec->remaining--;
 }
 }
@@ -240,18 +241,17 @@ TEST_F(McAlloc, testRdataExDtor)
 {
     CQWrap q;
     lcb_CMDBASE basecmd;
-    ExtraCookie ec;
+    const static mc_REQDATAPROCS procs = { NULL, pkt_dtor };
     protocol_binary_request_header hdr;
 
     memset(&hdr, 0, sizeof hdr);
     memset(&basecmd, 0, sizeof basecmd);
-    memset(&ec, 0, sizeof ec);
 
-    mc_REQDATAPROCS procs = { NULL, pkt_dtor };
-    ec.base.procs = &procs;
     basecmd.key.contig.bytes = "foo";
     basecmd.key.contig.nbytes = 3;
 
+    ExtraCookie ec(procs);
+
     mcreq_sched_enter(&q);
     for (unsigned ii = 0; ii < 5; ii++) {
         lcb_error_t err;
@@ -260,7 +260,7 @@ TEST_F(McAlloc, testRdataExDtor)
         err = mcreq_basic_packet(&q, &basecmd, &hdr, 0, &pkt, &pl, 0);
         ASSERT_EQ(LCB_SUCCESS, err);
         pkt->flags |= MCREQ_F_REQEXT;
-        pkt->u_rdata.exdata = &ec.base;
+        pkt->u_rdata.exdata = &ec;
         mcreq_sched_add(pl, pkt);
         ec.remaining++;
     }