libcouchbase 0.0.9 → 0.1.0

data/ext/libcouchbase/src/errmap.h

@@ -0,0 +1,113 @@
+#ifndef LCB_ERRMAP_H
+#define LCB_ERRMAP_H
+
+#ifdef __cplusplus
+
+#include <map>
+#include <set>
+#include <string>
+
+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")
+
+    #define X(c, s) c,
+    LCB_XERRMAP_ATTRIBUTES(X)
+    #undef X
+
+    INVALID_ATTRIBUTE
+};
+
+struct Error {
+    uint16_t code;
+    std::string shortname;
+    std::string description;
+    std::set<ErrorAttribute> attributes;
+
+    Error() : code(-1) {
+    }
+
+    bool isValid() const {
+        return code != uint16_t(-1);
+    }
+
+    bool hasAttribute(ErrorAttribute attr) const {
+        return attributes.find(attr) != attributes.end();
+    }
+};
+
+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/hostlist.cc

@@ -263,38 +263,3 @@ Hostlist::assign(const Hostlist& src)
     }
     return *this;
 }
-
-extern "C" {
-Hostlist* hostlist_create(void) { return new Hostlist(); }
-void hostlist_destroy(hostlist_t l) { delete l; }
-void hostlist_clear(hostlist_t l) { l->clear(); }
-void hostlist_reset_strlist(hostlist_t l) { l->reset_strlist(); }
-lcb_error_t hostlist_add_host(hostlist_t l, const lcb_host_t *h) { l->add(*h); return LCB_SUCCESS; }
-lcb_host_t *hostlist_shift_next(hostlist_t hl, int wrap) { return hl->next(wrap); }
-int hostlist_finished(hostlist_t l) { return l->ix == l->hosts.size(); }
-size_t hostlist_size(hostlist_t l) { return l->size(); }
-void hostlist_randomize(hostlist_t l) { l->randomize(); }
-
-lcb_error_t
-hostlist_add_string(hostlist_t hl, const char *spec, int len, int deflport) {
-    return hl->add(spec, len, deflport);
-}
-
-void
-hostlist_assign(hostlist_t dst, const hostlist_t src) {
-    dst->assign(*src);
-}
-
-const lcb_host_t*
-hostlist_get(const hostlist_t h, size_t ix) { return &h->hosts[ix]; }
-
-const char * const *
-hostlist_strents(const hostlist_t h) {
-    h->ensure_strlist();
-    if (h->hoststrs.size()) {
-        return &h->hoststrs[0];
-    } else {
-        return NULL;
-    }
-}
-}

data/ext/libcouchbase/src/hostlist.h

@@ -45,56 +45,74 @@ struct Hostlist {
     Hostlist() : ix(0) {}
     ~Hostlist();
 
-    void add(const lcb_host_t&);
+    /**
+     * Adds a string to the hostlist. See lcb_host_parse for details.
+     * Note that if the host already exists (see 'lcb_host_equals') it will
+     * not be added
+     * @param s the string to parse
+     * @param len the length of the string
+     * @param deflport If `s` does not contain an explicit port, use this
+     *        port instead.
+     * @return LCB_EINVAL if the host string is not valid
+     */
     lcb_error_t add(const char *s, long len, int deflport);
     lcb_error_t add(const char *s, int deflport) { return add(s, -1, deflport); }
+    void add(const lcb_host_t&);
+
     bool exists(const lcb_host_t&) const;
     bool exists(const char *hostport) const;
+
+    /**
+     * Return the next host in the list.
+     * @param wrap If the internal iterator has reached its limit, this
+     * indicates whether it should be reset, or if it should return NULL
+     * @return a new host if available, or NULL if the list is empty or the
+     * iterator is finished.
+     */
     lcb_host_t *next(bool wrap);
     bool finished() const;
 
     size_t size() const { return hosts.size(); }
     bool empty() const { return hosts.empty(); }
     Hostlist& assign(const Hostlist& other);
+
+    /** Clears the hostlist */
     void clear() { hosts.clear(); reset_strlist(); ix = 0; }
+
+    /** Randomize the hostlist by shuffling the order. */
     void randomize();
+
+    /**
+     * String list handling functions. These are used to return the hostlist via
+     * the API where we return a char*[] terminated by a NULL pointer.
+     */
+
+    /** Ensure that the string list contains at least one entry */
     void ensure_strlist();
+
+    /** Frees the current list of strings */
     void reset_strlist();
+
+    const char * const *get_strlist() const { return &hoststrs[0]; }
+
     unsigned int ix;
     const lcb_host_t& operator[](size_t ix_) const { return hosts[ix_]; }
 
     std::vector<lcb_host_t> hosts;
     std::vector<const char *> hoststrs;
-    static Hostlist* from_c(hostlist_st* src) {
-        return reinterpret_cast<Hostlist*>(src);
-    }
 };
 }
 typedef lcb::Hostlist* hostlist_t;
 
 struct hostlist_st : lcb::Hostlist {
+    hostlist_st() : Hostlist() {
+    }
 };
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-
-/**
- * Creates a new hostlist. Returns NULL on allocation failure
- */
-hostlist_t hostlist_create(void);
-
-/**
- * Frees resources associated with the hostlist
- */
-void hostlist_destroy(hostlist_t hostlist);
-
-/**
- * Clears the hostlist
- */
-void hostlist_clear(hostlist_t hostlist);
-
 /**
  * Parses a string into a hostlist
  * @param host the target host to populate
@@ -126,50 +144,6 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport);
  */
 int lcb_host_equals(const lcb_host_t *a, const lcb_host_t *b);
 
