libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/mcserver/negotiate.h

@@ -19,9 +19,8 @@
 #define LCB_MCSERVER_NEGOTIATE_H
 #include <libcouchbase/couchbase.h>
 #include <lcbio/lcbio.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <string>
+#include <vector>
 
 /**
  * @file
@@ -37,83 +36,95 @@ extern "C" {
  */
 
 struct lcb_settings_st;
-typedef struct mc_SESSREQ *mc_pSESSREQ;
-typedef struct mc_SESSINFO *mc_pSESSINFO;
 
-/**
- * @brief Start negotiation on a connected socket
- *
- * This will start negotiation on the socket. Once complete (or an error has
- * taken place) the `callback` will be invoked with the result.
- *
- * @param sock A connected socket to use. Its reference count will be increased
- * @param settings A settings structure. Used for auth information as well as
- * logging
- * @param tmo Time in microseconds to wait until the negotiation is done
- * @param callback A callback to invoke when a result has been received
- * @param data User-defined pointer passed to the callback
- * @return A new handle which may be cancelled via mc_sessreq_cancel(). As with
- * other cancellable requests, once this handle is cancelled a callback will
- * not be received for it, and once the callback is received the handle may not
- * be cancelled as it will point to invalid memory.
- *
- * Once the socket has been negotiated successfuly, you may then use the
- * mc_sess_get() function to query the socket about various negotiation aspects
- *
- * @code{.c}
- * lcbio_CONNREQ creq;
- * mc_pSASLREQ req;
- * req = mc_sasl_start(sock, settings, tmo, callback, data);
- * LCBIO_CONNREQ_MKGENERIC(req, mc_sasl_cancel);
- * @endcode
- *
- * @see lcbio_connreq_cancel()
- * @see LCBIO_CONNREQ_MKGENERIC
- */
-mc_pSESSREQ
-mc_sessreq_start(
-        lcbio_SOCKET *sock, struct lcb_settings_st *settings,
-        uint32_t tmo, lcbio_CONNDONE_cb callback, void *data);
+namespace lcb {
+class SessionRequest {
+public:
+    /**
+     * @brief Start negotiation on a connected socket
+     *
+     * This will start negotiation on the socket. Once complete (or an error has
+     * taken place) the `callback` will be invoked with the result.
+     *
+     * @param sock A connected socket to use. Its reference count will be increased
+     * @param settings A settings structure. Used for auth information as well as
+     * logging
+     * @param tmo Time in microseconds to wait until the negotiation is done
+     * @param callback A callback to invoke when a result has been received
+     * @param data User-defined pointer passed to the callback
+     * @return A new handle which may be cancelled via mc_sessreq_cancel(). As with
+     * other cancellable requests, once this handle is cancelled a callback will
+     * not be received for it, and once the callback is received the handle may not
+     * be cancelled as it will point to invalid memory.
+     *
+     * Once the socket has been negotiated successfuly, you may then use the
+     * mc_sess_get() function to query the socket about various negotiation aspects
+     *
+     * @code{.c}
+     * lcbio_CONNREQ creq;
+     * SessionRequest *req = SessionRequest::start(sock, settings, tmo, callback, data);
+     * LCBIO_CONNREQ_MKGENERIC(req, sessreq_cancel);
+     * @endcode
+     *
+     * @see lcb::sessreq_cancel()
+     * @see LCBIO_CONNREQ_MKGENERIC
+     */
+    static SessionRequest *start(lcbio_SOCKET *sock, lcb_settings_st *settings,
+                                 uint32_t tmo, lcbio_CONNDONE_cb callback,
+                                 void *data);
 
-/**
- * @brief Cancel a pending SASL negotiation request
- * @param handle The handle to cancel
- */
-void
-mc_sessreq_cancel(mc_pSESSREQ handle);
+    /**
+     * @brief Cancel a pending SASL negotiation request
+     * @param handle The handle to cancel
+     */
+    virtual void cancel() = 0;
+    virtual ~SessionRequest(){}
+};
+class SessionRequestImpl;
 
-/**
- * @brief Get an opaque handle representing the negotiated state of the socket
- * @param sock The negotiated socket
- * @return the `SASLINFO` structure if the socket is negotiated, or `NULL` if
- * the socket has not been negotiated.
- *
- * @see mc_sasl_getmech()
- */
-mc_pSESSINFO
-mc_sess_get(lcbio_SOCKET *sock);
+extern "C" { void sessreq_cancel(SessionRequest *); }
 
-/**
- * @brief Get the mechanism employed for authentication
- * @param info pointer retrieved via mc_sasl_get()
- * @return A string indicating the mechanism used. This may be `PLAIN` or
- * `CRAM-MD5`.
- */
-const char *
-mc_sess_get_saslmech(mc_pSESSINFO info);
+class SessionInfo : public lcbio_PROTOCTX {
+public:
+    /**
+     * @brief Get an opaque handle representing the negotiated state of the socket
+     * @param sock The negotiated socket
+     * @return the `SASLINFO` structure if the socket is negotiated, or `NULL` if
+     * the socket has not been negotiated.
+     *
+     * @see get_mech()
+     */
+    static SessionInfo* get(lcbio_SOCKET*);
 
-/**
- * @brief Determine if a specific protocol feature is supported on the server
- * @param info info pointer returned via mc_sasl_get()
- * @param feature A feature ID
- * @return true if supported, false otherwise
- */
-int
-mc_sess_chkfeature(mc_pSESSINFO info, uint16_t feature);
+    /**
+     * @brief Get the mechanism employed for authentication
+     * @param info pointer retrieved via mc_sasl_get()
+     * @return A string indicating the mechanism used. This may be `PLAIN` or
+     * `CRAM-MD5`.
+     */
+    const std::string& get_mech() const {
+        return mech;
+    }
+
+    /**
+     * @brief Determine if a specific protocol feature is supported on the server
+     * @param info info pointer returned via mc_sasl_get()
+     * @param feature A feature ID
+     * @return true if supported, false otherwise
+     */
+    bool has_feature(uint16_t feature) const;
+
+private:
+    SessionInfo();
+    friend class lcb::SessionRequestImpl;
+
+    std::string mech;
+    std::vector<uint16_t> server_features;
+};
+
+
+} // namespace
 
 /**@}*/
 
