libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/cntl.cc

@@ -79,6 +79,7 @@ static lcb_uint32_t *get_timeout_field(lcb_t instance, int cmd)
     case LCB_CNTL_HTCONFIG_IDLE_TIMEOUT: return &settings->bc_http_stream_time;
     case LCB_CNTL_RETRY_INTERVAL: return &settings->retry_interval;
     case LCB_CNTL_RETRY_NMV_INTERVAL: return &settings->retry_nmv_interval;
+    case LCB_CNTL_CONFIG_POLL_INTERVAL: return &settings->config_poll_interval;
     default: return NULL;
     }
 }
@@ -145,7 +146,7 @@ HANDLER(retry_backoff_handler) {
     RETURN_GET_SET(float, LCBT_SETTING(instance, retry_backoff))
 }
 HANDLER(http_poolsz_handler) {
-    RETURN_GET_SET(lcb_SIZE, instance->http_sockpool->maxidle)
+    RETURN_GET_SET(lcb_SIZE, instance->http_sockpool->get_options().maxidle)
 }
 HANDLER(http_refresh_config_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, refresh_on_hterr))
@@ -174,6 +175,9 @@ HANDLER(nmv_imm_retry_handler) {
 HANDLER(tcp_nodelay_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, tcp_nodelay));
 }
+HANDLER(tcp_keepalive_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, tcp_keepalive));
+}
 HANDLER(readj_ts_wait_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, readj_ts_wait));
 }
