couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/couchbase/io/query_cache.hxx

@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <map>
+#include <string>
+#include <optional>
+#include <mutex>
+
+namespace couchbase
+{
+class query_cache
+{
+  public:
+    struct entry {
+        std::string name;
+        std::optional<std::string> plan{};
+    };
+
+    void put(const std::string& statement, const std::string& prepared)
+    {
+        std::scoped_lock lock(store_mutex_);
+        store_.emplace(statement, entry{ prepared });
+    }
+
+    void put(const std::string& statement, const std::string& name, const std::string& encoded_plan)
+    {
+        std::scoped_lock lock(store_mutex_);
+        store_.emplace(statement, entry{ name, encoded_plan });
+    }
+
+    std::optional<entry> get(const std::string& statement)
+    {
+        std::scoped_lock lock(store_mutex_);
+        auto it = store_.find(statement);
+        if (it == store_.end()) {
+            return {};
+        }
+        return it->second;
+    }
+
+  private:
+    std::map<std::string, entry> store_;
+    std::mutex store_mutex_{};
+};
+} // namespace couchbase

data/ext/couchbase/io/retry_context.hxx

@@ -27,8 +27,7 @@ namespace couchbase::io
 {
 
 template<class RetryStrategy>
-struct retry_context
-{
+struct retry_context {
     bool idempotent;
     int retry_attempts{ 0 };
     std::chrono::milliseconds last_duration{ 0 };

data/ext/couchbase/io/retry_orchestrator.hxx

@@ -73,6 +73,13 @@ retry_with_duration(std::shared_ptr<Manager> manager,
     ++command->request.retries.retry_attempts;
     command->request.retries.reasons.insert(reason);
     command->request.retries.last_duration = duration;
+    spdlog::trace(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}))",
+                  manager->log_prefix(),
+                  decltype(command->request)::encoded_request_type::body_type::opcode,
+                  duration.count(),
+                  command->id_,
+                  reason,
+                  command->request.retries.retry_attempts);
     manager->schedule_for_retry(command, duration);
 }
 
@@ -90,6 +97,15 @@ maybe_retry(std::shared_ptr<Manager> manager, std::shared_ptr<Command> command,
     if (action.retry_requested) {
         return priv::retry_with_duration(manager, command, reason, priv::cap_duration(action.duration, command));
     }
+
+    spdlog::trace(R"({} not retrying operation {} (id="{}", reason={}, attempts={}, ec={} ({})))",
+                  manager->log_prefix(),
+                  decltype(command->request)::encoded_request_type::body_type::opcode,
+                  command->id_,
+                  reason,
+                  command->request.retries.retry_attempts,
+                  ec.value(),
+                  ec.message());
     return command->invoke_handler(ec);
 }
 

data/ext/couchbase/io/retry_strategy.hxx

@@ -106,7 +106,7 @@ class exponential
             if (previous_backoff >= max_backoff_) {
                 next_backoff = max_backoff_;
             } else {
-                next_backoff = first_backoff_ * static_cast<int>(std::pow(factor_, request.retries.retry_attempts - 1));
+                next_backoff = first_backoff_ * static_cast<int>(std::pow(factor_, request.retries.retry_attempts));
             }
         }
         return { next_backoff, first_backoff_, max_backoff_ };

data/ext/couchbase/io/streams.hxx

@@ -30,11 +30,13 @@ class stream_impl
   protected:
     asio::strand<asio::io_context::executor_type> strand_;
     bool tls_;
+    std::string id_{};
 
   public:
     stream_impl(asio::io_context& ctx, bool is_tls)
       : strand_(asio::make_strand(ctx))
       , tls_(is_tls)
+      , id_(uuid::to_string(uuid::random()))
     {
     }
 
@@ -45,10 +47,19 @@ class stream_impl
         return tls_ ? "tls" : "plain";
     }
 
+    [[nodiscard]] const std::string& id() const
+    {
+        return id_;
+    }
+
     [[nodiscard]] virtual bool is_open() const = 0;
 
+    [[nodiscard]] virtual asio::ip::tcp::endpoint local_endpoint() const = 0;
+
     virtual void close() = 0;
 
+    virtual void reopen() = 0;
+
     virtual void set_options() = 0;
 
     virtual void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
