couchbase 3.0.0 → 3.0.1

data/ext/couchbase/cbcrypto/cbcrypto.cc

@@ -88,7 +88,7 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
         throw std::runtime_error("digest: BCryptHashData return: " + std::to_string(status));
     }
 
-    status = BCryptFinishHash(hHash, reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())), cbHash, 0);
+    status = BCryptFinishHash(hHash, reinterpret_cast<uint8_t*>(ret.data()), cbHash, 0);
 
     // Release resources
     BCryptCloseAlgorithmProvider(hAlg, 0);
@@ -256,7 +256,7 @@ AES_256_cbc(bool encrypt, std::string_view key, std::string_view iv, std::string
                                nullptr,
                                (PBYTE)civ.data(),
                                ULONG(civ.size()),
-                               reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                               reinterpret_cast<uint8_t*>(ret.data()),
                                ULONG(ret.size()),
                                &cbData,
                                BCRYPT_BLOCK_PADDING);
@@ -267,7 +267,7 @@ AES_256_cbc(bool encrypt, std::string_view key, std::string_view iv, std::string
                                nullptr,
                                (PBYTE)civ.data(),
                                ULONG(civ.size()),
-                               reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                               reinterpret_cast<uint8_t*>(ret.data()),
                                ULONG(ret.size()),
                                &cbData,
                                BCRYPT_BLOCK_PADDING);
@@ -309,7 +309,7 @@ HMAC_SHA1(std::string_view key, std::string_view data)
 {
     std::string ret;
     ret.resize(couchbase::crypto::SHA1_DIGEST_SIZE);
-    CCHmac(kCCHmacAlgSHA1, key.data(), key.size(), data.data(), data.size(), reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())));
+    CCHmac(kCCHmacAlgSHA1, key.data(), key.size(), data.data(), data.size(), reinterpret_cast<uint8_t*>(ret.data()));
     return ret;
 }
 
@@ -318,7 +318,7 @@ HMAC_SHA256(std::string_view key, std::string_view data)
 {
     std::string ret;
     ret.resize(couchbase::crypto::SHA256_DIGEST_SIZE);
-    CCHmac(kCCHmacAlgSHA256, key.data(), key.size(), data.data(), data.size(), reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())));
+    CCHmac(kCCHmacAlgSHA256, key.data(), key.size(), data.data(), data.size(), reinterpret_cast<uint8_t*>(ret.data()));
     return ret;
 }
 
@@ -327,7 +327,7 @@ HMAC_SHA512(std::string_view key, std::string_view data)
 {
     std::string ret;
     ret.resize(couchbase::crypto::SHA512_DIGEST_SIZE);
-    CCHmac(kCCHmacAlgSHA512, key.data(), key.size(), data.data(), data.size(), reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())));
+    CCHmac(kCCHmacAlgSHA512, key.data(), key.size(), data.data(), data.size(), reinterpret_cast<uint8_t*>(ret.data()));
     return ret;
 }
 
@@ -343,7 +343,7 @@ PBKDF2_HMAC_SHA1(const std::string& pass, std::string_view salt, unsigned int it
                                     salt.size(),
                                     kCCPRFHmacAlgSHA1,
                                     iterationCount,
-                                    reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                                    reinterpret_cast<uint8_t*>(ret.data()),
                                     ret.size());
 
     if (err != 0) {
@@ -364,7 +364,7 @@ PBKDF2_HMAC_SHA256(const std::string& pass, std::string_view salt, unsigned int
                                     salt.size(),
                                     kCCPRFHmacAlgSHA256,
                                     iterationCount,
-                                    reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                                    reinterpret_cast<uint8_t*>(ret.data()),
                                     ret.size());
     if (err != 0) {
         throw std::runtime_error("couchbase::crypto::PBKDF2_HMAC(SHA256): CCKeyDerivationPBKDF "
@@ -386,7 +386,7 @@ PBKDF2_HMAC_SHA512(const std::string& pass, std::string_view salt, unsigned int
                                     salt.size(),
                                     kCCPRFHmacAlgSHA512,
                                     iterationCount,
-                                    reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                                    reinterpret_cast<uint8_t*>(ret.data()),
                                     ret.size());
     if (err != 0) {
         throw std::runtime_error("couchbase::crypto::PBKDF2_HMAC(SHA512): CCKeyDerivationPBKDF "
@@ -401,7 +401,7 @@ digest_sha1(std::string_view data)
 {
     std::string ret;
     ret.resize(couchbase::crypto::SHA1_DIGEST_SIZE);
-    CC_SHA1(data.data(), data.size(), reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())));
+    CC_SHA1(data.data(), static_cast<CC_LONG>(data.size()), reinterpret_cast<uint8_t*>(ret.data()));
     return ret;
 }
 
@@ -410,7 +410,7 @@ digest_sha256(std::string_view data)
 {
     std::string ret;
     ret.resize(couchbase::crypto::SHA256_DIGEST_SIZE);
-    CC_SHA256(data.data(), data.size(), reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())));
+    CC_SHA256(data.data(), static_cast<CC_LONG>(data.size()), reinterpret_cast<uint8_t*>(ret.data()));
     return ret;
 }
 
@@ -419,7 +419,7 @@ digest_sha512(std::string_view data)
 {
     std::string ret;
     ret.resize(couchbase::crypto::SHA512_DIGEST_SIZE);
-    CC_SHA512(data.data(), data.size(), reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())));
+    CC_SHA512(data.data(), static_cast<CC_LONG>(data.size()), reinterpret_cast<uint8_t*>(ret.data()));
     return ret;
 }
 
