couchbase 3.0.1 → 3.0.2

data/ext/couchbase/operations/document_query.hxx

@@ -196,7 +196,7 @@ struct query_request {
     std::optional<http_context> ctx_{};
     bool extract_encoded_plan_{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context& context)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context)
     {
         ctx_.emplace(context);
         tao::json::value body{};
@@ -324,11 +324,12 @@ struct query_request {
         } else {
             spdlog::debug("QUERY: prep={}, {}", tao::json::to_string(prep), tao::json::to_string(stmt));
         }
+        return {};
     }
 };
 
 query_response
-make_response(std::error_code ec, query_request& request, query_request::encoded_response_type encoded)
+make_response(std::error_code ec, query_request& request, query_request::encoded_response_type&& encoded)
 {
     query_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/document_remove.hxx

@@ -39,24 +39,27 @@ struct remove_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
+    uint64_t cas{ 0 };
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
+        encoded.cas(cas);
         encoded.body().id(id);
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        return {};
     }
 };
 
 remove_response
-make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type encoded)
+make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type&& encoded)
 {
     remove_response response{ request.id, encoded.opaque(), ec };
     if (ec && response.opaque == 0) {

data/ext/couchbase/operations/document_replace.hxx

@@ -49,7 +49,7 @@ struct replace_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -61,11 +61,12 @@ struct replace_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        return {};
     }
 };
 
 replace_response
-make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type encoded)
+make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type&& encoded)
 {
     replace_response response{ request.id, encoded.opaque(), ec };
     if (ec && response.opaque == 0) {

data/ext/couchbase/operations/document_search.hxx

@@ -128,7 +128,7 @@ struct search_request {
 
     std::map<std::string, tao::json::value> raw{};
 
-    void encode_to(encoded_request_type& encoded, http_context& context)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context)
     {
         tao::json::value body{
             { "query", query },
@@ -201,11 +201,12 @@ struct search_request {
         } else {
             spdlog::debug("SEARCH: {}", tao::json::to_string(body["query"]));
         }
+        return {};
     }
 };
 
 search_response
-make_response(std::error_code ec, search_request& request, search_request::encoded_response_type encoded)
+make_response(std::error_code ec, search_request& request, search_request::encoded_response_type&& encoded)
 {
     search_response response{ ec };
     response.meta_data.client_context_id = request.client_context_id;

data/ext/couchbase/operations/document_touch.hxx

@@ -42,17 +42,18 @@ struct touch_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
         encoded.body().expiry(expiry);
+        return {};
     }
 };
 
 touch_response
-make_response(std::error_code ec, touch_request& request, touch_request::encoded_response_type encoded)
+make_response(std::error_code ec, touch_request& request, touch_request::encoded_response_type&& encoded)
 {
     touch_response response{ request.id, encoded.opaque(), ec };
     if (ec && response.opaque == 0) {

data/ext/couchbase/operations/document_unlock.hxx

@@ -42,17 +42,18 @@ struct unlock_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
         encoded.cas(cas);
+        return {};
     }
 };
 
 unlock_response
-make_response(std::error_code ec, unlock_request& request, unlock_request::encoded_response_type encoded)
+make_response(std::error_code ec, unlock_request& request, unlock_request::encoded_response_type&& encoded)
 {
     unlock_response response{ request.id, encoded.opaque(), ec };
     if (ec && response.opaque == 0) {

data/ext/couchbase/operations/document_upsert.hxx

@@ -48,7 +48,7 @@ struct upsert_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -59,11 +59,12 @@ struct upsert_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        return {};
     }
 };
 
 upsert_response
-make_response(std::error_code ec, upsert_request& request, upsert_request::encoded_response_type encoded)
+make_response(std::error_code ec, upsert_request& request, upsert_request::encoded_response_type&& encoded)
 {
     upsert_response response{ request.id, encoded.opaque(), ec };
     if (ec && response.opaque == 0) {

data/ext/couchbase/operations/document_view.hxx

@@ -89,7 +89,7 @@ struct document_view_request {
     enum class sort_order { ascending, descending };
     std::optional<sort_order> order;
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::vector<std::string> query_string;
 
@@ -172,11 +172,12 @@ struct document_view_request {
                                    view_name,
                                    fmt::join(query_string, "&"));
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 document_view_response
-make_response(std::error_code ec, document_view_request& request, document_view_request::encoded_response_type encoded)
+make_response(std::error_code ec, document_view_request& request, document_view_request::encoded_response_type&& encoded)
 {
     document_view_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/group_drop.hxx

@@ -42,15 +42,16 @@ struct group_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, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/settings/rbac/groups/{}", name);
+        return {};
     }
 };
 
 group_drop_response
-make_response(std::error_code ec, group_drop_request& request, group_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, group_drop_request& request, group_drop_request::encoded_response_type&& encoded)
 {
     group_drop_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/group_get.hxx

@@ -43,16 +43,17 @@ struct group_get_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, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/settings/rbac/groups/{}", name);
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        return {};
     }
 };
 
 group_get_response
-make_response(std::error_code ec, group_get_request& request, group_get_request::encoded_response_type encoded)
+make_response(std::error_code ec, group_get_request& request, group_get_request::encoded_response_type&& encoded)
 {
     group_get_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/group_get_all.hxx

@@ -42,16 +42,17 @@ struct group_get_all_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, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/settings/rbac/groups");
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        return {};
     }
 };
 
 group_get_all_response
-make_response(std::error_code ec, group_get_all_request& request, group_get_all_request::encoded_response_type encoded)
+make_response(std::error_code ec, group_get_all_request& request, group_get_all_request::encoded_response_type&& encoded)
 {
     group_get_all_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/group_upsert.hxx

@@ -47,7 +47,7 @@ struct group_upsert_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, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "PUT";
         encoded.path = fmt::format("/settings/rbac/groups/{}", group.name);
@@ -86,11 +86,12 @@ struct group_upsert_request {
         }
         encoded.body = fmt::format("{}", fmt::join(params, "&"));
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        return {};
     }
 };
 
 group_upsert_response
