libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/http/http_io.cc

@@ -30,19 +30,13 @@ using namespace lcb::http;
 #define LOGARGS(req, lvl) req->instance->settings, "http-io", LCB_LOG_##lvl, __FILE__, __LINE__
 
 void
-Request::assign_response_headers(const lcbht_RESPONSE *resp)
+Request::assign_response_headers(const lcb::htparse::Response& resp)
 {
-    response_headers.clear();
+    response_headers.assign(resp.headers.begin(), resp.headers.end());
     response_headers_clist.clear();
 
-    sllist_node *curnode;
-    SLLIST_ITERBASIC(&resp->headers, curnode) {
-        lcbht_MIMEHDR *hdr = SLLIST_ITEM(curnode, lcbht_MIMEHDR, slnode);
-        response_headers.push_back(Header(hdr->key, hdr->value));
-    }
-
-    std::vector<Header>::const_iterator ii = response_headers.begin();
-    for (; ii != response_headers.end(); ++ii) {
+    std::vector<lcb::htparse::MimeHeader>::const_iterator ii;
+    for (ii = response_headers.begin(); ii != response_headers.end(); ++ii) {
         response_headers_clist.push_back(ii->key.c_str());
         response_headers_clist.push_back(ii->value.c_str());
     }
@@ -53,29 +47,30 @@ int
 Request::handle_parse_chunked(const char *buf, unsigned nbuf)
 {
     int parse_state, oldstate, diff;
-    lcbht_RESPONSE *res = lcbht_get_response(parser);
+    using lcb::htparse::Parser;
+    lcb::htparse::Response& res = parser->get_cur_response();
 
     do {
         const char *rbody;
         unsigned nused = -1, nbody = -1;
-        oldstate = res->state;
+        oldstate = res.state;
 
-        parse_state = lcbht_parse_ex(parser, buf, nbuf, &nused, &nbody, &rbody);
+        parse_state = parser->parse_ex(buf, nbuf, &nused, &nbody, &rbody);
         diff = oldstate ^ parse_state;
 
         /* Got headers now for the first time */
-        if (diff & LCBHT_S_HEADER) {
+        if (diff & Parser::S_HEADER) {
             assign_response_headers(res);
-            if (res->status >=  300 && res->status <= 400) {
-                const char *redir = lcbht_get_resphdr(res, "Location");
+            if (res.status >=  300 && res.status <= 400) {
+                const char *redir = res.get_header_value("Location");
                 if (redir != NULL) {
                     pending_redirect.assign(redir);
-                    return LCBHT_S_DONE;
+                    return Parser::S_DONE;
                 }
             }
         }
 
-        if (parse_state & LCBHT_S_ERROR) {
+        if (parse_state & Parser::S_ERROR) {
             /* nothing to do here */
             return parse_state;
         }
@@ -91,22 +86,22 @@ Request::handle_parse_chunked(const char *buf, unsigned nbuf)
                 callback(instance, LCB_CALLBACK_HTTP, (const lcb_RESPBASE *)&htresp);
 
             } else {
-                lcb_string_append(&res->body, rbody, nbody);
+                res.body.append(rbody, nbody);
             }
         }
 
         buf += nused;
         nbuf -= nused;
-    } while ((parse_state & LCBHT_S_DONE) == 0 && is_ongoing() && nbuf);
+    } while ((parse_state & Parser::S_DONE) == 0 && is_ongoing() && nbuf);
 
-    if ( (parse_state & LCBHT_S_DONE) && is_ongoing()) {
+    if ( (parse_state & Parser::S_DONE) && is_ongoing()) {
         lcb_RESPHTTP resp = { 0 };
         if (chunked) {
             buf = NULL;
             nbuf = 0;
         } else {
-            buf = res->body.base;
-            nbuf = res->body.nused;
+            buf = res.body.c_str();
+            nbuf = res.body.size();
         }
 
         init_resp(&resp);
@@ -143,7 +138,8 @@ io_read(lcbio_CTX *ctx, unsigned nr)
         nbuf = lcbio_ctx_risize(&iter);
         parse_state = req->handle_parse_chunked(buf, nbuf);
 
-        if ((parse_state & LCBHT_S_ERROR) || req->has_pending_redirect()) {
+        if ((parse_state & lcb::htparse::Parser::S_ERROR) ||
+                req->has_pending_redirect()) {
             rv = -1;
             break;
         } else if (!req->is_ongoing()) {
@@ -156,7 +152,7 @@ io_read(lcbio_CTX *ctx, unsigned nr)
         // parse error or redirect
         lcb_error_t err;
         if (req->has_pending_redirect()) {
-            lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE);
+            instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
             // Transfer control to redirect function()
             lcb_log(LOGARGS(req, DEBUG), LOGFMT "Attempting redirect to %s", LOGID(req), req->pending_redirect.c_str());
             req->redirect();
@@ -297,7 +293,7 @@ Request::close_io()
     int can_ka;
 
     if (parser && is_data_request()) {
-        can_ka = lcbht_can_keepalive(parser);
+        can_ka = parser->can_keepalive();
     } else {
         can_ka = 0;
     }

data/ext/libcouchbase/src/instance.cc

@@ -116,17 +116,57 @@ lcb_st::populate_nodes(const Connspec& spec)
     }
 }
 
+lcb_error_t
+lcb_st::process_dns_srv(Connspec& spec)
+{
+    if (!spec.can_dnssrv()) {
+        return LCB_SUCCESS;
+    }
+    if (spec.hosts().empty()) {
+        lcb_log(LOGARGS(this, ERR), "Cannot use DNS SRV without a hostname");
+        return spec.is_explicit_dnssrv() ? LCB_EINVAL : LCB_SUCCESS;
+    }
+
+    const Spechost& host = spec.hosts().front();
+    lcb_error_t rc = LCB_ERROR;
+    Hostlist* hl = lcb_dnssrv_getbslist(host.hostname.c_str(), host.isSSL(), &rc);
+
+    if (hl == NULL) {
+        lcb_log(LOGARGS(this, INFO), "DNS SRV lookup failed: %s. Ignore this if not relying on DNS SRV records", lcb_strerror(this, rc));
+        if (spec.is_explicit_dnssrv()) {
+            return rc;
+        } else {
+            return LCB_SUCCESS;
+        }
+    }
+
+    spec.clear_hosts();
+    for (size_t ii = 0; ii < hl->size(); ++ii) {
+        const lcb_host_t& src = (*hl)[ii];
+        Spechost sh;
+        sh.hostname = src.host;
+        sh.port = std::atoi(src.port);
+        sh.type = spec.default_port();
+        spec.add_host(sh);
+        lcb_log(LOGARGS(this, INFO), "Found host %s:%d via DNS SRV", sh.hostname.c_str(), sh.port);
+    }
+    delete hl;
+
+    return LCB_SUCCESS;
+}
+
 static lcb_error_t
 init_providers(lcb_t obj, const Connspec &spec)
 {
-    clconfig_provider *http, *cccp, *mcraw;
-    http = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_HTTP);
-    cccp = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_CCCP);
-    mcraw = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_MCRAW);
+    using namespace lcb::clconfig;
+    Provider *http, *cccp, *mcraw;
+    http = obj->confmon->get_provider(CLCONFIG_HTTP);
+    cccp = obj->confmon->get_provider(CLCONFIG_CCCP);
+    mcraw = obj->confmon->get_provider(CLCONFIG_MCRAW);
 
     if (spec.default_port() == LCB_CONFIG_MCCOMPAT_PORT) {
-        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_MCRAW, 1);
-        mcraw->configure_nodes(mcraw, obj->mc_nodes);
+        obj->confmon->set_active(CLCONFIG_MCRAW, true);
+        mcraw->configure_nodes(*obj->mc_nodes);
         return LCB_SUCCESS;
     }
 
@@ -155,7 +195,7 @@ init_providers(lcb_t obj, const Connspec &spec)
         if (spec.is_bs_file()) {
             /* If the 'file_only' provider is set, just assume something else
              * will provide us with the config, and forget about it. */
-            clconfig_provider *prov = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_FILE);
+            Provider *prov = obj->confmon->get_provider(CLCONFIG_FILE);
             if (prov && prov->enabled) {
                 return LCB_SUCCESS;
             }
@@ -164,17 +204,17 @@ init_providers(lcb_t obj, const Connspec &spec)
     }
 
     if (http_enabled) {
-        lcb_clconfig_http_enable(http);
-        lcb_clconfig_http_set_nodes(http, obj->ht_nodes);
+        http->enable();
+        http->configure_nodes(*obj->ht_nodes);
     } else {
-        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_HTTP, 0);
+        obj->confmon->set_active(CLCONFIG_HTTP, false);
     }
 
     if (cccp_enabled && obj->type != LCB_TYPE_CLUSTER) {
-        lcb_clconfig_cccp_enable(cccp, obj);
-        lcb_clconfig_cccp_set_nodes(cccp, obj->mc_nodes);
+        cccp->enable(obj);
+        cccp->configure_nodes(*obj->mc_nodes);
     } else {
-        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_CCCP, 0);
+        obj->confmon->set_active(CLCONFIG_CCCP, false);
     }
     return LCB_SUCCESS;
 }
