libcouchbase 0.2.0 → 0.3.1

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

@@ -22,9 +22,14 @@ struct BcastCookie : mc_REQDATAEX {
     int remaining;
 
     BcastCookie(lcb_CALLBACKTYPE type_,
-                const mc_REQDATAPROCS* procs_, const void *cookie_)
-        : mc_REQDATAEX(cookie_, *procs_, gethrtime()),
-          type(type_), remaining(0) {
+                 mc_REQDATAPROCS* procs_,
+                 const void *cookie_) {
+
+        mc_REQDATAEX::procs = procs_;
+        mc_REQDATAEX::cookie = cookie_;
+        mc_REQDATAEX::start = gethrtime();
+        type = type_;
+        remaining = 0;
     }
 };
 

data/ext/libcouchbase/src/operations/{store.cc → store.c}

@@ -19,30 +19,23 @@
 #include "trace.h"
 #include "durability_internal.h"
 
-struct DurStoreCtx : mc_REQDATAEX {
+typedef struct {
+    mc_REQDATAEX base;
     lcb_t instance;
     lcb_U16 persist_to;
     lcb_U16 replicate_to;
-
-    static mc_REQDATAPROCS proctable;
-
-    DurStoreCtx(lcb_t instance_, lcb_U16 persist_, lcb_U16 replicate_,
-                const void *cookie_)
-        : mc_REQDATAEX(cookie_, proctable, gethrtime()),
-          instance(instance_), persist_to(persist_), replicate_to(replicate_) {
-    }
-};
+} DURSTORECTX;
 
 /** Observe stuff */
 static void
