libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/dump.cc

@@ -34,7 +34,7 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
     fprintf(fp, "Settings=%p\n", (void*)instance->settings);
 
     if (instance->cur_configinfo) {
-        clconfig_info *cfg = instance->cur_configinfo;
+        lcb::clconfig::ConfigInfo *cfg = instance->cur_configinfo;
         fprintf(fp, "Current VBC=%p\n", (void*)cfg->vbc);
         fprintf(fp, "Config RevID=%d\n", cfg->vbc->revid);
         if (flags & LCB_DUMP_VBCONFIG) {
@@ -67,7 +67,7 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
             fprintf(fp, "** == BEGIN SOCKET INFO\n");
             lcbio_ctx_dump(server->connctx, fp);
             fprintf(fp, "** == END SOCKET INFO\n");
-        } else if (server->connreq.u.p_generic) {
+        } else if (server->connreq) {
             fprintf(fp, "** == STILL CONNECTING\n");
         } else {
             fprintf(fp, "** == NOT CONNECTED\n");
@@ -90,6 +90,6 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
     fprintf(fp, "=== END PIPELINE DUMP ===\n");
 
     fprintf(fp, "=== BEGIN CONFMON DUMP ===\n");
-    lcb_confmon_dump(instance->confmon, fp);
+    instance->confmon->dump(fp);
     fprintf(fp, "=== END CONFMON DUMP ===\n");
 }

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,198 @@
+#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) \
+    X(TEMPORARY, "temp") \
+    X(SUBDOC, "subdoc") \
+    X(RETRY_NOW, "retry-now") \
+    X(RETRY_LATER, "retry-later") \
+    X(INVALID_INPUT, "invalid-input") \
+    X(NOT_ENABLED, "support") \
+    X(AUTH, "auth") \
+    X(CONN_STATE_INVALIDATED, "conn-state-invalidated") \
+    X(CONSTRAINT_FAILURE, "item-only") \
+    X(RETRY_EXP_BACKOFF, "retry-exp-backoff") \
+    X(RETRY_LINEAR_BACKOFF, "retry-linear-backoff") \
+    X(INTERNAL, "internal") \
+    X(DCP, "dcp") \
+    X(FETCH_CONFIG, "fetch-config") \
+    X(SPECIAL_HANDLING, "special-handling") \
+    X(AUTO_RETRY, "auto-retry")
+
+    #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

@@ -18,31 +18,6 @@
 #include "internal.h"
 #include "packetutils.h"
 #include <bucketconfig/clconfig.h>
-LCB_INTERNAL_API
-lcb::Server *
-lcb_find_server_by_host(lcb_t instance, const lcb_host_t *host)
-{
-    mc_CMDQUEUE *cq = &instance->cmdq;
-    unsigned ii;
-    for (ii = 0; ii < cq->npipelines; ii++) {
-        lcb::Server *server = static_cast<lcb::Server*>(cq->pipelines[ii]);
-        if (lcb_host_equals(&server->get_host(), host)) {
-            return server;
-        }
-    }
-    return NULL;
-}
-
-LCB_INTERNAL_API
-lcb::Server *
-lcb_find_server_by_index(lcb_t instance, int ix)
-{
-    mc_CMDQUEUE *cq = &instance->cmdq;
-    if (ix < 0 || ix >= static_cast<int>(cq->npipelines)) {
-        return NULL;
-    }
-    return static_cast<lcb::Server*>(cq->pipelines[ix]);
-}
 
 static void
 ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
@@ -53,19 +28,18 @@ ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
     const lcb::MemcachedResponse *res =
             reinterpret_cast<const lcb::MemcachedResponse*>(resdata);
 
-    lcb_cccp_update2(rd->cookie, rc, res->body<const char*>(), res->bodylen(),
-                     &server->get_host());
+    lcb::clconfig::cccp_update(
+        rd->cookie, rc, res->body<const char*>(), res->bodylen(),
+        &server->get_host());
     free(rd);
 }
 
 static mc_REQDATAPROCS procs = { ext_callback_proxy };
 
-LCB_INTERNAL_API
 lcb_error_t
-lcb_getconfig(lcb_t instance, const void *cookie, lcb::Server *server)
+lcb_st::request_config(const void *cookie_, lcb::Server *server)
 {
     lcb_error_t err;
-    mc_CMDQUEUE *cq = &instance->cmdq;
     mc_PACKET *packet;
     mc_REQDATAEX *rd;
 
@@ -82,7 +56,7 @@ lcb_getconfig(lcb_t instance, const void *cookie, lcb::Server *server)
 
     rd = reinterpret_cast<mc_REQDATAEX*>(calloc(1, sizeof(*rd)));
     rd->procs = &procs;
-    rd->cookie = cookie;
+    rd->cookie = cookie_;
     rd->start = gethrtime();
     packet->u_rdata.exdata = rd;
     packet->flags |= MCREQ_F_REQEXT;
@@ -92,8 +66,8 @@ lcb_getconfig(lcb_t instance, const void *cookie, lcb::Server *server)
     hdr.opaque(packet->opaque);
     memcpy(SPAN_BUFFER(&packet->kh_span), hdr.data(), hdr.size());
 
-    mcreq_sched_enter(cq);
+    mcreq_sched_enter(&cmdq);
     mcreq_sched_add(server, packet);
-    mcreq_sched_leave(cq, 1);
+    mcreq_sched_leave(&cmdq, 1);
     return LCB_SUCCESS;
 }