-make_response(std::error_code ec, group_upsert_request& request, group_upsert_request::encoded_response_type encoded)
+make_response(std::error_code ec, group_upsert_request& request, group_upsert_request::encoded_response_type&& encoded)
 {
     group_upsert_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/http_noop.hxx

@@ -0,0 +1,78 @@
+/* -*- 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 <tao/json.hpp>
+
+#include <version.hxx>
+
+namespace couchbase::operations
+{
+struct http_noop_response {
+    std::string client_context_id;
+    std::error_code ec;
+    uint32_t status_code;
+};
+
+struct http_noop_request {
+    using response_type = http_noop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    service_type type;
+    std::chrono::milliseconds timeout;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    {
+        encoded.headers["connection"] = "keep-alive";
+        encoded.method = "GET";
+        switch (type) {
+            case service_type::query:
+                timeout = timeout_defaults::query_timeout;
+                encoded.path = "/admin/ping";
+                break;
+            case service_type::analytics:
+                timeout = timeout_defaults::analytics_timeout;
+                encoded.path = "/admin/ping";
+                break;
+            case service_type::search:
+                timeout = timeout_defaults::search_timeout;
+                encoded.path = "/api/ping";
+                break;
+            case service_type::views:
+                timeout = timeout_defaults::view_timeout;
+                encoded.path = "/";
+                break;
+            case service_type::management:
+            case service_type::kv:
+                return std::make_error_code(error::common_errc::feature_not_available);
+        }
+        return {};
+    }
+};
+
+http_noop_response
+make_response(std::error_code ec, http_noop_request& request, http_noop_request::encoded_response_type&& encoded)
+{
+    http_noop_response response{ request.client_context_id, ec, encoded.status_code };
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/mcbp_noop.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 <document_id.hxx>
+#include <protocol/cmd_noop.hxx>
+#include <io/retry_context.hxx>
+
+namespace couchbase::operations
+{
+
+struct mcbp_noop_response {
+    std::uint32_t opaque;
+    std::error_code ec{};
+    std::chrono::steady_clock::time_point start{};
+    std::chrono::steady_clock::time_point stop{};
+};
+
+struct mcbp_noop_request {
+    using encoded_request_type = protocol::client_request<protocol::mcbp_noop_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::mcbp_noop_response_body>;
+
+    uint16_t partition{};
+    uint32_t opaque{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ true };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        return {};
+    }
+};
+
+mcbp_noop_response
+make_response(std::error_code ec, mcbp_noop_request& request, mcbp_noop_request::encoded_response_type&& encoded)
+{
+    mcbp_noop_response response{ encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_build_deferred.hxx

@@ -45,7 +45,7 @@ struct query_index_build_deferred_request {
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value body{
@@ -58,13 +58,14 @@ struct query_index_build_deferred_request {
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 query_index_build_deferred_response
 make_response(std::error_code ec,
               query_index_build_deferred_request& request,
-              query_index_build_deferred_request::encoded_response_type encoded)
+              query_index_build_deferred_request::encoded_response_type&& encoded)
 {
     query_index_build_deferred_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/query_index_create.hxx

@@ -55,7 +55,7 @@ struct query_index_create_request {
     std::optional<int> num_replicas{};
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value with{};
@@ -95,11 +95,12 @@ struct query_index_create_request {
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 query_index_create_response
-make_response(std::error_code ec, query_index_create_request& request, query_index_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, query_index_create_request& request, query_index_create_request::encoded_response_type&& encoded)
 {
     query_index_create_response response{ request.client_context_id, ec };
     if (!ec) {