couchbase 4.4.2 → 4.4.3

package/deps/couchbase-cxx-client/core/io/streams.cxx

@@ -0,0 +1,256 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "streams.hxx"
+
+#include "core/platform/uuid.h"
+
+#include <asio.hpp>
+#include <asio/error.hpp>
+#include <asio/ssl.hpp>
+
+namespace couchbase::core::io
+{
+stream_impl::stream_impl(asio::io_context& ctx, bool is_tls)
+  : strand_(asio::make_strand(ctx))
+  , tls_(is_tls)
+  , id_(uuid::to_string(uuid::random()))
+{
+}
+
+auto
+stream_impl::log_prefix() const -> std::string_view
+{
+  return tls_ ? "tls" : "plain";
+}
+
+auto
+stream_impl::id() const -> const std::string&
+{
+  return id_;
+}
+
+plain_stream_impl::plain_stream_impl(asio::io_context& ctx)
+  : stream_impl(ctx, false)
+  , stream_(std::make_shared<asio::ip::tcp::socket>(strand_))
+{
+}
+
+auto
+plain_stream_impl::local_endpoint() const -> asio::ip::tcp::endpoint
+{
+  if (!stream_) {
+    return {};
+  }
+  std::error_code ec;
+  auto res = stream_->local_endpoint(ec);
+  if (ec) {
+    return {};
+  }
+  return res;
+}
+
+auto
+plain_stream_impl::is_open() const -> bool
+{
+  if (stream_) {
+    return stream_->is_open();
+  }
+  return false;
+}
+
+void
+plain_stream_impl::close(utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    return handler(asio::error::bad_descriptor);
+  }
+  return asio::post(strand_, [stream = std::move(stream_), handler = std::move(handler)]() {
+    asio::error_code ec{};
+    stream->shutdown(asio::socket_base::shutdown_both, ec);
+    stream->close(ec);
+    handler(ec);
+  });
+}
+
+void
+plain_stream_impl::set_options()
+{
+  if (!is_open()) {
+    return;
+  }
+  std::error_code ec{};
+  stream_->set_option(asio::ip::tcp::no_delay{ true }, ec);
+  stream_->set_option(asio::socket_base::keep_alive{ true }, ec);
+}
+
+void
+plain_stream_impl::async_connect(
+  const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+  utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    id_ = uuid::to_string(uuid::random());
+    stream_ = std::make_shared<asio::ip::tcp::socket>(strand_);
+  }
+  return stream_->async_connect(endpoint,
+                                [stream = stream_, handler = std::move(handler)](auto ec) {
+                                  return handler(ec);
+                                });
+}
+
+void
+plain_stream_impl::async_write(
+  std::vector<asio::const_buffer>& buffers,
+  utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return asio::async_write(
+    *stream_,
+    buffers,
+    [stream = stream_, handler = std::move(handler)](auto ec, auto bytes_transferred) {
+      return handler(ec, bytes_transferred);
+    });
+}
+
+void
+plain_stream_impl::async_read_some(
+  asio::mutable_buffer buffer,
+  utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return stream_->async_read_some(buffer, std::move(handler));
+}
+
+tls_stream_impl::tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
+  : stream_impl(ctx, true)
+  , tls_(tls)
+  , stream_(
+      std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_),
+                                                                 tls_))
+{
+}
+
+auto
+tls_stream_impl::local_endpoint() const -> asio::ip::tcp::endpoint
+{
+  if (!stream_) {
+    return {};
+  }
+  std::error_code ec;
+  auto res = stream_->lowest_layer().local_endpoint(ec);
+  if (ec) {
+    return {};
+  }
+  return res;
+}
+
+auto
+tls_stream_impl::is_open() const -> bool
+{
+  if (stream_) {
+    return stream_->lowest_layer().is_open();
+  }
+  return false;
+}
+
+void
+tls_stream_impl::close(utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    return handler(asio::error::bad_descriptor);
+  }
+  return asio::post(strand_, [stream = std::move(stream_), handler = std::move(handler)]() {
+    asio::error_code ec{};
+    stream->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
+    stream->lowest_layer().close(ec);
+    handler(ec);
+  });
+}
+
+void
+tls_stream_impl::set_options()
+{
+  if (!is_open()) {
+    return;
+  }
+  std::error_code ec{};
+  stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true }, ec);
+  stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true }, ec);
+}
+
+void
+tls_stream_impl::async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                               utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    id_ = uuid::to_string(uuid::random());
+    stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(
+      asio::ip::tcp::socket(strand_), tls_);
+  }
+  return stream_->lowest_layer().async_connect(
+    endpoint, [stream = stream_, handler = std::move(handler)](std::error_code ec_connect) mutable {
+      if (ec_connect == asio::error::operation_aborted) {
+        return;
+      }
+      if (ec_connect) {
+        return handler(ec_connect);
+      }
+      stream->async_handshake(
+        asio::ssl::stream_base::client,
+        [stream, handler = std::move(handler)](std::error_code ec_handshake) mutable {
+          if (ec_handshake == asio::error::operation_aborted) {
+            return;
+          }
+          return handler(ec_handshake);
+        });
+    });
+}
+
+void
+tls_stream_impl::async_write(std::vector<asio::const_buffer>& buffers,
+                             utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return asio::async_write(
+    *stream_,
+    buffers,
+    [stream = stream_, handler = std::move(handler)](auto ec, auto bytes_transferred) {
+      return handler(ec, bytes_transferred);
+    });
+}
+
+void
+tls_stream_impl::async_read_some(
+  asio::mutable_buffer buffer,
+  utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return stream_->async_read_some(
+    buffer, [stream = stream_, handler = std::move(handler)](auto ec, auto bytes_transferred) {
+      return handler(ec, bytes_transferred);
+    });
+}
+} // namespace couchbase::core::io

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

