libcouchbase 0.0.1

data/ext/libcouchbase/plugins/io/select/select_io_opts.h

@@ -0,0 +1,39 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 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 LIBCOUCHBASE_SELECT_IO_OPTS_H
+#define LIBCOUCHBASE_SELECT_IO_OPTS_H 1
+
+#include <libcouchbase/couchbase.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+     * Create an instance of an event handler that utilize libev for
+     * event notification.
+     *
+     * @return status of the operation
+     */
+    LIBCOUCHBASE_API
+    lcb_error_t lcb_create_select_io_opts(int version, lcb_io_opt_t *io, void *loop);
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/src/README.md

@@ -0,0 +1,103 @@
+# Internal source code structure
+
+This directory contains the source code for libcouchbase. Here is a brief
+listing of the various subcomponents and what they do:
+
+* `internal.h` contains the top level internal declarations.
+
+* `config_static.h` contains statically inferred (via macros) platform information.
+
+* `instance.c` contains functions related to creating and destroying the actual
+  `lcb_t` handle. It also contains some convenience functions.
+
+* `bootstrap.{c,h}` contains the top-level logic for _retrieving_ the cluster
+  configuration
+
+* `newconfig.c` contains the logic for _applying_ a new configuration
+
+* `bucketconfig/*` is a directory which contains the low level transport logic used
+  to retrieve a new configuration
+
+* `callbacks.c` contains the functions used to implement the library's `set_callback`
+  accessor functions.
+
+* `operations/*` is a directory which contains the top level entry points for memcached
+  requests
+
+* `handler.c` contains the response handlers for memcached.
+
+* `getconfig.c` contains the implementation for requesting a config from an existing
+  server.
+
+* `connspec.{c,h}` contains the connection string parsing logic
+
+* `cntl.c` contains the handlers for the `lcb_cntl()` family of functions
+
+* `dump.c` contains the handlers for the `lcb_dump()` function
+
+* `gethrtime.c` contains platform-dependent implementations of a nanosecond timer
+
+* `hashset.{c,h}` contains the implementation for a set (unique collection of pointers)
+
+* `list.{c,h}` contains the implementation for a double-linked list
+
+* `sllist.h, sllist-inl.h` contain the implementation for a single-linked list
+
+* `simplestring.{c,h}` contains the implementation for a dynamically sized string
+
+* `logging.{c,h}` contains the implementation for the library's logging mechanism
+
+* `hostlist.{c,h}` defines a list of hosts, with features for de-duping and converting
+  to other structures
+
+* `nodeinfo.c` contains the implementation for the `lcb_get_node()` function.
+
+* `packetutils.{c,h}` contains utilities and macros for handling partial memcached
+  response packets
+
+* `wait.c` contains the implementation of `lcb_wait()`
+
+* `timings.c` contains the implementation of `lcb_get_timings()`
+
+* `trace.h` contains macros for DTrace functionality
+
+* `utilities.c` contains cross-platform utilities (such as temporary directory,
+  getting environment variables)
+
+* `iofactory.c` contains the plugin intialization/loading functionality for I/O
+  plugins
+
+* `retrychk.c` contains logic which determines if a rety is necessary under certain
+  conditions
+
+* `retryq.{c,h}` contains an internal retried operations, and are placed there if they
+  are eligible for retries.
+
+* `aspend.h` contains definitions for pending operations which are meant to block
+  calls to `lcb_wait()` (implementation in instance.c)
+
+* `lcbio/*` is a directory which contains the cross platform/cross model IO
+  implementation. Most I/O is done in this subdirectory
+
+* `http/*` contains the API implementation for user-level HTTP requests
+
+* `lcbht/*` contains an HTTP response parsing API/implementation
+
+* `mc/*` contains the memcached/Couchbase structure and packet/buffer allocation
+  and scheduling logic.
+
+* `mcserver/*` contains the operation/failure/IO logic for memcached connections
+
+* `vbucket/*` contains the raw vBucket config parsing and hashing/mapping implementation
+  (formerly known as "libvbucket")
+
+* `rdb/*` contains an extensible pooled read buffer implementation
+
+* `netbuf/*` contains an extensible high performance output buffer implementation
+
+* `rigbuffer.{c,h}` contains a circular buffer implementation.
+
+* `ssl/*` contains the OpenSSL interfacing routines
+
+* `strcodecs/*` contains utility functions to encode/decode strings to/from
+  various formats.

