libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/src/cbft.cc

@@ -27,10 +27,10 @@
 #define LOGID(req) static_cast<const void*>(req)
 #define LOGARGS(req, lvl) req->instance->settings, "n1ql", LCB_LOG_##lvl, __FILE__, __LINE__
 
-struct lcb_FTSREQ : lcb::jsparse::Parser::Actions {
+struct lcb_FTSREQ {
     const lcb_RESPHTTP *cur_htresp;
     lcb_http_request_t htreq;
-    lcb::jsparse::Parser *parser;
+    lcbjsp_PARSER *parser;
     const void *cookie;
     lcb_FTSCALLBACK callback;
     lcb_t instance;
@@ -41,21 +41,26 @@ struct lcb_FTSREQ : lcb::jsparse::Parser::Actions {
 
     lcb_FTSREQ(lcb_t, const void *, const lcb_CMDFTS *);
     ~lcb_FTSREQ();
-    void JSPARSE_on_row(const lcb::jsparse::Row& datum) {
-        lcb_RESPFTS resp = { 0 };
-        resp.row = static_cast<const char*>(datum.row.iov_base);
-        resp.nrow = datum.row.iov_len;
-        nrows++;
-        invoke_row(&resp);
-    }
-    void JSPARSE_on_error(const std::string&) {
-        lasterr = LCB_PROTOCOL_ERROR;
-    }
-    void JSPARSE_on_complete(const std::string&) {
-        // Nothing
-    }
 };
 
+static void
+row_callback(lcbjsp_PARSER *parser, const lcbjsp_ROW *datum)
+{
+    lcb_FTSREQ *req = static_cast<lcb_FTSREQ*>(parser->data);
+    lcb_RESPFTS 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);
+    } 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, int, const lcb_RESPBASE *rb)
 {
@@ -78,7 +83,7 @@ chunk_callback(lcb_t, int, const lcb_RESPBASE *rb)
          * should remain alive (so we can cancel it later on) */
         delete req;
     } else {
-        req->parser->feed(static_cast<const char*>(rh->body), rh->nbody);
+        lcbjsp_feed(req->parser, static_cast<const char*>(rh->body), rh->nbody);
     }
 }
 
@@ -102,7 +107,7 @@ lcb_FTSREQ::invoke_last()
 
     if (parser) {
         lcb_IOV meta;
-        parser->get_postmortem(meta);
+        lcbjsp_get_postmortem(parser, &meta);
         resp.row = static_cast<const char*>(meta.iov_base);
         resp.nrow = meta.iov_len;
     }
@@ -111,9 +116,7 @@ lcb_FTSREQ::invoke_last()
 }
 
 lcb_FTSREQ::lcb_FTSREQ(lcb_t instance_, const void *cookie_, const lcb_CMDFTS *cmd)
