libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/src/newconfig.cc

@@ -221,7 +221,7 @@ iterwipe_cb(mc_CMDQUEUE *cq, mc_PIPELINE *oldpl, mc_PACKET *oldpkt, void *)
         return MCREQ_KEEP_PACKET;
     }
 
-    lcb_log(LOGARGS((lcb_t)cq->cqdata, DEBUG), "Remapped packet %p (SEQ=%u) from " SERVER_FMT " to " SERVER_FMT,
+    lcb_log(LOGARGS((lcb_t)cq->cqdata, DEBUG), "Remapped packet %p (SEQ=%u) from "SERVER_FMT " to " SERVER_FMT,
         (void*)oldpkt, oldpkt->opaque, SERVER_ARGS((lcb::Server*)oldpl), SERVER_ARGS((lcb::Server*)newpl));
 
     /** Otherwise, copy over the packet and find the new vBucket to map to */
@@ -256,7 +256,7 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
             cur->set_new_index(newix);
             ppnew[newix] = cur;
             ppold[ii] = NULL;
-            lcb_log(LOGARGS(instance, INFO), "Reusing server " SERVER_FMT ". OldIndex=%d. NewIndex=%d", SERVER_ARGS(cur), ii, newix);
+            lcb_log(LOGARGS(instance, INFO), "Reusing server "SERVER_FMT". OldIndex=%d. NewIndex=%d", SERVER_ARGS(cur), ii, newix);
         }
     }
 
@@ -305,14 +305,14 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
     free(ppold);
 }
 
-void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config)
+void lcb_update_vbconfig(lcb_t instance, clconfig_info *config)
 {
     lcb_configuration_t change_status;
-    lcb::clconfig::ConfigInfo *old_config = instance->cur_configinfo;
+    clconfig_info *old_config = instance->cur_configinfo;
     mc_CMDQUEUE *q = &instance->cmdq;
 
     instance->cur_configinfo = config;
-    config->incref();
+    lcb_clconfig_incref(config);
     q->config = instance->cur_configinfo->vbc;
     q->cqdata = instance;
 
@@ -328,7 +328,7 @@ void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config)
         lcb_vbguess_newconfig(instance, config->vbc, instance->vbguess);
 
         replace_config(instance, old_config->vbc, config->vbc);