@@ -20,10 +20,15 @@
 #include "core/utils/movable_function.hxx"
 #include "ip_protocol.hxx"
 
-#include <asio.hpp>
-#include <asio/ssl.hpp>
+#include <asio/error.hpp>
+#include <asio/io_context.hpp>
+#include <asio/ip/tcp.hpp>
+#include <asio/ssl/context.hpp>
+#include <asio/ssl/stream.hpp>
+#include <asio/strand.hpp>
 
-#include <functional>
+#include <string>
+#include <vector>
 
 namespace couchbase::core::io
 {
@@ -59,43 +64,26 @@ protected:
   asio::strand<asio::io_context::executor_type> strand_;
   bool tls_;
   std::string id_{};
-  std::atomic_bool open_{ false };
 
 public:
-  stream_impl(asio::io_context& ctx, bool is_tls)
-    : strand_(asio::make_strand(ctx))
-    , tls_(is_tls)
-    , id_(uuid::to_string(uuid::random()))
-  {
-  }
+  stream_impl(asio::io_context& ctx, bool is_tls);
 
   virtual ~stream_impl() = default;
 
-  [[nodiscard]] auto log_prefix() const -> std::string_view
-  {
-    return tls_ ? "tls" : "plain";
-  }
-
-  [[nodiscard]] auto id() const -> const std::string&
-  {
-    return id_;
-  }
+  [[nodiscard]] auto log_prefix() const -> std::string_view;
 
-  [[nodiscard]] auto is_open() const -> bool
-  {
-    return open_;
-  }
+  [[nodiscard]] auto id() const -> const std::string&;
 
-  auto get_executor() const noexcept
+  [[nodiscard]] auto get_executor() const noexcept
   {
     return strand_;
   }
 
   [[nodiscard]] virtual auto local_endpoint() const -> asio::ip::tcp::endpoint = 0;
 
-  virtual void close(utils::movable_function<void(std::error_code)>&& handler) = 0;
+  [[nodiscard]] virtual auto is_open() const -> bool = 0;
 
-  virtual void reopen() = 0;
+  virtual void close(utils::movable_function<void(std::error_code)>&& handler) = 0;
 
   virtual void set_options() = 0;
 
@@ -117,165 +105,53 @@ private:
   std::shared_ptr<asio::ip::tcp::socket> stream_;
 
 public:
-  explicit plain_stream_impl(asio::io_context& ctx)
-    : stream_impl(ctx, false)
-    , stream_(std::make_shared<asio::ip::tcp::socket>(strand_))
-  {
-  }
+  explicit plain_stream_impl(asio::io_context& ctx);
 
-  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override
-  {
-    std::error_code ec;
-    auto res = stream_->local_endpoint(ec);
-    if (ec) {
-      return {};
-    }
-    return res;
-  }
+  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override;
 
-  void close(utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    open_ = false;
-    return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
-      asio::error_code ec{};
-      stream->shutdown(asio::socket_base::shutdown_both, ec);
-      stream->close(ec);
-      h(ec);
-    });
-  }
+  [[nodiscard]] auto is_open() const -> bool override;
 
