libcouchbase 0.2.0 → 0.3.1

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

@@ -43,7 +43,7 @@ Request::decref()
     close_io();
 
     if (parser) {
-        delete parser;
+        lcbht_free(parser);
     }
 
     if (timer) {
@@ -103,6 +103,7 @@ void
 Request::maybe_refresh_config(lcb_error_t err)
 {
     int htstatus_ok;
+    lcbht_RESPONSE *resp;
     if (!parser) {
         return;
     }
@@ -111,25 +112,25 @@ Request::maybe_refresh_config(lcb_error_t err)
         return;
     }
 
-    const lcb::htparse::Response& resp = parser->get_cur_response();
-    htstatus_ok = resp.status >= 200 && resp.status < 299;
+    resp = lcbht_get_response(parser);
+    htstatus_ok = resp->status >= 200 && resp->status < 299;
 
     if (err != LCB_SUCCESS && (err == LCB_ESOCKSHUTDOWN && htstatus_ok) == 0) {
         /* ignore graceful close */
-        instance->bootstrap(BS_REFRESH_ALWAYS);
+        lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
         return;
     }
 
     if (htstatus_ok) {
         return;
     }
-    instance->bootstrap(BS_REFRESH_ALWAYS);
+    lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
 }
 
 void
 Request::init_resp(lcb_RESPHTTP *res)
 {
-    const lcb::htparse::Response& htres = parser->get_cur_response();
+    const lcbht_RESPONSE *htres = lcbht_get_response(parser);
 
     res->cookie = const_cast<void*>(command_cookie);
     res->key = url.c_str() + url_info.field_data[UF_PATH].off;
@@ -138,7 +139,9 @@ Request::init_resp(lcb_RESPHTTP *res)
     if (!response_headers.empty()) {
         res->headers = &response_headers_clist[0];
     }
-    res->htstatus = htres.status;
+    if (htres) {
+        res->htstatus = htres->status;
+    }
 }
 
 void
@@ -251,9 +254,9 @@ Request::submit()
         // Only wipe old parser/response information if current I/O request
         // was a success
         if (parser) {
-            parser->reset();
+            lcbht_reset(parser);
         } else {
-            parser = new lcb::htparse::Parser(instance->settings);
+            parser = lcbht_new(instance->settings);
         }
         response_headers.clear();
         response_headers_clist.clear();
@@ -459,12 +462,7 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         return rc;
     }
 
-    std::string ua("libcouchbase/" LCB_VERSION_STRING);
-    if (instance->settings->client_string) {
-        ua.append(" ").append(instance->settings->client_string);
-    }
-    add_header("User-Agent", ua);
-
+    add_header("User-Agent", "libcouchbase/" LCB_VERSION_STRING);
     if (instance->http_sockpool->maxidle == 0 || !is_data_request()) {
         add_header("Connection", "close");
     }
@@ -615,6 +613,23 @@ Request::cancel()
     finish(LCB_SUCCESS);
 }
 
+// Wrappers
+void lcb_htreq_setcb(lcb_http_request_t req, lcb_RESPCALLBACK callback) {
+    req->callback = callback;
+}
+void lcb_htreq_block_callback(lcb_http_request_t req) {
+    req->block_callback();
+}
+void lcb_htreq_pause(lcb_http_request_t req) {
+    req->pause();
+}
+void lcb_htreq_resume(lcb_http_request_t req) {
+    req->resume();
+}
+void lcb_htreq_finish(lcb_t, lcb_http_request_t req, lcb_error_t rc) {
+    req->finish(rc);
+}
+
 LIBCOUCHBASE_API
 void
 lcb_cancel_http_request(lcb_t, lcb_http_request_t req)

data/ext/libcouchbase/src/http/http.h

@@ -1 +1,34 @@
-#include "http-priv.h"
+#ifndef LCB_HTTPAPI_H
+#define LCB_HTTPAPI_H
+
+/* This file contains the internal API for HTTP requests. This allows us to
+ * change the internals without exposing the object structure to the rest
+ * of the library
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void
+lcb_htreq_setcb(lcb_http_request_t, lcb_RESPCALLBACK);
+
+void
+lcb_htreq_pause(lcb_http_request_t);
+
+void
+lcb_htreq_resume(lcb_http_request_t);
+
+void
+lcb_htreq_finish(lcb_t, lcb_http_request_t, lcb_error_t);
+
+/* Prevents the callback from being invoked. This is different than a full
+ * destruction of the object. This is only called in lcb_destroy() to
+ * prevent dereferencing the instance itself.
+ */
+void
+lcb_htreq_block_callback(lcb_http_request_t);
+#ifdef __cplusplus
+}
+#endif
+#endif

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

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

