libcouchbase 0.0.1

data/ext/libcouchbase/example/observe/observe.c

@@ -0,0 +1,146 @@
+/* -*- 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.
+ */
+
+/*
+ * BUILD: `cc -o observe observe.c -lcouchbase`
+ * RUN: `./observe key`
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+
+#define fail(msg) \
+    fprintf(stderr, "%s\n", msg); \
+    exit(EXIT_FAILURE);
+
+#define fail2(msg, err) \
+    fprintf(stderr, "%s\n", msg); \
+    fprintf(stderr, "Error was 0x%x (%s)\n", err, lcb_strerror(NULL, err))
+
+typedef struct {
+    int master;
+    lcb_U8 status;
+    lcb_U64 cas;
+} node_info;
+
+typedef struct {
+    unsigned nresp;
+    node_info *nodeinfo;
+} observe_info;
+
+static void
+observe_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPOBSERVE *resp = (const lcb_RESPOBSERVE*)rb;
+    observe_info *obs_info = (observe_info *)rb->cookie;
+    node_info *ni = &obs_info->nodeinfo[obs_info->nresp];
+
+    if (rb->nkey == 0) {
+        fprintf(stderr, "All nodes have replied\n");
+        return;
+    }
+
+    if (rb->rc != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to observe key from node. 0x%x (%s)\n",
+            rb->rc, lcb_strerror(instance, rb->rc));
+        obs_info->nresp++;
+        return;
+    }
+
+    /* Copy over the fields we care about */
+    ni->cas = resp->cas;
+    ni->status = resp->status;
+    ni->master = resp->ismaster;
+
+    /* Increase the response counter */
+    obs_info->nresp++;
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_t instance;
+    lcb_error_t err;
+    lcb_CMDOBSERVE cmd = { 0 };
+    lcb_MULTICMD_CTX *mctx = NULL;
+    observe_info obs_info;
+    unsigned nservers, ii;
+
+    if (argc != 2) {
+        fail("requires key as argument");
+    }
+
+    if ((err = lcb_create(&instance, NULL)) != LCB_SUCCESS) {
+        fail2("cannot create connection instance", err);
+    }
+    if ((err = lcb_connect(instance)) != LCB_SUCCESS) {
+        fail2("Couldn't schedule connection", err);
+    }
+    lcb_wait(instance);
+    if ((err = lcb_get_bootstrap_status(instance)) != LCB_SUCCESS) {
+        fail2("Couldn't get initial cluster configuration", err);
+    }
+    lcb_install_callback3(instance, LCB_CALLBACK_OBSERVE, observe_callback);
+
+    nservers = lcb_get_num_nodes(instance);
+    obs_info.nodeinfo = calloc(nservers, sizeof (*obs_info.nodeinfo));
+    obs_info.nresp = 0;
+
+    mctx = lcb_observe3_ctxnew(instance);
+    LCB_CMD_SET_KEY(&cmd, argv[1], strlen(argv[1]));
+    mctx->addcmd(mctx, (const lcb_CMDBASE*)&cmd);
+
+    printf("observing the state of '%s':\n", argv[1]);
+    if ((err = mctx->done(mctx, &obs_info)) != LCB_SUCCESS) {
+        fail2("Couldn't schedule observe request", err);
+    }
+
+    lcb_wait(instance);
+    for (ii = 0; ii < obs_info.nresp; ii++) {
+        node_info *ni = &obs_info.nodeinfo[ii];
+        fprintf(stderr, "Got status from %s node:\n", ni->master ? "master" : "replica");
+        fprintf(stderr, "\tCAS: 0x0%llx\n", ni->cas);
+        fprintf(stderr, "\tStatus (RAW): 0x%02x\n", ni->status);
+        fprintf(stderr, "\tExists [CACHE]: %s\n", ni->status & LCB_OBSERVE_NOT_FOUND ? "No" : "Yes");
+        fprintf(stderr, "\tExists [DISK]: %s\n", ni->status & LCB_OBSERVE_PERSISTED ? "Yes" : "No");
+        fprintf(stderr, "\n");
+    }
+
+    /* The next example shows how to use lcb_observe() to only request the
+     * CAS from the master node */
+    obs_info.nresp = 0;
+    memset(obs_info.nodeinfo, 0, sizeof(obs_info.nodeinfo[0]) * nservers);
+
+    fprintf(stderr, "Will request CAS from master...\n");
+    cmd.cmdflags |= LCB_CMDOBSERVE_F_MASTER_ONLY;
+    mctx = lcb_observe3_ctxnew(instance);
+    mctx->addcmd(mctx, (const lcb_CMDBASE*)&cmd);
+    if ((err = mctx->done(mctx, &obs_info)) != LCB_SUCCESS) {
+        fail2("Couldn't schedule observe request!\n", err);
+    }
+
+    lcb_wait(instance);
+
+    assert(obs_info.nresp == 1 && obs_info.nodeinfo[0].master);
+    fprintf(stderr, "CAS on master is 0x%llx\n", obs_info.nodeinfo[0].cas);
+
+    lcb_destroy(instance);
+    free(obs_info.nodeinfo);
+    return EXIT_SUCCESS;
+}

