mt-libcouchbase 1.4.0

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

@@ -0,0 +1,306 @@
+/* -*- 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
+
+#ifdef __cplusplus
+#include "mctx-helper.h"
+
+extern "C" {
+#endif
+
+/**
+ * @name internal durability functions
+ * These functions are used internally beyond the durability module.
+ * @{
+ */
+
+/**
+ * Called from the OBSERVE codebase to update an item's status for CAS-based
+ * observe
+ */
+void lcbdur_cas_update(lcb_t, void *dset, lcb_error_t, const lcb_RESPOBSERVE *);
+
+/**
+ * Called from the OBSERVE codebase to update an item's status for seqno-based
+ * observe
+ */
+void lcbdur_update_seqno(lcb_t, void *dset, const lcb_RESPOBSEQNO*);
+
+/** Indicate that this durability command context is for an original storage op */
+void lcbdurctx_set_durstore(lcb_MULTICMD_CTX *ctx, int enabled);
+
+void lcbdur_destroy(void *dset);
+
+/** Called from durability-cas to request an OBSERVE with a special callback */
+lcb_MULTICMD_CTX *lcb_observe_ctx_dur_new(lcb_t instance);
+
+/**@}
+ *
+ * The rest of this file is internal to the various durability operations and
+ * is not accessed by the rest of the codebase
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef LCBDUR_PRIV_SYMS
+namespace lcb {
+namespace durability {
+
+/**
+ * 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.
+ */
+struct ServerInfo {
+    const lcb::Server *server; /**< Server pointer (for comparison only) */
+    lcb_U16 persisted; /**< Exists on server */
+    lcb_U16 exists; /**< Persisted to server */
+
+    ServerInfo() : server(NULL), persisted(0), exists(0) {
+    }
+
+    void clear() {
+        server = NULL;
+        persisted = 0;
+        exists = 0;
+    }
+};
+
+struct Durset;
+
+// For use in conjunction with MCREQ_F_PRIVCALLBACK
+struct CallbackCookie {
+    lcb_RESPCALLBACK callback;
+
+    CallbackCookie() : callback(NULL) {}
+};
+
+/**Information a single entry in a durability set. Each entry contains a single
+ * key */
+struct Item : public CallbackCookie {
+    Item():
+        reqcas(0),
+        reqseqno(0),
+        uuid(0),
+        result(),
+        parent(NULL),
+        vbid(0),
+        done(0)
+    {
+    }
+
+    /**
+     * Returns true if the entry is complete, false otherwise. This only assumes
+     * successful entries.
+     */
+    bool is_all_done() const;
+
+    /**
+     * Determine if this item has been satisfied on a specific server. This
+     * function is used to determine if a probe should be sent to the server.
+     *
+     * If there are no items "tied" to the server (because they have all been
+     * completed) then we employ a bandwidth saving optimization by not sending
+     * additional probes to it.
+     *
+     * @param info Server to check against
+     * @param is_master If this server is the master for the item's vbucket
+     *
+     * @return true if the item is both persisted and replicated on the server,
+     *         OR if the item has been replicated, but replication is not
+     *         required for the item.
+     */
+    bool is_server_done(const ServerInfo& info, bool is_master) const;
+
+    /**
+     * 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[out] ixarray An array of server indices which should be queried
+     * @return the number of effective entries in the array.
+     */
+    size_t prepare(uint16_t ixarray[4]);
+
+    enum UpdateFlags {
+        NO_CHANGES = 0x00,
+        UPDATE_PERSISTED = 0x01,
+        UPDATE_REPLICATED = 0x02
+    };
+
+    /**
+     * Update an item's status.
+     * @param flags OR'd set of UPDATE_PERSISTED and UPDATE_REPLICATED
+     * @param ix The server index
+     */
+    void update(int flags, int srvix);
+
+    /**
+     * Set the logical state of the entry to done, and invoke the callback.
+     * It is safe to call this multiple times
+     */
+    void finish();
+
+    void finish(lcb_error_t err) {
+        result.rc = err;
+        finish();
+    }
+
+    lcb_RESPENDURE& res() { return result; }
+    const lcb_RESPENDURE& res() const { return result; }
+    ServerInfo* get_server_info(int index);
+
+    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 */
+    Durset *parent;
+    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 */
+    ServerInfo sinfo[4];
+};
+
+/**
+ * A collection encompassing one or more entries which are to be checked for
+ * persistence
+ */
+struct Durset : public MultiCmdContext {
+    /**
+     * Call this when the polling method (poll_impl()) has completed. This will
+     * trigger a new poll after the interval.
+     */
+    void on_poll_done();
+
+    void incref() { refcnt++; }
+
+    /**
+     * Decrement the refcount for the 'dset'. When it hits zero then the dset is
+     * freed
+     */
+    void decref() { if (!--refcnt) { delete this; } }
+
+    enum State {
+        STATE_OBSPOLL,
+        STATE_INIT,
+        STATE_TIMEOUT,
+        STATE_IGNORE
+    };
+
+    /**
+     * 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 switch_state(State state);
+
+    /**
+     * Called from mctx_schedule(). This allows implementations to do any
+     * additional bookeeping, having guaranteed that all items are now
+     * added.
+     */
+    virtual lcb_error_t prepare_schedule() {
+        return LCB_SUCCESS;
+    }
+
+    /**
+     * Called from mctx_add. Called to register any item-specific data (i.e.
+     * to associate item data with internal structures)
+     * @param itm the newly added item
+     * @param the original command, for more context
+     */
+    virtual lcb_error_t after_add(Item&, const lcb_CMDENDURE*) {
+        return LCB_SUCCESS;
+    }
+
+    /**
+     * Called to actually check for persistence/replication. This must be
+     * implemented.
+     */
+    virtual lcb_error_t poll_impl() = 0;
+
+    virtual ~Durset();
+    Durset(lcb_t instance, const lcb_durability_opts_t* options);
+
+    // Implementation for MULTICMD_CTX
+    lcb_error_t MCTX_done(const void *cookie);
+    lcb_error_t MCTX_addcmd(const lcb_CMDBASE *cmd);
+    void MCTX_fail();
+#ifdef LCB_TRACING
+    void MCTX_setspan(lcbtrace_SPAN *span);
+#endif
+
+    /**
+     * This function calls poll_impl(). The implementation should then call
+     * on_poll_done() once the polling is finished
+     */
+    inline void poll();
+
+    /** Called after timeouts and intervals. */
+    inline void tick();
+
+    static Durset* createCasDurset(lcb_t, const lcb_durability_opts_t*);
+    static Durset* createSeqnoDurset(lcb_t, const lcb_durability_opts_t*);
+
+    lcb_DURABILITYOPTSv0 opts; /**< Sanitized user options */
+    std::vector<Item> entries;
+    unsigned nremaining; /**< Number of entries remaining to poll for */
+    int waiting; /**< Set if currently awaiting an observe callback */
+    unsigned refcnt; /**< Reference count */
+    State next_state; /**< Internal state */
+    lcb_error_t lasterr;
+    bool is_durstore; /** Whether the callback should be DURSTORE */
+    std::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;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
+};
+
+} // namespace durability
+} // namespace lcb
+#endif // __cplusplus
+#endif // LCB_DURABILITY_INTERNAL_H

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

