mt-libcouchbase 1.4.0

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

@@ -0,0 +1,85 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017-2018 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_AUTH_PRIV_H
+#define LCB_AUTH_PRIV_H
+#include <libcouchbase/auth.h>
+
+#ifdef __cplusplus
+#include <string>
+#include <map>
+
+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 *host, const char *port, const char *bucket) const;
+    const std::string password_for(const char *host, const char *port, const char *bucket) const;
+
+    const Map& buckets() const { return m_buckets; }
+    Authenticator() : m_refcount(1), m_mode(LCBAUTH_MODE_CLASSIC), m_usercb(NULL), m_passcb(NULL), m_cookie(NULL)
+    {
+    }
+    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 (mode_ == LCBAUTH_MODE_DYNAMIC && (m_usercb == NULL || m_passcb == NULL)) {
+            return LCB_EINVAL;
+        }
+        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 add(const std::string& user, const std::string& pass, int flags) {
+        return add(user.c_str(), pass.c_str(), flags);
+    }
+    lcb_error_t set_callbacks(void *cookie, lcb_AUTHCALLBACK usercb, lcb_AUTHCALLBACK passcb)
+    {
+        m_usercb = usercb;
+        m_passcb = passcb;
+        m_cookie = cookie;
+        return LCB_SUCCESS;
+    }
+
+  private:
+    Map m_buckets;
+    std::string m_username;
+    std::string m_password;
+    size_t m_refcount;
+    lcbauth_MODE m_mode;
+    lcb_AUTHCALLBACK m_usercb;
+    lcb_AUTHCALLBACK m_passcb;
+    void *m_cookie;
+};
+}
+#endif
+#endif /* LCB_AUTH_H */

data/ext/libcouchbase/src/auth.cc

@@ -0,0 +1,146 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017-2018 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 <libcouchbase/couchbase.h>
+#include "auth-priv.h"
+
+using namespace lcb;
+
+lcb_AUTHENTICATOR *
+lcbauth_new()
+{
+    return new Authenticator();
+}
+
+lcb_error_t
+lcbauth_add_pass(lcb_AUTHENTICATOR *auth, const char *u, const char *p, int flags)
+{
+    return auth->add(u, p, flags);
+}
+
+lcb_error_t
+Authenticator::add(const char *u, const char *p, int flags)
+{
+    if (!u) {
+        return LCB_EINVAL;
+    }
+
+    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 = u;
+            m_password = p;
+        } else {
+            m_username.clear();
+            m_password.clear();
+        }
+    }
+
+    if (flags & LCBAUTH_F_BUCKET) {
+        if (p) {
+            m_buckets[u] = p;
+        } else {
+            m_buckets.erase(u);
+        }
+    }
+
+    return LCB_SUCCESS;
+}
+
+static const std::string EmptyString;
+
+const std::string Authenticator::username_for(const char *host, const char *port, const char *bucket) const
+{
+    switch (m_mode) {
+        case LCBAUTH_MODE_RBAC:
+            return m_username;
+        case LCBAUTH_MODE_DYNAMIC:
+            if (m_usercb != NULL) {
+                return m_usercb(m_cookie, host, port, bucket);
+            }
+            break;
+        case LCBAUTH_MODE_CLASSIC:
+            // Find bucket specific credentials:
+            const Map::const_iterator it = m_buckets.find(bucket);
+            if (it != m_buckets.end()) {
+                return it->first;
+            }
+            break;
+    }
+    return EmptyString;
+}
+
+const std::string Authenticator::password_for(const char *host, const char *port, const char *bucket) const
+{
+    switch (m_mode) {
+        case LCBAUTH_MODE_RBAC:
+            return m_password;
+        case LCBAUTH_MODE_DYNAMIC:
+            if (m_passcb != NULL) {
+                return m_passcb(m_cookie, host, port, bucket);
+            }
+            break;
+        case LCBAUTH_MODE_CLASSIC:
+            const Map::const_iterator it = m_buckets.find(bucket);
+            if (it != m_buckets.end()) {
+                return it->second;
+            }
+            break;
+    }
+    return EmptyString;
+}
+
+void
+lcbauth_ref(lcb_AUTHENTICATOR *auth)
+{
+    auth->incref();
+}
+
+void
+lcbauth_unref(lcb_AUTHENTICATOR *auth)
+{
+    auth->decref();
+}
+
+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), m_usercb(other.m_usercb), m_passcb(other.m_passcb), m_cookie(other.m_cookie)
+{
+}
+
+lcb_AUTHENTICATOR *
+lcbauth_clone(const lcb_AUTHENTICATOR *src) {
+    return new Authenticator(*src);
+}
+
+lcb_error_t
+lcbauth_set_mode(lcb_AUTHENTICATOR *src, lcbauth_MODE mode) {
+    return src->set_mode(mode);
+}
+
+lcb_error_t lcbauth_set_callbacks(lcb_AUTHENTICATOR *auth, void *cookie, lcb_AUTHCALLBACK usercb,
+                                  lcb_AUTHCALLBACK passcb)
+{
+    return auth->set_callbacks(cookie, usercb, passcb);
+}

