libcouchbase 0.0.1

data/ext/libcouchbase/example/db/vb.c

@@ -0,0 +1,227 @@
+/* -*- 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.
+ */
+
+/* View Benchmark. This application is using libcouchbase to store
+ * single key and then get this key back infinitely through the view
+ * through the views.
+ *
+ * BUILD:
+ *
+ *      cc -o vb vb.c -lcouchbase
+ *      cl /DWIN32 /Iinclude vb.c lib\libcouchbase.lib
+ *
+ * RUN:
+ *
+ *      valgrind -v --tool=memcheck  --leak-check=full --show-reachable=yes ./vb
+ *      ./vb key size <connstr> <passwd>
+ *      vb.exe key size <connstr> <passwd>
+ */
+
+#include <stdio.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <libcouchbase/views.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#ifdef _WIN32
+#define PRIu64 "I64u"
+#else
+#include <signal.h>
+#include <inttypes.h>
+#endif
+
+#ifndef _WIN32
+static void handle_sigint(int sig)
+{
+    (void)sig;
+    printf("Exiting on SIGINT\n");
+    exit(0);
+}
+
+#define INSTALL_SIGINT_HANDLER() signal(SIGINT, handle_sigint)
+#else
+#define INSTALL_SIGINT_HANDLER()
+#endif
+
+
+static void
+store_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    if (rb->rc == LCB_SUCCESS) {
+        fprintf(stderr, "STORED \"%.*s\" CAS: %"PRIu64"\n", (int)rb->nkey, rb->key, rb->cas);
+    } else {
+        fprintf(stderr, "STORE ERROR: %s (0x%x)\n", lcb_strerror(instance, rb->rc), rb->rc);
+        exit(EXIT_FAILURE);
+    }
+    (void)cbtype;
+}
+
+const char *view;
+const char *design;
+
+static void
+do_query_view(lcb_t instance);
+
+static void
+viewrow_callback(lcb_t instance, int cbtype, const lcb_RESPVIEWQUERY *resp)
+{
+    if (resp->rflags & LCB_RESP_F_FINAL) {
+        if (resp->rc == LCB_SUCCESS) {
+            do_query_view(instance);
+        } else {
+            fprintf(stderr, "Couldn't query view: %s (0x%x)\n", lcb_strerror(NULL, resp->rc), resp->rc);
+            if (resp->htresp != NULL) {
+                fprintf(stderr, "HTTP Status: %u\n", resp->htresp->htstatus);
+                fprintf(stderr, "HTTP Body: %.*s\n", (int)resp->htresp->nbody, resp->htresp->body);
+            }
+            exit(EXIT_FAILURE);
+        }
+    }
+    (void)cbtype;
+}
+
+static void
+http_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPHTTP *rh = (const lcb_RESPHTTP *)rb;
+    fprintf(stderr, "%.*s... %d\n", (int)rb->nkey, rh->key, rh->htstatus);
+    if (rh->rc != LCB_SUCCESS) {
+        fprintf(stderr, "Couldn't issue HTTP request: %s\n", lcb_strerror(NULL, rh->rc));
+        exit(EXIT_FAILURE);
+    } else if (rh->htstatus != 201) {
+        fprintf(stderr, "Negative reply from server!\n");
+        fprintf(stderr, "%*.s\n", (int)rh->nbody, rh->body);
+        exit(EXIT_FAILURE);
+    }
+
+    (void)cbtype;
+}
+
+static void
+do_query_view(lcb_t instance)
+{
+    lcb_CMDVIEWQUERY cmd = { 0 };
+    lcb_error_t err;
+    lcb_view_query_initcmd(&cmd, design, view, NULL, viewrow_callback);
+    cmd.cmdflags |= LCB_CMDVIEWQUERY_F_INCLUDE_DOCS;
+    err = lcb_view_query(instance, NULL, &cmd);
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "Couldn't schedule view query: %s\n", lcb_strerror(NULL, err));
+        exit(EXIT_FAILURE);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_error_t err;
+    lcb_t instance;
+    struct lcb_create_st create_options;
+    const char *key = "foo";
+    size_t nkey = strlen(key);
+    void *bytes;
+    size_t nbytes = 6; /* the size of the value */
+
+    memset(&create_options, 0, sizeof(create_options));
+    create_options.version = 3;
+
+    if (argc > 1) {
+        key = argv[1];
+        nkey = strlen(key);
+    }
+    if (argc > 2) {
+        nbytes = atol(argv[2]);
+    }
+    if (argc > 3) {
+        create_options.v.v3.connstr = argv[3];
+    }
+    if (argc > 4) {
+        create_options.v.v3.passwd = argv[4];
+    }
+
+    INSTALL_SIGINT_HANDLER();
+
+    err = lcb_create(&instance, &create_options);
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to create libcouchbase instance: %s\n",
+                lcb_strerror(NULL, err));
+        exit(EXIT_FAILURE);
+    }
+    /* Initiate the connect sequence in libcouchbase */
+    if ((err = lcb_connect(instance)) != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to initiate connect: %s\n", lcb_strerror(NULL, err));
+        lcb_destroy(instance);
+        exit(EXIT_FAILURE);
+    }
+    lcb_wait(instance);
+    if ((err = lcb_get_bootstrap_status(instance)) != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to establish connection to cluster: %s\n", lcb_strerror(NULL, err));
+        exit(EXIT_FAILURE);
+    }
+    lcb_install_callback3(instance, LCB_CALLBACK_HTTP, http_callback);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, store_callback);
+
+    fprintf(stderr, "key: \"%s\"\n", key);
+    fprintf(stderr, "value size: %ld\n", nbytes);
+    fprintf(stderr, "connection string: %s\n", create_options.v.v3.connstr ? create_options.v.v3.connstr : "");
+    fprintf(stderr, "password: %s\n", create_options.v.v0.passwd ? create_options.v.v3.passwd : "");
+    bytes = malloc(nbytes);
+
+    {
+        lcb_CMDSTORE cmd = { 0 };
+        cmd.operation = LCB_SET;
+        LCB_CMD_SET_KEY(&cmd, key, nkey);
+        LCB_CMD_SET_VALUE(&cmd, bytes, nbytes);
+        err = lcb_store3(instance, NULL, &cmd);
+        if (err != LCB_SUCCESS) {
+            fprintf(stderr, "Failed to store: %s\n", lcb_strerror(NULL, err));
+            exit(EXIT_FAILURE);
+        }
+    }
+    lcb_wait(instance);
+
+    /* Set view and design name: */
+    view = "all";
+    design = key;
+
+    {
+        char design_path[64] = { 0 };
+        char doc[256] = { 0 };
+        lcb_CMDHTTP cmd = { 0 };
+        sprintf(design_path, "_design/%s", design);
+        sprintf(doc, "{\"views\":{\"all\":{\"map\":\"function(doc,meta){if(meta.id=='%s'){emit(meta.id)}}\"}}}", key);
+
+        LCB_CMD_SET_KEY(&cmd, design_path, strlen(design_path));
+        cmd.body = doc;
+        cmd.nbody = strlen(doc);
+        cmd.method = LCB_HTTP_METHOD_PUT;
+        cmd.type = LCB_HTTP_TYPE_VIEW;
+        cmd.content_type = "application/json";
+        err = lcb_http3(instance, NULL, &cmd);
+        if (err != LCB_SUCCESS) {
+            fprintf(stderr, "Failed to create design document: %s (0x%02x)\n", lcb_strerror(NULL, err), err);
+            exit(EXIT_FAILURE);
+        }
+    }
+    lcb_wait(instance);
+
+    do_query_view(instance);
+    lcb_wait(instance);
+    lcb_destroy(instance);
+
+    exit(EXIT_SUCCESS);
+}

