libcouchbase 0.0.1

data/ext/libcouchbase/src/operations/touch.c

@@ -0,0 +1,81 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-2012 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 "internal.h"
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_touch3(lcb_t instance, const void *cookie, const lcb_CMDTOUCH *cmd)
+{
+    protocol_binary_request_touch tcmd;
+    protocol_binary_request_header *hdr = &tcmd.message.header;
+    mc_PIPELINE *pl;
+    mc_PACKET *pkt;
+    lcb_error_t err;
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+
+    err = mcreq_basic_packet(&instance->cmdq, cmd, hdr, 4, &pkt, &pl,
+        MCREQ_BASICPACKET_F_FALLBACKOK);
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    hdr->request.opcode = PROTOCOL_BINARY_CMD_TOUCH;
+    hdr->request.cas = 0;
+    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr->request.opaque = pkt->opaque;
+    hdr->request.bodylen = htonl(4 + ntohs(hdr->request.keylen));
+    tcmd.message.body.expiration = htonl(cmd->exptime);
+    memcpy(SPAN_BUFFER(&pkt->kh_span), tcmd.bytes, sizeof(tcmd.bytes));
+    pkt->u_rdata.reqdata.cookie = cookie;
+    pkt->u_rdata.reqdata.start = gethrtime();
+    LCB_SCHED_ADD(instance, pl, pkt);
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_touch(lcb_t instance, const void *cookie, lcb_size_t num,
+          const lcb_touch_cmd_t * const * items)
+{
+    unsigned ii;
+
+    lcb_sched_enter(instance);
+    for (ii = 0; ii < num; ii++) {
+        const lcb_touch_cmd_t *src = items[ii];
+        lcb_CMDTOUCH dst;
+        lcb_error_t err;
+
+        memset(&dst, 0, sizeof(dst));
+        dst.key.contig.bytes = src->v.v0.key;
+        dst.key.contig.nbytes = src->v.v0.nkey;
+        dst._hashkey.contig.bytes = src->v.v0.hashkey;
+        dst._hashkey.contig.nbytes = src->v.v0.nhashkey;
+        dst.exptime = src->v.v0.exptime;
+        err = lcb_touch3(instance, cookie, &dst);
+        if (err != LCB_SUCCESS) {
+            lcb_sched_fail(instance);
+            return err;
+        }
+    }
+    lcb_sched_leave(instance);
+    SYNCMODE_INTERCEPT(instance)
+}

data/ext/libcouchbase/src/packetutils.c

@@ -0,0 +1,60 @@
+/* -*- 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)
+{
+    unsigned total = rdb_get_nused(ior);
+    unsigned wanted = sizeof(info->res.bytes);
+
+    if (total < wanted) {
+        *required = wanted;
+        return 0;
+    }
+
+    rdb_copyread(ior, info->res.bytes, sizeof(info->res.bytes));
+    if (!PACKET_NBODY(info)) {
+        rdb_consumed(ior, sizeof(info->res.bytes));
+        return 1;
+    }
+
+    wanted += PACKET_NBODY(info);
+    if (total < wanted) {
+        *required = wanted;
+        return 0;
+    }
+
+    rdb_consumed(ior, sizeof(info->res.bytes));
+    info->payload = rdb_get_consolidated(ior, PACKET_NBODY(info));
+    return 1;
+}
+
+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

@@ -0,0 +1,147 @@
+/* -*- 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.
+ */
+
+#ifndef LCB_PACKETUTILS_H
+#define LCB_PACKETUTILS_H
+
+#include <libcouchbase/couchbase.h>
+#include "ringbuffer.h"
+#include "rdb/rope.h"
+#include "memcached/protocol_binary.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * 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;
+
+/**
+ * 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))
+
+#define PACKET_BODY(pkt) (pkt)->payload
+
+/**
+ * Gets the key size, if included in the packet.
+ */
+#define PACKET_NKEY(pkt) (ntohs((pkt)->res.response.keylen))
+
+/**
+ * Gets the status of the packet
+ */
+#define PACKET_STATUS(pkt) (ntohs((pkt)->res.response.status))
+
+/**
+ * Gets the length of the 'extras' in the body
+ */
+#define PACKET_EXTLEN(pkt) ((pkt)->res.response.extlen)
+
+/**
+ * Gets the raw unconverted 'opaque' 32 bit field
+ */
+#define PACKET_OPAQUE(pkt) ((pkt)->res.response.opaque)
+
+/**
+ * Gets the command for the packet
+ */
+#define PACKET_OPCODE(pkt) ((pkt)->res.response.opcode)
+
+/**
+ * Gets the CAS for the packet
+ */
+#define PACKET_CAS(pkt) lcb_ntohll((pkt)->res.response.cas)
+
+/**
+ * Gets the 'datatype' field for the packet.
+ */
+#define PACKET_DATATYPE(pkt) ((pkt)->res.response.datatype)
+
+/**
+ * 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))
+
+#define PACKET_REQUEST(pkt) \
+    ( (protocol_binary_request_header *) &(pkt)->res)
+
+#define PACKET_REQ_VBID(pkt) \
+    (ntohs(PACKET_REQUEST(pkt)->request.vbucket))
+
+/**
+ * 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 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.
+ */
+#define PACKET_EPHEMERAL_START(pkt) \
+    (const void *)(( ((const char *)(pkt)->payload) - 24 ))
+
+/**
+ * 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);
+
+void
+lcb_pktinfo_ior_done(packet_info *info, rdb_IOROPE *ior);
+
+#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)
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/src/probes.d

@@ -0,0 +1,211 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 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.
+ */
+
+provider libcouchbase {
+    probe get_begin(uint32_t,       /* opaque */
+                    uint16_t,       /* vbucket */
+                    uint8_t,        /* opcode (get, gat, getl) */
+                    const char*,    /* key */
+                    size_t,         /* nkey */
+                    uint32_t);      /* expiration */
+    probe get_end(uint32_t,     /* opaque */
+                  uint16_t,     /* vbucket */
+                  uint8_t,      /* opcode (get, gat, getl) */
+                  uint16_t,     /* return code (from libcouchbase) */
+                  const char*,  /* key */
+                  size_t,       /* nkey */
+                  const void*,  /* bytes */
+                  size_t,       /* nbytes */
+                  uint32_t,     /* flags */
+                  uint64_t,     /* cas */
+                  uint8_t);     /* datatype */
+
+    probe unlock_begin(uint32_t,    /* opaque */
+                       uint16_t,    /* vbucket */
+                       uint8_t,     /* opcode */
+                       const char*, /* key */
+                       size_t);     /* nkey */
+    probe unlock_end(uint32_t,      /* opaque */
+                     uint16_t,      /* vbucket */
+                     uint8_t,       /* opcode */
+                     uint16_t,      /* return code (from libcouchbase) */
+                     const char*,   /* key */
+                     size_t);       /* nkey */
+
+    probe store_begin(uint32_t,     /* opaque */
+                      uint16_t,     /* vbucket */
+                      uint8_t,      /* opcode (set, add, replace, append, prepend) */
+                      const char*,  /* key */
+                      size_t,       /* nkey */
+                      const char*,  /* bytes */
+                      size_t,       /* nbytes */
+                      uint32_t,     /* flags */
+                      uint64_t,     /* cas */
+                      uint8_t,      /* datatype */
+                      uint32_t);    /* expiration */
+    probe store_end(uint32_t,       /* opaque */
+                    uint16_t,       /* vbucket */
+                    uint8_t,        /* opcode (set, add, replace, append, prepend) */
+                    uint16_t,       /* return code (from libcouchbase) */
+                    const char*,    /* key */
+                    size_t,         /* nkey */
+                    uint64_t);      /* cas */
+
+    probe arithmetic_begin(uint32_t,    /* opaque */
+                           uint16_t,    /* vbucket */
+                           uint8_t,     /* opcode (increment, decrement) */
+                           const char*, /* key */
+                           size_t,      /* nkey */
+                           uint64_t,    /* delta */
+                           uint64_t,    /* initial */
+                           uint32_t);   /* expiration */
+    probe arithmetic_end(uint32_t,      /* opaque */
+                         uint16_t,      /* vbucket */
+                         uint8_t,       /* opcode (increment, decrement) */
+                         uint16_t,      /* return code (from libcouchbase) */
+                         const char*,   /* key */
+                         size_t,        /* nkey */
+                         uint64_t,      /* value */
+                         uint64_t);     /* cas */
+
+    probe touch_begin(uint32_t,       /* opaque */
+                      uint16_t,       /* vbucket */
+                      uint8_t,        /* opcode */
+                      const char*,    /* key */
+                      size_t,         /* nkey */
+                      uint32_t);      /* expiration */
+    probe touch_end(uint32_t,     /* opaque */
+                    uint16_t,     /* vbucket */
+                    uint8_t,      /* opcode */
+                    uint16_t,     /* return code (from libcouchbase) */
+                    const char*,  /* key */
+                    size_t,       /* nkey */
+                    uint64_t);    /* cas */
+
+    probe remove_begin(uint32_t,       /* opaque */
+                       uint16_t,       /* vbucket */
+                       uint8_t,        /* opcode */
+                       const char*,    /* key */
+                       size_t);        /* nkey */
+    probe remove_end(uint32_t,     /* opaque */
+                     uint16_t,     /* vbucket */
+                     uint8_t,      /* opcode */
+                     uint16_t,     /* return code (from libcouchbase) */
+                     const char*,  /* key */
+                     size_t,       /* nkey */
+                     uint64_t);    /* cas */
+
+    probe flush_begin(uint32_t,        /* opaque */
+                      uint16_t,        /* vbucket */
+                      uint8_t,         /* opcode */
+                      const char*);    /* server_endpoint */
+    probe flush_progress(uint32_t,     /* opaque */
+                         uint16_t,     /* vbucket */
+                         uint8_t,      /* opcode */
+                         uint16_t,     /* return code (from libcouchbase) */
+                         const char*); /* server_endpoint */
+    probe flush_end(uint32_t,     /* opaque */
+                    uint16_t,     /* vbucket */
+                    uint8_t,      /* opcode */
+                    uint16_t);    /* return code (from libcouchbase) */
+
+    probe versions_begin(uint32_t,        /* opaque */
+                         uint16_t,        /* vbucket */
+                         uint8_t,         /* opcode */
+                         const char*);    /* server_endpoint */
+    probe versions_progress(uint32_t,     /* opaque */
+                            uint16_t,     /* vbucket */
+                            uint8_t,      /* opcode */
+                            uint16_t,     /* return code (from libcouchbase) */
+                            const char*); /* server_endpoint */
+    probe versions_end(uint32_t,     /* opaque */
+                       uint16_t,     /* vbucket */
+                       uint8_t,      /* opcode */
+                       uint16_t);    /* return code (from libcouchbase) */
+
+    probe stats_begin(uint32_t,     /* opaque */
+                      uint16_t,     /* vbucket */
+                      uint8_t,      /* opcode */
+                      const char*,  /* server_endpoint */
+                      const char*,  /* arg */
+                      size_t);      /* narg */
+    probe stats_progress(uint32_t,      /* opaque */
+                         uint16_t,      /* vbucket */
+                         uint8_t,       /* opcode */
+                         uint16_t,      /* return code (from libcouchbase) */
+                         const char*,   /* server_endpoint */
+                         const char*,   /* key */
+                         size_t,        /* nkey */
+                         const char*,   /* bytes */
+                         size_t);       /* nbytes */
+    probe stats_end(uint32_t,      /* opaque */
+                    uint16_t,      /* vbucket */
+                    uint8_t,       /* opcode */
+                    uint16_t);     /* return code (from libcouchbase) */
+
+    probe verbosity_begin(uint32_t,     /* opaque */
+                          uint16_t,     /* vbucket */
+                          uint8_t,      /* opcode */
+                          const char*,  /* server_endpoint */
+                          uint32_t);    /* level */
+    probe verbosity_end(uint32_t,       /* opaque */
+                        uint16_t,       /* vbucket */
+                        uint8_t,        /* opcode */
+                        uint16_t,       /* return code (from libcouchbase) */
+                        const char*);   /* server_endpoint */
+
+    /*
+     * OBSERVE_BEGIN probe intended to be parsed in the handler.
+     * the bytes argument is a blob with nbytes length:
+     *
+     * +---------+---------+------------+----
+     * | 16 bits | 16 bits | nkey bytes | ...
+     * +---------+---------+------------+----
+     * | vbucket |   nkey  |    key     | ...
+     * +---------+---------+------------+----
+     */
+    probe observe_begin(uint32_t,       /* opaque */
+                        uint16_t,       /* vbucket */
+                        uint8_t,        /* opcode */
+                        const char*,    /* bytes */
+                        size_t);        /* nbytes */
+    probe observe_progress(uint32_t,    /* opaque */
+                           uint16_t,    /* vbucket */
+                           uint8_t,     /* opcode */
+                           uint16_t,    /* return code (from libcouchbase) */
+                           const char*, /* key */
+                           size_t,      /* nkey */
+                           uint64_t,    /* cas */
+                           uint8_t,     /* observe status: FOUND = 0x00, PERSISTED = 0x01, NOT_FOUND = 0x80 */
+                           uint8_t,     /* master (zero if from replica) */
+                           uint32_t,    /* ttp, time to persist */
+                           uint32_t);   /* ttr, time to replicate */
+    probe observe_end(uint32_t,     /* opaque */
+                      uint16_t,     /* vbucket */
+                      uint8_t,      /* opcode */
+                      uint16_t);    /* return code (from libcouchbase) */
+
+    probe http_begin(const char*,   /* url */
+                     size_t,        /* nurl */
+                     uint8_t);      /* method: GET = 0, POST = 1, PUT = 2, DELETE = 3 */
+    probe http_end(const char*,     /* url */
+                   size_t,          /* nurl */
+                   uint8_t,         /* method: GET = 0, POST = 1, PUT = 2, DELETE = 3 */
+                   uint16_t,        /* return code (from libcouchbase) */
+                   uint16_t);       /* HTTP status code or zero */
+
+};