libcouchbase 0.3.3 → 1.0.0

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

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

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

@@ -48,11 +48,12 @@ extern "C" {
      * Create an instance of an event handler that utilize libev for
      * event notification.
      *
-     * @param version the API version to use
+     * @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 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,8 +43,6 @@ 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

@@ -10,24 +10,43 @@ namespace lcb {
 class Authenticator {
 public:
     typedef std::map<std::string,std::string> Map;
+    // Gets the "global" username
     const std::string& username() const { return m_username; }
+
+    // Gets the "global" password
     const std::string& password() const { return m_password; }
+
+    // Get the username and password for a specific bucket
+    const std::string& username_for(const char *bucket) const;
+    const std::string& password_for(const char *bucket) const;
+
     const Map& buckets() const { return m_buckets; }
-    Authenticator() : m_refcount(1) {}
+    Authenticator() : m_refcount(1), m_mode(LCBAUTH_MODE_CLASSIC) {}
+    Authenticator(const Authenticator&);
 
     size_t refcount() const { return m_refcount; }
     void incref() { ++m_refcount; }
     void decref() { if (!--m_refcount) { delete this; } }
+    lcb_error_t set_mode(lcbauth_MODE mode_) {
+        if (m_buckets.size() || m_username.size() || m_password.size()) {
+            return LCB_ERROR;
+        } else {
+            m_mode = mode_;
+            return LCB_SUCCESS;
+        }
+    }
+    lcbauth_MODE mode() const { return m_mode; }
     lcb_error_t add(const char *user, const char *pass, int flags);
-    lcb_error_t init(const std::string& username_, const std::string& bucket,
-        const std::string& password, lcb_type_t conntype);
+    lcb_error_t add(const std::string& user, const std::string& pass, int flags) {
+        return add(user.c_str(), pass.c_str(), flags);
+    }
 
 private:
-    // todo: refactor these out
     Map m_buckets;
     std::string m_username;
     std::string m_password;
     size_t m_refcount;
+    lcbauth_MODE m_mode;
 };
 }
 #endif

data/ext/libcouchbase/src/auth.cc

@@ -9,16 +9,6 @@ lcbauth_new()
     return new Authenticator();
 }
 
