couchbase 3.0.0.beta.1 → 3.1.0

data/ext/couchbase/capabilities.hxx

@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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.
+ */
+
+#pragma once
+
+#include <spdlog/fmt/fmt.h>
+
+namespace couchbase
+{
+enum class bucket_capability {
+    couchapi,
+    xattr,
+    dcp,
+    cbhello,
+    touch,
+    cccp,
+    xdcr_checkpointing,
+    nodes_ext,
+    collections,
+    durable_write,
+    tombstoned_user_xattrs,
+};
+
+enum class cluster_capability {
+    n1ql_cost_based_optimizer,
+    n1ql_index_advisor,
+    n1ql_javascript_functions,
+    n1ql_inline_functions,
+    n1ql_enhanced_prepared_statements,
+};
+} // namespace couchbase
+
+template<>
+struct fmt::formatter<couchbase::bucket_capability> : formatter<std::string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::bucket_capability type, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (type) {
+            case couchbase::bucket_capability::couchapi:
+                name = "couchapi";
+                break;
+            case couchbase::bucket_capability::xattr:
+                name = "xattr";
+                break;
+            case couchbase::bucket_capability::dcp:
+                name = "dcp";
+                break;
+            case couchbase::bucket_capability::cbhello:
+                name = "cbhello";
+                break;
+            case couchbase::bucket_capability::touch:
+                name = "touch";
+                break;
+            case couchbase::bucket_capability::cccp:
+                name = "cccp";
+                break;
+            case couchbase::bucket_capability::xdcr_checkpointing:
+                name = "xdcr_checkpointing";
+                break;
+            case couchbase::bucket_capability::nodes_ext:
+                name = "nodes_ext";
+                break;
+            case couchbase::bucket_capability::collections:
+                name = "collections";
+                break;
+            case couchbase::bucket_capability::durable_write:
+                name = "durable_write";
+                break;
+            case couchbase::bucket_capability::tombstoned_user_xattrs:
+                name = "tombstoned_user_xattrs";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};
+
+template<>
+struct fmt::formatter<couchbase::cluster_capability> : formatter<std::string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::cluster_capability type, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (type) {
+            case couchbase::cluster_capability::n1ql_cost_based_optimizer:
+                name = "n1ql_cost_based_optimizer";
+                break;
+            case couchbase::cluster_capability::n1ql_index_advisor:
+                name = "n1ql_index_advisor";
+                break;
+            case couchbase::cluster_capability::n1ql_javascript_functions:
+                name = "n1ql_javascript_functions";
+                break;
+            case couchbase::cluster_capability::n1ql_inline_functions:
+                name = "n1ql_inline_functions";
+                break;
+            case couchbase::cluster_capability::n1ql_enhanced_prepared_statements:
+                name = "n1ql_enhanced_prepared_statements";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};

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/cbsasl/client.h

@@ -58,7 +58,7 @@ class MechanismBackend
     virtual ~MechanismBackend() = default;
     virtual std::pair<error, std::string_view> start() = 0;
     virtual std::pair<error, std::string_view> step(std::string_view input) = 0;
-    virtual std::string_view get_name() const = 0;
+    [[nodiscard]] virtual std::string_view get_name() const = 0;
 
   protected:
     const GetUsernameCallback usernameCallback;

data/ext/couchbase/cluster.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *   Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -32,8 +32,58 @@
 #include <operations.hxx>
 #include <operations/document_query.hxx>
 
