mt-libcouchbase 1.4.0

data/ext/libcouchbase/example/instancepool/pool.h

@@ -0,0 +1,69 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 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 POOL_H
+#define POOL_H
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <pthread.h>
+#include <queue>
+#include <vector>
+
+namespace lcb {
+
+class Pool {
+public:
+    /**
+     * Create a new pool to use across threads
+     * @param options The options used to initialize the instance
+     * @param items How many items should be in the pool
+     */
+    Pool(const lcb_create_st& options, size_t items = 10);
+    virtual ~Pool();
+
+    /**Get an instance from the pool. You should call #push() when you are
+     * done with the instance
+     * @return an lcb_t instance */
+    lcb_t pop();
+
+    /**Release an instance back into the pool
+     * @param instance The instance to release */
+    void push(lcb_t instance);
+
+    // Connect all the instances in the pool. This should be called once the
+    // pool has been constructed
+    lcb_error_t connect();
+
+protected:
+    /**Function called after the instance is created. You may
+     * customize the instance here with e.g. lcb_set_cookie()
+     * @param instance the newly created instance */
+    virtual void initialize(lcb_t instance) = 0;
+
+private:
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    std::queue<lcb_t> instances;
+
+    // List of all instances
+    std::vector<lcb_t> all_instances;
+    size_t initial_size;
+};
+} // namespace
+
+#endif

data/ext/libcouchbase/example/libeventdirect/main.c