data/ext/libcouchbase/src/aspend.h

@@ -0,0 +1,106 @@
+/* -*- 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_ASPEND_H
+#define LCB_ASPEND_H
+
+#include "config.h"
+#include "hashset.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page Asynchronous Pending Queue
+ *
+ * This defines the API for asynchronous requests which should block calls to
+ * lcb_wait() or similar. This is a replacement for the explicit hashsets used
+ * in lcb_t.
+ *
+ * Items are added to the pending queue via lcb_aspend_add(). They may be
+ * removed either explicitly via lcb_aspend_del() or implicitly when the
+ * instance is destroyed.
+ *
+ * An exception to this rule is the special LCB_PENDTYPE_COUNTER which does
+ * not associate a specific pointer with it.
+ */
+
+/** Pending item type */
+typedef enum {
+    LCB_PENDTYPE_TIMER = 0, /**< item is of type lcb_timer_t */
+    LCB_PENDTYPE_HTTP, /**< item is of type lcb_http_request_t */
+    LCB_PENDTYPE_DURABILITY, /**< item is of type lcb_durability_set_t */
+    LCB_PENDTYPE_COUNTER, /**< just increment/decrement the counter */
+    LCB_PENDTYPE_MAX
+} lcb_ASPENDTYPE;
+
+/** Items for pending operations */
+typedef struct {
+    hashset_t items[LCB_PENDTYPE_MAX];
+    unsigned count;
+} lcb_ASPEND;
+
+/**
+ * Initialize the pending queues
+ * @param ops
+ */
+void lcb_aspend_init(lcb_ASPEND *ops);
+
+/**
+ * Clean up any resources used by the pending queues
+ * @param ops
+ */
+void lcb_aspend_cleanup(lcb_ASPEND *ops);
+
+/**
+ * Add an opaque pointer of a given type to a pending queue
+ * @param ops
+ * @param type The type of pointer to add
+ * @param item The item to add
+ */
+void lcb_aspend_add(lcb_ASPEND *ops, lcb_ASPENDTYPE type, const void *item);
+
+/**
+ * Remove an item from the queue and decrement the pending count
+ * @param ops
+ * @param type The type of item to remove
+ * @param item The item to remove
+ *
+ * @attention If the item is not found inside the queue then the count is
+ * _not_ decremented. An exception to this rule is the LCB_PENDTYPE_COUNTER
+ * type which does not have a pointer associated with it. In this case the
+ * counter is always decremented.
+ */
+void lcb_aspend_del(lcb_ASPEND *ops, lcb_ASPENDTYPE type, const void *item);
+
+/**
+ * Get a queue for a given type
+ * @param ops
+ * @param type
+ */
+#define lcb_aspend_get(ops, type) (ops)->items[type]
+
+/**
+ * Determine whether there are pending items in any of the queues
+ * @param ops
+ */
+#define lcb_aspend_pending(ops) ((ops)->count > 0)
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/src/auth.cc