-#ifdef __cplusplus
-}
-#endif
 #endif

data/ext/libcouchbase/src/mctx-helper.h

@@ -0,0 +1,51 @@
+/*
+ *     Copyright 2016 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_MCTX_HELPER_H
+#define LCB_MCTX_HELPER_H
+#include <libcouchbase/couchbase.h>
+
+namespace lcb {
+
+class MultiCmdContext : public lcb_MULTICMD_CTX {
+protected:
+    virtual lcb_error_t MCTX_addcmd(const lcb_CMDBASE* cmd) = 0;
+    virtual lcb_error_t MCTX_done(const void *cookie) = 0;
+    virtual void MCTX_fail() = 0;
+
+    MultiCmdContext() {
+        lcb_MULTICMD_CTX::addcmd = dispatch_mctx_addcmd;
+        lcb_MULTICMD_CTX::done = dispatch_mctx_done;
+        lcb_MULTICMD_CTX::fail = dispatch_mctx_fail;
+    }
+
+    virtual ~MultiCmdContext() {}
+
+private:
+    static lcb_error_t dispatch_mctx_addcmd(lcb_MULTICMD_CTX* ctx, const lcb_CMDBASE * cmd) {
+        return static_cast<MultiCmdContext*>(ctx)->MCTX_addcmd(cmd);
+    }
+    static lcb_error_t dispatch_mctx_done(lcb_MULTICMD_CTX* ctx, const void *cookie) {
+        return static_cast<MultiCmdContext*>(ctx)->MCTX_done(cookie);
+    }
+    static void dispatch_mctx_fail(lcb_MULTICMD_CTX* ctx) {
+        static_cast<MultiCmdContext*>(ctx)->MCTX_fail();
+    }
+};
+
+}
+
+#endif

data/ext/libcouchbase/src/n1ql/ixmgmt.cc

@@ -210,8 +210,7 @@ dispatch_common(lcb_t instance,
 // mind-numbing buffer copies. Maybe this can be done via a macro instead?
 class IndexSpec : public lcb_N1XSPEC {
 public:
-    IndexSpec(const char *s, size_t n) {
-        memset(static_cast<lcb_N1XSPEC*>(this), 0, sizeof (lcb_N1XSPEC));
+    IndexSpec(const char *s, size_t n) : lcb_N1XSPEC() {
         load_json(s, n);
     }
     inline IndexSpec(const lcb_N1XSPEC *spec);

data/ext/libcouchbase/src/n1ql/n1ql.cc

@@ -142,10 +142,10 @@ struct lcb_N1QLCACHE_st {
     }
 };
 
-typedef struct lcb_N1QLREQ {
+typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     const lcb_RESPHTTP *cur_htresp;
     struct lcb_http_request_st *htreq;
-    lcbjsp_PARSER *parser;
+    lcb::jsparse::Parser *parser;
     const void *cookie;
     lcb_N1QLCALLBACK callback;
     lcb_t instance;
@@ -155,6 +155,9 @@ typedef struct lcb_N1QLREQ {
     // How many rows were received. Used to avoid parsing the meta
     size_t nrows;
 
+    // Host for CBAS/Analytics query
+    std::string cbashost;
+
     /** The PREPARE query itself */
     struct lcb_N1QLREQ *prepare_req;
 
