libcouchbase 0.0.7 → 0.0.8

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

@@ -19,8 +19,6 @@ lcb_error_t
 lcb_observe_seqno3(lcb_t instance, const void *cookie, const lcb_CMDOBSEQNO *cmd)
 {
     mc_PACKET *pkt;
-    mc_SERVER *server;
-    mc_PIPELINE *pl;
     protocol_binary_request_header hdr;
     lcb_U64 uuid;
 
@@ -28,11 +26,10 @@ lcb_observe_seqno3(lcb_t instance, const void *cookie, const lcb_CMDOBSEQNO *cmd
         return LCB_EINVAL;
     }
 
-    server = LCBT_GET_SERVER(instance, cmd->server_index);
-    pl = &server->pipeline;
-    pkt = mcreq_allocate_packet(pl);
-    mcreq_reserve_header(pl, pkt, MCREQ_PKT_BASESIZE);
-    mcreq_reserve_value2(pl, pkt, 8);
+    lcb::Server *server = instance->get_server(cmd->server_index);
+    pkt = mcreq_allocate_packet(server);
+    mcreq_reserve_header(server, pkt, MCREQ_PKT_BASESIZE);
+    mcreq_reserve_value2(server, pkt, 8);
 
     /* Set the static fields */
     MCREQ_PKT_RDATA(pkt)->cookie = cookie;
@@ -52,7 +49,7 @@ lcb_observe_seqno3(lcb_t instance, const void *cookie, const lcb_CMDOBSEQNO *cmd
 
     uuid = lcb_htonll(cmd->uuid);
     memcpy(SPAN_BUFFER(&pkt->u_value.single), &uuid, sizeof uuid);
-    LCB_SCHED_ADD(instance, pl, pkt);
+    LCB_SCHED_ADD(instance, server, pkt);
     return LCB_SUCCESS;
 }
 

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

@@ -18,20 +18,26 @@
 #include "internal.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,
@@ -39,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;
@@ -67,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;
@@ -77,12 +91,11 @@ 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;
-        lcbdur_cas_update( instance,
-            (lcb_DURSET *)MCREQ_PKT_COOKIE(pkt), err, resp);
+        lcbdur_cas_update(instance, (void*)MCREQ_PKT_COOKIE(pkt), err, resp);
 
     } else if ((oc->oflags & F_SCHEDFAILED) == 0) {
         lcb_RESPCALLBACK callback = lcb_find_callback(instance, LCB_CALLBACK_OBSERVE);
@@ -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

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

@@ -17,32 +17,44 @@
 
 #include "internal.h"
 
-typedef struct {
-    mc_REQDATAEX base;
+struct BcastCookie : mc_REQDATAEX {
     lcb_CALLBACKTYPE type;
     int remaining;
-} bcast_cookie;
+
+    BcastCookie(lcb_CALLBACKTYPE type_,
+                const mc_REQDATAPROCS* procs_, const void *cookie_)
+        : mc_REQDATAEX(cookie_, *procs_, gethrtime()),
+          type(type_), remaining(0) {
+    }
+};
 
 static void
 refcnt_dtor_common(mc_PACKET *pkt)
 {
-    bcast_cookie *ck = (bcast_cookie *)pkt->u_rdata.exdata;
+    BcastCookie *ck = static_cast<BcastCookie *>(pkt->u_rdata.exdata);
     if (!--ck->remaining) {
-        free(ck);
+        delete ck;
     }
 }
 
+static const char *
+make_hp_string(const lcb::Server& server, std::string& out) {
+    out.assign(server.get_host().host);
+    out.append(":");
+    out.append(server.get_host().port);
+    return out.c_str();
+}
+
 static void
 stats_handler(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t err, const void *arg)
 {
-    bcast_cookie *ck = (bcast_cookie *)req->u_rdata.exdata;
-    mc_SERVER *server = (mc_SERVER *)pl;
-    lcb_RESPSTATS *resp = (void *)arg;
-    char epbuf[NI_MAXHOST + NI_MAXSERV + 4];
+    BcastCookie *ck = static_cast<BcastCookie *>(req->u_rdata.exdata);
+    lcb::Server *server = static_cast<lcb::Server*>(pl);
+    lcb_RESPSTATS *resp = reinterpret_cast<lcb_RESPSTATS*>(const_cast<void*>(arg));
+
     lcb_RESPCALLBACK callback;
-    lcb_t instance = server->instance;
+    lcb_t instance = server->get_instance();
 
-    sprintf(epbuf, "%s:%s", mcserver_get_host(server), mcserver_get_port(server));
     callback = lcb_find_callback(instance, LCB_CALLBACK_STATS);
 
     if (!arg) {
@@ -53,14 +65,15 @@ stats_handler(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t err, const void *arg)
         }
 
         s_resp.rc = err;
-        s_resp.cookie = (void *)ck->base.cookie;
+        s_resp.cookie = const_cast<void *>(ck->cookie);
         s_resp.rflags = LCB_RESP_F_CLIENTGEN|LCB_RESP_F_FINAL;
         callback(instance, LCB_CALLBACK_STATS, (lcb_RESPBASE *)&s_resp);
-        free(ck);
+        delete ck;
 
     } else {
-        resp->server = epbuf;
-        resp->cookie = (void *)ck->base.cookie;
+        std::string epbuf;
+        resp->server = make_hp_string(*server, epbuf);
+        resp->cookie = const_cast<void *>(ck->cookie);
         callback(instance, LCB_CALLBACK_STATS, (lcb_RESPBASE *)resp);
         return;
     }
@@ -79,7 +92,6 @@ lcb_stats3(lcb_t instance, const void *cookie, const lcb_CMDSTATS * cmd)
     int vbid = -1;
     char ksbuf[512] = { 0 };
     mc_CMDQUEUE *cq = &instance->cmdq;
-    bcast_cookie *ckwrap = NULL;
     lcbvb_CONFIG *vbc = cq->config;
     const lcb_CONTIGBUF *kbuf_in = &cmd->key.contig;
     lcb_KEYBUF kbuf_out;
@@ -113,10 +125,8 @@ lcb_stats3(lcb_t instance, const void *cookie, const lcb_CMDSTATS * cmd)
         kbuf_out.contig = *kbuf_in;
     }
 
