libcouchbase 0.0.7 → 0.0.8

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 (server->compsupport == 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

@@ -58,6 +58,17 @@ 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),
@@ -163,6 +174,28 @@ 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) {
@@ -266,17 +299,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_subdoc_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 +355,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;
     }
 
@@ -399,14 +426,7 @@ 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 = 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;
-    }
+    request.message.extras.subdoc_flags = make_subdoc_flags(spec->options);
 
     hdr->request.opcode = traits.opcode;
     memcpy(SPAN_BUFFER(&packet->kh_span), request.bytes, sizeof request.bytes);

data/ext/libcouchbase/src/packetutils.h

@@ -24,128 +24,209 @@
 #include <memcached/protocol_binary.h>
 #include "rdb/rope.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef __cplusplus
+typedef struct packet_info_st packet_info;
+#else
+namespace lcb {
+class Server;
+
 /**
  * Response packet informational structure.
  *
  * This contains information regarding the response packet which is used by
  * the response processors.
  */
-typedef struct packet_info_st {
-    /** The response header */
-    protocol_binary_response_header res;
-    /** The payload of the response. This should only be used if there is a body */
-    void *payload;
-    /** Segment for payload */
-    void *bufh;
-} packet_info;
+class MemcachedResponse {
+public:
+    MemcachedResponse() : payload(NULL), bufh(NULL) {
+        // Bodyless. Members are initialized via load!
+    }
 
-/**
- * Gets the size of the _total_ non-header part of the packet. This data is
- * also featured inside the payload field itself.
- */
-#define PACKET_NBODY(pkt) (ntohl((pkt)->res.response.bodylen))
+    MemcachedResponse(protocol_binary_command cmd, uint32_t opaque_,
+                      protocol_binary_response_status code)
+        : res(), payload(NULL), bufh(NULL) {
+        res.response.opcode = cmd;
+        res.response.opaque = opaque_;
+        res.response.status = htons(code);
+    }
+    /**
+     * Read from an 'IOR' structure to parse the packet information. This will
+     * always load a full packet.
+     *
+     * @param ior the rope structure to read from
+     * @param[out] required how much total bytes must remain in the buffer for the
+     *  parse to complete.
+     *
+     * @return false if more data is needed, true otherwise
+     */
+    bool load(rdb_IOROPE *ior, unsigned *required) {
+        unsigned total = rdb_get_nused(ior);
+        unsigned wanted = sizeof(res.bytes);
+
+        if (total < wanted) {
+            *required = wanted;
+            return false;
+        }
+
+        rdb_copyread(ior, res.bytes, sizeof(res.bytes));
+        if (!bodylen()) {
+            rdb_consumed(ior, sizeof(res.bytes));
+            return true;
+        }
+
+        wanted += bodylen();
+        if (total < wanted) {
+            *required = wanted;
+            return false;
+        }
+
+        rdb_consumed(ior, sizeof(res.bytes));
+        payload = rdb_get_consolidated(ior, bodylen());
+        return true;
+    }
 
-#define PACKET_BODY(pkt) (pkt)->payload
+    template <typename T>
+    bool load(T ctx, unsigned *required) {
+        return load(&ctx->ior, required);
+    }
 
-/**
- * Gets the key size, if included in the packet.
- */
-#define PACKET_NKEY(pkt) (ntohs((pkt)->res.response.keylen))
+    void release(rdb_IOROPE *ior) {
+        if (!bodylen()) {
+            return;
+        }
+        rdb_consumed(ior, bodylen());
+    }
 
-/**
- * Gets the status of the packet
- */
-#define PACKET_STATUS(pkt) (ntohs((pkt)->res.response.status))
+    template <typename T>
+    void release(T ctx) {
+        release(&ctx->ior);
+    }
 
-/**
- * Gets the length of the 'extras' in the body
- */
-#define PACKET_EXTLEN(pkt) ((pkt)->res.response.extlen)
+    /**
+     * Gets the command for the packet
+     */
+    uint8_t opcode() const {
+        return res.response.opcode;
+    }
 
-/**
- * Gets the raw unconverted 'opaque' 32 bit field
- */
-#define PACKET_OPAQUE(pkt) ((pkt)->res.response.opaque)
+    /**
+     * Gets the CAS for the packet
+     */
+    uint64_t cas() const {
+        return lcb_ntohll(res.response.cas);
+    }
 
-/**
- * Gets the command for the packet
- */
-#define PACKET_OPCODE(pkt) ((pkt)->res.response.opcode)
+    /**
+     * Gets the 'datatype' field for the packet.
+     */
+    uint8_t datatype() const {
+        return res.response.datatype;
+    }
 
-/**
- * Gets the CAS for the packet
- */
-#define PACKET_CAS(pkt) lcb_ntohll((pkt)->res.response.cas)
+    /**
+     * Gets a pointer starting at the packet's key field. Only use if NKEY is 0
+     */
+    const char *key() const {
+        return body<const char*>() + extlen();
+    }
 
-/**
- * Gets the 'datatype' field for the packet.
- */
-#define PACKET_DATATYPE(pkt) ((pkt)->res.response.datatype)
+    /**
+     * Gets a pointer starting at the packet's value field. Only use if NVALUE is 0
+     */
+    const char *value() const {
+        return body<const char*>() + keylen() + extlen();
+    }
 
-/**
- * Gets a pointer starting at the packet's key field. Only use if NKEY is 0
- */
-#define PACKET_KEY(pkt) \
-    ( ((const char *)(pkt)->payload) + PACKET_EXTLEN(pkt))
+    /**
+     * Gets the size of the packet value. The value is the part of the payload
+     * which is after the key (if applicable) and extras (if applicable).
+     */
+    uint32_t vallen() const {
+        return bodylen() - (keylen() + extlen());
+    }
 
-#define PACKET_REQUEST(pkt) \
-    ( (protocol_binary_request_header *) &(pkt)->res)
 
-#define PACKET_REQ_VBID(pkt) \
-    (ntohs(PACKET_REQUEST(pkt)->request.vbucket))
+    /**
+     * Gets the status of the packet
+     */
+    uint16_t status() const {
+        return ntohs(res.response.status);
+    }
 
-/**
- * Gets a pointer starting at the packet's value field. Only use if NVALUE is 0
- */
-#define PACKET_VALUE(pkt) \
-    ( ((const char *) (pkt)->payload) + PACKET_NKEY(pkt) + PACKET_EXTLEN(pkt))
+    /**
+     * Gets the payload
+     */
+    template <typename T>
+    const T body() const {
+        return reinterpret_cast<const T>(payload);
+    }
 
-/**
- * Gets the size of the packet value. The value is the part of the payload
- * which is after the key (if applicable) and extras (if applicable).
- */
-#define PACKET_NVALUE(pkt) \
-    (PACKET_NBODY(pkt) - (PACKET_NKEY(pkt) + PACKET_EXTLEN(pkt)))
+    /**
+     * Map a command 'subclass' so that its body field starts at the payload. Note
+     * that the return value is actually an ephemeral pointer starting 24 bytes
+     * _before_ the actual memory block, so only use the non-header part.
+     */
+    const char *ephemeral_start() const {
+        return body<const char*>() - 24;
+    }
+
+    /**
+     * Gets the size of the _total_ non-header part of the packet. This data is
+     * also featured inside the payload field itself.
+     */
+    uint32_t bodylen() const {
+        return ntohl(res.response.bodylen);
+    }
 
+    /**
+     * Gets the key size, if included in the packet.
+     */
+    uint16_t keylen() const {
+        return ntohs(res.response.keylen);
+    }
 
-/**
- * Map a command 'subclass' so that its body field starts at the payload. Note
- * that the return value is actually an ephemeral pointer starting 24 bytes
- * _before_ the actual memory block, so only use the non-header part.
- */
-#define PACKET_EPHEMERAL_START(pkt) \
-    (const void *)(( ((const char *)(pkt)->payload) - 24 ))
+    /**
+     * Gets the length of the 'extras' in the body
+     */
+    uint8_t extlen() const {
+        return (res.response.extlen);
+    }
 
-/**
- * Read from an 'IOR' structure to parse the packet information. This will
- * always load a full packet.
- *
- * @param info the info structure to populate
- * @param ior the rope structure to read from
- * @param[out] required how much total bytes must remain in the buffer for the
- *  parse to complete.
- *
- * @return zero if more data is needed, a true value otherwise
- */
-int
-lcb_pktinfo_ior_get(packet_info *info, rdb_IOROPE *ior, unsigned *required);
+    /**
+     * Gets the raw unconverted 'opaque' 32 bit field
+     */
+    uint32_t opaque() const {
+        return (res.response.opaque);
+    }
 
-void
-lcb_pktinfo_ior_done(packet_info *info, rdb_IOROPE *ior);
+    size_t hdrsize() const {
+        return sizeof (res.bytes);
+    }
 
-#define lcb_pktinfo_ectx_get(info, ctx, n) lcb_pktinfo_ior_get(info, &(ctx)->ior, n)
-#define lcb_pktinfo_ectx_done(info, ctx) lcb_pktinfo_ior_done(info, &(ctx)->ior)
+    uint8_t *hdrbytes() {
+        return res.bytes;
+    }
 
+    void *bufseg() const {
+        return bufh;
+    }
 
+protected:
+    /** The response header */
+    protocol_binary_response_header res;
+    /** The payload of the response. This should only be used if there is a body */
+    void *payload;
+    /** Segment for payload */
+    void *bufh;
 
-#ifdef __cplusplus
-}
+    friend class lcb::Server;
+};
 