@@ -0,0 +1,222 @@
+/* -*- 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.
+ */
+
+/**
+ * gcc -levent -lcouchbase main.c
+ *
+ * # perform STORE and 20 iterations of GET commands with interval 3 seconds
+ * ./a.out couchbase://localhost password Administrator 20 3
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <event2/event.h>
+
+const char key[] = "foo";
+lcb_SIZE nkey = sizeof(key);
+
+const char val[] = "{\"answer\":42}";
+lcb_SIZE nval = sizeof(val);
+
+int nreq = 1;
+int nresp = 1;
+int interval = 0;
+struct event *timer = NULL;
+
+static void bootstrap_callback(lcb_t instance, lcb_error_t err)
+{
+    lcb_CMDSTORE cmd = {0};
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "ERROR: %s\n", lcb_strerror(instance, err));
+        exit(EXIT_FAILURE);
+    }
+    printf("successfully bootstrapped\n");
+    fflush(stdout);
+    /* Since we've got our configuration, let's go ahead and store a value */
+    LCB_CMD_SET_KEY(&cmd, key, nkey);
+    LCB_CMD_SET_VALUE(&cmd, val, nval);
+    cmd.operation = LCB_SET;
+    err = lcb_store3(instance, NULL, &cmd);
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to set up store request: %s\n", lcb_strerror(instance, err));
+        exit(EXIT_FAILURE);
+    }
+}
+
+static void get_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
+    if (rg->rc != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to get key: %s\n", lcb_strerror(instance, rg->rc));
+        exit(EXIT_FAILURE);
+    }
+
+    printf("%d. retrieved the key 'foo', value: %.*s\n", nresp, (int)rg->nvalue, rg->value);
+    fflush(stdout);
+    nresp--;
+    if (nresp == 0) {
+        printf("stopping the loop\n");
+        event_base_loopbreak((void *)lcb_get_cookie(instance));
+    }
+    (void)cbtype;
+}
+
+static void schedule_timer();
+
+static void timer_callback(int fd, short event, void *arg)
+{
+    lcb_t instance = arg;
+    lcb_error_t rc;
+    lcb_CMDGET gcmd = {0};
+
+    LCB_CMD_SET_KEY(&gcmd, key, nkey);
+    rc = lcb_get3(instance, NULL, &gcmd);
+    if (rc != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to schedule get request: %s\n", lcb_strerror(NULL, rc));
+        exit(EXIT_FAILURE);
+    }
+    (void)fd;
+    (void)event;
+    schedule_timer();
+}
+
+static void schedule_timer()
+{
+    struct timeval tv;
+
+    if (!nreq) {
+        return;
+    }
+    tv.tv_sec = interval;
+    tv.tv_usec = 0;
+    evtimer_add(timer, &tv);
+    nreq--;
+}
+
+static void store_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    if (rb->rc != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to store key: %s\n", lcb_strerror(instance, rb->rc));
+        exit(EXIT_FAILURE);
+    }
+    printf("stored key 'foo'\n");
+    fflush(stdout);
+    {
+        struct event_base *evbase = (struct event_base *)lcb_get_cookie(instance);
+
+        printf("try to get value %d times with %dsec interval\n", nreq, interval);
+        timer = evtimer_new(evbase, timer_callback, instance);
+        schedule_timer();
+    }
+
+    (void)cbtype;
+}
+
+static lcb_io_opt_t create_libevent_io_ops(struct event_base *evbase)
+{
+    struct lcb_create_io_ops_st ciops;
+    lcb_io_opt_t ioops;
+    lcb_error_t error;
+
+    memset(&ciops, 0, sizeof(ciops));
+    ciops.v.v0.type = LCB_IO_OPS_LIBEVENT;
+    ciops.v.v0.cookie = evbase;
+
+    error = lcb_create_io_ops(&ioops, &ciops);
+    if (error != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to create an IOOPS structure for libevent: %s\n", lcb_strerror(NULL, error));
+        exit(EXIT_FAILURE);
+    }
+
+    return ioops;
+}
+
+static lcb_t create_libcouchbase_handle(lcb_io_opt_t ioops, int argc, char **argv)
+{
+    lcb_t instance;
+    lcb_error_t error;
+    struct lcb_create_st copts;
+
+    memset(&copts, 0, sizeof(copts));
+
+    /* If NULL, will default to localhost */
+    copts.version = 3;
+    if (argc > 1) {
+        copts.v.v3.connstr = argv[1];
+    }
+    if (argc > 2) {
+        copts.v.v3.passwd = argv[2];
+    }
+    if (argc > 3) {
+        copts.v.v3.username = argv[3];
+    }
+    copts.v.v3.io = ioops;
+    error = lcb_create(&instance, &copts);
+
+    if (error != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to create a libcouchbase instance: %s\n", lcb_strerror(NULL, error));
+        exit(EXIT_FAILURE);
+    }
+
+    /* Set up the callbacks */
+    lcb_set_bootstrap_callback(instance, bootstrap_callback);
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, get_callback);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, store_callback);
+
+    if ((error = lcb_connect(instance)) != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to connect libcouchbase instance: %s\n", lcb_strerror(NULL, error));
+        lcb_destroy(instance);
+        exit(EXIT_FAILURE);
+    }
+
+    return instance;
+}
+
+/* This example shows how we can hook ourself into an external event loop.
+ * You may find more information in the blogpost: http://goo.gl/fCTrX */
+int main(int argc, char **argv)
+{
+    struct event_base *evbase = event_base_new();
+    lcb_io_opt_t ioops = create_libevent_io_ops(evbase);
+    lcb_t instance = create_libcouchbase_handle(ioops, argc, argv);
+
+    if (argc > 4) {
+        nreq = nresp = atoi(argv[4]);
+    }
+    if (argc > 5) {
+        interval = atoi(argv[4]);
+    }
+    /*Store the event base as the user cookie in our instance so that
+     * we may terminate the program when we're done */
+    lcb_set_cookie(instance, evbase);
+
+    /* Run the event loop */
+    event_base_loop(evbase, 0);
+
+    /* Cleanup */
+    lcb_destroy(instance);
+    if (timer) {
+        evtimer_del(timer);
+    }
+    lcb_destroy_io_ops(ioops);
+    event_base_free(evbase);
+
+    return EXIT_SUCCESS;
+}

data/ext/libcouchbase/example/mcc/mcc.cc

