libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/views/viewreq.h

@@ -1,36 +1,66 @@
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/views.h>
 #include <libcouchbase/pktfwd.h>
-
 #include <jsparse/parser.h>
+#include <string>
 #include "docreq.h"
 
-struct lcbview_REQUEST_st;
+namespace lcb {
+namespace views {
 
-typedef struct {
-    lcb_DOCQREQ base;
-    struct lcbview_REQUEST_st *parent;
+struct ViewRequest;
+struct VRDocRequest : docreq::DocRequest {
+    ViewRequest *parent;
     lcb_IOV key;
     lcb_IOV value;
     lcb_IOV geo;
-    char rowbuf[1];
-} lcbview_DOCREQ;
+    std::string rowbuf;
+};
+
+struct ViewRequest : lcb::jsparse::Parser::Actions {
+    ViewRequest(lcb_t, const void*, const lcb_CMDVIEWQUERY*);
+    ~ViewRequest();
+    void invoke_last(lcb_error_t err);
+    void invoke_last() { invoke_last(lasterr); }
+    void invoke_row(lcb_RESPVIEWQUERY*);
+    void unref() {if(!--refcount){delete this;}}
+    void ref() {refcount++;}
+    void cancel();
+
+    /**
+     * Perform the actual HTTP request
+     * @param cmd User's command
+     */
+    inline lcb_error_t request_http(const lcb_CMDVIEWQUERY* cmd);
+
+    bool is_include_docs() const {
+        return cmdflags & LCB_CMDVIEWQUERY_F_INCLUDE_DOCS;
+    }
+    bool is_no_rowparse() const {
+        return cmdflags & LCB_CMDVIEWQUERY_F_NOROWPARSE;
+    }
+    bool is_spatial() const {
+        return cmdflags & LCB_CMDVIEWQUERY_F_SPATIAL;
+    }
+
+    void JSPARSE_on_row(const lcb::jsparse::Row&);
+    void JSPARSE_on_error(const std::string&);
+    void JSPARSE_on_complete(const std::string&);
 
-struct lcbview_REQUEST_st {
     /** Current HTTP response to provide in callbacks */
     const lcb_RESPHTTP *cur_htresp;
     /** HTTP request object, in case we need to cancel prematurely */
     struct lcb_http_request_st *htreq;
-    lcbjsp_PARSER *parser;
+    lcb::jsparse::Parser *parser;
     const void *cookie;
-    lcb_DOCQUEUE *docq;
+    docreq::Queue *docq;
     lcb_VIEWQUERYCALLBACK callback;
     lcb_t instance;
 
     unsigned refcount;
-    unsigned include_docs;
-    unsigned no_parse_rows;
+    uint32_t cmdflags;
     lcb_error_t lasterr;
 };
 
-typedef struct lcbview_REQUEST_st lcbview_REQUEST;
+}
+}

data/ext/libcouchbase/src/{wait.c → wait.cc}

@@ -18,44 +18,39 @@
 #include <lcbio/iotable.h>
 #include <lcbio/timer-ng.h>
 
-static int
+static bool
 has_pending(lcb_t instance)
 {
-    unsigned ii;
 
-    if (!lcb_retryq_empty(instance->retryq)) {
-        return 1;
+    if (!instance->retryq->empty()) {
+        return true;
     }
 
     if (lcb_aspend_pending(&instance->pendops)) {
-        return 1;
+        return true;
     }
 
-    for (ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
-        mc_SERVER *ss = LCBT_GET_SERVER(instance, ii);
-        if (mcserver_has_pending(ss)) {
-            return 1;
+    for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
+        if (instance->get_server(ii)->has_pending()) {
+            return true;
         }
     }
-    return 0;
+    return false;
 }
 
 static void
 maybe_reset_timeouts(lcb_t instance)
 {
-    size_t ii;
-    lcb_U64 now;
 
     if (!LCBT_SETTING(instance, readj_ts_wait)) {
         return;
     }
 
-    now = lcb_nstime();
-    for (ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
-        mc_SERVER *ss = LCBT_GET_SERVER(instance, ii);
-        mcreq_reset_timeouts(&ss->pipeline, now);
+    uint64_t now = lcb_nstime();
+    for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
+        mcreq_reset_timeouts(instance->get_server(ii), now);
     }
-    lcb_retryq_reset_timeouts(instance->retryq, now);
+    instance->retryq->reset_timeouts(now);
 }
 
 void

data/ext/libcouchbase/tests/basic/t_connstr.cc

@@ -2,14 +2,6 @@
 #include "connspec.h"
 using namespace lcb;
 
-static lcb_error_t lcb_connspec_parse(const char *connstr, Connspec *spec, const char **errmsg)
-{
-    return spec->parse(connstr, errmsg);
-}
-static lcb_error_t lcb_connspec_convert(Connspec *spec, const lcb_create_st *cropts)
-{
-    return spec->load(*cropts);
-}
 static size_t countHosts(const Connspec *spec) {
     return spec->hosts().size();
 }
@@ -110,7 +102,7 @@ TEST_F(ConnstrTest, testParseBasic)
     ASSERT_EQ(LCB_CONFIG_HTTP_PORT, params.default_port());
 
     reinit();
-    err = lcb_connspec_parse("1.2.3.4:999", &params, &errmsg);
+    err = params.parse("1.2.3.4:999", &errmsg);
     ASSERT_EQ(1, countHosts(&params));
     tmphost = findHost(&params, "1.2.3.4");
     ASSERT_FALSE(tmphost == NULL);
@@ -122,7 +114,7 @@ TEST_F(ConnstrTest, testParseBasic)
 TEST_F(ConnstrTest, testParseHosts)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://foo.com,bar.com,baz.com", &params, &errmsg);
+    err = params.parse("couchbase://foo.com,bar.com,baz.com", &errmsg);
     ASSERT_EQ(3, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
     ASSERT_FALSE(NULL == findHost(&params, "bar.com"));
@@ -130,7 +122,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // Parse with 'legacy' format
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:8091", &params, &errmsg);
+    err = params.parse("couchbase://foo.com:8091", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     const Spechost *dh = findHost(&params, "foo.com");
     ASSERT_FALSE(NULL == dh);
@@ -141,14 +133,14 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // parse with invalid port, without specifying protocol
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:4444", &params, &errmsg);
+    err = params.parse("couchbase://foo.com:4444", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ(4444, dh->port);
     ASSERT_TRUE(dh->isMCD());
 
     reinit();
-    err = lcb_connspec_parse("couchbases://foo.com:4444", &params, &errmsg);
+    err = params.parse("couchbases://foo.com:4444", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
@@ -157,7 +149,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // Parse with recognized format
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:4444=mcd", &params, &errmsg);
+    err = params.parse("couchbase://foo.com:4444=mcd", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ("foo.com", dh->hostname);
@@ -166,8 +158,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     //Parse multiple hosts with ports
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:4444=mcd,bar.com:5555=mcd",
-        &params, &errmsg);
+    err = params.parse("couchbase://foo.com:4444=mcd,bar.com:5555=mcd", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
 
     dh = findHost(&params, "foo.com");
@@ -183,7 +174,7 @@ TEST_F(ConnstrTest, testParseHosts)
     ASSERT_TRUE(dh->isMCD());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com,bar.com:4444", &params, &errmsg);
+    err = params.parse("couchbase://foo.com,bar.com:4444", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "bar.com");
     ASSERT_EQ(4444, dh->port);
@@ -192,7 +183,7 @@ TEST_F(ConnstrTest, testParseHosts)
     ASSERT_TRUE(dh->isTypeless());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com;bar.com;baz.com", &params, &errmsg);
+    err = params.parse("couchbase://foo.com;bar.com;baz.com", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Can parse old-style semicolons";
     ASSERT_EQ(3, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
@@ -203,27 +194,27 @@ TEST_F(ConnstrTest, testParseHosts)
 TEST_F(ConnstrTest, testParseBucket)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://foo.com/user", &params, &errmsg);
+    err = params.parse("couchbase://foo.com/user", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("user", params.bucket()) << "Basic bucket parse";
 
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com/user/", &params, &errmsg);
+    err = params.parse("couchbase://foo.com/user/", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Bucket can have a slash";
     // We can have a bucket using a slash
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///default", &params, &errmsg);
+    err = params.parse("couchbase:///default", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Bucket without host OK";
     ASSERT_EQ("default", params.bucket());
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///default?", &params, &errmsg);
+    err = params.parse("couchbase:///default?", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("default", params.bucket());
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///%2FUsers%2F?", &params, &errmsg);
+    err = params.parse("couchbase:///%2FUsers%2F?", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("/Users/", params.bucket());
 }
@@ -231,7 +222,7 @@ TEST_F(ConnstrTest, testParseBucket)
 TEST_F(ConnstrTest, testOptionsPassthrough)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://?foo=bar", &params, &errmsg);
+    err = params.parse("couchbase://?foo=bar", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Options only";
     ASSERT_FALSE(params.options().empty());
     ASSERT_NE(0, params.options().size());
@@ -241,19 +232,19 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
     ASSERT_EQ("bar", op.value);
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=bar", &params, &errmsg);
+    err = params.parse("couchbase://?foo=bar", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_EQ("bar", op.value);
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo", &params, &errmsg);
+    err = params.parse("couchbase://?foo", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err) << "Option without value";
 
 
     // Multiple options
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=fooval&bar=barval", &params, &errmsg);
+    err = params.parse("couchbase://?foo=fooval&bar=barval", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_EQ("fooval", op.value);
@@ -262,20 +253,18 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
     ASSERT_EQ("barval", op.value);
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///protected?ssl=on&compression=off",
-        &params, &errmsg);
+    err = params.parse("couchbase:///protected?ssl=on&compression=off", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with bucket and no hosts";
     ASSERT_EQ(1, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "localhost"));
     ASSERT_TRUE(findOption(&params, "compression", op));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=foo&bar=bar&", &params, &errmsg);
+    err = params.parse("couchbase://?foo=foo&bar=bar&", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with trailing '&'";
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=foo&bootstrap_on=all&bar=bar",
-        &params, &errmsg);
+    err = params.parse("couchbase://?foo=foo&bootstrap_on=all&bar=bar", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with non-passthrough option";
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_TRUE(findOption(&params, "bar", op));
@@ -285,32 +274,32 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
 TEST_F(ConnstrTest, testRecognizedOptions)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbases://", &params, &errmsg);
+    err = params.parse("couchbases://", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?ssl=on", &params, &errmsg);
+    err = params.parse("couchbase://?ssl=on", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
 
     reinit();
-    err = lcb_connspec_parse("couchbases://?ssl=no_verify", &params, &errmsg);
+    err = params.parse("couchbases://?ssl=no_verify", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED|LCB_SSL_NOVERIFY, params.sslopts());
 
     reinit();
-    err = lcb_connspec_parse("couchbases://?ssl=off", &params, &errmsg);
+    err = params.parse("couchbases://?ssl=off", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
     // Loglevel
     reinit();
-    err = lcb_connspec_parse("couchbase://?console_log_level=5", &params, &errmsg);
+    err = params.parse("couchbase://?console_log_level=5", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(5, params.loglevel());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?console_log_level=gah", &params, &errmsg);
+    err = params.parse("couchbase://?console_log_level=gah", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
 }
@@ -318,30 +307,30 @@ TEST_F(ConnstrTest, testRecognizedOptions)
 TEST_F(ConnstrTest, testTransportOptions)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://", &params, &errmsg);
+    err = params.parse("couchbase://", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_FALSE(params.is_bs_udef());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=cccp", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=cccp", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "bootstrap_on=cccp";
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_CCCP));
     ASSERT_FALSE(params.has_bsmode(LCB_CONFIG_TRANSPORT_HTTP));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=http", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=http", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "bootstrap_on=http";
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_HTTP));
     ASSERT_FALSE(params.has_bsmode(LCB_CONFIG_TRANSPORT_CCCP));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=all", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=all", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "bootstrap_on=all";
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_CCCP));
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_HTTP));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=bleh", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=bleh", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err) << "Error on bad bootstrap_on value";
 }
 
@@ -355,7 +344,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.v.v0.host = "foo.com;bar.com;baz.com";
     cropts.v.v0.passwd = "secret";
 
-    err = lcb_connspec_convert(&params, &cropts);
+    err = params.load(cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
     ASSERT_FALSE(NULL == findHost(&params, "bar.com"));
@@ -372,7 +361,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.version = 2;
     cropts.v.v2.host = "foo.com:9030;bar.com:9040;baz.com:9050";
     cropts.v.v2.mchosts = "foo.com:7030;bar.com:7040;baz.com:7050";
-    err = lcb_connspec_convert(&params, &cropts);
+    err = params.load(cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(6, countHosts(&params));
 
@@ -382,7 +371,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.version = 3;
     cropts.v.v3.passwd = "secret";
     cropts.v.v3.connstr = "couchbase:///fluffle?password=bleh";
-    err = lcb_connspec_convert(&params, &cropts);
+    err = params.load(cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("fluffle", params.bucket());
     ASSERT_EQ(cropts.v.v3.passwd, params.password());
@@ -393,12 +382,62 @@ TEST_F(ConnstrTest, testCertificateWithoutSSL)
     // Ensure we get an invalid input error for certificate paths without
     // couchbases://
     lcb_error_t err;
-    err = lcb_connspec_parse(
-        "couchbase://1.2.3.4/default?certpath=/foo/bar/baz", &params, &errmsg);
+    err = params.parse(
+        "couchbase://1.2.3.4/default?certpath=/foo/bar/baz", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
     reinit();
-    err = lcb_connspec_parse(
-        "couchbases://1.2.3.4/default?certpath=/foo/bar/baz", &params, &errmsg);
+    err = params.parse(
+        "couchbases://1.2.3.4/default?certpath=/foo/bar/baz", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
 }
+
+TEST_F(ConnstrTest, testDnsSrvExplicit)
+{
+    // Test various things relating to DNS SRV
+    lcb_error_t err;
+    err = params.parse("couchbase+dnssrv://1.1.1.1", &errmsg);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    EXPECT_TRUE(params.can_dnssrv());
+    EXPECT_TRUE(params.is_explicit_dnssrv());
+
+    reinit();
+    err = params.parse("couchbase+dnssrv://1.1.1.1,2.2.2.2", &errmsg);
+    EXPECT_NE(LCB_SUCCESS, err);
+
+    reinit();
+    err = params.parse("couchbases+dnssrv://1.1.1.1", &errmsg);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    EXPECT_NE(0, params.sslopts());
+    EXPECT_TRUE(params.can_dnssrv());
+    EXPECT_TRUE(params.is_explicit_dnssrv());
+}
+
+TEST_F(ConnstrTest, testDnsSrvImplicit)
+{
+    lcb_error_t err;
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://"));
+    EXPECT_FALSE(params.can_dnssrv());
+    EXPECT_FALSE(params.is_explicit_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1"));
+    EXPECT_TRUE(params.can_dnssrv());
+    EXPECT_FALSE(params.is_explicit_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1,2.2.2.2"));
+    EXPECT_FALSE(params.can_dnssrv()) << "No implicit SRV on multiple hosts";
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1:666"));
+    EXPECT_FALSE(params.can_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1:11210"));
+    EXPECT_TRUE(params.can_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbases://1.1.1.1"));
+    EXPECT_TRUE(params.can_dnssrv());
+}