libcouchbase 0.0.1

data/ext/libcouchbase/src/nodeinfo.cc

@@ -0,0 +1,194 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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 "internal.h"
+#include <lcbio/lcbio.h>
+#include "bucketconfig/clconfig.h"
+#include "hostlist.h"
+
+/**This file contains routines to assist users in retrieving valid nodes */
+
+/* We're gonna try to be extra careful in this function since many SDKs use
+ * this to display node and/or host-port information.*/
+
+static std::string&
+ensure_scratch(lcb_t instance)
+{
+    if (!instance->scratch) {
+        instance->scratch = new std::string;
+    }
+    instance->scratch->clear();
+    return *instance->scratch;
+}
+
+static const char *
+mk_scratch_host(lcb_t instance, const lcb_host_t *host)
+{
+    std::string& s = ensure_scratch(instance);
+    s.append(host->host);
+    s.append(":");
+    s.append(host->port);
+    return s.c_str();
+}
+
+static const char *
+return_badhost(lcb_GETNODETYPE type)
+{
+    if (type & LCB_NODE_NEVERNULL) {
+        return LCB_GETNODE_UNAVAILABLE;
+    } else {
+        return NULL;
+    }
+}
+
+LIBCOUCHBASE_API
+const char *
+lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
+{
+    lcbvb_SVCMODE mode;
+    lcbvb_CONFIG *vbc = LCBT_VBCONFIG(instance);
+
+    if (LCBT_SETTING(instance, sslopts) & LCB_SSL_ENABLED) {
+        mode = LCBVB_SVCMODE_SSL;
+    } else {
+        mode = LCBVB_SVCMODE_PLAIN;
+    }
+
+    if (type & LCB_NODE_HTCONFIG) {
+        if (type & LCB_NODE_CONNECTED) {
+            const lcb_host_t *host = lcb_confmon_get_rest_host(instance->confmon);
+            if (host) {
+                return mk_scratch_host(instance, host);
+            } else {
+                return return_badhost(type);
+            }
+
+        } else {
+            /* Retrieve one from the vbucket configuration */
+            const char *hp = NULL;
+
+            if (instance->type == LCB_TYPE_BUCKET) {
+                if (vbc) {
+                    ix %= LCBVB_NSERVERS(vbc);
+                    hp = lcbvb_get_hostport(vbc, ix, LCBVB_SVCTYPE_MGMT, mode);
+
+                } else if ((type & LCB_NODE_NEVERNULL) == 0) {
+                    return NULL;
+                }
+            }
+            if (hp == NULL && instance->ht_nodes && !instance->ht_nodes->empty()) {
+                ix %= instance->ht_nodes->size();
+                instance->ht_nodes->ensure_strlist();
+                hp = instance->ht_nodes->hoststrs[ix];
+            }
+            if (!hp) {
+                return return_badhost(type);
+            }
+            return ensure_scratch(instance).append(hp).c_str();
+        }
+    } else if (type & (LCB_NODE_DATA|LCB_NODE_VIEWS)) {
+        const mc_SERVER *server;
+        ix %= LCBT_NSERVERS(instance);
+        server = LCBT_GET_SERVER(instance, ix);
+
+        if ((type & LCB_NODE_CONNECTED) && server->connctx == NULL) {
+            return return_badhost(type);
+        }
+        if (server->curhost == NULL) {
+            return return_badhost(type);
+        }
+
+        /* otherwise, return the actual host:port of the server */
+        if (type & LCB_NODE_DATA) {
+            return mk_scratch_host(instance, server->curhost);
+        } else {
+            return lcbvb_get_hostport(vbc, ix, LCBVB_SVCTYPE_VIEWS, mode);
+        }
+    } else {
+        return NULL; /* don't know the type */
+    }
+}
+
+LIBCOUCHBASE_API const char * lcb_get_host(lcb_t instance) {
+    char *colon;
+    const char *rv = lcb_get_node(instance,
+        static_cast<lcb_GETNODETYPE>(LCB_NODE_HTCONFIG|LCB_NODE_NEVERNULL), 0);
+    if (rv != NULL && (colon = (char *)strstr(rv, ":"))  != NULL) {
+        if (instance->scratch && rv == instance->scratch->c_str()) {
+            // We have a colon
+            size_t colon_pos = instance->scratch->find(':');
+            if (colon_pos != std::string::npos) {
+                instance->scratch->erase(colon_pos);
+            }
+        }
+    }
+    return rv;
+}
+
+LIBCOUCHBASE_API const char * lcb_get_port(lcb_t instance) {
+    const char *rv = lcb_get_node(instance,
+        static_cast<lcb_GETNODETYPE>(LCB_NODE_HTCONFIG|LCB_NODE_NEVERNULL), 0);
+    if (rv && (rv = strstr(rv, ":"))) {
+        rv++;
+    }
+    return rv;
+}
+
+LIBCOUCHBASE_API
+lcb_int32_t lcb_get_num_replicas(lcb_t instance)
+{
+    if (LCBT_VBCONFIG(instance)) {
+        return LCBT_NREPLICAS(instance);
+    } else {
+        return -1;
+    }
+}
+
+LIBCOUCHBASE_API
+lcb_int32_t lcb_get_num_nodes(lcb_t instance)
+{
+    if (LCBT_VBCONFIG(instance)) {
+        return LCBT_NSERVERS(instance);
+    } else {
+        return -1;
+    }
+}
+
+LIBCOUCHBASE_API
+const char *const *lcb_get_server_list(lcb_t instance)
+{
+    return hostlist_strents(instance->ht_nodes);
+}
+
+LIBCOUCHBASE_API
+const char *
+lcb_get_keynode(lcb_t instance, const void *key, size_t nkey)
+{
+    lcbvb_CONFIG *vbc = LCBT_VBCONFIG(instance);
+    int srvix, vbid;
+
+    if (!vbc) {
+        return NULL;
+    }
+
+    lcbvb_map_key(vbc, key, nkey, &vbid, &srvix);
+    if (srvix < 0) {
+        return NULL;
+    }
+
+    return lcbvb_get_hostname(vbc, srvix);
+}