@@ -470,7 +470,7 @@ encrypt(const couchbase::crypto::Cipher cipher, std::string_view key, std::strin
                           iv.data(),
                           data.data(),
                           data.size(),
-                          reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                          reinterpret_cast<uint8_t*>(ret.data()),
                           ret.size(),
                           &outputsize);
 
@@ -499,7 +499,7 @@ decrypt(const couchbase::crypto::Cipher cipher, std::string_view key, std::strin
                           iv.data(),
                           data.data(),
                           data.size(),
-                          reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data())),
+                          reinterpret_cast<uint8_t*>(ret.data()),
                           ret.size(),
                           &outputsize);
 
@@ -718,7 +718,7 @@ encrypt(const couchbase::crypto::Cipher cipher, std::string_view key, std::strin
     }
 
     std::string ret;
-    ret.resize(data.size() + static_cast<std::size_t>(EVP_CIPHER_block_size(cip)));
+    ret.resize(data.size() + static_cast<std::string_view::size_type>(EVP_CIPHER_block_size(cip)));
     int len1 = int(ret.size());
 
     if (EVP_EncryptUpdate(

data/ext/couchbase/cluster.hxx

@@ -32,6 +32,8 @@
 #include <operations.hxx>
 #include <operations/document_query.hxx>
 
+#include <diagnostics.hxx>
+
 namespace couchbase
 {
 class cluster
@@ -69,6 +71,7 @@ class cluster
             for (auto& bucket : buckets_) {
                 bucket.second->close();
             }
+            session_manager_->close();
             handler();
             work_.reset();
         }));
@@ -77,6 +80,10 @@ class cluster
     template<typename Handler>
     void open_bucket(const std::string& bucket_name, Handler&& handler)
     {
+        auto ptr = buckets_.find(bucket_name);
+        if (ptr != buckets_.end()) {
+            return handler({});
+        }
         std::vector<protocol::hello_feature> known_features;
         if (session_ && session_->has_config()) {
             known_features = session_->supported_features();
@@ -115,6 +122,28 @@ class cluster
         });
     }
 
+    template<typename Handler>
+    void diagnostics(std::optional<std::string> report_id, Handler&& handler)
+    {
+        if (!report_id) {
+            report_id = std::make_optional(uuid::to_string(uuid::random()));
+        }
+        asio::post(asio::bind_executor(ctx_, [this, report_id, handler = std::forward<Handler>(handler)]() mutable {
+            diag::diagnostics_result res{
+                report_id.value(),
+                fmt::format("ruby/{}.{}.{}/{}", BACKEND_VERSION_MAJOR, BACKEND_VERSION_MINOR, BACKEND_VERSION_PATCH, BACKEND_GIT_REVISION)
+            };
+            if (session_) {
+                res.services[service_type::kv].emplace_back(session_->diag_info());
+            }
+            for (const auto& bucket : buckets_) {
+                bucket.second->export_diag_info(res);
+            }
+            session_manager_->export_diag_info(res);
+            handler(std::move(res));
+        }));
+    }
+
   private:
     template<typename Handler>
     void do_dns_srv(Handler&& handler)