-/**
- * Adds a string to the hostlist. See lcb_host_parse for details.
- * Note that if the host already exists (see 'lcb_host_equals') it will
- * not be added
- * @return LCB_EINVAL if the host string is not value, LCB_CLIENT_ENOMEM on
- * allocation failure.
- */
-lcb_error_t hostlist_add_string(hostlist_t hostlist,
-                                const char *spec,
-                                int speclen,
-                                int deflport);
-
-#define hostlist_add_stringz(hostlist, spec, deflport) \
-    hostlist_add_string(hostlist, spec, -1, deflport)
-
-lcb_error_t hostlist_add_host(hostlist_t hostlist, const lcb_host_t *host);
-
-/**
- * Return the next host in the list.
- * @param hostlist the hostlist to use
- * @param rollover If the internal iterator has reached its limit, this
- * indicates whether it should be reset, or if it should return NULL
- * @return a new host if available, or NULL if the list is empty or the
- * iterator is finished.
- */
-lcb_host_t *hostlist_shift_next(hostlist_t hostlist, int rollover);
-
-/**
- * Randomize the hostlist
- */
-void hostlist_randomize(hostlist_t hostlist);
-
-/**
- * String list handling functions. These are used to return the hostlist via
- * the API where we return a char*[] terminated by a NULL pointer.
- */
-void hostlist_reset_strlist(hostlist_t hostlist);
-
-/** Whether the internal iterator has finished. */
-int hostlist_finished(hostlist_t);
-size_t hostlist_size(const hostlist_t hl);
-void hostlist_assign(hostlist_t dst, const hostlist_t src);
-const lcb_host_t *hostlist_get(const hostlist_t, size_t);
-const char * const *hostlist_strents(const hostlist_t hl);
 #ifdef __cplusplus
 }
 #endif

data/ext/libcouchbase/src/http/http.cc

@@ -459,7 +459,12 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         return rc;
     }
 
-    add_header("User-Agent", "libcouchbase/" LCB_VERSION_STRING);
+    std::string ua("libcouchbase/" LCB_VERSION_STRING);
+    if (instance->settings->client_string) {
+        ua.append(" ").append(instance->settings->client_string);
+    }
+    add_header("User-Agent", ua);
+
     if (instance->http_sockpool->maxidle == 0 || !is_data_request()) {
         add_header("Connection", "close");
     }

data/ext/libcouchbase/src/instance.cc

@@ -129,7 +129,7 @@ lcb_st::process_dns_srv(Connspec& spec)
 
     const Spechost& host = spec.hosts().front();
     lcb_error_t rc = LCB_ERROR;
-    Hostlist* hl = lcb_dnssrv_getbslist(host.hostname.c_str(), host.isSSL(), &rc);
+    Hostlist* hl = dnssrv_getbslist(host.hostname.c_str(), host.isSSL(), rc);
 
     if (hl == NULL) {
         lcb_log(LOGARGS(this, INFO), "DNS SRV lookup failed: %s. Ignore this if not relying on DNS SRV records", lcb_strerror(this, rc));

data/ext/libcouchbase/src/internal.h

@@ -165,6 +165,16 @@ struct lcb_st {
         }
         return bs_state->bootstrap(options);
     }
+
+    lcbvb_CONFIG *getConfig() const {
+        return cur_configinfo->vbc;
+    }
+
+    int map_key(const std::string& key) {
+        int srvix, tmpvb;
+        lcbvb_map_key(getConfig(), key.c_str(), key.size(), &tmpvb, &srvix);
+        return srvix;
+    }
     #endif
 };
 

data/ext/libcouchbase/src/mcserver/mcserver.cc

@@ -29,6 +29,8 @@
 #define LOGARGS_T(lvl) LOGARGS(this, lvl)
 
 #define LOGFMT "<%s:%s> (SRV=%p,IX=%d) "
+#define PKTFMT "OP=0x%x, RC=0x%x, SEQ=%u"
+#define PKTARGS(pkt) (pkt).opcode(), (pkt).status(), (pkt).opaque()
 
 #define LOGID(server) get_ctx_host(server->connctx), get_ctx_port(server->connctx), (void*)server, server->index
 #define LOGID_T() LOGID(this)
@@ -164,6 +166,107 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
     return true;
 }
 
