libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/probes.d

@@ -28,7 +28,7 @@ provider libcouchbase {
                   uint16_t,     /* return code (from libcouchbase) */
                   const char*,  /* key */
                   size_t,       /* nkey */
-                  const void*,  /* bytes */
+                  const char*,  /* bytes */
                   size_t,       /* nbytes */
                   uint32_t,     /* flags */
                   uint64_t,     /* cas */

data/ext/libcouchbase/src/rdb/rope.c

@@ -395,7 +395,7 @@ dump_ropebuf(const rdb_ROPEBUF *buf, FILE *fp)
         rdb_ROPESEG *seg = LCB_LIST_ITEM(llcur, rdb_ROPESEG, llnode);
         fprintf(fp, "%sSEG=%p\n", indent, (void*)seg);
         fprintf(fp, "%sALLOCATOR=%p [%u]\n", indent, (void*)seg->allocator, seg->allocid);
-        fprintf(fp, "%sBUFROOT=%p\n", indent, seg->root);
+        fprintf(fp, "%sBUFROOT=%p\n", indent, (void *)seg->root);
         fprintf(fp, "%sALLOC SIZE: %u\n", indent, seg->nalloc);
         fprintf(fp, "%sDATA SIZE: %u\n", indent, seg->nused);
         fprintf(fp, "%sDATS OFFSET: %u\n", indent, seg->start);

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

@@ -20,8 +20,8 @@
 int
 lcb_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_error_t err)
 {
-    lcb_RETRYCMDOPTS policy;
-    lcb_RETRYMODEOPTS mode;
+    unsigned policy;
+    unsigned mode;
     protocol_binary_request_header hdr;
 
     mcreq_read_hdr(pkt, &hdr);
@@ -70,7 +70,6 @@ lcb_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_error_t
 
     /* get is a safe operation which may be retried */
     case PROTOCOL_BINARY_CMD_GET:
-    case PROTOCOL_BINARY_CMD_GETKQ:
     case PROTOCOL_BINARY_CMD_SUBDOC_GET:
     case PROTOCOL_BINARY_CMD_SUBDOC_EXISTS:
     case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP:

data/ext/libcouchbase/src/retryq.cc

@@ -37,7 +37,13 @@ struct lcb::RetryOp : mc_EPKTDATUM, SchedNode, TmoNode {
     hrtime_t trytime; /**< Next retry time */
     mc_PACKET *pkt;
     lcb_error_t origerr;
-    RetryOp();
+    errmap::RetrySpec *spec;
+    RetryOp(errmap::RetrySpec *spec);
+    ~RetryOp() {
+        if (spec != NULL) {
+            spec->unref();
+        }
+    }
 };
 
 static RetryOp *from_schednode(lcb_list_t *ll) {
@@ -79,10 +85,24 @@ RetryQueue::update_trytime(RetryOp *op, hrtime_t now)
     if (!now) {
         now = gethrtime();
     }
-    op->trytime = now + (hrtime_t) (
-            (float)get_retry_interval() *
-            (float)op->pkt->retries *
-            (float)settings->retry_backoff);
+
+    if (op->spec) {
+        uint32_t us_trytime = op->spec->get_next_interval(op->pkt->retries - 1);
+        if (op->pkt->retries == 1) {
+            us_trytime += op->spec->after;
+        }
+        if (!us_trytime) {
+            goto GT_DEFAULT;
+        }
+        op->trytime = now + (LCB_US2NS(us_trytime));
+    } else {
+        GT_DEFAULT:
+        op->trytime = now + (hrtime_t) (
+                (float)get_retry_interval() *
+                (float)op->pkt->retries *
+                (float)settings->retry_backoff);
+
+    }
 }
 
 /** Comparison routine for sorting by timeout */
@@ -139,7 +159,7 @@ RetryQueue::fail(RetryOp *op, lcb_error_t err)
                            PROTOCOL_BINARY_RESPONSE_EINVAL);
 
     assign_error(op, err);
-    lcb_log(LOGARGS(this, WARN), "Failing command (seq=%u) from retry queue with error code 0x%x", op->pkt->opaque, op->origerr);
+    lcb_log(LOGARGS(this, WARN), "Failing command (seq=%u) from retry queue: %s", op->pkt->opaque, lcb_strerror_short(op->origerr));
 
     mcreq_dispatch_response(&tmpsrv, op->pkt, &resp, op->origerr);
     op->pkt->flags |= MCREQ_F_FLUSHED|MCREQ_F_INVOKED;
