libcouchbase 0.0.1

data/ext/libcouchbase/src/operations/durability_internal.h

@@ -0,0 +1,199 @@
+/* -*- 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.
+ */
+
+#ifndef LCB_DURABILITY_INTERNAL_H
+#define LCB_DURABILITY_INTERNAL_H
+
+#include "simplestring.h"
+#include "ssobuf.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Here is the internal API for the durability functions.
+ *
+ * Durability works on polling multiple observe responses and waiting until a
+ * key (or set of keys) have either been persisted, or the wait period has
+ * expired.
+ *
+ * The operation maintains an internal counter which counts how many keys
+ * do not have a conclusive observe response yet (i.e. how many do not have
+ * their criteria satisfied yet). The operation is considered complete when
+ * the counter reaches 0.
+ */
+
+/**
+ * Information about a particular server's state -- whether it has been
+ * persisted to or replicated to. This is tied to a given mc_SERVER
+ * instance.
+ */
+typedef struct {
+    const mc_SERVER *server; /**< Server pointer (for comparison only) */
+    lcb_U16 persisted; /**< Exists on server */
+    lcb_U16 exists; /**< Persisted to server */
+} lcbdur_SERVINFO;
+
+/**Information a single entry in a durability set. Each entry contains a single
+ * key */
+typedef struct lcb_DURITEM_st {
+    lcb_U64 reqcas; /**< Last known CAS for the user */
+    lcb_U64 reqseqno; /**< Last known seqno for the user */
+    lcb_U64 uuid;
+    lcb_RESPENDURE result; /**< Result to be passed to user */
+    struct lcb_DURSET_st *parent;
+    lcb_RESPCALLBACK callback; /**< For F_INTERNAL_CALLBACK */
+    lcb_U16 vbid; /**< vBucket ID (computed via hashkey) */
+    lcb_U8 done; /**< Whether we have a conclusive result for this entry */
+
+    /** Array of servers which have satisfied constraints */
+    lcbdur_SERVINFO sinfo[4];
+} lcb_DURITEM;
+
+struct lcbdur_PROCS_st;
+
+enum {
+    LCBDUR_STATE_OBSPOLL = 0,
+    LCBDUR_STATE_INIT,
+    LCBDUR_STATE_TIMEOUT,
+    LCBDUR_STATE_IGNORE
+};
+
+/**
+ * A collection encompassing one or more entries which are to be checked for
+ * persistence
+ */
+typedef struct lcb_DURSET_st {
+    lcb_MULTICMD_CTX mctx; /**< Base class returned to user for scheduling */
+    lcb_DURABILITYOPTSv0 opts; /**< Sanitized user options */
+    LCB_SSOBUF_DECLARE(lcb_DURITEM) entries_;
+    unsigned nremaining; /**< Number of entries remaining to poll for */
+    int waiting; /**< Set if currently awaiting an observe callback */
+    unsigned refcnt; /**< Reference count */
+    unsigned next_state; /**< Internal state */
+    lcb_error_t lasterr;
+    int is_durstore; /** Whether the callback should be DURSTORE */
+    lcb_string kvbufs; /**< Backing storage for key buffers */
+    const void *cookie; /**< User cookie */
+    hrtime_t ns_timeout; /**< Timestamp of next timeout */
+    void *timer;
+    lcb_t instance;
+    void *impldata;
+} lcb_DURSET;
+
+typedef struct lcbdur_PROCS_st {
+    lcb_error_t (*poll)(lcb_DURSET *dset);
+    lcb_error_t (*ent_add)(lcb_DURSET*,lcb_DURITEM*,const lcb_CMDENDURE*);
+    lcb_error_t (*schedule)(lcb_DURSET*);
+    void (*clean)(lcb_DURSET*);
+} lcbdur_PROCS;
+
+void
+lcbdur_cas_update(lcb_t instance, lcb_DURSET *dset, lcb_error_t err,
+    const lcb_RESPOBSERVE *resp);
+void
+lcbdur_update_seqno(lcb_t instance, lcb_DURSET *dset,
+    const lcb_RESPOBSEQNO *resp);
+
+/** Indicate that this durability command context is for an original storage op */
+void
+lcbdurctx_set_durstore(lcb_MULTICMD_CTX *ctx, int enabled);
+
+lcb_MULTICMD_CTX *
+lcb_observe_ctx_dur_new(lcb_t instance);
+
+#ifdef LCBDUR_PRIV_SYMS
+
+extern lcbdur_PROCS lcbdur_cas_procs;
+extern lcbdur_PROCS lcbdur_seqno_procs;
+
+#define RESFLD(e, f) (e)->result.f
+#define ENT_CAS(e) (e)->request.options.cas
+#define DSET_OPTFLD(ds, opt) (ds)->opts.opt
+#define DSET_COUNT(ds) (ds)->entries_.count
+#define DSET_ENTRIES(ds) LCB_SSOBUF_ARRAY(&(ds)->entries_, lcb_DURITEM)
+#define DSET_PROCS(ds) ((ds)->opts.pollopts == LCB_DURABILITY_MODE_CAS \
+    ? (&lcbdur_cas_procs) : (&lcbdur_seqno_procs))
+#define ENT_NUMINFO(ent) 4
+
+/**
+ * Returns true if the entry is complete, false otherwise. This only assumes
+ * successful entries.
+ */
+int lcbdur_ent_check_done(lcb_DURITEM *ent);
+
+/**
+ * Set the logical state of the entry to done, and invoke the callback.
+ * It is safe to call this multiple times
+ */
+void lcbdur_ent_finish(lcb_DURITEM *ent);
+
+/**
+ * Called when the last (primitive) OBSERVE response is received for the entry.
+ */
+void lcbdur_reqs_done(lcb_DURSET *dset);
+
+/**
+ * Updates the state of the given entry and synchronizes it with the
+ * current server list.
+ *
+ * Specifically this function will return a list of
+ * servers which still need to be contacted, and will increment internal
+ * counters on behalf of those (still active) servers which the item has
+ * already been replicated to (and persisted to, if requested).
+ *
+ * This will invalidate any cached information of the cluster configuration
+ * in respect to this item has changed -- this includes things like servers
+ * moving indices or being recreated entirely.
+ *
+ * This function should be called during poll().
+ * @param item The item to update
+ * @param[out] ixarray An array of server indices which should be queried
+ * @param[out] nitems the number of effective entries in the array.
+ */
+void
+lcbdur_prepare_item(lcb_DURITEM *item, lcb_U16 *ixarray, size_t *nitems);
+
+#define LCBDUR_UPDATE_PERSISTED 1
+#define LCBDUR_UPDATE_REPLICATED 2
+/**
+ * Update an item's status.
+ * @param item The item to update
+ * @param flags OR'd set of UPDATE_PERSISTED and UPDATE_REPLICATED
+ * @param ix The server index
+ */
+void
+lcbdur_update_item(lcb_DURITEM *item, int flags, int ix);
+
+lcbdur_SERVINFO *
+lcbdur_ent_getinfo(lcb_DURITEM *item, int srvix);
+
+/**
+ * Schedules us to be notified with the given state within a particular amount
+ * of time. This is used both for the timeout and for the interval
+ */
+void lcbdur_switch_state(lcb_DURSET *dset, unsigned int state);
+#define lcbdur_ref(dset) (dset)->refcnt++;
+void lcbdur_unref(lcb_DURSET *dset);
+
+#endif /* PRIV_SYMS */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,409 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-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 "trace.h"
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_get3(lcb_t instance, const void *cookie, const lcb_CMDGET *cmd)
+{
+    mc_PIPELINE *pl;
+    mc_PACKET *pkt;
+    mc_REQDATA *rdata;
+    mc_CMDQUEUE *q = &instance->cmdq;
+    lcb_error_t err;
+    lcb_uint8_t extlen = 0;
+    lcb_uint8_t opcode = PROTOCOL_BINARY_CMD_GET;
+    protocol_binary_request_gat gcmd;
+    protocol_binary_request_header *hdr = &gcmd.message.header;
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+    if (cmd->cas) {
+        return LCB_OPTIONS_CONFLICT;
+    }
+
+    if (cmd->lock) {
+        extlen = 4;
+        opcode = PROTOCOL_BINARY_CMD_GET_LOCKED;
+    } else if (cmd->exptime || (cmd->cmdflags & LCB_CMDGET_F_CLEAREXP)) {
+        extlen = 4;
+        opcode = PROTOCOL_BINARY_CMD_GAT;
+    }
+
+    err = mcreq_basic_packet(q, (const lcb_CMDBASE *)cmd, hdr, extlen, &pkt, &pl,
+        MCREQ_BASICPACKET_F_FALLBACKOK);
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    rdata = &pkt->u_rdata.reqdata;
+    rdata->cookie = cookie;
+    rdata->start = gethrtime();
+
+    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    hdr->request.opcode = opcode;
+    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr->request.bodylen = htonl(extlen + ntohs(hdr->request.keylen));
+    hdr->request.opaque = pkt->opaque;
+    hdr->request.cas = 0;
+
+    if (extlen) {
+        gcmd.message.body.expiration = htonl(cmd->exptime);
+    }
+
+    if (cmd->cmdflags & LCB_CMD_F_INTERNAL_CALLBACK) {
+        pkt->flags |= MCREQ_F_PRIVCALLBACK;
+    }
+
+    memcpy(SPAN_BUFFER(&pkt->kh_span), gcmd.bytes, MCREQ_PKT_BASESIZE + extlen);
+    LCB_SCHED_ADD(instance, pl, pkt);
+    TRACE_GET_BEGIN(hdr, cmd);
+
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_get(lcb_t instance,
+                    const void *command_cookie,
+                    lcb_size_t num,
+                    const lcb_get_cmd_t *const *items)
+{
+    unsigned ii;
+    lcb_sched_enter(instance);
+
+    for (ii = 0; ii < num; ii++) {
+        const lcb_get_cmd_t *src = items[ii];
+        lcb_CMDGET dst;
+        lcb_error_t err;
+
+        memset(&dst, 0, sizeof(dst));
+        dst.key.contig.bytes = src->v.v0.key;
+        dst.key.contig.nbytes = src->v.v0.nkey;
+        dst._hashkey.contig.bytes = src->v.v0.hashkey;
+        dst._hashkey.contig.nbytes = src->v.v0.nhashkey;
+        dst.lock = src->v.v0.lock;
+        dst.exptime = src->v.v0.exptime;
+
+        err = lcb_get3(instance, command_cookie, &dst);
+        if (err != LCB_SUCCESS) {
+            lcb_sched_fail(instance);
+            return err;
+        }
+    }
+    lcb_sched_leave(instance);
+    SYNCMODE_INTERCEPT(instance)
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_unlock3(lcb_t instance, const void *cookie, const lcb_CMDUNLOCK *cmd)
+{
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    mc_PIPELINE *pl;
+    mc_PACKET *pkt;
+    mc_REQDATA *rd;
+    lcb_error_t err;
+    protocol_binary_request_header hdr;
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+
+    err = mcreq_basic_packet(cq, cmd, &hdr, 0, &pkt, &pl,
+        MCREQ_BASICPACKET_F_FALLBACKOK);
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    rd = &pkt->u_rdata.reqdata;
+    rd->cookie = cookie;
+    rd->start = gethrtime();
+
+    hdr.request.magic = PROTOCOL_BINARY_REQ;
+    hdr.request.opcode = PROTOCOL_BINARY_CMD_UNLOCK_KEY;
+    hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr.request.bodylen = htonl((lcb_uint32_t)ntohs(hdr.request.keylen));
+    hdr.request.opaque = pkt->opaque;
+    hdr.request.cas = lcb_htonll(cmd->cas);
+
+    memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
+    TRACE_UNLOCK_BEGIN(&hdr, cmd);
+    LCB_SCHED_ADD(instance, pl, pkt);
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_unlock(lcb_t instance, const void *cookie, lcb_size_t num,
+           const lcb_unlock_cmd_t * const * items)
+{
+    unsigned ii;
+    lcb_error_t err = LCB_SUCCESS;
+
+    lcb_sched_enter(instance);
+    for (ii = 0; ii < num; ii++) {
+        const lcb_unlock_cmd_t *src = items[ii];
+        lcb_CMDUNLOCK dst;
+        memset(&dst, 0, sizeof(dst));
+        dst.key.contig.bytes = src->v.v0.key;
+        dst.key.contig.nbytes = src->v.v0.nkey;
+        dst._hashkey.contig.bytes = src->v.v0.hashkey;
+        dst._hashkey.contig.nbytes = src->v.v0.nhashkey;
+        dst.cas = src->v.v0.cas;
+        err = lcb_unlock3(instance, cookie, &dst);
+        if (err != LCB_SUCCESS) {
+            break;
+        }
+    }
+    if (err != LCB_SUCCESS) {
+        lcb_sched_fail(instance);
+        return err;
+    } else {
+        lcb_sched_leave(instance);
+        SYNCMODE_INTERCEPT(instance)
+    }
+}
+
+typedef struct {
+    mc_REQDATAEX base;
+    unsigned r_cur;
+    unsigned r_max;
+    int remaining;
+    int vbucket;
+    lcb_replica_t strategy;
+    lcb_t instance;
+} rget_cookie;
+
+static void rget_dtor(mc_PACKET *pkt) {
+    rget_cookie *rck = (rget_cookie *)pkt->u_rdata.exdata;
+    if (! --rck->remaining) {
+        free(rck);
+    }
+}
+
+static void
+rget_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t err, const void *arg)
+{
+    rget_cookie *rck = (rget_cookie *)pkt->u_rdata.exdata;
+    lcb_RESPGET *resp = (void *)arg;
+    lcb_RESPCALLBACK callback;
+    lcb_t instance = rck->instance;
+
+    callback = lcb_find_callback(instance, LCB_CALLBACK_GETREPLICA);
+
+    /** Figure out what the strategy is.. */
+    if (rck->strategy == LCB_REPLICA_SELECT || rck->strategy == LCB_REPLICA_ALL) {
+        /** Simplest */
+        if (rck->strategy == LCB_REPLICA_SELECT || rck->remaining == 1) {
+            resp->rflags |= LCB_RESP_F_FINAL;
+        }
+        callback(instance, LCB_CALLBACK_GETREPLICA, (const lcb_RESPBASE *)resp);
+    } else {
+        mc_CMDQUEUE *cq = &instance->cmdq;
+        mc_PIPELINE *nextpl = NULL;
+
+        /** FIRST */
+        do {
+            int nextix;
+            rck->r_cur++;
+            nextix = lcbvb_vbreplica(cq->config, rck->vbucket, rck->r_cur);
+            if (nextix > -1 && nextix < (int)cq->npipelines) {
+                /* have a valid next index? */
+                nextpl = cq->pipelines[nextix];
+                break;
+            }
+        } while (rck->r_cur < rck->r_max);
+
+        if (err == LCB_SUCCESS || rck->r_cur == rck->r_max || nextpl == NULL) {
+            resp->rflags |= LCB_RESP_F_FINAL;
+            callback(instance, LCB_CALLBACK_GETREPLICA, (lcb_RESPBASE *)resp);
+            /* refcount=1 . Free this now */
+            rck->remaining = 1;
+        } else if (err != LCB_SUCCESS) {
+            mc_PACKET *newpkt = mcreq_renew_packet(pkt);
+            newpkt->flags &= ~MCREQ_STATE_FLAGS;
+            mcreq_sched_add(nextpl, newpkt);
+            /* Use this, rather than lcb_sched_leave(), because this is being
+             * invoked internally by the library. */
+            mcreq_sched_leave(cq, 1);
+            /* wait */
+            rck->remaining = 2;
+        }
+    }
+
+    if (!--rck->remaining) {
+        free(rck);
+    }
+    (void)pl;
+}
+
+static mc_REQDATAPROCS rget_procs = {
+        rget_callback,
+        rget_dtor
+};
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
+{
+    /**
+     * Because we need to direct these commands to specific servers, we can't
+     * just use the 'basic_packet()' function.
+     */
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    int vbid, ixtmp;
+    protocol_binary_request_header req;
+    unsigned r0, r1 = 0;
+    rget_cookie *rck = NULL;
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+    if (!cq->config) {
+        return LCB_CLIENT_ETMPFAIL;
+    }
+    if (!LCBT_NREPLICAS(instance)) {
+        return LCB_NO_MATCHING_SERVER;
+    }
+
+    mcreq_map_key(cq, &cmd->key, &cmd->_hashkey, MCREQ_PKT_BASESIZE,
+        &vbid, &ixtmp);
+
+    /* The following blocks will also validate that the entire index range is
+     * valid. This is in order to ensure that we don't allocate the cookie
+     * if there aren't enough replicas online to satisfy the requirements */
+
+    if (cmd->strategy == LCB_REPLICA_SELECT) {
+        r0 = r1 = cmd->index;
+        if ((ixtmp = lcbvb_vbreplica(cq->config, vbid, r0)) < 0) {
+            return LCB_NO_MATCHING_SERVER;
+        }
+
+    } else if (cmd->strategy == LCB_REPLICA_ALL) {
+        unsigned ii;
+        r0 = 0;
+        r1 = LCBT_NREPLICAS(instance);
+        /* Make sure they're all online */
+        for (ii = 0; ii < LCBT_NREPLICAS(instance); ii++) {
+            if ((ixtmp = lcbvb_vbreplica(cq->config, vbid, ii)) < 0) {
+                return LCB_NO_MATCHING_SERVER;
+            }
+        }
+    } else {
+        for (r0 = 0; r0 < LCBT_NREPLICAS(instance); r0++) {
+            if ((ixtmp = lcbvb_vbreplica(cq->config, vbid, r0)) > -1) {
+                r1 = r0;
+                break;
+            }
+        }
+        if (r0 == LCBT_NREPLICAS(instance)) {
+            return LCB_NO_MATCHING_SERVER;
+        }
+    }
+
+    if (r1 < r0 || r1 >= cq->npipelines) {
+        return LCB_NO_MATCHING_SERVER;
+    }
+
+    /* Initialize the cookie */
+    rck = calloc(1, sizeof(*rck));
+    rck->base.cookie = cookie;
+    rck->base.start = gethrtime();
+    rck->base.procs = &rget_procs;
+    rck->strategy = cmd->strategy;
+    rck->r_cur = r0;
+    rck->r_max = LCBT_NREPLICAS(instance);
+    rck->instance = instance;
+    rck->vbucket = vbid;
+
+    /* Initialize the packet */
+    req.request.magic = PROTOCOL_BINARY_REQ;
+    req.request.opcode = PROTOCOL_BINARY_CMD_GET_REPLICA;
+    req.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    req.request.vbucket = htons((lcb_uint16_t)vbid);
+    req.request.cas = 0;
+    req.request.extlen = 0;
+    req.request.keylen = htons((lcb_uint16_t)cmd->key.contig.nbytes);
+    req.request.bodylen = htonl((lcb_uint32_t)cmd->key.contig.nbytes);
+
+    do {
+        int curix;
+        mc_PIPELINE *pl;
+        mc_PACKET *pkt;
+
+        curix = lcbvb_vbreplica(cq->config, vbid, r0);
+        /* XXX: this is always expected to be in range. For the FIRST mode
+         * it will seek to the first valid index (checked above), and for the
+         * ALL mode, it will fail if not all replicas are already online
+         * (also checked above) */
+        pl = cq->pipelines[curix];
+        pkt = mcreq_allocate_packet(pl);
+        if (!pkt) {
+            return LCB_CLIENT_ENOMEM;
+        }
+
+        pkt->u_rdata.exdata = &rck->base;
+        pkt->flags |= MCREQ_F_REQEXT;
+
+        mcreq_reserve_key(pl, pkt, sizeof(req.bytes), &cmd->key);
+
+        req.request.opaque = pkt->opaque;
+        rck->remaining++;
+        mcreq_write_hdr(pkt, &req);
+        mcreq_sched_add(pl, pkt);
+    } while (++r0 < r1);
+
+    MAYBE_SCHEDLEAVE(instance);
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_get_replica(lcb_t instance, const void *cookie, lcb_size_t num,
+                const lcb_get_replica_cmd_t * const * items)
+{
+    unsigned ii;
+    lcb_error_t err = LCB_SUCCESS;
+
+    lcb_sched_enter(instance);
+    for (ii = 0; ii < num; ii++) {
+        const lcb_get_replica_cmd_t *src = items[ii];
+        lcb_CMDGETREPLICA dst;
+        memset(&dst, 0, sizeof(dst));
+        dst.key.contig.bytes = src->v.v1.key;
+        dst.key.contig.nbytes = src->v.v1.nkey;
+        dst._hashkey.contig.bytes = src->v.v1.hashkey;
+        dst._hashkey.contig.nbytes = src->v.v1.nhashkey;
+        dst.strategy = src->v.v1.strategy;
+        dst.index = src->v.v1.index;
+        err = lcb_rget3(instance, cookie, &dst);
+        if (err != LCB_SUCCESS) {
+            break;
+        }
+    }
+
+    if (err == LCB_SUCCESS) {
+        lcb_sched_leave(instance);
+        SYNCMODE_INTERCEPT(instance)
+    } else {
+        lcb_sched_fail(instance);
+        return err;
+    }
+}