couchbase 3.0.2 → 3.0.3

data/ext/couchbase/operations/document_remove.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct remove_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
 };
@@ -59,17 +57,14 @@ struct remove_request {
 };
 
 remove_response
-make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, remove_request& request, remove_request::encoded_response_type&& encoded)
 {
-    remove_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    remove_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_replace.hxx

@@ -26,9 +26,7 @@ namespace couchbase::operations
 {
 
 struct replace_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
 };
@@ -66,17 +64,14 @@ struct replace_request {
 };
 
 replace_response
-make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, replace_request& request, replace_request::encoded_response_type&& encoded)
 {
-    replace_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    replace_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_search.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 #include <tao/json.hpp>
 
 #include <version.hxx>
+#include <error_context/search.hxx>
 
 namespace couchbase::operations
 {
@@ -87,7 +88,7 @@ struct search_response {
         std::vector<numeric_range_facet> numeric_ranges{};
     };
 
-    std::error_code ec;
+    error_context::search ctx;
     std::string status{};
     search_meta_data meta_data{};
     std::string error{};
@@ -99,6 +100,7 @@ struct search_request {
     using response_type = search_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::search;
 
     static const inline service_type type = service_type::search;
 
@@ -127,10 +129,11 @@ struct search_request {
     std::map<std::string, std::string> facets{};
 
     std::map<std::string, tao::json::value> raw{};
+    std::string body_str{};
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context)
     {
-        tao::json::value body{
+        tao::json::value body = tao::json::value{
             { "query", query },
             { "explain", explain },
             { "ctl", { { "timeout", timeout.count() } } },
@@ -195,7 +198,8 @@ struct search_request {
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/query", index_name);
-        encoded.body = tao::json::to_string(body);
+        body_str = tao::json::to_string(body);
+        encoded.body = body_str;
         if (context.options.show_queries) {
             spdlog::info("SEARCH: {}", tao::json::to_string(body["query"]));
         } else {
@@ -206,13 +210,22 @@ struct search_request {
 };
 
 search_response
-make_response(std::error_code ec, search_request& request, search_request::encoded_response_type&& encoded)
+make_response(error_context::search&& ctx, search_request& request, search_request::encoded_response_type&& encoded)
 {
-    search_response response{ ec };
+    search_response response{ ctx };
     response.meta_data.client_context_id = request.client_context_id;
-    if (!ec) {
+    response.ctx.index_name = request.index_name;
+    response.ctx.query = tao::json::to_string(request.query);
+    response.ctx.parameters = request.body_str;
+    if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
-            auto payload = tao::json::from_string(encoded.body);
+            tao::json::value payload{};
+            try {
+                payload = tao::json::from_string(encoded.body);
+            } catch (tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                return response;
+            }
             response.meta_data.metrics.took = std::chrono::nanoseconds(payload.at("took").get_unsigned());
             response.meta_data.metrics.max_score = payload.at("max_score").as<double>();
             response.meta_data.metrics.total_rows = payload.at("total_hits").get_unsigned();
@@ -232,7 +245,7 @@ make_response(std::error_code ec, search_request& request, search_request::encod
                     }
                 }
             } else {
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 return response;
             }
             const auto* rows = payload.find("hits");
@@ -349,21 +362,29 @@ make_response(std::error_code ec, search_request& request, search_request::encod
             return response;
         }
         if (encoded.status_code == 400) {
-            auto payload = tao::json::from_string(encoded.body);
+            tao::json::value payload{};
+            try {
+                payload = tao::json::from_string(encoded.body);
+            } catch (tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                return response;
+            }
             response.status = payload.at("status").get_string();
             response.error = payload.at("error").get_string();
             if (response.error.find("index not found") != std::string::npos) {
-                response.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
                 return response;
-            } else if (response.error.find("no planPIndexes for indexName") != std::string::npos) {
-                response.ec = std::make_error_code(error::search_errc::index_not_ready);
+            }
+            if (response.error.find("no planPIndexes for indexName") != std::string::npos) {
+                response.ctx.ec = std::make_error_code(error::search_errc::index_not_ready);
                 return response;
-            } else if (response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
-                response.ec = std::make_error_code(error::search_errc::consistency_mismatch);
+            }
+            if (response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
+                response.ctx.ec = std::make_error_code(error::search_errc::consistency_mismatch);
                 return response;
             }
         }
-        response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
     }
     return response;
 }

data/ext/couchbase/operations/document_touch.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct touch_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
 };
 
@@ -53,13 +51,10 @@ struct touch_request {
 };
 
 touch_response
-make_response(std::error_code ec, touch_request& request, touch_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, touch_request&, touch_request::encoded_response_type&& encoded)
 {
-    touch_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    touch_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
     }
     return response;

data/ext/couchbase/operations/document_unlock.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct unlock_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
 };
 
@@ -53,13 +51,10 @@ struct unlock_request {
 };
 
 unlock_response
-make_response(std::error_code ec, unlock_request& request, unlock_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, unlock_request&, unlock_request::encoded_response_type&& encoded)
 {
-    unlock_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    unlock_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
     }
     return response;

data/ext/couchbase/operations/document_upsert.hxx

@@ -26,9 +26,7 @@ namespace couchbase::operations
 {
 
 struct upsert_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
 };
@@ -64,17 +62,14 @@ struct upsert_request {
 };
 
 upsert_response
-make_response(std::error_code ec, upsert_request& request, upsert_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, upsert_request& request, upsert_request::encoded_response_type&& encoded)
 {
-    upsert_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    upsert_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_view.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 #include <tao/json.hpp>
 #include <operations/design_document.hxx>
 #include <utils/url_codec.hxx>
+#include <error_context/view.hxx>
 
 namespace couchbase::operations
 {
@@ -40,8 +41,7 @@ struct document_view_response {
         std::string message;
     };
 
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::view ctx;
     document_view_response::meta_data meta_data{};
     std::vector<document_view_response::row> rows{};
     std::optional<problem> error{};
@@ -51,6 +51,7 @@ struct document_view_request {
     using response_type = document_view_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::view;
 
     static const inline service_type type = service_type::views;
 
@@ -88,11 +89,10 @@ struct document_view_request {
 
     enum class sort_order { ascending, descending };
     std::optional<sort_order> order;
+    std::vector<std::string> query_string{};
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
-        std::vector<std::string> query_string;
-
         if (debug) {
             query_string.emplace_back("debug=true");
         }
@@ -177,12 +177,22 @@ struct document_view_request {
 };
 
 document_view_response
-make_response(std::error_code ec, document_view_request& request, document_view_request::encoded_response_type&& encoded)
+make_response(error_context::view&& ctx, document_view_request& request, document_view_request::encoded_response_type&& encoded)
 {
-    document_view_response response{ request.client_context_id, ec };
-    if (!ec) {
+    document_view_response response{ ctx };
+    response.ctx.client_context_id = request.client_context_id;
+    response.ctx.design_document_name = request.document_name;
+    response.ctx.view_name = request.view_name;
+    response.ctx.query_string = request.query_string;
+    if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
-            tao::json::value payload = tao::json::from_string(encoded.body);
+            tao::json::value payload{};
+            try {
+                payload = tao::json::from_string(encoded.body);
+            } catch (tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                return response;
+            }
             const auto* total_rows = payload.find("total_rows");
             if (total_rows != nullptr && total_rows->is_unsigned()) {
                 response.meta_data.total_rows = total_rows->get_unsigned();
@@ -205,7 +215,13 @@ make_response(std::error_code ec, document_view_request& request, document_view_
                 }
             }
         } else if (encoded.status_code == 400) {
-            tao::json::value payload = tao::json::from_string(encoded.body);
+            tao::json::value payload{};
+            try {
+                payload = tao::json::from_string(encoded.body);
+            } catch (tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                return response;
+            }
             document_view_response::problem problem{};
             const auto* error = payload.find("error");
             if (error != nullptr && error->is_string()) {
@@ -216,11 +232,11 @@ make_response(std::error_code ec, document_view_request& request, document_view_
                 problem.message = reason->get_string();
             }
             response.error.emplace(problem);
-            response.ec = std::make_error_code(error::common_errc::invalid_argument);
+            response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
         } else if (encoded.status_code == 404) {
-            response.ec = std::make_error_code(error::view_errc::design_document_not_found);
+            response.ctx.ec = std::make_error_code(error::view_errc::design_document_not_found);
         } else {
-            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
         }
     }
     return response;

data/ext/couchbase/operations/group_drop.hxx

@@ -27,14 +27,14 @@ namespace couchbase::operations
 {
 
 struct group_drop_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
 };
 
 struct group_drop_request {
     using response_type = group_drop_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
 
@@ -51,18 +51,18 @@ struct group_drop_request {
 };
 
 group_drop_response
-make_response(std::error_code ec, group_drop_request& request, group_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, group_drop_request&, group_drop_request::encoded_response_type&& encoded)
 {
-    group_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
+    group_drop_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
                 break;
             case 404:
-                response.ec = std::make_error_code(error::management_errc::group_not_found);
+                response.ctx.ec = std::make_error_code(error::management_errc::group_not_found);
                 break;
             default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }

data/ext/couchbase/operations/group_get.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct group_get_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     rbac::group group{};
 };
 
@@ -36,6 +35,7 @@ struct group_get_request {
     using response_type = group_get_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
 
@@ -53,20 +53,24 @@ struct group_get_request {
 };
 
 group_get_response
-make_response(std::error_code ec, group_get_request& request, group_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, group_get_request&, group_get_request::encoded_response_type&& encoded)
 {
-    group_get_response response{ request.client_context_id, ec };
-    if (!ec) {
+    group_get_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200: {
-                tao::json::value payload = tao::json::from_string(encoded.body);
-                response.group = payload.as<rbac::group>();
+                try {
+                    response.group = tao::json::from_string(encoded.body).as<rbac::group>();
+                } catch (tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                    return response;
+                }
             } break;
             case 404:
-                response.ec = std::make_error_code(error::management_errc::group_not_found);
+                response.ctx.ec = std::make_error_code(error::management_errc::group_not_found);
                 break;
             default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }