libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/include/memcached/vbucket.h

@@ -0,0 +1,42 @@
+/* -*- 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 MEMCACHED_VBUCKET_H
+#define MEMCACHED_VBUCKET_H 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+typedef enum {
+    vbucket_state_active = 1, /**< Actively servicing a vbucket. */
+    vbucket_state_replica, /**< Servicing a vbucket as a replica only. */
+    vbucket_state_pending, /**< Pending active. */
+    vbucket_state_dead /**< Not in use, pending deletion. */
+} vbucket_state_t;
+
+#define is_valid_vbucket_state_t(state) \
+    (state == vbucket_state_active || \
+     state == vbucket_state_replica || \
+     state == vbucket_state_pending || \
+     state == vbucket_state_dead)
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/packaging/parse-git-describe.pl

@@ -1,4 +1,4 @@
-#!/usr/bin/env perl
+#!/usr/bin/perl
 
 use strict;
 use warnings;

data/ext/libcouchbase/plugins/io/libev/libev_io_opts.h

@@ -48,12 +48,11 @@ extern "C" {
      * Create an instance of an event handler that utilize libev for
      * event notification.
      *
-     * @param version Set this to 0. This may be used in the future to allow
-     *        variation on the third argument (`void*` currently).
-     * @param[out] io a pointer to a newly created and initialized event handler
+     * @param version the API version to use
      * @param loop the event loop (struct ev_loop *) to hook use (please
      *             note that you shouldn't reference the event loop from
      *             multiple threads)
+     * @param io a pointer to a newly created and initialized event handler
      * @return status of the operation
      */
     LIBCOUCHBASE_API

data/ext/libcouchbase/src/README.md

@@ -43,6 +43,8 @@ listing of the various subcomponents and what they do:
 
 * `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

data/ext/libcouchbase/src/auth-priv.h

@@ -14,7 +14,6 @@ public:
     const std::string& password() const { return m_password; }
     const Map& buckets() const { return m_buckets; }
     Authenticator() : m_refcount(1) {}
-    Authenticator(const Authenticator&);
 
     size_t refcount() const { return m_refcount; }
     void incref() { ++m_refcount; }

data/ext/libcouchbase/src/auth.cc

@@ -90,16 +90,10 @@ Authenticator::init(const std::string& username_, const std::string& bucket,
     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;
 }
-
-Authenticator::Authenticator(const Authenticator& other)
-    : m_buckets(other.m_buckets), m_username(other.m_username),
-      m_password(other.m_password), m_refcount(1) {
-}
-
-lcb_AUTHENTICATOR *
-lcbauth_clone(const lcb_AUTHENTICATOR *src) {
-    return new Authenticator(*src);
-}

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

data/ext/libcouchbase/src/bootstrap.h

@@ -17,6 +17,9 @@
 
 #ifndef LCB_BOOTSTRAP_H
 #define LCB_BOOTSTRAP_H
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /**@file
  * Core bootstrap/cluster configuration routines */
@@ -26,43 +29,19 @@
  * @{
  */
 
-#ifdef __cplusplus
+#if defined(__LCB_DOXYGEN__) || defined(LCB_BOOTSTRAP_DEFINE_STRUCT)
 #include "bucketconfig/clconfig.h"
-#include <lcbio/timer-cxx.h>
 
-namespace lcb {
 /**
  * Structure containing the bootstrap state for the instance.
- *
- * Derived from Listener,
- * used to react when a new configuration is received. This
- * is used for both requested configurations (i.e. an explicit call to
- * lcb_bootstrap_common()) as well as unsolicited updates such as
- * HTTP streaming configurations or Not-My-Vbucket "Carrier" updates.
  */
-class Bootstrap : lcb::clconfig::Listener {
-public:
-    Bootstrap(lcb_t);
-    ~Bootstrap();
-    lcb_error_t bootstrap(unsigned options);
-
-    hrtime_t get_last_refresh() const {
-        return last_refresh;
-    }
-    void reset_last_refresh() {
-        last_refresh = 0;
-    }
-    size_t get_errcounter() const {
-        return errcounter;
-    }
-
-private:
-    // Override
-    void clconfig_lsn(lcb::clconfig::EventType e, lcb::clconfig::ConfigInfo* i);
-
-    inline void config_callback(lcb::clconfig::EventType, lcb::clconfig::ConfigInfo*);
-    inline void initial_error(lcb_error_t, const char *);
-    void timer_dispatch();
+struct lcb_BOOTSTRAP {
+    /**Listener object used to react when a new configuration is received. This
+     * is used for both requested configurations (i.e. an explicit call to
+     * lcb_bootstrap_common()) as well as unsolicited updates such as
+     * HTTP streaming configurations or Not-My-Vbucket "Carrier" updates.
+     */
+    clconfig_listener listener;
 
     lcb_t parent;
 
@@ -70,7 +49,7 @@ private:
      * updates as an asynchronous event (to allow safe updates and avoid
      * reentrancy issues)
      */
-    lcb::io::Timer<Bootstrap, &Bootstrap::timer_dispatch> tm;
+    lcbio_pTIMER tm;
 
     /**
      * Timestamp indicating the most recent configuration activity. This
@@ -94,47 +73,57 @@ private:
      */
     unsigned errcounter;
 
-    enum State {
-        /** Initial 'blank' state */
-        S_INITIAL_PRE = 0,
-        /** We got something after our initial callback */
-        S_INITIAL_TRIGGERED,
-        /** Have received at least one valid configuration */
-        S_BOOTSTRAPPED
-    };
-    State state;
+    /** Flag indicating whether the _initial_ configuration has been received */
+    int bootstrapped;
 };
+#endif
 
 /**
  * These flags control the bootstrap refreshing mode that will take place
  * when lcb_bootstrap_common() is invoked. These options may be OR'd with
  * each other (with the exception of ::LCB_BS_REFRESH_ALWAYS).
  */
-enum BootstrapOptions {
+typedef enum {
     /** Always fetch a new configuration. No throttling checks are performed */
-    BS_REFRESH_ALWAYS = 0x00,
+    LCB_BS_REFRESH_ALWAYS = 0x00,
     /** Special mode used to fetch the first configuration */
-    BS_REFRESH_INITIAL = 0x02,
+    LCB_BS_REFRESH_INITIAL = 0x02,
 
     /** Make the request for a new configuration subject to throttling
      * limitations. Currently this will be subject to the interval specified
      * in the @ref LCB_CNTL_CONFDELAY_THRESH setting and the @ref
      * LCB_CNTL_CONFERRTHRESH setting. If the refresh has been throttled
      * the lcb_confmon_is_refreshing() function will return false */
-    BS_REFRESH_THROTTLE = 0x04,
+    LCB_BS_REFRESH_THROTTLE = 0x04,
 
     /** To be used in conjunction with ::LCB_BS_REFRESH_THROTTLE, this will
      * increment the error counter in case the current refresh is throttled,
      * such that when the error counter reaches the threshold, the throttle
      * limitations will expire and a new refresh will take place */
-    BS_REFRESH_INCRERR = 0x08
-};
+    LCB_BS_REFRESH_INCRERR = 0x08
+} lcb_BSFLAGS;
+
+/**
+ * @brief Request that the handle update its configuration.
+ *
+ * This function acts as a gateway to the more abstract confmon interface.
+ *
+ * @param instance The instance
+ * @param options A set of options specified as flags, indicating under what
+ * conditions a new configuration should be refetched.
+ *
+ * @return
+ */
+LCB_INTERNAL_API
+lcb_error_t
+lcb_bootstrap_common(lcb_t instance, int options);
 
 void
 lcb_bootstrap_destroy(lcb_t instance);
 
 /**@}*/
 
-} // namespace lcb
-#endif // __cplusplus
+#ifdef __cplusplus
+}
+#endif
 #endif /* LCB_BOOTSTRAP_H */