@@ -379,10 +419,10 @@ lcb_error_t lcb_create(lcb_t *instance,
     obj->memd_sockpool->tmoidle = 10000000;
     obj->http_sockpool->maxidle = 1;
     obj->http_sockpool->tmoidle = 10000000;
-    obj->confmon = lcb_confmon_create(settings, obj->iotable);
+    obj->confmon = new clconfig::Confmon(settings, obj->iotable);
     obj->ht_nodes = new Hostlist();
     obj->mc_nodes = new Hostlist();
-    obj->retryq = lcb_retryq_new(&obj->cmdq, obj->iotable, obj->settings);
+    obj->retryq = new RetryQueue(&obj->cmdq, obj->iotable, obj->settings);
     obj->n1ql_cache = lcb_n1qlcache_create();
     lcb_initialize_packet_handlers(obj);
     lcb_aspend_init(&obj->pendops);
@@ -398,8 +438,15 @@ lcb_error_t lcb_create(lcb_t *instance,
         goto GT_DONE;
     }
 
+    if ((err = obj->process_dns_srv(spec)) != LCB_SUCCESS) {
+        goto GT_DONE;
+    }
+
     obj->populate_nodes(spec);
-    err = init_providers(obj, spec);
+    if ((err = init_providers(obj, spec)) != LCB_SUCCESS) {
+        goto GT_DONE;
+    }
+
     if (err != LCB_SUCCESS) {
         lcb_destroy(obj);
         return err;
@@ -433,6 +480,10 @@ sync_dtor_cb(void *arg)
     }
 }
 
