mt-libcouchbase 1.4.0

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

@@ -0,0 +1,185 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018 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.
+ */
+
+/**
+
+   CFLAGS="-I$(realpath ../../include) -I$(realpath ../../build/generated)"
+   LDFLAGS="-L$(realpath ../../build/lib) -lcouchbase -Wl,-rpath=$(realpath ../../build/lib)"
+   make query
+
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/n1ql.h>
+#include <libcouchbase/ixmgmt.h>
+
+static void check(lcb_error_t err, const char *msg)
+{
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "[\x1b[31mERROR\x1b[0m] %s: %s\n", msg, lcb_strerror_short(err));
+        exit(EXIT_FAILURE);
+    }
+}
+
+static int err2color(lcb_error_t err)
+{
+    switch (err) {
+        case LCB_SUCCESS:
+            return 32;
+        case LCB_KEY_EEXISTS:
+            return 33;
+        default:
+            return 31;
+    }
+}
+
+static void ln2space(const void *buf, size_t nbuf)
+{
+    size_t ii;
+    char *str = (char *)buf;
+    for (ii = 0; ii < nbuf; ii++) {
+        if (str[ii] == '\n') {
+            str[ii] = ' ';
+        }
+    }
+}
+
+static void row_callback(lcb_t instance, int type, const lcb_RESPN1QL *resp)
+{
+    ln2space(resp->row, resp->nrow);
+    fprintf(stderr, "[\x1b[%dmQUERY\x1b[0m] %s, (%d) %.*s\n", err2color(resp->rc), lcb_strerror_short(resp->rc),
+            (int)resp->nrow, (int)resp->nrow, (char *)resp->row);
+    if (resp->rflags & LCB_RESP_F_FINAL) {
+        fprintf(stderr, "\n");
+    }
+}
+
+static void idx_callback(lcb_t instance, int type, const lcb_RESPN1XMGMT *resp)
+{
+    const lcb_RESPN1QL *inner = resp->inner;
+    ln2space(inner->row, inner->nrow);
+    fprintf(stderr, "[\x1b[%dmINDEX\x1b[0m] %s, (%d) %.*s\n", err2color(resp->rc), lcb_strerror_short(resp->rc),
+            (int)inner->nrow, (int)inner->nrow, (char *)inner->row);
+}
+
+static void kv_callback(lcb_t instance, int type, const lcb_RESPBASE *resp)
+{
+    fprintf(stderr, "[\x1b[%dm%-5s\x1b[0m] %s, key=%.*s\n", err2color(resp->rc), lcb_strcbtype(type),
+            lcb_strerror_short(resp->rc), (int)resp->nkey, resp->key);
+}
+
+static int running = 1;
+static void sigint_handler(int unused)
+{
+    running = 0;
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_error_t err;
+    lcb_t instance;
+    char *bucket = NULL;
+    const char *key = "user:king_arthur";
+    const char *val = "{"
+                      "  \"email\": \"kingarthur@couchbase.com\","
+                      "  \"interests\": [\"Holy Grail\", \"African Swallows\"]"
+                      "}";
+
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s couchbase://host/bucket [ password [ username ] ]\n", argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    {
+        struct lcb_create_st create_options = {0};
+        create_options.version = 3;
+        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];
+        }
+        check(lcb_create(&instance, &create_options), "create couchbase handle");
+        check(lcb_connect(instance), "schedule connection");
+        lcb_wait(instance);
+        check(lcb_get_bootstrap_status(instance), "bootstrap from cluster");
+        check(lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_BUCKETNAME, &bucket), "get bucket name");
+        lcb_install_callback3(instance, LCB_CALLBACK_GET, kv_callback);
+        lcb_install_callback3(instance, LCB_CALLBACK_STORE, kv_callback);
+    }
+
+    {
+        lcb_CMDSTORE cmd = {0};
+        LCB_CMD_SET_KEY(&cmd, key, strlen(key));
+        LCB_CMD_SET_VALUE(&cmd, val, strlen(val));
+        cmd.operation = LCB_SET;
+        check(lcb_store3(instance, NULL, &cmd), "schedule STORE operation");
+        lcb_wait(instance);
+    }
+
+    {
+        lcb_CMDGET cmd = {0};
+        LCB_CMD_SET_KEY(&cmd, key, strlen(key));
+        check(lcb_get3(instance, NULL, &cmd), "schedule GET operation");
+        lcb_wait(instance);
+    }
+
+    {
+        lcb_CMDN1XMGMT cmd = {0};
+        cmd.callback = idx_callback;
+        cmd.spec.flags = LCB_N1XSPEC_F_PRIMARY;
+        cmd.spec.ixtype = LCB_N1XSPEC_T_GSI;
+        check(lcb_n1x_create(instance, NULL, &cmd), "schedule N1QL index creation operation");
+        lcb_wait(instance);
+    }
+
+    /* setup CTRL-C handler */
+    struct sigaction action;
+    sigemptyset(&action.sa_mask);
+    action.sa_handler = sigint_handler;
+    action.sa_flags = 0;
+    sigaction(SIGINT, &action, NULL);
+
+    while (running) {
+        lcb_CMDN1QL cmd = {0};
+        char query[1024] = {0};
+        const char *param = "\"African Swallows\"";
+        lcb_N1QLPARAMS *builder = lcb_n1p_new();
+
+        snprintf(query, sizeof(query), "SELECT * FROM `%s` WHERE $1 in interests LIMIT 1", bucket);
+        check(lcb_n1p_setstmtz(builder, query), "set QUERY statement");
+        check(lcb_n1p_posparam(builder, param, strlen(param)), "set QUERY positional parameter");
+        check(lcb_n1p_setopt(builder, "pretty", strlen("pretty"), "false", strlen("false")),
+              "set QUERY 'pretty' option");
+        check(lcb_n1p_mkcmd(builder, &cmd), "build QUERY command structure");
+        cmd.callback = row_callback;
+        check(lcb_n1ql_query(instance, NULL, &cmd), "schedule QUERY operation");
+        lcb_n1p_free(builder);
+        lcb_wait(instance);
+    }
+
+    /* Now that we're all done, close down the connection handle */
+    lcb_destroy(instance);
+    return 0;
+}

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