-        old_config->decref();
+        lcb_clconfig_decref(old_config);
         change_status = LCB_CONFIGURATION_CHANGED;
     } else {
         size_t nservers = VB_NSERVERS(config->vbc);

data/ext/libcouchbase/src/nodeinfo.cc

@@ -70,7 +70,7 @@ lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
 
     if (type & LCB_NODE_HTCONFIG) {
         if (type & LCB_NODE_CONNECTED) {
-            const lcb_host_t *host = lcb::clconfig::http_get_host(instance->confmon);
+            const lcb_host_t *host = lcb_confmon_get_rest_host(instance->confmon);
             if (host) {
                 return mk_scratch_host(instance, host);
             } else {
@@ -167,7 +167,7 @@ lcb_int32_t lcb_get_num_nodes(lcb_t instance)
 LIBCOUCHBASE_API
 const char *const *lcb_get_server_list(lcb_t instance)
 {
-    return instance->ht_nodes->get_strlist();
+    return hostlist_strents(instance->ht_nodes);
 }
 
 LIBCOUCHBASE_API

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

@@ -15,10 +15,11 @@
  */
 
 #include "internal.h"
+#include "simplestring.h"
 #include <http/http.h>
 
 static void
-flush_cb(lcb_t instance, int, const lcb_RESPBASE *rb)
+flush_cb(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
 {
     const lcb_RESPHTTP *resp = (const lcb_RESPHTTP *)rb;
     lcb_RESPCBFLUSH fresp = { 0 };
@@ -34,30 +35,37 @@ flush_cb(lcb_t instance, int, const lcb_RESPBASE *rb)
     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 *)
+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;
 
-    std::string urlpath("/pools/default/buckets/");
-    urlpath.append(LCBT_SETTING(instance, bucket));
-    urlpath.append("/controller/doFlush");
+    (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.c_str(), urlpath.size());
+    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;
     }
-    htr->set_callback(flush_cb);
+    lcb_htreq_setcb(htr, flush_cb);
     return LCB_SUCCESS;
 }

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

@@ -323,7 +323,16 @@ lcb_durability_validate(lcb_t instance,
 
 }
 
-lcb_error_t Durset::MCTX_addcmd(const lcb_CMDBASE *cmd) {
+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)
+{
+
     if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
         return LCB_EMPTY_KEY;
     }
@@ -348,8 +357,14 @@ lcb_error_t Durset::MCTX_addcmd(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_done(const void *cookie_) {
+Durset::mctx_schedule(const void *cookie_) {
     lcb_error_t err;
     const char *kptr = kvbufs.c_str();
 
@@ -380,8 +395,10 @@ Durset::MCTX_done(const void *cookie_) {
     return LCB_SUCCESS;
 }
 
-void Durset::MCTX_fail() {
-    delete this;
+static void
+dset_ctx_fail(lcb_MULTICMD_CTX *mctx)
+{
+    delete static_cast<Durset*>(mctx);
 }
 
 void lcbdurctx_set_durstore(lcb_MULTICMD_CTX *mctx, int enabled)
@@ -419,11 +436,14 @@ get_poll_meth(lcb_t instance, const lcb_durability_opts_t *options)
 }
 
 Durset::Durset(lcb_t instance_, const lcb_durability_opts_t *options)
-    : MultiCmdContext(),
-      nremaining(0), waiting(0), refcnt(0), next_state(STATE_OBSPOLL),
+    : 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,8 +19,6 @@
 #define LCB_DURABILITY_INTERNAL_H
 
 #ifdef __cplusplus
-#include "mctx-helper.h"
-
 extern "C" {
 #endif
 
@@ -193,7 +191,7 @@ struct Item : public CallbackCookie {
  * A collection encompassing one or more entries which are to be checked for
  * persistence
  */
-struct Durset : public MultiCmdContext {
+struct Durset : public lcb_MULTICMD_CTX {
     /**
      * Call this when the polling method (poll_impl()) has completed. This will
      * trigger a new poll after the interval.
@@ -250,9 +248,8 @@ struct Durset : public MultiCmdContext {
     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();
+    inline lcb_error_t mctx_schedule(const void *cookie);
+    inline lcb_error_t mctx_add(const lcb_CMDBASE *cmd);
 
     /**
      * This function calls poll_impl(). The implementation should then call

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

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

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

@@ -16,28 +16,23 @@
  */
 
 #include "internal.h"
+#include "simplestring.h"
 #include "durability_internal.h"
 #include "trace.h"
-#include "mctx-helper.h"
-
-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();
 
+typedef struct {
+    mc_REQDATAEX base;
+    lcb_MULTICMD_CTX mctx;
     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) */
-    std::vector<ServerBuf> requests;
-};
+    size_t nrequests;
+    lcb_string requests[1];
+} OBSERVECTX;
 
 typedef enum {
     F_DURABILITY = 0x01,
@@ -45,20 +40,12 @@ 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 = static_cast<ObserveCtx*>(pkt->u_rdata.exdata);
-    lcb_RESPOBSERVE *resp = reinterpret_cast<lcb_RESPOBSERVE*>(const_cast<void*>(arg));
+    OBSERVECTX *oc = (void *)pkt->u_rdata.exdata;
+    lcb_RESPOBSERVE *resp = (void *)arg;
     lcb_t instance = oc->instance;
 
     (void)pl;
@@ -81,7 +68,7 @@ handle_observe_callback(mc_PIPELINE *pl,
             memset(&cur, 0, sizeof(cur));
             cur.key = ptr;
             cur.nkey = nkey;
-            cur.cookie = (void *)oc->cookie;
+            cur.cookie = (void *)oc->base.cookie;
             cur.rc = err;
             handle_observe_callback(NULL, pkt, err, &cur);
             ptr += nkey;
@@ -91,7 +78,7 @@ handle_observe_callback(mc_PIPELINE *pl,
         return;
     }
 
-    resp->cookie = (void *)oc->cookie;
+    resp->cookie = (void *)oc->base.cookie;
     resp->rc = err;
     if (oc->oflags & F_DURABILITY) {
         resp->ttp = pl ? pl->index : -1;
@@ -114,23 +101,36 @@ 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);
-        delete oc;
+        free(oc);
     }
 }
 
 static void
 handle_schedfail(mc_PACKET *pkt)
 {
-    ObserveCtx *oc = static_cast<ObserveCtx*>(pkt->u_rdata.exdata);
+    OBSERVECTX *oc = (void *)pkt->u_rdata.exdata;
     oc->oflags |= F_SCHEDFAILED;
     handle_observe_callback(NULL, pkt, LCB_SCHEDFAIL_INTERNAL, NULL);
 }
 
-lcb_error_t ObserveCtx::MCTX_addcmd(const lcb_CMDBASE *cmdbase)
+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)
 {
     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,18 +178,23 @@ lcb_error_t ObserveCtx::MCTX_addcmd(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 < requests.size());
+        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);
 
-        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++;
+        ctx->remaining++;
     }
     return LCB_SUCCESS;
 }
@@ -199,19 +204,21 @@ static mc_REQDATAPROCS obs_procs = {
         handle_schedfail
 };
 
-lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
+static lcb_error_t
+obs_ctxdone(lcb_MULTICMD_CTX *mctx, const void *cookie)
 {
     unsigned ii;
-    mc_CMDQUEUE *cq = &instance->cmdq;
+    OBSERVECTX *ctx = CTX_FROM_MULTI(mctx);
+    mc_CMDQUEUE *cq = &ctx->instance->cmdq;
 
-    for (ii = 0; ii < requests.size(); ii++) {
+    for (ii = 0; ii < ctx->nrequests; ii++) {
         protocol_binary_request_header hdr;
         mc_PACKET *pkt;
         mc_PIPELINE *pipeline;
-        ServerBuf& rr = requests[ii];
+        lcb_string *rr = ctx->requests + ii;
         pipeline = cq->pipelines[ii];
 
-        if (rr.empty()) {
+        if (!rr->nused) {
             continue;
         }
 
@@ -219,7 +226,7 @@ lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
         lcb_assert(pkt);
 
         mcreq_reserve_header(pipeline, pkt, MCREQ_PKT_BASESIZE);
-        mcreq_reserve_value2(pipeline, pkt, rr.size());
+        mcreq_reserve_value2(pipeline, pkt, rr->nused);
 
         hdr.request.magic = PROTOCOL_BINARY_REQ;
         hdr.request.opcode = PROTOCOL_BINARY_CMD_OBSERVE;
@@ -229,52 +236,70 @@ lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
         hdr.request.vbucket = 0;
         hdr.request.extlen = 0;
         hdr.request.opaque = pkt->opaque;
-        hdr.request.bodylen = htonl((lcb_uint32_t)rr.size());
+        hdr.request.bodylen = htonl((lcb_uint32_t)rr->nused);
 
         memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
-        memcpy(SPAN_BUFFER(&pkt->u_value.single), &rr[0], rr.size());
+        memcpy(SPAN_BUFFER(&pkt->u_value.single), rr->base, rr->nused);
 
         pkt->flags |= MCREQ_F_REQEXT;
-        pkt->u_rdata.exdata = this;
+        pkt->u_rdata.exdata = (mc_REQDATAEX *)ctx;
         mcreq_sched_add(pipeline, pkt);
         TRACE_OBSERVE_BEGIN(&hdr, SPAN_BUFFER(&pkt->u_value.single));
     }
 
-    start = gethrtime();
-    cookie = cookie_;
+    destroy_requests(ctx);
+    ctx->base.start = gethrtime();
+    ctx->base.cookie = cookie;
+    ctx->base.procs = &obs_procs;
 
-    if (requests.size() == 0 || remaining == 0) {
-        delete this;
+    if (ctx->nrequests == 0 || ctx->remaining == 0) {
+        free(ctx);
         return LCB_EINVAL;
     } else {
-        MAYBE_SCHEDLEAVE(instance);
+        MAYBE_SCHEDLEAVE(ctx->instance);
         return LCB_SUCCESS;
     }
 }
 
-void ObserveCtx::MCTX_fail() {
-    delete this;
-}
-
-ObserveCtx::ObserveCtx(lcb_t instance_)
-    : mc_REQDATAEX(NULL, obs_procs, 0),
-      instance(instance_),
-      remaining(0),
-      oflags(0) {
-
-    requests.resize(LCBT_NSERVERS(instance));
+static void
+obs_ctxfail(lcb_MULTICMD_CTX *mctx)
+{
+    OBSERVECTX *ctx = CTX_FROM_MULTI(mctx);
+    destroy_requests(ctx);
+    free(ctx);
 }
 
 LIBCOUCHBASE_API
-lcb_MULTICMD_CTX * lcb_observe3_ctxnew(lcb_t instance) {
-    return new ObserveCtx(instance);
+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);
+    }
+
+    return &ctx->mctx;
 }
 
 lcb_MULTICMD_CTX *
-lcb_observe_ctx_dur_new(lcb_t instance) {
-    ObserveCtx *ctx = new ObserveCtx(instance);
-    ctx->oflags |= F_DURABILITY;
-    return 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;
 }
 
 LIBCOUCHBASE_API