couchbase 4.0.0 → 4.1.0

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_session.hxx

@@ -47,7 +47,6 @@
 #include <couchbase/sasl/client.h>
 #include <couchbase/sasl/error.h>
 #include <couchbase/sasl/error_fmt.h>
-#include <couchbase/timeout_defaults.hxx>
 #include <couchbase/topology/capabilities_fmt.hxx>
 #include <couchbase/topology/configuration_fmt.hxx>
 #include <couchbase/utils/join_strings.hxx>
@@ -740,9 +739,12 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                   bootstrap_hostname_,
                                   bootstrap_port_);
         LOG_DEBUG("{} attempt to establish MCBP connection", log_prefix_);
-        resolver_.async_resolve(bootstrap_hostname_,
-                                bootstrap_port_,
-                                std::bind(&mcbp_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+
+        async_resolve(origin_.options().use_ip_protocol,
+                      resolver_,
+                      bootstrap_hostname_,
+                      bootstrap_port_,
+                      std::bind(&mcbp_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
     }
 
     [[nodiscard]] const std::string& id() const
@@ -1065,7 +1067,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
     {
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
@@ -1075,8 +1077,13 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         endpoints_ = endpoints;
         do_connect(endpoints_.begin());
-        connection_deadline_.expires_after(timeout_defaults::connect_timeout);
-        connection_deadline_.async_wait(std::bind(&mcbp_session::check_deadline, shared_from_this(), std::placeholders::_1));
+        connection_deadline_.expires_after(origin_.options().resolve_timeout);
+        connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+            if (timer_ec == asio::error::operation_aborted || self->stopped_) {
+                return;
+            }
+            return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
+        });
     }
 
     void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
@@ -1086,8 +1093,18 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         last_active_ = std::chrono::steady_clock::now();
         if (it != endpoints_.end()) {
-            LOG_DEBUG("{} connecting to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
-            connection_deadline_.expires_after(timeout_defaults::connect_timeout);
+            LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+                      log_prefix_,
+                      it->endpoint().address().to_string(),
+                      it->endpoint().port(),
+                      origin_.options().connect_timeout.count());
+            connection_deadline_.expires_after(origin_.options().connect_timeout);
+            connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+                if (timer_ec == asio::error::operation_aborted || self->stopped_) {
+                    return;
+                }
+                return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
+            });
             stream_->async_connect(it->endpoint(), std::bind(&mcbp_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
             LOG_ERROR("{} no more endpoints left to connect, will try another address", log_prefix_);
@@ -1097,7 +1114,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     void on_connect(const std::error_code& ec, asio::ip::tcp::resolver::results_type::iterator it)
     {
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         last_active_ = std::chrono::steady_clock::now();

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_traits.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 <type_traits>
+
+namespace couchbase::io::mcbp_traits
+{
+template<typename T>
+struct supports_durability : public std::false_type {
+};
+
+template<typename T>
+inline constexpr bool supports_durability_v = supports_durability<T>::value;
+} // namespace couchbase::io::mcbp_traits

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/streams.hxx

@@ -17,13 +17,35 @@
 
 #pragma once
 
+#include <couchbase/io/ip_protocol.hxx>
+
 #include <asio.hpp>
 #include <asio/ssl.hpp>
+
 #include <functional>
 
 namespace couchbase::io
 {
 
+template<typename Resolver, typename Handler>
+static void
+async_resolve(ip_protocol protocol, Resolver& resolver, const std::string& hostname, const std::string& service, Handler&& handler)
+{
+
+    switch (protocol) {
+        case ip_protocol::force_ipv4:
+            return resolver.async_resolve(asio::ip::tcp::v4(), hostname, service, std::forward<Handler>(handler));
+        case ip_protocol::force_ipv6:
+            return resolver.async_resolve(asio::ip::tcp::v6(), hostname, service, std::forward<Handler>(handler));
+        case ip_protocol::any:
+            /* fall-through */
+        default:
+            /* use any protocol */
+            break;
+    }
+    return resolver.async_resolve(hostname, service, std::forward<Handler>(handler));
+}
+
 class stream_impl
 {
   protected:

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_library(
+  couchbase_management OBJECT
+  analytics_link_azure_blob_external.cxx
+  analytics_link_couchbase_remote.cxx
+  analytics_link_s3_external.cxx)
+set_target_properties(couchbase_management PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_link_libraries(
+  couchbase_management
+  PRIVATE project_options
+          project_warnings
+          fmt::fmt
+          spdlog::spdlog)
+target_include_directories(couchbase_management PRIVATE ${PROJECT_SOURCE_DIR})

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/analytics_dataset.hxx

@@ -0,0 +1,30 @@
+/* -*- 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 <string>
+
+namespace couchbase::management::analytics
+{
+struct dataset {
+    std::string name;
+    std::string dataverse_name;
+    std::string link_name;
+    std::string bucket_name;
+};
+} // namespace couchbase::management::analytics

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/analytics_index.hxx

@@ -0,0 +1,30 @@
+/* -*- 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 <string>
+
+namespace couchbase::management::analytics
+{
+struct index {
+    std::string name;
+    std::string dataverse_name;
+    std::string dataset_name;
+    bool is_primary;
+};
+} // namespace couchbase::management::analytics

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/analytics_link.hxx

@@ -0,0 +1,22 @@
+/* -*- 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 <couchbase/management/analytics_link_azure_blob_external.hxx>
+#include <couchbase/management/analytics_link_couchbase_remote.hxx>
+#include <couchbase/management/analytics_link_s3_external.hxx>

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_azure_blob_external.cxx

@@ -15,17 +15,17 @@
  *   limitations under the License.
  */
 
-#include <couchbase/operations/management/analytics_link_azure_blob_external.hxx>
+#include <couchbase/management/analytics_link_azure_blob_external.hxx>
 
 #include <couchbase/errors.hxx>
 #include <couchbase/utils/url_codec.hxx>
 
 #include <algorithm>
 
-namespace couchbase::operations::management
+namespace couchbase::management::analytics
 {
 std::error_code
-analytics_link::azure_blob_external::validate() const
+azure_blob_external_link::validate() const
 {
     if (dataverse.empty() || link_name.empty()) {
         return error::common_errc::invalid_argument;
@@ -37,7 +37,7 @@ analytics_link::azure_blob_external::validate() const
 }
 
 std::string
-analytics_link::azure_blob_external::encode() const
+azure_blob_external_link::encode() const
 {
     std::map<std::string, std::string> values{
         { "type", "azureblob" },
@@ -64,4 +64,4 @@ analytics_link::azure_blob_external::encode() const
     }
     return utils::string_codec::v2::form_encode(values);
 }
-} // namespace couchbase::operations::management
+} // namespace couchbase::management::analytics

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_azure_blob_external.hxx

@@ -21,13 +21,13 @@
 #include <string>
 #include <system_error>
 
-namespace couchbase::operations::management::analytics_link
+namespace couchbase::management::analytics
 {
 /**
  * An external analytics link which uses the Microsoft Azure Blob Storage service.
  * Only available as of 7.0 Developer Preview.
  */
-struct azure_blob_external {
+struct azure_blob_external_link {
     /**
      * The name of this link.
      */
@@ -73,4 +73,4 @@ struct azure_blob_external {
 
     [[nodiscard]] std::string encode() const;
 };
-} // namespace couchbase::operations::management::analytics_link
+} // namespace couchbase::management::analytics

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_azure_blob_external_json.hxx

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/operations/management/analytics_link_azure_blob_external.hxx>
+#include <couchbase/management/analytics_link_azure_blob_external.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::analytics_link::azure_blob_external> {
+struct traits<couchbase::management::analytics::azure_blob_external_link> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::analytics_link::azure_blob_external as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::analytics::azure_blob_external_link as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::analytics_link::azure_blob_external result{};
+        couchbase::management::analytics::azure_blob_external_link result{};
 
         result.link_name = v.at("name").get_string();
         if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_couchbase_remote.cxx

@@ -15,24 +15,24 @@
  *   limitations under the License.
  */
 
-#include <couchbase/operations/management/analytics_link_couchbase_remote.hxx>
+#include <couchbase/management/analytics_link_couchbase_remote.hxx>
 
 #include <couchbase/errors.hxx>
 #include <couchbase/utils/url_codec.hxx>
 
 #include <algorithm>
 
-namespace couchbase::operations::management
+namespace couchbase::management::analytics
 {
 std::error_code
-analytics_link::couchbase_remote::validate() const
+couchbase_remote_link::validate() const
 {
     if (dataverse.empty() || link_name.empty() || hostname.empty()) {
         return error::common_errc::invalid_argument;
     }
     switch (encryption.level) {
-        case encryption_level::none:
-        case encryption_level::half:
+        case couchbase_link_encryption_level::none:
+        case couchbase_link_encryption_level::half:
             if (/* username and password must be provided */ username.has_value() && password.has_value() &&
                 /* and client certificate and key must be empty */
                 (!encryption.client_certificate.has_value() && !encryption.client_key.has_value())) {
@@ -41,7 +41,7 @@ analytics_link::couchbase_remote::validate() const
             }
             return error::common_errc::invalid_argument;
 
-        case encryption_level::full:
+        case couchbase_link_encryption_level::full:
             if (/* certificate must be provided and */ encryption.certificate.has_value() &&
                 (/* either username/password must be set */ (username.has_value() && password.has_value() &&
                                                              !encryption.client_certificate.has_value() &&
@@ -57,7 +57,7 @@ analytics_link::couchbase_remote::validate() const
 }
 
 std::string
-analytics_link::couchbase_remote::encode() const
+couchbase_remote_link::encode() const
 {
     std::map<std::string, std::string> values{
         { "type", "couchbase" },
@@ -87,18 +87,18 @@ analytics_link::couchbase_remote::encode() const
 }
 
 std::string
-analytics_link::to_string(analytics_link::encryption_level level)
+to_string(couchbase_link_encryption_level level)
 {
     switch (level) {
-        case encryption_level::none:
+        case couchbase_link_encryption_level::none:
             return "none";
 
-        case encryption_level::half:
+        case couchbase_link_encryption_level::half:
             return "half";
 
-        case encryption_level::full:
+        case couchbase_link_encryption_level::full:
             return "full";
     }
     return "none";
 }
-} // namespace couchbase::operations::management
+} // namespace couchbase::management::analytics

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_couchbase_remote.hxx

@@ -21,9 +21,9 @@
 #include <string>
 #include <system_error>
 
-namespace couchbase::operations::management::analytics_link
+namespace couchbase::management::analytics
 {
-enum class encryption_level {
+enum class couchbase_link_encryption_level {
     /**
      * Connect to the remote Couchbase cluster using an unsecured channel. Send the password in plaintext.
      */
@@ -43,13 +43,13 @@ enum class encryption_level {
 };
 
 std::string
-to_string(encryption_level level);
+to_string(couchbase_link_encryption_level level);
 
-struct encryption_settings {
+struct couchbase_link_encryption_settings {
     /**
      * Specifies what level of encryption should be used.
      */
-    encryption_level level{ encryption_level::none };
+    couchbase_link_encryption_level level{ couchbase_link_encryption_level::none };
 
     /**
      * Provides a certificate to use for connecting when encryption level is set to 'full'.  Required when 'encryption_level' is set to
@@ -72,7 +72,7 @@ struct encryption_settings {
 /**
  * A remote analytics link which uses a Couchbase data service that is not part of the same cluster as the Analytics Service.
  */
-struct couchbase_remote {
+struct couchbase_remote_link {
     /**
      * The name of this link.
      */
@@ -98,10 +98,10 @@ struct couchbase_remote {
      */
     std::optional<std::string> password{};
 
-    encryption_settings encryption{};
+    couchbase_link_encryption_settings encryption{};
 
     [[nodiscard]] std::error_code validate() const;
 
     [[nodiscard]] std::string encode() const;
 };
-} // namespace couchbase::operations::management::analytics_link
+} // namespace couchbase::management::analytics

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_couchbase_remote_json.hxx

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/operations/management/analytics_link_couchbase_remote.hxx>
+#include <couchbase/management/analytics_link_couchbase_remote.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::analytics_link::couchbase_remote> {
+struct traits<couchbase::management::analytics::couchbase_remote_link> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::analytics_link::couchbase_remote as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::analytics::couchbase_remote_link as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::analytics_link::couchbase_remote result{};
+        couchbase::management::analytics::couchbase_remote_link result{};
 
         result.link_name = v.at("name").get_string();
         if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {
@@ -40,11 +40,11 @@ struct traits<couchbase::operations::management::analytics_link::couchbase_remot
         if (const auto* encryption = v.find("encryption"); encryption != nullptr && encryption->is_string()) {
             const auto& level = encryption->get_string();
             if (level == "none") {
-                result.encryption.level = couchbase::operations::management::analytics_link::encryption_level::none;
+                result.encryption.level = couchbase::management::analytics::couchbase_link_encryption_level::none;
             } else if (level == "half") {
-                result.encryption.level = couchbase::operations::management::analytics_link::encryption_level::half;
+                result.encryption.level = couchbase::management::analytics::couchbase_link_encryption_level::half;
             } else if (level == "full") {
-                result.encryption.level = couchbase::operations::management::analytics_link::encryption_level::full;
+                result.encryption.level = couchbase::management::analytics::couchbase_link_encryption_level::full;
             }
         }
         if (const auto* username = v.find("username"); username != nullptr && username->is_string()) {

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_s3_external.cxx

@@ -15,17 +15,17 @@
  *   limitations under the License.
  */
 
-#include <couchbase/operations/management/analytics_link_s3_external.hxx>
+#include <couchbase/management/analytics_link_s3_external.hxx>
 
 #include <couchbase/errors.hxx>
 #include <couchbase/utils/url_codec.hxx>
 
 #include <algorithm>
 
-namespace couchbase::operations::management
+namespace couchbase::management::analytics
 {
 std::error_code
-analytics_link::s3_external::validate() const
+s3_external_link::validate() const
 {
     if (dataverse.empty() || link_name.empty() || access_key_id.empty() || secret_access_key.empty() || region.empty()) {
         return error::common_errc::invalid_argument;
@@ -34,7 +34,7 @@ analytics_link::s3_external::validate() const
 }
 
 std::string
-analytics_link::s3_external::encode() const
+s3_external_link::encode() const
 {
     std::map<std::string, std::string> values{
         { "type", "s3" },
@@ -54,4 +54,4 @@ analytics_link::s3_external::encode() const
     }
     return utils::string_codec::v2::form_encode(values);
 }
-} // namespace couchbase::operations::management
+} // namespace couchbase::management::analytics

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/{operations/management → management}/analytics_link_s3_external.hxx

@@ -21,12 +21,12 @@
 #include <string>
 #include <system_error>
 
-namespace couchbase::operations::management::analytics_link
+namespace couchbase::management::analytics
 {
 /**
  * An external analytics link which uses the AWS S3 service to access data.
  */
-struct s3_external {
+struct s3_external_link {
     /**
      * The name of this link.
      */
@@ -66,4 +66,4 @@ struct s3_external {
 
     [[nodiscard]] std::string encode() const;
 };
-} // namespace couchbase::operations::management::analytics_link
+} // namespace couchbase::management::analytics

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_s3_external_json.hxx

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/operations/management/analytics_link_s3_external.hxx>
+#include <couchbase/management/analytics_link_s3_external.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::analytics_link::s3_external> {
+struct traits<couchbase::management::analytics::s3_external_link> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::analytics_link::s3_external as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::analytics::s3_external_link as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::analytics_link::s3_external result{};
+        couchbase::management::analytics::s3_external_link result{};
 
         result.link_name = v.at("name").get_string();
         if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {