mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/errmap.cc

@@ -0,0 +1,173 @@
+#include "internal.h"
+#include "errmap.h"
+#include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
+
+using namespace lcb::errmap;
+
+ErrorMap::ErrorMap() : revision(0), version(0) {
+}
+
+static ErrorAttribute getAttribute(const std::string& s) {
+    #define X(c, s_) if (s == s_) { return c; }
+    LCB_XERRMAP_ATTRIBUTES(X)
+    #undef X
+    return INVALID_ATTRIBUTE;
+}
+
+RetrySpec *Error::getRetrySpec() const {
+    return retry.specptr;
+}
+
+RetrySpec* RetrySpec::parse(const Json::Value& retryJson, std::string& emsg) {
+
+    RetrySpec *spec = new RetrySpec();
+    spec->refcount = 1;
+
+#define FAIL_RETRY(s) \
+    emsg = s; \
+    delete spec; \
+    return NULL;
+
+    if (!retryJson.isObject()) {
+        FAIL_RETRY("Missing retry specification");
+    }
+
+    const Json::Value& strategyJson = retryJson["strategy"];
+    if (!strategyJson.isString()) {
+        FAIL_RETRY("Missing `strategy`");
+    }
+    const char* strategy = strategyJson.asCString();
+    if (!strcasecmp(strategy, "constant")) {
+        spec->strategy = CONSTANT;
+    } else if (!strcasecmp(strategy, "linear")) {
+        spec->strategy = LINEAR;
+    } else if (!strcasecmp(strategy, "exponential")) {
+        spec->strategy = EXPONENTIAL;
+    } else {
+        FAIL_RETRY("Unknown strategy");
+    }
+
+#define GET_TIMEFLD(srcname, dstname, required) { \
+    Json::Value dstname##Json = retryJson[srcname]; \
+    if (dstname##Json.isNumeric()) { \
+        spec->dstname = (dstname##Json).asUInt() * 1000; \
+    } else if (required) { \
+        FAIL_RETRY("Missing " # srcname); \
+    } else { \
+        spec->dstname = 0; \
+    } \
+}
+
+    GET_TIMEFLD("interval", interval, true);
+    GET_TIMEFLD("after", after, true);
+    GET_TIMEFLD("ceil", ceil, false);
+    GET_TIMEFLD("max-duration", max_duration, false);
+
+    return spec;
+
+#undef FAIL_RETRY
+#undef GET_TIMEFLD
+
+}
+
+const uint32_t ErrorMap::MAX_VERSION = 1;
+
+ErrorMap::ParseStatus
+ErrorMap::parse(const char *s, size_t n, std::string& errmsg) {
+    Json::Value root_nonconst;
+    Json::Reader reader;
+    if (!reader.parse(s, s + n, root_nonconst)) {
+        errmsg = "Invalid JSON";
+        return PARSE_ERROR;
+    }
+
+    const Json::Value& root = root_nonconst;
+    const Json::Value& verJson = root["version"];
+    if (!verJson.isNumeric()) {
+        errmsg = "'version' is not a number";
+        return PARSE_ERROR;
+    }
+
+    if (verJson.asUInt() > MAX_VERSION) {
+        errmsg = "'version' is unreasonably high";
+        return UNKNOWN_VERSION;
+    }
+
+    const Json::Value& revJson = root["revision"];
+    if (!revJson.isNumeric()) {
+        errmsg = "'revision' is not a number";
+        return PARSE_ERROR;
+    }
+
+    if (revJson.asUInt() <= revision) {
+        return NOT_UPDATED;
+    }
+
+    const Json::Value& errsJson = root["errors"];
+    if (!errsJson.isObject()) {
+        errmsg = "'errors' is not an object";
+        return PARSE_ERROR;
+    }
+
+    Json::Value::const_iterator ii = errsJson.begin();
+    for (; ii != errsJson.end(); ++ii) {
+        // Key is the version in hex
+        unsigned ec = 0;
+        if (sscanf(ii.key().asCString(), "%x", &ec) != 1) {
+            errmsg = "key " + ii.key().asString() + " is not a hex number";
+            return PARSE_ERROR;
+        }
+
+        const Json::Value& errorJson = *ii;
+
+        // Descend into the error attributes
+        Error error;
+        error.code = static_cast<uint16_t>(ec);
+
+        error.shortname = errorJson["name"].asString();
+        error.description = errorJson["desc"].asString();
+
+        const Json::Value& attrs = errorJson["attrs"];
+        if (!attrs.isArray()) {
+            errmsg = "'attrs' is not an array";
+            return PARSE_ERROR;
+        }
+
+        Json::Value::const_iterator jj = attrs.begin();
+        for (; jj != attrs.end(); ++jj) {
+            ErrorAttribute attr = getAttribute(jj->asString());
+            if (attr == INVALID_ATTRIBUTE) {
+                errmsg = "unknown attribute received";
+                return UNKNOWN_VERSION;
+            }
+            error.attributes.insert(attr);
+        }
+        if (error.hasAttribute(AUTO_RETRY)) {
+            const Json::Value& retryJson = errorJson["retry"];
+            if (!retryJson.isObject()) {
+                errmsg = "Need `retry` specification for `auto-retry` attribute";
+                return PARSE_ERROR;
+            }
+            if ((error.retry.specptr = RetrySpec::parse(retryJson, errmsg)) == NULL) {
+                return PARSE_ERROR;
+            }
+        }
+        errors.insert(MapType::value_type(ec, error));
+    }
+
+    return UPDATED;
+}
+
+const Error& ErrorMap::getError(uint16_t code) const {
+    static const Error invalid;
+    MapType::const_iterator it = errors.find(code);
+
+    if (it != errors.end()) {
+        return it->second;
+    } else {
+        return invalid;
+    }
+}
+
+ErrorMap *lcb_errmap_new() { return new ErrorMap(); }
+void lcb_errmap_free(ErrorMap* m) { delete m; }

data/ext/libcouchbase/src/errmap.h

@@ -0,0 +1,271 @@
+#ifndef LCB_ERRMAP_H
+#define LCB_ERRMAP_H
+
+#ifdef __cplusplus
+#include <map>
+#include <set>
+#include <string>
+#include <cmath>
+
+namespace Json { class Value; }
+
+namespace lcb {
+namespace errmap {
+
+enum ErrorAttribute {
+#define LCB_XERRMAP_ATTRIBUTES(X) \
+    /**                                                                 \
+     * This error is transient. Note that this does not mean the        \
+     * error is retriable.                                              \
+     */                                                                 \
+    X(TEMPORARY, "temp")                                                \
+    /**                                                                 \
+     * The error is related to the subdocument subsystem.               \
+     */                                                                 \
+    X(SUBDOC, "subdoc")                                                 \
+    /**                                                                 \
+     * The operation may be retried immediately.                        \
+     */                                                                 \
+    X(RETRY_NOW, "retry-now")                                           \
+    /**                                                                 \
+     * The operation may be retried after some time.                    \
+     */                                                                 \
+    X(RETRY_LATER, "retry-later")                                       \
+    /**                                                                 \
+     * This attribute means that a user's input was invalid because it  \
+     * violates the semantics of the operation, or exceeds some         \
+     * predefined limit.                                                \
+     */                                                                 \
+    X(INVALID_INPUT, "invalid-input")                                   \
+    /**                                                                 \
+     * The operation is not supported, possibly because the of server   \
+     * version, bucket type, or  current user.                          \
+     */                                                                 \
+    X(NOT_ENABLED, "support")                                           \
+    /**                                                                 \
+     * The operation failed because the client failed to authenticate   \
+     * or is not authorized to perform this operation. Note that this   \
+     * error in itself does not mean the connection is invalid, unless  \
+     * conn-state-invalidated is also present.                          \
+     */                                                                 \
+    X(AUTH, "auth")                                                     \
+    /**                                                                 \
+     * The current connection is no longer valid. The client must       \
+     * reconnect to the server. Note that the presence of other         \
+     * attributes may indicate an alternate remedy to fixing the        \
+     * connection without a disconnect, but without special remedial    \
+     * action a disconnect is needed.                                   \
+     */                                                                 \
+    X(CONN_STATE_INVALIDATED, "conn-state-invalidated")                 \
+    /**                                                                 \
+     * This attribute means that the error is related to a constraint   \
+     * failure regarding the item itself, i.e. the item does not exist, \
+     * already exists, or its current value makes the current operation \
+     * impossible. Retrying the operation when the item's value or      \
+     * status has changed may succeed.                                  \
+     */                                                                 \
+    X(CONSTRAINT_FAILURE, "item-only")                                  \
+    /**                                                                 \
+     *  This is an internal error in the server.                        \
+     */                                                                 \
+    X(INTERNAL, "internal")                                             \
+    /**                                                                 \
+     * The error is related to the DCP subsystem.                       \
+     */                                                                 \
+    X(DCP, "dcp")                                                       \
+    /**                                                                 \
+     * The client's cluster map may be outdated and requires updating.  \
+     * The client should obtain a newer configuration.                  \
+     */                                                                 \
+    X(FETCH_CONFIG, "fetch-config")                                     \
+    /**                                                                 \
+     * This error code must be handled specially. If it is not handled, \
+     * the connection must be dropped.                                  \
+     */                                                                 \
+    X(SPECIAL_HANDLING, "special-handling")                             \
+    /**                                                                 \
+     * Use retry specifications from the server                         \
+     */                                                                 \
+    X(AUTO_RETRY, "auto-retry")                                         \
+    /**                                                                 \
+     * The operation was successful for those situations                \
+     * where the error code is indicating successful (i.e. subdoc       \
+     * operations carried out on a deleted document)                    \
+     */                                                                 \
+    X(SUCCESS, "success")                                               \
+    /**                                                                 \
+     * This attribute specifies that the requested item is currently    \
+     * locked.                                                          \
+     */                                                                 \
+    X(ITEM_LOCKED, "item-locked")                                       \
+    /**                                                                 \
+     * This attribute means that the error is related to operating on   \
+     * a soft-deleted document.                                         \
+     */                                                                 \
+    X(ITEM_DELETED, "item-deleted")                                     \
+
+    #define X(c, s) c,
+    LCB_XERRMAP_ATTRIBUTES(X)
+    #undef X
+
+    INVALID_ATTRIBUTE
+};
+
+class RetrySpec {
+public:
+    enum Strategy { CONSTANT, LINEAR, EXPONENTIAL };
+    // Grace time
+    uint32_t after;
+
+    // Maximum duration for retry.
+    uint32_t max_duration;
+
+    uint32_t get_next_interval(size_t num_attempts) const {
+        uint32_t cur_interval = 0; // 50ms is a safe bet.
+        if (strategy == CONSTANT) {
+            return interval;
+        } else if (strategy == LINEAR) {
+            cur_interval = num_attempts * interval;
+        } else if (strategy == EXPONENTIAL) {
+            // Convert to ms for pow(), convert result back to us.
+            cur_interval = std::pow((double)(interval / 1000), (int)num_attempts) * 1000;
+        }
+        if (ceil != 0) {
+            // Note, I *could* use std::min here, but this file gets
+            // included by other files, and Windows is giving a hard time
+            // because it defines std::min as a macro. NOMINMAX is a possible
+            // definition, but I'd rather not touch all including files
+            // to contain that macro, and I don't want to add additional
+            // preprocessor defs at this time.
+            cur_interval = ceil > cur_interval ? cur_interval : ceil;
+        }
+        return cur_interval;
+    }
+
+    void ref() {
+        refcount++;
+    }
+
+    void unref() {
+        if (!--refcount) {
+            delete this;
+        }
+    }
+
+    static inline RetrySpec* parse(const Json::Value& specJson,
+                                   std::string& errmsg);
+
+private:
+    Strategy strategy;
+
+    // Base interval
+    uint32_t interval;
+
+    // Max interval
+    uint32_t ceil;
+
+
+    size_t refcount;
+};
+
+class SpecWrapper {
+private:
+    friend class RetrySpec;
+    friend struct Error;
+    friend class ErrorMap;
+
+    RetrySpec *specptr;
+    SpecWrapper() : specptr(NULL) {}
+    SpecWrapper(const SpecWrapper& other) {
+        specptr = other.specptr;
+        if (specptr != NULL) {
+            specptr->ref();
+        }
+    }
+    ~SpecWrapper() {
+        if (specptr) {
+            specptr->unref();
+        }
+        specptr = NULL;
+    }
+};
+
+struct Error {
+    uint16_t code;
+    std::string shortname;
+    std::string description;
+    std::set<ErrorAttribute> attributes;
+    SpecWrapper retry;
+
+    Error() : code(-1) {
+    }
+
+    bool isValid() const {
+        return code != uint16_t(-1);
+    }
+
+    bool hasAttribute(ErrorAttribute attr) const {
+        return attributes.find(attr) != attributes.end();
+    }
+
+    RetrySpec *getRetrySpec() const;
+};
+
+class ErrorMap {
+public:
+    enum ParseStatus {
+        /** Couldn't parse JSON!*/
+        PARSE_ERROR,
+
+        /** Version is too high */
+        UNKNOWN_VERSION,
+
+        /** Current version/revision is higher or equal */
+        NOT_UPDATED,
+
+        /** Updated */
+        UPDATED
+    };
+
+    ErrorMap();
+    ParseStatus parse(const char *s, size_t n, std::string& errmsg);
+    ParseStatus parse(const char *s, size_t n) {
+        std::string tmp;
+        return parse(s, n, tmp);
+    }
+    size_t getVersion() const { return version; }
+    size_t getRevision() const { return revision; };
+    const Error& getError(uint16_t code) const;
+    bool isLoaded() const {
+        return !errors.empty();
+    }
+
+private:
+    static const uint32_t MAX_VERSION;
+    ErrorMap(const ErrorMap&);
+    typedef std::map<uint16_t, Error> MapType;
+    MapType errors;
+    uint32_t revision;
+    uint32_t version;
+};
+
+} // namespace
+} // namespace
+
+typedef lcb::errmap::ErrorMap* lcb_pERRMAP;
+#else
+typedef struct lcb_ERRMAP* lcb_pERRMAP;
+#endif /* __cplusplus */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+lcb_pERRMAP lcb_errmap_new(void);
+void lcb_errmap_free(lcb_pERRMAP);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LCB_ERRMAP_H */

data/ext/libcouchbase/src/getconfig.cc

@@ -0,0 +1,72 @@
+/* -*- 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 "internal.h"
+#include "packetutils.h"
+#include <bucketconfig/clconfig.h>
+
+static void
+ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
+                   const void  *resdata)
+{
+    lcb::Server *server = static_cast<lcb::Server*>(pl);
+    mc_REQDATAEX *rd = req->u_rdata.exdata;
+    const lcb::MemcachedResponse *res =
+            reinterpret_cast<const lcb::MemcachedResponse*>(resdata);
+
+    lcb::clconfig::cccp_update(rd->cookie, rc, res->value(), res->vallen(),
+        &server->get_host());
+    free(rd);
+}
+
+static mc_REQDATAPROCS procs = { ext_callback_proxy };
+
+lcb_error_t
+lcb_st::request_config(const void *cookie_, lcb::Server *server)
+{
+    lcb_error_t err;
+    mc_PACKET *packet;
+    mc_REQDATAEX *rd;
+
+    packet = mcreq_allocate_packet(server);
+    if (!packet) {
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    err = mcreq_reserve_header(server, packet, 24);
+    if (err != LCB_SUCCESS) {
+        mcreq_release_packet(server, packet);
+        return err;
+    }
+
+    rd = reinterpret_cast<mc_REQDATAEX*>(calloc(1, sizeof(*rd)));
+    rd->procs = &procs;
+    rd->cookie = cookie_;
+    rd->start = gethrtime();
+    packet->u_rdata.exdata = rd;
+    packet->flags |= MCREQ_F_REQEXT;
+
+    lcb::MemcachedRequest hdr(
+        PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG, packet->opaque);
+    hdr.opaque(packet->opaque);
+    memcpy(SPAN_BUFFER(&packet->kh_span), hdr.data(), hdr.size());
+
+    mcreq_sched_enter(&cmdq);
+    mcreq_sched_add(server, packet);
+    mcreq_sched_leave(&cmdq, 1);
+    return LCB_SUCCESS;
+}

data/ext/libcouchbase/src/gethrtime.c

@@ -0,0 +1,109 @@
+/* -*- 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.
+ */
+
+#include "config.h"
+#include "settings.h"
+#include <libcouchbase/couchbase.h>
+
+#ifndef HAVE_GETHRTIME
+
+#include <stdlib.h>
+#include <time.h>
+#if defined(__MACH__) && defined(__APPLE__)
+#include <mach/mach_time.h>
+#endif
+
+#ifdef __linux__
+#undef HAVE_CLOCK_GETTIME
+#define HAVE_CLOCK_GETTIME 1
+#endif
+
+#define CLOCK_START_OFFSET (LCB_S2NS(3600 * 24))
+
+hrtime_t gethrtime(void)
+{
+#ifdef __APPLE__
+
+    /* Most things expect a pretty large timestamp - even though a smaller one
+     * may be perfectly valid. Initialize the default with an offset of one day,
+     * in nanoseconds
+     */
+
+    /* Use the various mach stuff:
+     * https://developer.apple.com/library/mac/qa/qa1398/_index.html */
+
+    static uint64_t start = 0;
+    uint64_t now ;
+    static mach_timebase_info_data_t tmbi;
+
+    if (start == 0) {
+        start = mach_absolute_time();
+        mach_timebase_info(&tmbi);
+    }
+
+    now = mach_absolute_time();
+    return ((now - start) * tmbi.numer / tmbi.denom) + CLOCK_START_OFFSET;
+
+#elif defined(HAVE_CLOCK_GETTIME)
+    struct timespec tm;
+    lcb_assert(clock_gettime(CLOCK_MONOTONIC, &tm) != -1);
+    return (((hrtime_t)tm.tv_sec) * 1000000000) + (hrtime_t)tm.tv_nsec;
+#elif defined(HAVE_GETTIMEOFDAY)
+
+    hrtime_t ret;
+    struct timeval tv;
+    if (gettimeofday(&tv, NULL) == -1) {
+        return -1;
+    }
+
+    ret = (hrtime_t)tv.tv_sec * 1000000000;
+    ret += (hrtime_t)tv.tv_usec * 1000;
+    return ret;
+#elif defined(HAVE_QUERYPERFORMANCECOUNTER)
+    double ret;
+    // To fix the potential race condition for the local static variable,
+    // gethrtime should be called in a global static variable first.
+    // It will guarantee the local static variable will be initialized
+    // before any thread calls the function.
+    static LARGE_INTEGER pf = { 0 };
+    static double freq;
+    LARGE_INTEGER currtime;
+
+    if (pf.QuadPart == 0) {
+        lcb_assert(QueryPerformanceFrequency(&pf));
+        lcb_assert(pf.QuadPart != 0);
+        freq = 1.0e9 / (double)pf.QuadPart;
+    }
+
+    QueryPerformanceCounter(&currtime);
+
+    ret = (double)currtime.QuadPart * freq ;
+    return (hrtime_t)ret + CLOCK_START_OFFSET;
+#else
+#error "I don't know how to build a highres clock..."
+#endif
+}
+#endif /* HAVE_GETHRTIME */
+
+/* Symbol usable so other subsystems can get the same idea of time the library
+ * has. This will also allow us to stop shipping the 'gethrtime' file around.
+ */
+
+LCB_INTERNAL_API
+lcb_U64 lcb_nstime(void) {
+    return gethrtime();
+}