@@ -231,8 +251,8 @@ RetryQueue::flush(bool throttle)
              * configuration (i.e. the attempt has not been throttled) then
              * keep the command in there until it has a chance to be scheduled.
              */
-            lcb_bootstrap_common(get_instance(), LCB_BS_REFRESH_THROTTLE);
-            if (lcb_confmon_is_refreshing(get_instance()->confmon) ||
+            get_instance()->bootstrap(lcb::BS_REFRESH_THROTTLE);
+            if (get_instance()->confmon->is_refreshing() ||
                     settings->retry[LCB_RETRY_ON_MISSINGNODE]) {
 
                 lcb_list_delete(static_cast<SchedNode*>(op));
@@ -276,22 +296,40 @@ static void op_dtorfn(mc_EPKTDATUM *d) {
     delete static_cast<RetryOp*>(d);
 }
 
-RetryOp::RetryOp() {
-    memset(this, 0, sizeof *this);
+RetryOp::RetryOp(errmap::RetrySpec *spec_)
+    : mc_EPKTDATUM(), start(0), trytime(0), pkt(NULL), origerr(LCB_SUCCESS),
+      spec(spec_) {
     mc_EPKTDATUM::dtorfn = op_dtorfn;
     mc_EPKTDATUM::key = RETRY_PKT_KEY;
+
+    if (spec != NULL) {
+        spec->ref();
+    }
 }
 
 void
-RetryQueue::add(mc_EXPACKET *pkt, const lcb_error_t err, int options)
+RetryQueue::add(mc_EXPACKET *pkt, const lcb_error_t err,
+                errmap::RetrySpec *spec, int options)
 {
     RetryOp *op;
     mc_EPKTDATUM *d = mcreq_epkt_find(pkt, RETRY_PKT_KEY);
     if (d) {
         op = static_cast<RetryOp *>(d);
     } else {
-        op = new RetryOp();
+        op = new RetryOp(NULL);
         op->start = MCREQ_PKT_RDATA(&pkt->base)->start;
+        if (spec) {
+            op->spec = spec;
+            spec->ref();
+
+            if (spec->max_duration && spec->max_duration < settings->operation_timeout) {
+                // Offset the start by the difference between the duration and
+                // the timeout. We really use this number only for calculating
+                // the timeout, so it shouldn't hurt to fake it.
+                uint32_t diff = settings->operation_timeout - op->spec->max_duration;
+                op->start -= LCB_US2NS(diff);
+            }
+        }
         mcreq_epkt_insert(pkt, op);
     }
 
@@ -320,7 +358,7 @@ RetryQueue::nmvadd(mc_EXPACKET *detchpkt)
     if (settings->nmv_retry_imm) {
         flags = RETRY_SCHED_IMM;
     }
-    add(detchpkt, LCB_NOT_MY_VBUCKET, flags);
+    add(detchpkt, LCB_NOT_MY_VBUCKET, NULL, flags);
 }
 
 static void
@@ -332,7 +370,7 @@ fallback_handler(mc_CMDQUEUE *cq, mc_PACKET *pkt)
 
 void RetryQueue::add_fallback(mc_PACKET *pkt) {
     mc_PACKET *copy = mcreq_renew_packet(pkt);
-    add((mc_EXPACKET*)copy, LCB_NO_MATCHING_SERVER, RETRY_SCHED_IMM);
+    add((mc_EXPACKET*)copy, LCB_NO_MATCHING_SERVER, NULL, RETRY_SCHED_IMM);
 }
 
 void

data/ext/libcouchbase/src/retryq.h

@@ -72,8 +72,8 @@ public:
      * it may _not_ be used for memcached buckets (which is typically OK, as we only
      * map things here as a response for a not-my-vbucket).
      */
-    void add(mc_EXPACKET *detchpkt, lcb_error_t err) {
-        add(detchpkt, err, 0);
+    void add(mc_EXPACKET *detchpkt, lcb_error_t err, errmap::RetrySpec *spec) {
+        add(detchpkt, err, spec, 0);
     }
 
     /**
@@ -151,7 +151,7 @@ private:
     enum AddOptions {
         RETRY_SCHED_IMM = 0x01
     };
-    void add(mc_EXPACKET *pkt, lcb_error_t, int options);
+    void add(mc_EXPACKET *pkt, lcb_error_t, errmap::RetrySpec*, int options);
 
     /** List of operations in retry ordering. Sorted by 'crtime' */
     lcb_list_t schedops;

data/ext/libcouchbase/src/settings.c

@@ -57,6 +57,9 @@ void lcb_default_settings(lcb_settings *settings)
     settings->tcp_nodelay = LCB_DEFAULT_TCP_NODELAY;
     settings->retry_nmv_interval = LCB_DEFAULT_RETRY_NMV_INTERVAL;
     settings->vb_noguess = LCB_DEFAULT_VB_NOGUESS;
+    settings->select_bucket = LCB_DEFAULT_SELECT_BUCKET;
+    settings->tcp_keepalive = LCB_DEFAULT_TCP_KEEPALIVE;
+    settings->send_hello = 1;
 }
 
 LCB_INTERNAL_API
@@ -67,6 +70,7 @@ lcb_settings_new(void)
     lcb_default_settings(settings);
     settings->refcount = 1;
     settings->auth = lcbauth_new();
+    settings->errmap = lcb_errmap_new();
     return settings;
 }
 
@@ -83,6 +87,7 @@ lcb_settings_unref(lcb_settings *settings)
     free(settings->client_string);
 
     lcbauth_unref(settings->auth);
+    lcb_errmap_free(settings->errmap);
 
     if (settings->ssl_ctx) {
         lcbio_ssl_free(settings->ssl_ctx);

data/ext/libcouchbase/src/settings.h

@@ -84,9 +84,12 @@
 #define LCB_DEFAULT_RETRY_NMV_INTERVAL LCB_MS2US(100)
 #define LCB_DEFAULT_VB_NOGUESS 1
 #define LCB_DEFAULT_TCP_NODELAY 1
+#define LCB_DEFAULT_SELECT_BUCKET 1
+#define LCB_DEFAULT_TCP_KEEPALIVE 1
 
 #include "config.h"
 #include <libcouchbase/couchbase.h>
+#include "errmap.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -128,6 +131,9 @@ typedef struct lcb_settings_st {
      * updates. */
     lcb_U32 bc_http_stream_time;
 
+    /** Time to wait in between background config polls. 0 disables this */
+    lcb_U32 config_poll_interval;
+
     unsigned bc_http_urltype : 4;
 
     /** Don't guess next vbucket server. Mainly for testing */
@@ -148,6 +154,10 @@ typedef struct lcb_settings_st {
     unsigned ipv6 : 2;
     unsigned tcp_nodelay : 1;
     unsigned readj_ts_wait : 1;
+    unsigned use_errmap : 1;
+    unsigned select_bucket : 1;
+    unsigned tcp_keepalive : 1;
+    unsigned send_hello : 1;
 
     short max_redir;
     unsigned refcount;
@@ -165,6 +175,7 @@ typedef struct lcb_settings_st {
     void (*dtorcb)(const void *);
     void *dtorarg;
     char *client_string;
+    lcb_pERRMAP errmap;
     lcb_U32 retry_nmv_interval;
 } lcb_settings;
 

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

@@ -137,6 +137,7 @@ async_write(void *arg)
 {
     lcbio_CSSL *cs = arg;
     appdata_encode(cs);
+    schedule_wants(cs);
     appdata_free_flushed(cs);
 }
 

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

@@ -156,7 +156,9 @@ iotssl_log_errors(lcbio_XSSL *xs)
         if (ERR_GET_LIB(curerr) == ERR_LIB_SSL) {
             switch (ERR_GET_REASON(curerr)) {
             case SSL_R_CERTIFICATE_VERIFY_FAILED:
+#ifdef SSL_R_MISSING_VERIFY_MESSAGE
             case SSL_R_MISSING_VERIFY_MESSAGE:
+#endif
                 xs->errcode = LCB_SSL_CANTVERIFY;
                 break;
 

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

@@ -16,7 +16,6 @@
  */
 
 #include "ssl_iot_common.h"
-#include "simplestring.h"
 #include <openssl/err.h>
 /**
  * Event-Style SSL Wrapping.

data/ext/libcouchbase/src/strcodecs/strcodecs.h

@@ -105,7 +105,7 @@ bool urldecode(Ti first, Ti last, To out, size_t& nout) {
 
 inline bool
 urldecode(const char *input, char *output) {
-    const char *endp = NULL;
+    const char *endp = input + strlen(input);
     size_t nout = 0;
     if (urldecode(input, endp, output, nout)) {
         output[nout] = '\0';

data/ext/libcouchbase/src/trace.h

@@ -40,11 +40,11 @@
 
 #define TRACE_BEGIN_COMMON(TGT, req, cmd,  ...) \
     TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-    (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes, ## __VA_ARGS__)
+    (const char *)((cmd)->key.contig.bytes), (cmd)->key.contig.nbytes, ## __VA_ARGS__)
 
 #define TRACE_BEGIN_SIMPLE(TGT, req, cmd) \
     TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-        (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
+        (const char *)(cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
 
 #define TRACE_END_COMMON(TGT, mcresp, resp, ...) \
     TGT(mcresp->opaque(), 0, mcresp->opcode(), (resp)->rc, (const char *)(resp)->key, (resp)->nkey, \
@@ -58,7 +58,7 @@
 
 #define TRACE_GET_END(mcresp, resp) \
     TRACE(TRACE_END_COMMON(LIBCOUCHBASE_GET_END, mcresp, resp, \
-        (char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
+        (const char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
         mcresp->datatype()))
 
 #define TRACE_UNLOCK_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_UNLOCK_BEGIN, req, cmd))
@@ -66,7 +66,7 @@
 
 #define TRACE_STORE_BEGIN(req, cmd) \
     TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_STORE_BEGIN, req, cmd, \
-        ( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
+        (const char *)( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
         ( (cmd)->value.vtype == LCB_KV_IOV ? 0 : (cmd)->value.u_buf.contig.nbytes ),\
         (cmd)->flags, (cmd)->cas, (req)->request.datatype, (cmd)->exptime))
 

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

@@ -26,7 +26,6 @@
 #include "json-inl.h"
 #include "hash.h"
 #include "crc32.h"
-#include "simplestring.h"
 
 #define STRINGIFY_(X) #X
 #define STRINGIFY(X) STRINGIFY_(X)
@@ -1367,15 +1366,12 @@ lcbvb_genconfig_ex(lcbvb_CONFIG *vb,
         }
     }
 
-    if (!vb->ndatasrv) {
-        vb->errstr = "No data servers in list";
-        return -1;
-    }
-
-    vb->vbuckets = malloc(vb->nvb * sizeof(*vb->vbuckets));
-    if (!vb->vbuckets) {
-        vb->errstr = "Couldn't allocate vbucket array";
-        return -1;
+    if (vb->nvb) {
+        vb->vbuckets = malloc(vb->nvb * sizeof(*vb->vbuckets));
+        if (!vb->vbuckets) {
+            vb->errstr = "Couldn't allocate vbucket array";
+            return -1;
+        }
     }
 
     for (ii = 0; ii < vb->nvb; ii++) {

data/ext/libcouchbase/src/views/{docreq.c → docreq.cc}

@@ -2,56 +2,53 @@
 #include "internal.h"
 #include "sllist-inl.h"
 
+using namespace lcb::docreq;
+
 static void docreq_handler(void *arg);
-static void invoke_pending(lcb_DOCQUEUE*);
+static void invoke_pending(Queue*);
 static void doc_callback(lcb_t,int, const lcb_RESPBASE *);
 
 #define MAX_PENDING_DOCREQ 10
 #define MIN_SCHED_SIZE 5
 #define DOCQ_DELAY_US 200000
 
-#define DOCQ_REF(q) (q)->refcount++
-#define DOCQ_UNREF(q) if (!--(q)->refcount) { docq_free(q); }
-
-lcb_DOCQUEUE *
-lcbdocq_create(lcb_t instance)
-{
-    lcb_DOCQUEUE *q = calloc(1, sizeof *q);
-    q->timer = lcbio_timer_new(instance->iotable, q, docreq_handler);
-    q->refcount = 1;
-    q->instance = instance;
-    q->max_pending_response = MAX_PENDING_DOCREQ;
-    q->min_batch_size = MIN_SCHED_SIZE;
-    return q;
+Queue::Queue(lcb_t instance_)
+    : instance(instance_),
+      parent(NULL),
+      timer(lcbio_timer_new(instance->iotable, this, docreq_handler)),
+      cb_ready(NULL), cb_throttle(NULL),
+      n_awaiting_schedule(0),
+      n_awaiting_response(0),
+      max_pending_response(MAX_PENDING_DOCREQ),
+      min_batch_size(MIN_SCHED_SIZE),
+      cancelled(false),
+      refcount(1)
+      {
+
+    memset(&pending_gets, 0, sizeof pending_gets);
+    memset(&cb_queue, 0, sizeof cb_queue);
 }
 
-static void
-docq_free(lcb_DOCQUEUE *q)
-{
-    lcbdocq_cancel(q);
-    lcbio_timer_destroy(q->timer);
-    free(q);
+Queue::~Queue() {
+    cancel();
+    lcbio_timer_destroy(timer);
 }
 
-void
-lcbdocq_unref(lcb_DOCQUEUE *q)
-{
-    DOCQ_UNREF(q);
+void Queue::unref() {
+    if (!--refcount) {
+        delete this;
+    }
 }
 
-void
-lcbdocq_cancel(lcb_DOCQUEUE *q)
-{
-    if (!q->cancelled) {
-        q->cancelled = 1;
-    }
+void Queue::cancel() {
+    cancelled = true;
 }
 
 /* Calling this function ensures that the request will be scheduled in due
  * time. This may be done at the next event loop iteration, or after a delay
  * depending on how many items are actually found within the queue. */
 static void
-docq_poke(lcb_DOCQUEUE *q)
+docq_poke(Queue *q)
 {
     if (q->n_awaiting_response < q->max_pending_response) {
         if (q->n_awaiting_schedule > q->min_batch_size) {
@@ -65,27 +62,26 @@ docq_poke(lcb_DOCQUEUE *q)
     }
 }
 
-void
-lcbdocq_add(lcb_DOCQUEUE *q, lcb_DOCQREQ *req)
+void Queue::add(DocRequest *req)
 {
-    sllist_append(&q->pending_gets, &req->slnode);
-    q->n_awaiting_schedule++;
-    req->parent = q;
+    sllist_append(&pending_gets, &req->slnode);
+    n_awaiting_schedule++;
+    req->parent = this;
     req->ready = 0;
-    DOCQ_REF(q);
-    docq_poke(q);
+    ref();
+    docq_poke(this);
 }
 
 static void
 docreq_handler(void *arg)
 {
-    lcb_DOCQUEUE *q = arg;
+    Queue *q = reinterpret_cast<Queue*>(arg);
     sllist_iterator iter;
     lcb_t instance = q->instance;
 
     lcb_sched_enter(instance);
     SLLIST_ITERFOR(&q->pending_gets, &iter) {
-        lcb_DOCQREQ *cont = SLLIST_ITEM(iter.cur, lcb_DOCQREQ, slnode);
+        DocRequest *cont = SLLIST_ITEM(iter.cur, DocRequest, slnode);
 
         if (q->n_awaiting_response > q->max_pending_response) {
             lcbio_timer_rearm(q->timer, DOCQ_DELAY_US);
@@ -136,13 +132,12 @@ docreq_handler(void *arg)
 /* Invokes the callback on all requests which are ready, until a request which
  * is not yet ready is reached. */
 static void
-invoke_pending(lcb_DOCQUEUE *q)
+invoke_pending(Queue *q)
 {
     sllist_iterator iter = { NULL };
-
-    DOCQ_REF(q);
+    q->ref();
     SLLIST_ITERFOR(&q->cb_queue, &iter) {
-        lcb_DOCQREQ *dreq = SLLIST_ITEM(iter.cur, lcb_DOCQREQ, slnode);
+        DocRequest *dreq = SLLIST_ITEM(iter.cur, DocRequest, slnode);
         void *bufh = NULL;
 
         if (dreq->ready == 0) {
@@ -157,21 +152,21 @@ invoke_pending(lcb_DOCQUEUE *q)
 
         q->cb_ready(q, dreq);
         if (bufh) {
-            lcb_backbuf_unref(bufh);
+            lcb_backbuf_unref(reinterpret_cast<lcb_BACKBUF>(bufh));
         }
-        DOCQ_UNREF(q);
+        q->unref();
     }
-    DOCQ_UNREF(q);
+    q->unref();
 }
 
 static void
-doc_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+doc_callback(lcb_t, int, const lcb_RESPBASE *rb)
 {
     const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
-    lcb_DOCQREQ *dreq = rb->cookie;
-    lcb_DOCQUEUE *q = dreq->parent;
+    DocRequest *dreq = reinterpret_cast<DocRequest*>(rb->cookie);
+    Queue *q = dreq->parent;
 
-    DOCQ_REF(q);
+    q->ref();
 
     q->n_awaiting_response--;
     dreq->docresp = *rg;
@@ -182,13 +177,12 @@ doc_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
     /* Reference the response data, since we might not be invoking this right
      * away */
     if (rg->rc == LCB_SUCCESS) {
-        lcb_backbuf_ref(dreq->docresp.bufh);
+        lcb_backbuf_ref(reinterpret_cast<lcb_BACKBUF>(dreq->docresp.bufh));
     }
 
     /* Ensure the invoke_pending doesn't destroy us */
     invoke_pending(q);
     docq_poke(q);
 
-    DOCQ_UNREF(q);
-    (void)instance; (void)cbtype;
+    q->unref();
 }