@@ -227,9 +230,28 @@ typedef struct lcb_N1QLREQ {
      */
     inline void fail_prepared(const lcb_RESPN1QL *orig, lcb_error_t err);
 
+    bool is_cbas() const {
+        return !cbashost.empty();
+    }
+
     inline lcb_N1QLREQ(lcb_t obj, const void *user_cookie, const lcb_CMDN1QL *cmd);
     inline ~lcb_N1QLREQ();
 
+    // Parser overrides:
+    void JSPARSE_on_row(const lcb::jsparse::Row& row) {
+        lcb_RESPN1QL resp = { 0 };
+        resp.row = static_cast<const char *>(row.row.iov_base);
+        resp.nrow = row.row.iov_len;
+        nrows++;
+        invoke_row(&resp, false);
+    }
+    void JSPARSE_on_error(const std::string&) {
+        lasterr = LCB_PROTOCOL_ERROR;
+    }
+    void JSPARSE_on_complete(const std::string&) {
+        // Nothing
+    }
+
 } N1QLREQ;
 
 static bool
@@ -330,8 +352,7 @@ N1QLREQ::maybe_retry()
     }
 
     was_retried = true;
-
-    lcbjsp_get_postmortem(parser, &meta);
+    parser->get_postmortem(meta);
     if (!parse_json(static_cast<const char*>(meta.iov_base), meta.iov_len, root)) {
         return false; // Not JSON
     }
@@ -351,7 +372,7 @@ N1QLREQ::maybe_retry()
 
     } else {
         // We'll be parsing more rows later on..
-        lcbjsp_reset(parser);
+        parser->reset();
     }
     return true;
 }
@@ -366,7 +387,7 @@ N1QLREQ::invoke_row(lcb_RESPN1QL *resp, bool is_last)
         lcb_IOV meta;
         resp->rflags |= LCB_RESP_F_FINAL;
         resp->rc = lasterr;
-        lcbjsp_get_postmortem(parser, &meta);
+        parser->get_postmortem(meta);
         resp->row = static_cast<const char*>(meta.iov_base);
         resp->nrow = meta.iov_len;
     }
