libcouchbase 0.0.1

data/ext/libcouchbase/src/ringbuffer.h

@@ -0,0 +1,100 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-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.
+ */
+#ifndef RINGBUFFER_H
+#define RINGBUFFER_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef struct ringbuffer_st {
+        char *root;
+        char *read_head;
+        char *write_head;
+        lcb_size_t size;
+        lcb_size_t nbytes;
+    } ringbuffer_t;
+
+    typedef enum {
+        RINGBUFFER_READ = 0x01,
+        RINGBUFFER_WRITE = 0x02
+    } ringbuffer_direction_t;
+
+    int ringbuffer_initialize(ringbuffer_t *buffer,
+                              lcb_size_t size);
+
+    /**
+     * Initialize a ringbuffer, taking ownership of an allocated char buffer.
+     * This function always succeeds.
+     * @param buffer a ringbuffer_t to be initialized
+     * @param buf the buffer to steal
+     * @param size the allocated size of the buffer
+     */
+    void ringbuffer_take_buffer(ringbuffer_t *buffer,
+                                char *buf,
+                                lcb_size_t size);
+
+    void ringbuffer_reset(ringbuffer_t *buffer);
+
+    void ringbuffer_destruct(ringbuffer_t *buffer);
+    int ringbuffer_ensure_capacity(ringbuffer_t *buffer,
+                                   lcb_size_t size);
+    lcb_size_t ringbuffer_get_size(ringbuffer_t *buffer);
+    void *ringbuffer_get_start(ringbuffer_t *buffer);
+    void *ringbuffer_get_read_head(ringbuffer_t *buffer);
+    void *ringbuffer_get_write_head(ringbuffer_t *buffer);
+    lcb_size_t ringbuffer_write(ringbuffer_t *buffer,
+                                const void *src,
+                                lcb_size_t nb);
+    lcb_size_t ringbuffer_strcat(ringbuffer_t *buffer,
+                                 const char *str);
+    lcb_size_t ringbuffer_read(ringbuffer_t *buffer,
+                               void *dest,
+                               lcb_size_t nb);
+    lcb_size_t ringbuffer_peek(ringbuffer_t *buffer,
+                               void *dest,
+                               lcb_size_t nb);
+    lcb_size_t ringbuffer_peek_at(ringbuffer_t *buffer,
+                                  lcb_size_t offset,
+                                  void *dest,
+                                  lcb_size_t nb);
+    /* replace +nb+ bytes on +direction+ end of the buffer with src */
+    lcb_size_t ringbuffer_update(ringbuffer_t *buffer,
+                                 ringbuffer_direction_t direction,
+                                 const void *src, lcb_size_t nb);
+    void ringbuffer_get_iov(ringbuffer_t *buffer,
+                            ringbuffer_direction_t direction,
+                            struct lcb_iovec_st *iov);
+    void ringbuffer_produced(ringbuffer_t *buffer, lcb_size_t nb);
+    void ringbuffer_consumed(ringbuffer_t *buffer, lcb_size_t nb);
+    lcb_size_t ringbuffer_get_nbytes(ringbuffer_t *buffer);
+    int ringbuffer_is_continous(ringbuffer_t *buffer,
+                                ringbuffer_direction_t direction,
+                                lcb_size_t nb);
+
+    int ringbuffer_append(ringbuffer_t *src, ringbuffer_t *dest);
+    int ringbuffer_memcpy(ringbuffer_t *dst, ringbuffer_t *src,
+                          lcb_size_t nbytes);
+
+    /* Align the read head of the ringbuffer for platforms where it's needed */
+    int ringbuffer_ensure_alignment(ringbuffer_t *src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/src/settings.c

@@ -0,0 +1,95 @@
+/* -*- 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 "settings.h"
+#include <lcbio/ssl.h>
+#include <rdb/rope.h>
+#include "auth.h"
+
+LCB_INTERNAL_API
+void lcb_default_settings(lcb_settings *settings)
+{
+    settings->ipv6 = LCB_IPV6_DISABLED;
+    settings->operation_timeout = LCB_DEFAULT_TIMEOUT;
+    settings->config_timeout = LCB_DEFAULT_CONFIGURATION_TIMEOUT;
+    settings->config_node_timeout = LCB_DEFAULT_NODECONFIG_TIMEOUT;
+    settings->views_timeout = LCB_DEFAULT_VIEW_TIMEOUT;
+    settings->n1ql_timeout = LCB_DEFAULT_N1QL_TIMEOUT;
+    settings->durability_timeout = LCB_DEFAULT_DURABILITY_TIMEOUT;
+    settings->durability_interval = LCB_DEFAULT_DURABILITY_INTERVAL;
+    settings->http_timeout = LCB_DEFAULT_HTTP_TIMEOUT;
+    settings->weird_things_threshold = LCB_DEFAULT_CONFIG_ERRORS_THRESHOLD;
+    settings->weird_things_delay = LCB_DEFAULT_CONFIG_ERRORS_DELAY;
+    settings->max_redir = LCB_DEFAULT_CONFIG_MAXIMUM_REDIRECTS;
+    settings->grace_next_cycle = LCB_DEFAULT_CLCONFIG_GRACE_CYCLE;
+    settings->grace_next_provider = LCB_DEFAULT_CLCONFIG_GRACE_NEXT;
+    settings->bc_http_stream_time = LCB_DEFAULT_BC_HTTP_DISCONNTMO;
+    settings->retry_interval = LCB_DEFAULT_RETRY_INTERVAL;
+    settings->retry_backoff = LCB_DEFAULT_RETRY_BACKOFF;
+    settings->sslopts = 0;
+    settings->retry[LCB_RETRY_ON_SOCKERR] = LCB_DEFAULT_NETRETRY;
+    settings->retry[LCB_RETRY_ON_TOPOCHANGE] = LCB_DEFAULT_TOPORETRY;
+    settings->retry[LCB_RETRY_ON_VBMAPERR] = LCB_DEFAULT_NMVRETRY;
+    settings->retry[LCB_RETRY_ON_MISSINGNODE] = 0;
+    settings->bc_http_urltype = LCB_DEFAULT_HTCONFIG_URLTYPE;
+    settings->compressopts = LCB_DEFAULT_COMPRESSOPTS;
+    settings->allocator_factory = rdb_bigalloc_new;
+    settings->syncmode = LCB_ASYNCHRONOUS;
+    settings->detailed_neterr = 0;
+    settings->refresh_on_hterr = 1;
+    settings->sched_implicit_flush = 1;
+    settings->fetch_mutation_tokens = 0;
+    settings->dur_mutation_tokens = 1;
+    settings->nmv_retry_imm = LCB_DEFAULT_NVM_RETRY_IMM;
+    settings->tcp_nodelay = LCB_DEFAULT_TCP_NODELAY;
+    settings->retry_nmv_interval = LCB_DEFAULT_RETRY_NMV_INTERVAL;
+    settings->vb_noguess = LCB_DEFAULT_VB_NOGUESS;
+}
+
+LCB_INTERNAL_API
+lcb_settings *
+lcb_settings_new(void)
+{
+    lcb_settings *settings = calloc(1, sizeof(*settings));
+    lcb_default_settings(settings);
+    settings->refcount = 1;
+    settings->auth = lcbauth_new();
+    return settings;
+}
+
+LCB_INTERNAL_API
+void
+lcb_settings_unref(lcb_settings *settings)
+{
+    if (--settings->refcount) {
+        return;
+    }
+    free(settings->bucket);
+    free(settings->sasl_mech_force);
+    free(settings->certpath);
+    free(settings->client_string);
+
+    lcbauth_free(settings->auth);
+
+    if (settings->ssl_ctx) {
+        lcbio_ssl_free(settings->ssl_ctx);
+    }
+    if (settings->dtorcb) {
+        settings->dtorcb(settings->dtorarg);
+    }
+    free(settings);
+}

data/ext/libcouchbase/src/settings.h

@@ -0,0 +1,188 @@
+/* -*- 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_SETTINGS_H
+#define LCB_SETTINGS_H
+#include "auth.h"
+
+/**
+ * Handy macros for converting between different time resolutions
+ */
+
+/** Convert seconds to millis */
+#define LCB_S2MS(s) ((lcb_uint32_t)s) * 1000
+
+/** Convert seconds to microseconds */
+#define LCB_S2US(s) ((lcb_uint32_t)s) * 1000000
+
+/** Convert seconds to nanoseconds */
+#define LCB_S2NS(s) ((hrtime_t)s) * 1000000000
+
+/** Convert nanoseconds to microseconds */
+#define LCB_NS2US(s) (lcb_uint32_t) ((s) / 1000)
+
+#define LCB_MS2US(s) (s) * 1000
+
+/** Convert microseconds to nanoseconds */
+#define LCB_US2NS(s) ((hrtime_t)s) * 1000
+
+
+#define LCB_DEFAULT_TIMEOUT LCB_MS2US(2500)
+
+/** 5 seconds for total bootstrap */
+#define LCB_DEFAULT_CONFIGURATION_TIMEOUT LCB_MS2US(5000)
+
+/** 2 seconds per node */
+#define LCB_DEFAULT_NODECONFIG_TIMEOUT LCB_MS2US(2000)
+
+#define LCB_DEFAULT_VIEW_TIMEOUT LCB_MS2US(75000)
+#define LCB_DEFAULT_N1QL_TIMEOUT LCB_MS2US(75000)
+#define LCB_DEFAULT_DURABILITY_TIMEOUT LCB_MS2US(5000)
+#define LCB_DEFAULT_DURABILITY_INTERVAL LCB_MS2US(100)
+#define LCB_DEFAULT_HTTP_TIMEOUT LCB_MS2US(75000)
+#define LCB_DEFAULT_CONFIG_MAXIMUM_REDIRECTS 3
+#define LCB_DEFAULT_CONFIG_ERRORS_THRESHOLD 100
+
+/* 10 seconds */
+#define LCB_DEFAULT_CONFIG_ERRORS_DELAY LCB_MS2US(10000)
+
+/* 1 second */
+#define LCB_DEFAULT_CLCONFIG_GRACE_CYCLE LCB_MS2US(1000)
+
+/* 100 ms */
+#define LCB_DEFAULT_CLCONFIG_GRACE_NEXT LCB_MS2US(100)
+
+/* Infinite (i.e. compat mode) */
+#define LCB_DEFAULT_BC_HTTP_DISCONNTMO -1
+
+/* 10ms */
+#define LCB_DEFAULT_RETRY_INTERVAL LCB_MS2US(10)
+
+/* 1.5x */
+#define LCB_DEFAULT_RETRY_BACKOFF 1.5
+
+#define LCB_DEFAULT_TOPORETRY LCB_RETRY_CMDS_ALL
+#define LCB_DEFAULT_NETRETRY LCB_RETRY_CMDS_ALL
+#define LCB_DEFAULT_NMVRETRY LCB_RETRY_CMDS_ALL
+#define LCB_DEFAULT_HTCONFIG_URLTYPE LCB_HTCONFIG_URLTYPE_TRYALL
+#define LCB_DEFAULT_COMPRESSOPTS LCB_COMPRESS_NONE
+
+#define LCB_DEFAULT_NVM_RETRY_IMM 1
+#define LCB_DEFAULT_RETRY_NMV_INTERVAL LCB_MS2US(100)
+#define LCB_DEFAULT_VB_NOGUESS 1
+#define LCB_DEFAULT_TCP_NODELAY 1
+
+#include "config.h"
+#include <libcouchbase/couchbase.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct lcb_logprocs_st;
+struct lcbio_SSLCTX;
+struct rdb_ALLOCATOR;
+
+/**
+ * Stateless setting structure.
+ * Specifically this contains the 'environment' of the instance for things
+ * which are intended to be passed around to other objects.
+ */
+typedef struct lcb_settings_st {
+    lcb_U16 iid;
+    lcb_U8 compressopts;
+    lcb_U8 syncmode;
+    lcb_U32 read_chunk_size;
+    lcb_U32 operation_timeout;
+    lcb_U32 views_timeout;
+    lcb_U32 http_timeout;
+    lcb_U32 n1ql_timeout;
+    lcb_U32 durability_timeout;
+    lcb_U32 durability_interval;
+    lcb_U32 config_timeout;
+    lcb_U32 config_node_timeout;
+    lcb_U32 retry_interval;
+    lcb_U32 weird_things_threshold;
+    lcb_U32 weird_things_delay;
+
+    /** Grace period to wait between querying providers */
+    lcb_U32 grace_next_provider;
+
+    /** Grace period to wait between retrying from the beginning */
+    lcb_U32 grace_next_cycle;
+
+    /**For bc_http, the amount of type to keep the stream open, for future
+     * updates. */
+    lcb_U32 bc_http_stream_time;
+
+    unsigned bc_http_urltype : 4;
+
+    /** Don't guess next vbucket server. Mainly for testing */
+    unsigned vb_noguess : 1;
+    /** Whether lcb_destroy is synchronous. This mode will run the I/O event
+     * loop as much as possible until no outstanding events remain.*/
+    unsigned syncdtor : 1;
+    unsigned detailed_neterr : 1;
+    unsigned randomize_bootstrap_nodes : 1;
+    unsigned conntype : 1;
+    unsigned refresh_on_hterr : 1;
+    unsigned sched_implicit_flush : 1;
+    unsigned nmv_retry_imm : 1;
+    unsigned keep_guess_vbs : 1;
+    unsigned fetch_mutation_tokens : 1;
+    unsigned dur_mutation_tokens : 1;
+    unsigned sslopts : 3;
+    unsigned ipv6 : 2;
+    unsigned tcp_nodelay : 1;
+    unsigned readj_ts_wait : 1;
+
+    short max_redir;
+    unsigned refcount;
+
+    uint8_t retry[LCB_RETRY_ON_MAX];
+    float retry_backoff;
+
+    char *bucket;
+    char *sasl_mech_force;
+    char *certpath;
+    lcb_AUTHENTICATOR *auth;
+    struct rdb_ALLOCATOR* (*allocator_factory)(void);
+    struct lcbio_SSLCTX *ssl_ctx;
+    struct lcb_logprocs_st *logger;
+    void (*dtorcb)(const void *);
+    void *dtorarg;
+    char *client_string;
+    lcb_U32 retry_nmv_interval;
+} lcb_settings;
+
+LCB_INTERNAL_API
+void lcb_default_settings(lcb_settings *settings);
+
+LCB_INTERNAL_API
+lcb_settings *
+lcb_settings_new(void);
+
+LCB_INTERNAL_API
+void
+lcb_settings_unref(lcb_settings *);
+
+#define lcb_settings_ref(settings) (settings)->refcount++
+
+#ifdef __cplusplus
+}
+#endif
+#endif

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));
+}