mt-libcouchbase 1.4.0

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

@@ -0,0 +1,251 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012-2013 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 "mock-unit-test.h"
+#include "testutil.h"
+#include <map>
+
+/*
+ * Helper functions
+ */
+extern "C" {
+    static void storeKvoCallback(lcb_t, const void *cookie,
+                                 lcb_storage_t operation,
+                                 lcb_error_t error,
+                                 const lcb_store_resp_t *resp)
+    {
+
+        KVOperation *kvo = (KVOperation *)cookie;
+        kvo->cbCommon(error);
+        kvo->result.assignKC(resp, error);
+        ASSERT_EQ(LCB_SET, operation);
+    }
+
+    static void getKvoCallback(lcb_t, const void *cookie,
+                               lcb_error_t error,
+                               const lcb_get_resp_t *resp)
+    {
+        KVOperation *kvo = (KVOperation *)cookie;
+        kvo->cbCommon(error);
+        kvo->result.assign(resp, error);
+    }
+
+    static void removeKvoCallback(lcb_t, const void *cookie,
+                                  lcb_error_t error,
+                                  const lcb_remove_resp_t *resp)
+    {
+        KVOperation *kvo = (KVOperation *)cookie;
+        kvo->cbCommon(error);
+        kvo->result.assignKC(resp, error);
+    }
+}
+
+void KVOperation::handleInstanceError(lcb_t instance, lcb_error_t err,
+                                      const char *)
+{
+    KVOperation *kvo = reinterpret_cast<KVOperation *>(
+            const_cast<void*>(lcb_get_cookie(instance)));
+    kvo->assertOk(err);
+    kvo->globalErrors.insert(err);
+}
+
+void KVOperation::enter(lcb_t instance)
+{
+    callbacks.get = lcb_set_get_callback(instance, getKvoCallback);
+    callbacks.rm = lcb_set_remove_callback(instance, removeKvoCallback);
+    callbacks.store = lcb_set_store_callback(instance, storeKvoCallback);
+    oldCookie = lcb_get_cookie(instance);
+    lcb_set_cookie(instance, this);
+}
+
+void KVOperation::leave(lcb_t instance)
+{
+    lcb_set_get_callback(instance, callbacks.get);
+    lcb_set_remove_callback(instance, callbacks.rm);
+    lcb_set_store_callback(instance, callbacks.store);
+    lcb_set_cookie(instance, oldCookie);
+}
+
+void KVOperation::assertOk(lcb_error_t err)
+{
+    if (ignoreErrors) {
+        return;
+    }
+
+    if (allowableErrors.empty()) {
+        ASSERT_EQ(LCB_SUCCESS, err) << "Unexpected error: " << lcb_strerror_short(err);
+        return;
+    }
+    ASSERT_TRUE(allowableErrors.find(err) != allowableErrors.end())
+        << "Unable to find " << lcb_strerror_short(err) << " in allowable errors";
+}
+
+void KVOperation::store(lcb_t instance)
+{
+    lcb_store_cmd_t cmd(LCB_SET,
+                        request->key.data(), request->key.length(),
+                        request->val.data(), request->val.length(),
+                        request->flags,
+                        request->exp,
+                        request->cas,
+                        request->datatype);
+    lcb_store_cmd_t *cmds[] = { &cmd };
+
+    enter(instance);
+    EXPECT_EQ(LCB_SUCCESS, lcb_store(instance, this, 1, cmds));
+    EXPECT_EQ(LCB_SUCCESS, lcb_wait(instance));
+    leave(instance);
+
+    ASSERT_EQ(1, callCount);
+
+}
+
+void KVOperation::remove(lcb_t instance)
+{
+    lcb_remove_cmd_t cmd(request->key.data(), request->key.length(),
+                         request->cas);
+    lcb_remove_cmd_t *cmds[] = { &cmd };
+
+    enter(instance);
+    EXPECT_EQ(LCB_SUCCESS, lcb_remove(instance, this, 1, cmds));
+    EXPECT_EQ(LCB_SUCCESS, lcb_wait(instance));
+    leave(instance);
+
+    ASSERT_EQ(1, callCount);
+
+}
+
+void KVOperation::get(lcb_t instance)
+{
+    lcb_get_cmd_t cmd(request->key.data(), request->key.length(), request->exp);
+    lcb_get_cmd_t *cmds[] = { &cmd };
+
+    enter(instance);
+    EXPECT_EQ(LCB_SUCCESS, lcb_get(instance, this, 1, cmds));
+    EXPECT_EQ(LCB_SUCCESS, lcb_wait(instance));
+    leave(instance);
+
+    ASSERT_EQ(1, callCount);
+}
+
+void storeKey(lcb_t instance, const std::string &key, const std::string &value)
+{
+    Item req = Item(key, value);
+    KVOperation kvo = KVOperation(&req);
+    kvo.store(instance);
+}
+
+void removeKey(lcb_t instance, const std::string &key)
+{
+    Item req = Item();
+    req.key = key;
+    KVOperation kvo = KVOperation(&req);
+    kvo.allowableErrors.insert(LCB_SUCCESS);
+    kvo.allowableErrors.insert(LCB_KEY_ENOENT);
+    kvo.remove(instance);
+}
+
+void getKey(lcb_t instance, const std::string &key, Item &item)
+{
+    Item req = Item();
+    req.key = key;
+    KVOperation kvo = KVOperation(&req);
+    kvo.result.cas = 0xdeadbeef;
+
+    kvo.get(instance);
+    ASSERT_NE(0xdeadbeef, kvo.result.cas);
+    item = kvo.result;
+}
+
+void genDistKeys(lcbvb_CONFIG *vbc, std::vector<std::string> &out)
+{
+    char buf[1024] = { '\0' };
+    int servers_max = lcbvb_get_nservers(vbc);
+    std::map<int, bool> found_servers;
+    EXPECT_TRUE(servers_max > 0);
+
+    for (int cur_num = 0; found_servers.size() != servers_max; cur_num++) {
+        int ksize = sprintf(buf, "VBKEY_%d", cur_num);
+        int vbid;
+        int srvix;
+        lcbvb_map_key(vbc, buf, ksize, &vbid, &srvix);
+
+        if (!found_servers[srvix]) {
+            out.push_back(std::string(buf));
+            found_servers[srvix] = true;
+        }
+    }
+
+    EXPECT_EQ(servers_max, out.size());
+}
+
+void genStoreCommands(const std::vector<std::string> &keys,
+                      std::vector<lcb_store_cmd_t> &cmds,
+                      std::vector<lcb_store_cmd_t*> &cmdpp)
+{
+    for (unsigned int ii = 0; ii < keys.size(); ii++) {
+        lcb_store_cmd_t cmd;
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.v.v0.key = keys[ii].c_str();
+        cmd.v.v0.nkey = keys[ii].size();
+        cmd.v.v0.bytes = cmd.v.v0.key;
+        cmd.v.v0.nbytes = cmd.v.v0.nkey;
+        cmd.v.v0.operation = LCB_SET;
+        cmds.push_back(cmd);
+    }
+
+    for (unsigned int ii = 0; ii < keys.size(); ii++) {
+        cmdpp.push_back(&cmds[ii]);
+    }
+}
+
+/**
+ * This doesn't _actually_ attempt to make sense of an operation. It simply
+ * will try to keep the event loop alive.
+ */
+void doDummyOp(lcb_t& instance)
+{
+    Item itm("foo", "bar");
+    KVOperation kvo(&itm);
+    kvo.ignoreErrors = true;
+    kvo.store(instance);
+}
+
+/**
+ * Dump the item object to a stream
+ * @param out where to dump the object to
+ * @param item the item to print
+ * @return the stream
+ */
+std::ostream &operator<< (std::ostream &out, const Item &item)
+{
+    using namespace std;
+    out << "Key: " << item.key << endl;
+    if (item.val.length()) {
+        out <<  "Value: " << item.val << endl;
+    }
+
+    out << ios::hex << "CAS: 0x" << item.cas << endl
+        << "Flags: 0x" << item.flags << endl;
+
+    if (item.err != LCB_SUCCESS) {
+        out << "Error: " << item.err << endl;
+    }
+
+    return out;
+}