-    ckwrap = calloc(1, sizeof(*ckwrap));
-    ckwrap->base.cookie = cookie;
-    ckwrap->base.start = gethrtime();
-    ckwrap->base.procs = &stats_procs;
+    BcastCookie *ckwrap = new BcastCookie(LCB_CALLBACK_STATS,
+                                            &stats_procs, cookie);
 
     for (ii = 0; ii < cq->npipelines; ii++) {
         mc_PACKET *pkt;
@@ -143,7 +153,7 @@ lcb_stats3(lcb_t instance, const void *cookie, const lcb_CMDSTATS * cmd)
             mcreq_reserve_header(pl, pkt, MCREQ_PKT_BASESIZE);
         }
 
-        pkt->u_rdata.exdata = &ckwrap->base;
+        pkt->u_rdata.exdata = ckwrap;
         pkt->flags |= MCREQ_F_REQEXT;
 
         ckwrap->remaining++;
@@ -153,7 +163,7 @@ lcb_stats3(lcb_t instance, const void *cookie, const lcb_CMDSTATS * cmd)
     }
 
     if (!ii) {
-        free(ckwrap);
+        delete ckwrap;
         return LCB_NO_MATCHING_SERVER;
     }
 
@@ -165,9 +175,8 @@ static void
 handle_bcast(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err,
              const void *arg)
 {
-    mc_SERVER *server = (mc_SERVER *)pipeline;
-    char epbuf[NI_MAXHOST + NI_MAXSERV + 4];
-    bcast_cookie *ck = (bcast_cookie *)req->u_rdata.exdata;
+    lcb::Server *server = static_cast<lcb::Server*>(pipeline);
+    BcastCookie *ck = (BcastCookie *)req->u_rdata.exdata;
     lcb_RESPCALLBACK callback;
 
     union {
@@ -187,19 +196,20 @@ handle_bcast(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err,
     memset(&u_empty, 0, sizeof(u_empty));
 
     if (arg) {
-        u_resp.base = (void *)arg;
+        u_resp.base = (lcb_RESPSERVERBASE*)arg;
     } else {
         u_resp.base = &u_empty.base;
         u_resp.base->rflags = LCB_RESP_F_CLIENTGEN;
     }
 
     u_resp.base->rc = err;
-    u_resp.base->cookie = (void *)ck->base.cookie;
-    u_resp.base->server = epbuf;
-    sprintf(epbuf, "%s:%s", mcserver_get_host(server), mcserver_get_port(server));
+    u_resp.base->cookie = const_cast<void*>(ck->cookie);
+
+    std::string epbuf;
+    u_resp.base->server = make_hp_string(*server, epbuf);
 
-    callback = lcb_find_callback(server->instance, ck->type);
-    callback(server->instance, ck->type, (lcb_RESPBASE *)u_resp.base);
+    callback = lcb_find_callback(server->get_instance(), ck->type);
+    callback(server->get_instance(), ck->type, (lcb_RESPBASE *)u_resp.base);
     if (--ck->remaining) {
         return;
     }
@@ -207,9 +217,9 @@ handle_bcast(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err,
     u_empty.base.server = NULL;
     u_empty.base.rc = err;
     u_empty.base.rflags = LCB_RESP_F_CLIENTGEN|LCB_RESP_F_FINAL;
-    u_empty.base.cookie = (void *)ck->base.cookie;
-    callback(server->instance, ck->type, (lcb_RESPBASE *)&u_empty.base);
-    free(ck);
+    u_empty.base.cookie = const_cast<void*>(ck->cookie);
+    callback(server->get_instance(), ck->type, (lcb_RESPBASE *)&u_empty.base);
+    delete ck;
 }
 
 static mc_REQDATAPROCS bcast_procs = {
@@ -222,17 +232,12 @@ pkt_bcast_simple(lcb_t instance, const void *cookie, lcb_CALLBACKTYPE type)
 {
     mc_CMDQUEUE *cq = &instance->cmdq;
     unsigned ii;
-    bcast_cookie *ckwrap;
 
     if (!cq->config) {
         return LCB_CLIENT_ETMPFAIL;
     }
 
-    ckwrap = calloc(1, sizeof(*ckwrap));
-    ckwrap->base.cookie = cookie;
-    ckwrap->base.start = gethrtime();
-    ckwrap->base.procs = &bcast_procs;
-    ckwrap->type = type;
+    BcastCookie *ckwrap = new BcastCookie(type, &bcast_procs, cookie);
 
     for (ii = 0; ii < cq->npipelines; ii++) {
         mc_PIPELINE *pl = cq->pipelines[ii];
@@ -244,7 +249,7 @@ pkt_bcast_simple(lcb_t instance, const void *cookie, lcb_CALLBACKTYPE type)
             return LCB_CLIENT_ENOMEM;
         }
 
-        pkt->u_rdata.exdata = &ckwrap->base;
+        pkt->u_rdata.exdata = ckwrap;
         pkt->flags |= MCREQ_F_REQEXT;
 
         hdr.request.magic = PROTOCOL_BINARY_REQ;
@@ -265,7 +270,7 @@ pkt_bcast_simple(lcb_t instance, const void *cookie, lcb_CALLBACKTYPE type)
     }
 
     if (ii == 0) {
-        free(ckwrap);
+        delete ckwrap;
         return LCB_NO_MATCHING_SERVER;
     }
     MAYBE_SCHEDLEAVE(instance);
@@ -274,18 +279,16 @@ pkt_bcast_simple(lcb_t instance, const void *cookie, lcb_CALLBACKTYPE type)
 
 LIBCOUCHBASE_API
 lcb_error_t
-lcb_server_versions3(lcb_t instance, const void *cookie, const lcb_CMDBASE * cmd)
+lcb_server_versions3(lcb_t instance, const void *cookie, const lcb_CMDBASE *)
 {
-    (void)cmd;
     return pkt_bcast_simple(instance, cookie, LCB_CALLBACK_VERSIONS);
 }
 
 
 LIBCOUCHBASE_API
 lcb_error_t
-lcb_flush3(lcb_t instance, const void *cookie, const lcb_CMDFLUSH *cmd)
+lcb_flush3(lcb_t instance, const void *cookie, const lcb_CMDFLUSH *)
 {
-    (void)cmd;
     return pkt_bcast_simple(instance, cookie, LCB_CALLBACK_FLUSH);
 }
 
@@ -296,30 +299,24 @@ lcb_server_verbosity3(lcb_t instance, const void *cookie,
 {
     mc_CMDQUEUE *cq = &instance->cmdq;
     unsigned ii;
-    bcast_cookie *ckwrap;
 
     if (!cq->config) {
         return LCB_CLIENT_ETMPFAIL;
     }
 
-    ckwrap = calloc(1, sizeof(*ckwrap));
-    ckwrap->base.cookie = cookie;
-    ckwrap->base.start = gethrtime();
-    ckwrap->base.procs = &bcast_procs;
-    ckwrap->type = LCB_CALLBACK_VERBOSITY;
+    BcastCookie *ckwrap = new BcastCookie(
+        LCB_CALLBACK_VERBOSITY, &bcast_procs, cookie);
 
     for (ii = 0; ii < cq->npipelines; ii++) {
         mc_PACKET *pkt;
-        mc_PIPELINE *pl = cq->pipelines[ii];
-        mc_SERVER *server = (mc_SERVER *)pl;
-        char cmpbuf[NI_MAXHOST + NI_MAXSERV + 4];
+        lcb::Server *server = static_cast<lcb::Server*>(cq->pipelines[ii]);
         protocol_binary_request_verbosity vcmd;
         protocol_binary_request_header *hdr = &vcmd.message.header;
         uint32_t level;
 
-        sprintf(cmpbuf, "%s:%s",
-            mcserver_get_host(server), mcserver_get_port(server));
-        if (cmd->server && strncmp(cmpbuf, cmd->server, strlen(cmd->server))) {
+        std::string cmpbuf;
+        make_hp_string(*server, cmpbuf);
+        if (cmd->server && cmpbuf != cmd->server) {
             continue;
         }
 
@@ -333,15 +330,15 @@ lcb_server_verbosity3(lcb_t instance, const void *cookie,
             level = 0;
         }
 
-        pkt = mcreq_allocate_packet(pl);
+        pkt = mcreq_allocate_packet(server);
         if (!pkt) {
             return LCB_CLIENT_ENOMEM;
         }
 
-        pkt->u_rdata.exdata = &ckwrap->base;
+        pkt->u_rdata.exdata = ckwrap;
         pkt->flags |= MCREQ_F_REQEXT;
 
-        mcreq_reserve_header(pl, pkt, MCREQ_PKT_BASESIZE + 4);
+        mcreq_reserve_header(server, pkt, MCREQ_PKT_BASESIZE + 4);
         hdr->request.magic = PROTOCOL_BINARY_REQ;
         hdr->request.opcode = PROTOCOL_BINARY_CMD_VERBOSITY;
         hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
@@ -354,12 +351,12 @@ lcb_server_verbosity3(lcb_t instance, const void *cookie,
         vcmd.message.body.level = htonl((uint32_t)level);
 
         memcpy(SPAN_BUFFER(&pkt->kh_span), vcmd.bytes, sizeof(vcmd.bytes));
-        mcreq_sched_add(pl, pkt);
+        mcreq_sched_add(server, pkt);
         ckwrap->remaining++;
     }
 
     if (!ckwrap->remaining) {
-        free(ckwrap);
+        delete ckwrap;
         return LCB_NO_MATCHING_SERVER;
     }
     MAYBE_SCHEDLEAVE(instance);
@@ -371,10 +368,8 @@ lcb_error_t
 lcb_server_stats(lcb_t instance, const void *cookie, lcb_size_t num,
                  const lcb_server_stats_cmd_t * const * items)
 {
-    unsigned ii;
-
     lcb_sched_enter(instance);
-    for (ii = 0; ii < num; ii++) {
+    for (size_t ii = 0; ii < num; ii++) {
         const lcb_server_stats_cmd_t *src = items[ii];
         lcb_CMDSTATS dst;
         lcb_error_t err;
@@ -397,10 +392,8 @@ lcb_error_t
 lcb_set_verbosity(lcb_t instance, const void *cookie, lcb_size_t num,
                   const lcb_verbosity_cmd_t * const * items)
 {
-    unsigned ii;
-
     lcb_sched_enter(instance);
-    for (ii = 0; ii < num; ii++) {
+    for (size_t ii = 0; ii < num; ii++) {
         lcb_CMDVERBOSITY dst;
         lcb_error_t err;
         const lcb_verbosity_cmd_t *src = items[ii];
@@ -421,12 +414,10 @@ lcb_set_verbosity(lcb_t instance, const void *cookie, lcb_size_t num,
 LIBCOUCHBASE_API
 lcb_error_t
 lcb_flush(lcb_t instance, const void *cookie, lcb_size_t num,
-          const lcb_flush_cmd_t * const * items)
+          const lcb_flush_cmd_t * const *)
 {
-    unsigned ii;
-
     lcb_sched_enter(instance);
-    for (ii = 0; ii < num; ii++) {
+    for (size_t ii = 0; ii < num; ii++) {
         lcb_error_t rc = lcb_flush3(instance, cookie, NULL);
         if (rc != LCB_SUCCESS) {
             lcb_sched_fail(instance);
@@ -434,20 +425,17 @@ lcb_flush(lcb_t instance, const void *cookie, lcb_size_t num,
         }
     }
     lcb_sched_leave(instance);
-    (void)items;
     SYNCMODE_INTERCEPT(instance)
 }
 
 LIBCOUCHBASE_API
 lcb_error_t
 lcb_server_versions(lcb_t instance, const void *cookie, lcb_size_t num,
-                    const lcb_server_version_cmd_t * const * items)
+                    const lcb_server_version_cmd_t * const *)
 {
-    unsigned ii;
-    (void)items;
     lcb_sched_enter(instance);
 
-    for (ii = 0; ii < num; ii++) {
+    for (size_t ii = 0; ii < num; ii++) {
         lcb_error_t rc = lcb_server_versions3(instance, cookie, NULL);
         if (rc != LCB_SUCCESS) {
             lcb_sched_fail(instance);