@@ -204,10 +233,13 @@ class cluster
                     origin::node_list nodes;
                     nodes.reserve(config.nodes.size());
                     for (const auto& address : config.nodes) {
+                        auto port = address.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0);
+                        if (port == 0) {
+                            continue;
+                        }
                         origin::node_entry node;
                         node.first = address.hostname_for(origin_.options().network);
-                        node.second =
-                          std::to_string(address.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0));
+                        node.second = std::to_string(port);
                         nodes.emplace_back(node);
                     }
                     origin_.set_nodes(nodes);

data/ext/couchbase/cluster_options.hxx

@@ -39,6 +39,7 @@ struct cluster_options {
     bool enable_tcp_keep_alive{ true };
     bool force_ipv4{ false };
     bool enable_dns_srv{ true };
+    bool show_queries{ false };
     std::string network{ "auto" };
 
     std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;

data/ext/couchbase/configuration.hxx

@@ -25,10 +25,17 @@
 #include <platform/uuid.h>
 
 #include <service_type.hxx>
+#include <capabilities.hxx>
 
 namespace couchbase
 {
 struct configuration {
+    enum class node_locator_type {
+        unknown,
+        vbucket,
+        ketama,
+    };
+
     struct port_map {
         std::optional<std::uint16_t> key_value{};
         std::optional<std::uint16_t> management{};
@@ -96,7 +103,7 @@ struct configuration {
             return default_value;
         }
 
-        [[nodiscard]] const std::string & hostname_for(const std::string& network) const
+        [[nodiscard]] const std::string& hostname_for(const std::string& network) const
         {
             if (network == "default") {
                 return hostname;
@@ -182,13 +189,27 @@ struct configuration {
 
     using vbucket_map = typename std::vector<std::vector<std::int16_t>>;
 
-    std::uint64_t rev{};
+    std::optional<std::uint64_t> rev{};
     couchbase::uuid::uuid_t id{};
     std::optional<std::uint32_t> num_replicas{};
     std::vector<node> nodes{};
     std::optional<std::string> uuid{};
     std::optional<std::string> bucket{};
     std::optional<vbucket_map> vbmap{};
+    std::optional<std::uint64_t> collections_manifest_uid{};
+    std::set<bucket_capability> bucket_capabilities{};
+    std::set<cluster_capability> cluster_capabilities{};
+    node_locator_type node_locator{ node_locator_type::unknown };
+
+    [[nodiscard]] std::string rev_str() const
+    {
+        return rev ? fmt::format("{}", *rev) : "(none)";
+    }
+
+    [[nodiscard]] bool supports_enhanced_prepared_statements() const
+    {
+        return cluster_capabilities.find(cluster_capability::n1ql_enhanced_prepared_statements) != cluster_capabilities.end();
+    }
 
     size_t index_for_endpoint(const asio::ip::tcp::endpoint& endpoint)
     {
@@ -353,15 +374,17 @@ struct fmt::formatter<couchbase::configuration> : formatter<std::string> {
     auto format(const couchbase::configuration& config, FormatContext& ctx)
     {
         format_to(ctx.out(),
-                  R"(#<config:{} rev={}{}{}{}{}, nodes({})=[{}]>)",
+                  R"(#<config:{} rev={}{}{}{}{}, nodes({})=[{}], bucket_caps=[{}], cluster_caps=[{}]>)",
                   couchbase::uuid::to_string(config.id),
-                  config.rev,
+                  config.rev_str(),
                   config.uuid ? fmt::format(", uuid={}", *config.uuid) : "",
                   config.bucket ? fmt::format(", bucket={}", *config.bucket) : "",
                   config.num_replicas ? fmt::format(", replicas={}", *config.num_replicas) : "",
                   config.vbmap.has_value() ? fmt::format(", partitions={}", config.vbmap->size()) : "",
                   config.nodes.size(),
-                  fmt::join(config.nodes, ", "));
+                  fmt::join(config.nodes, ", "),
+                  fmt::join(config.bucket_capabilities, ", "),
+                  fmt::join(config.cluster_capabilities, ", "));
         return formatter<std::string>::format("", ctx);
     }
 };
@@ -375,58 +398,152 @@ struct traits<couchbase::configuration> {
     {
         couchbase::configuration result;
         result.id = couchbase::uuid::random();
-        result.rev = v.at("rev").template as<std::uint64_t>();
-        size_t index = 0;
-        for (const auto& j : v.at("nodesExt").get_array()) {
-            couchbase::configuration::node n;
-            n.index = index++;
-            const auto& o = j.get_object();
-            const auto& this_node = o.find("thisNode");
-            if (this_node != o.end() && this_node->second.get_boolean()) {
-                n.this_node = true;
+        result.rev = v.template optional<std::uint64_t>("rev");
+        auto* node_locator = v.find("nodeLocator");
+        if (node_locator != nullptr && node_locator->is_string()) {
+            if (node_locator->get_string() == "ketama") {
+                result.node_locator = couchbase::configuration::node_locator_type::ketama;
+            } else {
+                result.node_locator = couchbase::configuration::node_locator_type::vbucket;
             }
-            const auto& hostname = o.find("hostname");
-            if (hostname != o.end()) {
-                n.hostname = hostname->second.get_string();
+        }
+        auto* nodes_ext = v.find("nodesExt");
+        if (nodes_ext != nullptr) {
+            size_t index = 0;
+            for (const auto& j : nodes_ext->get_array()) {
+                couchbase::configuration::node n;
+                n.index = index++;
+                const auto& o = j.get_object();
+                const auto& this_node = o.find("thisNode");
+                if (this_node != o.end() && this_node->second.get_boolean()) {
+                    n.this_node = true;
+                }
+                const auto& hostname = o.find("hostname");
+                if (hostname != o.end()) {
+                    n.hostname = hostname->second.get_string();
+                    n.hostname = n.hostname.substr(0, n.hostname.rfind(":"));
+                }
+                const auto& s = o.at("services");
+                n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
+                n.services_plain.management = s.template optional<std::uint16_t>("mgmt");
+                n.services_plain.search = s.template optional<std::uint16_t>("fts");
+                n.services_plain.analytics = s.template optional<std::uint16_t>("cbas");
+                n.services_plain.query = s.template optional<std::uint16_t>("n1ql");
+                n.services_plain.views = s.template optional<std::uint16_t>("capi");
+                n.services_tls.key_value = s.template optional<std::uint16_t>("kvSSL");
+                n.services_tls.management = s.template optional<std::uint16_t>("mgmtSSL");
+                n.services_tls.search = s.template optional<std::uint16_t>("ftsSSL");
+                n.services_tls.analytics = s.template optional<std::uint16_t>("cbasSSL");
+                n.services_tls.query = s.template optional<std::uint16_t>("n1qlSSL");
+                n.services_tls.views = s.template optional<std::uint16_t>("capiSSL");
+                {
+                    const auto& alt = o.find("alternateAddresses");
+                    if (alt != o.end()) {
+                        for (const auto& entry : alt->second.get_object()) {
+                            couchbase::configuration::alternate_address addr;
+                            addr.name = entry.first;
+                            addr.hostname = entry.second.at("hostname").get_string();
+                            const auto& ports = entry.second.find("ports");
+                            addr.services_plain.key_value = ports->template optional<std::uint16_t>("kv");
+                            addr.services_plain.management = ports->template optional<std::uint16_t>("mgmt");
+                            addr.services_plain.search = ports->template optional<std::uint16_t>("fts");
+                            addr.services_plain.analytics = ports->template optional<std::uint16_t>("cbas");
+                            addr.services_plain.query = ports->template optional<std::uint16_t>("n1ql");
+                            addr.services_plain.views = ports->template optional<std::uint16_t>("capi");
+                            addr.services_tls.key_value = ports->template optional<std::uint16_t>("kvSSL");
+                            addr.services_tls.management = ports->template optional<std::uint16_t>("mgmtSSL");
+                            addr.services_tls.search = ports->template optional<std::uint16_t>("ftsSSL");
+                            addr.services_tls.analytics = ports->template optional<std::uint16_t>("cbasSSL");
+                            addr.services_tls.query = ports->template optional<std::uint16_t>("n1qlSSL");
+                            addr.services_tls.views = ports->template optional<std::uint16_t>("capiSSL");
+                            n.alt.emplace(entry.first, addr);
+                        }
+                    }
+                }
+                result.nodes.emplace_back(n);
             }
-            const auto& s = o.at("services");
-            n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
-            n.services_plain.management = s.template optional<std::uint16_t>("mgmt");
-            n.services_plain.search = s.template optional<std::uint16_t>("fts");
-            n.services_plain.analytics = s.template optional<std::uint16_t>("cbas");
-            n.services_plain.query = s.template optional<std::uint16_t>("n1ql");
-            n.services_plain.views = s.template optional<std::uint16_t>("capi");
-            n.services_tls.key_value = s.template optional<std::uint16_t>("kvSSL");
-            n.services_tls.management = s.template optional<std::uint16_t>("mgmtSSL");
-            n.services_tls.search = s.template optional<std::uint16_t>("ftsSSL");
-            n.services_tls.analytics = s.template optional<std::uint16_t>("cbasSSL");
-            n.services_tls.query = s.template optional<std::uint16_t>("n1qlSSL");
-            n.services_tls.views = s.template optional<std::uint16_t>("capiSSL");
-            {
-                const auto& alt = o.find("alternateAddresses");
-                if (alt != o.end()) {
-                    for (const auto& entry : alt->second.get_object()) {
-                        couchbase::configuration::alternate_address addr;
-                        addr.name = entry.first;
-                        addr.hostname = entry.second.at("hostname").get_string();
-                        const auto& ports = entry.second.find("ports");
-                        addr.services_plain.key_value = ports->template optional<std::uint16_t>("kv");
-                        addr.services_plain.management = ports->template optional<std::uint16_t>("mgmt");
-                        addr.services_plain.search = ports->template optional<std::uint16_t>("fts");
-                        addr.services_plain.analytics = ports->template optional<std::uint16_t>("cbas");
-                        addr.services_plain.query = ports->template optional<std::uint16_t>("n1ql");
-                        addr.services_plain.views = ports->template optional<std::uint16_t>("capi");
-                        addr.services_tls.key_value = ports->template optional<std::uint16_t>("kvSSL");
-                        addr.services_tls.management = ports->template optional<std::uint16_t>("mgmtSSL");
-                        addr.services_tls.search = ports->template optional<std::uint16_t>("ftsSSL");
-                        addr.services_tls.analytics = ports->template optional<std::uint16_t>("cbasSSL");
-                        addr.services_tls.query = ports->template optional<std::uint16_t>("n1qlSSL");
-                        addr.services_tls.views = ports->template optional<std::uint16_t>("capiSSL");
-                        n.alt.emplace(entry.first, addr);
+        } else {
+            if (result.node_locator == couchbase::configuration::node_locator_type::vbucket) {
+                const auto* m = v.find("vBucketServerMap");
+                const auto& nodes = v.at("nodes").get_array();
+                if (m != nullptr) {
+                    const auto* s = m->find("serverList");
+                    size_t index = 0;
+                    if (s != nullptr && s->is_array()) {
+                        for (const auto& j : s->get_array()) {
+                            couchbase::configuration::node n;
+                            n.index = index++;
+                            const auto& address = j.get_string();
+                            n.hostname = address.substr(0, address.rfind(':'));
+                            n.services_plain.key_value = std::stoul(address.substr(address.rfind(':') + 1));
+                            if (n.index >= nodes.size()) {
+                                continue;
+                            }
+                            const auto& np = nodes[n.index];
+                            if (np.is_object()) {
+                                const auto& o = np.get_object();
+                                const auto& this_node = o.find("thisNode");
+                                if (this_node != o.end() && this_node->second.get_boolean()) {
+                                    n.this_node = true;
+                                }
+                                const auto& p = o.at("ports");
+                                std::optional<std::int64_t> https_views = p.template optional<std::int64_t>("httpsCAPI");
+                                if (https_views && https_views.value() > 0 &&
+                                    https_views.value() < std::numeric_limits<std::uint16_t>::max()) {
+                                    n.services_tls.views = static_cast<std::uint16_t>(https_views.value());
+                                }
+                                auto https_mgmt = p.template optional<std::int64_t>("httpsMgmt");
+                                if (https_mgmt && https_mgmt.value() > 0 &&
+                                    https_mgmt.value() < std::numeric_limits<std::uint16_t>::max()) {
+                                    n.services_tls.management = static_cast<std::uint16_t>(https_mgmt.value());
+                                }
+                                const auto& h = o.at("hostname").get_string();
+                                n.services_plain.management = std::stoul(h.substr(h.rfind(':') + 1));
+                                std::string capi = o.at("couchApiBase").get_string();
+                                auto slash = capi.rfind('/');
+                                auto colon = capi.rfind(':', slash);
+                                n.services_plain.views = std::stoul(capi.substr(colon + 1, slash));
+                            }
+                            result.nodes.emplace_back(n);
+                        }
+                    }
+                }
+            } else {
+                size_t index = 0;
+                for (const auto& node : v.at("nodes").get_array()) {
+                    couchbase::configuration::node n;
+                    n.index = index++;
+                    const auto& o = node.get_object();
+                    const auto& this_node = o.find("thisNode");
+                    if (this_node != o.end() && this_node->second.get_boolean()) {
+                        n.this_node = true;
                     }
+                    const auto& p = o.at("ports");
+                    std::optional<std::int64_t> direct = p.template optional<std::int64_t>("direct");
+                    if (direct && direct.value() > 0 && direct.value() < std::numeric_limits<std::uint16_t>::max()) {
+                        n.services_plain.key_value = static_cast<std::uint16_t>(direct.value());
+                    }
+                    std::optional<std::int64_t> https_views = p.template optional<std::int64_t>("httpsCAPI");
+                    if (https_views && https_views.value() > 0 && https_views.value() < std::numeric_limits<std::uint16_t>::max()) {
+                        n.services_tls.views = static_cast<std::uint16_t>(https_views.value());
+                    }
+                    auto https_mgmt = p.template optional<std::int64_t>("httpsMgmt");
+                    if (https_mgmt && https_mgmt.value() > 0 && https_mgmt.value() < std::numeric_limits<std::uint16_t>::max()) {
+                        n.services_tls.management = static_cast<std::uint16_t>(https_mgmt.value());
+                    }
+                    const auto& h = o.at("hostname").get_string();
+                    auto colon = h.rfind(':');
+                    n.hostname = h.substr(0, colon);
+                    n.services_plain.management = std::stoul(h.substr(colon + 1));
+
+                    std::string capi = o.at("couchApiBase").get_string();
+                    auto slash = capi.rfind('/');
+                    colon = capi.rfind(':', slash);
+                    n.services_plain.views = std::stoul(capi.substr(colon + 1, slash));
+
+                    result.nodes.emplace_back(n);
                 }
             }
-            result.nodes.emplace_back(n);
         }
         {
             const auto m = v.find("uuid");
@@ -434,6 +551,12 @@ struct traits<couchbase::configuration> {
                 result.uuid = m->get_string();
             }
         }
+        {
+            const auto m = v.find("collectionsManifestUid");
+            if (m != nullptr) {
+                result.collections_manifest_uid = std::stoull(m->get_string(), 0, 16);
+            }
+        }
         {
             const auto m = v.find("name");
             if (m != nullptr) {
@@ -468,6 +591,59 @@ struct traits<couchbase::configuration> {
                 }
             }
         }
+        {
+            const auto m = v.find("bucketCapabilities");
+            if (m != nullptr && m->is_array()) {
+                for (const auto& entry : m->get_array()) {
+                    const auto& name = entry.get_string();
+                    if (name == "couchapi") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::couchapi);
+                    } else if (name == "collections") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::collections);
+                    } else if (name == "durableWrite") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::durable_write);
+                    } else if (name == "tombstonedUserXAttrs") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::tombstoned_user_xattrs);
+                    } else if (name == "dcp") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::dcp);
+                    } else if (name == "cbhello") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::cbhello);
+                    } else if (name == "touch") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::touch);
+                    } else if (name == "cccp") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::cccp);
+                    } else if (name == "xdcrCheckpointing") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::xdcr_checkpointing);
+                    } else if (name == "nodesExt") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::nodes_ext);
+                    } else if (name == "xattr") {
+                        result.bucket_capabilities.insert(couchbase::bucket_capability::xattr);
+                    }
+                }
+            }
+        }
+        {
+            const auto m = v.find("clusterCapabilities");
+            if (m != nullptr && m->is_object()) {
+                const auto nc = m->find("n1ql");
+                if (nc != nullptr && nc->is_array()) {
+                    for (const auto& entry : nc->get_array()) {
+                        const auto& name = entry.get_string();
+                        if (name == "costBasedOptimizer") {
+                            result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_cost_based_optimizer);
+                        } else if (name == "indexAdvisor") {
+                            result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_index_advisor);
+                        } else if (name == "javaScriptFunctions") {
+                            result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_javascript_functions);
+                        } else if (name == "inlineFunctions") {
+                            result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_inline_functions);
+                        } else if (name == "enhancedPreparedStatements") {
+                            result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_enhanced_prepared_statements);
+                        }
+                    }
+                }
+            }
+        }
         return result;
     }
 };