libcouchbase 0.0.1

data/ext/libcouchbase/src/logging.h

@@ -0,0 +1,86 @@
+/* -*- 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_LOGGING_H
+#define LCB_LOGGING_H
+#include <stdarg.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+struct lcb_settings_st;
+struct lcb_st;
+struct lcbvb_CONFIG_st;
+
+/**
+ * Default printf logger which is enabled via LCB_LOGLEVEL in the
+ * environment
+ */
+extern struct lcb_logprocs_st *lcb_console_logprocs;
+
+struct lcb_CONSOLELOGGER {
+    struct lcb_logprocs_st base;
+    FILE *fp;
+    int minlevel;
+};
+
+/**
+ * Log a message via the installed logger. The parameters correlate to the
+ * arguments passed to the lcb_logging_callback function.
+ *
+ * Typically a subsystem may wish to define macros in order to reduce the
+ * number of arguments manually passed for each message.
+ */
+LCB_INTERNAL_API
+void lcb_log(const struct lcb_settings_st *settings,
+             const char *subsys,
+             int severity,
+             const char *srcfile,
+             int srcline,
+             const char *fmt, ...)
+
+#ifdef __GNUC__
+             __attribute__ ((format(printf, 6, 7)))
+#endif
+             ;
+
+LCB_INTERNAL_API
+void lcb_log_badconfig(const struct lcb_settings_st *settings,
+    const char *subsys, int severity, const char *srcfile, int srcline,
+    const struct lcbvb_CONFIG_st *vbc, const char *origin_txt);
+
+lcb_logprocs * lcb_init_console_logger(void);
+
+#define LCB_LOGS(settings, subsys, severity, msg) \
+    lcb_log(settings, subsys, severity, __FILE__, __LINE__, msg)
+
+#define LCB_LOG_EX(settings, subsys, severity, msg) \
+    lcb_log(settings, subsys, severity, __FILE__, __LINE__, msg)
+
+#define LCB_LOG_BASIC(settings, msg) \
+    lcb_log(settings, "unknown", 0, __FILE__, __LINE__, msg)
+
+/** Macro for overcoming Win32 identifiers */
+#define LCB_LOG_ERR LCB_LOG_ERROR
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* LCB_LOGGING_H */

data/ext/libcouchbase/src/mc/compress.c

@@ -0,0 +1,90 @@
+/* -*- 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 "mcreq.h"
+#include "compress.h"
+
+#ifndef LCB_NO_SNAPPY
+#include <contrib/snappy/snappy-c.h>
+#endif
+
+int
+mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_CONTIGBUF *vbuf)
+{
+#ifdef LCB_NO_SNAPPY
+    (void)pl;(void)pkt;(void)vbuf;return -1;
+#else
+    /* get the desired size */
+    size_t maxsize, compsize;
+    snappy_status status;
+    nb_SPAN *outspan;
+
+    compsize = maxsize = snappy_max_compressed_length(vbuf->nbytes);
+    if (mcreq_reserve_value2(pl, pkt, maxsize) != LCB_SUCCESS) {
+        return -1;
+    }
+
+    outspan = &pkt->u_value.single;
+    status = snappy_compress(vbuf->bytes, vbuf->nbytes,
+        SPAN_BUFFER(outspan), &compsize);
+
+    if (status != SNAPPY_OK) {
+        return -1;
+    }
+
+    if (compsize < maxsize) {
+        /* chop off some bytes? */
+        nb_SPAN trailspan = *outspan;
+        trailspan.offset += compsize;
+        trailspan.size = maxsize - compsize;
+        netbuf_mblock_release(&pl->nbmgr, &trailspan);
+        outspan->size = compsize;
+    }
+    return 0;
+#endif
+}
+
+int
+mcreq_inflate_value(const void *compressed, lcb_SIZE ncompressed,
+    const void **bytes, lcb_SIZE *nbytes, void **freeptr)
+{
+#ifdef LCB_NO_SNAPPY
+    (void)compressed;(void)ncompressed;(void)bytes;(void)nbytes;(void)freeptr;
+    return -1;
+#else
+    lcb_SIZE cursize, compsize;
+    snappy_status status;
+    cursize = ncompressed;
+    do {
+        cursize *= 2;
+        *freeptr = realloc(*freeptr, cursize);
+        compsize = cursize;
+        status = snappy_uncompress(compressed, ncompressed, *freeptr, &compsize);
+    } while (status == SNAPPY_BUFFER_TOO_SMALL);
+
+    if (status != SNAPPY_OK) {
+        /* TODO: return an error here */
+        free(*freeptr);
+        *freeptr = NULL;
+        return -1;
+    }
+
+    *bytes = *freeptr;
+    *nbytes = compsize;
+    return 0;
+#endif
+}

data/ext/libcouchbase/src/mc/compress.h

