libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/cntl.cc

@@ -198,7 +198,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;
 
@@ -206,25 +206,25 @@ HANDLER(conninfo) {
     if (si->version < 0 || si->version > 1) { return LCB_ECTL_BADARG; }
 
     if (cmd == LCB_CNTL_MEMDNODE_INFO) {
-        mc_SERVER *server;
+        lcb::Server *server;
         int ix = si->v.v0.index;
 
         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;
         }
         sock = server->connctx->sock;
         if (si->version == 1 && sock) {
-            mc_pSESSINFO sasl = mc_sess_get(server->connctx->sock);
-            if (sasl) {
-                si->v.v1.sasl_mech = mc_sess_get_saslmech(sasl);
+            lcb::SessionInfo *info = lcb::SessionInfo::get(server->connctx->sock);
+            if (info) {
+                si->v.v1.sasl_mech = info->get_mech().c_str();
             }
         }
     } 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 +246,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 +283,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 +293,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 +310,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 +328,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;
     }
 }
@@ -470,8 +471,7 @@ HANDLER(mutation_tokens_supported_handler) {
     *(int *)arg = 0;
 
     for (ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
-        mc_SERVER *s = LCBT_GET_SERVER(instance, ii);
-        if (s->mutation_tokens) {
+        if (instance->get_server(ii)->supports_mutation_tokens()) {
             *(int *)arg = 1;
             break;
         }

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);
@@ -288,10 +298,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 +362,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) {
@@ -460,3 +479,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

@@ -73,6 +73,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 +95,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 +124,10 @@ 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://"
 } // namespace
+
 #endif
 
 #ifdef _MSC_VER

data/ext/libcouchbase/src/dns-srv.cc

@@ -0,0 +1,143 @@
+#include <libcouchbase/couchbase.h>
+
+#include "config.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_INTERNAL_API
+lcb_error_t
+lcb_dnssrv_query(const char *name, hostlist_t 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_INTERNAL_API
+lcb_error_t
+lcb_dnssrv_query(const char *addr, hostlist_t 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;
+        hostlist_add_stringz(hs, srv->pNameTarget, srv->wPort);
+    }
+    DnsRecordListFree(root, DnsFreeRecordList);
+    return LCB_SUCCESS;
+}
+
+#endif /* !WIN32 */
+
+
+#ifndef CAN_SRV_LOOKUP
+LCB_INTERNAL_API lcb_error_t lcb_dnssrv_query(const char *, hostlist_t) {
+    return LCB_CLIENT_FEATURE_UNAVAILABLE;
+}
+#endif
+
+#define SVCNAME_PLAIN "_couchbase._tcp."
+#define SVCNAME_SSL "_couchbases._tcp."
+
+LCB_INTERNAL_API
+hostlist_st*
+lcb_dnssrv_getbslist(const char *addr, int is_ssl, lcb_error_t *errp) {
+    std::string ss;
+    lcb::Hostlist *ret = new lcb::Hostlist();
+    ss.append(is_ssl ? SVCNAME_SSL : SVCNAME_PLAIN);
+    ss.append(addr);
+
+    *errp = lcb_dnssrv_query(ss.c_str(), ret);
+    if (*errp != LCB_SUCCESS) {
+        delete ret;
+        ret = NULL;
+    }
+    return static_cast<hostlist_st*>(ret);
+}

data/ext/libcouchbase/src/{dump.c → 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) {
-        clconfig_info *cfg = instance->cur_configinfo;
+        lcb::clconfig::ConfigInfo *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) {
@@ -50,10 +50,10 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
     } else {
         fprintf(fp, "NO CLUSTER CONFIG\n");
     }
-    fprintf(fp,"Retry queue has items: %s\n", lcb_retryq_empty(instance->retryq) ? "No" : "Yes");
+    fprintf(fp,"Retry queue has items: %s\n", instance->retryq->empty() ? "No" : "Yes");
     if (flags & LCB_DUMP_PKTINFO) {
         fprintf(fp, "=== BEGIN RETRY QUEUE DUMP ===\n");
-        lcb_retryq_dump(instance->retryq, fp, NULL);
+        instance->retryq->dump(fp, NULL);
         fprintf(fp, "=== END RETRY QUEUE DUMP ===\n");
     } else {
         fprintf(fp, "=== NOT DUMPING PACKET INFO. LCB_DUMP_PKTINFO not passed\n");
@@ -61,10 +61,7 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
 
     fprintf(fp, "=== BEGIN PIPELINE DUMP ===\n");
     for (ii = 0; ii < instance->cmdq.npipelines; ii++) {
-        mc_SERVER *server;
-        mc_PIPELINE *pl = instance->cmdq.pipelines[ii];
-
-        server = (mc_SERVER *)pl;
+        lcb::Server *server = static_cast<lcb::Server*>(instance->cmdq.pipelines[ii]);
         fprintf(fp, "** [%u] SERVER %s:%s\n", ii, server->curhost->host, server->curhost->port);
         if (server->connctx) {
             fprintf(fp, "** == BEGIN SOCKET INFO\n");
@@ -77,14 +74,14 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
         }
         if (flags & LCB_DUMP_BUFINFO) {
             fprintf(fp, "** == DUMPING NETBUF INFO (For packet network data)\n");
-            netbuf_dump_status(&pl->nbmgr, fp);
+            netbuf_dump_status(&server->nbmgr, fp);
             fprintf(fp, "** == DUMPING NETBUF INFO (For packet structures)\n");
-            netbuf_dump_status(&pl->reqpool, fp);
+            netbuf_dump_status(&server->reqpool, fp);
         } else {
             fprintf(fp, "** == NOT DUMPING NETBUF INFO. LCB_DUMP_BUFINFO not passed\n");
         }
         if (flags & LCB_DUMP_PKTINFO) {
-            mcreq_dump_chain(pl, fp, NULL);
+            mcreq_dump_chain(server, fp, NULL);
         } else {
             fprintf(fp, "** == NOT DUMPING PACKETS. LCB_DUMP_PKTINFO not passed\n");
         }
@@ -93,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");
-    lcb_confmon_dump(instance->confmon, fp);
+    instance->confmon->dump(fp);
     fprintf(fp, "=== END CONFMON DUMP ===\n");
 }

data/ext/libcouchbase/src/getconfig.cc

@@ -0,0 +1,73 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "internal.h"
+#include "packetutils.h"
+#include <bucketconfig/clconfig.h>
+
+static void
+ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
+                   const void  *resdata)
+{
+    lcb::Server *server = static_cast<lcb::Server*>(pl);
+    mc_REQDATAEX *rd = req->u_rdata.exdata;
+    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());
+    free(rd);
+}
+
+static mc_REQDATAPROCS procs = { ext_callback_proxy };
+
+lcb_error_t
+lcb_st::request_config(const void *cookie_, lcb::Server *server)
+{
+    lcb_error_t err;
+    mc_PACKET *packet;
+    mc_REQDATAEX *rd;
+
+    packet = mcreq_allocate_packet(server);
+    if (!packet) {
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    err = mcreq_reserve_header(server, packet, 24);
+    if (err != LCB_SUCCESS) {
+        mcreq_release_packet(server, packet);
+        return err;
+    }
+
+    rd = reinterpret_cast<mc_REQDATAEX*>(calloc(1, sizeof(*rd)));
+    rd->procs = &procs;
+    rd->cookie = cookie_;
+    rd->start = gethrtime();
+    packet->u_rdata.exdata = rd;
+    packet->flags |= MCREQ_F_REQEXT;
+
+    lcb::MemcachedRequest hdr(
+        PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG, packet->opaque);
+    hdr.opaque(packet->opaque);
+    memcpy(SPAN_BUFFER(&packet->kh_span), hdr.data(), hdr.size());
+
+    mcreq_sched_enter(&cmdq);
+    mcreq_sched_add(server, packet);
+    mcreq_sched_leave(&cmdq, 1);
+    return LCB_SUCCESS;
+}