-: lcb::jsparse::Parser::Actions(),
-  cur_htresp(NULL), htreq(NULL),
-  parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_FTS, this)),
+: cur_htresp(NULL), htreq(NULL), parser(lcbjsp_create(LCBJSP_MODE_FTS)),
   cookie(cookie_), callback(cmd->callback), instance(instance_), nrows(0),
   lasterr(LCB_SUCCESS)
 {
@@ -162,10 +165,12 @@ lcb_FTSREQ::lcb_FTSREQ(lcb_t instance_, const void *cookie_, const lcb_CMDFTS *c
     std::string qbody(Json::FastWriter().write(root));
     htcmd.body = qbody.c_str();
     htcmd.nbody = qbody.size();
+    parser->data = this;
+    parser->callback = row_callback;
 
     lasterr = lcb_http3(instance, this, &htcmd);
     if (lasterr == LCB_SUCCESS) {
-        htreq->set_callback(chunk_callback);
+        lcb_htreq_setcb(htreq, chunk_callback);
         if (cmd->handle) {
             *cmd->handle = reinterpret_cast<lcb_FTSREQ*>(this);
         }
@@ -179,7 +184,7 @@ lcb_FTSREQ::~lcb_FTSREQ()
         htreq = NULL;
     }
     if (parser) {
-        delete parser;
+        lcbjsp_free(parser);
         parser = NULL;
     }
 }

data/ext/libcouchbase/src/cntl.cc

@@ -183,12 +183,6 @@ HANDLER(kv_hg_handler) {
 HANDLER(read_chunk_size_handler) {
     RETURN_GET_SET(lcb_U32, LCBT_SETTING(instance, read_chunk_size));
 }
-HANDLER(enable_errmap_handler) {
-    RETURN_GET_SET(int, LCBT_SETTING(instance, use_errmap));
-}
-HANDLER(select_bucket_handler) {
-    RETURN_GET_SET(int, LCBT_SETTING(instance, select_bucket));
-}
 
 HANDLER(get_kvb) {
     lcb_cntl_vbinfo_st *vbi = reinterpret_cast<lcb_cntl_vbinfo_st*>(arg);
@@ -204,7 +198,7 @@ HANDLER(get_kvb) {
 
 
 HANDLER(conninfo) {
-    const lcbio_SOCKET *sock;
+    lcbio_SOCKET *sock;
     lcb_cntl_server_st *si = reinterpret_cast<lcb_cntl_server_st*>(arg);
     const lcb_host_t *host;
 
@@ -218,7 +212,7 @@ HANDLER(conninfo) {
         if (ix < 0 || ix > (int)LCBT_NSERVERS(instance)) {
             return LCB_ECTL_BADARG;
         }
-        server = instance->get_server(ix);
+        server = LCBT_GET_SERVER(instance, ix);
         if (!server) {
             return LCB_NETWORK_ERROR;
         }
@@ -230,7 +224,7 @@ HANDLER(conninfo) {
             }
         }
     } else if (cmd == LCB_CNTL_CONFIGNODE_INFO) {
-        sock = lcb::clconfig::http_get_conn(instance->confmon);
+        sock = lcb_confmon_get_rest_connection(instance->confmon);
     } else {
         return LCB_ECTL_BADARG;
     }
@@ -252,8 +246,7 @@ HANDLER(conninfo) {
 
 HANDLER(config_cache_loaded_handler) {
     if (mode != LCB_CNTL_GET) { return LCB_ECTL_UNSUPPMODE; }
-    *(int *)arg = instance->cur_configinfo &&
-            instance->cur_configinfo->get_origin() == lcb::clconfig::CLCONFIG_FILE;
+    *(int *)arg = instance->cur_configinfo && instance->cur_configinfo->origin == LCB_CLCONFIG_FILE;
     (void)cmd; return LCB_SUCCESS;
 }
 
@@ -289,9 +282,9 @@ HANDLER(config_transport) {
     if (mode == LCB_CNTL_SET) { return LCB_ECTL_UNSUPPMODE; }
     if (!instance->cur_configinfo) { return LCB_CLIENT_ETMPFAIL; }
 
-    switch (instance->cur_configinfo->get_origin()) {
-        case lcb::clconfig::CLCONFIG_HTTP: *val = LCB_CONFIG_TRANSPORT_HTTP; break;
-        case lcb::clconfig::CLCONFIG_CCCP: *val = LCB_CONFIG_TRANSPORT_CCCP; break;
+    switch (instance->cur_configinfo->origin) {
+        case LCB_CLCONFIG_HTTP: *val = LCB_CONFIG_TRANSPORT_HTTP; break;
+        case LCB_CLCONFIG_CCCP: *val = LCB_CONFIG_TRANSPORT_CCCP; break;
         default: return LCB_CLIENT_ETMPFAIL;
     }
     (void)cmd; return LCB_SUCCESS;
@@ -299,7 +292,7 @@ HANDLER(config_transport) {
 
 HANDLER(config_nodes) {
     const char *node_strs = reinterpret_cast<const char*>(arg);
-    lcb::clconfig::Provider *target;
+    clconfig_provider *target;
     lcb::Hostlist hostlist;
     lcb_error_t err;
 
@@ -316,13 +309,13 @@ HANDLER(config_nodes) {
     }
 
     if (cmd == LCB_CNTL_CONFIG_HTTP_NODES) {
-        target = instance->confmon->get_provider(lcb::clconfig::CLCONFIG_HTTP);
+        target = lcb_confmon_get_provider(instance->confmon, LCB_CLCONFIG_HTTP);
+        lcb_clconfig_http_set_nodes(target, &hostlist);
     } else {
-        target = instance->confmon->get_provider(lcb::clconfig::CLCONFIG_CCCP);
+        target = lcb_confmon_get_provider(instance->confmon, LCB_CLCONFIG_CCCP);
+        lcb_clconfig_cccp_set_nodes(target, &hostlist);
     }
 
-    target->configure_nodes(hostlist);
-
     return LCB_SUCCESS;
 }
 
@@ -334,22 +327,22 @@ HANDLER(init_providers) {
 }
 
 HANDLER(config_cache_handler) {
-    using namespace lcb::clconfig;
-    Provider *provider;
+    clconfig_provider *provider;
 
-    provider = instance->confmon->get_provider(lcb::clconfig::CLCONFIG_FILE);
+    provider = lcb_confmon_get_provider(instance->confmon, LCB_CLCONFIG_FILE);
     if (mode == LCB_CNTL_SET) {
-        bool rv = file_set_filename(provider,
+        int rv;
+        rv = lcb_clconfig_file_set_filename(provider,
             reinterpret_cast<const char*>(arg),
             cmd == LCB_CNTL_CONFIGCACHE_RO);
 
-        if (rv) {
+        if (rv == 0) {
             instance->settings->bc_http_stream_time = LCB_MS2US(10000);
             return LCB_SUCCESS;
         }
         return LCB_ERROR;
     } else {
-        *(const char **)arg = file_get_filename(provider);
+        *(const char **)arg = lcb_clconfig_file_get_filename(provider);
         return LCB_SUCCESS;
     }
 }
@@ -592,9 +585,7 @@ static ctl_handler handlers[] = {
     client_string_handler, /* LCB_CNTL_CLIENT_STRING */
     bucket_auth_handler, /* LCB_CNTL_BUCKET_CRED */
     timeout_common, /* LCB_CNTL_RETRY_NMV_DELAY */
-    read_chunk_size_handler, /*LCB_CNTL_READ_CHUNKSIZE */
-    enable_errmap_handler, /* LCB_CNTL_ENABLE_ERRMAP */
-    select_bucket_handler /* LCB_CNTL_SELECT_BUCKET */
+    read_chunk_size_handler /*LCB_CNTL_READ_CHUNKSIZE */
 };
 
 /* Union used for conversion to/from string functions */
@@ -746,8 +737,6 @@ static cntl_OPCODESTRS stropcode_map[] = {
         {"retry_nmv_delay", LCB_CNTL_RETRY_NMV_INTERVAL, convert_timeout},
         {"bucket_cred", LCB_CNTL_BUCKET_CRED, NULL},
         {"read_chunk_size", LCB_CNTL_READ_CHUNKSIZE, convert_u32},
-        {"enable_errmap", LCB_CNTL_ENABLE_ERRMAP, convert_intbool},
-        {"select_bucket", LCB_CNTL_SELECT_BUCKET, convert_intbool},
         {NULL, -1}
 };
 

data/ext/libcouchbase/src/connspec.cc

@@ -31,8 +31,6 @@
 #define F_HASUSER (1<<2)
 #define F_SSLSCHEME (1<<3)
 #define F_FILEONLY (1<<4)
-#define F_DNSSRV (1<<5)
-#define F_DNSSRV_EXPLICIT ( (1<<6) |F_DNSSRV)
 
 using namespace lcb;
 
@@ -106,14 +104,6 @@ Connspec::parse_hosts(const char *hostbegin,
             port = scratch.substr(colonpos + 1);
         }
 
-        if (m_flags & F_DNSSRV_EXPLICIT) {
-            if (!m_hosts.empty()) {
-                SET_ERROR("Only a single host is allowed with DNS SRV");
-            } else if (!port.empty()) {
-                SET_ERROR("Port cannot be specified with DNS SRV");
-            }
-        }
-
         m_hosts.resize(m_hosts.size() + 1);
         Spechost *dh = &m_hosts.back();
         dh->hostname = scratch.substr(0, hostlen);
@@ -244,24 +234,6 @@ Connspec::parse_options(
             if (sscanf(value, "%d", &m_loglevel) != 1) {
                 SET_ERROR("console_log_level must be a numeric value");
             }
-        } else if (!strcmp(key, "dnssrv")) {
-            if ((m_flags & F_DNSSRV_EXPLICIT) == F_DNSSRV_EXPLICIT) {
-                SET_ERROR("Cannot use dnssrv scheme with dnssrv option");
-            }
-            int btmp = 0;
-            if (!strcmp(value, "on") || !strcmp(value, "true")) {
-                btmp = 1;
-            } else if (!strcmp(value, "off") || !strcmp(value, "false")) {
-                btmp = 0;
-            } else if (sscanf(value, "%d", &btmp) != 1) {
-                printf("Coldn't parse value!\n");
-                SET_ERROR("dnssrv must have numeric (boolean) value");
-            }
-            if (btmp) {
-                m_flags |= F_DNSSRV;
-            } else {
-                m_flags &= ~F_DNSSRV_EXPLICIT;
-            }
         } else {
             m_ctlopts.push_back(std::make_pair(key, value));
         }
@@ -316,17 +288,10 @@ Connspec::parse(const char *connstr_, const char **errmsg)
         m_implicit_port = 0;
     } else if (SCHEME_MATCHES(LCB_SPECSCHEME_MCCOMPAT)) {
         m_implicit_port = LCB_CONFIG_MCCOMPAT_PORT;
-    } else if (SCHEME_MATCHES(LCB_SPECSCHEME_SRV)) {
-        m_implicit_port = LCB_CONFIG_MCD_PORT;
-        m_flags |= F_DNSSRV_EXPLICIT;
-    } else if (SCHEME_MATCHES(LCB_SPECSCHEME_SRV_SSL)) {
-        m_implicit_port = LCB_CONFIG_MCD_SSL_PORT;
-        m_sslopts |= LCB_SSL_ENABLED;
-        m_flags |= F_SSLSCHEME | F_DNSSRV_EXPLICIT;
     } else {
         /* If we don't have a scheme at all: */
         if (strstr(connstr_, "://")) {
-            SET_ERROR("String must begin with 'couchbase://, 'couchbases://', or 'http://'");
+            SET_ERROR("String must begin with ''couchbase://, 'couchbases://', or 'http://'");
         } else {
             found_scheme = "";
             m_implicit_port = LCB_CONFIG_HTTP_PORT;
@@ -380,8 +345,6 @@ Connspec::parse(const char *connstr_, const char **errmsg)
     if (m_hosts.empty()) {
         m_hosts.resize(m_hosts.size()+1);
         m_hosts.back().hostname = "localhost";
-    } else if (m_hosts.size() == 1 && m_hosts[0].isTypeless()) {
-        m_flags |= F_DNSSRV;
     }
 
     if (options_ != NULL) {
@@ -497,13 +460,3 @@ Connspec::load(const lcb_create_st& cropts)
     GT_DONE:
     return err;
 }
-
-bool
-Connspec::can_dnssrv() const {
-    return m_flags & F_DNSSRV;
-}
-
-bool
-Connspec::is_explicit_dnssrv() const {
-    return (m_flags & F_DNSSRV_EXPLICIT) == F_DNSSRV_EXPLICIT;
-}

data/ext/libcouchbase/src/connspec.h

@@ -20,11 +20,9 @@
 
 #include <libcouchbase/couchbase.h>
 #include "config.h"
-
 #include <string>
 #include <vector>
 #include <set>
-#include "hostlist.h"
 
 #ifdef _MSC_VER
 /*
@@ -75,18 +73,6 @@ public:
     bool is_bs_http() const { return has_bsmode(LCB_CONFIG_TRANSPORT_HTTP); }
     bool is_bs_cccp() const { return has_bsmode(LCB_CONFIG_TRANSPORT_CCCP); }
     bool is_bs_file() const { return m_flags & LCB_CONNSPEC_F_FILEONLY; }
-
-    /**
-     * Whether a DNS SRV lookup can be performed on this connection string.
-     * @return true if a DNS SRV lookup is possible, or false if there is
-     * a parameter or format of the connection string preventing a lookup
-     */
-    bool can_dnssrv() const;
-
-    /**
-     * Whether the explicit `couchbase{s}+dnssrv` internal scheme is used
-     */
-    bool is_explicit_dnssrv() const;
     uint16_t default_port() const { return m_implicit_port; }
     const std::vector<Spechost>& hosts() const { return m_hosts; }
     const std::string& bucket() const { return m_bucket; }
@@ -97,8 +83,6 @@ public:
     const Options& options() const { return m_ctlopts; }
     unsigned loglevel() const { return m_loglevel; }
     const std::string& connstr() const { return m_connstr; }
-    void clear_hosts() { m_hosts.clear(); }
-    void add_host(const Spechost& host) { m_hosts.push_back(host); }
 private:
     Options m_ctlopts;
     std::string m_bucket;
@@ -126,18 +110,7 @@ private:
 #define LCB_SPECSCHEME_HTTP "http://"
 #define LCB_SPECSCHEME_HTTP_SSL "https-internal://"
 #define LCB_SPECSCHEME_MCCOMPAT "memcached://"
-#define LCB_SPECSCHEME_SRV "couchbase+dnssrv://"
-#define LCB_SPECSCHEME_SRV_SSL "couchbases+dnssrv://"
-
-// Standalone functionality:
-lcb_error_t
-dnssrv_query(const char *name, Hostlist& hostlist);
-
-Hostlist *
-dnssrv_getbslist(const char *addr, bool is_ssl, lcb_error_t& errout);
-
 } // namespace
-
 #endif
 
 #ifdef _MSC_VER

data/ext/libcouchbase/src/dump.cc

@@ -34,7 +34,7 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
     fprintf(fp, "Settings=%p\n", (void*)instance->settings);
 
     if (instance->cur_configinfo) {
-        lcb::clconfig::ConfigInfo *cfg = instance->cur_configinfo;
+        clconfig_info *cfg = instance->cur_configinfo;
         fprintf(fp, "Current VBC=%p\n", (void*)cfg->vbc);
         fprintf(fp, "Config RevID=%d\n", cfg->vbc->revid);
         if (flags & LCB_DUMP_VBCONFIG) {
@@ -90,6 +90,6 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
     fprintf(fp, "=== END PIPELINE DUMP ===\n");
 
     fprintf(fp, "=== BEGIN CONFMON DUMP ===\n");
-    instance->confmon->dump(fp);
+    lcb_confmon_dump(instance->confmon, fp);
     fprintf(fp, "=== END CONFMON DUMP ===\n");
 }

data/ext/libcouchbase/src/getconfig.cc

@@ -18,6 +18,31 @@
 #include "internal.h"
 #include "packetutils.h"
 #include <bucketconfig/clconfig.h>
+LCB_INTERNAL_API
+lcb::Server *
+lcb_find_server_by_host(lcb_t instance, const lcb_host_t *host)
+{
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    unsigned ii;
+    for (ii = 0; ii < cq->npipelines; ii++) {
+        lcb::Server *server = static_cast<lcb::Server*>(cq->pipelines[ii]);
+        if (lcb_host_equals(&server->get_host(), host)) {
+            return server;
+        }
+    }
+    return NULL;
+}
+
+LCB_INTERNAL_API
+lcb::Server *
+lcb_find_server_by_index(lcb_t instance, int ix)
+{
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    if (ix < 0 || ix >= static_cast<int>(cq->npipelines)) {
+        return NULL;
+    }
+    return static_cast<lcb::Server*>(cq->pipelines[ix]);
+}
 
 static void
 ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
@@ -28,18 +53,19 @@ ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
     const lcb::MemcachedResponse *res =
             reinterpret_cast<const lcb::MemcachedResponse*>(resdata);
 
-    lcb::clconfig::cccp_update(
-        rd->cookie, rc, res->body<const char*>(), res->bodylen(),
-        &server->get_host());
+    lcb_cccp_update2(rd->cookie, rc, res->body<const char*>(), res->bodylen(),
+                     &server->get_host());
     free(rd);
 }
 
 static mc_REQDATAPROCS procs = { ext_callback_proxy };
 
+LCB_INTERNAL_API
 lcb_error_t
-lcb_st::request_config(const void *cookie_, lcb::Server *server)
+lcb_getconfig(lcb_t instance, const void *cookie, lcb::Server *server)
 {
     lcb_error_t err;
+    mc_CMDQUEUE *cq = &instance->cmdq;
     mc_PACKET *packet;
     mc_REQDATAEX *rd;
 
@@ -56,7 +82,7 @@ lcb_st::request_config(const void *cookie_, lcb::Server *server)
 
     rd = reinterpret_cast<mc_REQDATAEX*>(calloc(1, sizeof(*rd)));
     rd->procs = &procs;
-    rd->cookie = cookie_;
+    rd->cookie = cookie;
     rd->start = gethrtime();
     packet->u_rdata.exdata = rd;
     packet->flags |= MCREQ_F_REQEXT;
@@ -66,8 +92,8 @@ lcb_st::request_config(const void *cookie_, lcb::Server *server)
     hdr.opaque(packet->opaque);
     memcpy(SPAN_BUFFER(&packet->kh_span), hdr.data(), hdr.size());
 
-    mcreq_sched_enter(&cmdq);
+    mcreq_sched_enter(cq);
     mcreq_sched_add(server, packet);
-    mcreq_sched_leave(&cmdq, 1);
+    mcreq_sched_leave(cq, 1);
     return LCB_SUCCESS;
 }