@@ -0,0 +1,102 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017 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 durability durability.c -lcouchbase
+ *
+ * RUN:
+ *   ./durability [ CONNSTRING [ PASSWORD [ USERNAME ] ] ]
+ *
+ *   # use default durability check method
+ *   ./durability couchbase://localhost
+ *
+ *   # force durability check method based on sequence numbers
+ *   ./durability couchbase://localhost?fetch_mutation_tokens=true&dur_mutation_tokens=true
+ */
+#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));                                            \
+    exit(EXIT_FAILURE)
+
+static void store_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPSTOREDUR *resp = (const lcb_RESPSTOREDUR *)rb;
+    fprintf(stderr, "Got status of operation: 0x%02x, %s\n", resp->rc, lcb_strerror(NULL, resp->rc));
+    fprintf(stderr, "Stored: %s\n", resp->store_ok ? "true" : "false");
+    fprintf(stderr, "Number of roundtrips: %d\n", resp->dur_resp->nresponses);
+    fprintf(stderr, "In memory on master: %s\n", resp->dur_resp->exists_master ? "true" : "false");
+    fprintf(stderr, "Persisted on master: %s\n", resp->dur_resp->persisted_master ? "true" : "false");
+    fprintf(stderr, "Nodes have value replicated: %d\n", resp->dur_resp->nreplicated);
+    fprintf(stderr, "Nodes have value persisted (including master): %d\n", resp->dur_resp->npersisted);
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_t instance;
+    lcb_error_t err;
+    lcb_CMDSTOREDUR cmd = {0};
+    struct lcb_create_st create_options = {0};
+    const char *key = "foo";
+    const char *value = "{\"val\":42}";
+
+    create_options.version = 3;
+    if (argc > 1) {
+        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];
+    }
+
+    if ((err = lcb_create(&instance, &create_options)) != 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_STOREDUR, store_callback);
+
+    LCB_CMD_SET_KEY(&cmd, key, strlen(key));
+    LCB_CMD_SET_VALUE(&cmd, value, strlen(value));
+    /* replicate and persist on all nodes */
+    cmd.replicate_to = -1;
+    cmd.persist_to = -1;
+    lcb_storedur3(instance, NULL, &cmd);
+
+    lcb_wait(instance);
+
+    lcb_destroy(instance);
+    return EXIT_SUCCESS;
+}

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

@@ -0,0 +1,159 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013-2017 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)); \
+    exit(EXIT_FAILURE)
+
+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;
+    struct lcb_create_st create_options = { 0 };
+
+    if (argc < 2) {
+        fail("Requires key as argument\n"
+             "Usage: observe KEY [CONNSTRING [ PASSWORD [ USERNAME ] ] ]\n");
+    }
+    create_options.version = 3;
+    if (argc > 2) {
+        create_options.v.v3.connstr = argv[2];
+    }
+    if (argc > 3) {
+        create_options.v.v3.passwd = argv[3];
+    }
+    if (argc > 4) {
+        create_options.v.v3.username = argv[4];
+    }
+
+    if ((err = lcb_create(&instance, &create_options)) != 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,143 @@
+#define LCB_NO_DEPR_CXX_CTORS
+#undef NDEBUG
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <assert.h>
+#include <string.h>
+#include <cstdlib>
+#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;
+    }
+    if (argc > 2) {
+        crst.v.v3.username = argv[2];
+    } else {
+        crst.v.v3.username = "Administrator";
+    }
+    if (argc > 3) {
+        crst.v.v3.passwd = argv[3];
+    } else {
+        crst.v.v3.passwd = "password";
+    }
+
+    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);
+}