+#define PACKET_REQUEST(pkt) \
+    ( (protocol_binary_request_header *) &(pkt)->res)
 
-namespace lcb {
+#define PACKET_REQ_VBID(pkt) \
+    (ntohs(PACKET_REQUEST(pkt)->request.vbucket))
 
 class MemcachedRequest {
 public:
@@ -169,65 +250,47 @@ public:
         hdr.request.opaque = opaque_;
     }
 
-    MemcachedRequest(uint8_t opcode) {
-        hdr.request.opcode = opcode;
-        hdr.request.magic = PROTOCOL_BINARY_REQ;
-        hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-        hdr.request.cas = 0;
-        hdr.request.vbucket = 0;
-        hdr.request.opaque = 0;
-        hdr.request.bodylen = 0;
-        hdr.request.extlen = 0;
-        hdr.request.keylen = 0;
-        hdr.request.opaque = 0;
-    }
-
-    const void *data() const { return hdr.bytes; }
-    size_t size() const { return sizeof hdr.bytes; }
-
-private:
-    protocol_binary_request_header hdr;
-};
-
-class MemcachedResponse : private packet_info {
-public:
-    bool load(rdb_IOROPE *ior, unsigned *required) {
-        return lcb_pktinfo_ior_get(this, ior, required) != 0;
+    uint32_t opaque() const {
+        return hdr.request.opaque;
     }
 
-    template <typename T>
-    bool load(T ctx, unsigned *required) {
-        return lcb_pktinfo_ectx_get(this, ctx, required);
+    uint8_t opcode() const {
+        return hdr.request.opcode;
     }
 
-    void release(rdb_IOROPE *ior) {
-        lcb_pktinfo_ior_done(this, ior);
+    MemcachedRequest(uint8_t opcode_) {
+        assign(opcode_);
     }
 
-    template <typename T>
-    void release(T ctx) {
-        lcb_pktinfo_ectx_done(this, ctx);
+    MemcachedRequest(uint8_t opcode_, uint32_t opaque_) {
+        assign(opcode_);
+        hdr.request.opaque = opaque_;
     }
 
-    uint8_t opcode() const {
-        return PACKET_OPCODE(this);
+    MemcachedRequest(const void *buf) {
+        memcpy(hdr.bytes, buf, sizeof hdr.bytes);
     }
 
-    uint16_t status() const {
-        return PACKET_STATUS(this);
-    }
+    const void *data() const { return hdr.bytes; }
+    size_t size() const { return sizeof hdr.bytes; }
 
-    template <typename T>
-    const T body() const {
-        return reinterpret_cast<const T>(packet_info::payload);
-    }
+private:
+    protocol_binary_request_header hdr;
 
-    size_t bodylen() const {
-        return PACKET_NBODY(this);
+    void assign(uint8_t opcode_) {
+        hdr.request.opcode = opcode_;
+        hdr.request.magic = PROTOCOL_BINARY_REQ;
+        hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+        hdr.request.cas = 0;
+        hdr.request.vbucket = 0;
+        hdr.request.opaque = 0;
+        hdr.request.bodylen = 0;
+        hdr.request.extlen = 0;
+        hdr.request.keylen = 0;
+        hdr.request.opaque = 0;
     }
 };
-
 }
+typedef lcb::MemcachedResponse packet_info;
 #endif
-
 #endif