data/ext/libcouchbase/tests/iotests/testutil.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012-2013 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.
+ */
+#ifndef TESTS_TESTUTIL_H
+#define TESTS_TESTUTIL_H 1
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/vbucket.h>
+#include <string.h>
+struct Item {
+    void assign(const lcb_get_resp_t *resp, lcb_error_t e = LCB_SUCCESS) {
+        key.assign((const char *)resp->v.v0.key, resp->v.v0.nkey);
+        val.assign((const char *)resp->v.v0.bytes, resp->v.v0.nbytes);
+        flags = resp->v.v0.flags;
+        cas =  resp->v.v0.cas;
+        datatype =  resp->v.v0.datatype;
+        err = e;
+    }
+
+    /**
+     * Extract the key and CAS from a response.
+     */
+    template <typename T>
+    void assignKC(const T *resp, lcb_error_t e = LCB_SUCCESS) {
+        key.assign((const char *)resp->v.v0.key, resp->v.v0.nkey);
+        cas = resp->v.v0.cas;
+        err = e;
+    }
+
+    Item() {
+        key.clear();
+        val.clear();
+
+        err = LCB_SUCCESS;
+        flags = 0;
+        cas = 0;
+        datatype = 0;
+        exp = 0;
+    }
+
+    Item(const std::string &key,
+         const std::string &value = "",
+         lcb_cas_t cas = 0) {
+
+        this->key = key;
+        this->val = value;
+        this->cas = cas;
+
+        flags = 0;
+        datatype = 0;
+        exp = 0;
+    }
+
+    friend std::ostream &operator<< (std::ostream &out,
+                                     const Item &item);
+
+    /**
+     * Dump the string representation of the item to standard output
+     */
+    void dump() {
+        std::cout << *this;
+    }
+
+    std::string key;
+    std::string val;
+    lcb_uint32_t flags;
+    lcb_cas_t cas;
+    lcb_datatype_t datatype;
+    lcb_error_t err;
+    lcb_time_t exp;
+};
+
+struct KVOperation {
+    /** The resultant item */
+    Item result;
+
+    /** The request item */
+    const Item *request;
+
+    /** whether the callback was at all received */
+    unsigned callCount;
+
+    /** Acceptable errors during callback */
+    std::set<lcb_error_t> allowableErrors;
+
+    /** Errors received from error handler */
+    std::set<lcb_error_t> globalErrors;
+
+    void assertOk(lcb_error_t err);
+
+    KVOperation(const Item *request) {
+        this->request = request;
+        this->ignoreErrors = false;
+        callCount = 0;
+    }
+
+    void clear() {
+        result = Item();
+        callCount = 0;
+        allowableErrors.clear();
+        globalErrors.clear();
+    }
+
+    void store(lcb_t instance);
+    void get(lcb_t instance);
+    void remove(lcb_t instance);
+
+    void cbCommon(lcb_error_t error) {
+        callCount++;
+        if (error != LCB_SUCCESS) {
+            globalErrors.insert(error);
+        }
+        assertOk(error);
+    }
+
+    static void handleInstanceError(lcb_t, lcb_error_t, const char *);
+    bool ignoreErrors;
+
+private:
+    void enter(lcb_t);
+    void leave(lcb_t);
+    const void *oldCookie;
+
+    struct {
+        lcb_get_callback get;
+        lcb_store_callback store;
+        lcb_error_callback err;
+        lcb_remove_callback rm;
+    } callbacks;
+};
+
+void storeKey(lcb_t instance, const std::string &key, const std::string &value);
+void removeKey(lcb_t instance, const std::string &key);
+void getKey(lcb_t instance, const std::string &key, Item &item);
+
+/**
+ * Generate keys which will trigger all the servers in the map.
+ */
+void genDistKeys(lcbvb_CONFIG* vbc, std::vector<std::string> &out);
+void genStoreCommands(const std::vector<std::string> &keys,
+                      std::vector<lcb_store_cmd_t> &cmds,
+                      std::vector<lcb_store_cmd_t*> &cmdpp);
+
+/**
+ * This doesn't _actually_ attempt to make sense of an operation. It simply
+ * will try to keep the event loop alive.
+ */
+void doDummyOp(lcb_t& instance);
+
+#endif