@@ -183,6 +187,25 @@ 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(send_hello_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, send_hello));
+}
+HANDLER(config_poll_interval_handler) {
+    lcb_error_t rv = timeout_common(mode, instance, cmd, arg);
+    if (rv == LCB_SUCCESS &&
+            (mode == LCB_CNTL_SET || CNTL__MODE_SETSTRING) &&
+            // Note: This might be NULL during creation!
+            instance->bs_state) {
+        instance->bs_state->check_bgpoll();
+    }
+    return rv;
+}
 
 HANDLER(get_kvb) {
     lcb_cntl_vbinfo_st *vbi = reinterpret_cast<lcb_cntl_vbinfo_st*>(arg);
@@ -198,7 +221,7 @@ HANDLER(get_kvb) {
 
 
 HANDLER(conninfo) {
-    lcbio_SOCKET *sock;
+    const lcbio_SOCKET *sock;
     lcb_cntl_server_st *si = reinterpret_cast<lcb_cntl_server_st*>(arg);
     const lcb_host_t *host;
 
@@ -212,7 +235,7 @@ HANDLER(conninfo) {
         if (ix < 0 || ix > (int)LCBT_NSERVERS(instance)) {
             return LCB_ECTL_BADARG;
         }
-        server = LCBT_GET_SERVER(instance, ix);
+        server = instance->get_server(ix);
         if (!server) {
             return LCB_NETWORK_ERROR;
         }
@@ -224,7 +247,7 @@ HANDLER(conninfo) {
             }
         }
     } else if (cmd == LCB_CNTL_CONFIGNODE_INFO) {
-        sock = lcb_confmon_get_rest_connection(instance->confmon);
+        sock = lcb::clconfig::http_get_conn(instance->confmon);
     } else {
         return LCB_ECTL_BADARG;
     }
@@ -246,7 +269,8 @@ HANDLER(conninfo) {
 
 HANDLER(config_cache_loaded_handler) {
     if (mode != LCB_CNTL_GET) { return LCB_ECTL_UNSUPPMODE; }
-    *(int *)arg = instance->cur_configinfo && instance->cur_configinfo->origin == LCB_CLCONFIG_FILE;
+    *(int *)arg = instance->cur_configinfo &&
+            instance->cur_configinfo->get_origin() == lcb::clconfig::CLCONFIG_FILE;
     (void)cmd; return LCB_SUCCESS;
 }
 
@@ -282,9 +306,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->origin) {
-        case LCB_CLCONFIG_HTTP: *val = LCB_CONFIG_TRANSPORT_HTTP; break;
-        case LCB_CLCONFIG_CCCP: *val = LCB_CONFIG_TRANSPORT_CCCP; break;
+    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;
         default: return LCB_CLIENT_ETMPFAIL;
     }
     (void)cmd; return LCB_SUCCESS;
@@ -292,7 +316,7 @@ HANDLER(config_transport) {
 
 HANDLER(config_nodes) {
     const char *node_strs = reinterpret_cast<const char*>(arg);
-    clconfig_provider *target;
+    lcb::clconfig::Provider *target;
     lcb::Hostlist hostlist;
     lcb_error_t err;
 
@@ -309,13 +333,13 @@ HANDLER(config_nodes) {
     }
 
     if (cmd == LCB_CNTL_CONFIG_HTTP_NODES) {
-        target = lcb_confmon_get_provider(instance->confmon, LCB_CLCONFIG_HTTP);
-        lcb_clconfig_http_set_nodes(target, &hostlist);
+        target = instance->confmon->get_provider(lcb::clconfig::CLCONFIG_HTTP);
     } else {
-        target = lcb_confmon_get_provider(instance->confmon, LCB_CLCONFIG_CCCP);
-        lcb_clconfig_cccp_set_nodes(target, &hostlist);
+        target = instance->confmon->get_provider(lcb::clconfig::CLCONFIG_CCCP);
     }
 
+    target->configure_nodes(hostlist);
+
     return LCB_SUCCESS;
 }
 
@@ -327,22 +351,22 @@ HANDLER(init_providers) {
 }
 
 HANDLER(config_cache_handler) {
-    clconfig_provider *provider;
+    using namespace lcb::clconfig;
+    Provider *provider;
 
-    provider = lcb_confmon_get_provider(instance->confmon, LCB_CLCONFIG_FILE);
+    provider = instance->confmon->get_provider(lcb::clconfig::CLCONFIG_FILE);
     if (mode == LCB_CNTL_SET) {
-        int rv;
-        rv = lcb_clconfig_file_set_filename(provider,
+        bool rv = file_set_filename(provider,
             reinterpret_cast<const char*>(arg),
             cmd == LCB_CNTL_CONFIGCACHE_RO);
 
-        if (rv == 0) {
+        if (rv) {
             instance->settings->bc_http_stream_time = LCB_MS2US(10000);
             return LCB_SUCCESS;
         }
         return LCB_ERROR;
     } else {
-        *(const char **)arg = lcb_clconfig_file_get_filename(provider);
+        *(const char **)arg = file_get_filename(provider);
         return LCB_SUCCESS;
     }
 }
@@ -496,7 +520,7 @@ HANDLER(bucket_auth_handler) {
     if (mode == LCB_CNTL_SET) {
         /* Parse the bucket string... */
         cred = (const lcb_BUCKETCRED *)arg;
-        lcbauth_add_pass(instance->settings->auth, (*cred)[0], (*cred)[1], LCBAUTH_F_BUCKET);
+        return lcbauth_add_pass(instance->settings->auth, (*cred)[0], (*cred)[1], LCBAUTH_F_BUCKET);
         (void)cmd; (void)arg;
     } else if (mode == CNTL__MODE_SETSTRING) {
         const char *ss = reinterpret_cast<const char *>(arg);
@@ -508,7 +532,7 @@ HANDLER(bucket_auth_handler) {
         if (!root.isArray() || root.size() != 2) {
             return LCB_ECTL_BADARG;
         }
-        lcbauth_add_pass(instance->settings->auth,
+        return lcbauth_add_pass(instance->settings->auth,
             root[0].asString().c_str(),
             root[1].asString().c_str(), LCBAUTH_F_BUCKET);
     } else {
@@ -585,7 +609,12 @@ 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 */
+    read_chunk_size_handler, /*LCB_CNTL_READ_CHUNKSIZE */
+    enable_errmap_handler, /* LCB_CNTL_ENABLE_ERRMAP */
+    select_bucket_handler, /* LCB_CNTL_SELECT_BUCKET */
+    tcp_keepalive_handler, /* LCB_CNTL_TCP_KEEPALIVE */
+    config_poll_interval_handler, /* LCB_CNTL_CONFIG_POLL_INTERVAL */
+    send_hello_handler /* LCB_CNTL_SEND_HELLO */
 };
 
 /* Union used for conversion to/from string functions */
@@ -737,6 +766,11 @@ 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},
+        {"tcp_keepalive", LCB_CNTL_TCP_KEEPALIVE, convert_intbool},
+        {"config_poll_interval", LCB_CNTL_CONFIG_POLL_INTERVAL, convert_timeout},
+        {"send_hello", LCB_CNTL_SEND_HELLO, convert_intbool},
         {NULL, -1}
 };
 

data/ext/libcouchbase/src/connspec.cc

@@ -31,6 +31,8 @@
 #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;
 
@@ -104,6 +106,14 @@ 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);
@@ -234,6 +244,23 @@ 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) {
+                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));
         }
@@ -288,10 +315,17 @@ 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;
@@ -345,6 +379,8 @@ 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) {
@@ -352,11 +388,6 @@ Connspec::parse(const char *connstr_, const char **errmsg)
             goto GT_DONE;
         }
     }
-
-    if (m_username.empty()) {
-        m_username = m_bucket;
-    }
-
     GT_DONE:
     return err;
 }
@@ -460,3 +491,13 @@ 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,9 +20,11 @@
 
 #include <libcouchbase/couchbase.h>
 #include "config.h"
+
 #include <string>
 #include <vector>
 #include <set>
