couchbase 3.5.3 → 3.5.5

data/ext/couchbase/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

data/ext/couchbase/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

data/ext/couchbase/core/key_value_config.cxx

@@ -15,8 +15,8 @@
 
 #include "key_value_config.hxx"
 
-#include <fmt/chrono.h>
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 namespace couchbase::core
 {

data/ext/couchbase/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
    */

data/ext/couchbase/core/logger/custom_rotating_file_sink.cxx

@@ -24,11 +24,14 @@
 
 #include "core/platform/dirutils.h"
 
+#include <algorithm>
 #include <gsl/assert>
 #include <memory>
 #include <spdlog/details/file_helper.h>
 
-static auto
+namespace
+{
+auto
 find_first_logfile_id(const std::string& basename) -> unsigned long
 {
   unsigned long id = 0;
@@ -46,10 +49,8 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
     index = file.rfind('.');
     if (index != std::string::npos) {
       try {
-        unsigned long value = std::stoul(file.substr(index + 1));
-        if (value > id) {
-          id = value;
-        }
+        const unsigned long value = std::stoul(file.substr(index + 1));
+        id = std::max(value, id);
       } catch (const std::invalid_argument&) {
         continue; /* ignore */
       } catch (const std::out_of_range&) {
@@ -60,19 +61,20 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
 
   return id;
 }
+} // namespace
 
 template<class Mutex>
 custom_rotating_file_sink<Mutex>::custom_rotating_file_sink(const spdlog::filename_t& base_filename,
                                                             std::size_t max_size,
                                                             const std::string& log_pattern)
-  : base_filename_(base_filename)
-  , max_size_(max_size)
-  , next_file_id_(find_first_logfile_id(base_filename))
+  : base_filename_{ base_filename }
+  , max_size_{ max_size }
+  , file_helper_{ open_file() }
+  , current_size_{ file_helper_->size() } // expensive. called only once
+  , formatter{ std::make_unique<spdlog::pattern_formatter>(log_pattern,
+                                                           spdlog::pattern_time_type::local) }
+  , next_file_id_{ find_first_logfile_id(base_filename) }
 {
-  formatter =
-    std::make_unique<spdlog::pattern_formatter>(log_pattern, spdlog::pattern_time_type::local);
-  file_helper_ = open_file();
-  current_size_ = file_helper_->size(); // expensive. called only once
   add_hook(opening_log_file_);
 }
 

data/ext/couchbase/core/logger/custom_rotating_file_sink.hxx

@@ -65,8 +65,8 @@ private:
 
   const spdlog::filename_t base_filename_;
   const std::size_t max_size_;
-  std::size_t current_size_{ 0 };
   std::unique_ptr<spdlog::details::file_helper> file_helper_;
+  std::size_t current_size_{ 0 };
   std::unique_ptr<spdlog::pattern_formatter> formatter;
   unsigned long next_file_id_;