libcouchbase 0.3.3 → 1.0.0

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

@@ -323,16 +323,7 @@ lcb_durability_validate(lcb_t instance,
 
 }
 
-static lcb_error_t
-dset_ctx_add(lcb_MULTICMD_CTX *mctx, const lcb_CMDBASE *cmd)
-{
-    return static_cast<Durset*>(mctx)->mctx_add(cmd);
-}
-
-lcb_error_t
-Durset::mctx_add(const lcb_CMDBASE *cmd)
-{
-
+lcb_error_t Durset::MCTX_addcmd(const lcb_CMDBASE *cmd) {
     if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
         return LCB_EMPTY_KEY;
     }
@@ -357,14 +348,8 @@ Durset::mctx_add(const lcb_CMDBASE *cmd)
     return after_add(ent, reinterpret_cast<const lcb_CMDENDURE*>(cmd));
 }
 
-static lcb_error_t
-dset_ctx_schedule(lcb_MULTICMD_CTX *mctx, const void *cookie)
-{
-    return static_cast<Durset*>(mctx)->mctx_schedule(cookie);
-}
-
 lcb_error_t
-Durset::mctx_schedule(const void *cookie_) {
+Durset::MCTX_done(const void *cookie_) {
     lcb_error_t err;
     const char *kptr = kvbufs.c_str();
 
@@ -395,10 +380,8 @@ Durset::mctx_schedule(const void *cookie_) {
     return LCB_SUCCESS;
 }
 
-static void
-dset_ctx_fail(lcb_MULTICMD_CTX *mctx)
-{
-    delete static_cast<Durset*>(mctx);
+void Durset::MCTX_fail() {
+    delete this;
 }
 
 void lcbdurctx_set_durstore(lcb_MULTICMD_CTX *mctx, int enabled)
@@ -436,14 +419,11 @@ get_poll_meth(lcb_t instance, const lcb_durability_opts_t *options)
 }
 
 Durset::Durset(lcb_t instance_, const lcb_durability_opts_t *options)
-    : nremaining(0), waiting(0), refcnt(0), next_state(STATE_OBSPOLL),
+    : MultiCmdContext(),
+      nremaining(0), waiting(0), refcnt(0), next_state(STATE_OBSPOLL),
       lasterr(LCB_SUCCESS), is_durstore(false), cookie(NULL),
       ns_timeout(0), timer(NULL), instance(instance_)
 {
-    lcb_MULTICMD_CTX::addcmd = dset_ctx_add;
-    lcb_MULTICMD_CTX::done = dset_ctx_schedule;
-    lcb_MULTICMD_CTX::fail = dset_ctx_fail;
-
     const lcb_DURABILITYOPTSv0 *opts_in = &options->v.v0;
 
     std::memset(&opts, 0, sizeof opts);

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

@@ -19,6 +19,8 @@
 #define LCB_DURABILITY_INTERNAL_H
 
 #ifdef __cplusplus
+#include "mctx-helper.h"
+
 extern "C" {
 #endif
 
@@ -191,7 +193,7 @@ struct Item : public CallbackCookie {
  * A collection encompassing one or more entries which are to be checked for
  * persistence
  */
-struct Durset : public lcb_MULTICMD_CTX {
+struct Durset : public MultiCmdContext {
     /**
      * Call this when the polling method (poll_impl()) has completed. This will
      * trigger a new poll after the interval.
@@ -248,8 +250,9 @@ struct Durset : public lcb_MULTICMD_CTX {
     Durset(lcb_t instance, const lcb_durability_opts_t* options);
 
     // Implementation for MULTICMD_CTX
-    inline lcb_error_t mctx_schedule(const void *cookie);
-    inline lcb_error_t mctx_add(const lcb_CMDBASE *cmd);
+    lcb_error_t MCTX_done(const void *cookie);
+    lcb_error_t MCTX_addcmd(const lcb_CMDBASE *cmd);
+    void MCTX_fail();
 
     /**
      * This function calls poll_impl(). The implementation should then call

data/ext/libcouchbase/src/operations/{get.c → get.cc}

@@ -181,28 +181,31 @@ lcb_unlock(lcb_t instance, const void *cookie, lcb_size_t num,
     }
 }
 
-typedef struct {
-    mc_REQDATAEX base;
+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;
-} rget_cookie;
+};
 
 static void rget_dtor(mc_PACKET *pkt) {
-    rget_cookie *rck = (rget_cookie *)pkt->u_rdata.exdata;
-    if (! --rck->remaining) {
-        free(rck);
-    }
+    static_cast<RGetCookie*>(pkt->u_rdata.exdata)->decref();
 }
 
 static void
-rget_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t err, const void *arg)
+rget_callback(mc_PIPELINE *, mc_PACKET *pkt, lcb_error_t err, const void *arg)
 {
-    rget_cookie *rck = (rget_cookie *)pkt->u_rdata.exdata;
-    lcb_RESPGET *resp = (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;
 
@@ -247,11 +250,7 @@ rget_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t err, const void *arg)
             rck->remaining = 2;
         }
     }
-
-    if (!--rck->remaining) {
-        free(rck);
-    }
-    (void)pl;
+    rck->decref();
 }
 
 static mc_REQDATAPROCS rget_procs = {
@@ -259,6 +258,13 @@ static mc_REQDATAPROCS rget_procs = {
         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)
@@ -271,7 +277,6 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
     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;
@@ -323,15 +328,7 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
     }
 
     /* 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;
+    RGetCookie *rck = new RGetCookie(cookie, instance, cmd->strategy, vbid);
 
     /* Initialize the packet */
     req.request.magic = PROTOCOL_BINARY_REQ;
@@ -343,6 +340,7 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
     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;
@@ -359,7 +357,7 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
             return LCB_CLIENT_ENOMEM;
         }
 
-        pkt->u_rdata.exdata = &rck->base;
+        pkt->u_rdata.exdata = rck;
         pkt->flags |= MCREQ_F_REQEXT;
 
         mcreq_reserve_key(pl, pkt, sizeof(req.bytes), &cmd->key);

data/ext/libcouchbase/src/operations/{observe.c → observe.cc}

@@ -16,23 +16,28 @@
  */
 
 #include "internal.h"
-#include "simplestring.h"
 #include "durability_internal.h"
 #include "trace.h"
+#include "mctx-helper.h"
 
-typedef struct {
-    mc_REQDATAEX base;
-    lcb_MULTICMD_CTX mctx;
-    lcb_t instance;
+struct ObserveCtx : mc_REQDATAEX, lcb::MultiCmdContext {
+    void clear_requests() { requests.clear(); }
+    ObserveCtx(lcb_t instance_);
+
+    // Overrides
+    lcb_error_t MCTX_addcmd(const lcb_CMDBASE*);
+    lcb_error_t MCTX_done(const void *);
+    void MCTX_fail();
 
+    lcb_t instance;
     size_t remaining;
     unsigned oflags;
 
+    typedef std::vector<uint8_t> ServerBuf;
     /* requests array contains one buffer per server. nrequest essentially
      * says how many elements (and thus how many servers) */
-    size_t nrequests;
-    lcb_string requests[1];
-} OBSERVECTX;
+    std::vector<ServerBuf> requests;
+};
 
 typedef enum {
     F_DURABILITY = 0x01,
@@ -40,12 +45,20 @@ typedef enum {
     F_SCHEDFAILED = 0x04
 } obs_flags;
 
+// TODO: Move this to a common file
+template <typename ContainerType, typename ValueType>
+void add_to_buf(ContainerType& c, ValueType v) {
+    typename ContainerType::value_type *p =
+            reinterpret_cast<typename ContainerType::value_type*>(&v);
+    c.insert(c.end(), p, p + sizeof(ValueType));
+}
+
 static void
 handle_observe_callback(mc_PIPELINE *pl,
     mc_PACKET *pkt, lcb_error_t err, const void *arg)
 {
-    OBSERVECTX *oc = (void *)pkt->u_rdata.exdata;
-    lcb_RESPOBSERVE *resp = (void *)arg;
+    ObserveCtx *oc = static_cast<ObserveCtx*>(pkt->u_rdata.exdata);
+    lcb_RESPOBSERVE *resp = reinterpret_cast<lcb_RESPOBSERVE*>(const_cast<void*>(arg));
     lcb_t instance = oc->instance;
 
     (void)pl;
@@ -68,7 +81,7 @@ handle_observe_callback(mc_PIPELINE *pl,
             memset(&cur, 0, sizeof(cur));
             cur.key = ptr;
             cur.nkey = nkey;
-            cur.cookie = (void *)oc->base.cookie;
+            cur.cookie = (void *)oc->cookie;
             cur.rc = err;
             handle_observe_callback(NULL, pkt, err, &cur);
             ptr += nkey;
@@ -78,7 +91,7 @@ handle_observe_callback(mc_PIPELINE *pl,
         return;
     }
 
-    resp->cookie = (void *)oc->base.cookie;
+    resp->cookie = (void *)oc->cookie;
     resp->rc = err;
     if (oc->oflags & F_DURABILITY) {
         resp->ttp = pl ? pl->index : -1;
@@ -101,36 +114,23 @@ handle_observe_callback(mc_PIPELINE *pl,
         resp2.rflags = LCB_RESP_F_CLIENTGEN|LCB_RESP_F_FINAL;
         oc->oflags |= F_DESTROY;
         handle_observe_callback(NULL, pkt, err, &resp2);
-        free(oc);
+        delete oc;
     }
 }
 
 static void
 handle_schedfail(mc_PACKET *pkt)
 {
-    OBSERVECTX *oc = (void *)pkt->u_rdata.exdata;
+    ObserveCtx *oc = static_cast<ObserveCtx*>(pkt->u_rdata.exdata);
     oc->oflags |= F_SCHEDFAILED;
     handle_observe_callback(NULL, pkt, LCB_SCHEDFAIL_INTERNAL, NULL);
 }
 
-static void destroy_requests(OBSERVECTX *reqs)
-{
-    size_t ii;
-    for (ii = 0; ii < reqs->nrequests; ii++) {
-        lcb_string_release(reqs->requests + ii);
-    }
-}
-
-#define CTX_FROM_MULTI(mcmd) (void *) ((((char *) (mcmd))) - offsetof(OBSERVECTX, mctx))
-
-static lcb_error_t
-obs_ctxadd(lcb_MULTICMD_CTX *mctx, const lcb_CMDBASE *cmdbase)
+lcb_error_t ObserveCtx::MCTX_addcmd(const lcb_CMDBASE *cmdbase)
 {
     int vbid, srvix_dummy;
     unsigned ii;
     const lcb_CMDOBSERVE *cmd = (const lcb_CMDOBSERVE *)cmdbase;
-    OBSERVECTX *ctx = CTX_FROM_MULTI(mctx);
-    lcb_t instance = ctx->instance;
     mc_CMDQUEUE *cq = &instance->cmdq;
     lcb_U16 servers_s[4];
     const lcb_U16 *servers;
@@ -178,23 +178,18 @@ obs_ctxadd(lcb_MULTICMD_CTX *mctx, const lcb_CMDBASE *cmdbase)
     }
 
     for (ii = 0; ii < nservers; ii++) {
-        lcb_string *rr;
-        lcb_U16 vb16, klen16;
         lcb_U16 ix = servers[ii];
 
-        lcb_assert(ix < ctx->nrequests);
-        rr = ctx->requests + ix;
-        if (0 != lcb_string_reserve(rr, 4 + cmd->key.contig.nbytes)) {
-            return LCB_CLIENT_ENOMEM;
-        }
-
-        vb16 = htons((lcb_U16)vbid);
-        klen16 = htons((lcb_U16)cmd->key.contig.nbytes);
-        lcb_string_append(rr, &vb16, sizeof vb16);
-        lcb_string_append(rr, &klen16, sizeof klen16);
-        lcb_string_append(rr, cmd->key.contig.bytes, cmd->key.contig.nbytes);
+        lcb_assert(ix < requests.size());
 
-        ctx->remaining++;
+        ServerBuf& rr = requests[ix];
+        add_to_buf(rr, uint16_t(htons(vbid)));
+        add_to_buf(rr, uint16_t(htons(cmd->key.contig.nbytes)));
+        rr.insert(rr.end(),
+            reinterpret_cast<const uint8_t*>(cmd->key.contig.bytes),
+            reinterpret_cast<const uint8_t*>(cmd->key.contig.bytes) +
+            cmd->key.contig.nbytes);
+        remaining++;
     }
     return LCB_SUCCESS;
 }
@@ -204,21 +199,19 @@ static mc_REQDATAPROCS obs_procs = {
         handle_schedfail
 };
 
-static lcb_error_t
-obs_ctxdone(lcb_MULTICMD_CTX *mctx, const void *cookie)
+lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
 {
     unsigned ii;
-    OBSERVECTX *ctx = CTX_FROM_MULTI(mctx);
-    mc_CMDQUEUE *cq = &ctx->instance->cmdq;
+    mc_CMDQUEUE *cq = &instance->cmdq;
 
-    for (ii = 0; ii < ctx->nrequests; ii++) {
+    for (ii = 0; ii < requests.size(); ii++) {
         protocol_binary_request_header hdr;
         mc_PACKET *pkt;
         mc_PIPELINE *pipeline;
-        lcb_string *rr = ctx->requests + ii;
+        ServerBuf& rr = requests[ii];
         pipeline = cq->pipelines[ii];
 
-        if (!rr->nused) {
+        if (rr.empty()) {
             continue;
         }
 
@@ -226,7 +219,7 @@ obs_ctxdone(lcb_MULTICMD_CTX *mctx, const void *cookie)
         lcb_assert(pkt);
 
         mcreq_reserve_header(pipeline, pkt, MCREQ_PKT_BASESIZE);
-        mcreq_reserve_value2(pipeline, pkt, rr->nused);
+        mcreq_reserve_value2(pipeline, pkt, rr.size());
 
         hdr.request.magic = PROTOCOL_BINARY_REQ;
         hdr.request.opcode = PROTOCOL_BINARY_CMD_OBSERVE;
@@ -236,70 +229,52 @@ obs_ctxdone(lcb_MULTICMD_CTX *mctx, const void *cookie)
         hdr.request.vbucket = 0;
         hdr.request.extlen = 0;
         hdr.request.opaque = pkt->opaque;
-        hdr.request.bodylen = htonl((lcb_uint32_t)rr->nused);
+        hdr.request.bodylen = htonl((lcb_uint32_t)rr.size());
 
         memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
-        memcpy(SPAN_BUFFER(&pkt->u_value.single), rr->base, rr->nused);
+        memcpy(SPAN_BUFFER(&pkt->u_value.single), &rr[0], rr.size());
 
         pkt->flags |= MCREQ_F_REQEXT;
-        pkt->u_rdata.exdata = (mc_REQDATAEX *)ctx;
+        pkt->u_rdata.exdata = this;
         mcreq_sched_add(pipeline, pkt);
         TRACE_OBSERVE_BEGIN(&hdr, SPAN_BUFFER(&pkt->u_value.single));
     }
 
-    destroy_requests(ctx);
-    ctx->base.start = gethrtime();
-    ctx->base.cookie = cookie;
-    ctx->base.procs = &obs_procs;
+    start = gethrtime();
+    cookie = cookie_;
 
-    if (ctx->nrequests == 0 || ctx->remaining == 0) {
-        free(ctx);
+    if (requests.size() == 0 || remaining == 0) {
+        delete this;
         return LCB_EINVAL;
     } else {
-        MAYBE_SCHEDLEAVE(ctx->instance);
+        MAYBE_SCHEDLEAVE(instance);
         return LCB_SUCCESS;
     }
 }
 
-static void
-obs_ctxfail(lcb_MULTICMD_CTX *mctx)
-{
-    OBSERVECTX *ctx = CTX_FROM_MULTI(mctx);
-    destroy_requests(ctx);
-    free(ctx);
+void ObserveCtx::MCTX_fail() {
+    delete this;
 }
 
-LIBCOUCHBASE_API
-lcb_MULTICMD_CTX *
-lcb_observe3_ctxnew(lcb_t instance)
-{
-    OBSERVECTX *ctx;
-    size_t ii, n_extra = LCBT_NSERVERS(instance)-1;
-    ctx = calloc(1, sizeof(*ctx) + sizeof(ctx->requests) * n_extra);
-    ctx->instance = instance;
-    ctx->nrequests = n_extra + 1;
-    ctx->mctx.addcmd = obs_ctxadd;
-    ctx->mctx.done = obs_ctxdone;
-    ctx->mctx.fail = obs_ctxfail;
-
-    /* note this block doesn't do anything not done with calloc, but makes for
-     * easier reading/tracking */
-    for (ii = 0; ii < ctx->nrequests; ii++) {
-        lcb_string_init(ctx->requests + ii);
-    }
+ObserveCtx::ObserveCtx(lcb_t instance_)
+    : mc_REQDATAEX(NULL, obs_procs, 0),
+      instance(instance_),
+      remaining(0),
+      oflags(0) {
+
+    requests.resize(LCBT_NSERVERS(instance));
+}
 
-    return &ctx->mctx;
+LIBCOUCHBASE_API
+lcb_MULTICMD_CTX * lcb_observe3_ctxnew(lcb_t instance) {
+    return new ObserveCtx(instance);
 }
 
 lcb_MULTICMD_CTX *
-lcb_observe_ctx_dur_new(lcb_t instance)
-{
-    lcb_MULTICMD_CTX *mctx = lcb_observe3_ctxnew(instance);
-    if (mctx) {
-        OBSERVECTX *ctx = CTX_FROM_MULTI(mctx);
-        ctx->oflags |= F_DURABILITY;
-    }
-    return mctx;
+lcb_observe_ctx_dur_new(lcb_t instance) {
+    ObserveCtx *ctx = new ObserveCtx(instance);
+    ctx->oflags |= F_DURABILITY;
+    return ctx;
 }
 
 LIBCOUCHBASE_API