data/ext/libcouchbase/example/subdoc/subdoc-multi.cc

@@ -0,0 +1,132 @@
+#define LCB_NO_DEPR_CXX_CTORS
+#undef NDEBUG
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <assert.h>
+#include <string.h>
+#include <string>
+#include <vector>
+
+static void generic_callback(lcb_t, int type, const lcb_RESPBASE *rb)
+{
+    printf("Got callback for %s\n", lcb_strcbtype(type));
+
+    if (rb->rc != LCB_SUCCESS && rb->rc != LCB_SUBDOC_MULTI_FAILURE) {
+        printf("Failure: 0x%x\n", rb->rc);
+        abort();
+    }
+
+    if (type == LCB_CALLBACK_GET) {
+        const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
+        printf("Result is: %.*s\n", (int)rg->nvalue, rg->value);
+    } else if (type == LCB_CALLBACK_SDLOOKUP || type == LCB_CALLBACK_SDMUTATE) {
+        lcb_SDENTRY ent;
+        size_t iter = 0;
+        size_t oix = 0;
+        const lcb_RESPSUBDOC *resp = reinterpret_cast<const lcb_RESPSUBDOC*>(rb);
+        while (lcb_sdresult_next(resp, &ent, &iter)) {
+            size_t index = oix++;
+            if (type == LCB_CALLBACK_SDMUTATE) {
+                index = ent.index;
+            }
+            printf("[%lu]: 0x%x. %.*s\n",
+                index, ent.status, (int)ent.nvalue, ent.value);
+        }
+    }
+}
+
+// cluster_run mode
+#define DEFAULT_CONNSTR "couchbase://localhost"
+
+int main(int argc, char **argv) {
+    lcb_create_st crst = { 0 };
+    crst.version = 3;
+    if (argc > 1) {
+        crst.v.v3.connstr = argv[1];
+    } else {
+        crst.v.v3.connstr = DEFAULT_CONNSTR;
+    }
+
+    lcb_t instance;
+    lcb_error_t rc = lcb_create(&instance, &crst);
+    assert(rc == LCB_SUCCESS);
+
+    rc = lcb_connect(instance);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+    rc = lcb_get_bootstrap_status(instance);
+    assert(rc == LCB_SUCCESS);
+
+    // Install generic callback
+    lcb_install_callback3(instance, LCB_CALLBACK_DEFAULT, generic_callback);
+
+    // Store an item
+    lcb_CMDSTORE scmd = { 0 };
+    scmd.operation = LCB_SET;
+    LCB_CMD_SET_KEY(&scmd, "key", 3);
+    const char *initval = "{\"hello\":\"world\"}";
+    LCB_CMD_SET_VALUE(&scmd, initval, strlen(initval));
+    rc = lcb_store3(instance, NULL, &scmd);
+    assert(rc == LCB_SUCCESS);
+
+    lcb_CMDSUBDOC mcmd = { 0 };
+    LCB_CMD_SET_KEY(&mcmd, "key", 3);
+
+    std::vector<lcb_SDSPEC> specs;
+    std::string bufs[10];
+
+    // Add some mutations
+    for (int ii = 0; ii < 5; ii++) {
+        std::string& path = bufs[ii * 2];
+        std::string& val = bufs[(ii * 2) + 1];
+        char pbuf[24], vbuf[24];
+
+        sprintf(pbuf, "pth%d", ii);
+        sprintf(vbuf, "\"Value_%d\"", ii);
+        path = pbuf;
+        val = vbuf;
+
+        lcb_SDSPEC spec = { 0 };
+        LCB_SDSPEC_SET_PATH(&spec, path.c_str(), path.size());
+        LCB_CMD_SET_VALUE(&spec, val.c_str(), val.size());
+        spec.sdcmd = LCB_SDCMD_DICT_UPSERT;
+        specs.push_back(spec);
+    }
+
+    mcmd.specs = specs.data();
+    mcmd.nspecs = specs.size();
+    rc = lcb_subdoc3(instance, NULL, &mcmd);
+    assert(rc == LCB_SUCCESS);
+
+    // Reset the specs
+    specs.clear();
+    for (int ii = 0; ii < 5; ii++) {
+        char pbuf[24];
+        std::string& path = bufs[ii];
+        sprintf(pbuf, "pth%d", ii);
+        path = pbuf;
+
+        lcb_SDSPEC spec = { 0 };
+        LCB_SDSPEC_SET_PATH(&spec, path.c_str(), path.size());
+        spec.sdcmd = LCB_SDCMD_GET;
+        specs.push_back(spec);
+    }
+
+    lcb_SDSPEC spec2 = { 0 };
+    LCB_SDSPEC_SET_PATH(&spec2, "dummy", 5);
+    spec2.sdcmd = LCB_SDCMD_GET;
+    specs.push_back(spec2);
+    mcmd.specs = specs.data();
+    mcmd.nspecs = specs.size();
+    rc = lcb_subdoc3(instance, NULL, &mcmd);
+    assert(rc == LCB_SUCCESS);
+
+    lcb_CMDGET gcmd = { 0 };
+    LCB_CMD_SET_KEY(&gcmd, "key", 3);
+    rc = lcb_get3(instance, NULL, &gcmd);
+    assert(rc == LCB_SUCCESS);
+
+    lcb_wait(instance);
+    lcb_destroy(instance);
+}

