couchbase 4.2.8-dev.1 → 4.2.9

package/deps/couchbase-cxx-client/core/cluster_agent_config.hxx

@@ -30,7 +30,7 @@ class retry_strategy;
 namespace couchbase::core
 {
 struct cluster_agent_config {
-    core_sdk_shim shim{}; // TODO: remove once refactoring will be finished.
+    core_sdk_shim shim; // TODO: remove once refactoring will be finished.
 
     std::string user_agent{};
     std::shared_ptr<retry_strategy> default_retry_strategy{};

package/deps/couchbase-cxx-client/core/cluster_options.cxx

@@ -16,12 +16,17 @@
  */
 
 #include "cluster_options.hxx"
+
 #include "config_profiles.hxx"
+#include "core/transactions/attempt_context_testing_hooks.hxx"
+#include "core/transactions/cleanup_testing_hooks.hxx"
+
+#include <couchbase/best_effort_retry_strategy.hxx>
+
 #include <stdexcept>
 
 namespace couchbase::core
 {
-
 std::chrono::milliseconds
 cluster_options::default_timeout_for(service_type type) const
 {
@@ -43,8 +48,13 @@ cluster_options::default_timeout_for(service_type type) const
     throw std::runtime_error("unexpected service type");
 }
 void
-cluster_options::apply_profile(std::string profile_name)
+cluster_options::apply_profile(std::string_view profile_name)
 {
     known_profiles().apply(profile_name, *this);
 }
+
+cluster_options::cluster_options()
+  : default_retry_strategy_{ make_best_effort_retry_strategy() }
+{
+}
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/cluster_options.hxx

@@ -21,14 +21,12 @@
 #include "core/io/ip_protocol.hxx"
 #include "core/metrics/logging_meter_options.hxx"
 #include "core/tracing/threshold_logging_options.hxx"
-#include "core/transactions/attempt_context_testing_hooks.hxx"
-#include "core/transactions/cleanup_testing_hooks.hxx"
 #include "service_type.hxx"
 #include "timeout_defaults.hxx"
 #include "tls_verify_mode.hxx"
 
-#include <couchbase/best_effort_retry_strategy.hxx>
 #include <couchbase/metrics/meter.hxx>
+#include <couchbase/retry_strategy.hxx>
 #include <couchbase/tracing/request_tracer.hxx>
 #include <couchbase/transactions/transactions_config.hxx>
 
@@ -38,6 +36,12 @@
 namespace couchbase::core
 {
 struct cluster_options {
+  public:
+    cluster_options();
+
+    void apply_profile(std::string_view profile_name);
+    [[nodiscard]] std::chrono::milliseconds default_timeout_for(service_type type) const;
+
     std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
     std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
     std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
@@ -61,7 +65,7 @@ struct cluster_options {
     io::dns::dns_config dns_config{ io::dns::dns_config::system_config() };
     bool show_queries{ false };
     bool enable_unordered_execution{ true };
-    bool enable_clustermap_notification{ false };
+    bool enable_clustermap_notification{ true };
     bool enable_compression{ true };
     bool enable_tracing{ true };
     bool enable_metrics{ true };
@@ -71,7 +75,7 @@ struct cluster_options {
     tls_verify_mode tls_verify{ tls_verify_mode::peer };
     std::shared_ptr<couchbase::tracing::request_tracer> tracer{ nullptr };
     std::shared_ptr<couchbase::metrics::meter> meter{ nullptr };
-    std::shared_ptr<retry_strategy> default_retry_strategy_{ make_best_effort_retry_strategy() };
+    std::shared_ptr<retry_strategy> default_retry_strategy_;
 
     std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;
     std::chrono::milliseconds config_poll_interval = timeout_defaults::config_poll_interval;
@@ -83,11 +87,8 @@ struct cluster_options {
     std::string user_agent_extra{};
     couchbase::transactions::transactions_config::built transactions{};
 
-    [[nodiscard]] std::chrono::milliseconds default_timeout_for(service_type type) const;
-
     bool dump_configuration{ false };
     bool disable_mozilla_ca_certificates{ false };
-    void apply_profile(std::string profile_name);
 };
 
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/config_profiles.cxx

@@ -58,9 +58,9 @@ config_profiles::config_profiles() noexcept
 }
 
 void
-config_profiles::apply(const std::string& profile_name, couchbase::core::cluster_options& opts)
+config_profiles::apply(std::string_view profile_name, couchbase::core::cluster_options& opts)
 {
-    std::lock_guard<std::mutex> lock(mut_);
+    const std::lock_guard<std::mutex> lock(mut_);
     auto it = profiles_.find(profile_name);
     if (it != profiles_.end()) {
         it->second->apply(opts);

package/deps/couchbase-cxx-client/core/config_profiles.hxx

@@ -36,7 +36,7 @@ class config_profiles
   public:
     config_profiles() noexcept;
 
-    void apply(const std::string& profile_name, couchbase::core::cluster_options& opts);
+    void apply(std::string_view profile_name, couchbase::core::cluster_options& opts);
 
     template<typename T, typename... Args>
     void register_profile(const std::string& name, Args... args)

package/deps/couchbase-cxx-client/core/core_sdk_shim.cxx

@@ -22,7 +22,6 @@ namespace couchbase::core
 auto
 core_sdk_shim::to_string() const -> std::string
 {
-    return fmt::format(
-      R"(#<core_sdk_shim:{} cluster={}>)", static_cast<const void*>(this), cluster ? static_cast<const void*>(cluster.get()) : "(none)");
+    return fmt::format(R"(#<core_sdk_shim:{} cluster={}>)", static_cast<const void*>(this), cluster.to_string());
 }
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/core_sdk_shim.hxx

@@ -15,7 +15,8 @@
 
 #pragma once
 
-#include <memory>
+#include "cluster.hxx"
+
 #include <string>
 
 namespace couchbase::core
@@ -23,7 +24,7 @@ namespace couchbase::core
 class cluster;
 
 struct core_sdk_shim {
-    std::shared_ptr<core::cluster> cluster;
+    core::cluster cluster;
 
     [[nodiscard]] auto to_string() const -> std::string;
 };

package/deps/couchbase-cxx-client/core/diagnostics.hxx

@@ -19,7 +19,6 @@
 
 #include "service_type.hxx"
 
-#include <array>
 #include <chrono>
 #include <map>
 #include <optional>

package/deps/couchbase-cxx-client/core/dispatcher.cxx

@@ -27,11 +27,11 @@ dispatcher::dispatcher(std::string bucket_name, core_sdk_shim shim)
 auto
 dispatcher::direct_dispatch(std::shared_ptr<mcbp::queue_request> req) const -> std::error_code
 {
-    return shim_.cluster->direct_dispatch(bucket_name_, std::move(req));
+    return shim_.cluster.direct_dispatch(bucket_name_, std::move(req));
 }
 auto
 dispatcher::direct_re_queue(std::shared_ptr<mcbp::queue_request> req, bool is_retry) const -> std::error_code
 {
-    return shim_.cluster->direct_re_queue(bucket_name_, std::move(req), is_retry);
+    return shim_.cluster.direct_re_queue(bucket_name_, std::move(req), is_retry);
 }
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/impl/analytics.cxx

@@ -15,37 +15,20 @@
  *   limitations under the License.
  */
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/error_codes.hxx>
-#include <couchbase/scope.hxx>
+#include "analytics.hxx"
 
 #include "core/cluster.hxx"
 #include "core/operations/document_analytics.hxx"
+#include "core/utils/binary.hxx"
+
+#include <couchbase/cluster.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/scope.hxx>
 
-namespace couchbase
+namespace couchbase::core::impl
 {
-static analytics_error_context
-build_context(core::operations::analytics_response& resp)
+namespace
 {
-    return {
-        resp.ctx.ec,
-        resp.ctx.last_dispatched_to,
-        resp.ctx.last_dispatched_from,
-        resp.ctx.retry_attempts,
-        std::move(resp.ctx.retry_reasons),
-        resp.ctx.first_error_code,
-        std::move(resp.ctx.first_error_message),
-        std::move(resp.ctx.client_context_id),
-        std::move(resp.ctx.statement),
-        std::move(resp.ctx.parameters),
-        std::move(resp.ctx.method),
-        std::move(resp.ctx.path),
-        resp.ctx.http_status,
-        std::move(resp.ctx.http_body),
-        std::move(resp.ctx.hostname),
-        resp.ctx.port,
-    };
-}
 
 static analytics_status
 map_status(core::operations::analytics_response::analytics_status status)
@@ -80,9 +63,9 @@ map_scan_consistency(std::optional<couchbase::analytics_scan_consistency> consis
 {
     if (consistency.has_value()) {
         switch (consistency.value()) {
-            case analytics_scan_consistency::not_bounded:
+            case couchbase::analytics_scan_consistency::not_bounded:
                 return couchbase::core::analytics_scan_consistency::not_bounded;
-            case analytics_scan_consistency::request_plus:
+            case couchbase::analytics_scan_consistency::request_plus:
                 return couchbase::core::analytics_scan_consistency::request_plus;
         }
     }
@@ -133,7 +116,32 @@ map_signature(core::operations::analytics_response& resp)
     return core::utils::to_binary(resp.meta.signature.value());
 }
 
-static analytics_result
+} // namespace
+
+analytics_error_context
+build_context(core::operations::analytics_response& resp)
+{
+    return {
+        resp.ctx.ec,
+        resp.ctx.last_dispatched_to,
+        resp.ctx.last_dispatched_from,
+        resp.ctx.retry_attempts,
+        std::move(resp.ctx.retry_reasons),
+        resp.ctx.first_error_code,
+        std::move(resp.ctx.first_error_message),
+        std::move(resp.ctx.client_context_id),
+        std::move(resp.ctx.statement),
+        std::move(resp.ctx.parameters),
+        std::move(resp.ctx.method),
+        std::move(resp.ctx.path),
+        resp.ctx.http_status,
+        std::move(resp.ctx.http_body),
+        std::move(resp.ctx.hostname),
+        resp.ctx.port,
+    };
+}
+
+analytics_result
 build_result(core::operations::analytics_response& resp)
 {
     return {
@@ -149,7 +157,7 @@ build_result(core::operations::analytics_response& resp)
     };
 }
 
-static core::operations::analytics_request
+core::operations::analytics_request
 build_analytics_request(std::string statement,
                         analytics_options::built options,
                         std::optional<std::string> bucket_name,
@@ -188,50 +196,4 @@ build_analytics_request(std::string statement,
     return request;
 }
 
-void
-cluster::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
-{
-    auto request = build_analytics_request(std::move(statement), options.build(), {}, {});
-
-    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
-        auto r = std::move(resp);
-        return handler(build_context(r), build_result(r));
-    });
-}
-
-auto
-cluster::analytics_query(std::string statement, const analytics_options& options) const
-  -> std::future<std::pair<analytics_error_context, analytics_result>>
-{
-    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
-    auto future = barrier->get_future();
-    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
-        barrier->set_value({ std::move(ctx), std::move(result) });
-    });
-    return future;
-}
-
-void
-scope::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
-{
-    auto request = build_analytics_request(std::move(statement), options.build(), bucket_name_, name_);
-
-    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
-        auto r = std::move(resp);
-        return handler(build_context(r), build_result(r));
-    });
-}
-
-auto
-scope::analytics_query(std::string statement, const analytics_options& options) const
-  -> std::future<std::pair<analytics_error_context, analytics_result>>
-{
-    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
-    auto future = barrier->get_future();
-    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
-        barrier->set_value({ std::move(ctx), std::move(result) });
-    });
-    return future;
-}
-
-} // namespace couchbase
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/analytics.hxx

@@ -0,0 +1,40 @@
+/* -*- 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 "core/operations/document_analytics.hxx"
+
+#include <couchbase/analytics_options.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase::core::impl
+{
+analytics_error_context
+build_context(core::operations::analytics_response& resp);
+
+analytics_result
+build_result(core::operations::analytics_response& resp);
+
+core::operations::analytics_request
+build_analytics_request(std::string statement,
+                        analytics_options::built options,
+                        std::optional<std::string> bucket_name,
+                        std::optional<std::string> scope_name);
+} // namespace couchbase::core::impl