@@ -0,0 +1,61 @@
+/* -*- 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 "mcreq.h"
+#ifndef LCB_MCCOMPRESS_H
+#define LCB_MCCOMPRESS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Stores a compressed payload into a packet
+ * @param pl The pipeline which hosts the packet
+ * @param pkt The packet which hosts the value
+ * @param vbuf The user input to be compressed
+ * @return 0 if successful, nonzero on error.
+ */
+int
+mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_CONTIGBUF *vbuf);
+
+
+/**
+ * Inflate a compressed value
+ * @param compressed The value to inflate
+ * @param ncompressed Size of value to inflate
+ * @param[out] bytes The inflated value
+ * @param[out] nbytes The size of the inflated value
+ * @param[in/out] freeptr Pointer initialized to NULL (or an malloc'd buffer)
+ * which on output should point to a malloc'd buffer to be freed() when no
+ * longer required.
+ * @return 0 if successful, nonzero on error.
+ */
+int
+mcreq_inflate_value(const void *compressed, lcb_SIZE ncompressed,
+    const void **bytes, lcb_SIZE *nbytes, void **freeptr);
+
+#ifndef LCB_NO_SNAPPY
+#define mcreq_compression_supported() 1
+#else
+#define mcreq_compression_supported() 0
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/src/mc/forward.c

@@ -0,0 +1,186 @@
+/* -*- 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 "mcreq.h"
+#include "forward.h"
+#include "iovcursor-inl.h"
+#include <stdio.h>
+
+#define MINIMUM(a, b) (a) < (b) ? a : b
+
+static void
+span_from_first(mc_IOVCURSOR *cursor, unsigned size, nb_SPAN *span)
+{
+    nb_IOV dummy;
+    iovcursor_adv_first(cursor, size, &dummy);
+    CREATE_STANDALONE_SPAN(span, dummy.iov_base, dummy.iov_len);
+}
+
+void
+mc_iovinfo_init(mc_IOVINFO *info, const nb_IOV *iov, unsigned niov)
+{
+    unsigned ii;
+    info->c.iov = (void *)iov;
+    info->c.niov = niov;
+    info->c.offset = 0;
+    info->total = 0;
+
+    for (ii = 0; ii < niov; ii++) {
+        info->total += iov[ii].iov_len;
+    }
+}
+
+#define REQLEN_HDR(req) sizeof(req.bytes)
+#define REQLEN_
+
+lcb_error_t
+mc_forward_packet(mc_CMDQUEUE *cq,
+    mc_IOVINFO *info, mc_PACKET **pkt_p, mc_PIPELINE **pl_p, int options)
+{
+    /* stack based header with our modifications. this is copied into the
+     * packet's actual header */
+    protocol_binary_request_header hdr;
+    int vbid, srvix;
+    mc_IOVCURSOR *mincur = &info->c;
+
+    unsigned n_packet; /* total packet size */
+    unsigned n_header; /* extras + key + memcached header */
+    unsigned n_body_total; /* size of everything following the memcached header */
+    unsigned n_body_key; /* length of the key */
+    unsigned n_body_value; /* packetsize - hdrsize */
+
+    unsigned offset;
+
+    /* stack buffer and key pointer. stack buffer is used if the key is not
+     * contiguous */
+    char kbuf_s[256];
+    const char *kptr;
+
+    /* pipeline and packet for command */
+    mc_PIPELINE *pl;
+    mc_PACKET *pkt;
+    info->wanted = 0;
+
+    /* not enough bytes */
+    if (info->total < 24) {
+        info->wanted = 24;
+        return LCB_INCOMPLETE_PACKET;
+    }
+
+    iovcursor_peek(mincur, (char*)hdr.bytes, sizeof hdr.bytes, 0);
+
+    /* Initialize our size variables */
+    n_body_total = ntohl(hdr.request.bodylen);
+    n_body_key = ntohs(hdr.request.keylen);
+    n_header = sizeof hdr.bytes + n_body_key + hdr.request.extlen;
+    n_packet = n_body_total + sizeof hdr.bytes;
+    n_body_value = n_packet - n_header;
+
+    if (n_packet > info->total) {
+        info->wanted = n_packet;
+        return LCB_INCOMPLETE_PACKET;
+    }
+
+    info->total -= n_packet;
+
+    /* seek ahead to read the item's key into the header */
+    offset = sizeof hdr.bytes + hdr.request.extlen;
+
+    iovcursor_peek_ex(mincur, kbuf_s, &kptr, n_body_key, offset);
+
+    if (kptr == NULL) {
+        /* key is not contiguous? that's ok. use the static buffer */
+        kptr = kbuf_s;
+    }
+
+    if ((options & MC_FWD_OPT_NOMAP) == 0) {
+        lcbvb_map_key(cq->config, kptr, n_body_key, &vbid, &srvix);
+        if (srvix < 0 || (unsigned)srvix >= cq->npipelines) {
+            return LCB_NO_MATCHING_SERVER;
+        }
+        pl = cq->pipelines[srvix];
+        hdr.request.vbucket = htons(vbid);
+
+    } else {
+        pl = *pl_p;
+        if (!pl) {
+            return LCB_EINVAL;
+        }
+        srvix = pl->index;
+    }
+
+    pkt = mcreq_allocate_packet(pl);
+
+    if (pkt == NULL) {
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    hdr.request.opaque = pkt->opaque;
+    pkt->extlen = hdr.request.extlen;
+    info->consumed = n_packet;
+
+    if (options & MC_FWD_OPT_COPY) {
+        /* reserve bytes for the entire packet */
+        mcreq_reserve_header(pl, pkt, n_header);
+        iovcursor_adv_copy(mincur, SPAN_BUFFER(&pkt->kh_span), n_header);
+        if (n_body_value) {
+            mcreq_reserve_value2(pl, pkt, n_body_value);
+            iovcursor_adv_copy(mincur,
+                SPAN_BUFFER(&pkt->u_value.single), n_body_value);
+            pkt->flags |= MCREQ_F_HASVALUE;
+        }
+
+    } else {
+        if (IOVCURSOR_HAS_CONTIG(mincur, n_header)) {
+            span_from_first(mincur, n_header, &pkt->kh_span);
+            pkt->flags |= MCREQ_F_KEY_NOCOPY;
+
+        } else {
+            /* header is fragmented into multiple IOVs */
+            mcreq_reserve_header(pl, pkt, n_header);
+            iovcursor_adv_copy(mincur, SPAN_BUFFER(&pkt->kh_span), n_header);
+        }
+
+        /* do we have a value payload still? */
+        if (n_body_value) {
+            pkt->flags |= MCREQ_F_HASVALUE | MCREQ_F_VALUE_NOCOPY;
+            if (IOVCURSOR_HAS_CONTIG(mincur, n_body_value)) {
+                span_from_first(mincur, n_body_value, &pkt->u_value.single);
+
+            } else {
+                /* body is fragmented */
+                iovcursor_adv_iovalloc(mincur, n_body_value,
+                    (nb_IOV**)&pkt->u_value.multi.iov,
+                    &pkt->u_value.multi.niov);
+                pkt->u_value.multi.total_length = n_body_value;
+                pkt->flags |= MCREQ_F_VALUE_IOV;
+            }
+        }
+    }
+
+    /* Copy the first 24 bytes into the header span */
+    memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof hdr.bytes);
+
+    *pkt_p = pkt;
+    *pl_p = pl;
+
+    /* Set the UFWD flag. This causes the rest of the system to invoke the
+     * handler for the raw response, rather than the "Contiguous" structures*/
+    pkt->flags |= MCREQ_F_UFWD;
+    mcreq_sched_add(pl, pkt);
+    return LCB_SUCCESS;
+}