@@ -0,0 +1,74 @@
+#include <libcouchbase/couchbase.h>
+#include "auth.h"
+
+using namespace lcb;
+
+lcb_AUTHENTICATOR *
+lcbauth_new()
+{
+    return new Authenticator();
+}
+
+void
+lcbauth_free(lcb_AUTHENTICATOR *auth)
+{
+    delete auth;
+}
+
+const char *
+lcbauth_get_bpass(const lcb_AUTHENTICATOR *auth, const char *u)
+{
+    Authenticator::Map::const_iterator ii = auth->m_buckets.find(u);
+    if (ii == auth->m_buckets.end()) {
+        return NULL;
+    }
+    return ii->second.c_str();
+}
+
+void
+lcbauth_set(lcb_AUTHENTICATOR *auth, const char *u, const char *p,
+    int is_global)
+{
+    if (is_global) {
+        auth->m_username = u;
+        auth->m_password = p;
+    } else {
+        auth->m_buckets[u] = p;
+    }
+}
+
+void
+lcb_authenticator_clear(lcb_AUTHENTICATOR *auth)
+{
+    auth->m_buckets.clear();
+}
+
+void
+lcbauth_get_upass(const lcb_AUTHENTICATOR *auth, const char **u, const char **p)
+{
+    if (!auth->m_username.empty()) {
+        *u = auth->m_username.c_str();
+    } else {
+        *u = NULL;
+    }
+    if (!auth->m_password.empty()) {
+        *p = auth->m_password.c_str();
+    } else {
+        *p = NULL;
+    }
+}
+
+lcb_error_t
+Authenticator::init(const std::string& username_, const std::string& bucket,
+    const std::string& passwd, lcb_type_t conntype)
+{
+    m_username = (!username_.empty()) ? username_ : bucket;
+    m_password = passwd;
+
+    if (conntype == LCB_TYPE_BUCKET && m_username != bucket) {
+        return LCB_INVALID_USERNAME;
+    }
+
+    m_buckets[bucket] = m_password;
+    return LCB_SUCCESS;
+}

data/ext/libcouchbase/src/auth.h

@@ -0,0 +1,54 @@
+#ifndef LCB_AUTH_H
+#define LCB_AUTH_H
+
+#ifdef __cplusplus
+#include <map>
+#include <string>
+namespace lcb { class Authenticator; }
+typedef lcb::Authenticator lcb_AUTHENTICATOR;
+extern "C" {
+#else /* C only! */
+typedef struct lcb_AUTHENTICATOR_Cdummy lcb_AUTHENTICATOR;
+#endif
+
+lcb_AUTHENTICATOR *
+lcbauth_new(void);
+
+void
+lcbauth_free(lcb_AUTHENTICATOR *);
+
+const char *
+lcbauth_get_bpass(const lcb_AUTHENTICATOR *auth, const char *name);
+
+void
+lcbauth_set(lcb_AUTHENTICATOR *auth,
+    const char *user, const char *pass, int is_global);
+
+void
+lcb_authenticator_clear(lcb_AUTHENTICATOR *auth);
+
+void
+lcbauth_get_upass(const lcb_AUTHENTICATOR *auth,
+    const char **u, const char **p);
+
+#ifdef __cplusplus
+}
+namespace lcb {
+class Authenticator {
+public:
+    typedef std::map<std::string,std::string> Map;
+    const std::string& username() const { return m_username; }
+    const std::string& password() const { return m_password; }
+    const Map& buckets() const { return m_buckets; }
+
+    // todo: refactor these out
+    Map m_buckets;
+    std::string m_username;
+    std::string m_password;
+
+    lcb_error_t init(const std::string& username_, const std::string& bucket,
+        const std::string& password, lcb_type_t conntype);
+};
+}
+#endif
+#endif /* LCB_AUTH_H */

data/ext/libcouchbase/src/bootstrap.c

