libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/packaging/parse-git-describe.pl

@@ -1,4 +1,4 @@
-#!/usr/bin/perl
+#!/usr/bin/env perl
 
 use strict;
 use warnings;

data/ext/libcouchbase/plugins/io/libev/libev_io_opts.h

@@ -48,11 +48,12 @@ extern "C" {
      * Create an instance of an event handler that utilize libev for
      * event notification.
      *
-     * @param version the API version to use
+     * @param version Set this to 0. This may be used in the future to allow
+     *        variation on the third argument (`void*` currently).
+     * @param[out] io a pointer to a newly created and initialized event handler
      * @param loop the event loop (struct ev_loop *) to hook use (please
      *             note that you shouldn't reference the event loop from
      *             multiple threads)
-     * @param io a pointer to a newly created and initialized event handler
      * @return status of the operation
      */
     LIBCOUCHBASE_API

data/ext/libcouchbase/src/README.md

@@ -43,8 +43,6 @@ listing of the various subcomponents and what they do:
 
 * `sllist.h, sllist-inl.h` contain the implementation for a single-linked list
 
-* `simplestring.{c,h}` contains the implementation for a dynamically sized string
-
 * `logging.{c,h}` contains the implementation for the library's logging mechanism
 
 * `hostlist.{c,h}` defines a list of hosts, with features for de-duping and converting

data/ext/libcouchbase/src/auth-priv.h

@@ -14,6 +14,7 @@ public:
     const std::string& password() const { return m_password; }
     const Map& buckets() const { return m_buckets; }
     Authenticator() : m_refcount(1) {}
+    Authenticator(const Authenticator&);
 
     size_t refcount() const { return m_refcount; }
     void incref() { ++m_refcount; }

data/ext/libcouchbase/src/auth.cc

@@ -97,3 +97,13 @@ Authenticator::init(const std::string& username_, const std::string& bucket,
     m_buckets[bucket] = m_password;
     return LCB_SUCCESS;
 }
+
+Authenticator::Authenticator(const Authenticator& other)
+    : m_buckets(other.m_buckets), m_username(other.m_username),
+      m_password(other.m_password), m_refcount(1) {
+}
+
+lcb_AUTHENTICATOR *
+lcbauth_clone(const lcb_AUTHENTICATOR *src) {
+    return new Authenticator(*src);
+}

data/ext/libcouchbase/src/bootstrap.cc

@@ -0,0 +1,216 @@
+/* -*- 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.
+ */
+
+#define LCB_BOOTSTRAP_DEFINE_STRUCT 1
+#include "internal.h"
+
+
+#define LOGARGS(instance, lvl) instance->settings, "bootstrap", LCB_LOG_##lvl, __FILE__, __LINE__
+
+using lcb::clconfig::EventType;
+using lcb::clconfig::ConfigInfo;
+using namespace lcb;
+
+/**
+ * This function is where the configuration actually takes place. We ensure
+ * in other functions that this is only ever called directly from an event
+ * loop stack frame (or one of the small mini functions here) so that we
+ * don't accidentally end up destroying resources underneath us.
+ */
+void Bootstrap::config_callback(EventType event, ConfigInfo *info) {
+    using namespace lcb::clconfig;
+    lcb_t instance = parent;
+
+    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
+            if (!LCBT_VBCONFIG(instance)) {
+                initial_error(LCB_ERROR, "No more bootstrap providers remain");
+            }
+        }
+        return;
+    }
+
+    instance->last_error = LCB_SUCCESS;
+
+    /** Ensure we're not called directly twice again */
+    if (state < S_INITIAL_TRIGGERED) {
+        state = S_INITIAL_TRIGGERED;
+    }
+
+    tm.cancel();
+
+    lcb_log(LOGARGS(instance, DEBUG), "Instance configured!");
+
+    if (info->get_origin() != CLCONFIG_FILE) {
+        /* Set the timestamp for the current config to control throttling,
+         * but only if it's not an initial file-based config. See CCBC-482 */
+        last_refresh = gethrtime();
+        errcounter = 0;
+    }
+
+    if (info->get_origin() == CLCONFIG_CCCP) {
+        /* Disable HTTP provider if we've received something via CCCP */
+
+        if (instance->cur_configinfo == NULL ||
+                instance->cur_configinfo->get_origin() != CLCONFIG_HTTP) {
+            /* Never disable HTTP if it's still being used */
+            instance->confmon->set_active(CLCONFIG_HTTP, false);
+        }
+    }
+
+    if (instance->type != LCB_TYPE_CLUSTER) {
+        lcb_update_vbconfig(instance, info);
+    }
+
+    if (state < S_BOOTSTRAPPED) {
+        state = S_BOOTSTRAPPED;
+        lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
+
+        if (instance->type == LCB_TYPE_BUCKET &&
+                LCBVB_DISTTYPE(LCBT_VBCONFIG(instance)) == LCBVB_DIST_KETAMA &&
+                instance->cur_configinfo->get_origin() != CLCONFIG_MCRAW) {
+
+            lcb_log(LOGARGS(instance, INFO), "Reverting to HTTP Config for memcached buckets");
+            instance->settings->bc_http_stream_time = -1;
+            instance->confmon->set_active(CLCONFIG_HTTP, true);
+            instance->confmon->set_active(CLCONFIG_CCCP, false);
+        }
+        instance->callbacks.bootstrap(instance, LCB_SUCCESS);
+    }
+
+    lcb_maybe_breakout(instance);
+}
+
+void Bootstrap::clconfig_lsn(EventType e, ConfigInfo *i) {
+    if (state == S_INITIAL_PRE) {
+        config_callback(e, i);
+    } else if (e == clconfig::CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        lcb_log(LOGARGS(parent, INFO), "Got new config. Will refresh asynchronously");
+        tm.signal();
+    }
+}
+
+/**
+ * This it the initial bootstrap timeout handler. This timeout pins down the
+ * instance. It is only scheduled during the initial bootstrap and is only
+ * triggered if the initial bootstrap fails to configure in time.
+ */
+void Bootstrap::timer_dispatch() {
+    if (state > S_INITIAL_PRE) {
+        config_callback(clconfig::CLCONFIG_EVENT_GOT_NEW_CONFIG,
+            parent->confmon->get_config());
+    } else {
+        // Not yet bootstrapped!
+        initial_error(LCB_ETIMEDOUT, "Failed to bootstrap in time");
+    }
+}
+
+
+void Bootstrap::initial_error(lcb_error_t err, const char *errinfo) {
+    parent->last_error = parent->confmon->get_last_error();
+    if (parent->last_error == LCB_SUCCESS) {
+        parent->last_error = err;
+    }
+    parent->callbacks.error(parent, parent->last_error, errinfo);
+    lcb_log(LOGARGS(parent, ERR), "Failed to bootstrap client=%p. Error=%s, Message=%s", (void *)parent, lcb_strerror_short(parent->last_error), errinfo);
+    tm.cancel();
+
+    parent->callbacks.bootstrap(parent, parent->last_error);
+
+    lcb_aspend_del(&parent->pendops, LCB_PENDTYPE_COUNTER, NULL);
+    lcb_maybe_breakout(parent);
+}
+
+Bootstrap::Bootstrap(lcb_t instance)
+    : parent(instance),
+      tm(parent->iotable, this),
+      last_refresh(0),
+      errcounter(0),
+      state(S_INITIAL_PRE) {
+    parent->confmon->add_listener(this);
+}
+
+lcb_error_t Bootstrap::bootstrap(unsigned options) {
+    hrtime_t now = gethrtime();
+    if (parent->confmon->is_refreshing()) {
+        return LCB_SUCCESS;
+    }
+
+    if (options & BS_REFRESH_THROTTLE) {
+        /* Refresh throttle requested. This is not true if options == ALWAYS */
+        hrtime_t next_ts;
+        unsigned errthresh = LCBT_SETTING(parent, weird_things_threshold);
+
+        if (options & BS_REFRESH_INCRERR) {
+            errcounter++;
+        }
+        next_ts = last_refresh;
+        next_ts += LCB_US2NS(LCBT_SETTING(parent, weird_things_delay));
+        if (now < next_ts && errcounter < errthresh) {
+            lcb_log(LOGARGS(parent, INFO),
+                "Not requesting a config refresh because of throttling parameters. Next refresh possible in %ums or %u errors. "
+                "See LCB_CNTL_CONFDELAY_THRESH and LCB_CNTL_CONFERRTHRESH to modify the throttling settings",
+                LCB_NS2US(next_ts-now)/1000, (unsigned)errthresh-errcounter);
+            return LCB_SUCCESS;
+        }
+    }
+
+    if (options == BS_REFRESH_INITIAL) {
+        state = S_INITIAL_PRE;
+        parent->confmon->prepare();
+        tm.rearm(LCBT_SETTING(parent, config_timeout));
+        lcb_aspend_add(&parent->pendops, LCB_PENDTYPE_COUNTER, NULL);
+    }
+
+    /* Reset the counters */
+    errcounter = 0;
+    if (options != BS_REFRESH_INITIAL) {
+        last_refresh = now;
+    }
+    parent->confmon->start();
+    return LCB_SUCCESS;
+}
+
+Bootstrap::~Bootstrap() {
+    tm.release();
+    parent->confmon->remove_listener(this);
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_get_bootstrap_status(lcb_t instance)
+{
+    if (instance->cur_configinfo) {
+        return LCB_SUCCESS;
+    }
+    if (instance->last_error != LCB_SUCCESS) {
+        return instance->last_error;
+    }
+    if (instance->type == LCB_TYPE_CLUSTER) {
+        if (lcb::clconfig::http_get_conn(instance->confmon) != NULL) {
+            return LCB_SUCCESS;
+        }
+    }
+    return LCB_ERROR;
+}
+
+LIBCOUCHBASE_API
+void
+lcb_refresh_config(lcb_t instance)
+{
+    instance->bootstrap(BS_REFRESH_ALWAYS);
+}

data/ext/libcouchbase/src/bootstrap.h

@@ -17,9 +17,6 @@
 
 #ifndef LCB_BOOTSTRAP_H
 #define LCB_BOOTSTRAP_H
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 /**@file
  * Core bootstrap/cluster configuration routines */
@@ -29,19 +26,43 @@ extern "C" {
  * @{
  */
 
-#if defined(__LCB_DOXYGEN__) || defined(LCB_BOOTSTRAP_DEFINE_STRUCT)
+#ifdef __cplusplus
 #include "bucketconfig/clconfig.h"
+#include <lcbio/timer-cxx.h>
 
+namespace lcb {
 /**
  * Structure containing the bootstrap state for the instance.
+ *
+ * Derived from Listener,
+ * used to react when a new configuration is received. This
+ * is used for both requested configurations (i.e. an explicit call to
+ * lcb_bootstrap_common()) as well as unsolicited updates such as
+ * HTTP streaming configurations or Not-My-Vbucket "Carrier" updates.
  */
-struct lcb_BOOTSTRAP {
-    /**Listener object used to react when a new configuration is received. This
-     * is used for both requested configurations (i.e. an explicit call to
-     * lcb_bootstrap_common()) as well as unsolicited updates such as
-     * HTTP streaming configurations or Not-My-Vbucket "Carrier" updates.
-     */
-    clconfig_listener listener;
+class Bootstrap : lcb::clconfig::Listener {
+public:
+    Bootstrap(lcb_t);
+    ~Bootstrap();
+    lcb_error_t bootstrap(unsigned options);
+
+    hrtime_t get_last_refresh() const {
+        return last_refresh;
+    }
+    void reset_last_refresh() {
+        last_refresh = 0;
+    }
+    size_t get_errcounter() const {
+        return errcounter;
+    }
+
+private:
+    // Override
+    void clconfig_lsn(lcb::clconfig::EventType e, lcb::clconfig::ConfigInfo* i);
+
+    inline void config_callback(lcb::clconfig::EventType, lcb::clconfig::ConfigInfo*);
+    inline void initial_error(lcb_error_t, const char *);
+    void timer_dispatch();
 
     lcb_t parent;
 
@@ -49,7 +70,7 @@ struct lcb_BOOTSTRAP {
      * updates as an asynchronous event (to allow safe updates and avoid
      * reentrancy issues)
      */
-    lcbio_pTIMER tm;
+    lcb::io::Timer<Bootstrap, &Bootstrap::timer_dispatch> tm;
 
     /**
      * Timestamp indicating the most recent configuration activity. This
@@ -73,57 +94,47 @@ struct lcb_BOOTSTRAP {
      */
     unsigned errcounter;
 
-    /** Flag indicating whether the _initial_ configuration has been received */
-    int bootstrapped;
+    enum State {
+        /** Initial 'blank' state */
+        S_INITIAL_PRE = 0,
+        /** We got something after our initial callback */
+        S_INITIAL_TRIGGERED,
+        /** Have received at least one valid configuration */
+        S_BOOTSTRAPPED
+    };
+    State state;
 };
-#endif
 
 /**
  * These flags control the bootstrap refreshing mode that will take place
  * when lcb_bootstrap_common() is invoked. These options may be OR'd with
  * each other (with the exception of ::LCB_BS_REFRESH_ALWAYS).
  */
-typedef enum {
+enum BootstrapOptions {
     /** Always fetch a new configuration. No throttling checks are performed */
-    LCB_BS_REFRESH_ALWAYS = 0x00,
+    BS_REFRESH_ALWAYS = 0x00,
     /** Special mode used to fetch the first configuration */
-    LCB_BS_REFRESH_INITIAL = 0x02,
+    BS_REFRESH_INITIAL = 0x02,
 
     /** Make the request for a new configuration subject to throttling
      * limitations. Currently this will be subject to the interval specified
      * in the @ref LCB_CNTL_CONFDELAY_THRESH setting and the @ref
      * LCB_CNTL_CONFERRTHRESH setting. If the refresh has been throttled
      * the lcb_confmon_is_refreshing() function will return false */
-    LCB_BS_REFRESH_THROTTLE = 0x04,
+    BS_REFRESH_THROTTLE = 0x04,
 
     /** To be used in conjunction with ::LCB_BS_REFRESH_THROTTLE, this will
      * increment the error counter in case the current refresh is throttled,
      * such that when the error counter reaches the threshold, the throttle
      * limitations will expire and a new refresh will take place */
-    LCB_BS_REFRESH_INCRERR = 0x08
-} lcb_BSFLAGS;
-
-/**
- * @brief Request that the handle update its configuration.
- *
- * This function acts as a gateway to the more abstract confmon interface.
- *
- * @param instance The instance
- * @param options A set of options specified as flags, indicating under what
- * conditions a new configuration should be refetched.
- *
- * @return
- */
-LCB_INTERNAL_API
-lcb_error_t
-lcb_bootstrap_common(lcb_t instance, int options);
+    BS_REFRESH_INCRERR = 0x08
+};
 
 void
 lcb_bootstrap_destroy(lcb_t instance);
 
 /**@}*/
 
-#ifdef __cplusplus
-}
-#endif
+} // namespace lcb
+#endif // __cplusplus
 #endif /* LCB_BOOTSTRAP_H */

data/ext/libcouchbase/src/bucketconfig/bc_cccp.cc

@@ -0,0 +1,455 @@
+/* -*- 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.
+ */
+
+/**
+ * This file contains the CCCP (Cluster Carrier Configuration Protocol)
+ * implementation of the confmon provider. It utilizes a memcached connection
+ * to retrieve configuration information.
+ */
+
+#include "internal.h"
+#include "clconfig.h"
+#include "packetutils.h"
+#include <mcserver/negotiate.h>
+#include <lcbio/lcbio.h>
+#include <lcbio/timer-cxx.h>
+#include <lcbio/ssl.h>
+#include "ctx-log-inl.h"
+#define LOGARGS(cccp, lvl) cccp->parent->settings, "cccp", LCB_LOG_##lvl, __FILE__, __LINE__
+#define LOGFMT "<%s:%s> "
+#define LOGID(cccp) get_ctx_host(cccp->ioctx), get_ctx_port(cccp->ioctx)
+
+struct CccpCookie;
+
+using namespace lcb::clconfig;
+
+struct CccpProvider : public Provider {
+    CccpProvider(Confmon *);
+    ~CccpProvider();
+
+    void release_socket(bool can_reuse);
+    lcb_error_t schedule_next_request(lcb_error_t why, bool can_rollover);
+    lcb_error_t mcio_error(lcb_error_t why);
+    void on_timeout() { mcio_error(LCB_ETIMEDOUT); }
+    lcb_error_t update(const char *host, const char* data);
+    void request_config();
+    void on_io_read();
+
+    bool pause(); // Override
+    void configure_nodes(const lcb::Hostlist&); // Override
+    void config_updated(lcbvb_CONFIG *); // Override;
+    void dump(FILE*) const; // Override
+    lcb_error_t refresh(); // Override
+
+    ConfigInfo *get_cached() /* Override */ {
+        return config;
+    }
+
+    const lcb::Hostlist* get_nodes() const /* Override */ {
+        return nodes;
+    }
+
+    void enable(void *arg) {
+        instance = reinterpret_cast<lcb_t>(arg);
+        Provider::enable();
+    }
+
+    lcb::Hostlist *nodes;
+    ConfigInfo *config;
+    bool server_active;
+    lcb::io::Timer<CccpProvider, &CccpProvider::on_timeout> timer;
+    lcb_t instance;
+    lcbio_CONNREQ creq;
+    lcbio_CTX *ioctx;
+    CccpCookie *cmdcookie;
+};
+
+struct CccpCookie {
+    CccpProvider *parent;
+    bool ignore_errors;
+    CccpCookie(CccpProvider *parent_) : parent(parent_), ignore_errors(false) {
+    }
+};
+
+static void io_error_handler(lcbio_CTX *, lcb_error_t);
+static void io_read_handler(lcbio_CTX *, unsigned nr);
+static void on_connected(lcbio_SOCKET *, void*, lcb_error_t, lcbio_OSERR);
+
+static void
+pooled_close_cb(lcbio_SOCKET *sock, int reusable, void *arg)
+{
+    bool *ru_ex = reinterpret_cast<bool*>(arg);
+    lcbio_ref(sock);
+    if (reusable && *ru_ex) {
+        lcbio_mgr_put(sock);
+    } else {
+        lcbio_mgr_discard(sock);
+    }
+}
+
+void
+CccpProvider::release_socket(bool can_reuse)
+{
+    if (cmdcookie) {
+        cmdcookie->ignore_errors = 1;
+        cmdcookie =  NULL;
+        return;
+    }
+
+    lcbio_connreq_cancel(&creq);
+
+    if (ioctx) {
+        lcbio_ctx_close(ioctx, pooled_close_cb, &can_reuse);
+        ioctx = NULL;
+    }
+}
+
+lcb_error_t
+CccpProvider::schedule_next_request(lcb_error_t err, bool can_rollover)
+{
+    lcb::Server *server;
+    lcb_host_t *next_host = nodes->next(can_rollover);
+    if (!next_host) {
+        timer.cancel();
+        parent->provider_failed(this, err);
+        server_active = false;
+        return err;
+    }
+
+    server = instance->find_server(*next_host);
+    if (server) {
+        CccpCookie *cookie = new CccpCookie(this);
+        cmdcookie = cookie;
+        lcb_log(LOGARGS(this, INFO), "Re-Issuing CCCP Command on server struct %p (%s:%s)", (void*)server, next_host->host, next_host->port);
+        timer.rearm(settings().config_node_timeout);
+        instance->request_config(cookie, server);
+
+    } else {
+        lcbio_pMGRREQ preq;
+
+        lcb_log(LOGARGS(this, INFO), "Requesting connection to node %s:%s for CCCP configuration", next_host->host, next_host->port);
+        preq = lcbio_mgr_get(
+                instance->memd_sockpool, next_host,
+                settings().config_node_timeout,
+                on_connected, this);
+        LCBIO_CONNREQ_MKPOOLED(&creq, preq);
+    }
+
+    server_active = true;
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+CccpProvider::mcio_error(lcb_error_t err)
+{
+    if (err != LCB_NOT_SUPPORTED && err != LCB_UNKNOWN_COMMAND) {
+        lcb_log(LOGARGS(this, ERR), LOGFMT "Could not get configuration: %s", LOGID(this), lcb_strerror_short(err));
+    }
+
+    release_socket(err == LCB_NOT_SUPPORTED);
+    return schedule_next_request(err, false);
+}
+
+/** Update the configuration from a server. */
+lcb_error_t
+lcb::clconfig::cccp_update(Provider *provider, const char *host, const char *data) {
+    return static_cast<CccpProvider*>(provider)->update(host, data);
+}
+
+lcb_error_t
+CccpProvider::update(const char *host, const char *data)
+{
+    /** TODO: replace this with lcbvb_ names */
+    lcbvb_CONFIG* vbc;
+    int rv;
+    ConfigInfo *new_config;
+    vbc = lcbvb_create();
+
+    if (!vbc) {
+        return LCB_CLIENT_ENOMEM;
+    }
+    rv = lcbvb_load_json(vbc, data);
+
+    if (rv) {
+        lcb_log(LOGARGS(this, ERROR), LOGFMT "Failed to parse config", LOGID(this));
+        lcb_log_badconfig(LOGARGS(this, ERROR), vbc, data);
+        lcbvb_destroy(vbc);
+        return LCB_PROTOCOL_ERROR;
+    }
+
+    lcbvb_replace_host(vbc, host);
+    new_config = ConfigInfo::create(vbc, CLCONFIG_CCCP);
+
+    if (!new_config) {
+        lcbvb_destroy(vbc);
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    if (config) {
+        config->decref();
+    }
+
+    /** TODO: Figure out the comparison vector */
+    config = new_config;
+    parent->provider_got_config(this, new_config);
+    return LCB_SUCCESS;
+}
+
+void lcb::clconfig::cccp_update(
+    const void *cookie, lcb_error_t err,
+    const void *bytes, size_t nbytes, const lcb_host_t *origin)
+{
+    CccpCookie *ck = reinterpret_cast<CccpCookie*>(const_cast<void*>(cookie));
+    CccpProvider *cccp = ck->parent;
+
+    if (ck == cccp->cmdcookie) {
+        cccp->timer.cancel();
+        cccp->cmdcookie = NULL;
+    }
+
+    if (err == LCB_SUCCESS) {
+        std::string ss(reinterpret_cast<const char *>(bytes), nbytes);
+        err = cccp->update(origin->host, ss.c_str());
+    }
+
+    if (err != LCB_SUCCESS && ck->ignore_errors == 0) {
+        cccp->mcio_error(err);
+    }
+
+    free(ck);
+}
+
+static void
+on_connected(lcbio_SOCKET *sock, void *data, lcb_error_t err, lcbio_OSERR)
+{
+    lcbio_CTXPROCS ioprocs;
+    CccpProvider *cccp = reinterpret_cast<CccpProvider*>(data);
+    lcb_settings *settings = cccp->parent->settings;
+
+    LCBIO_CONNREQ_CLEAR(&cccp->creq);
+    if (err != LCB_SUCCESS) {
+        if (sock) {
+            lcbio_mgr_discard(sock);
+        }
+        cccp->mcio_error(err);
+        return;
+    }
+
+    if (lcbio_protoctx_get(sock, LCBIO_PROTOCTX_SESSINFO) == NULL) {
+        lcb::SessionRequest *sreq = lcb::SessionRequest::start(
+                sock, settings, settings->config_node_timeout, on_connected,
+                cccp);
+        LCBIO_CONNREQ_MKGENERIC(&cccp->creq, sreq, lcb::sessreq_cancel);
+        return;
+    }
+
+    ioprocs.cb_err = io_error_handler;
+    ioprocs.cb_read = io_read_handler;
+    cccp->ioctx = lcbio_ctx_new(sock, data, &ioprocs);
+    cccp->ioctx->subsys = "bc_cccp";
+    cccp->request_config();
+}
+
+lcb_error_t CccpProvider::refresh() {
+    if (creq.u.p_generic || server_active || cmdcookie) {
+        return LCB_BUSY;
+    }
+
+    return schedule_next_request(LCB_SUCCESS, true);
+}
+
+bool
+CccpProvider::pause()
+{
+    if (!server_active) {
+        return true;
+    }
+
+    server_active = 0;
+    release_socket(false);
+    timer.cancel();
+    return true;
+}
+
+CccpProvider::~CccpProvider() {
+    release_socket(false);
+
+    if (config) {
+        config->decref();
+    }
+    if (nodes) {
+        delete nodes;
+    }
+    timer.release();
+    if (cmdcookie) {
+        cmdcookie->ignore_errors = 1;
+    }
+}
+
+void
+CccpProvider::configure_nodes(const lcb::Hostlist& nodes_)
+{
+    nodes->assign(nodes_);
+    if (parent->settings->randomize_bootstrap_nodes) {
+        nodes->randomize();
+    }
+}
+
+void
+CccpProvider::config_updated(lcbvb_CONFIG *vbc)
+{
+    lcbvb_SVCMODE mode;
+    if (LCBVB_NSERVERS(vbc) < 1) {
+        return;
+    }
+
+    nodes->clear();
+    if (settings().sslopts & LCB_SSL_ENABLED) {
+        mode = LCBVB_SVCMODE_SSL;
+    } else {
+        mode = LCBVB_SVCMODE_PLAIN;
+    }
+    for (size_t ii = 0; ii < LCBVB_NSERVERS(vbc); ii++) {
+        const char *mcaddr = lcbvb_get_hostport(vbc,
+            ii, LCBVB_SVCTYPE_DATA, mode);
+        if (!mcaddr) {
+            lcb_log(LOGARGS(this, DEBUG), "Node %lu has no data service", ii);
+            continue;
+        }
+        nodes->add(mcaddr, LCB_CONFIG_MCD_PORT);
+    }
+
+    if (settings().randomize_bootstrap_nodes) {
+        nodes->randomize();
+    }
+}
+
+static void
+io_error_handler(lcbio_CTX *ctx, lcb_error_t err)
+{
+    CccpProvider *cccp = reinterpret_cast<CccpProvider*>(lcbio_ctx_data(ctx));
+    cccp->mcio_error(err);
+}
+
+static void io_read_handler(lcbio_CTX *ioctx, unsigned) {
+    reinterpret_cast<CccpProvider*>(lcbio_ctx_data(ioctx))->on_io_read();
+}
+
+void
+CccpProvider::on_io_read()
+{
+    unsigned required;
+
+#define return_error(e) \
+    resp.release(ioctx); \
+    mcio_error(e); \
+    return
+
+    lcb::MemcachedResponse resp;
+    if (!resp.load(ioctx, &required)) {
+        lcbio_ctx_rwant(ioctx, required);
+        lcbio_ctx_schedule(ioctx);
+        return;
+    }
+
+    if (resp.status() != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+        lcb_log(LOGARGS(this, WARN), LOGFMT "CCCP Packet responded with 0x%x; nkey=%d, nbytes=%lu, cmd=0x%x, seq=0x%x", LOGID(this),
+                resp.status(), resp.keylen(), (unsigned long)resp.bodylen(),
+                resp.opcode(), resp.opaque());
+
+        switch (resp.status()) {
+        case PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED:
+        case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+            return_error(LCB_NOT_SUPPORTED);
+        default:
+            return_error(LCB_PROTOCOL_ERROR);
+        }
+
+        return;
+    }
+
+    if (!resp.bodylen()) {
+        return_error(LCB_PROTOCOL_ERROR);
+    }
+
+    std::string jsonstr(resp.body<const char*>(), resp.bodylen());
+    std::string hoststr(lcbio_get_host(lcbio_ctx_sock(ioctx))->host);
+
+    resp.release(ioctx);
+    release_socket(true);
+
+    lcb_error_t err = update(hoststr.c_str(), jsonstr.c_str());
+
+    if (err == LCB_SUCCESS) {
+        timer.cancel();
+        server_active = false;
+    } else {
+        schedule_next_request(LCB_PROTOCOL_ERROR, 0);
+    }
+
+#undef return_error
+}
+
+void CccpProvider::request_config()
+{
+    lcb::MemcachedRequest req(PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG);
+    req.opaque(0xF00D);
+    lcbio_ctx_put(ioctx, req.data(), req.size());
+    lcbio_ctx_rwant(ioctx, 24);
+    lcbio_ctx_schedule(ioctx);
+    timer.rearm(settings().config_node_timeout);
+}
+
+void CccpProvider::dump(FILE *fp) const {
+    if (!enabled) {
+        return;
+    }
+
+    fprintf(fp, "## BEGIN CCCP PROVIDER DUMP ##\n");
+    fprintf(fp, "TIMER ACTIVE: %s\n", timer.is_armed() ? "YES" : "NO");
+    fprintf(fp, "PIPELINE RESPONSE COOKIE: %p\n", (void*)cmdcookie);
+    if (ioctx) {
+        fprintf(fp, "CCCP Owns connection:\n");
+        lcbio_ctx_dump(ioctx, fp);
+    } else if (creq.u.p_generic) {
+        fprintf(fp, "CCCP Is connecting\n");
+    } else {
+        fprintf(fp, "CCCP does not have a dedicated connection\n");
+    }
+
+    for (size_t ii = 0; ii < nodes->size(); ii++) {
+        const lcb_host_t &curhost = (*nodes)[ii];
+        fprintf(fp, "CCCP NODE: %s:%s\n", curhost.host, curhost.port);
+    }
+    fprintf(fp, "## END CCCP PROVIDER DUMP ##\n");
+}
+
+CccpProvider::CccpProvider(Confmon *mon)
+    : Provider(mon, CLCONFIG_CCCP),
+      nodes(new lcb::Hostlist()),
+      config(NULL),
+      server_active(false),
+      timer(mon->iot, this),
+      instance(NULL),
+      ioctx(NULL),
+      cmdcookie(NULL) {
+    std::memset(&creq, 0, sizeof creq);
+}
+
+Provider* lcb::clconfig::new_cccp_provider(Confmon *mon) {
+    return new CccpProvider(mon);
+}