data/ext/libcouchbase/example/instancepool/main.cc

@@ -0,0 +1,102 @@
+/* -*- 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 "pool.h"
+#include <stdio.h>
+#include <vector>
+
+using namespace lcb;
+
+extern "C" {
+static void get_callback(lcb_t instance, int, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPGET *rg = reinterpret_cast<const lcb_RESPGET*>(rb);
+    if (rb->rc != LCB_SUCCESS) {
+        fprintf(stderr, "%p: Couldn't get key", instance);
+    } else {
+        fprintf(stderr, "%p: Got key %.*s with value %.*s\n", instance,
+            (int)rg->nkey, rg->key, (int)rg->nvalue, rg->value);
+    }
+}
+}
+
+class MyPool : public Pool {
+public:
+    MyPool(const lcb_create_st& opts, size_t items) : Pool(opts, items) {}
+protected:
+    void initialize(lcb_t instance) {
+        // We override the initialize function to set the proper callback we
+        // care about
+        fprintf(stderr, "Initializing %p\n", instance);
+        lcb_install_callback3(instance, LCB_CALLBACK_GET, get_callback);
+    }
+};
+
+extern "C" {
+static void *
+pthr_func(void *arg) {
+    Pool *pool = reinterpret_cast<Pool*>(arg);
+    lcb_CMDGET gcmd = { 0 };
+    LCB_CMD_SET_KEY(&gcmd, "foo", 3);
+
+    // Get an instance to use
+    lcb_t instance = pool->pop();
+
+    // Issue the command
+    lcb_get3(instance, NULL, &gcmd);
+
+    // Wait for the command to complete
+    lcb_wait(instance);
+
+    // Release back to pool
+    pool->push(instance);
+
+    return NULL;
+}
+}
+
+#define NUM_WORKERS 20
+int main(void) {
+    lcb_create_st options;
+    pthread_t workers[NUM_WORKERS];
+    Pool *pool;
+    lcb_error_t err;
+
+    // set up the options to represent your cluster (hostname etc)
+    memset(&options, 0, sizeof options);
+    options.version = 3;
+    options.v.v3.connstr = "couchbase://localhost/default";
+    pool = new MyPool(options, 5);
+
+    err = pool->connect();
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "Couldn't connect all instances: %s\n", lcb_strerror(NULL, err));
+        exit(EXIT_FAILURE);
+    }
+
+    for (size_t ii = 0; ii < NUM_WORKERS; ii++) {
+        pthread_create(&workers[ii], NULL, pthr_func, pool);
+    }
+
+    for (size_t ii = 0; ii < NUM_WORKERS; ii++) {
+        void *unused;
+        pthread_join(workers[ii], &unused);
+    }
+
+    delete pool;
+    return 0;
+}

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

@@ -0,0 +1,102 @@
+/* -*- 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 "pool.h"
+
+using namespace lcb;
+using std::queue;
+using std::vector;
+
+Pool::Pool(const lcb_create_st& options, size_t nitems) : initial_size(0)
+{
+    pthread_mutex_init(&mutex, NULL);
+    pthread_cond_init(&cond, NULL);
+    for (size_t ii = 0; ii < nitems; ii++) {
+        lcb_t cur;
+        lcb_error_t err = lcb_create(&cur, &options);
+        if (err != LCB_SUCCESS) {
+            throw err;
+        }
+
+        instances.push(cur);
+        all_instances.push_back(cur);
+        initial_size++;
+    }
+}
+
+lcb_error_t
+Pool::connect()
+{
+    vector<lcb_t>::const_iterator ii = all_instances.begin();
+    for (;  ii != all_instances.end(); ii++) {
+        lcb_error_t err;
+        initialize(*ii);
+        if ((err = lcb_connect(*ii)) != LCB_SUCCESS) {
+            return err;
+        }
+        lcb_wait(*ii);
+        if ((err = lcb_get_bootstrap_status(*ii)) != LCB_SUCCESS) {
+            return err;
+        }
+    }
+    return LCB_SUCCESS;
+}
+
+Pool::~Pool()
+{
+    pthread_mutex_lock(&mutex);
+    while (instances.size() < initial_size) {
+        pthread_cond_wait(&cond, &mutex);
+    }
+    vector<lcb_t>::const_iterator ii = all_instances.begin();
+    for (; ii != all_instances.end(); ii++) {
+        lcb_destroy(*ii);
+    }
+    pthread_mutex_unlock(&mutex);
+    pthread_mutex_destroy(&mutex);
+    pthread_cond_destroy(&cond);
+}
+
+lcb_t
+Pool::pop()
+{
+    lcb_t ret = NULL;
+
+    // Need to lock the mutex to the pool structure itself
+    pthread_mutex_lock(&mutex);
+
+    while (instances.empty()) {
+        pthread_cond_wait(&cond, &mutex);
+    }
+
+    ret = instances.front();
+    instances.pop();
+    pthread_mutex_unlock(&mutex);
+
+    // Note that the instance itself does not need a mutex as long as it is not
+    // used between multiple threads concurrently.
+    return ret;
+}
+
+void
+Pool::push(lcb_t instance)
+{
+    pthread_mutex_lock(&mutex);
+    instances.push(instance);
+    pthread_cond_signal(&cond);
+    pthread_mutex_unlock(&mutex);
+}

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