libcouchbase 0.3.3 → 1.0.0

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,49 @@ 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.
+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;
+    }
+
+    /**
+     * Try to start/stop background polling depending on whether we're able to.
      */
-    clconfig_listener listener;
+    void check_bgpoll();
+
+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();
+    void bgpoll();
 
     lcb_t parent;
 
@@ -49,7 +76,10 @@ 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;
+
+    /**Timer used for periodic polling of config */
+    lcb::io::Timer<Bootstrap, &Bootstrap::bgpoll> tmpoll;
 
     /**
      * Timestamp indicating the most recent configuration activity. This
@@ -73,57 +103,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

@@ -24,46 +24,74 @@
 #include "internal.h"
 #include "clconfig.h"
 #include "packetutils.h"
-#include "simplestring.h"
 #include <mcserver/negotiate.h>
 #include <lcbio/lcbio.h>
-#include <lcbio/timer-ng.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)
 
-#define PROVIDER_SETTING_T(fld) PROVIDER_SETTING(this, fld)
-
 struct CccpCookie;
 
-struct CccpProvider : public clconfig_provider {
-    CccpProvider(lcb_confmon *);
+using namespace lcb::clconfig;
+
+struct CccpProvider : public Provider {
+    CccpProvider(Confmon *);
     ~CccpProvider();
 
-    void release_socket(bool can_reuse);
+    /**
+     * Stops the current request.
+     * @param is_clean Whether the state of the current request is 'clean',
+     *        i.e. whether we are stopping because of an error condition, or
+     *        because we have received a successful response.
+     */
+    void stop_current_request(bool is_clean);
     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_config_updated(lcbvb_CONFIG *vbc);
     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();
+    }
+
+    // Whether there is a pending CCCP config request.
+    bool has_pending_request() const {
+        return creq != NULL || cmdcookie != NULL || ioctx != NULL;
+    }
+
     lcb::Hostlist *nodes;
-    clconfig_info *config;
-    bool server_active;
-    lcbio_pTIMER timer;
+    ConfigInfo *config;
+    lcb::io::Timer<CccpProvider, &CccpProvider::on_timeout> timer;
     lcb_t instance;
-    lcbio_CONNREQ creq;
+    lcb::io::ConnectionRequest *creq;
     lcbio_CTX *ioctx;
     CccpCookie *cmdcookie;
 };
 
 struct CccpCookie {
     CccpProvider *parent;
-    bool ignore_errors;
-    CccpCookie(CccpProvider *parent_) : parent(parent_), ignore_errors(false) {
+    bool active;
+    CccpCookie(CccpProvider *parent_) : parent(parent_), active(true) {
     }
 };
 
@@ -77,25 +105,24 @@ 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);
+        lcb::io::Pool::put(sock);
     } else {
-        lcbio_mgr_discard(sock);
+        lcb::io::Pool::discard(sock);
     }
 }
 
 void
-CccpProvider::release_socket(bool can_reuse)
+CccpProvider::stop_current_request(bool is_clean)
 {
     if (cmdcookie) {
-        cmdcookie->ignore_errors = 1;
+        cmdcookie->active = false;
         cmdcookie =  NULL;
-        return;
     }
 
-    lcbio_connreq_cancel(&creq);
+    lcb::io::ConnectionRequest::cancel(&creq);
 
     if (ioctx) {
-        lcbio_ctx_close(ioctx, pooled_close_cb, &can_reuse);
+        lcbio_ctx_close(ioctx, pooled_close_cb, &is_clean);
         ioctx = NULL;
     }
 }
@@ -103,35 +130,28 @@ CccpProvider::release_socket(bool can_reuse)
 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) {
-        lcbio_timer_disarm(timer);
-        lcb_confmon_provider_failed(this, err);
-        server_active = false;
+        timer.cancel();
+        parent->provider_failed(this, err);
         return err;
     }
 