+/**
+ * Determine if this is an error code that we can pass to the user, or can
+ * otherwise handle "innately"
+ */
+static bool is_fastpath_error(uint16_t rc) {
+    switch (rc) {
+    case PROTOCOL_BINARY_RESPONSE_SUCCESS:
+    case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
+    case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
+    case PROTOCOL_BINARY_RESPONSE_E2BIG:
+    case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
+    case PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL:
+    case PROTOCOL_BINARY_RESPONSE_ERANGE:
+    case PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED:
+    case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+    case PROTOCOL_BINARY_RESPONSE_ETMPFAIL:
+    case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_ENOENT:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_EEXISTS:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_MISMATCH:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_EINVAL:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_E2BIG:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_VALUE_CANTINSERT:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_VALUE_ETOODEEP:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_DOC_NOTJSON:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_NUM_ERANGE:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_DELTA_ERANGE:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_INVALID_COMBO:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_MULTI_PATH_FAILURE:
+        return true;
+    default:
+        if (rc >= 0xc0 && rc <= 0xcc) {
+            // other subdoc?
+            return true;
+        } else {
+            return false;
+        }
+        break;
+    }
+}
+
+/**
+ * Handle an unknown memcached error
+ *
+ * @param mcresp Response which contains the unknown error
+ * @param[out] newerr more user-friendly based on error map attributes
+ *
+ * @return true if this function handled the error specially (by disconnecting)
+ * or false if normal handling should continue.
+ */
+bool Server::handle_unknown_error(const MemcachedResponse& mcresp,
+                                  lcb_error_t& newerr) {
+
+    if (!settings->errmap->isLoaded() || !settings->use_errmap) {
+        // If there's no error map, just return false
+        return false;
+    }
+
+    // Look up the error map definition for this error
+    const errmap::Error& err = settings->errmap->getError(mcresp.status());
+
+    if (!err.isValid() || err.hasAttribute(errmap::SPECIAL_HANDLING)) {
+        lcb_log(LOGARGS_T(ERR), LOGFMT "Received error not in error map or requires special handling! " PKTFMT, LOGID_T(), PKTARGS(mcresp));
+        lcbio_ctx_senderr(connctx, LCB_PROTOCOL_ERROR);
+        return true;
+    } else {
+        lcb_log(LOGARGS_T(WARN), LOGFMT "Received server error %s (0x%x) on packet: " PKTFMT, LOGID_T(), err.shortname.c_str(), err.code, PKTARGS(mcresp));
+    }
+
+    if (err.hasAttribute(errmap::FETCH_CONFIG)) {
+        instance->bootstrap(BS_REFRESH_THROTTLE);
+    }
+
+    if (err.hasAttribute(errmap::TEMPORARY)) {
+        newerr = LCB_GENERIC_TMPERR;
+    }
+
+    if (err.hasAttribute(errmap::CONSTRAINT_FAILURE)) {
+        newerr = LCB_GENERIC_CONSTRAINT_ERR;
+    }
+
+    if (err.hasAttribute(errmap::AUTH)) {
+        newerr = LCB_AUTH_ERROR;
+    }
+
+    if (err.hasAttribute(errmap::SUBDOC) && newerr == LCB_SUCCESS) {
+        newerr = LCB_GENERIC_SUBDOCERR;
+    }
+
+    if (err.hasAttribute(errmap::CONN_STATE_INVALIDATED)) {
+        if (newerr != LCB_SUCCESS) {
+            newerr = LCB_ERROR;
+        }
+        lcbio_ctx_senderr(connctx, newerr);
+        return true;
+    }
+
+    return false;
+
+}
+
 /* This function is called within a loop to process a single packet.
  *
  * If a full packet is available, it will process the packet and return
@@ -224,7 +327,14 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
         return PKT_READ_COMPLETE;
     }
 
-    if (mcresp.status() == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
+    lcb_error_t err_override = LCB_SUCCESS;
+    ReadState rdstate = PKT_READ_COMPLETE;
+
+    /* Check if the status code is one which must be handled carefully by the
+     * client */
+    if (is_fastpath_error(mcresp.status())) {
+        // Nothing here!
+    } else if (mcresp.status() == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
         /* consume the header */
         DO_ASSIGN_PAYLOAD()
         if (!handle_nmv(mcresp, request)) {
@@ -232,13 +342,19 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
         }
         DO_SWALLOW_PAYLOAD()
         goto GT_DONE;
+    } else if (handle_unknown_error(mcresp, err_override)) {
+        DO_ASSIGN_PAYLOAD()
+        mcreq_dispatch_response(this, request, &mcresp, err_override);
+        DO_SWALLOW_PAYLOAD()
+        rdstate = PKT_READ_ABORT;
+        goto GT_DONE;
     }
 
     /* Figure out if the request is 'ufwd' or not */
     if (!(request->flags & MCREQ_F_UFWD)) {
         DO_ASSIGN_PAYLOAD();
         mcresp.bufh = rdb_get_first_segment(ior);
-        mcreq_dispatch_response(this, request, &mcresp, LCB_SUCCESS);
+        mcreq_dispatch_response(this, request, &mcresp, err_override);
         DO_SWALLOW_PAYLOAD()
 
     } else {
@@ -265,7 +381,7 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
     if (is_last) {
         mcreq_packet_handled(this, request);
     }
-    return PKT_READ_COMPLETE;
+    return rdstate;
 }
 
 static void