couchbase 3.5.2 → 3.5.4

data/ext/couchbase/core/http_component.hxx

@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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_sdk_shim.hxx"
+#include "free_form_http_request.hxx"
+#include "pending_operation.hxx"
+
+#include <tl/expected.hpp>
+
+#include <memory>
+#include <system_error>
+
+namespace asio
+{
+class io_context;
+} // namespace asio
+
+namespace couchbase
+{
+class retry_strategy;
+} // namespace couchbase
+
+namespace couchbase::core
+{
+class http_session_manager;
+class http_component_impl;
+
+class http_component
+{
+public:
+  http_component(asio::io_context& io,
+                 core_sdk_shim shim,
+                 std::shared_ptr<retry_strategy> default_retry_strategy = {});
+
+  auto do_http_request(const http_request& request, free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>;
+#else
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
+#endif
+
+  auto do_http_request_buffered(const http_request& request,
+                                buffered_free_form_http_request_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
+
+private:
+  std::shared_ptr<http_component_impl> impl_;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/impl/analytics.cxx

@@ -17,20 +17,29 @@
 
 #include "analytics.hxx"
 
-#include "core/cluster.hxx"
+#include "core/analytics_scan_consistency.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>
+#include <couchbase/analytics_metrics.hxx>
+#include <couchbase/analytics_options.hxx>
+#include <couchbase/analytics_result.hxx>
+#include <couchbase/analytics_scan_consistency.hxx>
+#include <couchbase/analytics_status.hxx>
+#include <couchbase/analytics_warning.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+
+#include <cstddef>
+#include <optional>
+#include <utility>
+#include <vector>
 
 namespace couchbase::core::impl
 {
 namespace
 {
 
-static auto
+auto
 map_status(core::operations::analytics_response::analytics_status status) -> analytics_status
 {
   switch (status) {
@@ -58,7 +67,7 @@ map_status(core::operations::analytics_response::analytics_status status) -> ana
   return analytics_status::unknown;
 }
 
-static auto
+auto
 map_scan_consistency(std::optional<couchbase::analytics_scan_consistency> consistency)
   -> std::optional<couchbase::core::analytics_scan_consistency>
 {
@@ -73,7 +82,7 @@ map_scan_consistency(std::optional<couchbase::analytics_scan_consistency> consis
   return {};
 }
 
-static auto
+auto
 map_rows(const core::operations::analytics_response& resp) -> std::vector<codec::binary>
 {
   std::vector<codec::binary> rows;
@@ -84,7 +93,7 @@ map_rows(const core::operations::analytics_response& resp) -> std::vector<codec:
   return rows;
 }
 
-static auto
+auto
 map_warnings(core::operations::analytics_response& resp) -> std::vector<analytics_warning>
 {
   if (resp.meta.warnings.empty()) {
@@ -98,7 +107,7 @@ map_warnings(core::operations::analytics_response& resp) -> std::vector<analytic
   return warnings;
 }
 
-static auto
+auto
 map_metrics(const core::operations::analytics_response& resp) -> analytics_metrics
 {
   return analytics_metrics{
@@ -109,7 +118,7 @@ map_metrics(const core::operations::analytics_response& resp) -> analytics_metri
   };
 }
 
-static auto
+auto
 map_signature(core::operations::analytics_response& resp) -> std::optional<std::vector<std::byte>>
 {
   if (!resp.meta.signature) {

data/ext/couchbase/core/impl/analytics_error_category.cxx

@@ -18,6 +18,7 @@
 #include <couchbase/error_codes.hxx>
 
 #include <string>
+#include <system_error>
 
 namespace couchbase::core::impl
 {

data/ext/couchbase/core/impl/analytics_index_manager.cxx

@@ -16,8 +16,12 @@
  */
 
 #include "core/cluster.hxx"
+#include "core/impl/error.hxx"
 #include "core/logger/logger.hxx"
 
+#include "core/management/analytics_link_azure_blob_external.hxx"
+#include "core/management/analytics_link_couchbase_remote.hxx"
+#include "core/management/analytics_link_s3_external.hxx"
 #include "core/operations/management/analytics_dataset_create.hxx"
 #include "core/operations/management/analytics_dataset_drop.hxx"
 #include "core/operations/management/analytics_dataset_get_all.hxx"
@@ -34,10 +38,35 @@
 #include "core/operations/management/analytics_link_get_all.hxx"
 #include "core/operations/management/analytics_link_replace.hxx"
 
-#include "core/impl/error.hxx"
-
 #include <couchbase/analytics_index_manager.hxx>
+#include <couchbase/connect_link_analytics_options.hxx>
+#include <couchbase/create_dataset_analytics_options.hxx>
+#include <couchbase/create_dataverse_analytics_options.hxx>
+#include <couchbase/create_index_analytics_options.hxx>
+#include <couchbase/create_link_analytics_options.hxx>
+#include <couchbase/disconnect_link_analytics_options.hxx>
+#include <couchbase/drop_dataset_analytics_options.hxx>
+#include <couchbase/drop_dataverse_analytics_options.hxx>
+#include <couchbase/drop_index_analytics_options.hxx>
+#include <couchbase/drop_link_analytics_options.hxx>
+#include <couchbase/error.hxx>
+#include <couchbase/get_all_datasets_analytics_options.hxx>
+#include <couchbase/get_all_indexes_analytics_options.hxx>
+#include <couchbase/get_links_analytics_options.hxx>
+#include <couchbase/get_pending_mutations_analytics_options.hxx>
+#include <couchbase/management/analytics_dataset.hxx>
+#include <couchbase/management/analytics_index.hxx>
 #include <couchbase/management/analytics_link.hxx>
+#include <couchbase/replace_link_analytics_options.hxx>
+
+#include <cstdint>
+#include <future>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace couchbase
 {
@@ -105,6 +134,9 @@ to_core_s3_external_link(const management::analytics_link& link)
     s3_link.service_endpoint,
   };
 }
+
+constexpr auto DEFAULT_DATAVERSE_NAME = "Default";
+constexpr auto DEFAULT_LINK_NAME = "Local";
 } // namespace
 
 class analytics_index_manager_impl
@@ -127,7 +159,7 @@ public:
         {},
         options.timeout,
       },
-      [dataverse_name, handler = std::move(handler)](auto resp) {
+      [dataverse_name, handler = std::move(handler)](const auto& resp) {
         CB_LOG_DEBUG(
           "Dataverse create for {} error code = {}", dataverse_name, resp.ctx.ec.value());
         handler(core::impl::make_error(resp.ctx));
@@ -145,7 +177,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -165,7 +197,7 @@ public:
         options.timeout,
         options.ignore_if_exists,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -182,7 +214,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -196,7 +228,7 @@ public:
         options.timeout,
       },
       [handler = std::move(handler)](
-        core::operations::management::analytics_dataset_get_all_response resp) {
+        const core::operations::management::analytics_dataset_get_all_response& resp) {
         if (resp.ctx.ec) {
           return handler(core::impl::make_error(resp.ctx), {});
         }
@@ -230,7 +262,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -249,7 +281,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -262,8 +294,8 @@ public:
         {},
         options.timeout,
       },
-      [handler =
-         std::move(handler)](core::operations::management::analytics_index_get_all_response resp) {
+      [handler = std::move(handler)](
+        const core::operations::management::analytics_index_get_all_response& resp) {
         if (resp.ctx.ec) {
           return handler(core::impl::make_error(resp.ctx), {});
         }
@@ -292,7 +324,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -307,7 +339,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -321,7 +353,7 @@ public:
         options.timeout,
       },
       [handler = std::move(handler)](
-        core::operations::management::analytics_get_pending_mutations_response resp) {
+        const core::operations::management::analytics_get_pending_mutations_response& resp) {
         if (resp.ctx.ec) {
           return handler(core::impl::make_error(resp.ctx), {});
         }
@@ -354,7 +386,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -366,7 +398,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -378,7 +410,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
     }
@@ -397,7 +429,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -409,7 +441,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -421,7 +453,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
     }
@@ -439,7 +471,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -471,8 +503,8 @@ public:
     }
     return core_.execute(
       req,
-      [handler =
-         std::move(handler)](core::operations::management::analytics_link_get_all_response resp) {
+      [handler = std::move(handler)](
+        const core::operations::management::analytics_link_get_all_response& resp) {
         if (resp.ctx.ec) {
           return handler(core::impl::make_error(resp.ctx), {});
         }
@@ -525,9 +557,6 @@ public:
   }
 
 private:
-  static const inline std::string DEFAULT_DATAVERSE_NAME = "Default";
-  static const inline std::string DEFAULT_LINK_NAME = "Local";
-
   core::cluster core_;
 };
 
@@ -537,7 +566,7 @@ analytics_index_manager::analytics_index_manager(core::cluster core)
 }
 
 void
-analytics_index_manager::create_dataverse(std::string dataverse_name,
+analytics_index_manager::create_dataverse(const std::string& dataverse_name,
                                           const create_dataverse_analytics_options& options,
                                           create_dataverse_analytics_handler&& handler) const
 {
@@ -545,20 +574,20 @@ analytics_index_manager::create_dataverse(std::string dataverse_name,
 }
 
 auto
-analytics_index_manager::create_dataverse(std::string dataverse_name,
+analytics_index_manager::create_dataverse(const std::string& dataverse_name,
                                           const create_dataverse_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  create_dataverse(std::move(dataverse_name), options, [barrier](auto err) mutable {
+  create_dataverse(dataverse_name, options, [barrier](auto err) mutable {
     barrier->set_value({ std::move(err) });
   });
   return future;
 }
 
 void
-analytics_index_manager::drop_dataverse(std::string dataverse_name,
+analytics_index_manager::drop_dataverse(const std::string& dataverse_name,
                                         const drop_dataverse_analytics_options& options,
                                         drop_dataverse_analytics_handler&& handler) const
 {
@@ -566,21 +595,21 @@ analytics_index_manager::drop_dataverse(std::string dataverse_name,
 }
 
 auto
-analytics_index_manager::drop_dataverse(std::string dataverse_name,
+analytics_index_manager::drop_dataverse(const std::string& dataverse_name,
                                         const drop_dataverse_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  drop_dataverse(std::move(dataverse_name), options, [barrier](auto err) mutable {
+  drop_dataverse(dataverse_name, options, [barrier](auto err) mutable {
     barrier->set_value({ std::move(err) });
   });
   return future;
 }
 
 void
-analytics_index_manager::create_dataset(std::string dataset_name,
-                                        std::string bucket_name,
+analytics_index_manager::create_dataset(const std::string& dataset_name,
+                                        const std::string& bucket_name,
                                         const create_dataset_analytics_options& options,
                                         create_dataset_analytics_handler&& handler) const
 {
@@ -588,22 +617,21 @@ analytics_index_manager::create_dataset(std::string dataset_name,
 }
 
 auto
-analytics_index_manager::create_dataset(std::string dataset_name,
-                                        std::string bucket_name,
+analytics_index_manager::create_dataset(const std::string& dataset_name,
+                                        const std::string& bucket_name,
                                         const create_dataset_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  create_dataset(
-    std::move(dataset_name), std::move(bucket_name), options, [barrier](auto err) mutable {
-      barrier->set_value({ std::move(err) });
-    });
+  create_dataset(dataset_name, bucket_name, options, [barrier](auto err) mutable {
+    barrier->set_value({ std::move(err) });
+  });
   return future;
 }
 
 void
-analytics_index_manager::drop_dataset(std::string dataset_name,
+analytics_index_manager::drop_dataset(const std::string& dataset_name,
                                       const drop_dataset_analytics_options& options,
                                       drop_dataset_analytics_handler&& handler) const
 {
@@ -611,13 +639,13 @@ analytics_index_manager::drop_dataset(std::string dataset_name,
 }
 
 auto
-analytics_index_manager::drop_dataset(std::string dataset_name,
+analytics_index_manager::drop_dataset(const std::string& dataset_name,
                                       const drop_dataset_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  drop_dataset(std::move(dataset_name), options, [barrier](auto err) mutable {
+  drop_dataset(dataset_name, options, [barrier](auto err) mutable {
     barrier->set_value({ std::move(err) });
   });
   return future;
@@ -644,9 +672,9 @@ analytics_index_manager::get_all_datasets(const get_all_datasets_analytics_optio
 }
 
 void
-analytics_index_manager::create_index(std::string index_name,
-                                      std::string dataset_name,
-                                      std::map<std::string, std::string> fields,
+analytics_index_manager::create_index(const std::string& index_name,
+                                      const std::string& dataset_name,
+                                      const std::map<std::string, std::string>& fields,
                                       const create_index_analytics_options& options,
                                       create_index_analytics_handler&& handler) const
 {
@@ -654,27 +682,23 @@ analytics_index_manager::create_index(std::string index_name,
 }
 
 auto
-analytics_index_manager::create_index(std::string index_name,
-                                      std::string dataset_name,
-                                      std::map<std::string, std::string> fields,
+analytics_index_manager::create_index(const std::string& index_name,
+                                      const std::string& dataset_name,
+                                      const std::map<std::string, std::string>& fields,
                                       const create_index_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  create_index(std::move(index_name),
-               std::move(dataset_name),
-               std::move(fields),
-               options,
-               [barrier](auto err) mutable {
-                 barrier->set_value({ std::move(err) });
-               });
+  create_index(index_name, dataset_name, fields, options, [barrier](auto err) mutable {
+    barrier->set_value({ std::move(err) });
+  });
   return future;
 }
 
 void
-analytics_index_manager::drop_index(std::string index_name,
-                                    std::string dataset_name,
+analytics_index_manager::drop_index(const std::string& index_name,
+                                    const std::string& dataset_name,
                                     const drop_index_analytics_options& options,
                                     drop_index_analytics_handler&& handler) const
 {
@@ -682,14 +706,14 @@ analytics_index_manager::drop_index(std::string index_name,
 }
 
 auto
-analytics_index_manager::drop_index(std::string index_name,
-                                    std::string dataset_name,
+analytics_index_manager::drop_index(const std::string& index_name,
+                                    const std::string& dataset_name,
                                     const drop_index_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  drop_index(std::move(index_name), std::move(dataset_name), options, [barrier](auto err) mutable {
+  drop_index(index_name, dataset_name, options, [barrier](auto err) mutable {
     barrier->set_value({ std::move(err) });
   });
   return future;
@@ -818,8 +842,8 @@ analytics_index_manager::replace_link(const management::analytics_link& link,
 }
 
 void
-analytics_index_manager::drop_link(std::string link_name,
-                                   std::string dataverse_name,
+analytics_index_manager::drop_link(const std::string& link_name,
+                                   const std::string& dataverse_name,
                                    const drop_link_analytics_options& options,
                                    drop_link_analytics_handler&& handler) const
 {
@@ -827,14 +851,14 @@ analytics_index_manager::drop_link(std::string link_name,
 }
 
 auto
-analytics_index_manager::drop_link(std::string link_name,
-                                   std::string dataverse_name,
+analytics_index_manager::drop_link(const std::string& link_name,
+                                   const std::string& dataverse_name,
                                    const drop_link_analytics_options& options) const
   -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
-  drop_link(std::move(link_name), std::move(dataverse_name), options, [barrier](auto err) mutable {
+  drop_link(link_name, dataverse_name, options, [barrier](auto err) mutable {
     barrier->set_value({ std::move(err) });
   });
   return future;

data/ext/couchbase/core/impl/best_effort_retry_strategy.cxx

@@ -17,9 +17,20 @@
 
 #include <couchbase/best_effort_retry_strategy.hxx>
 
-#include <fmt/core.h>
+#include <couchbase/retry_action.hxx>
+#include <couchbase/retry_reason.hxx>
+#include <couchbase/retry_request.hxx>
 
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <chrono>
 #include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace couchbase
 {
@@ -69,12 +80,7 @@ exponential_backoff(std::chrono::milliseconds min_backoff,
 
   return [min, max, factor](std::size_t retry_attempts) {
     double backoff = min * std::pow(factor, static_cast<double>(retry_attempts));
-    if (backoff > max) {
-      backoff = max;
-    }
-    if (backoff < min) {
-      backoff = min;
-    }
+    backoff = std::max(std::min(backoff, max), min);
     return std::chrono::milliseconds(static_cast<std::uint64_t>(backoff));
   };
 }