-    server = lcb_find_server_by_host(instance, next_host);
+    lcb::Server* server = instance->find_server(*next_host);
     if (server) {
-        CccpCookie *cookie = new CccpCookie(this);
-        cmdcookie = cookie;
+        cmdcookie = new CccpCookie(this);
         lcb_log(LOGARGS(this, INFO), "Re-Issuing CCCP Command on server struct %p (%s:%s)", (void*)server, next_host->host, next_host->port);
-        lcbio_timer_rearm(timer, PROVIDER_SETTING_T(config_node_timeout));
-        return lcb_getconfig(instance, cookie, server);
+        timer.rearm(settings().config_node_timeout);
+        instance->request_config(cmdcookie, 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,
-                PROVIDER_SETTING_T(config_node_timeout),
-                on_connected, this);
-        LCBIO_CONNREQ_MKPOOLED(&creq, preq);
+        creq = instance->memd_sockpool->get(*next_host,
+            settings().config_node_timeout,
+            on_connected, this);
     }
 
-    server_active = true;
     return LCB_SUCCESS;
 }
 
@@ -139,42 +159,25 @@ 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 "Got I/O Error=0x%x", LOGID(this), err);
+        lcb_log(LOGARGS(this, ERR), LOGFMT "Could not get configuration: %s", LOGID(this), lcb_strerror_short(err));
     }
 
-    release_socket(err == LCB_NOT_SUPPORTED);
+    stop_current_request(err == LCB_NOT_SUPPORTED);
     return schedule_next_request(err, false);
 }
 
-static void socket_timeout(void *arg) {
-    reinterpret_cast<CccpProvider*>(arg)->mcio_error(LCB_ETIMEDOUT);
-}
-
-void lcb_clconfig_cccp_enable(clconfig_provider *pb, lcb_t instance)
-{
-    CccpProvider *cccp = static_cast<CccpProvider*>(pb);
-    lcb_assert(pb->type == LCB_CLCONFIG_CCCP);
-    cccp->instance = instance;
-    pb->enabled = true;
-}
-
-static hostlist_t get_nodes(const clconfig_provider *pb) {
-    return static_cast<const CccpProvider*>(pb)->nodes;
-}
-
 /** Update the configuration from a server. */
 lcb_error_t
-lcb_cccp_update(clconfig_provider *provider, const char *host, const char *data) {
+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;
-    clconfig_info *new_config;
+    ConfigInfo *new_config;
     vbc = lcbvb_create();
 
     if (!vbc) {
@@ -190,7 +193,7 @@ CccpProvider::update(const char *host, const char *data)
     }
 
     lcbvb_replace_host(vbc, host);
-    new_config = lcb_clconfig_create(vbc, LCB_CLCONFIG_CCCP);
+    new_config = ConfigInfo::create(vbc, CLCONFIG_CCCP);
 
     if (!new_config) {
         lcbvb_destroy(vbc);
@@ -198,38 +201,38 @@ CccpProvider::update(const char *host, const char *data)
     }
 
     if (config) {
-        lcb_clconfig_decref(config);
+        config->decref();
     }
 
     /** TODO: Figure out the comparison vector */
-    new_config->cmpclock = gethrtime();
     config = new_config;
-    lcb_confmon_provider_success(this, new_config);
+    parent->provider_got_config(this, new_config);
     return LCB_SUCCESS;
 }
 
-void lcb_cccp_update2(const void *cookie, lcb_error_t err,
-                      const void *bytes, lcb_size_t nbytes,
-                      const lcb_host_t *origin)
+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;
+    CccpCookie *cookie = reinterpret_cast<CccpCookie*>(const_cast<void*>(cookie_));
+    CccpProvider *cccp = cookie->parent;
 
-    if (ck == cccp->cmdcookie) {
-        lcbio_timer_disarm(cccp->timer);
+    bool was_active = cookie->active;
+    if (cookie->active) {
+        cookie->active = false;
+        cccp->timer.cancel();
         cccp->cmdcookie = NULL;
     }
+    delete cookie;
 
     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) {
+    if (err != LCB_SUCCESS && was_active) {
         cccp->mcio_error(err);
     }
-
-    free(ck);
 }
 
 static void
@@ -238,21 +241,20 @@ 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;
+    cccp->creq = NULL;
 