data/ext/libcouchbase/example/subdoc/subdoc-simple.cc

@@ -0,0 +1,191 @@
+#define LCB_NO_DEPR_CXX_CTORS
+#undef NDEBUG
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <assert.h>
+#include <string.h>
+
+static void
+op_callback(lcb_t, int cbtype, const lcb_RESPBASE *rb)
+{
+    fprintf(stderr, "Got callback for %s.. ", lcb_strcbtype(cbtype));
+    if (rb->rc != LCB_SUCCESS && rb->rc != LCB_SUBDOC_MULTI_FAILURE) {
+        fprintf(stderr, "Operation failed (%s)\n", lcb_strerror(NULL, rb->rc));
+        return;
+    }
+
+    if (cbtype == LCB_CALLBACK_GET) {
+        const lcb_RESPGET *rg = reinterpret_cast<const lcb_RESPGET*>(rb);
+        fprintf(stderr, "Value %.*s\n", (int)rg->nvalue, rg->value);
+    } else if (cbtype == LCB_CALLBACK_SDMUTATE || cbtype == LCB_CALLBACK_SDLOOKUP) {
+        const lcb_RESPSUBDOC *resp = reinterpret_cast<const lcb_RESPSUBDOC*>(rb);
+        lcb_SDENTRY ent;
+        size_t iter = 0;
+        if (lcb_sdresult_next(resp, &ent, &iter)) {
+            fprintf(stderr, "Status: 0x%x. Value: %.*s\n", ent.status, (int)ent.nvalue, ent.value);
+        } else {
+            fprintf(stderr, "No result!\n");
+        }
+    } else {
+        fprintf(stderr, "OK\n");
+    }
+}
+
+// Function to issue an lcb_get3() (and print the state of the document)
+static void
+demoKey(lcb_t instance, const char *key)
+{
+    printf("Retrieving '%s'\n", key);
+    printf("====\n");
+    lcb_CMDGET gcmd = { 0 };
+    LCB_CMD_SET_KEY(&gcmd, key, strlen(key));
+    lcb_error_t rc = lcb_get3(instance, NULL, &gcmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+    printf("====\n\n");
+}
+
+// cluster_run mode
+#define DEFAULT_CONNSTR "couchbase://localhost"
+int main(int argc, char **argv)
+{
+    lcb_create_st crst = { 0 };
+    crst.version = 3;
+    if (argc > 1) {
+        crst.v.v3.connstr = argv[1];
+    } else {
+        crst.v.v3.connstr = DEFAULT_CONNSTR;
+    }
+
+    lcb_t instance;
+    lcb_error_t rc = lcb_create(&instance, &crst);
+    assert(rc == LCB_SUCCESS);
+
+    rc = lcb_connect(instance);
+    assert(rc == LCB_SUCCESS);
+
+    lcb_wait(instance);
+
+    rc = lcb_get_bootstrap_status(instance);
+    assert(rc == LCB_SUCCESS);
+
+    lcb_install_callback3(instance, LCB_CALLBACK_DEFAULT, op_callback);
+
+    // Store the initial document. Subdocument operations cannot create
+    // documents
+    printf("Storing the initial item..\n");
+    // Store an item
+    lcb_CMDSTORE scmd = { 0 };
+    scmd.operation = LCB_SET;
+    LCB_CMD_SET_KEY(&scmd, "key", 3);
+    const char *initval = "{\"hello\":\"world\"}";
+    LCB_CMD_SET_VALUE(&scmd, initval, strlen(initval));
+    rc = lcb_store3(instance, NULL, &scmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+
+    lcb_CMDSUBDOC cmd;
+    lcb_SDSPEC spec;
+    memset(&cmd, 0, sizeof cmd);
+    memset(&spec, 0, sizeof spec);
+
+    /**
+     * Retrieve a single item from a document
+     */
+    printf("Getting the 'hello' path from the document\n");
+    LCB_CMD_SET_KEY(&cmd, "key", 3);
+    // Subdocument commands are composed of one or more lcb_SDSPEC objects
+    // Assign the spec to the command. In this case our "list" is a single spec.
+    // See subdoc-multi.cc for an example using multiple specs
+    cmd.specs = &spec;
+    cmd.nspecs = 1;
+    // Populate the spec
+    spec.sdcmd = LCB_SDCMD_GET;
+    LCB_SDSPEC_SET_PATH(&spec, "hello", 5);
+    rc = lcb_subdoc3(instance, NULL, &cmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+
+    /**
+     * Set a dictionary/object field
+     */
+    memset(&cmd, 0, sizeof cmd);
+    memset(&spec, 0, sizeof spec);
+
+    printf("Adding new 'goodbye' path to document\n");
+    LCB_CMD_SET_KEY(&cmd, "key", 3);
+    cmd.specs = &spec;
+    cmd.nspecs = 1;
+
+    spec.sdcmd = LCB_SDCMD_DICT_UPSERT;
+    LCB_SDSPEC_SET_PATH(&spec, "goodbye", 7);
+    LCB_SDSPEC_SET_VALUE(&spec, "\"world\"", 7);
+
+    rc = lcb_subdoc3(instance, NULL, &cmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+    demoKey(instance, "key");
+
+    /**
+     * Add new element to end of an array
+     */
+    memset(&cmd, 0, sizeof cmd);
+    memset(&spec, 0, sizeof spec);
+    // Options can also be used
+    printf("Appending element to array (array might be missing)\n");
+    LCB_CMD_SET_KEY(&cmd, "key", 3);
+    cmd.specs = &spec;
+    cmd.nspecs = 1;
+
+    // "push" to the end of the array
+    spec.sdcmd = LCB_SDCMD_ARRAY_ADD_LAST;
+
+    // Create the array if it doesn't exist. This option can be used with
+    // other commands as well..
+    spec.options = LCB_SDSPEC_F_MKINTERMEDIATES;
+
+    LCB_SDSPEC_SET_PATH(&spec, "array", 5);
+    LCB_SDSPEC_SET_VALUE(&spec, "1", 1);
+    rc = lcb_subdoc3(instance, NULL, &cmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+    demoKey(instance, "key");
+
+    /**
+     * Add element to the beginning of an array
+     */
+    memset(&spec, 0, sizeof spec);
+    memset(&cmd, 0, sizeof cmd);
+    printf("Prepending element to array (array must exist)\n");
+    LCB_CMD_SET_KEY(&cmd, "key", 3);
+    cmd.specs = &spec;
+    cmd.nspecs = 1;
+
+    spec.sdcmd = LCB_SDCMD_ARRAY_ADD_FIRST;
+    LCB_SDSPEC_SET_PATH(&spec, "array", 5);
+    LCB_SDSPEC_SET_VALUE(&spec, "2", 1);
+    rc = lcb_subdoc3(instance, NULL, &cmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+    demoKey(instance, "key");
+
+    /**
+     * Get the first element back..
+     */
+    memset(&spec, 0, sizeof spec);
+    memset(&cmd, 0, sizeof cmd);
+    printf("Getting first array element...\n");
+    LCB_CMD_SET_KEY(&cmd, "key", 3);
+    cmd.specs = &spec;
+    cmd.nspecs = 1;
+
+    spec.sdcmd = LCB_SDCMD_GET;
+    LCB_SDSPEC_SET_PATH(&spec, "array[0]", strlen("array[0]"));
+    rc = lcb_subdoc3(instance, NULL, &cmd);
+    assert(rc == LCB_SUCCESS);
+    lcb_wait(instance);
+
+    lcb_destroy(instance);
+    return 0;
+}