data/ext/libcouchbase/tests/mc/mctest.h

@@ -0,0 +1,119 @@
+#include "mc/mcreq.h"
+#include "sllist-inl.h"
+#include <gtest/gtest.h>
+
+#define NUM_PIPELINES 4
+
+struct CQWrap : mc_CMDQUEUE {
+    lcbvb_CONFIG* config;
+    CQWrap() {
+        mc_PIPELINE **pll;
+        pll = (mc_PIPELINE **)malloc(sizeof(*pll) * NUM_PIPELINES);
+        config = lcbvb_create();
+        for (unsigned ii = 0; ii < NUM_PIPELINES; ii++) {
+            mc_PIPELINE *pipeline = (mc_PIPELINE *)calloc(1, sizeof(*pipeline));
+            mcreq_pipeline_init(pipeline);
+            pll[ii] = pipeline;
+        }
+        lcbvb_genconfig(config, NUM_PIPELINES, 3, 1024);
+        mcreq_queue_init(this);
+        this->seq = 100;
+        mcreq_queue_add_pipelines(this, pll, NUM_PIPELINES, config);
+        free(pll);
+    }
+
+    ~CQWrap() {
+        for (int ii = 0; ii < NUM_PIPELINES; ii++) {
+            mc_PIPELINE *pipeline = pipelines[ii];
+            EXPECT_NE(0, netbuf_is_clean(&pipeline->nbmgr));
+            EXPECT_NE(0, netbuf_is_clean(&pipeline->reqpool));
+            mcreq_pipeline_cleanup(pipeline);
+            free(pipeline);
+        }
+        mcreq_queue_cleanup(this);
+        lcbvb_destroy(config);
+    }
+
+    void clearPipelines() {
+        for (unsigned ii = 0; ii < npipelines; ii++) {
+            mc_PIPELINE *pipeline = pipelines[ii];
+            sllist_iterator iter;
+            SLLIST_ITERFOR(&pipeline->requests, &iter) {
+                mc_PACKET *pkt = SLLIST_ITEM(iter.cur, mc_PACKET, slnode);
+                sllist_iter_remove(&pipeline->requests, &iter);
+                mcreq_wipe_packet(pipeline, pkt);
+                mcreq_release_packet(pipeline, pkt);
+            }
+        }
+    }
+
+    void setBufFreeCallback(mcreq_bufdone_fn cb) {
+        for (unsigned ii = 0; ii < npipelines; ii++) {
+            pipelines[ii]->buf_done_callback = cb;
+        }
+    }
+
+    CQWrap(CQWrap&);
+};
+
+struct PacketWrap {
+    mc_PACKET *pkt;
+    mc_PIPELINE *pipeline;
+    protocol_binary_request_header hdr;
+    lcb_CMDBASE cmd;
+    char *pktbuf;
+    char *kbuf;
+
+    PacketWrap() {
+        pkt = NULL;
+        pipeline = NULL;
+        pktbuf = NULL;
+        kbuf = NULL;
+        memset(&hdr, 0, sizeof(hdr));
+        memset(&cmd, 0, sizeof(cmd));
+    }
+
+    void setKey(const char *key) {
+        size_t nkey = strlen(key);
+        pktbuf = new char[24 + nkey + 1];
+        kbuf = pktbuf + 24;
+        memcpy(kbuf, key, nkey);
+        kbuf[nkey] = '\0';
+    }
+
+    void setContigKey(const char *key) {
+        setKey(key);
+        cmd.key.type = LCB_KV_HEADER_AND_KEY;
+        cmd.key.contig.bytes = pktbuf;
+        cmd.key.contig.nbytes = strlen(key) + 24;
+    }
+
+    void setCopyKey(const char *key) {
+        setKey(key);
+        LCB_KREQ_SIMPLE(&cmd.key, kbuf, strlen(key));
+    }
+
+    void setHeaderSize() {
+        hdr.request.bodylen = htonl((lcb_uint32_t)strlen(kbuf));
+    }
+
+    void copyHeader() {
+        memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
+    }
+
+    void setCookie(void *ptr) {
+        pkt->u_rdata.reqdata.cookie = ptr;
+    }
+
+    bool reservePacket(mc_CMDQUEUE *cq) {
+        lcb_error_t err;
+        err = mcreq_basic_packet(cq, &cmd, &hdr, 0, &pkt, &pipeline, 0);
+        return err == LCB_SUCCESS;
+    }
+
+    ~PacketWrap() {
+        if (pktbuf != NULL) {
+            delete[] pktbuf;
+        }
+    }
+};