+extern "C" {
+void lcbdur_destroy(void*);
+}
+
 LIBCOUCHBASE_API
 void lcb_destroy(lcb_t instance)
 {
@@ -442,10 +493,12 @@ void lcb_destroy(lcb_t instance)
     lcb_ASPEND_SETTYPE::iterator it;
     lcb_ASPEND_SETTYPE *pendq;
 
-    DESTROY(lcb_clconfig_decref, cur_configinfo);
+    if (instance->cur_configinfo) {
+        instance->cur_configinfo->decref();
+        instance->cur_configinfo = NULL;
+    }
     instance->cmdq.config = NULL;
-
-    lcb_bootstrap_destroy(instance);
+    DESTROY(delete, bs_state);
     DESTROY(delete, ht_nodes);
     DESTROY(delete, mc_nodes);
 
@@ -458,26 +511,25 @@ void lcb_destroy(lcb_t instance)
     if ((pendq = po->items[LCB_PENDTYPE_DURABILITY])) {
         std::vector<void*> dsets(pendq->begin(), pendq->end());
         for (size_t ii = 0; ii < dsets.size(); ++ii) {
-            lcbdur_destroy(reinterpret_cast<lcb_DURSET_st*>(dsets[ii]));
+            lcbdur_destroy(dsets[ii]);
         }
         pendq->clear();
     }
 
     for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
-        mc_SERVER *server = LCBT_GET_SERVER(instance, ii);
-        mcserver_close(server);
+        instance->get_server(ii)->close();
     }
 
     if ((pendq = po->items[LCB_PENDTYPE_HTTP])) {
         for (it = pendq->begin(); it != pendq->end(); ++it) {
-            lcb_http_request_t htreq = reinterpret_cast<lcb_http_request_t>(*it);
-            lcb_htreq_block_callback(htreq);
-            lcb_htreq_finish(instance, htreq, LCB_ERROR);
+            http::Request *htreq = reinterpret_cast<http::Request*>(*it);
+            htreq->block_callback();
+            htreq->finish(LCB_ERROR);
         }
     }
 