@@ -0,0 +1,246 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 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 <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <getopt.h>
+#include <cstdlib>
+
+extern "C" {
+static void op_callback(lcb_t, int, const lcb_RESPBASE*);
+}
+
+class MultiClusterClient {
+public:
+    class Operation {
+    public:
+        Operation(MultiClusterClient *r) :
+            root(r),
+            error(LCB_SUCCESS),
+            numReferences(r->instances.size() + 1),
+            numResponses(0)
+        {
+        }
+
+        void response(lcb_error_t err, const std::string &value) {
+            if (err == LCB_SUCCESS) {
+                values.push_back(value);
+            } else {
+                // @todo handle retry etc
+                error = err;
+            }
+
+            // @todo figure out the number you want before you want
+            // the wait to resume
+            if (++numResponses == 1) {
+                root->resume();
+            }
+
+            --numReferences;
+            maybeNukeMe();
+        }
+
+        lcb_error_t getErrorCode(void) {
+            return error;
+        }
+
+        std::string getValue(void) {
+            return values[0];
+        }
+
+        void release(void) {
+            --numReferences;
+            maybeNukeMe();
+        }
+
+    private:
+        void maybeNukeMe(void) {
+            if (numReferences == 0) {
+                delete this;
+            }
+        }
+
+        MultiClusterClient *root;
+        lcb_error_t error;
+        int numReferences;
+        int numResponses;
+        std::vector<std::string> values;
+    };
+
+
+public:
+    MultiClusterClient(std::list<std::string> clusters) {
+        lcb_error_t err;
+        if ((err = lcb_create_io_ops(&iops, NULL)) != LCB_SUCCESS) {
+            std::cerr <<"Failed to create io ops: " << lcb_strerror(NULL, err)
+                      << std::endl;
+            exit(1);
+        }
+
+        for (std::list<std::string>::iterator iter = clusters.begin();
+             iter != clusters.end();
+             ++iter) {
+            std::cout<< "Creating instance for cluster " << *iter;
+            std::cout.flush();
+            lcb_create_st options(iter->c_str(), NULL, NULL, NULL, iops);
+            lcb_t instance;
+            if ((err = lcb_create(&instance, &options)) != LCB_SUCCESS) {
+                std::cerr <<"Failed to create instance: "
+                          << lcb_strerror(NULL, err)
+                          << std::endl;
+                exit(1);
+            }
+            lcb_install_callback3(instance, LCB_CALLBACK_GET, op_callback);
+            lcb_install_callback3(instance, LCB_CALLBACK_STORE, op_callback);
+
+
+            lcb_connect(instance);
+            lcb_wait(instance);
+            if ((err = lcb_get_bootstrap_status(instance)) != LCB_SUCCESS) {
+                std::cerr << "Failed to bootstrap: "
+                          << lcb_strerror(instance, err)
+                          << std::endl;
+                exit(1);
+            }
+            std::cout << " done" << std::endl;
+
+            instances.push_back(instance);
+        }
+    }
+
+    lcb_error_t store(const std::string &key, const std::string &value) {
+        lcb_CMDSTORE scmd = { 0 };
+        LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+        LCB_CMD_SET_VALUE(&scmd, value.c_str(), value.size());
+        scmd.operation = LCB_SET;
+        Operation *oper = new Operation(this);
+        lcb_error_t error;
+        for (std::list<lcb_t>::iterator iter = instances.begin();
+             iter != instances.end();
+             ++iter) {
+
+            if ((error = lcb_store3(*iter, oper, &scmd)) != LCB_SUCCESS) {
+                oper->response(error, "");
+            }
+        }
+
+        wait();
+        lcb_error_t ret = oper->getErrorCode();
+        oper->release();
+        return ret;
+    }
+
+    lcb_error_t get(const std::string &key, std::string &value) {
+        lcb_CMDGET gcmd = { 0 };
+        LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+        Operation *oper = new Operation(this);
+        lcb_error_t error;
+        for (std::list<lcb_t>::iterator iter = instances.begin();
+             iter != instances.end();
+             ++iter) {
+
+            if ((error = lcb_get3(*iter, oper, &gcmd)) != LCB_SUCCESS) {
+                oper->response(error, "");
+            }
+        }
+
+        wait();
+        value = oper->getValue();
+        lcb_error_t ret = oper->getErrorCode();
+        oper->release();
+        return ret;
+    }
+
+private:
+    void wait(void) {
+        lcb_run_loop(instances.front());
+    }
+
+    void resume(void) {
+        lcb_stop_loop(instances.front());
+    }
+
+    lcb_io_opt_t iops;
+    std::list<lcb_t> instances;
+};
+
+static void op_callback(lcb_t, int cbtype, const lcb_RESPBASE *rb)
+{
+    MultiClusterClient::Operation *o =
+            reinterpret_cast<MultiClusterClient::Operation*>(rb->cookie);
+    if (rb->rc != LCB_SUCCESS) {
+        o->response(rb->rc, "");
+    } else if (cbtype == LCB_CALLBACK_GET) {
+        const lcb_RESPGET *rg = reinterpret_cast<const lcb_RESPGET*>(rb);
+        std::string value(reinterpret_cast<const char*>(rg->value), rg->nvalue);
+        o->response(rb->rc, value);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    std::list<std::string> clusters;
+    int cmd;
+    std::string key;
+    std::string value;
+
+    while ((cmd = getopt(argc, argv, "h:k:v:")) != -1) {
+        switch (cmd) {
+        case 'h' :
+            clusters.push_back(optarg);
+            break;
+        case 'k':
+            key.assign(optarg);
+            break;
+        case 'v':
+            value.assign(optarg);
+            break;
+        default:
+            std::cerr << "Usage: mcc [-h clusterurl]+ -k key -v value"
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    if (clusters.empty()) {
+        std::cerr << "No clusters specified" << std::endl;
+        exit(EXIT_FAILURE);
+    }
+
+    if (key.empty()) {
+        std::cerr << "No key specified" << std::endl;
+        exit(EXIT_FAILURE);
+    }
+
+    MultiClusterClient client(clusters);
+    std::cout << "Storing kv-pair: [\"" << key << "\", \"" << value << "\"]: ";
+    std::cout.flush();
+    std::cout << lcb_strerror(NULL, client.store(key, value)) << std::endl;
+
+    std::cout << "Retrieving key \"" << key << "\": ";
+    std::cout.flush();
+    lcb_error_t err = client.get(key, value);
+    std::cout << lcb_strerror(NULL, err) << std::endl;
+    if (err == LCB_SUCCESS) {
+        std::cout << "\tValue: \"" << value << "\"" << std::endl;
+    }
+
+    exit(EXIT_SUCCESS);
+}

data/ext/libcouchbase/example/minimal/.gitignore

@@ -0,0 +1 @@
+query

data/ext/libcouchbase/example/minimal/minimal.c

@@ -0,0 +1,132 @@
+/* -*- 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.
+ */
+
+/**
+ * @file
+ *
+ * This is a minimal example file showing how to connect to a cluster and
+ * set and retrieve a single item.
+ */
+
+#include <stdio.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <stdlib.h>
+#include <string.h> /* strlen */
+#ifdef _WIN32
+#define PRIx64 "I64x"
+#else
+#include <inttypes.h>
+#endif
+
+static void
+die(lcb_t instance, const char *msg, lcb_error_t err)
+{
+    fprintf(stderr, "%s. Received code 0x%X (%s)\n",
+        msg, err, lcb_strerror(instance, err));
+    exit(EXIT_FAILURE);
+}
+
+static void
+op_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    fprintf(stderr, "=== %s ===\n", lcb_strcbtype(cbtype));
+    if (rb->rc == LCB_SUCCESS) {
+        fprintf(stderr, "KEY: %.*s\n", (int)rb->nkey, rb->key);
+        fprintf(stderr, "CAS: 0x%"PRIx64"\n", rb->cas);
+        if (cbtype == LCB_CALLBACK_GET) {
+            const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
+            fprintf(stderr, "VALUE: %.*s\n", (int)rg->nvalue, rg->value);
+            fprintf(stderr, "FLAGS: 0x%x\n", rg->itmflags);
+        }
+    } else {
+        die(instance, lcb_strcbtype(cbtype), rb->rc);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_error_t err;
+    lcb_t instance;
+    struct lcb_create_st create_options = { 0 };
+    lcb_CMDSTORE scmd = { 0 };
+    lcb_CMDGET gcmd = { 0 };
+
+    create_options.version = 3;
+
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s couchbase://host/bucket [ password [ username ] ]\n", argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    create_options.v.v3.connstr = argv[1];
+    if (argc > 2) {
+        create_options.v.v3.passwd = argv[2];
+    }
+    if (argc > 3) {
+        create_options.v.v3.username = argv[3];
+    }
+
+    err = lcb_create(&instance, &create_options);
+    if (err != LCB_SUCCESS) {
+        die(NULL, "Couldn't create couchbase handle", err);
+    }
+
+    err = lcb_connect(instance);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't schedule connection", err);
+    }
+
+    lcb_wait(instance);
+
+    err = lcb_get_bootstrap_status(instance);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't bootstrap from cluster", err);
+    }
+
+    /* Assign the handlers to be called for the operation types */
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, op_callback);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, op_callback);
+
+    LCB_CMD_SET_KEY(&scmd, "key", strlen("key"));
+    LCB_CMD_SET_VALUE(&scmd, "value", strlen("value"));
+    scmd.operation = LCB_SET;
+
+    err = lcb_store3(instance, NULL, &scmd);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't schedule storage operation", err);
+    }
+
+    /* The store_callback is invoked from lcb_wait() */
+    fprintf(stderr, "Will wait for storage operation to complete..\n");
+    lcb_wait(instance);
+
+    /* Now fetch the item back */
+    LCB_CMD_SET_KEY(&gcmd, "key", strlen("key"));
+    err = lcb_get3(instance, NULL, &gcmd);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't schedule retrieval operation", err);
+    }
+
+    /* Likewise, the get_callback is invoked from here */
+    fprintf(stderr, "Will wait to retrieve item..\n");
+    lcb_wait(instance);
+
+    /* Now that we're all done, close down the connection handle */
+    lcb_destroy(instance);
+    return 0;
+}