libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/src/operations/stats.cc

@@ -184,6 +184,7 @@ handle_bcast(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err,
         lcb_RESPVERBOSITY *verbosity;
         lcb_RESPMCVERSION *version;
         lcb_RESPFLUSH *flush;
+        lcb_RESPNOOP *noop;
     } u_resp;
 
     union {
@@ -191,6 +192,7 @@ handle_bcast(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err,
         lcb_RESPVERBOSITY verbosity;
         lcb_RESPMCVERSION version;
         lcb_RESPFLUSH flush;
+        lcb_RESPNOOP noop;
     } u_empty;
 
     memset(&u_empty, 0, sizeof(u_empty));
@@ -258,6 +260,8 @@ pkt_bcast_simple(lcb_t instance, const void *cookie, lcb_CALLBACKTYPE type)
             hdr.request.opcode = PROTOCOL_BINARY_CMD_FLUSH;
         } else if (type == LCB_CALLBACK_VERSIONS) {
             hdr.request.opcode = PROTOCOL_BINARY_CMD_VERSION;
+        } else if (type == LCB_CALLBACK_NOOP) {
+            hdr.request.opcode = PROTOCOL_BINARY_CMD_NOOP;
         } else {
             fprintf(stderr, "pkt_bcast_simple passed unknown type %u\n", type);
             assert(0);
@@ -284,6 +288,12 @@ lcb_server_versions3(lcb_t instance, const void *cookie, const lcb_CMDBASE *)
     return pkt_bcast_simple(instance, cookie, LCB_CALLBACK_VERSIONS);
 }
 
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_noop3(lcb_t instance, const void *cookie, const lcb_CMDNOOP *)
+{
+    return pkt_bcast_simple(instance, cookie, LCB_CALLBACK_NOOP);
+}
 
 LIBCOUCHBASE_API
 lcb_error_t

data/ext/libcouchbase/src/operations/subdoc.cc