@@ -392,31 +413,13 @@ lcb_N1QLREQ::~lcb_N1QLREQ()
     }
 
     if (parser) {
-        lcbjsp_free(parser);
+        delete parser;
     }
     if (prepare_req) {
         lcb_n1ql_cancel(instance, prepare_req);
     }
 }
 
-static void
-row_callback(lcbjsp_PARSER *parser, const lcbjsp_ROW *datum)
-{
-    N1QLREQ *req = static_cast<N1QLREQ*>(parser->data);
-    lcb_RESPN1QL resp = { 0 };
-
-    if (datum->type == LCBJSP_TYPE_ROW) {
-        resp.row = static_cast<const char*>(datum->row.iov_base);
-        resp.nrow = datum->row.iov_len;
-        req->nrows++;
-        req->invoke_row(&resp, 0);
-    } else if (datum->type == LCBJSP_TYPE_ERROR) {
-        req->lasterr = resp.rc = LCB_PROTOCOL_ERROR;
-    } else if (datum->type == LCBJSP_TYPE_COMPLETE) {
-        /* Nothing */
-    }
-}
-
 static void
 chunk_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
 {
@@ -444,8 +447,7 @@ chunk_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
         delete req;
         return;
     }
-
-    lcbjsp_feed(req->parser, static_cast<const char*>(rh->body), rh->nbody);
+    req->parser->feed(static_cast<const char*>(rh->body), rh->nbody);
 }
 
 #define QUERY_PATH "/query/service"
@@ -512,7 +514,14 @@ N1QLREQ::issue_htreq(const std::string& body)
 
     htcmd.content_type = "application/json";
     htcmd.method = LCB_HTTP_METHOD_POST;
-    htcmd.type = LCB_HTTP_TYPE_N1QL;
+
+    if (is_cbas()) {
+        htcmd.type = LCB_HTTP_TYPE_RAW;
+        htcmd.host = cbashost.c_str();
+    } else {
+        htcmd.type = LCB_HTTP_TYPE_N1QL;
+    }
+
     htcmd.cmdflags = LCB_CMDHTTP_F_STREAM|LCB_CMDHTTP_F_CASTMO;
     if (flags & F_CMDN1QL_CREDSAUTH) {
         htcmd.cmdflags |= LCB_CMDHTTP_F_NOUPASS;
@@ -522,7 +531,7 @@ N1QLREQ::issue_htreq(const std::string& body)
 
     lcb_error_t rc = lcb_http3(instance, this, &htcmd);
     if (rc == LCB_SUCCESS) {
-        lcb_htreq_setcb(htreq, chunk_callback);
+        htreq->set_callback(chunk_callback);
     }
     return rc;
 }
@@ -586,13 +595,12 @@ lcb_n1qlreq_parsetmo(const std::string& s)
 
 lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
     const void *user_cookie, const lcb_CMDN1QL *cmd)
-    : cur_htresp(NULL), htreq(NULL), parser(lcbjsp_create(LCBJSP_MODE_N1QL)),
+    : cur_htresp(NULL), htreq(NULL),
+      parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_N1QL, this)),
       cookie(user_cookie), callback(cmd->callback), instance(obj),
       lasterr(LCB_SUCCESS), flags(cmd->cmdflags), timeout(0),
       nrows(0), prepare_req(NULL), was_retried(false)
 {
-    parser->data = this;
-    parser->callback = row_callback;
     if (cmd->handle) {
         *cmd->handle = this;
     }
@@ -604,6 +612,22 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
         return;
     }
 