-  void reopen() override
-  {
-    return close([this](std::error_code) {
-      id_ = uuid::to_string(uuid::random());
-      stream_ = std::make_shared<asio::ip::tcp::socket>(strand_);
-    });
-  }
+  void close(utils::movable_function<void(std::error_code)>&& handler) override;
 
-  void set_options() override
-  {
-    if (!open_ || !stream_) {
-      return;
-    }
-    std::error_code ec{};
-    stream_->set_option(asio::ip::tcp::no_delay{ true }, ec);
-    stream_->set_option(asio::socket_base::keep_alive{ true }, ec);
-  }
+  void set_options() override;
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    return stream_->async_connect(endpoint, [this, h = std::move(handler)](std::error_code ec) {
-      open_ = stream_->is_open();
-      h(ec);
-    });
-  }
+                     utils::movable_function<void(std::error_code)>&& handler) override;
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return asio::async_write(*stream_, buffers, std::move(handler));
-  }
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 
   void async_read_some(
     asio::mutable_buffer buffer,
-    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return stream_->async_read_some(buffer, std::move(handler));
-  }
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 };
 
 class tls_stream_impl : public stream_impl
 {
 private:
-  std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
   asio::ssl::context& tls_;
+  std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
 
 public:
-  tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
-    : stream_impl(ctx, true)
-    , stream_(
-        std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_),
-                                                                   tls))
-    , tls_(tls)
-  {
-  }
+  tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls);
 
-  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override
-  {
-    std::error_code ec;
-    auto res = stream_->lowest_layer().local_endpoint(ec);
-    if (ec) {
-      return {};
-    }
-    return res;
-  }
+  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override;
 
-  void close(utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    open_ = false;
-    return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
-      asio::error_code ec{};
-      stream->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
-      stream->lowest_layer().close(ec);
-      h(ec);
-    });
-  }
+  [[nodiscard]] auto is_open() const -> bool override;
 
-  void reopen() override
-  {
-    return close([this](std::error_code) {
-      id_ = uuid::to_string(uuid::random());
-      stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(
-        asio::ip::tcp::socket(strand_), tls_);
-    });
-  }
+  void close(utils::movable_function<void(std::error_code)>&& handler) override;
 
-  void set_options() override
-  {
-    if (!open_ || !stream_) {
-      return;
-    }
-    std::error_code ec{};
-    stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true }, ec);
-    stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true }, ec);
-  }
+  void set_options() override;
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    return stream_->lowest_layer().async_connect(
-      endpoint, [this, handler = std::move(handler)](std::error_code ec_connect) mutable {
-        if (ec_connect == asio::error::operation_aborted) {
-          return;
-        }
-        if (ec_connect) {
-          return handler(ec_connect);
-        }
-        open_ = stream_->lowest_layer().is_open();
-        stream_->async_handshake(
-          asio::ssl::stream_base::client,
-          [handler = std::move(handler)](std::error_code ec_handshake) mutable {
-            if (ec_handshake == asio::error::operation_aborted) {
-              return;
-            }
-            return handler(ec_handshake);
-          });
-      });
-  }
+                     utils::movable_function<void(std::error_code)>&& handler) override;
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return asio::async_write(*stream_, buffers, std::move(handler));
-  }
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 
   void async_read_some(
     asio::mutable_buffer buffer,
-    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return stream_->async_read_some(buffer, std::move(handler));
-  }
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 };
 
 } // namespace couchbase::core::io

