libcouchbase 0.3.3 → 1.0.0

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

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

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

@@ -19,23 +19,30 @@
 #include "trace.h"
 #include "durability_internal.h"
 
-typedef struct {
-    mc_REQDATAEX base;
+struct DurStoreCtx : mc_REQDATAEX {
     lcb_t instance;
     lcb_U16 persist_to;
     lcb_U16 replicate_to;
-} DURSTORECTX;
+
+    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_) {
+    }
+};
 
 /** Observe stuff */
 static void
-handle_dur_storecb(mc_PIPELINE *pl, mc_PACKET *pkt,
+handle_dur_storecb(mc_PIPELINE *, 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 = (DURSTORECTX *)pkt->u_rdata.exdata;
+    DurStoreCtx *dctx = static_cast<DurStoreCtx*>(pkt->u_rdata.exdata);
     lcb_MULTICMD_CTX *mctx;
     lcb_durability_opts_t opts = { 0 };
     const lcb_RESPSTORE *sresp = (const lcb_RESPSTORE *)arg;
@@ -78,7 +85,7 @@ handle_dur_storecb(mc_PIPELINE *pl, mc_PACKET *pkt,
 
     if (err == LCB_SUCCESS) {
         /* Everything OK? */
-        free(dctx);
+        delete dctx;
         return;
     }
 
@@ -92,20 +99,15 @@ handle_dur_storecb(mc_PIPELINE *pl, 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);
-        free(dctx);
+        delete dctx;
     }
-
-    (void)pl;
 }
 
-static void
-handle_dur_schedfail(mc_PACKET *pkt)
-{
-    DURSTORECTX *dctx = (void *)pkt->u_rdata.exdata;
-    free(dctx);
+static void handle_dur_schedfail(mc_PACKET *pkt) {
+    delete static_cast<DurStoreCtx*>(pkt->u_rdata.exdata);
 }
 
-mc_REQDATAPROCS storedur_procs = {
+mc_REQDATAPROCS DurStoreCtx::proctable = {
         handle_dur_storecb,
         handle_dur_schedfail
 };
@@ -150,7 +152,7 @@ static int
 can_compress(lcb_t instance, const mc_PIPELINE *pipeline,
     const lcb_VALBUF *vbuf, lcb_datatype_t datatype)
 {
-    mc_SERVER *server = (mc_SERVER *)pipeline;
+    const lcb::Server *server = static_cast<const lcb::Server*>(pipeline);
     int compressopts = LCBT_SETTING(instance, compressopts);
 
     if (mcreq_compression_supported() == 0) {
@@ -163,7 +165,8 @@ can_compress(lcb_t instance, const mc_PIPELINE *pipeline,
     if ((compressopts & LCB_COMPRESS_OUT) == 0) {
         return 0;
     }
-    if (mcserver_supports_compression(server) == 0 && (compressopts & LCB_COMPRESS_FORCE) == 0) {
+    if (server->supports_compression() == false &&
+            (compressopts & LCB_COMPRESS_FORCE) == 0) {
         return 0;
     }
     if (datatype & LCB_VALUE_F_SNAPPYCOMP) {
@@ -178,7 +181,6 @@ 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;
@@ -256,8 +258,6 @@ 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,24 +268,19 @@ 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;
         }
 
-        dctx->instance = instance;
-        dctx->persist_to = persist_u;
-        dctx->replicate_to = replicate_u;
-        packet->u_rdata.exdata = &dctx->base;
+        DurStoreCtx *dctx = new DurStoreCtx(instance, persist_u, replicate_u,
+                                            cookie);
+        packet->u_rdata.exdata = dctx;
         packet->flags |= MCREQ_F_REQEXT;
-
-        dctx->base.cookie = cookie;
-        dctx->base.procs = &storedur_procs;
+    } else {
+        mc_REQDATA *rdata = MCREQ_PKT_RDATA(packet);
+        rdata->cookie = cookie;
+        rdata->start = gethrtime();
     }
 
-    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

@@ -39,7 +39,9 @@ enum Options {
     ALLOW_EXPIRY = 1<<1,
     HAS_VALUE = 1<<2,
     ALLOW_MKDIRP = 1<<3,
-    IS_LOOKUP = 1<<4
+    IS_LOOKUP = 1<<4,
+    // Must encapsulate in 'multi' spec
+    NO_STANDALONE = 1<<5
 };
 
 struct Traits {
@@ -51,13 +53,24 @@ struct Traits {
     const uint8_t opcode;
 
     inline bool valid() const {
-        return opcode != 0;
+        return opcode != PROTOCOL_BINARY_CMD_INVALID;
     }
 
     inline unsigned mode() const {
         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),
@@ -109,7 +122,13 @@ static const Traits
 Counter(PROTOCOL_BINARY_CMD_SUBDOC_COUNTER, ALLOW_EXPIRY|HAS_VALUE|ALLOW_MKDIRP);
 
 static const Traits
-Invalid(0, 0);
+GetDoc(PROTOCOL_BINARY_CMD_GET, IS_LOOKUP|EMPTY_PATH|NO_STANDALONE);
+
+static const Traits
+SetDoc(PROTOCOL_BINARY_CMD_SET, EMPTY_PATH|NO_STANDALONE);
+
+static const Traits
+Invalid(PROTOCOL_BINARY_CMD_INVALID, 0);
 
 const Traits&
 find(unsigned mode)
@@ -139,12 +158,28 @@ find(unsigned mode)
         return Remove;
     case LCB_SDCMD_COUNTER:
         return Counter;
+    case LCB_SDCMD_GET_FULLDOC:
+        return GetDoc;
+    case LCB_SDCMD_SET_FULLDOC:
+        return SetDoc;
     default:
         return Invalid;
     }
 }
 }
 
+namespace SubdocPathFlags {
+static const uint8_t MKDIR_P = 0x01;
+static const uint8_t XATTR = 0x04;
+static const uint8_t EXPAND_MACROS = 0x010;
+}
+
+namespace SubdocDocFlags {
+static const uint8_t MKDOC = 0x01;
+static const uint8_t ADDDOC = 0x02;
+static const uint8_t ACCESS_DELETED = 0x04;
+}
+
 static size_t
 get_valbuf_size(const lcb_VALBUF& vb)
 {
@@ -163,6 +198,36 @@ get_valbuf_size(const lcb_VALBUF& vb)
     }
 }
 
+static uint8_t
+make_path_flags(const uint32_t user) {
+    uint8_t flags = 0;
+    if (user & LCB_SDSPEC_F_MKINTERMEDIATES) {
+        flags |= SubdocPathFlags::MKDIR_P;
+    }
+    if (user & LCB_SDSPEC_F_XATTRPATH) {
+        flags |= SubdocPathFlags::XATTR;
+    }
+    if (user & LCB_SDSPEC_F_XATTR_MACROVALUES) {
+        flags |= SubdocPathFlags::XATTR | SubdocPathFlags::EXPAND_MACROS;
+    }
+    return flags;
+}
+
+static uint8_t
+make_doc_flags(const uint32_t user) {
+    uint8_t flags = 0;
+    if (user & LCB_CMDSUBDOC_F_INSERT_DOC) {
+        flags |= SubdocDocFlags::ADDDOC;
+    }
+    if (user & LCB_CMDSUBDOC_F_UPSERT_DOC) {
+        flags |= SubdocDocFlags::MKDOC;
+    }
+    if (user & LCB_CMDSUBDOC_F_ACCESS_DELETED) {
+        flags |= SubdocDocFlags::ACCESS_DELETED;
+    }
+    return flags;
+}
+
 struct MultiBuilder {
     MultiBuilder(const lcb_CMDSUBDOC *cmd_)
     : cmd(cmd_), payload_size(0), mode(0) {
@@ -266,17 +331,10 @@ MultiBuilder::add_spec(const lcb_SDSPEC *spec)
     // opcode
     add_field(trait.opcode, 1);
     // flags
-    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);
+    add_field(make_path_flags(spec->options), 1);
 
     uint16_t npath = static_cast<uint16_t>(spec->path.contig.nbytes);
-    if (!npath && !trait.allow_empty_path) {
+    if (!npath && !trait.chk_allow_empty_path(spec->options)) {
         return LCB_EMPTY_PATH;
     }
 
@@ -329,7 +387,8 @@ 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.allow_empty_path) {
+    if (LCB_KEYBUF_IS_EMPTY(&spec->path) &&
+            !traits.chk_allow_empty_path(spec->options)) {
         return LCB_EMPTY_PATH;
     }
 
@@ -367,14 +426,18 @@ sd3_single(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
         extlen = 7;
     }
 
-    protocol_binary_request_subdocument request;
-    protocol_binary_request_header *hdr = &request.message.header;
+    uint8_t docflags = make_doc_flags(cmd->cmdflags);
+    if (docflags) {
+        extlen++;
+    }
+
+    protocol_binary_request_header hdr = {{0}};
     mc_PACKET *packet;
     mc_PIPELINE *pipeline;
 
     rc = mcreq_basic_packet(&instance->cmdq,
         (const lcb_CMDBASE*)cmd,
-        hdr, extlen, &packet, &pipeline, MCREQ_BASICPACKET_F_FALLBACKOK);
+        &hdr, extlen, &packet, &pipeline, MCREQ_BASICPACKET_F_FALLBACKOK);
 
     if (rc != LCB_SUCCESS) {
         return rc;
@@ -390,29 +453,36 @@ sd3_single(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
     MCREQ_PKT_RDATA(packet)->cookie = cookie;
     MCREQ_PKT_RDATA(packet)->start = gethrtime();
 
-    hdr->request.magic = PROTOCOL_BINARY_REQ;
-    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr->request.extlen = packet->extlen;
-    hdr->request.opaque = packet->opaque;
-    hdr->request.cas = lcb_htonll(cmd->cas);
-    hdr->request.bodylen = htonl(hdr->request.extlen +
-        ntohs(hdr->request.keylen) + get_value_size(packet));
+    hdr.request.magic = PROTOCOL_BINARY_REQ;
+    hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr.request.extlen = packet->extlen;
+    hdr.request.opaque = packet->opaque;
+    hdr.request.opcode = traits.opcode;
+    hdr.request.cas = lcb_htonll(cmd->cas);
+    hdr.request.bodylen = htonl(hdr.request.extlen +
+        ntohs(hdr.request.keylen) + get_value_size(packet));
+
+    memcpy(SPAN_BUFFER(&packet->kh_span), hdr.bytes, sizeof hdr.bytes);
 
-    request.message.extras.pathlen = htons(spec->path.contig.nbytes);
-    request.message.extras.subdoc_flags = 0;
+    char *extras = SPAN_BUFFER(&packet->kh_span) + MCREQ_PKT_BASESIZE;
+    // Path length:
+    uint16_t enc_pathlen = htons(spec->path.contig.nbytes);
+    memcpy(extras, &enc_pathlen, 2);
+    extras += 2;
 
-    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;
-    }
+    uint8_t path_flags = make_path_flags(spec->options);
+    memcpy(extras, &path_flags, 1);
+    extras += 1;
 
-    hdr->request.opcode = traits.opcode;
-    memcpy(SPAN_BUFFER(&packet->kh_span), request.bytes, sizeof request.bytes);
     if (exptime) {
-        exptime = htonl(exptime);
-        memcpy(SPAN_BUFFER(&packet->kh_span) + sizeof request.bytes, &exptime, 4);
+        uint32_t enc_exptime = htonl(exptime);
+        memcpy(extras, &enc_exptime, 4);
+        extras += 4;
+    }
+
+    if (docflags) {
+        memcpy(extras, &docflags, 1);
+        extras += 1;
     }
 
     LCB_SCHED_ADD(instance, pipeline, packet);
@@ -429,10 +499,17 @@ lcb_subdoc3(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
     }
 
     if (cmd->nspecs == 1) {
-        return sd3_single(instance, cookie, cmd);
+        switch (cmd->specs[0].sdcmd) {
+        case LCB_SDCMD_GET_FULLDOC:
+        case LCB_SDCMD_SET_FULLDOC:
+            break;
+        default:
+            return sd3_single(instance, cookie, cmd);
+        }
     }
 
-    uint32_t exp = cmd->exptime;
+    uint32_t expiry = cmd->exptime;
+    uint8_t docflags = make_doc_flags(cmd->cmdflags);
     lcb_error_t rc = LCB_SUCCESS;
 
     MultiBuilder ctx(cmd);
@@ -440,7 +517,7 @@ lcb_subdoc3(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
         *cmd->error_index = -1;
     }
 
-    if (exp && !ctx.is_mutate()) {
+    if (expiry && !ctx.is_mutate()) {
         return LCB_OPTIONS_CONFLICT;
     }
 
@@ -456,7 +533,14 @@ lcb_subdoc3(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
 
     mc_PIPELINE *pl;
     mc_PACKET *pkt;
-    uint8_t extlen = exp ? 4 : 0;
+    uint8_t extlen = 0;
+    if (expiry) {
+        extlen += 4;
+    }
+    if (docflags) {
+        extlen ++;
+    }
+
     protocol_binary_request_header hdr;
 
     if (cmd->error_index) {
@@ -497,9 +581,12 @@ lcb_subdoc3(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
     hdr.request.bodylen = htonl(hdr.request.extlen +
         ntohs(hdr.request.keylen) + ctx.payload_size);
     memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof hdr.bytes);
-    if (exp) {
-        exp = htonl(exp);
-        memcpy(SPAN_BUFFER(&pkt->kh_span) + 24, &exp, 4);
+    if (expiry) {
+        expiry = htonl(expiry);
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + 24, &expiry, 4);
+    }
+    if (docflags) {
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + 24 + (extlen -1), &docflags, 1);
     }
 
     MCREQ_PKT_RDATA(pkt)->cookie = cookie;

data/ext/libcouchbase/src/packetutils.h

@@ -27,6 +27,7 @@
 #ifndef __cplusplus
 typedef struct packet_info_st packet_info;
 #else
+#include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
 namespace lcb {
 class Server;
 
@@ -43,8 +44,8 @@ public:
     }
 
     MemcachedResponse(protocol_binary_command cmd, uint32_t opaque_,
-                      protocol_binary_response_status code) {
-        std::memset(this, 0, sizeof *this);
+                      protocol_binary_response_status code)
+        : res(), payload(NULL), bufh(NULL) {
         res.response.opcode = cmd;
         res.response.opaque = opaque_;
         res.response.status = htons(code);
@@ -211,6 +212,33 @@ public:
         return bufh;
     }
 
+    static lcb_error_t
+    parse_enhanced_error(const char *value, lcb_SIZE nvalue, char **err_ref, char **err_ctx)
+    {
+        if (value == NULL || nvalue == 0) {
+            return LCB_EINVAL;
+        }
+        Json::Value jval;
+        if (!Json::Reader().parse(value, value + nvalue, jval)) {
+            return LCB_EINVAL;
+        }
+        if (jval.empty()) {
+            return LCB_EINVAL;
+        }
+        Json::Value jerr = jval["error"];
+        if (jerr.empty()) {
+            return LCB_EINVAL;
+        }
+        std::string emsg;
+        if (!jerr["ref"].empty()) {
+            *err_ref = strdup(jerr["ref"].asString().c_str());
+        }
+        if (!jerr["context"].empty()) {
+            *err_ctx = strdup(jerr["context"].asString().c_str());
+        }
+        return LCB_SUCCESS;
+    }
+
 protected:
     /** The response header */
     protocol_binary_response_header res;