+#include <diagnostics.hxx>
+
 namespace couchbase
 {
+namespace
+{
+class ping_collector : public std::enable_shared_from_this<ping_collector>
+{
+    diag::ping_result res_;
+    std::function<void(diag::ping_result)> handler_;
+    std::atomic_int expected_{ 0 };
+    std::mutex mutex_{};
+
+  public:
+    ping_collector(std::string report_id, std::function<void(diag::ping_result)> handler)
+      : res_{ std::move(report_id), couchbase::sdk_id() }
+      , handler_(std::move(handler))
+    {
+    }
+
+    ~ping_collector()
+    {
+        invoke_handler();
+    }
+
+    [[nodiscard]] diag::ping_result& result()
+    {
+        return res_;
+    }
+
+    auto build_reporter()
+    {
+        expected_++;
+        return [self = this->shared_from_this()](diag::endpoint_ping_info&& info) {
+            std::scoped_lock lock(self->mutex_);
+            self->res_.services[info.type].emplace_back(info);
+            if (--self->expected_ == 0) {
+                self->invoke_handler();
+            }
+        };
+    }
+
+    void invoke_handler()
+    {
+        if (handler_ != nullptr) {
+            handler_(std::move(res_));
+            handler_ = nullptr;
+        }
+    }
+};
+} // namespace
+
 class cluster
 {
   public:
@@ -53,7 +103,8 @@ class cluster
     {
         origin_ = origin;
         if (origin_.options().enable_dns_srv) {
-            return do_dns_srv(std::forward<Handler>(handler));
+            return asio::post(asio::bind_executor(
+              ctx_, [this, handler = std::forward<Handler>(handler)]() mutable { return do_dns_srv(std::forward<Handler>(handler)); }));
         }
         do_open(std::forward<Handler>(handler));
     }
@@ -63,11 +114,12 @@ class cluster
     {
         asio::post(asio::bind_executor(ctx_, [this, handler = std::forward<Handler>(handler)]() {
             if (session_) {
-                session_->stop();
+                session_->stop(io::retry_reason::do_not_retry);
             }
             for (auto& bucket : buckets_) {
                 bucket.second->close();
             }
+            session_manager_->close();
             handler();
             work_.reset();
         }));
@@ -76,6 +128,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();
@@ -95,7 +151,11 @@ class cluster
     {
         auto bucket = buckets_.find(request.id.bucket);
         if (bucket == buckets_.end()) {
-            return handler(operations::make_response(std::make_error_code(error::common_errc::bucket_not_found), request, {}));
+            error_context::key_value ctx{};
+            ctx.id = request.id;
+            ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+            using response_type = typename Request::encoded_response_type;
+            return handler(operations::make_response(std::move(ctx), request, response_type{}));
         }
         return bucket->second->execute(request, std::forward<Handler>(handler));
     }
@@ -103,9 +163,11 @@ class cluster
     template<class Request, class Handler>
     void execute_http(Request request, Handler&& handler)
     {
-        auto session = session_manager_->check_out(Request::type, origin_.get_username(), origin_.get_password());
+        auto session = session_manager_->check_out(Request::type, origin_.credentials());
         if (!session) {
-            return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), request, {}));
+            typename Request::error_context_type ctx{};
+            ctx.ec = std::make_error_code(error::common_errc::service_not_available);
+            return handler(operations::make_response(std::move(ctx), request, {}));
         }
         auto cmd = std::make_shared<operations::http_command<Request>>(ctx_, request);
         cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](typename Request::response_type resp) mutable {
@@ -114,6 +176,59 @@ 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(), couchbase::sdk_id() };
+            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));
+        }));
+    }
+
+    void ping(std::optional<std::string> report_id,
+              std::optional<std::string> bucket_name,
+              std::set<service_type> services,
+              std::function<void(diag::ping_result)> handler)
+    {
+        if (!report_id) {
+            report_id = std::make_optional(uuid::to_string(uuid::random()));
+        }
+        if (services.empty()) {
+            services = { service_type::kv, service_type::views, service_type::query, service_type::search, service_type::analytics };
+        }
+        asio::post(asio::bind_executor(ctx_, [this, report_id, bucket_name, services, handler = std::move(handler)]() mutable {
+            auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
+            if (bucket_name) {
+                if (services.find(service_type::kv) != services.end()) {
+                    auto bucket = buckets_.find(bucket_name.value());
+                    if (bucket != buckets_.end()) {
+                        bucket->second->ping(collector);
+                    }
+                }
+            } else {
+                if (services.find(service_type::kv) != services.end()) {
+                    if (session_) {
+                        session_->ping(collector->build_reporter());
+                    }
+                    for (auto& bucket : buckets_) {
+                        bucket.second->ping(collector);
+                    }
+                }
+                session_manager_->ping(services, collector, origin_.credentials());
+            }
+        }));
+    }
+
   private:
     template<typename Handler>
     void do_dns_srv(Handler&& handler)
@@ -125,7 +240,7 @@ class cluster
         dns_client_.query_srv(
           hostname,
           service,
-          [hostname, this, handler = std::forward<Handler>(handler)](couchbase::io::dns::dns_client::dns_srv_response resp) mutable {
+          [hostname, this, handler = std::forward<Handler>(handler)](couchbase::io::dns::dns_client::dns_srv_response&& resp) mutable {
               if (resp.ec) {
                   spdlog::warn("failed to fetch DNS SRV records for \"{}\" ({}), assuming that cluster is listening this address",
                                hostname,
@@ -157,9 +272,11 @@ class cluster
             tls_.set_options(asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
             if (!origin_.options().trust_certificate.empty()) {
                 std::error_code ec{};
+                spdlog::debug(R"([{}]: use TLS certificate chain: "{}")", id_, origin_.options().trust_certificate);
                 tls_.use_certificate_chain_file(origin_.options().trust_certificate, ec);
                 if (ec) {
-                    spdlog::error("unable to load certificate chain \"{}\": {}", origin_.options().trust_certificate, ec.message());
+                    spdlog::error(
+                      "[{}]: unable to load certificate chain \"{}\": {}", id_, origin_.options().trust_certificate, ec.message());
                     return handler(ec);
                 }
             }
@@ -172,6 +289,21 @@ class cluster
                              "(https://wiki.wireshark.org/TLS). DO NOT USE THIS BUILD IN PRODUCTION",
                              TLS_KEY_LOG_FILE);
 #endif
+            if (origin_.credentials().uses_certificate()) {
+                std::error_code ec{};
+                spdlog::debug(R"([{}]: use TLS certificate: "{}")", id_, origin_.certificate_path());
+                tls_.use_certificate_file(origin_.certificate_path(), asio::ssl::context::file_format::pem, ec);
+                if (ec) {
+                    spdlog::error("[{}]: unable to load certificate \"{}\": {}", id_, origin_.certificate_path(), ec.message());
+                    return handler(ec);
+                }
+                spdlog::debug(R"([{}]: use TLS private key: "{}")", id_, origin_.key_path());
+                tls_.use_private_key_file(origin_.key_path(), asio::ssl::context::file_format::pem, ec);
+                if (ec) {
+                    spdlog::error("[{}]: unable to load private key \"{}\": {}", id_, origin_.key_path(), ec.message());
+                    return handler(ec);
+                }
+            }
             session_ = std::make_shared<io::mcbp_session>(id_, ctx_, tls_, origin_);
         } else {
             session_ = std::make_shared<io::mcbp_session>(id_, ctx_, origin_);
@@ -180,16 +312,23 @@ class cluster
             if (!ec) {
                 if (origin_.options().network == "auto") {
                     origin_.options().network = config.select_network(session_->bootstrap_hostname());
-                    spdlog::info(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                    if (origin_.options().network == "default") {
+                        spdlog::debug(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                    } else {
+                        spdlog::info(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                    }
                 }
                 if (origin_.options().network != "default") {
                     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);