@@ -0,0 +1,269 @@
+/* -*- 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.
+ */
+
+#define LCB_BOOTSTRAP_DEFINE_STRUCT 1
+#include "internal.h"
+
+
+#define LOGARGS(instance, lvl) instance->settings, "bootstrap", LCB_LOG_##lvl, __FILE__, __LINE__
+
+static void async_step_callback(clconfig_listener*,clconfig_event_t,clconfig_info*);
+static void initial_bootstrap_error(lcb_t, lcb_error_t,const char*);
+
+/**
+ * This function is where the configuration actually takes place. We ensure
+ * in other functions that this is only ever called directly from an event
+ * loop stack frame (or one of the small mini functions here) so that we
+ * don't accidentally end up destroying resources underneath us.
+ */
+static void
+config_callback(clconfig_listener *listener, clconfig_event_t event,
+    clconfig_info *info)
+{
+    struct lcb_BOOTSTRAP *bs = (struct lcb_BOOTSTRAP *)listener;
+    lcb_t instance = bs->parent;
+
+    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
+            if (!LCBT_VBCONFIG(instance)) {
+                initial_bootstrap_error(
+                    instance, LCB_ERROR, "No more bootstrap providers remain");
+            }
+        }
+        return;
+    }
+
+    instance->last_error = LCB_SUCCESS;
+    /** Ensure we're not called directly twice again */
+    listener->callback = async_step_callback;
+    lcbio_timer_disarm(bs->tm);
+
+    lcb_log(LOGARGS(instance, DEBUG), "Instance configured!");
+
+    if (info->origin != LCB_CLCONFIG_FILE) {
+        /* Set the timestamp for the current config to control throttling,
+         * but only if it's not an initial file-based config. See CCBC-482 */
+        bs->last_refresh = gethrtime();
+        bs->errcounter = 0;
+    }
+
+    if (info->origin == LCB_CLCONFIG_CCCP) {
+        /* Disable HTTP provider if we've received something via CCCP */
+
+        if (instance->cur_configinfo == NULL ||
+                instance->cur_configinfo->origin != LCB_CLCONFIG_HTTP) {
+            /* Never disable HTTP if it's still being used */
+            lcb_confmon_set_provider_active(
+                instance->confmon, LCB_CLCONFIG_HTTP, 0);
+        }
+    }
+
+    if (instance->type != LCB_TYPE_CLUSTER) {
+        lcb_update_vbconfig(instance, info);
+    }
+
+    if (!bs->bootstrapped) {
+        bs->bootstrapped = 1;
+        lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
+
+        if (instance->type == LCB_TYPE_BUCKET &&
+                LCBVB_DISTTYPE(LCBT_VBCONFIG(instance)) == LCBVB_DIST_KETAMA &&
+                instance->cur_configinfo->origin != LCB_CLCONFIG_MCRAW) {
+
+            lcb_log(LOGARGS(instance, INFO), "Reverting to HTTP Config for memcached buckets");
+            instance->settings->bc_http_stream_time = -1;
+            lcb_confmon_set_provider_active(
+                instance->confmon, LCB_CLCONFIG_HTTP, 1);
+            lcb_confmon_set_provider_active(
+                instance->confmon, LCB_CLCONFIG_CCCP, 0);
+        }
+        instance->callbacks.bootstrap(instance, LCB_SUCCESS);
+    }
+
+    lcb_maybe_breakout(instance);
+}
+
+
+static void
+initial_bootstrap_error(lcb_t instance, lcb_error_t err, const char *errinfo)
+{
+    struct lcb_BOOTSTRAP *bs = instance->bootstrap;
+
+    instance->last_error = lcb_confmon_last_error(instance->confmon);
+    if (instance->last_error == LCB_SUCCESS) {
+        instance->last_error = err;
+    }
+    instance->callbacks.error(instance, instance->last_error, errinfo);
+    lcb_log(LOGARGS(instance, ERR), "Failed to bootstrap client=%p. Code=0x%x, Message=%s", (void *)instance, err, errinfo);
+    lcbio_timer_disarm(bs->tm);
+
+    instance->callbacks.bootstrap(instance, instance->last_error);
+
+    lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
+    lcb_maybe_breakout(instance);
+}
+
+/**
+ * This it the initial bootstrap timeout handler. This timeout pins down the
+ * instance. It is only scheduled during the initial bootstrap and is only
+ * triggered if the initial bootstrap fails to configure in time.
+ */
+static void initial_timeout(void *arg)
+{
+    struct lcb_BOOTSTRAP *bs = arg;
+    initial_bootstrap_error(bs->parent, LCB_ETIMEDOUT, "Failed to bootstrap in time");
+}
+
+/**
+ * Proxy async call to config_callback
+ */
+static void async_refresh(void *arg)
+{
+    /** Get the best configuration and run stuff.. */
+    struct lcb_BOOTSTRAP *bs = arg;
+    clconfig_info *info;
+
+    info = lcb_confmon_get_config(bs->parent->confmon);
+    config_callback(&bs->listener, CLCONFIG_EVENT_GOT_NEW_CONFIG, info);
+}
+
+/**
+ * set_next listener callback which schedules an async call to our config
+ * callback.
+ */
+static void
+async_step_callback(clconfig_listener *listener, clconfig_event_t event,
+    clconfig_info *info)
+{
+    struct lcb_BOOTSTRAP *bs = (struct lcb_BOOTSTRAP *)listener;
+
+    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        return;
+    }
+
+    if (lcbio_timer_armed(bs->tm) && lcbio_timer_get_target(bs->tm) == async_refresh) {
+        lcb_log(LOGARGS(bs->parent, DEBUG), "Timer already present..");
+        return;
+    }
+
+    lcb_log(LOGARGS(bs->parent, INFO), "Got async step callback..");
+    lcbio_timer_set_target(bs->tm, async_refresh);
+    lcbio_async_signal(bs->tm);
+    (void)info;
+}
+
+lcb_error_t
+lcb_bootstrap_common(lcb_t instance, int options)
+{
+    struct lcb_BOOTSTRAP *bs = instance->bootstrap;
+    hrtime_t now = gethrtime();
+
+    if (!bs) {
+        bs = calloc(1, sizeof(*instance->bootstrap));
+        if (!bs) {
+            return LCB_CLIENT_ENOMEM;
+        }
+
+        bs->tm = lcbio_timer_new(instance->iotable, bs, initial_timeout);
+        instance->bootstrap = bs;
+        bs->parent = instance;
+        lcb_confmon_add_listener(instance->confmon, &bs->listener);
+    }
+
+    if (lcb_confmon_is_refreshing(instance->confmon)) {
+        return LCB_SUCCESS;
+    }
+
+    if (options & LCB_BS_REFRESH_THROTTLE) {
+        /* Refresh throttle requested. This is not true if options == ALWAYS */
+        hrtime_t next_ts;
+        unsigned errthresh = LCBT_SETTING(instance, weird_things_threshold);
+
+        if (options & LCB_BS_REFRESH_INCRERR) {
+            bs->errcounter++;
+        }
+        next_ts = bs->last_refresh;
+        next_ts += LCB_US2NS(LCBT_SETTING(instance, weird_things_delay));
+        if (now < next_ts && bs->errcounter < errthresh) {
+            lcb_log(LOGARGS(instance, INFO),
+                "Not requesting a config refresh because of throttling parameters. Next refresh possible in %ums or %u errors. "
+                "See LCB_CNTL_CONFDELAY_THRESH and LCB_CNTL_CONFERRTHRESH to modify the throttling settings",
+                LCB_NS2US(next_ts-now)/1000, (unsigned)errthresh-bs->errcounter);
+            return LCB_SUCCESS;
+        }
+    }
+
+    if (options == LCB_BS_REFRESH_INITIAL) {
+        lcb_confmon_prepare(instance->confmon);
+
+        bs->listener.callback = config_callback;
+        lcbio_timer_set_target(bs->tm, initial_timeout);
+        lcbio_timer_rearm(bs->tm, LCBT_SETTING(instance, config_timeout));
+        lcb_aspend_add(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
+    } else {
+        /** No initial timer */
+        bs->listener.callback = async_step_callback;
+    }
+
+    /* Reset the counters */
+    bs->errcounter = 0;
+    if (options != LCB_BS_REFRESH_INITIAL) {
+        bs->last_refresh = now;
+    }
+    return lcb_confmon_start(instance->confmon);
+}
+
+void lcb_bootstrap_destroy(lcb_t instance)
+{
+    struct lcb_BOOTSTRAP *bs = instance->bootstrap;
+    if (!bs) {
+        return;
+    }
+    if (bs->tm) {
+        lcbio_timer_destroy(bs->tm);
+    }
+
+    lcb_confmon_remove_listener(instance->confmon, &bs->listener);
+    free(bs);
+    instance->bootstrap = NULL;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_get_bootstrap_status(lcb_t instance)
+{
+    if (instance->cur_configinfo) {
+        return LCB_SUCCESS;
+    }
+    if (instance->last_error != LCB_SUCCESS) {
+        return instance->last_error;
+    }
+    if (instance->type == LCB_TYPE_CLUSTER) {
+        lcbio_SOCKET *restconn = lcb_confmon_get_rest_connection(instance->confmon);
+        if (restconn) {
+            return LCB_SUCCESS;
+        }
+    }
+    return LCB_ERROR;
+}
+
+LIBCOUCHBASE_API
+void
+lcb_refresh_config(lcb_t instance)
+{
+    lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
+}