data/ext/libcouchbase/src/mc/forward.h

@@ -0,0 +1,90 @@
+/* -*- 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 MC_FORWARD_H
+#define MC_FORWARD_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "iovcursor.h"
+
+
+/**
+ * Copy over the entire packet to the internal buffers. Input buffer is
+ * temporary.
+ */
+#define MC_FWD_OPT_COPY 0x01
+
+/**
+ * The server to send to is already set as `pl`. Don't perform vbucket mapping.
+ */
+#define MC_FWD_OPT_NOMAP 0x02
+
+void
+mc_iovinfo_init(mc_IOVINFO *info, const nb_IOV *iov, unsigned niov);
+
+/**
+ * Forward a packet to an upstream server.
+ * @param[in] cq the command queue
+ * @param[in] ctx a queue context used for scheduling/flushing the packets
+ * @param[in] info an 'IOVINFO' structure. See the structure documentation for
+ *        more details.
+ * @param[out] pkt a pointer to a packet, set to the resultant packet structure
+ * @param[out] pl the pipeline this packet is mapped to
+ * @param options Options modifying the behavior of this operation
+ * @return LCB_SUCCESS or an error code.
+ *
+ * Currently only some commands will successfully make sense to forward. This
+ * function only handles the lower level aspect of actually allocating or
+ * reserving the buffers required to forward the packet, but not actually
+ * handling the received data for the callbacks themselves.
+ *
+ * Note that this function does not currently "Collapse" consectutive IOV
+ * structures. Additionally the following should be noted:
+ *
+ * <ol>
+ * <li>
+ *     If the first IOV does not contain a contiguous buffer of the
+ *     { header, extras, key }, then it will be copied into a library-based
+ *     buffer.
+ * </li>
+ *
+ * <li>
+ *     If the total number of IOVs is greater than two, then niov-1 IOV
+ *     structures will be allocated via 'malloc'. This may not always happen
+ *     if the header _itself_ is fragmented
+ * </li>
+ *
+ * <li>The first 24 bytes of the header WILL BE MODIFIED by the library.
+ *     This will be used to modify the 'opaque' and 'vbucket' fields.
+ *     Take this into note if you need to keep track of their original values.
+ * </li>
+ *
+ * <li>Check the 'niov' counter to see if it is 0. If it's 0 then you should
+ *     make sure to reset the counter.
+ * </li>
+ * </ol>
+ */
+lcb_error_t
+mc_forward_packet(mc_CMDQUEUE *cq,
+    mc_IOVINFO *info, mc_PACKET **pkt, mc_PIPELINE **pl, int options);
+
+#ifdef __cplusplus
+}
+#endif
+#endif