libcouchbase 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7528bfbb566a80d2229384ddb803404ddd397fb
-  data.tar.gz: 4f88409cda5903afc7e2ee5904dc6a03707e225a
+  metadata.gz: a694a8d99cf0101482777db2e8c4f81c9a2e3575
+  data.tar.gz: 3b484eb067a3ba40c9bf9b852cac90f48616db62
 SHA512:
-  metadata.gz: 2052657011535ae443555d9724776a0a62d7fae10b589404baacd8a28d8cd70fe66a8715581eb1f19fef7d4da52807c2a77941cd95e6fb9f87b612774ee2b7fc
-  data.tar.gz: caed84a246ae8747a5e777f6f7c4dbb7da623e1b53aa4557445dcba2e0041fe2724b67977ece54bed5f0313eef1619fb77acdcb1a4267bac059295dbd79e69cc
+  metadata.gz: 3cf8f41d050d5bbb1ff2337de189c8893f36bae402c687d9543e1f996a327610e6f8d6ca7f84cc2cec0e27e8e958d3bb0e5ee05acee4101f70082a7ffaa12e83
+  data.tar.gz: bfeadf7d0eca8959258c9dccb64f03c6b5a9f4391da856d2ddcdc7aa60631421cb0f37f332809a93e69c6516b364c4b6e553d1f5a8eb76281ebe1c383a45f6d6

data/.travis.yml

@@ -3,10 +3,10 @@ rvm:
   - ruby-2.3.1
   - ruby-2.2.5
   - ruby-head
-  - rubinius-3.62
-  - rubinius
   - jruby-9.1.5.0
   - jruby-head
+  - rubinius
+# - rubinius-3.62 # blocked by https://github.com/rubinius/rubinius/issues/3706
 branches:
   only:
     - master
@@ -14,8 +14,8 @@ before_install:
   - git submodule update --init --recursive
   - gem install ffi
   - sudo apt-get install libev-dev
-  - sudo wget http://packages.couchbase.com/releases/4.5.1/couchbase-server-enterprise_4.5.1-ubuntu14.04_amd64.deb
-  - sudo dpkg -i couchbase-server-enterprise_4.5.1-ubuntu14.04_amd64.deb
+  - sudo wget https://packages.couchbase.com/releases/4.6.1/couchbase-server-enterprise_4.6.1-ubuntu14.04_amd64.deb
+  - sudo dpkg -i couchbase-server-enterprise_4.6.1-ubuntu14.04_amd64.deb
   - sleep 4
   - sudo service couchbase-server status
   - /opt/couchbase/bin/couchbase-cli cluster-init -c 127.0.0.1:8091 --cluster-username=admin --cluster-password=password --cluster-ramsize=320 --cluster-index-ramsize=256 --cluster-fts-ramsize=256 --services=data,index,query,fts

data/README.md

@@ -1,10 +1,14 @@
 # libcouchbase FFI bindings for Ruby
 