data/ext/libcouchbase/tests/mc/pktmaker.h

@@ -0,0 +1,101 @@
+#ifndef PKTMAKER_H
+#define PKTMAKER_H
+
+#include <memcached/protocol_binary.h>
+namespace PacketMaker {
+
+class Packet {
+public:
+    Packet() {
+       memset(&hdr_s, 0, sizeof(hdr_s));
+       req = &hdr_s;
+       res = (protocol_binary_response_header *)&hdr_s;
+    }
+
+    uint8_t magic() const { return req->request.magic; }
+    void magic(uint8_t mg) { req->request.magic = mg; }
+
+    uint8_t op() const { return req->request.opcode; }
+    void op(uint8_t cc) { req->request.opcode = cc; }
+
+    uint8_t extlen() const { return req->request.extlen; }
+
+    void opaque(uint32_t seq) { req->request.opaque = seq; }
+    uint32_t opaque() const { return req->request.opaque; }
+
+    const char *keyptr() const {
+        return &body[extlen()];
+    }
+
+    std::string key() const {
+        uint16_t len = keylen();
+        if (!len) {
+            return std::string("");
+        }
+        return std::string(keyptr(), len);
+    }
+
+    uint16_t keylen() const { return ntohs(req->request.keylen); }
+
+    void serialize(std::vector<char>& ret) {
+        req->request.bodylen = htonl(body.size());
+        ret.insert(ret.end(), hdr_s.bytes, hdr_s.bytes + sizeof(hdr_s.bytes));
+        ret.insert(ret.end(), body.begin(), body.end());
+    }
+
+    void load(std::vector<char>& buf) {
+        memcpy(&hdr_s.bytes, &buf[0], sizeof(hdr_s.bytes));
+        body.assign(&buf[24], &buf[0] + buf.size());
+    }
+
+    void setKey(const char *kbuf, uint16_t len) {
+        body.insert(body.end(), kbuf, kbuf + len);
+        req->request.keylen = htons((uint16_t)len);
+    }
+
+    void setValue(const char *val, uint32_t len) {
+        body.insert(body.end(), val, val+len);
+    }
+
+protected:
+    protocol_binary_request_header *req;
+    protocol_binary_response_header *res;
+
+    void addExtra(char *extbuf, uint8_t nbuf) {
+        body.insert(body.begin(), extbuf, extbuf+nbuf);
+        req->request.extlen += nbuf;
+    }
+
+
+private:
+    protocol_binary_request_header hdr_s;
+    std::vector<char> body;
+    Packet(Packet&);
+};
+
+class StorageRequest : public Packet {
+public:
+    StorageRequest(const std::string& key, const std::string& val) : Packet() {
+        setKey(key.c_str(), (uint16_t)key.size());
+        setValue(val.c_str(), (uint32_t)val.size());
+    }
+};
+
+class GetRequest : public Packet {
+public:
+    GetRequest(std::string& key) : Packet() {
+        setKey(key.c_str(), (uint16_t)key.size());
+    }
+};
+
+class Response : public Packet {
+public:
+    Response(const Packet& request, uint16_t status = 0) : Packet() {
+        res->response.status = htons(status);
+        opaque(request.opaque());
+    }
+};
+
+}
+
+#endif