data/ext/libcouchbase/src/instance.cc

@@ -116,57 +116,17 @@ 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 = 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)
 {
-    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);
+    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);
 
     if (spec.default_port() == LCB_CONFIG_MCCOMPAT_PORT) {
-        obj->confmon->set_active(CLCONFIG_MCRAW, true);
-        mcraw->configure_nodes(*obj->mc_nodes);
+        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_MCRAW, 1);
+        mcraw->configure_nodes(mcraw, obj->mc_nodes);
         return LCB_SUCCESS;
     }
 
@@ -195,7 +155,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. */
-            Provider *prov = obj->confmon->get_provider(CLCONFIG_FILE);
+            clconfig_provider *prov = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_FILE);
             if (prov && prov->enabled) {
                 return LCB_SUCCESS;
             }
@@ -204,17 +164,17 @@ init_providers(lcb_t obj, const Connspec &spec)
     }
 
     if (http_enabled) {
-        http->enable();
-        http->configure_nodes(*obj->ht_nodes);
+        lcb_clconfig_http_enable(http);
+        lcb_clconfig_http_set_nodes(http, obj->ht_nodes);
     } else {
-        obj->confmon->set_active(CLCONFIG_HTTP, false);
+        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_HTTP, 0);
     }
 
     if (cccp_enabled && obj->type != LCB_TYPE_CLUSTER) {
-        cccp->enable(obj);
-        cccp->configure_nodes(*obj->mc_nodes);
+        lcb_clconfig_cccp_enable(cccp, obj);
+        lcb_clconfig_cccp_set_nodes(cccp, obj->mc_nodes);
     } else {
-        obj->confmon->set_active(CLCONFIG_CCCP, false);
+        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_CCCP, 0);
     }
     return LCB_SUCCESS;
 }
@@ -419,7 +379,7 @@ 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 = new clconfig::Confmon(settings, obj->iotable);
+    obj->confmon = lcb_confmon_create(settings, obj->iotable);
     obj->ht_nodes = new Hostlist();
     obj->mc_nodes = new Hostlist();
     obj->retryq = new RetryQueue(&obj->cmdq, obj->iotable, obj->settings);
@@ -438,15 +398,8 @@ 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);
-    if ((err = init_providers(obj, spec)) != LCB_SUCCESS) {
-        goto GT_DONE;
-    }
-
+    err = init_providers(obj, spec);
     if (err != LCB_SUCCESS) {
         lcb_destroy(obj);
         return err;
@@ -493,12 +446,10 @@ void lcb_destroy(lcb_t instance)
     lcb_ASPEND_SETTYPE::iterator it;
     lcb_ASPEND_SETTYPE *pendq;
 
-    if (instance->cur_configinfo) {
-        instance->cur_configinfo->decref();
-        instance->cur_configinfo = NULL;
-    }
+    DESTROY(lcb_clconfig_decref, cur_configinfo);
     instance->cmdq.config = NULL;
-    DESTROY(delete, bs_state);
+
+    lcb_bootstrap_destroy(instance);
     DESTROY(delete, ht_nodes);
     DESTROY(delete, mc_nodes);
 
@@ -522,14 +473,14 @@ void lcb_destroy(lcb_t instance)
 
     if ((pendq = po->items[LCB_PENDTYPE_HTTP])) {
         for (it = pendq->begin(); it != pendq->end(); ++it) {
-            http::Request *htreq = reinterpret_cast<http::Request*>(*it);
-            htreq->block_callback();
-            htreq->finish(LCB_ERROR);
+            lcb_http_request_t htreq = reinterpret_cast<lcb_http_request_t>(*it);
+            lcb_htreq_block_callback(htreq);
+            lcb_htreq_finish(instance, htreq, LCB_ERROR);
         }
     }
 
     DESTROY(delete, retryq);
-    DESTROY(delete, confmon);
+    DESTROY(lcb_confmon_destroy, confmon);
     DESTROY(lcbio_mgr_destroy, memd_sockpool);
     DESTROY(lcbio_mgr_destroy, http_sockpool);
     DESTROY(lcb_vbguess_destroy, vbguess);
@@ -583,23 +534,10 @@ 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 = instance->bootstrap(BS_REFRESH_INITIAL);
+    lcb_error_t err = lcb_bootstrap_common(instance, LCB_BS_REFRESH_INITIAL);
     if (err == LCB_SUCCESS) {
         SYNCMODE_INTERCEPT(instance);
     } else {
@@ -780,15 +718,6 @@ 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)
 {