+[![Build Status](https://secure.travis-ci.org/cotag/libcouchbase.svg)](http://travis-ci.org/cotag/libcouchbase)
+
 An alternative to the official [couchbase-client](https://github.com/couchbase/couchbase-ruby-client)
 
 * This client is non-blocking where possible using Fibers, which makes it simple to write performant code in Frameworks like [Rails](http://rubyonrails.org/).
 * Client is threadsafe and reentrant
 
+This is a low level wrapper around libcouchbase. For a more friendly ActiveModel interface see [couchbase-orm](https://github.com/acaprojects/couchbase-orm)
+
 
 ## Runtime Support:
 

data/ext/libcouchbase/CMakeLists.txt

@@ -21,7 +21,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8.9)
 # These variables can be modified as needed
 
 # Couchbase mock path to download
-SET(COUCHBASE_MOCK_VERSION CouchbaseMock-1.4.3.jar)
+SET(COUCHBASE_MOCK_VERSION CouchbaseMock-1.4.7.jar)
 # Maven repository where ${COUCHBASE_MOCK_VERSION} is to be found
 SET(COUCHBASE_MOCK_DLSERVER http://packages.couchbase.com/clients/c/mock)
 project(libcouchbase)

data/ext/libcouchbase/RELEASE_NOTES.markdown

@@ -1,5 +1,47 @@
 # Release Notes
 
+## 2.7.3 (March 21 2017)
+
+* Provide the ability to send the `SELECT_BUCKET` when establishing a
+  to a server. This is a building block allowing us to use 'RBAC'/username
+  auth in the future.
+  Note that this requires the `select_bucket=true` option in the connection
+  string or equivalent, and that this feature as a whole is considered
+  experimental.
+  * Priority: Major
+  * Issues: [CCBC-758](https://issues.couchbase.com/browse/CCBC-758)
+
+* Provide an option to disable DNS-SRV lookups. Because DNS SRV lookups often
+  result in no result (i.e. `NXDOMAIN`) - which takes longer, allowing to
+  disable such lookups may speed up startup time.
+  This option is available via the connection string, using `dnssrv=off`
+  * Priority: Minor
+  * Issues: [CCBC-756](https://issues.couchbase.com/browse/CCBC-756)
+
+* Send client/user-specific identifier in `User-Agent` HTTP header.
+  The library already does this for data nodes (Memcached). Using it in HTTP
+  services allows better supportability when diagnosing issues by reading the
+  HTTP logs.
+  * Priority: Major
+  * Issues: [CCBC-755](https://issues.couchbase.com/browse/CCBC-755)
+
+* Fix bug where DNS SRV hostnames would not be used.
+  While DNS SRV lookup was working, the library would not actually attempt
+  bootstrap off those received hostnames.
+  * Priority: Major
+  * Issues: [CCBC-753](https://issues.couchbase.com/browse/CCBC-753)
+
+* Provide experimental Analytics support.
+  This allows access to the Couchbase Analytics Service, available in
+  some pre-release builds. API and syntax wise, Analytics is very similar
+  to N1QL.
+  To use the analytics service, set the `LCB_CMDN1QL_F_CBASQUERY` bit in
+  `lcb_CMDN1QL::cmdflags`, and provide the appropriate _host:port_ combination
+  in the `lcb_CMDN1QL::host` field. - Currently, analytics support is not
+  used in the cluster map/configuration.
+  * Priority: Major
+  * Issues: [CCBC-734](https://issues.couchbase.com/browse/CCBC-734)
+
 ## 2.7.2 (February 21 2017)
 
 This release consists of additional internal refactoring and some improved

data/ext/libcouchbase/cmake/Modules/GetVersionInfo.cmake

@@ -42,13 +42,13 @@ ENDIF()
 
 IF (NOT LCB_VERSION)
     SET(LCB_NOGITVERSION ON)
-    SET(LCB_VERSION "2.7.2")
+    SET(LCB_VERSION "2.7.3")
 ENDIF()
 IF (NOT LCB_VERSION_CHANGESET)
     SET(LCB_VERSION_CHANGESET "0xdeadbeef")
 ENDIF()
 IF (NOT LCB_VERSION_HEX)
-    SET(LCB_VERSION_HEX 0x020702)
+    SET(LCB_VERSION_HEX 0x020703)
 ENDIF()
 
 # Now parse the version string
@@ -63,7 +63,7 @@ IF(APPLE)
 ELSE()
     SET(LCB_SONAME_MAJOR "2")
 ENDIF()
-SET(LCB_SONAME_FULL "${LCB_SONAME_MAJOR}.0.42")
+SET(LCB_SONAME_FULL "${LCB_SONAME_MAJOR}.0.43")
 
 MESSAGE(STATUS
     "libcouchbase ${LCB_VERSION_MAJOR},${LCB_VERSION_MINOR},${LCB_VERSION_PATCH}")

data/ext/libcouchbase/cmake/source_files.cmake

@@ -57,6 +57,7 @@ SET(LCB_CORE_CXXSRC
     src/connspec.cc
     src/dns-srv.cc
     src/dump.cc
+    src/errmap.cc
     src/getconfig.cc
     src/nodeinfo.cc
     src/handler.cc

data/ext/libcouchbase/include/libcouchbase/cntl.h

@@ -924,8 +924,34 @@ typedef const char *lcb_BUCKETCRED[2];
  */
 #define LCB_CNTL_READ_CHUNKSIZE 0x42
 
+/**
+ * Enable/Disable the Error Map feature. This is disabled by default.
+ * Works only on servers which support error map
+ *
+ * Use `enable_errmap` in the connection string
+ *
+ * @volatile
+ * @cntl_arg_both{int* (as boolean)}
+ */
+#define LCB_CNTL_ENABLE_ERRMAP 0x43
+
+/**
+ * Enable/Disable sending the SELECT_BUCKET command after authentication.
+ * This is useful to test auth, and should not be set by end-users.
+ *
+ * Note that even if this feature is enabled (the default), the client will
+ * only send `SELECT_BUCKET` if the server indicates that it is supported
+ * during negotiation.
+ *
+ * Use `select_bucket` in the connection string
+ *
+ * @volatile
+ * @cntl_arg_both{int* (as boolean)}
+ */
+#define LCB_CNTL_SELECT_BUCKET 0x44
+
 /** This is not a command, but rather an indicator of the last item */
-#define LCB_CNTL__MAX                    0x43
+#define LCB_CNTL__MAX                    0x45
 /**@}*/
 
 #ifdef __cplusplus

data/ext/libcouchbase/include/libcouchbase/couchbase.h

@@ -3679,16 +3679,6 @@ lcb_histogram_read(const lcb_HISTOGRAM *hg, const void *cookie,
 LCB_INTERNAL_API
 void lcb_histogram_print(lcb_HISTOGRAM* hg, FILE* stream);
 
-struct hostlist_st;
-
-LCB_INTERNAL_API
-lcb_error_t
-lcb_dnssrv_query(const char *, struct hostlist_st*);
-
-LCB_INTERNAL_API
-struct hostlist_st*
-lcb_dnssrv_getbslist(const char *, int, lcb_error_t*);
-
 /* Post-include some other headers */
 #ifdef __cplusplus
 }

data/ext/libcouchbase/include/libcouchbase/error.h

@@ -502,7 +502,14 @@ typedef enum {
     X(LCB_UNKNOWN_SDCMD, 0x4D, LCB_ERRTYPE_INPUT, "Unknown subdocument command") \
     X(LCB_ENO_COMMANDS, 0x4E, LCB_ERRTYPE_INPUT, "No commands specified") \
     X(LCB_QUERY_ERROR, 0x4F, LCB_ERRTYPE_SRVGEN, \
-        "Query execution failed. Inspect raw response object for information")
+        "Query execution failed. Inspect raw response object for information") \
+    \
+    X(LCB_GENERIC_TMPERR, 0x50, LCB_ERRTYPE_TRANSIENT|LCB_ERRTYPE_SRVGEN, \
+        "Generic temporary error received from server") \
+    X(LCB_GENERIC_SUBDOCERR, 0x51, LCB_ERRTYPE_SUBDOC|LCB_ERRTYPE_SRVGEN, \
+        "Generic subdocument error received from server") \
+    X(LCB_GENERIC_CONSTRAINT_ERR, 0x52, LCB_ERRTYPE_INPUT|LCB_ERRTYPE_SRVGEN, \
+        "Generic constraint error received from server")
 
 /** Error codes returned by the library. */
 typedef enum {

data/ext/libcouchbase/include/memcached/protocol_binary.h

@@ -224,6 +224,8 @@ extern "C"
 
         PROTOCOL_BINARY_CMD_GET_REPLICA = 0x83,
 
+        PROTOCOL_BINARY_CMD_SELECT_BUCKET = 0x89,
+
         PROTOCOL_BINARY_CMD_OBSERVE_SEQNO = 0x91,
         PROTOCOL_BINARY_CMD_OBSERVE = 0x92,
 
@@ -264,6 +266,9 @@ extern "C"
         /* Subdoc additions for Spock: */
         PROTOCOL_BINARY_CMD_SUBDOC_GET_COUNT = 0xd2,
 
+        /* get error code mappings */
+        PROTOCOL_BINARY_CMD_GET_ERROR_MAP = 0xfe,
+
         /* Reserved for being able to signal invalid opcode */
         PROTOCOL_BINARY_CMD_INVALID = 0xff
     } protocol_binary_command;
@@ -665,11 +670,13 @@ extern "C"
         PROTOCOL_BINARY_FEATURE_TCPNODELAY = 0x03,
         PROTOCOL_BINARY_FEATURE_MUTATION_SEQNO = 0x04,
         PROTOCOL_BINARY_FEATURE_TCPDELAY = 0x05,
-        PROTOCOL_BINARY_FEATURE_XATTR = 0x06
+        PROTOCOL_BINARY_FEATURE_XATTR = 0x06,
+        PROTOCOL_BINARY_FEATURE_XERROR = 0x07,
+        PROTOCOL_BINARY_FEATURE_SELECT_BUCKET = 0x08
     } protocol_binary_hello_features;
 
     #define MEMCACHED_FIRST_HELLO_FEATURE 0x01
-    #define MEMCACHED_TOTAL_HELLO_FEATURES 0x05
+    #define MEMCACHED_TOTAL_HELLO_FEATURES 10
 
 #define protocol_feature_2_text(a) \
     (a == PROTOCOL_BINARY_FEATURE_DATATYPE) ? "Datatype" : \
@@ -677,7 +684,9 @@ extern "C"
     (a == PROTOCOL_BINARY_FEATURE_TCPNODELAY) ? "TCP NODELAY" : \
     (a == PROTOCOL_BINARY_FEATURE_MUTATION_SEQNO) ? "Mutation seqno" : \
     (a == PROTOCOL_BINARY_FEATURE_TCPDELAY) ? "TCP DELAY" : \
-    (a == PROTOCOL_BINARY_FEATURE_XATTR) ? "XATTR" : "Unknown"
+    (a == PROTOCOL_BINARY_FEATURE_XATTR) ? "XATTR" : \
+    (a == PROTOCOL_BINARY_FEATURE_XERROR) ? "Error Map": \
+    (a == PROTOCOL_BINARY_FEATURE_SELECT_BUCKET) ? "Select Bucket": "Unknown"
 
     /**
      * The HELLO command is used by the client and the server to agree

data/ext/libcouchbase/src/auth.cc

@@ -90,10 +90,6 @@ Authenticator::init(const std::string& username_, const std::string& bucket,
     m_username = (!username_.empty()) ? username_ : bucket;
     m_password = passwd;
 
-    if (conntype == LCB_TYPE_BUCKET && m_username != bucket) {
-        return LCB_INVALID_USERNAME;
-    }
-
     m_buckets[bucket] = m_password;
     return LCB_SUCCESS;
 }

data/ext/libcouchbase/src/cntl.cc

@@ -183,6 +183,12 @@ HANDLER(kv_hg_handler) {
 HANDLER(read_chunk_size_handler) {
     RETURN_GET_SET(lcb_U32, LCBT_SETTING(instance, read_chunk_size));
 }
+HANDLER(enable_errmap_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, use_errmap));
+}
+HANDLER(select_bucket_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, select_bucket));
+}
 
 HANDLER(get_kvb) {
     lcb_cntl_vbinfo_st *vbi = reinterpret_cast<lcb_cntl_vbinfo_st*>(arg);
@@ -586,7 +592,9 @@ static ctl_handler handlers[] = {
     client_string_handler, /* LCB_CNTL_CLIENT_STRING */
     bucket_auth_handler, /* LCB_CNTL_BUCKET_CRED */
     timeout_common, /* LCB_CNTL_RETRY_NMV_DELAY */
-    read_chunk_size_handler /*LCB_CNTL_READ_CHUNKSIZE */
+    read_chunk_size_handler, /*LCB_CNTL_READ_CHUNKSIZE */
+    enable_errmap_handler, /* LCB_CNTL_ENABLE_ERRMAP */
+    select_bucket_handler /* LCB_CNTL_SELECT_BUCKET */
 };
 
 /* Union used for conversion to/from string functions */
@@ -738,6 +746,8 @@ static cntl_OPCODESTRS stropcode_map[] = {
         {"retry_nmv_delay", LCB_CNTL_RETRY_NMV_INTERVAL, convert_timeout},
         {"bucket_cred", LCB_CNTL_BUCKET_CRED, NULL},
         {"read_chunk_size", LCB_CNTL_READ_CHUNKSIZE, convert_u32},
+        {"enable_errmap", LCB_CNTL_ENABLE_ERRMAP, convert_intbool},
+        {"select_bucket", LCB_CNTL_SELECT_BUCKET, convert_intbool},
         {NULL, -1}
 };
 

data/ext/libcouchbase/src/connspec.cc

@@ -244,6 +244,24 @@ Connspec::parse_options(
             if (sscanf(value, "%d", &m_loglevel) != 1) {
                 SET_ERROR("console_log_level must be a numeric value");
             }
+        } else if (!strcmp(key, "dnssrv")) {
+            if ((m_flags & F_DNSSRV_EXPLICIT) == F_DNSSRV_EXPLICIT) {
+                SET_ERROR("Cannot use dnssrv scheme with dnssrv option");
+            }
+            int btmp = 0;
+            if (!strcmp(value, "on") || !strcmp(value, "true")) {
+                btmp = 1;
+            } else if (!strcmp(value, "off") || !strcmp(value, "false")) {
+                btmp = 0;
+            } else if (sscanf(value, "%d", &btmp) != 1) {
+                printf("Coldn't parse value!\n");
+                SET_ERROR("dnssrv must have numeric (boolean) value");
+            }
+            if (btmp) {
+                m_flags |= F_DNSSRV;
+            } else {
+                m_flags &= ~F_DNSSRV_EXPLICIT;
+            }
         } else {
             m_ctlopts.push_back(std::make_pair(key, value));
         }

data/ext/libcouchbase/src/connspec.h

@@ -20,9 +20,11 @@
 
 #include <libcouchbase/couchbase.h>
 #include "config.h"
+
 #include <string>
 #include <vector>
 #include <set>
+#include "hostlist.h"
 
 #ifdef _MSC_VER
 /*
@@ -126,6 +128,14 @@ private:
 #define LCB_SPECSCHEME_MCCOMPAT "memcached://"
 #define LCB_SPECSCHEME_SRV "couchbase+dnssrv://"
 #define LCB_SPECSCHEME_SRV_SSL "couchbases+dnssrv://"
+
+// Standalone functionality:
+lcb_error_t
+dnssrv_query(const char *name, Hostlist& hostlist);
+
+Hostlist *
+dnssrv_getbslist(const char *addr, bool is_ssl, lcb_error_t& errout);
+
 } // namespace
 
 #endif

data/ext/libcouchbase/src/dns-srv.cc

@@ -2,6 +2,8 @@
 
 #include "config.h"
 #include "hostlist.h"
+#include "connspec.h"
+#include "hostlist.h"
 
 #ifndef _WIN32
 #include <string>
@@ -20,9 +22,8 @@
 #include <netinet/in.h>
 #include <resolv.h>
 
-LCB_INTERNAL_API
 lcb_error_t
-lcb_dnssrv_query(const char *name, hostlist_t hostlist)
+lcb::dnssrv_query(const char* name, lcb::Hostlist& hostlist)
 {
     ns_msg msg;
 
@@ -82,7 +83,7 @@ lcb_dnssrv_query(const char *name, hostlist_t hostlist)
         ns_name_uncompress(
             ns_msg_base(msg), ns_msg_end(msg),
             rdata, &dname[0], NS_MAXDNAME);
-        hostlist->add(&dname[0], srv_port);
+        hostlist.add(&dname[0], srv_port);
     }
     return LCB_SUCCESS;
 }
@@ -92,9 +93,8 @@ lcb_dnssrv_query(const char *name, hostlist_t hostlist)
 #include <windns.h>
 #define CAN_SRV_LOOKUP
 /* Implement via DnsQuery() */
-LCB_INTERNAL_API
 lcb_error_t
-lcb_dnssrv_query(const char *addr, hostlist_t hs)
+lcb::dnssrv_query(const char *addr, Hostlist& hs)
 {
     DNS_STATUS status;
     PDNS_RECORDA root, cur;
@@ -108,7 +108,7 @@ lcb_dnssrv_query(const char *addr, hostlist_t hs)
     for (cur = root; cur; cur = cur->pNext) {
         // Use the ASCII version of the DNS lookup structure
         const DNS_SRV_DATAA *srv = &cur->Data.SRV;
-        hostlist_add_stringz(hs, srv->pNameTarget, srv->wPort);
+        hs.add(srv->pNameTarget, srv->wPort);
     }
     DnsRecordListFree(root, DnsFreeRecordList);
     return LCB_SUCCESS;
@@ -118,7 +118,7 @@ lcb_dnssrv_query(const char *addr, hostlist_t hs)
 
 
 #ifndef CAN_SRV_LOOKUP
-LCB_INTERNAL_API lcb_error_t lcb_dnssrv_query(const char *, hostlist_t) {
+lcb_error_t lcb::dnssrv_query(const char *, Hostlist&) {
     return LCB_CLIENT_FEATURE_UNAVAILABLE;
 }
 #endif
@@ -126,18 +126,17 @@ LCB_INTERNAL_API lcb_error_t lcb_dnssrv_query(const char *, hostlist_t) {
 #define SVCNAME_PLAIN "_couchbase._tcp."
 #define SVCNAME_SSL "_couchbases._tcp."
 
-LCB_INTERNAL_API
-hostlist_st*
-lcb_dnssrv_getbslist(const char *addr, int is_ssl, lcb_error_t *errp) {
+lcb::Hostlist*
+lcb::dnssrv_getbslist(const char *addr, bool is_ssl, lcb_error_t& errp) {
     std::string ss;
-    lcb::Hostlist *ret = new lcb::Hostlist();
+    Hostlist *ret = new Hostlist();
     ss.append(is_ssl ? SVCNAME_SSL : SVCNAME_PLAIN);
     ss.append(addr);
 
-    *errp = lcb_dnssrv_query(ss.c_str(), ret);
-    if (*errp != LCB_SUCCESS) {
+    errp = dnssrv_query(ss.c_str(), *ret);
+    if (errp != LCB_SUCCESS) {
         delete ret;
         ret = NULL;
     }
-    return static_cast<hostlist_st*>(ret);
+    return ret;
 }

data/ext/libcouchbase/src/errmap.cc

@@ -0,0 +1,107 @@
+#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;
+}
+
+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);
+        }
+        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; }