@@ -234,8 +234,20 @@ make_doc_flags(const uint32_t user) {
 }
 
 struct MultiBuilder {
+    static unsigned infer_mode(const lcb_CMDSUBDOC *cmd) {
+        if (cmd->nspecs == 0) {
+            return 0;
+        }
+        const SubdocCmdTraits::Traits& trait = SubdocCmdTraits::find(cmd->specs[0].sdcmd);
+        if (!trait.valid()) {
+            return 0;
+        }
+        return trait.mode();
+    }
+
     MultiBuilder(const lcb_CMDSUBDOC *cmd_)
-    : cmd(cmd_), payload_size(0), mode(0) {
+    : cmd(cmd_), payload_size(0) {
+        mode = infer_mode(cmd_);
         size_t ebufsz = is_lookup() ? cmd->nspecs * 4 : cmd->nspecs * 8;
         extra_body = new char[ebufsz];
         bodysz = 0;

data/ext/libcouchbase/src/retrychk.cc

@@ -35,6 +35,7 @@ lcb_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_error_t
     case PROTOCOL_BINARY_CMD_STAT:
     case PROTOCOL_BINARY_CMD_VERBOSITY:
     case PROTOCOL_BINARY_CMD_VERSION:
+    case PROTOCOL_BINARY_CMD_NOOP:
         return 0;
     }
 

data/ext/libcouchbase/src/settings.c

@@ -60,6 +60,8 @@ void lcb_default_settings(lcb_settings *settings)
     settings->select_bucket = LCB_DEFAULT_SELECT_BUCKET;
     settings->tcp_keepalive = LCB_DEFAULT_TCP_KEEPALIVE;
     settings->send_hello = 1;
+    settings->config_poll_interval = LCB_DEFAULT_CONFIG_POLL_INTERVAL;
+    settings->use_errmap = 1;
 }
 
 LCB_INTERNAL_API

data/ext/libcouchbase/src/settings.h

@@ -23,21 +23,23 @@
  */
 
 /** Convert seconds to millis */
-#define LCB_S2MS(s) ((lcb_uint32_t)s) * 1000
+#define LCB_S2MS(s) (((lcb_uint32_t)s) * 1000)
 
 /** Convert seconds to microseconds */
-#define LCB_S2US(s) ((lcb_uint32_t)s) * 1000000
+#define LCB_S2US(s) (((lcb_uint32_t)s) * 1000000)
 
 /** Convert seconds to nanoseconds */
-#define LCB_S2NS(s) ((hrtime_t)s) * 1000000000
+#define LCB_S2NS(s) (((hrtime_t)s) * 1000000000)
 
 /** Convert nanoseconds to microseconds */
 #define LCB_NS2US(s) (lcb_uint32_t) ((s) / 1000)
 
-#define LCB_MS2US(s) (s) * 1000
+#define LCB_MS2US(s) ((s) * 1000)
 
 /** Convert microseconds to nanoseconds */
-#define LCB_US2NS(s) ((hrtime_t)s) * 1000
+#define LCB_US2NS(s) (((hrtime_t)s) * 1000)
+/** Convert milliseconds to nanoseconds */
+#define LCB_MS2NS(s) (((hrtime_t)s) * 1000000)
 
 
 #define LCB_DEFAULT_TIMEOUT LCB_MS2US(2500)
@@ -56,8 +58,8 @@
 #define LCB_DEFAULT_CONFIG_MAXIMUM_REDIRECTS 3
 #define LCB_DEFAULT_CONFIG_ERRORS_THRESHOLD 100
 
-/* 10 seconds */
-#define LCB_DEFAULT_CONFIG_ERRORS_DELAY LCB_MS2US(10000)
+/* 10 milliseconds */
+#define LCB_DEFAULT_CONFIG_ERRORS_DELAY LCB_MS2US(10)
 
 /* 1 second */
 #define LCB_DEFAULT_CLCONFIG_GRACE_CYCLE LCB_MS2US(1000)
@@ -86,6 +88,10 @@
 #define LCB_DEFAULT_TCP_NODELAY 1
 #define LCB_DEFAULT_SELECT_BUCKET 1
 #define LCB_DEFAULT_TCP_KEEPALIVE 1
+/* 2.5 s */
+#define LCB_DEFAULT_CONFIG_POLL_INTERVAL LCB_MS2US(2500)
+/* 50 ms */
+#define LCB_CONFIG_POLL_INTERVAL_FLOOR LCB_MS2US(50)
 
 #include "config.h"
 #include <libcouchbase/couchbase.h>

data/ext/libcouchbase/src/ssl/ssl_c.c

@@ -189,16 +189,26 @@ appdata_read(lcbio_CSSL *cs)
 static void
 read_callback(lcb_sockdata_t *sd, lcb_ssize_t nr, void *arg)
 {
+#if LCB_CAN_OPTIMIZE_SSL_BIO
     lcbio_CSSL *cs = arg;
+#else
+    my_WBUF *rb = arg;
+    lcbio_CSSL *cs = rb->parent;
+#endif
+
     cs->rdactive = 0;
     cs->entered++;
 
     if (nr > 0) {
+#if LCB_CAN_OPTIMIZE_SSL_BIO
         BUF_MEM *mb;
 
         BIO_clear_retry_flags(cs->rbio);
         BIO_get_mem_ptr(cs->rbio, &mb);
         mb->length += nr;
+#else
+        BIO_write(cs->rbio, rb->buf, nr);
+#endif
 
     } else if (nr == 0) {
         cs->closed = 1;
@@ -208,6 +218,9 @@ read_callback(lcb_sockdata_t *sd, lcb_ssize_t nr, void *arg)
         cs->error = 1;
         IOTSSL_ERRNO(cs) = IOT_ERRNO(cs->orig);
     }
+#if !LCB_CAN_OPTIMIZE_SSL_BIO
+    free(rb);
+#endif
 
     appdata_encode(cs);
     appdata_read(cs);
@@ -271,17 +284,30 @@ schedule_wants(lcbio_CSSL *cs)
 
         } else if (SSL_want_read(cs->ssl) || (cs->urd_cb && has_appdata == 0)) {
             /* request more data from the socket */
-            BUF_MEM *mb;
             lcb_IOV iov;
+#if LCB_CAN_OPTIMIZE_SSL_BIO
+            BUF_MEM *mb;
+#else
+#define BUFSZ 4096
+            my_WBUF *rb = malloc(sizeof(*rb) + BUFSZ);
+            rb->parent = cs;
+#endif
 
             cs->rdactive = 1;
+            lcbio_table_ref(&cs->base_);
+#if LCB_CAN_OPTIMIZE_SSL_BIO
             BIO_get_mem_ptr(cs->rbio, &mb);
             iotssl_bm_reserve(mb);
             iov.iov_base = mb->data + mb->length;
             iov.iov_len = mb->max - mb->length;
-            lcbio_table_ref(&cs->base_);
             IOT_V1(cs->orig).read2(
                 IOT_ARG(cs->orig), cs->sd, &iov, 1, cs, read_callback);
+#else
+            iov.iov_base = rb->buf;
+            iov.iov_len = BUFSZ;
+            IOT_V1(cs->orig).read2(
+                IOT_ARG(cs->orig), cs->sd, &iov, 1, rb, read_callback);
+#endif
         }
 
     }