data/ext/libcouchbase/src/bootstrap.cc

@@ -0,0 +1,263 @@
+/* -*- 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();
+
+
+    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);
+
+        lcb_log(LOGARGS(instance, INFO), "Selected network configuration: \"%s\"", LCBT_SETTING(instance, network));
+        if (instance->type == LCB_TYPE_BUCKET) {
+            if (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);
+            }
+
+            /* infer bucket type using distribution and capabilities set */
+            switch (LCBVB_DISTTYPE(LCBT_VBCONFIG(instance))) {
+            case LCBVB_DIST_VBUCKET:
+                if (LCBVB_CAPS(LCBT_VBCONFIG(instance)) & LCBVB_CAP_COUCHAPI) {
+                    instance->btype = LCB_BTYPE_COUCHBASE;
+                } else {
+                    instance->btype = LCB_BTYPE_EPHEMERAL;
+                }
+                break;
+            case LCBVB_DIST_KETAMA:
+                instance->btype = LCB_BTYPE_MEMCACHED;
+                break;
+            }
+        }
+        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_ALWAYS);
+    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 %" PRIu64 "ms 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) {
+        if (LCBT_SETTING(parent, network)) {
+            lcb_log(LOGARGS(parent, INFO), "Requested network configuration: \"%s\"", LCBT_SETTING(parent, network));
+        } else {
+            lcb_log(LOGARGS(parent, INFO), "Requested network configuration: heuristic");
+        }
+        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);
+}

data/ext/libcouchbase/src/bootstrap.h

@@ -0,0 +1,149 @@
+/* -*- 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_BOOTSTRAP_H
+#define LCB_BOOTSTRAP_H
+
+/**@file
+ * Core bootstrap/cluster configuration routines */
+
+/**@defgroup lcb_bootstrap Bootstrap Routines
+ * @addtogroup lcb_bootstrap
+ * @{
+ */
+
+#ifdef __cplusplus
+#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;
+    }
+
+    /**
+     * Try to start/stop background polling depending on whether we're able to.
+     */
+    void check_bgpoll();
+
+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();
+    void bgpoll();
+
+    lcb_t parent;
+
+    /**Timer used for initial bootstrap as an interval timer, and for subsequent
+     * updates as an asynchronous event (to allow safe updates and avoid
+     * reentrancy issues)
+     */
+    lcb::io::Timer<Bootstrap, &Bootstrap::timer_dispatch> tm;
+
+    /**Timer used for periodic polling of config */
+    lcb::io::Timer<Bootstrap, &Bootstrap::bgpoll> tmpoll;
+
+    /**
+     * Timestamp indicating the most recent configuration activity. This
+     * timestamp is used to control throttling, such that the @ref
+     * LCB_CNTL_CONFDELAY_THRESH setting is applied as an offset to this
+     * timestamp (accounting for ns-to-us conversion). This flag is set whenever
+     *
+     * * A new configuration is received (solicited or unsolicited)
+     * * A request for a new configuration is made, and the request has not
+     *   been throttled
+     */
+    hrtime_t last_refresh;
+
+    /**
+     * Counter incremented each time a request is based to lcb_bootstrap_common()
+     * with the @ref LCB_BS_REFRESH_INCRERR flag, and where the request itself
+     * had been throttled. This increments the internal error counter and when
+     * the counter reaches a threshold higher than @ref LCB_CNTL_CONFERRTHRESH
+     * a new configuration is requested.
+     * This counter is cleared whenever a new configuration arrives.
+     */
+    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;
+};
+
+/**
+ * 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 {
+    /** Always fetch a new configuration. No throttling checks are performed */
+    BS_REFRESH_ALWAYS = 0x00,
+    /** Special mode used to fetch the first configuration */
+    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,
+
+    /** 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
+};
+
+void
+lcb_bootstrap_destroy(lcb_t instance);
+
+/**@}*/
+
+} // namespace lcb
+#endif // __cplusplus
+#endif /* LCB_BOOTSTRAP_H */