@@ -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);
+    LCBTRACE_KV_START(instance->settings, cmd, LCBTRACE_OP_GET, pkt->opaque, rdata->span);
+    TRACE_GET_BEGIN(instance, 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));
+    LCB_SCHED_ADD(instance, pl, pkt);
+    LCBTRACE_KV_START(instance->settings, cmd, LCBTRACE_OP_UNLOCK, pkt->opaque, rd->span);
+    TRACE_UNLOCK_BEGIN(instance, &hdr, cmd);
+    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)
+    }
+}
+
+struct RGetCookie : mc_REQDATAEX {
+    RGetCookie(const void *cookie, lcb_t instance, lcb_replica_t, int vb);
+    void decref() {
+        if (!--remaining) {
+            delete this;
+        }
+    }
+
+    unsigned r_cur;
+    unsigned r_max;
+    int remaining;
+    int vbucket;
+    lcb_replica_t strategy;
+    lcb_t instance;
+};
+
+static void rget_dtor(mc_PACKET *pkt) {
+    static_cast<RGetCookie*>(pkt->u_rdata.exdata)->decref();
+}
+
+static void
+rget_callback(mc_PIPELINE *, mc_PACKET *pkt, lcb_error_t err, const void *arg)
+{
+    RGetCookie *rck = static_cast<RGetCookie*>(pkt->u_rdata.exdata);
+    lcb_RESPGET *resp = reinterpret_cast<lcb_RESPGET*>(const_cast<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;
+        }
+    }
+    rck->decref();
+}
+
+static mc_REQDATAPROCS rget_procs = {
+        rget_callback,
+        rget_dtor
+};
+
+RGetCookie::RGetCookie(const void *cookie_, lcb_t instance_,
+    lcb_replica_t strategy_, int vbucket_)
+    : mc_REQDATAEX(cookie_, rget_procs, gethrtime()),
+      r_cur(0), r_max(LCBT_NREPLICAS(instance_)), remaining(0),
+      vbucket(vbucket_), strategy(strategy_), instance(instance_) {
+}
+
+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;
+
+    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 */
+    RGetCookie *rck = new RGetCookie(cookie, instance, cmd->strategy, 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);
+
+    rck->r_cur = r0;
+    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;
+        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;
+    }
+}