-handle_dur_storecb(mc_PIPELINE *, mc_PACKET *pkt,
+handle_dur_storecb(mc_PIPELINE *pl, mc_PACKET *pkt,
     lcb_error_t err, const void *arg)
 {
     lcb_RESPCALLBACK cb;
     lcb_RESPSTOREDUR resp = { 0 };
     lcb_CMDENDURE dcmd = { 0 };
     const lcb_MUTATION_TOKEN *mt;
-    DurStoreCtx *dctx = static_cast<DurStoreCtx*>(pkt->u_rdata.exdata);
+    DURSTORECTX *dctx = (DURSTORECTX *)pkt->u_rdata.exdata;
     lcb_MULTICMD_CTX *mctx;
     lcb_durability_opts_t opts = { 0 };
     const lcb_RESPSTORE *sresp = (const lcb_RESPSTORE *)arg;
@@ -85,7 +78,7 @@ handle_dur_storecb(mc_PIPELINE *, mc_PACKET *pkt,
 
     if (err == LCB_SUCCESS) {
         /* Everything OK? */
-        delete dctx;
+        free(dctx);
         return;
     }
 
@@ -99,15 +92,20 @@ handle_dur_storecb(mc_PIPELINE *, mc_PACKET *pkt,
         resp.dur_resp = &dresp;
         cb = lcb_find_callback(dctx->instance, LCB_CALLBACK_STOREDUR);
         cb(dctx->instance, LCB_CALLBACK_STOREDUR, (const lcb_RESPBASE*)&resp);
-        delete dctx;
+        free(dctx);
     }
+
+    (void)pl;
 }
 
-static void handle_dur_schedfail(mc_PACKET *pkt) {
-    delete static_cast<DurStoreCtx*>(pkt->u_rdata.exdata);
+static void
+handle_dur_schedfail(mc_PACKET *pkt)
+{
+    DURSTORECTX *dctx = (void *)pkt->u_rdata.exdata;
+    free(dctx);
 }
 
-mc_REQDATAPROCS DurStoreCtx::proctable = {
+mc_REQDATAPROCS storedur_procs = {
         handle_dur_storecb,
         handle_dur_schedfail
 };
@@ -152,7 +150,7 @@ static int
 can_compress(lcb_t instance, const mc_PIPELINE *pipeline,
     const lcb_VALBUF *vbuf, lcb_datatype_t datatype)
 {
-    const lcb::Server *server = static_cast<const lcb::Server*>(pipeline);
+    mc_SERVER *server = (mc_SERVER *)pipeline;
     int compressopts = LCBT_SETTING(instance, compressopts);
 
     if (mcreq_compression_supported() == 0) {
@@ -165,8 +163,7 @@ can_compress(lcb_t instance, const mc_PIPELINE *pipeline,
     if ((compressopts & LCB_COMPRESS_OUT) == 0) {
         return 0;
     }
-    if (server->supports_compression() == false &&
-            (compressopts & LCB_COMPRESS_FORCE) == 0) {
+    if (mcserver_supports_compression(server) == 0 && (compressopts & LCB_COMPRESS_FORCE) == 0) {
         return 0;
     }
     if (datatype & LCB_VALUE_F_SNAPPYCOMP) {
@@ -181,6 +178,7 @@ do_store3(lcb_t instance, const void *cookie,
 {
     mc_PIPELINE *pipeline;
     mc_PACKET *packet;
+    mc_REQDATA *rdata;
     mc_CMDQUEUE *cq = &instance->cmdq;
     int hsize;
     int should_compress = 0;
@@ -258,6 +256,8 @@ do_store3(lcb_t instance, const void *cookie,
         int duropts = 0;
         lcb_U16 persist_u , replicate_u;
         const lcb_CMDSTOREDUR *dcmd = (const lcb_CMDSTOREDUR *)cmd;
+        DURSTORECTX *dctx = calloc(1, sizeof(*dctx));
+
         persist_u = dcmd->persist_to;
         replicate_u = dcmd->replicate_to;
         if (dcmd->replicate_to == -1 || dcmd->persist_to == -1) {
@@ -268,19 +268,24 @@ do_store3(lcb_t instance, const void *cookie,
         if (err != LCB_SUCCESS) {
             mcreq_wipe_packet(pipeline, packet);
             mcreq_release_packet(pipeline, packet);
+            free(dctx);
             return err;
         }
 
-        DurStoreCtx *dctx = new DurStoreCtx(instance, persist_u, replicate_u,
-                                            cookie);
-        packet->u_rdata.exdata = dctx;
+        dctx->instance = instance;
+        dctx->persist_to = persist_u;
+        dctx->replicate_to = replicate_u;
+        packet->u_rdata.exdata = &dctx->base;
         packet->flags |= MCREQ_F_REQEXT;
-    } else {
-        mc_REQDATA *rdata = MCREQ_PKT_RDATA(packet);
-        rdata->cookie = cookie;
-        rdata->start = gethrtime();
+
+        dctx->base.cookie = cookie;
+        dctx->base.procs = &storedur_procs;
     }
 
+    rdata = MCREQ_PKT_RDATA(packet);
+    rdata->cookie = cookie;
+    rdata->start = gethrtime();
+
     scmd.message.body.expiration = htonl(cmd->exptime);
     scmd.message.body.flags = htonl(flags);
     hdr->request.magic = PROTOCOL_BINARY_REQ;

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

@@ -58,17 +58,6 @@ struct Traits {
         return is_lookup ? LCB_SDMULTI_MODE_LOOKUP : LCB_SDMULTI_MODE_MUTATE;
     }
 
-    inline bool chk_allow_empty_path(uint32_t options) const {
-        if (allow_empty_path) {
-            return true;
-        }
-        if (!is_lookup) {
-            return false;
-        }
-
-        return (options & LCB_SDSPEC_F_XATTRPATH) != 0;
-    }
-
     inline Traits(uint8_t op, unsigned options) :
         allow_empty_path(options & EMPTY_PATH),
         allow_expiry(options & ALLOW_EXPIRY),
@@ -174,28 +163,6 @@ get_valbuf_size(const lcb_VALBUF& vb)
     }
 }
 
-static uint8_t
-make_subdoc_flags(const uint32_t user)
-{
-    uint8_t subdoc_flags = 0;
-    if (user & LCB_SDSPEC_F_MKINTERMEDIATES) {
-        subdoc_flags |= SUBDOC_FLAG_MKDIR_P;
-    }
-    if (user & LCB_SDSPEC_F_MKDOCUMENT) {
-        subdoc_flags |= SUBDOC_FLAG_MKDOC;
-    }
-    if (user & LCB_SDSPEC_F_XATTRPATH) {
-        subdoc_flags |= SUBDOC_FLAG_XATTR_PATH;
-    }
-    if (user & LCB_SDSPEC_F_XATTR_MACROVALUES) {
-        subdoc_flags |= (SUBDOC_FLAG_EXPAND_MACROS | SUBDOC_FLAG_XATTR_PATH);
-    }
-    if (user & LCB_SDSPEC_F_XATTR_DELETED_OK) {
-        subdoc_flags |= (SUBDOC_FLAG_XATTR_PATH|SUBDOC_FLAG_ACCESS_DELETED);
-    }
-    return subdoc_flags;
-}
-
 struct MultiBuilder {
     MultiBuilder(const lcb_CMDSUBDOC *cmd_)
     : cmd(cmd_), payload_size(0), mode(0) {
@@ -299,10 +266,17 @@ MultiBuilder::add_spec(const lcb_SDSPEC *spec)
     // opcode
     add_field(trait.opcode, 1);
     // flags
-    add_field(make_subdoc_flags(spec->options), 1);
+    uint8_t sdflags = 0;
+    if (spec->options & LCB_SDSPEC_F_MKINTERMEDIATES) {
+        sdflags = SUBDOC_FLAG_MKDIR_P;
+    }
+    if (spec->options & LCB_SDSPEC_F_MKDOCUMENT) {
+        sdflags |= SUBDOC_FLAG_MKDOC;
+    }
+    add_field(sdflags, 1);
 
     uint16_t npath = static_cast<uint16_t>(spec->path.contig.nbytes);
-    if (!npath && !trait.chk_allow_empty_path(spec->options)) {
+    if (!npath && !trait.allow_empty_path) {
         return LCB_EMPTY_PATH;
     }
 
@@ -355,8 +329,7 @@ sd3_single(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
     if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
         return LCB_EMPTY_KEY;
     }
-    if (LCB_KEYBUF_IS_EMPTY(&spec->path) &&
-            !traits.chk_allow_empty_path(spec->options)) {
+    if (LCB_KEYBUF_IS_EMPTY(&spec->path) && !traits.allow_empty_path) {
         return LCB_EMPTY_PATH;
     }
 
@@ -426,7 +399,14 @@ sd3_single(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
         ntohs(hdr->request.keylen) + get_value_size(packet));
 
     request.message.extras.pathlen = htons(spec->path.contig.nbytes);
-    request.message.extras.subdoc_flags = make_subdoc_flags(spec->options);
+    request.message.extras.subdoc_flags = 0;
+
+    if (spec->options & LCB_SDSPEC_F_MKINTERMEDIATES) {
+        request.message.extras.subdoc_flags |= SUBDOC_FLAG_MKDIR_P;
+    }
+    if (spec->options & LCB_SDSPEC_F_MKDOCUMENT) {
+        request.message.extras.subdoc_flags |= SUBDOC_FLAG_MKDOC;
+    }
 
     hdr->request.opcode = traits.opcode;
     memcpy(SPAN_BUFFER(&packet->kh_span), request.bytes, sizeof request.bytes);

data/ext/libcouchbase/src/packetutils.c

@@ -0,0 +1,37 @@
+/* -*- 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 "packetutils.h"
+#include "rdb/rope.h"
+
+#ifndef _WIN32 /* for win32 this is inside winsock, included in sysdefs.h */
+#include <arpa/inet.h>
+#endif
+
+int
+lcb_pktinfo_ior_get(packet_info *info, rdb_IOROPE *ior, unsigned *required)
+{
+}
+
+void
+lcb_pktinfo_ior_done(packet_info *info, rdb_IOROPE *ior)
+{
+    if (!PACKET_NBODY(info)) {
+        return;
+    }
+    rdb_consumed(ior, PACKET_NBODY(info));
+}

data/ext/libcouchbase/src/packetutils.h

@@ -43,8 +43,8 @@ public:
     }
 
     MemcachedResponse(protocol_binary_command cmd, uint32_t opaque_,
-                      protocol_binary_response_status code)
-        : res(), payload(NULL), bufh(NULL) {
+                      protocol_binary_response_status code) {
+        std::memset(this, 0, sizeof *this);
         res.response.opcode = cmd;
         res.response.opaque = opaque_;
         res.response.status = htons(code);

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 char*,  /* bytes */
+                  const void*,  /* bytes */
                   size_t,       /* nbytes */
                   uint32_t,     /* flags */
                   uint64_t,     /* cas */

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

@@ -20,8 +20,8 @@
 int
 lcb_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_error_t err)
 {
-    unsigned policy;
-    unsigned mode;
+    lcb_RETRYCMDOPTS policy;
+    lcb_RETRYMODEOPTS mode;
     protocol_binary_request_header hdr;
 
     mcreq_read_hdr(pkt, &hdr);
@@ -70,6 +70,7 @@ 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

@@ -231,8 +231,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.
              */
-            get_instance()->bootstrap(lcb::BS_REFRESH_THROTTLE);
-            if (get_instance()->confmon->is_refreshing() ||
+            lcb_bootstrap_common(get_instance(), LCB_BS_REFRESH_THROTTLE);
+            if (lcb_confmon_is_refreshing(get_instance()->confmon) ||
                     settings->retry[LCB_RETRY_ON_MISSINGNODE]) {
 
                 lcb_list_delete(static_cast<SchedNode*>(op));
@@ -276,8 +276,8 @@ static void op_dtorfn(mc_EPKTDATUM *d) {
     delete static_cast<RetryOp*>(d);
 }
 
-RetryOp::RetryOp()
-    : mc_EPKTDATUM(), start(0), trytime(0), pkt(NULL), origerr(LCB_SUCCESS) {
+RetryOp::RetryOp() {
+    memset(this, 0, sizeof *this);
     mc_EPKTDATUM::dtorfn = op_dtorfn;
     mc_EPKTDATUM::key = RETRY_PKT_KEY;
 }

data/ext/libcouchbase/src/settings.c

@@ -57,7 +57,6 @@ 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;
 }
 
 LCB_INTERNAL_API
@@ -68,7 +67,6 @@ lcb_settings_new(void)
     lcb_default_settings(settings);
     settings->refcount = 1;
     settings->auth = lcbauth_new();
-    settings->errmap = lcb_errmap_new();
     return settings;
 }
 
@@ -85,7 +83,6 @@ 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,11 +84,9 @@
 #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 0
 
 #include "config.h"
 #include <libcouchbase/couchbase.h>
-#include "errmap.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -150,8 +148,6 @@ 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;
 
     short max_redir;
     unsigned refcount;
@@ -169,7 +165,6 @@ 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/simplestring.c

@@ -0,0 +1,211 @@
+/* -*- 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 "simplestring.h"
+#include "assert.h"
+
+static void ensure_cstr(lcb_string *str);
+
+int lcb_string_init(lcb_string *str)
+{
+    str->base = NULL;
+    str->nalloc = 0;
+    str->nused = 0;
+    return 0;
+}
+
+void lcb_string_release(lcb_string *str)
+{
+    if (str->base == NULL) {
+        return;
+    }
+    free(str->base);
+    memset(str, 0, sizeof(*str));
+}
+
+void lcb_string_clear(lcb_string *str)
+{
+    str->nused = 0;
+    if (str->nalloc) {
+        ensure_cstr(str);
+    }
+}
+
+void lcb_string_added(lcb_string *str, lcb_size_t nused)
+{
+    str->nused += nused;
+    lcb_assert(str->nused <= str->nalloc);
+    ensure_cstr(str);
+}
+
+int lcb_string_reserve(lcb_string *str, lcb_size_t size)
+{
+    lcb_size_t newalloc;
+    char *newbuf;
+
+    /** Set size to one greater, for the terminating NUL */
+    size++;
+    if (!size) {
+        return -1;
+    }
+
+    if (str->nalloc - str->nused >= size) {
+        return 0;
+    }
+
+    newalloc = str->nalloc;
+    if (!newalloc) {
+        newalloc = 1;
+    }
+
+    while (newalloc - str->nused < size) {
+        if (newalloc * 2 < newalloc) {
+            return -1;
+        }
+
+        newalloc *= 2;
+    }
+
+    newbuf = realloc(str->base, newalloc);
+    if (newbuf == NULL) {
+        return -1;
+    }
+
+    str->base = newbuf;
+    str->nalloc = newalloc;
+    return 0;
+}
+
+static void ensure_cstr(lcb_string *str)
+{
+    str->base[str->nused] = '\0';
+}
+
+int lcb_string_append(lcb_string *str, const void *data, lcb_size_t size)
+{
+    if (lcb_string_reserve(str, size)) {
+        return -1;
+    }
+
+    memcpy(str->base + str->nused, data, size);
+    str->nused += size;
+    ensure_cstr(str);
+    return 0;
+}
+
+int lcb_string_appendz(lcb_string *str, const char *s)
+{
+    return lcb_string_append(str, s, strlen(s));
+}
+
+int lcb_string_appendv(lcb_string *str, ...)
+{
+    va_list ap;
+    va_start(ap, str);
+
+    while (1) {
+        size_t len;
+        int rc;
+        const char *ptr;
+
+        if ((ptr = va_arg(ap, const char *)) == NULL) {
+            return 0;
+        }
+
+        len = va_arg(ap, size_t);
+        if (len == (size_t)-1) {
+            len = strlen(ptr);
+        }
+
+        rc = lcb_string_append(str, ptr, len);
+        if (rc != 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+int lcb_string_rbappend(lcb_string *str, ringbuffer_t *rb, int rbadvance)
+{
+    lcb_size_t expected, nw;
+    expected = rb->nbytes;
+    if (!expected) {
+        return 0;
+    }
+
+    if (lcb_string_reserve(str, expected)) {
+        return -1;
+    }
+
+    nw = ringbuffer_peek(rb, lcb_string_tail(str), expected);
+    if (nw != expected) {
+        return -1;
+    }
+
+    if (rbadvance) {
+        ringbuffer_consumed(rb, nw);
+    }
+
+    lcb_string_added(str, nw);
+    return 0;
+}
+
+void lcb_string_erase_end(lcb_string *str, lcb_size_t to_remove)
+{
+    lcb_assert(to_remove <= str->nused);
+    str->nused -= to_remove;
+    ensure_cstr(str);
+}
+
+void lcb_string_erase_beginning(lcb_string *str, lcb_size_t to_remove)
+{
+    lcb_assert(to_remove <= str->nused);
+    if (!to_remove) {
+        str->nused = 0;
+        return;
+    }
+
+    memmove(str->base, str->base + to_remove, str->nused - to_remove);
+    str->nused -= to_remove;
+    ensure_cstr(str);
+}
+
+int lcb_string_insert(lcb_string *str, size_t at, const char *src, size_t nsrc)
+{
+    if (!nsrc) {
+        return 0;
+    }
+    if (at == str->nused) {
+        return lcb_string_append(str, src, nsrc);
+    }
+
+    if (lcb_string_reserve(str, nsrc) != 0) {
+        return -1;
+    }
+    memmove(str->base + at + nsrc, str->base + at, str->nused - at);
+    memcpy(str->base + at, src, nsrc);
+    str->nused += nsrc;
+    ensure_cstr(str);
+    return 0;
+}
+
+void lcb_string_transfer(lcb_string *from, lcb_string *to)
+{
+    lcb_assert(to->base == NULL);
+    *to = *from;
+    memset(from, 0, sizeof(*from));
+}