data/ext/libcouchbase/src/ssl/ssl_common.c

@@ -127,6 +127,7 @@ iotssl_destroy_common(lcbio_XSSL *xs)
     lcbio_table_unref(xs->orig);
 }
 
+#if LCB_CAN_OPTIMIZE_SSL_BIO
 void
 iotssl_bm_reserve(BUF_MEM *bm)
 {
@@ -139,6 +140,7 @@ iotssl_bm_reserve(BUF_MEM *bm)
     }
     bm->length = oldlen;
 }
+#endif
 
 void
 iotssl_log_errors(lcbio_XSSL *xs)
@@ -428,6 +430,7 @@ ossl_init_locks(void)
     for (ii = 0; ii < nlocks; ii++) {
         ossl_lock_init(ossl_locks + ii);
     }
+    /* TODO: locking API has been removed in OpenSSL 1.1 */
     CRYPTO_set_locking_callback(ossl_lockfn);
 }
 

data/ext/libcouchbase/src/ssl/ssl_e.c

@@ -112,24 +112,38 @@ schedule_pending(lcbio_ESSL *es)
 static int
 read_ssl_data(lcbio_ESSL *es)
 {
-    BUF_MEM *rmb;
     int nr;
     lcbio_pTABLE iot = es->orig;
 
+#if LCB_CAN_OPTIMIZE_SSL_BIO
+    BUF_MEM *rmb;
+
     /* This block is an optimization over BIO_write to avoid copying the memory
      * to a temporary buffer and _then_ copying it into the BIO */
 
     BIO_get_mem_ptr(es->rbio, &rmb);
+#endif
+
     while (1) {
+#if LCB_CAN_OPTIMIZE_SSL_BIO
         /* I don't know why this is here, but it's found inside BIO_write */
         BIO_clear_retry_flags(es->rbio);
         iotssl_bm_reserve(rmb);
         nr = IOT_V0IO(iot).recv(IOT_ARG(iot), es->fd,
             rmb->data + rmb->length, rmb->max - rmb->length, 0);
+#else
+#define BUFSZ 4096
+        char buf[BUFSZ];
+        nr = IOT_V0IO(iot).recv(IOT_ARG(iot), es->fd, buf, BUFSZ, 0);
+#endif
 
         if (nr > 0) {
+#if LCB_CAN_OPTIMIZE_SSL_BIO
             /* Extend the BIO used length */
             rmb->length += nr;
+#else
+            BIO_write(es->rbio, buf, nr);
+#endif
         } else if (nr == 0) {
             es->closed = 1;
             return -1;

data/ext/libcouchbase/src/ssl/ssl_iot_common.h

@@ -31,7 +31,7 @@
     lcbio_pTABLE orig; /**< Table pointer we are wrapping */ \
     SSL *ssl; /**< SSL object */ \
     BIO *wbio; /**< BIO used for writing data to network */ \
-    BIO *rbio; /**<< BIO used for reading data from network */\
+    BIO *rbio; /**< BIO used for reading data from network */\
     lcb_io_opt_t iops_dummy_; /**< Dummy IOPS structure which is exposed to LCB */ \
     int error; /**< Internal error flag set once a fatal error is detect */\
     lcb_error_t errcode; /**< The error, converted into libcouchbase */
@@ -113,6 +113,7 @@ iotssl_init_common(lcbio_XSSL *xs, lcbio_TABLE *orig, SSL_CTX *ctx);
 void
 iotssl_destroy_common(lcbio_XSSL *xs);
 
+#if LCB_CAN_OPTIMIZE_SSL_BIO
 /**
  * Reserve a specified amount of bytes for reading into a `BUF_MEM*` structure.
  * Currently the amount reserved is hard coded.
@@ -132,6 +133,7 @@ iotssl_destroy_common(lcbio_XSSL *xs);
  */
 void
 iotssl_bm_reserve(BUF_MEM *bm);
+#endif
 
 /**
  * Prepare the SSL structure so that a subsequent call to SSL_pending will

data/ext/libcouchbase/src/timings.c

@@ -111,7 +111,6 @@ lcb_histogram_read(const lcb_HISTOGRAM *hg,
         start = end + 1;
     }
 
-    start = 1000;
     for (ii = 1; ii < 9; ++ii) {
         start = ii * 1000;
         end = ((ii + 1) * 1000) - 1;

data/ext/libcouchbase/src/vbucket/vbucket.c

@@ -329,6 +329,7 @@ extract_services(lcbvb_CONFIG *cfg, cJSON *jsvc, lcbvb_SERVICES *svc, int is_ssl
     EXTRACT_SERVICE("fts", fts);
     EXTRACT_SERVICE("indexAdmin", ixadmin);
     EXTRACT_SERVICE("indexScan", ixquery);
+    EXTRACT_SERVICE("cbas", cbas);
 
     #undef EXTRACT_SERVICE
 
@@ -360,6 +361,9 @@ build_server_strings(lcbvb_CONFIG *cfg, lcbvb_SERVER *server)
     if (server->ftspath == NULL && server->svc.fts) {
         server->ftspath = strdup("/");
     }
+    if (server->cbaspath == NULL && server->svc.cbas) {
+        server->cbaspath = strdup("/query/service");
+    }
     return 1;
 }
 
@@ -538,6 +542,36 @@ lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
         cfg->revid = -1;
     }
 
+    cfg->caps = 0;
+    {
+        cJSON *jcaps = NULL;
+        if (get_jarray(cj, "bucketCapabilities", &jcaps)) {
+            unsigned ncaps = cJSON_GetArraySize(jcaps);
+            for (ii = 0; ii < ncaps; ii++) {
+                cJSON *jcap = cJSON_GetArrayItem(jcaps, ii);
+                if (jcap || jcap->type == cJSON_String) {
+                    if (strcmp(jcap->valuestring, "xattr") == 0) {
+                        cfg->caps |= LCBVB_CAP_XATTR;
+                    } else if (strcmp(jcap->valuestring, "dcp") == 0) {
+                        cfg->caps |= LCBVB_CAP_DCP;
+                    } else if (strcmp(jcap->valuestring, "cbhello") == 0) {
+                        cfg->caps |= LCBVB_CAP_CBHELLO;
+                    } else if (strcmp(jcap->valuestring, "touch") == 0) {
+                        cfg->caps |= LCBVB_CAP_TOUCH;
+                    } else if (strcmp(jcap->valuestring, "couchapi") == 0) {
+                        cfg->caps |= LCBVB_CAP_COUCHAPI;
+                    } else if (strcmp(jcap->valuestring, "cccp") == 0) {
+                        cfg->caps |= LCBVB_CAP_CCCP;
+                    } else if (strcmp(jcap->valuestring, "xdcrCheckpointing") == 0) {
+                        cfg->caps |= LCBVB_CAP_XDCR_CHECKPOINTING;
+                    } else if (strcmp(jcap->valuestring, "nodesExt") == 0) {
+                        cfg->caps |= LCBVB_CAP_NODES_EXT;
+                    }
+                }
+            }
+        }
+    }
+
     /** Get the number of nodes. This traverses the list. Yuck */
     cfg->nsrv = cJSON_GetArraySize(jnodes);
 
@@ -680,6 +714,7 @@ free_service_strs(lcbvb_SERVICES *svc)
     free(svc->views_base_);
     free(svc->query_base_);
     free(svc->fts_base_);
+    free(svc->cbas_base_);
 }
 
 void
@@ -692,6 +727,7 @@ lcbvb_destroy(lcbvb_CONFIG *conf)
         free(srv->viewpath);
         free(srv->querypath);
         free(srv->ftspath);
+        free(srv->cbaspath);
         free_service_strs(&srv->svc);
         free_service_strs(&srv->svc_ssl);
     }
@@ -1115,6 +1151,8 @@ lcbvb_get_port(lcbvb_CONFIG *cfg,
         return svc->n1ql;
     } else if (type == LCBVB_SVCTYPE_FTS) {
         return svc->fts;
+    } else if (type == LCBVB_SVCTYPE_CBAS) {
+        return svc->cbas;
     } else {
         return 0;
     }
@@ -1190,7 +1228,8 @@ lcbvb_get_randhost_ex(const lcbvb_CONFIG *cfg,
                 (type == LCBVB_SVCTYPE_MGMT && svcs->mgmt) ||
                 (type == LCBVB_SVCTYPE_N1QL && svcs->n1ql) ||
                 (type == LCBVB_SVCTYPE_FTS && svcs->fts) ||
-                (type == LCBVB_SVCTYPE_VIEWS && svcs->views);
+                (type == LCBVB_SVCTYPE_VIEWS && svcs->views) ||
+                (type == LCBVB_SVCTYPE_CBAS && svcs->cbas);
 
         if (has_svc) {
             cfg->randbuf[oix++] = (int)nn;
@@ -1251,6 +1290,9 @@ lcbvb_get_resturl(lcbvb_CONFIG *cfg, unsigned ix,
     } else if (svc == LCBVB_SVCTYPE_FTS) {
         path = srv->ftspath;
         strp = &svcs->fts_base_;
+    } else if (svc == LCBVB_SVCTYPE_CBAS) {
+        path = srv->cbaspath;
+        strp = &svcs->cbas_base_;
     } else {
         /* Unknown service! */
         return NULL;
@@ -1310,6 +1352,9 @@ copy_service(const char *hostname,
     if (src->fts_base_) {
         dst->fts_base_ = strdup(src->fts_base_);
     }
+    if (src->cbas_base_) {
+        dst->cbas_base_ = strdup(src->cbas_base_);
+    }
     if (dst->data) {
         sprintf(buf, "%s:%d", hostname, dst->data);
         dst->hoststrs[LCBVB_SVCTYPE_DATA] = strdup(buf);
@@ -1401,6 +1446,9 @@ lcbvb_genconfig_ex(lcbvb_CONFIG *vb,
         if (src->ftspath) {
             dst->ftspath = strdup(src->ftspath);
         }
+        if (src->cbaspath) {
+            dst->cbaspath = strdup(src->cbaspath);
+        }
 
         copy_service(src->hostname, &src->svc, &dst->svc);
         copy_service(src->hostname, &src->svc_ssl, &dst->svc_ssl);

data/ext/libcouchbase/tests/iotests/mock-environment.cc

@@ -21,6 +21,9 @@
 #include <mocksupport/server.h>
 #include "mock-environment.h"
 #include <sstream>
+#include "internal.h" /* settings from lcb_t for logging */
+
+#define LOGARGS(instance, lvl) instance->settings, "tests-ENV", LCB_LOG_##lvl, __FILE__, __LINE__
 
 MockEnvironment *MockEnvironment::instance;
 
@@ -66,9 +69,10 @@ MockEnvironment::MockEnvironment(const char **args, std::string bucketname)
     SetUp();
 }
 
-void MockEnvironment::failoverNode(int index, std::string bucket)
+void MockEnvironment::failoverNode(int index, std::string bucket, bool rebalance)
 {
     MockBucketCommand bCmd(MockCommand::FAILOVER, index, bucket);
+    bCmd.set("rebalance", rebalance);
     sendCommand(bCmd);
     getResponse();
 }
@@ -250,44 +254,61 @@ void MockEnvironment::createConnection(lcb_t &instance)
 
 }
 
-#define STAT_EP_VERSION "ep_version"
+#define STAT_VERSION "version"
 
 extern "C" {
-    static void statsCallback(lcb_t, const void *cookie,
-                              lcb_error_t err,
-                              const lcb_server_stat_resp_t *resp)
-    {
-        MockEnvironment *me = (MockEnvironment *)cookie;
-        ASSERT_EQ(LCB_SUCCESS, err);
-
-        if (resp->v.v0.server_endpoint == NULL) {
-            return;
-        }
-
-        if (!resp->v.v0.nkey) {
-            return;
-        }
+static void statsCallback(lcb_t instance, const void *cookie, lcb_error_t err, const lcb_server_stat_resp_t *resp)
+{
+    MockEnvironment *me = (MockEnvironment *)cookie;
+    ASSERT_EQ(LCB_SUCCESS, err);
 
-        if (resp->v.v0.nkey != sizeof(STAT_EP_VERSION) - 1  ||
-                memcmp(resp->v.v0.key, STAT_EP_VERSION,
-                       sizeof(STAT_EP_VERSION) - 1) != 0) {
-            return;
-        }
-        int version = ((const char *)resp->v.v0.bytes)[0] - '0';
-        if (version == 1) {
-            me->setServerVersion(MockEnvironment::VERSION_10);
-        } else if (version == 2) {
-            me->setServerVersion(MockEnvironment::VERSION_20);
+    if (resp->v.v0.server_endpoint == NULL) {
+        return;
+    }
 
-        } else {
-            std::cerr << "Unable to determine version from string '";
-            std::cerr.write((const char *)resp->v.v0.bytes,
-                            resp->v.v0.nbytes);
-            std::cerr << "' assuming 1.x" << std::endl;
+    if (!resp->v.v0.nkey) {
+        return;
+    }
 
-            me->setServerVersion(MockEnvironment::VERSION_10);
+    if (resp->v.v0.nkey != sizeof(STAT_VERSION) - 1 ||
+        memcmp(resp->v.v0.key, STAT_VERSION, sizeof(STAT_VERSION) - 1) != 0) {
+        return;
+    }
+    MockEnvironment::ServerVersion version = MockEnvironment::VERSION_UNKNOWN;
+    if (resp->v.v0.nbytes > 2) {
+        int major = ((const char *)resp->v.v0.bytes)[0] - '0';
+        int minor = ((const char *)resp->v.v0.bytes)[2] - '0';
+        switch (major) {
+            case 4:
+                switch (minor) {
+                    case 0:
+                        version = MockEnvironment::VERSION_40;
+                        break;
+                    case 1:
+                        version = MockEnvironment::VERSION_41;
+                        break;
+                    case 5:
+                        version = MockEnvironment::VERSION_45;
+                        break;
+                    case 6:
+                        version = MockEnvironment::VERSION_46;
+                        break;
+                }
+                break;
+            case 5:
+                version = MockEnvironment::VERSION_50;
+                break;
         }
     }
+    if (version == MockEnvironment::VERSION_UNKNOWN) {
+        lcb_log(LOGARGS(instance, ERROR), "Unable to determine version from string '%.*s', assuming 4.0",
+                (int)resp->v.v0.nbytes, (const char *)resp->v.v0.bytes);
+        version = MockEnvironment::VERSION_40;
+    }
+    me->setServerVersion(version);
+    lcb_log(LOGARGS(instance, INFO), "Using real cluster version %.*s (id=%d)", (int)resp->v.v0.nbytes,
+            (const char *)resp->v.v0.bytes, version);
+}
 }
 
 void MockEnvironment::bootstrapRealCluster()
@@ -318,14 +339,11 @@ void MockEnvironment::bootstrapRealCluster()
         // no body
     }
 
-    if (serverVersion == VERSION_20) {
-        // Couchbase 2.0.x
-        featureRegistry.insert("observe");
-        featureRegistry.insert("views");
-        featureRegistry.insert("http");
-        featureRegistry.insert("replica_read");
-        featureRegistry.insert("lock");
-    }
+    featureRegistry.insert("observe");
+    featureRegistry.insert("views");
+    featureRegistry.insert("http");
+    featureRegistry.insert("replica_read");
+    featureRegistry.insert("lock");
 
     numNodes = ii;
     lcb_destroy(tmphandle);