-    LCBIO_CONNREQ_CLEAR(&cccp->creq);
     if (err != LCB_SUCCESS) {
         if (sock) {
-            lcbio_mgr_discard(sock);
+            lcb::io::Pool::discard(sock);
         }
         cccp->mcio_error(err);
         return;
     }
 
     if (lcbio_protoctx_get(sock, LCBIO_PROTOCTX_SESSINFO) == NULL) {
-        lcb::SessionRequest *sreq = lcb::SessionRequest::start(
+        cccp->creq = lcb::SessionRequest::start(
                 sock, settings, settings->config_node_timeout, on_connected,
                 cccp);
-        LCBIO_CONNREQ_MKGENERIC(&cccp->creq, sreq, lcb::sessreq_cancel);
         return;
     }
 
@@ -263,70 +265,49 @@ on_connected(lcbio_SOCKET *sock, void *data, lcb_error_t err, lcbio_OSERR)
     cccp->request_config();
 }
 
-static lcb_error_t cccp_get(clconfig_provider *pb)
-{
-    CccpProvider *cccp = static_cast<CccpProvider *>(pb);
-    if (cccp->creq.u.p_generic || cccp->server_active || cccp->cmdcookie) {
+lcb_error_t CccpProvider::refresh() {
+    if (has_pending_request()) {
         return LCB_BUSY;
     }
 
-    return cccp->schedule_next_request(LCB_SUCCESS, true);
-}
-
-static clconfig_info *cccp_get_cached(clconfig_provider *pb) {
-    return static_cast<CccpProvider *>(pb)->config;
+    return schedule_next_request(LCB_SUCCESS, true);
 }
 
-static lcb_error_t cccp_pause(clconfig_provider *pb)
+bool
+CccpProvider::pause()
 {
-    CccpProvider *cccp = static_cast<CccpProvider *>(pb);
-    if (!cccp->server_active) {
-        return LCB_SUCCESS;
+    if (!has_pending_request()) {
+        return true;
     }
 
-    cccp->server_active = 0;
-    cccp->release_socket(false);
-    lcbio_timer_disarm(cccp->timer);
-    return LCB_SUCCESS;
-}
-
-static void cccp_cleanup(clconfig_provider *pb) {
-    delete static_cast<CccpProvider*>(pb);
+    stop_current_request(false);
+    timer.cancel();
+    return true;
 }
 
 CccpProvider::~CccpProvider() {
-    release_socket(false);
+    stop_current_request(false);
 
     if (config) {
-        lcb_clconfig_decref(config);
+        config->decref();
     }
     if (nodes) {
         delete nodes;
     }
-    if (timer) {
-        lcbio_timer_destroy(timer);
-    }
-    if (cmdcookie) {
-        cmdcookie->ignore_errors = 1;
-    }
+    timer.release();
 }
 
-static void
-configure_nodes(clconfig_provider *pb, const hostlist_t nodes)
+void
+CccpProvider::configure_nodes(const lcb::Hostlist& nodes_)
 {
-    CccpProvider *cccp = static_cast<CccpProvider *>(pb);
-    cccp->nodes->assign(*nodes);
-    if (PROVIDER_SETTING(pb, randomize_bootstrap_nodes)) {
-        cccp->nodes->randomize();
+    nodes->assign(nodes_);
+    if (parent->settings->randomize_bootstrap_nodes) {
+        nodes->randomize();
     }
 }
 
-static void config_updated(clconfig_provider *provider, lcbvb_CONFIG* vbc) {
-    static_cast<CccpProvider*>(provider)->on_config_updated(vbc);
-}
-
 void
-CccpProvider::on_config_updated(lcbvb_CONFIG *vbc)
+CccpProvider::config_updated(lcbvb_CONFIG *vbc)
 {
     lcbvb_SVCMODE mode;
     if (LCBVB_NSERVERS(vbc) < 1) {
@@ -334,7 +315,7 @@ CccpProvider::on_config_updated(lcbvb_CONFIG *vbc)
     }
 
     nodes->clear();
-    if (PROVIDER_SETTING_T(sslopts) & LCB_SSL_ENABLED) {
+    if (settings().sslopts & LCB_SSL_ENABLED) {
         mode = LCBVB_SVCMODE_SSL;
     } else {
         mode = LCBVB_SVCMODE_PLAIN;
@@ -349,7 +330,7 @@ CccpProvider::on_config_updated(lcbvb_CONFIG *vbc)
         nodes->add(mcaddr, LCB_CONFIG_MCD_PORT);
     }
 
-    if (PROVIDER_SETTING_T(randomize_bootstrap_nodes)) {
+    if (settings().randomize_bootstrap_nodes) {
         nodes->randomize();
     }
 }
@@ -406,13 +387,12 @@ CccpProvider::on_io_read()
     std::string hoststr(lcbio_get_host(lcbio_ctx_sock(ioctx))->host);
 
     resp.release(ioctx);
-    release_socket(true);
+    stop_current_request(true);
 
     lcb_error_t err = update(hoststr.c_str(), jsonstr.c_str());
 
     if (err == LCB_SUCCESS) {
-        lcbio_timer_disarm(timer);
-        server_active = false;
+        timer.cancel();
     } else {
         schedule_next_request(LCB_PROTOCOL_ERROR, 0);
     }
@@ -427,62 +407,44 @@ void CccpProvider::request_config()
     lcbio_ctx_put(ioctx, req.data(), req.size());
     lcbio_ctx_rwant(ioctx, 24);
     lcbio_ctx_schedule(ioctx);
-    lcbio_timer_rearm(timer, PROVIDER_SETTING(this, config_node_timeout));
+    timer.rearm(settings().config_node_timeout);
 }
 
-static void do_dump(clconfig_provider *pb, FILE *fp)
-{
-    CccpProvider *cccp = (CccpProvider *)pb;
-
-    if (!cccp->enabled) {
+void CccpProvider::dump(FILE *fp) const {
+    if (!enabled) {
         return;
     }
 
     fprintf(fp, "## BEGIN CCCP PROVIDER DUMP ##\n");
-    fprintf(fp, "TIMER ACTIVE: %s\n", lcbio_timer_armed(cccp->timer) ? "YES" : "NO");
-    fprintf(fp, "PIPELINE RESPONSE COOKIE: %p\n", (void*)cccp->cmdcookie);
-    if (cccp->ioctx) {
+    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(cccp->ioctx, fp);
-    } else if (cccp->creq.u.p_generic) {
+        lcbio_ctx_dump(ioctx, fp);
+    } else if (creq) {
         fprintf(fp, "CCCP Is connecting\n");
     } else {
         fprintf(fp, "CCCP does not have a dedicated connection\n");
     }
 
-    for (size_t ii = 0; ii < cccp->nodes->size(); ii++) {
-        const lcb_host_t &curhost = (*cccp->nodes)[ii];
+    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");
 }
 
-clconfig_provider * lcb_clconfig_create_cccp(lcb_confmon *mon)
-{
-    return new CccpProvider(mon);
-}
-
-CccpProvider::CccpProvider(lcb_confmon *mon)
-    : nodes(new lcb::Hostlist()),
+CccpProvider::CccpProvider(Confmon *mon)
+    : Provider(mon, CLCONFIG_CCCP),
+      nodes(new lcb::Hostlist()),
       config(NULL),
-      server_active(false),
-      timer(NULL),
+      timer(mon->iot, this),
       instance(NULL),
       ioctx(NULL),
-      cmdcookie(NULL)
-{
-    clconfig_provider::type = LCB_CLCONFIG_CCCP;
-    clconfig_provider::refresh = cccp_get;
-    clconfig_provider::get_cached = cccp_get_cached;
-    clconfig_provider::pause = cccp_pause;
-    clconfig_provider::shutdown = cccp_cleanup;
-    clconfig_provider::config_updated = ::config_updated;
-    clconfig_provider::configure_nodes = ::configure_nodes;
-    clconfig_provider::get_nodes = ::get_nodes;
-    clconfig_provider::dump = do_dump;
-    clconfig_provider::parent = mon;
-    clconfig_provider::enabled = 0;
-
-    timer = lcbio_timer_new(mon->iot, this, socket_timeout);
+      cmdcookie(NULL) {
     std::memset(&creq, 0, sizeof creq);
 }
+
+Provider* lcb::clconfig::new_cccp_provider(Confmon *mon) {
+    return new CccpProvider(mon);
+}