+#include "hostlist.h"
 
 #ifdef _MSC_VER
 /*
@@ -73,6 +75,18 @@ 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; }
@@ -83,6 +97,8 @@ 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;
@@ -110,7 +126,18 @@ 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/dns-srv.cc

@@ -0,0 +1,147 @@
+#include <libcouchbase/couchbase.h>
+
+#include "config.h"
+#include "hostlist.h"
+#include "connspec.h"
+#include "hostlist.h"
+
+#ifndef _WIN32
+#include <string>
+
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#if __NAMESER < 19991006
+#undef HAVE_RES_SEARCH
+#endif /* __NAMESER < NNN */
+#endif /* HAVE_ARPA_NAMESER_H */
+
+#if defined(HAVE_ARPA_NAMESER_H) && defined(HAVE_RES_SEARCH)
+#define CAN_SRV_LOOKUP
+#include <cstdio>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <resolv.h>
+
+lcb_error_t
+lcb::dnssrv_query(const char* name, lcb::Hostlist& hostlist)
+{
+    ns_msg msg;
+
+    int rv = 0, nresp, ii;
+    lcb_U16 dns_rv;
+
+    std::vector<unsigned char> pkt(NS_PACKETSZ);
+    nresp = res_search(name, ns_c_in, ns_t_srv, &pkt[0], NS_PACKETSZ);
+    if (nresp < 0) {
+        return LCB_UNKNOWN_HOST;
+    }
+
+    rv = ns_initparse(&pkt[0], nresp, &msg);
+    if (rv != 0) {
+        return LCB_PROTOCOL_ERROR;
+    }
+
+    dns_rv = ns_msg_getflag(msg, ns_f_rcode);
+    if (dns_rv != ns_r_noerror) {
+        return LCB_UNKNOWN_HOST;
+    }
+
+    if (!ns_msg_count(msg, ns_s_an)) {
+        return LCB_UNKNOWN_HOST;
+    }
+
+    for (ii = 0; ii < ns_msg_count(msg, ns_s_an); ii++) {
+        lcb_U16 srv_prio, srv_weight, srv_port;
+        ns_rr rr;
+        const lcb_U8 *rdata;
+        size_t rdlen;
+
+        if (ns_parserr(&msg, ns_s_an, ii, &rr) != 0) {
+            continue;
+        }
+
+        if (ns_rr_type(rr) != ns_t_srv) {
+            continue;
+        }
+
+        /* Get the rdata and length fields */
+        rdata = ns_rr_rdata(rr);
+        rdlen = ns_rr_rdlen(rr);
+
+        if (rdlen < 6) {
+            continue;
+        }
+
+        #define do_get16(t) t = ns_get16(rdata); rdata += 2; rdlen -=2
+        do_get16(srv_prio);
+        do_get16(srv_weight);
+        do_get16(srv_port);
+        #undef do_get_16
+
+        (void)srv_prio; (void)srv_weight; /* Handle these in the future */
+        std::vector<char> dname(NS_MAXDNAME + 1);
+        ns_name_uncompress(
+            ns_msg_base(msg), ns_msg_end(msg),
+            rdata, &dname[0], NS_MAXDNAME);
+        hostlist.add(&dname[0], srv_port);
+    }
+    return LCB_SUCCESS;
+}
+#endif /* HAVE_RES_SEARCH */
+
+#else
+#include <windns.h>
+#define CAN_SRV_LOOKUP
+/* Implement via DnsQuery() */
+lcb_error_t
+lcb::dnssrv_query(const char *addr, Hostlist& hs)
+{
+    DNS_STATUS status;
+    PDNS_RECORDA root, cur;
+
+    status = DnsQuery_A(
+        addr, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, (PDNS_RECORD*)&root, NULL);
+    if (status != 0) {
+        return LCB_UNKNOWN_HOST;
+    }
+
+    for (cur = root; cur; cur = cur->pNext) {
+        // Use the ASCII version of the DNS lookup structure
+        const DNS_SRV_DATAA *srv = &cur->Data.SRV;
+        hs.add(srv->pNameTarget, srv->wPort);
+    }
+    DnsRecordListFree(root, DnsFreeRecordList);
+    return LCB_SUCCESS;
+}
+
+#endif /* !WIN32 */
+
+
+#ifndef CAN_SRV_LOOKUP
+lcb_error_t lcb::dnssrv_query(const char *, Hostlist&) {
+    return LCB_CLIENT_FEATURE_UNAVAILABLE;
+}
+#endif
+
+#define SVCNAME_PLAIN "_couchbase._tcp."
+#define SVCNAME_SSL "_couchbases._tcp."
+
+lcb::Hostlist*
+lcb::dnssrv_getbslist(const char *addr, bool is_ssl, lcb_error_t& errp) {
+    std::string ss;
+    Hostlist *ret = new Hostlist();
+    ss.append(is_ssl ? SVCNAME_SSL : SVCNAME_PLAIN);
+    ss.append(addr);
+
+    errp = dnssrv_query(ss.c_str(), *ret);
+    if (errp != LCB_SUCCESS) {
+        delete ret;
+        return NULL;
+    }
+    if (ret->empty()) {
+        delete ret;
+        errp = LCB_NAMESERVER_ERROR;
+        return NULL;
+    }
+    return ret;
+}