package/deps/couchbase-cxx-client/core/logger/configuration.hxx

@@ -51,6 +51,11 @@ struct configuration {
    */
   level log_level{ level::info };
 
+  /**
+   * The default log level for console sink
+   */
+  level console_sink_log_level{ level::trace };
+
   /**
    * Custom sink to use, if desired
    */

package/deps/couchbase-cxx-client/core/logger/custom_rotating_file_sink.cxx

@@ -24,6 +24,7 @@
 
 #include "core/platform/dirutils.h"
 
+#include <algorithm>
 #include <gsl/assert>
 #include <memory>
 #include <spdlog/details/file_helper.h>
@@ -49,9 +50,7 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
     if (index != std::string::npos) {
       try {
         const unsigned long value = std::stoul(file.substr(index + 1));
-        if (value > id) {
-          id = value;
-        }
+        id = std::max(value, id);
       } catch (const std::invalid_argument&) {
         continue; /* ignore */
       } catch (const std::out_of_range&) {

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

@@ -25,6 +25,7 @@
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <memory>
@@ -77,8 +78,10 @@ update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
   const std::scoped_lock lock(file_logger_mutex);
   // delete if already exists
   spdlog::drop(file_logger_name);
-  file_logger = new_logger;
-  spdlog::register_logger(new_logger);
+  if (new_logger) {
+    file_logger = new_logger;
+    spdlog::register_logger(new_logger);
+  }
   ++file_logger_version;
 }
 
@@ -112,6 +115,28 @@ translate_level(level level) -> spdlog::level::level_enum
   return spdlog::level::level_enum::trace;
 }
 
+auto
+translate_level(spdlog::level::level_enum spdlog_level) -> level
+{
+  switch (spdlog_level) {
+    case spdlog::level::level_enum::trace:
+      return level::trace;
+    case spdlog::level::debug:
+      return level::debug;
+    case spdlog::level::info:
+      return level::info;
+    case spdlog::level::warn:
+      return level::warn;
+    case spdlog::level::err:
+      return level::err;
+    case spdlog::level::critical:
+      return level::critical;
+    default:
+      break;
+  }
+  return level::off;
+}
+
 auto
 level_from_str(const std::string& str) -> level
 {
@@ -248,11 +273,7 @@ create_file_logger_impl(const std::string& logger_name, const configuration& log
 
       // Set the formatting pattern of this sink
       stderrsink->set_pattern(log_pattern);
-      if (logger_settings.unit_test) {
-        stderrsink->set_level(spdlog::level::trace);
-      } else {
-        stderrsink->set_level(spdlog::level::err);
-      }
+      stderrsink->set_level(translate_level(logger_settings.console_sink_log_level));
       sink->add_sink(stderrsink);
     }
     if (nullptr != logger_settings.sink) {
@@ -410,6 +431,17 @@ check_log_levels(level lvl) -> bool
   return correct;
 }
 
+auto
+get_lowest_log_level() -> level
+{
+  auto lowest = spdlog::level::off;
+  // Apply the function to each registered spdlog::logger except protocol logger
+  spdlog::apply_all([&lowest](const std::shared_ptr<spdlog::logger>& l) {
+    lowest = std::min(l->level(), lowest);
+  });
+  return translate_level(lowest);
+}
+
 void
 set_log_levels(level lvl)
 {

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

@@ -148,6 +148,13 @@ check_log_levels(level lvl) -> bool;
 void
 set_log_levels(level lvl);
 
+/**
+ * Get the lowest (most verbose) level among the registered loggers
+ * @return log severity level
+ */
+auto
+get_lowest_log_level() -> level;
+
 /**
  * Checks whether a specific level should be logged based on the current
  * configuration.