-const char *
-lcbauth_get_bpass(const lcb_AUTHENTICATOR *auth, const char *u)
-{
-    Authenticator::Map::const_iterator ii = auth->buckets().find(u);
-    if (ii == auth->buckets().end()) {
-        return NULL;
-    }
-    return ii->second.c_str();
-}
-
 lcb_error_t
 lcbauth_add_pass(lcb_AUTHENTICATOR *auth, const char *u, const char *p, int flags)
 {
@@ -28,46 +18,63 @@ lcbauth_add_pass(lcb_AUTHENTICATOR *auth, const char *u, const char *p, int flag
 lcb_error_t
 Authenticator::add(const char *u, const char *p, int flags)
 {
-    if (!flags) {
+    if (!(flags & (LCBAUTH_F_BUCKET|LCBAUTH_F_CLUSTER))) {
         return LCB_EINVAL;
     }
 
+    if (m_mode == LCBAUTH_MODE_RBAC && (flags & LCBAUTH_F_BUCKET)) {
+        return LCB_OPTIONS_CONFLICT;
+    }
+
     if (flags & LCBAUTH_F_CLUSTER) {
-        if (!p) {
-            m_username.clear();
-            m_password.clear();
-        } else {
+        if (p) {
             m_username = u;
             m_password = p;
+        } else {
+            m_username.clear();
+            m_password.clear();
         }
     }
+
     if (flags & LCBAUTH_F_BUCKET) {
-        if (!p) {
-            m_buckets.erase(u);
-        } else {
+        if (p) {
             m_buckets[u] = p;
+        } else {
+            m_buckets.erase(u);
         }
     }
+
     return LCB_SUCCESS;
 }
 
-void
-lcbauth_get_upass(const lcb_AUTHENTICATOR *auth, const char **u, const char **p)
-{
-    if (!auth->username().empty()) {
-        *u = auth->username().c_str();
-        *p = auth->password().empty() ? NULL : auth->password().c_str();
-
-    } else if (!auth->buckets().empty()) {
-        Authenticator::Map::const_iterator it = auth->buckets().begin();
-        *u = it->first.c_str();
-        if (!it->second.empty()) {
-            *p = it->second.c_str();
+static const std::string EmptyString;
+
+const std::string&
+Authenticator::username_for(const char *bucket) const {
+    if (m_mode == LCBAUTH_MODE_CLASSIC) {
+        // Find bucket specific credentials:
+        const Map::const_iterator it = m_buckets.find(bucket);
+        if (it == m_buckets.end()) {
+            return EmptyString;
+        } else {
+            return it->first;
+        }
+    } else {
+        return m_username;
+    }
+}
+
+const std::string&
+Authenticator::password_for(const char *bucket) const {
+    if (m_mode == LCBAUTH_MODE_CLASSIC) {
+        const Map::const_iterator it = m_buckets.find(bucket);
+        if (it == m_buckets.end()) {
+            return EmptyString;
         } else {
-            *p = NULL;
+            return it->second;
         }
     } else {
-        *u = *p = NULL;
+        return m_password;
     }
 }
 
@@ -83,17 +90,18 @@ lcbauth_unref(lcb_AUTHENTICATOR *auth)
     auth->decref();
 }
 
-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;
+Authenticator::Authenticator(const Authenticator& other)
+    : m_buckets(other.m_buckets), m_username(other.m_username),
+      m_password(other.m_password), m_refcount(1),
+      m_mode(other.m_mode) {
+}
 
-    if (conntype == LCB_TYPE_BUCKET && m_username != bucket) {
-        return LCB_INVALID_USERNAME;
-    }
+lcb_AUTHENTICATOR *
+lcbauth_clone(const lcb_AUTHENTICATOR *src) {
+    return new Authenticator(*src);
+}
 
-    m_buckets[bucket] = m_password;
-    return LCB_SUCCESS;
+lcb_error_t
+lcbauth_set_mode(lcb_AUTHENTICATOR *src, lcbauth_MODE mode) {
+    return src->set_mode(mode);
 }

data/ext/libcouchbase/src/bootstrap.cc

@@ -0,0 +1,244 @@
+/* -*- 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__
+
+using lcb::clconfig::EventType;
+using lcb::clconfig::ConfigInfo;
+using namespace lcb;
+
+/**
+ * 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.
+ */
+void Bootstrap::config_callback(EventType event, ConfigInfo *info) {
+    using namespace lcb::clconfig;
+    lcb_t instance = parent;
+
+    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
+            if (!LCBT_VBCONFIG(instance)) {
+                initial_error(LCB_ERROR, "No more bootstrap providers remain");
+            }
+        }
+        return;
+    }
+
+    instance->last_error = LCB_SUCCESS;
+
+    /** Ensure we're not called directly twice again */
+    if (state < S_INITIAL_TRIGGERED) {
+        state = S_INITIAL_TRIGGERED;
+    }
+
+    tm.cancel();
+
+    lcb_log(LOGARGS(instance, DEBUG), "Instance configured!");
+
+    if (info->get_origin() != 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 */
+        last_refresh = gethrtime();
+        errcounter = 0;
+    }
+
+    if (info->get_origin() == CLCONFIG_CCCP) {
+        /* Disable HTTP provider if we've received something via CCCP */
+
+        if (instance->cur_configinfo == NULL ||
+                instance->cur_configinfo->get_origin() != CLCONFIG_HTTP) {
+            /* Never disable HTTP if it's still being used */
+            instance->confmon->set_active(CLCONFIG_HTTP, false);
+        }
+    }
+
+    if (instance->type == LCB_TYPE_CLUSTER && info->get_origin() == CLCONFIG_CLADMIN) {
+        /* Disable HTTP provider for management operations, and fallback to static */
+        if (instance->cur_configinfo == NULL ||
+                instance->cur_configinfo->get_origin() != CLCONFIG_HTTP) {
+            instance->confmon->set_active(CLCONFIG_HTTP, false);
+        }
+    }
+
+    if (instance->type != LCB_TYPE_CLUSTER) {
+        lcb_update_vbconfig(instance, info);
+    }
+
+    if (state < S_BOOTSTRAPPED) {
+        state = S_BOOTSTRAPPED;
+        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->get_origin() != CLCONFIG_MCRAW) {
+
+            lcb_log(LOGARGS(instance, INFO), "Reverting to HTTP Config for memcached buckets");
+            instance->settings->bc_http_stream_time = -1;
+            instance->confmon->set_active(CLCONFIG_HTTP, true);
+            instance->confmon->set_active(CLCONFIG_CCCP, false);
+        }
+        instance->callbacks.bootstrap(instance, LCB_SUCCESS);
+
+        // See if we can enable background polling.
+        check_bgpoll();
+    }
+
+    lcb_maybe_breakout(instance);
+}
+
+void Bootstrap::clconfig_lsn(EventType e, ConfigInfo *i) {
+    if (state == S_INITIAL_PRE) {
+        config_callback(e, i);
+    } else if (e == clconfig::CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        lcb_log(LOGARGS(parent, INFO), "Got new config. Will refresh asynchronously");
+        tm.signal();
+    }
+}
+
+void Bootstrap::check_bgpoll() {
+    if (parent->cur_configinfo == NULL ||
+            parent->cur_configinfo->get_origin() != lcb::clconfig::CLCONFIG_CCCP ||
+            LCBT_SETTING(parent, config_poll_interval) == 0) {
+        tmpoll.cancel();
+    } else {
+        tmpoll.rearm(LCBT_SETTING(parent, config_poll_interval));
+    }
+}
+
+void Bootstrap::bgpoll() {
+    lcb_log(LOGARGS(parent, TRACE), "Background-polling for new configuration");
+    bootstrap(BS_REFRESH_THROTTLE);
+    check_bgpoll();
+}
+
+/**
+ * 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.
+ */
+void Bootstrap::timer_dispatch() {
+    if (state > S_INITIAL_PRE) {
+        config_callback(clconfig::CLCONFIG_EVENT_GOT_NEW_CONFIG,
+            parent->confmon->get_config());
+    } else {
+        // Not yet bootstrapped!
+        initial_error(LCB_ETIMEDOUT, "Failed to bootstrap in time");
+    }
+}
+
+
+void Bootstrap::initial_error(lcb_error_t err, const char *errinfo) {
+    parent->last_error = parent->confmon->get_last_error();
+    if (parent->last_error == LCB_SUCCESS) {
+        parent->last_error = err;
+    }
+    parent->callbacks.error(parent, parent->last_error, errinfo);
+    lcb_log(LOGARGS(parent, ERR), "Failed to bootstrap client=%p. Error=%s, Message=%s", (void *)parent, lcb_strerror_short(parent->last_error), errinfo);
+    tm.cancel();
+
+    parent->callbacks.bootstrap(parent, parent->last_error);
+
+    lcb_aspend_del(&parent->pendops, LCB_PENDTYPE_COUNTER, NULL);
+    lcb_maybe_breakout(parent);
+}
+
+Bootstrap::Bootstrap(lcb_t instance)
+    : parent(instance),
+      tm(parent->iotable, this),
+      tmpoll(parent->iotable, this),
+      last_refresh(0),
+      errcounter(0),
+      state(S_INITIAL_PRE) {
+    parent->confmon->add_listener(this);
+}
+
+lcb_error_t Bootstrap::bootstrap(unsigned options) {
+    hrtime_t now = gethrtime();
+    if (parent->confmon->is_refreshing()) {
+        return LCB_SUCCESS;
+    }
+
+    if (options & BS_REFRESH_THROTTLE) {
+        /* Refresh throttle requested. This is not true if options == ALWAYS */
+        hrtime_t next_ts;
+        unsigned errthresh = LCBT_SETTING(parent, weird_things_threshold);
+
+        if (options & BS_REFRESH_INCRERR) {
+            errcounter++;
+        }
+        next_ts = last_refresh;
+        next_ts += LCB_US2NS(LCBT_SETTING(parent, weird_things_delay));
+        if (now < next_ts && errcounter < errthresh) {
+            lcb_log(LOGARGS(parent, 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-errcounter);
+            return LCB_SUCCESS;
+        }
+    }
+
+    if (options == BS_REFRESH_INITIAL) {
+        state = S_INITIAL_PRE;
+        parent->confmon->prepare();
+        tm.rearm(LCBT_SETTING(parent, config_timeout));
+        lcb_aspend_add(&parent->pendops, LCB_PENDTYPE_COUNTER, NULL);
+    }
+
+    /* Reset the counters */
+    errcounter = 0;
+    if (options != BS_REFRESH_INITIAL) {
+        last_refresh = now;
+    }
+    parent->confmon->start();
+    return LCB_SUCCESS;
+}
+
+Bootstrap::~Bootstrap() {
+    tm.release();
+    parent->confmon->remove_listener(this);
+}
+
+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) {
+        if (lcb::clconfig::http_get_conn(instance->confmon) != NULL || instance->confmon->get_config() != NULL) {
+            return LCB_SUCCESS;
+        }
+    }
+    return LCB_ERROR;
+}
+
+LIBCOUCHBASE_API
+void
+lcb_refresh_config(lcb_t instance)
+{
+    instance->bootstrap(BS_REFRESH_ALWAYS);
+}