data/ext/libcouchbase/src/operations/cbflush.c

@@ -0,0 +1,71 @@
+/*
+ *     Copyright 2010-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.
+ */
+
+#include "internal.h"
+#include "simplestring.h"
+#include <http/http.h>
+
+static void
+flush_cb(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPHTTP *resp = (const lcb_RESPHTTP *)rb;
+    lcb_RESPCBFLUSH fresp = { 0 };
+    lcb_RESPCALLBACK callback = lcb_find_callback(instance, LCB_CALLBACK_CBFLUSH);
+
+    fresp = *(lcb_RESPBASE *)rb;
+    fresp.rflags |= LCB_RESP_F_FINAL;
+    if (resp->rc == LCB_SUCCESS) {
+        if (resp->htstatus < 200 || resp->htstatus > 299) {
+            fresp.rc = LCB_HTTP_ERROR;
+        }
+    }
+    if (callback) {
+        callback(instance, LCB_CALLBACK_CBFLUSH, (lcb_RESPBASE*)&fresp);
+    }
+    (void)cbtype;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_cbflush3(lcb_t instance, const void *cookie, const lcb_CMDBASE *cmd)
+{
+    lcb_http_request_t htr;
+    lcb_CMDHTTP htcmd = { 0 };
+    lcb_string urlpath;
+    lcb_error_t rc;
+
+    (void)cmd;
+
+    lcb_string_init(&urlpath);
+    lcb_string_appendz(&urlpath, "/pools/default/buckets/");
+    lcb_string_appendz(&urlpath, LCBT_SETTING(instance, bucket));
+    lcb_string_appendz(&urlpath, "/controller/doFlush");
+
+
+    htcmd.type = LCB_HTTP_TYPE_MANAGEMENT;
+    htcmd.method = LCB_HTTP_METHOD_POST;
+    htcmd.reqhandle = &htr;
+    LCB_CMD_SET_KEY(&htcmd, urlpath.base, urlpath.nused);
+
+    rc = lcb_http3(instance, cookie, &htcmd);
+    lcb_string_release(&urlpath);
+
+    if (rc != LCB_SUCCESS) {
+        return rc;
+    }
+    lcb_htreq_setcb(htr, flush_cb);
+    return LCB_SUCCESS;
+}

data/ext/libcouchbase/src/operations/counter.c

@@ -0,0 +1,116 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-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.
+ */
+#include "internal.h"
+#include "trace.h"
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_counter3(
+        lcb_t instance, const void *cookie, const lcb_CMDCOUNTER *cmd)
+{
+    mc_CMDQUEUE *q = &instance->cmdq;
+    mc_PIPELINE *pipeline;
+    mc_PACKET *packet;
+    mc_REQDATA *rdata;
+    lcb_error_t err;
+
+    protocol_binary_request_incr acmd;
+    protocol_binary_request_header *hdr = &acmd.message.header;
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+    if (cmd->cas || (cmd->create == 0 && cmd->exptime != 0)) {
+        return LCB_OPTIONS_CONFLICT;
+    }
+
+    err = mcreq_basic_packet(q, (const lcb_CMDBASE *)cmd, hdr, 20, &packet,
+        &pipeline, MCREQ_BASICPACKET_F_FALLBACKOK);
+
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    rdata = &packet->u_rdata.reqdata;
+    rdata->cookie = cookie;
+    rdata->start = gethrtime();
+    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr->request.cas = 0;
+    hdr->request.opaque = packet->opaque;
+    hdr->request.bodylen =
+            htonl(hdr->request.extlen + ntohs(hdr->request.keylen));
+
+    acmd.message.body.delta = lcb_htonll((lcb_uint64_t)cmd->delta);
+    acmd.message.body.initial = lcb_htonll(cmd->initial);
+    if (!cmd->create) {
+        memset(&acmd.message.body.expiration, 0xff,
+               sizeof(acmd.message.body.expiration));
+    } else {
+        acmd.message.body.expiration = htonl(cmd->exptime);
+    }
+
+    if (cmd->delta < 0) {
+        hdr->request.opcode = PROTOCOL_BINARY_CMD_DECREMENT;
+        acmd.message.body.delta = lcb_htonll((lcb_uint64_t)(cmd->delta * -1));
+    } else {
+        hdr->request.opcode = PROTOCOL_BINARY_CMD_INCREMENT;
+    }
+
+    memcpy(SPAN_BUFFER(&packet->kh_span), acmd.bytes, sizeof(acmd.bytes));
+    TRACE_ARITHMETIC_BEGIN(hdr, cmd);
+    LCB_SCHED_ADD(instance, pipeline, packet);
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_arithmetic(lcb_t instance,
+                           const void *cookie,
+                           lcb_size_t num,
+                           const lcb_arithmetic_cmd_t *const *items)
+{
+    unsigned ii;
+
+    lcb_sched_enter(instance);
+
+    for (ii = 0; ii < num; ii++) {
+        const lcb_arithmetic_cmd_t *src = items[ii];
+        lcb_CMDCOUNTER dst;
+        lcb_error_t err;
+
+        memset(&dst, 0, sizeof(dst));
+
+        dst.create = src->v.v0.create;
+        dst.delta = src->v.v0.delta;
+        dst.initial = src->v.v0.initial;
+        dst.key.type = LCB_KV_COPY;
+        dst.key.contig.bytes = src->v.v0.key;
+        dst.key.contig.nbytes = src->v.v0.nkey;
+        dst._hashkey.type = LCB_KV_COPY;
+        dst._hashkey.contig.bytes = src->v.v0.hashkey;
+        dst._hashkey.contig.nbytes = src->v.v0.nhashkey;
+        dst.exptime = src->v.v0.exptime;
+        err = lcb_counter3(instance, cookie, &dst);
+        if (err != LCB_SUCCESS) {
+            lcb_sched_fail(instance);
+            return err;
+        }
+    }
+
+    lcb_sched_leave(instance);
+    SYNCMODE_INTERCEPT(instance)
+}

data/ext/libcouchbase/src/operations/durability-cas.c

@@ -0,0 +1,224 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012-2015 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.
+ */
+
+#define LCBDUR_PRIV_SYMS
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include "internal.h"
+#include "durability_internal.h"
+
+#define DSET_HT(dset) (dset)->impldata
+
+/* Called when the criteria is to ensure the key exists somewhow */
+static int
+check_positive_durability(lcb_DURITEM *ent, const lcb_RESPOBSERVE *res)
+{
+    switch (res->status) {
+    case LCB_OBSERVE_NOT_FOUND:
+    case LCB_OBSERVE_LOGICALLY_DELETED:
+        /* If we get NOT_FOUND from the master, this means the key
+         * simply does not exists (and we don't have to continue polling) */
+        if (res->ismaster) {
+            RESFLD(ent, rc) = LCB_KEY_ENOENT;
+            lcbdur_ent_finish(ent);
+        }
+        return 0;
+
+    case LCB_OBSERVE_PERSISTED:
+        return LCBDUR_UPDATE_PERSISTED | LCBDUR_UPDATE_REPLICATED;
+
+    case LCB_OBSERVE_FOUND:
+        return LCBDUR_UPDATE_REPLICATED;
+
+    default:
+        RESFLD(ent, rc) = LCB_EINTERNAL;
+        lcbdur_ent_finish(ent);
+        return 0;
+    }
+}
+
+/* Called when the criteria is to ensure that the key is deleted somehow */
+static int
+check_negative_durability(lcb_DURITEM *ent, const lcb_RESPOBSERVE *res)
+{
+    switch (res->status) {
+    case LCB_OBSERVE_PERSISTED:
+    case LCB_OBSERVE_FOUND:
+        /* Still there! */
+        return 0;
+
+    case LCB_OBSERVE_LOGICALLY_DELETED:
+        /* removed from cache, but not actually deleted from disk */
+        return LCBDUR_UPDATE_REPLICATED;
+
+    case LCB_OBSERVE_NOT_FOUND:
+        /* No knowledge of key. */
+        return LCBDUR_UPDATE_PERSISTED | LCBDUR_UPDATE_REPLICATED;
+
+    default:
+        RESFLD(ent, rc) = LCB_EINTERNAL;
+        lcbdur_ent_finish(ent);
+        return 0;
+    }
+}
+
+/* Observe callback. Called internally by observe.c */
+void
+lcbdur_cas_update(lcb_t instance,
+    lcb_DURSET *dset, lcb_error_t err, const lcb_RESPOBSERVE *resp)
+{
+    lcb_DURITEM *ent;
+    int flags;
+
+    if (resp->key == NULL) {
+        /* Last observe response for requests. Start polling after interval */
+        lcbdur_reqs_done(dset);
+        return;
+    }
+
+    if (DSET_COUNT(dset) == 1) {
+        ent = DSET_ENTRIES(dset);
+    } else {
+        ent = genhash_find(DSET_HT(dset), resp->key, resp->nkey);
+    }
+
+    if (ent->done) {
+        /* ignore subsequent errors */
+        return;
+    }
+
+    if (err != LCB_SUCCESS) {
+        RESFLD(ent, rc) = err;
+        return;
+    }
+
+    RESFLD(ent, nresponses)++;
+    if (resp->cas && resp->ismaster) {
+        RESFLD(ent, cas) = resp->cas;
+
+        if (ent->reqcas && ent->reqcas != resp->cas) {
+            RESFLD(ent, rc) = LCB_KEY_EEXISTS;
+            lcbdur_ent_finish(ent);
+            return;
+        }
+    }
+
+    if (DSET_OPTFLD(ent->parent, check_delete)) {
+        flags = check_negative_durability(ent, resp);
+    } else {
+        flags = check_positive_durability(ent, resp);
+    }
+
+    lcbdur_update_item(ent, flags, resp->ttp);
+    (void)instance;
+}
+
+static lcb_error_t
+cas_poll(lcb_DURSET *dset)
+{
+    lcb_MULTICMD_CTX *mctx;
+    size_t ii;
+    lcb_error_t err;
+    lcb_t instance = dset->instance;
+
+    mctx = lcb_observe_ctx_dur_new(dset->instance);
+    if (!mctx) {
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    for (ii = 0; ii < DSET_COUNT(dset); ii++) {
+        lcb_CMDOBSERVE cmd = { 0 };
+        lcb_U16 servers[4];
+        size_t nservers = 0;
+
+        struct lcb_DURITEM_st *ent = DSET_ENTRIES(dset) + ii;
+        if (ent->done) {
+            continue;
+        }
+
+        lcbdur_prepare_item(ent, servers, &nservers);
+        if (nservers == 0) {
+            RESFLD(ent, rc) = LCB_NO_MATCHING_SERVER;
+            continue;
+        }
+
+        LCB_KREQ_SIMPLE(&cmd.key, RESFLD(ent, key), RESFLD(ent, nkey));
+        LCB_CMD__SETVBID(&cmd, ent->vbid);
+        cmd.servers_ = servers;
+        cmd.nservers_ = nservers;
+
+        err = mctx->addcmd(mctx, (lcb_CMDBASE *)&cmd);
+        if (err != LCB_SUCCESS) {
+            mctx->fail(mctx);
+            return err;
+        }
+    }
+
+    lcb_sched_enter(instance);
+    err = mctx->done(mctx, dset);
+    mctx = NULL;
+
+    if (err == LCB_SUCCESS) {
+        lcb_sched_leave(instance);
+        dset->waiting = 1;
+    } else {
+        lcb_sched_fail(instance);
+    }
+    return err;
+}
+
+static lcb_error_t
+cas_schedule(lcb_DURSET *dset)
+{
+    size_t ii;
+
+    if (DSET_COUNT(dset) < 2) {
+        return LCB_SUCCESS;
+    }
+
+    DSET_HT(dset) = lcb_hashtable_nc_new(DSET_COUNT(dset));
+    if (!DSET_HT(dset)) {
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    for (ii = 0; ii < DSET_COUNT(dset); ++ii) {
+        int mt;
+        lcb_DURITEM *ent = DSET_ENTRIES(dset) + ii;
+
+        mt = genhash_update(DSET_HT(dset),
+            RESFLD(ent, key), RESFLD(ent, nkey), ent, 0);
+        if (mt != NEW) {
+            return LCB_DUPLICATE_COMMANDS;
+        }
+    }
+    return LCB_SUCCESS;
+}
+
+static void
+cas_clean(lcb_DURSET *dset)
+{
+    if (DSET_HT(dset)) {
+        genhash_free(DSET_HT(dset));
+    }
+}
+
+lcbdur_PROCS lcbdur_cas_procs = {
+        cas_poll,
+        NULL, /* ent_add */
+        cas_schedule,
+        cas_clean
+};