+    if (flags & LCB_CMDN1QL_F_CBASQUERY) {
+        if (!cmd->host) {
+            lasterr = LCB_EINVAL;
+            return;
+        }
+        cbashost.assign(cmd->host);
+        if (cbashost.empty()) {
+            lasterr = LCB_EINVAL;
+            return;
+        }
+        if (flags & LCB_CMDN1QL_F_PREPCACHE) {
+            lasterr = LCB_OPTIONS_CONFLICT;
+            return;
+        }
+    }
+
     const Json::Value& j_statement = json_const()["statement"];
     if (j_statement.isString()) {
         statement = j_statement.asString();

data/ext/libcouchbase/src/{newconfig.c → newconfig.cc}

@@ -25,7 +25,7 @@
 #define LOG(instance, lvlbase, msg) lcb_log(instance->settings, "newconfig", LCB_LOG_##lvlbase, __FILE__, __LINE__, msg)
 
 #define SERVER_FMT "%s:%s (%p)"
-#define SERVER_ARGS(s) (s)->curhost->host, (s)->curhost->port, (void *)s
+#define SERVER_ARGS(s) (s)->get_host().host, (s)->get_host().port, (void *)s
 
 typedef struct lcb_GUESSVB_st {
     time_t last_update; /**< Last time this vBucket was heuristically set */
@@ -106,8 +106,8 @@ lcb_vbguess_remap(lcb_t instance, int vbid, int bad)
         lcb_GUESSVB *guess = guesses + vbid;
         int newix = lcbvb_nmv_remap_ex(LCBT_VBCONFIG(instance), vbid, bad, 1);
         if (!guesses) {
-            guesses = instance->vbguess = calloc(
-                LCBT_VBCONFIG(instance)->nvb, sizeof *guesses);
+            guesses = instance->vbguess = reinterpret_cast<lcb_GUESSVB*>(calloc(
+                LCBT_VBCONFIG(instance)->nvb, sizeof *guesses));
         }
         if (newix > -1 && newix != bad) {
             guess->newix = newix;
@@ -136,18 +136,17 @@ lcb_vbguess_remap(lcb_t instance, int vbid, int bad)
  */
 static int
 find_new_data_index(lcbvb_CONFIG *oldconfig, lcbvb_CONFIG* newconfig,
-    mc_SERVER *server)
+    lcb::Server *server)
 {
-    size_t ii;
     const char *old_datahost = lcbvb_get_hostport(oldconfig,
-        server->pipeline.index, LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_PLAIN);
+        server->get_index(), LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_PLAIN);
 
     if (!old_datahost) {
         /* Old server had no data service */
         return -1;
     }
 
-    for (ii = 0; ii < LCBVB_NSERVERS(newconfig); ii++) {
+    for (size_t ii = 0; ii < LCBVB_NSERVERS(newconfig); ii++) {
         const char *new_datahost = lcbvb_get_hostport(newconfig, ii,
             LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_PLAIN);
         if (new_datahost && strcmp(new_datahost, old_datahost) == 0) {
@@ -160,15 +159,14 @@ find_new_data_index(lcbvb_CONFIG *oldconfig, lcbvb_CONFIG* newconfig,
 static void
 log_vbdiff(lcb_t instance, lcbvb_CONFIGDIFF *diff)
 {
-    char **curserver;
     lcb_log(LOGARGS(instance, INFO), "Config Diff: [ vBuckets Modified=%d ], [Sequence Changed=%d]", diff->n_vb_changes, diff->sequence_changed);
     if (diff->servers_added) {
-        for (curserver = diff->servers_added; *curserver; curserver++) {
+        for (char **curserver = diff->servers_added; *curserver; curserver++) {
             lcb_log(LOGARGS(instance, INFO), "Detected server %s added", *curserver);
         }
     }
     if (diff->servers_removed) {
-        for (curserver = diff->servers_removed; *curserver; curserver++) {
+        for (char **curserver = diff->servers_removed; *curserver; curserver++) {
             lcb_log(LOGARGS(instance, INFO), "Detected server %s removed", *curserver);
         }
     }
@@ -187,19 +185,15 @@ log_vbdiff(lcb_t instance, lcbvb_CONFIGDIFF *diff)
  * another server.
  */
 static int
-iterwipe_cb(mc_CMDQUEUE *cq, mc_PIPELINE *oldpl, mc_PACKET *oldpkt, void *arg)
+iterwipe_cb(mc_CMDQUEUE *cq, mc_PIPELINE *oldpl, mc_PACKET *oldpkt, void *)
 {
     protocol_binary_request_header hdr;
-    mc_SERVER *srv = (mc_SERVER *)oldpl;
-    mc_PIPELINE *newpl;
-    mc_PACKET *newpkt;
+    lcb::Server *srv = static_cast<lcb::Server *>(oldpl);
     int newix;
 
-    (void)arg;
-
     mcreq_read_hdr(oldpkt, &hdr);
 
-    if (!lcb_should_retry(srv->settings, oldpkt, LCB_MAX_ERROR)) {
+    if (!lcb_should_retry(srv->get_settings(), oldpkt, LCB_MAX_ERROR)) {
         return MCREQ_KEEP_PACKET;
     }
 
@@ -222,23 +216,23 @@ iterwipe_cb(mc_CMDQUEUE *cq, mc_PIPELINE *oldpl, mc_PACKET *oldpkt, void *arg)
     }
 
 
-    newpl = cq->pipelines[newix];
+    mc_PIPELINE *newpl = cq->pipelines[newix];
     if (newpl == oldpl || newpl == NULL) {
         return MCREQ_KEEP_PACKET;
     }
 
-    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((mc_SERVER*)oldpl), SERVER_ARGS((mc_SERVER*)newpl));
+    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 */
-    newpkt = mcreq_renew_packet(oldpkt);
+    mc_PACKET *newpkt = mcreq_renew_packet(oldpkt);
     newpkt->flags &= ~MCREQ_STATE_FLAGS;
     mcreq_reenqueue_packet(newpl, newpkt);
     mcreq_packet_handled(oldpl, oldpkt);
     return MCREQ_REMOVE_PACKET;
 }
 
-static int
+static void
 replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
 {
     mc_CMDQUEUE *cq = &instance->cmdq;
@@ -248,7 +242,7 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
     assert(LCBT_VBCONFIG(instance) == newconfig);
 
     nnew = LCBVB_NSERVERS(newconfig);
-    ppnew = calloc(nnew, sizeof(*ppnew));
+    ppnew = reinterpret_cast<mc_PIPELINE**>(calloc(nnew, sizeof(*ppnew)));
     ppold = mcreq_queue_take_pipelines(cq, &nold);
 
     /**
@@ -256,26 +250,25 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
      * and place it inside the new list.
      */
     for (ii = 0; ii < nold; ii++) {
-        mc_SERVER *cur = (mc_SERVER *)ppold[ii];
+        lcb::Server *cur = static_cast<lcb::Server *>(ppold[ii]);
         int newix = find_new_data_index(oldconfig, newconfig, cur);
         if (newix > -1) {
-            cur->pipeline.index = newix;
-            ppnew[newix] = &cur->pipeline;
+            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);
         }
     }
 
     /**
-     * Once we've moved the kept servers to the new list, allocate new mc_SERVER
-     * structures for slots that don't have an existing mc_SERVER. We must do
+     * Once we've moved the kept servers to the new list, allocate new lcb::Server
+     * structures for slots that don't have an existing lcb::Server. We must do
      * this before add_pipelines() is called, so that there are no holes inside
      * ppnew
      */
     for (ii = 0; ii < nnew; ii++) {
         if (!ppnew[ii]) {
-            ppnew[ii] = (mc_PIPELINE *)mcserver_alloc(instance, ii);
-            ppnew[ii]->index = ii;
+            ppnew[ii] = new lcb::Server(instance, ii);
         }
     }
 
@@ -298,31 +291,28 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
         }
 
         mcreq_iterwipe(cq, ppold[ii], iterwipe_cb, NULL);
-        mcserver_fail_chain((mc_SERVER *)ppold[ii], LCB_MAP_CHANGED);
-        mcserver_close((mc_SERVER *)ppold[ii]);
+        static_cast<lcb::Server*>(ppold[ii])->purge(LCB_MAP_CHANGED);
+        static_cast<lcb::Server*>(ppold[ii])->close();
     }
 
     for (ii = 0; ii < nnew; ii++) {
-        if (mcserver_has_pending((mc_SERVER*)ppnew[ii])) {
+        if (static_cast<lcb::Server*>(ppnew[ii])->has_pending()) {
             ppnew[ii]->flush_start(ppnew[ii]);
         }
     }
 
     free(ppnew);
     free(ppold);
-    return LCB_CONFIGURATION_CHANGED;
 }
 
-void lcb_update_vbconfig(lcb_t instance, clconfig_info *config)
+void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config)
 {
-    lcb_size_t ii;
-    int change_status;
-    clconfig_info *old_config;
+    lcb_configuration_t change_status;
+    lcb::clconfig::ConfigInfo *old_config = instance->cur_configinfo;
     mc_CMDQUEUE *q = &instance->cmdq;
 
-    old_config = instance->cur_configinfo;
     instance->cur_configinfo = config;
-    lcb_clconfig_incref(config);
+    config->incref();
     q->config = instance->cur_configinfo->vbc;
     q->cqdata = instance;
 
@@ -337,49 +327,31 @@ void lcb_update_vbconfig(lcb_t instance, clconfig_info *config)
         /* Apply the vb guesses */
         lcb_vbguess_newconfig(instance, config->vbc, instance->vbguess);
 
-        change_status = replace_config(instance, old_config->vbc, config->vbc);
-        if (change_status == -1) {
-            LOG(instance, ERR, "Couldn't replace config");
-            return;
-        }
-        lcb_clconfig_decref(old_config);
+        replace_config(instance, old_config->vbc, config->vbc);
+        old_config->decref();
+        change_status = LCB_CONFIGURATION_CHANGED;
     } else {
-        unsigned nservers;
-        mc_PIPELINE **servers;
-        nservers = VB_NSERVERS(config->vbc);
-        if ((servers = malloc(sizeof(*servers) * nservers)) == NULL) {
-            assert(servers);
-            lcb_log(LOGARGS(instance, FATAL), "Couldn't allocate memory for new server list! (n=%u)", nservers);
-            return;
-        }
+        size_t nservers = VB_NSERVERS(config->vbc);
+        std::vector<mc_PIPELINE*> servers;
 
-        for (ii = 0; ii < nservers; ii++) {
-            mc_SERVER *srv;
-            if ((srv = mcserver_alloc(instance, ii)) == NULL) {
-                assert(srv);
-                lcb_log(LOGARGS(instance, FATAL), "Couldn't allocate memory for server instance!");
-                return;
-            }
-            servers[ii] = &srv->pipeline;
+        for (size_t ii = 0; ii < nservers; ii++) {
+            servers.push_back(new lcb::Server(instance, ii));
         }
 
-        mcreq_queue_add_pipelines(q, servers, nservers, config->vbc);
+        mcreq_queue_add_pipelines(q, &servers[0], nservers, config->vbc);
         change_status = LCB_CONFIGURATION_NEW;
-        free(servers);
     }
 
     /* Update the list of nodes here for server list */
-    hostlist_clear(instance->ht_nodes);
-    for (ii = 0; ii < LCBVB_NSERVERS(config->vbc); ++ii) {
+    instance->ht_nodes->clear();
+    for (size_t ii = 0; ii < LCBVB_NSERVERS(config->vbc); ++ii) {
         const char *hp = lcbvb_get_hostport(config->vbc, ii,
             LCBVB_SVCTYPE_MGMT, LCBVB_SVCMODE_PLAIN);
         if (hp) {
-            hostlist_add_stringz(instance->ht_nodes, hp, LCB_CONFIG_HTTP_PORT);
+            instance->ht_nodes->add(hp, LCB_CONFIG_HTTP_PORT);
         }
     }
 
     instance->callbacks.configuration(instance, change_status);
     lcb_maybe_breakout(instance);
 }
-
-