-    DESTROY(lcb_retryq_destroy, retryq);
-    DESTROY(lcb_confmon_destroy, confmon);
+    DESTROY(delete, retryq);
+    DESTROY(delete, confmon);
     DESTROY(lcbio_mgr_destroy, memd_sockpool);
     DESTROY(lcbio_mgr_destroy, http_sockpool);
     DESTROY(lcb_vbguess_destroy, vbguess);
@@ -531,10 +583,23 @@ lcb_destroy_async(lcb_t instance, const void *arg)
     lcbio_async_signal(instance->dtor_timer);
 }
 
+lcb::Server *
+lcb_st::find_server(const lcb_host_t& host) const
+{
+    unsigned ii;
+    for (ii = 0; ii < cmdq.npipelines; ii++) {
+        lcb::Server *server = static_cast<lcb::Server*>(cmdq.pipelines[ii]);
+        if (lcb_host_equals(&server->get_host(), &host)) {
+            return server;
+        }
+    }
+    return NULL;
+}
+
 LIBCOUCHBASE_API
 lcb_error_t lcb_connect(lcb_t instance)
 {
-    lcb_error_t err = lcb_bootstrap_common(instance, LCB_BS_REFRESH_INITIAL);
+    lcb_error_t err = instance->bootstrap(BS_REFRESH_INITIAL);
     if (err == LCB_SUCCESS) {
         SYNCMODE_INTERCEPT(instance);
     } else {
@@ -715,6 +780,15 @@ const char *lcb_strerror(lcb_t instance, lcb_error_t error)
     return "Unknown error";
 }
 
+LCB_INTERNAL_API
+const char *lcb_strerror_short(lcb_error_t error)
+{
+#define X(c, v, t, s) if (error == c) { return #c " (" #v ")"; }
+    LCB_XERR(X)
+#undef X
+    return "<FIXME: Not an LCB error>";
+}
+
 LIBCOUCHBASE_API
 int lcb_get_errtype(lcb_error_t err)
 {

data/ext/libcouchbase/src/internal.h

@@ -56,12 +56,16 @@
 namespace lcb {
 class Connspec;
 struct Spechost;
+class RetryQueue;
+class Bootstrap;
+namespace clconfig {
+struct Confmon;
+class ConfigInfo;
+}
 }
 extern "C" {
 #endif
 
-struct lcb_string_st;
-
 struct lcb_callback_st {
     lcb_RESPCALLBACK v3callbacks[LCB_CALLBACK__MAX];
     lcb_get_callback get;
@@ -86,25 +90,31 @@ struct lcb_callback_st {
     lcb_pktflushed_callback pktflushed;
 };
 
-struct lcb_confmon_st;
-struct lcb_BOOTSTRAP;
 struct lcb_GUESSVB_st;
 
 #ifdef __cplusplus
 #include <string>
 typedef std::string* lcb_pSCRATCHBUF;
+typedef lcb::RetryQueue lcb_RETRYQ;
+typedef lcb::clconfig::Confmon* lcb_pCONFMON;
+typedef lcb::clconfig::ConfigInfo *lcb_pCONFIGINFO;
+typedef lcb::Bootstrap lcb_BOOTSTRAP;
 #else
 typedef struct lcb_SCRATCHBUF* lcb_pSCRATCHBUF;
+typedef struct lcb_RETRYQ_st lcb_RETRYQ;
+typedef struct lcb_CONFMON_st* lcb_pCONFMON;
+typedef struct lcb_CONFIGINFO_st* lcb_pCONFIGINFO;
+typedef struct lcb_BOOTSTRAP_st lcb_BOOTSTRAP;
 #endif
 
 struct lcb_st {
     mc_CMDQUEUE cmdq; /**< Base command queue object */
     const void *cookie; /**< User defined pointer */
-    struct lcb_confmon_st *confmon; /**< Cluster config manager */
+    lcb_pCONFMON confmon; /**< Cluster config manager */
     hostlist_t mc_nodes; /**< List of current memcached endpoints */
     hostlist_t ht_nodes; /**< List of current management endpoints */
-    struct clconfig_info_st *cur_configinfo; /**< Pointer to current config */
-    struct lcb_BOOTSTRAP *bootstrap; /**< Bootstrapping state */
+    lcb_pCONFIGINFO cur_configinfo; /**< Pointer to current config */
+    lcb_BOOTSTRAP *bs_state; /**< Bootstrapping state */
     struct lcb_callback_st callbacks; /**< Callback table */
     lcb_HISTOGRAM *kv_timings; /**< Histogram object (for timing) */
     lcb_ASPEND pendops; /**< Pending asynchronous requests */
@@ -127,7 +137,34 @@ struct lcb_st {
     lcbio_pTABLE getIOT() { return iotable; }
     inline void add_bs_host(const char *host, int port, unsigned bstype);
     inline void add_bs_host(const lcb::Spechost& host, int defl_http, int defl_cccp);
+    inline lcb_error_t process_dns_srv(lcb::Connspec& spec);
     inline void populate_nodes(const lcb::Connspec&);
+    lcb::Server *get_server(size_t index) const {
+        return static_cast<lcb::Server*>(cmdq.pipelines[index]);
+    }
+    lcb::Server *find_server(const lcb_host_t& host) const;
+    lcb_error_t request_config(const void *cookie, lcb::Server* server);
+
+    /**
+     * @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.
+     *
+     * This should be a combination of one or more @ref lcb::BootstrapOptions
+     *
+     * Note, the definition for this function (and the flags)
+     * are found in bootstrap.cc
+     */
+    inline lcb_error_t bootstrap(unsigned options) {
+        if (!bs_state) {
+            bs_state = new lcb::Bootstrap(this);
+        }
+        return bs_state->bootstrap(options);
+    }
     #endif
 };
 
@@ -135,7 +172,7 @@ struct lcb_st {
 #define LCBT_NSERVERS(instance) (instance)->cmdq.npipelines
 #define LCBT_NDATASERVERS(instance) LCBVB_NDATASERVERS(LCBT_VBCONFIG(instance))
 #define LCBT_NREPLICAS(instance) LCBVB_NREPLICAS(LCBT_VBCONFIG(instance))
-#define LCBT_GET_SERVER(instance, ix) (mc_SERVER *)(instance)->cmdq.pipelines[ix]
+#define LCBT_GET_SERVER(instance, ix) (instance)->cmdq.pipelines[ix]
 #define LCBT_SETTING(instance, name) (instance)->settings->name
 
 void lcb_initialize_packet_handlers(lcb_t instance);
@@ -143,18 +180,13 @@ void lcb_initialize_packet_handlers(lcb_t instance);
 LCB_INTERNAL_API
 void lcb_maybe_breakout(lcb_t instance);
 
-struct clconfig_info_st;
-void lcb_update_vbconfig(lcb_t instance, struct clconfig_info_st *config);
+void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config);
 /**
  * Hashtable wrappers
  */
 genhash_t *lcb_hashtable_nc_new(lcb_size_t est);
 genhash_t *lcb_hashtable_szt_new(lcb_size_t est);
 
-struct lcb_DURSET_st;
-void lcbdur_destroy(struct lcb_DURSET_st *dset);
-void lcbdur_maybe_schedfail(struct lcb_DURSET_st *dset);
-
 lcb_error_t lcb_iops_cntl_handler(int mode, lcb_t instance, int cmd, void *arg);
 
 /**
@@ -184,22 +216,8 @@ lcb_error_t lcb_init_providers2(lcb_t obj,
                                const struct lcb_create_st2 *e_options);
 lcb_error_t lcb_reinit3(lcb_t obj, const char *connstr);
 
-
-LCB_INTERNAL_API
-mc_SERVER *
-lcb_find_server_by_host(lcb_t instance, const lcb_host_t *host);
-
-
-LCB_INTERNAL_API
-mc_SERVER *
-lcb_find_server_by_index(lcb_t instance, int ix);
-
-LCB_INTERNAL_API
-lcb_error_t
-lcb_getconfig(lcb_t instance, const void *cookie, mc_SERVER *server);
-
 int
-lcb_should_retry(lcb_settings *settings, mc_PACKET *pkt, lcb_error_t err);
+lcb_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_error_t err);
 
 lcb_error_t
 lcb__synchandler_return(lcb_t instance);