@@ -76,11 +87,30 @@ class plain_stream_impl : public stream_impl
         return stream_.is_open();
     }
 
+    [[nodiscard]] virtual asio::ip::tcp::endpoint local_endpoint() const override
+    {
+        std::error_code ec;
+        auto res = stream_.local_endpoint(ec);
+        if (ec) {
+            return {};
+        }
+        return res;
+    }
+
     void close() override
     {
         stream_.close();
     }
 
+    void reopen() override
+    {
+        id_ = uuid::to_string(uuid::random());
+        asio::error_code ec{};
+        stream_.shutdown(asio::socket_base::shutdown_both, ec);
+        stream_.close(ec);
+        stream_ = asio::ip::tcp::socket(strand_);
+    }
+
     void set_options() override
     {
         stream_.set_option(asio::ip::tcp::no_delay{ true });
@@ -107,42 +137,63 @@ class plain_stream_impl : public stream_impl
 class tls_stream_impl : public stream_impl
 {
   private:
-    asio::ssl::stream<asio::ip::tcp::socket> stream_;
+    std::unique_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
+    asio::ssl::context& tls_;
 
   public:
     tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
       : stream_impl(ctx, true)
-      , stream_(ctx, tls)
+      , stream_(std::make_unique<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_), tls))
+      , tls_(tls)
     {
     }
 
     [[nodiscard]] bool is_open() const override
     {
-        return stream_.lowest_layer().is_open();
+        return stream_->lowest_layer().is_open();
+    }
+
+    [[nodiscard]] virtual asio::ip::tcp::endpoint local_endpoint() const override
+    {
+        std::error_code ec;
+        auto res = stream_->lowest_layer().local_endpoint(ec);
+        if (ec) {
+            return {};
+        }
+        return res;
     }
 
     void close() override
     {
-        stream_.lowest_layer().close();
+        stream_->lowest_layer().close();
+    }
+
+    void reopen() override
+    {
+        id_ = uuid::to_string(uuid::random());
+        asio::error_code ec{};
+        stream_->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
+        stream_->lowest_layer().close(ec);
+        stream_ = std::make_unique<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_), tls_);
     }
 
     void set_options() override
     {
-        stream_.lowest_layer().set_option(asio::ip::tcp::no_delay{ true });
-        stream_.lowest_layer().set_option(asio::socket_base::keep_alive{ true });
+        stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true });
+        stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true });
     }
 
     void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
                        std::function<void(std::error_code)>&& handler) override
     {
-        return stream_.lowest_layer().async_connect(endpoint, [this, handler](std::error_code ec_connect) mutable {
+        return stream_->lowest_layer().async_connect(endpoint, [this, 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, [handler](std::error_code ec_handshake) mutable {
+            stream_->async_handshake(asio::ssl::stream_base::client, [handler](std::error_code ec_handshake) mutable {
                 if (ec_handshake == asio::error::operation_aborted) {
                     return;
                 }
@@ -153,12 +204,12 @@ class tls_stream_impl : public stream_impl
 
     void async_write(std::vector<asio::const_buffer>& buffers, std::function<void(std::error_code, std::size_t)>&& handler) override
     {
-        return asio::async_write(stream_, buffers, handler);
+        return asio::async_write(*stream_, buffers, handler);
     }
 
     void async_read_some(asio::mutable_buffer buffer, std::function<void(std::error_code, std::size_t)>&& handler) override
     {
-        return stream_.async_read_some(buffer, handler);
+        return stream_->async_read_some(buffer, handler);
     }
 };
 

data/ext/couchbase/operations.hxx

@@ -48,6 +48,16 @@
 #include <operations/bucket_create.hxx>
 #include <operations/bucket_update.hxx>
 
+#include <operations/role_get_all.hxx>
+#include <operations/user_get_all.hxx>
+#include <operations/user_get.hxx>
+#include <operations/user_drop.hxx>
+#include <operations/user_upsert.hxx>
+#include <operations/group_get_all.hxx>
+#include <operations/group_get.hxx>
+#include <operations/group_drop.hxx>
+#include <operations/group_upsert.hxx>
+
 #include <operations/scope_get_all.hxx>
 #include <operations/scope_create.hxx>
 #include <operations/scope_drop.hxx>
@@ -55,14 +65,17 @@
 #include <operations/collection_drop.hxx>
 
 #include <operations/cluster_developer_preview_enable.hxx>
+#include <operations/collections_manifest_get.hxx>
 
 #include <operations/query_index_get_all.hxx>
 #include <operations/query_index_drop.hxx>
 #include <operations/query_index_create.hxx>
 #include <operations/query_index_build_deferred.hxx>
 
+#include <operations/search_get_stats.hxx>
 #include <operations/search_index_get_all.hxx>
 #include <operations/search_index_get.hxx>
+#include <operations/search_index_get_stats.hxx>
 #include <operations/search_index_get_documents_count.hxx>
 #include <operations/search_index_upsert.hxx>
 #include <operations/search_index_drop.hxx>

data/ext/couchbase/operations/analytics_dataset_create.hxx

@@ -53,7 +53,7 @@ struct analytics_dataset_create_request {
 
     bool ignore_if_exists{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string where_clause = condition ? fmt::format("WHERE {}", *condition) : "";
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";

data/ext/couchbase/operations/analytics_dataset_drop.hxx

@@ -50,7 +50,7 @@ struct analytics_dataset_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 

data/ext/couchbase/operations/analytics_dataset_get_all.hxx

@@ -53,7 +53,7 @@ struct analytics_dataset_get_all_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body{
             { "statement", "SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> \"Metadata\"" },

data/ext/couchbase/operations/analytics_dataverse_create.hxx

@@ -49,7 +49,7 @@ struct analytics_dataverse_create_request {
 
     bool ignore_if_exists{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
 

data/ext/couchbase/operations/analytics_dataverse_drop.hxx

@@ -49,7 +49,7 @@ struct analytics_dataverse_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 

data/ext/couchbase/operations/analytics_get_pending_mutations.hxx

@@ -46,7 +46,7 @@ struct analytics_get_pending_mutations_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = "/analytics/node/agg/stats/remaining";

data/ext/couchbase/operations/analytics_index_create.hxx

@@ -52,7 +52,7 @@ struct analytics_index_create_request {
 
     bool ignore_if_exists{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
         std::vector<std::string> field_specs;

data/ext/couchbase/operations/analytics_index_drop.hxx

@@ -51,7 +51,7 @@ struct analytics_index_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 

data/ext/couchbase/operations/analytics_index_get_all.hxx

@@ -53,7 +53,7 @@ struct analytics_index_get_all_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body{
             { "statement", "SELECT d.* FROM Metadata.`Index` d WHERE d.DataverseName <> \"Metadata\"" },

data/ext/couchbase/operations/analytics_link_connect.hxx

@@ -49,7 +49,7 @@ struct analytics_link_connect_request {
     std::string link_name;
     bool force{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string with_clause = force ? "WITH {\"force\": true}" : "";
 

data/ext/couchbase/operations/analytics_link_disconnect.hxx

@@ -48,7 +48,7 @@ struct analytics_link_disconnect_request {
     std::string dataverse_name{ "Default" };
     std::string link_name;
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body{
             { "statement", fmt::format("DISCONNECT LINK `{}`.`{}`", dataverse_name, link_name) },

data/ext/couchbase/operations/bucket_create.hxx

@@ -43,7 +43,7 @@ struct bucket_create_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets");
@@ -68,14 +68,20 @@ struct bucket_create_request {
         encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
         encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
         encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
-        switch (bucket.ejection_policy) {
-            case bucket_settings::ejection_policy::full:
+        switch (bucket.eviction_policy) {
+            case bucket_settings::eviction_policy::full:
                 encoded.body.append("&evictionPolicy=fullEviction");
                 break;
-            case bucket_settings::ejection_policy::value_only:
+            case bucket_settings::eviction_policy::value_only:
                 encoded.body.append("&evictionPolicy=valueOnly");
                 break;
-            case bucket_settings::ejection_policy::unknown:
+            case bucket_settings::eviction_policy::no_eviction:
+                encoded.body.append("&evictionPolicy=noEviction");
+                break;
+            case bucket_settings::eviction_policy::not_recently_used:
+                encoded.body.append("&evictionPolicy=nruEviction");
+                break;
+            case bucket_settings::eviction_policy::unknown:
                 break;
         }
         switch (bucket.compression_mode) {

data/ext/couchbase/operations/bucket_drop.hxx

@@ -38,7 +38,7 @@ struct bucket_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}", name);