couchbase 3.0.2 → 3.0.3

data/ext/couchbase/operations/group_get_all.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_all_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::vector<rbac::group> groups{};
 };
 
@@ -36,6 +35,7 @@ struct group_get_all_request {
     using response_type = group_get_all_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;
 
@@ -52,17 +52,23 @@ struct group_get_all_request {
 };
 
 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(error_context::http&& ctx, group_get_all_request&, group_get_all_request::encoded_response_type&& encoded)
 {
-    group_get_all_response response{ request.client_context_id, ec };
-    if (!ec) {
+    group_get_all_response response{ ctx };
+    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;
+            }
             for (const auto& entry : payload.get_array()) {
                 response.groups.emplace_back(entry.as<rbac::group>());
             }
         } 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_upsert.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.
@@ -31,8 +31,7 @@ namespace couchbase::operations
 {
 
 struct group_upsert_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::vector<std::string> errors{};
 };
 
@@ -40,6 +39,7 @@ struct group_upsert_request {
     using response_type = group_upsert_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;
 
@@ -91,16 +91,22 @@ struct group_upsert_request {
 };
 
 group_upsert_response
-make_response(std::error_code ec, group_upsert_request& request, group_upsert_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, group_upsert_request&, group_upsert_request::encoded_response_type&& encoded)
 {
-    group_upsert_response response{ request.client_context_id, ec };
-    if (!ec) {
+    group_upsert_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
                 break;
             case 400: {
-                response.ec = std::make_error_code(error::common_errc::invalid_argument);
-                tao::json::value payload = tao::json::from_string(encoded.body);
+                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                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* errors = payload.find("errors");
                 if (errors != nullptr && errors->is_object()) {
                     for (const auto& entry : errors->get_object()) {
@@ -109,7 +115,7 @@ make_response(std::error_code ec, group_upsert_request& request, group_upsert_re
                 }
             } 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/http_noop.hxx

@@ -20,19 +20,19 @@
 #include <tao/json.hpp>
 
 #include <version.hxx>
+#include <error_context/http.hxx>
 
 namespace couchbase::operations
 {
 struct http_noop_response {
-    std::string client_context_id;
-    std::error_code ec;
-    uint32_t status_code;
+    error_context::http ctx;
 };
 
 struct http_noop_request {
     using response_type = http_noop_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     service_type type;
     std::chrono::milliseconds timeout;
@@ -69,9 +69,9 @@ struct http_noop_request {
 };
 
 http_noop_response
-make_response(std::error_code ec, http_noop_request& request, http_noop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, http_noop_request&, http_noop_request::encoded_response_type&&)
 {
-    http_noop_response response{ request.client_context_id, ec, encoded.status_code };
+    http_noop_response response{ ctx };
     return response;
 }
 

data/ext/couchbase/operations/mcbp_noop.hxx

@@ -25,10 +25,7 @@ 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{};
+    error_context::key_value ctx;
 };
 
 struct mcbp_noop_request {
@@ -49,12 +46,9 @@ struct mcbp_noop_request {
 };
 
 mcbp_noop_response
-make_response(std::error_code ec, mcbp_noop_request& request, mcbp_noop_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, mcbp_noop_request&, mcbp_noop_request::encoded_response_type&&)
 {
-    mcbp_noop_response response{ encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
+    mcbp_noop_response response{ ctx };
     return response;
 }
 

data/ext/couchbase/operations/query_index_build_deferred.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.
@@ -28,8 +28,7 @@ struct query_index_build_deferred_response {
         std::uint64_t code;
         std::string message;
     };
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_problem> errors{};
 };
@@ -38,6 +37,7 @@ struct query_index_build_deferred_request {
     using response_type = query_index_build_deferred_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::query;
 
@@ -63,13 +63,19 @@ struct query_index_build_deferred_request {
 };
 
 query_index_build_deferred_response
-make_response(std::error_code ec,
-              query_index_build_deferred_request& request,
+make_response(error_context::http&& ctx,
+              query_index_build_deferred_request&,
               query_index_build_deferred_request::encoded_response_type&& encoded)
 {
-    query_index_build_deferred_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    query_index_build_deferred_response response{ ctx };
+    if (!response.ctx.ec) {
+        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();
         if (response.status != "success") {
             for (const auto& entry : payload.at("errors").get_array()) {
@@ -78,7 +84,7 @@ make_response(std::error_code ec,
                 error.message = entry.at("msg").get_string();
                 response.errors.emplace_back(error);
             }
-            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/query_index_create.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.
@@ -28,8 +28,7 @@ struct query_index_create_response {
         std::uint64_t code;
         std::string message;
     };
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_problem> errors{};
 };
@@ -38,6 +37,7 @@ struct query_index_create_request {
     using response_type = query_index_create_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::query;
 
@@ -100,11 +100,17 @@ struct query_index_create_request {
 };
 
 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(error_context::http&& ctx, 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) {
-        auto payload = tao::json::from_string(encoded.body);
+    query_index_create_response response{ ctx };
+    if (!response.ctx.ec) {
+        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();
 
         if (response.status != "success") {
@@ -131,12 +137,12 @@ make_response(std::error_code ec, query_index_create_request& request, query_ind
             }
             if (index_already_exists) {
                 if (!request.ignore_if_exists) {
-                    response.ec = std::make_error_code(error::common_errc::index_exists);
+                    response.ctx.ec = std::make_error_code(error::common_errc::index_exists);
                 }
             } else if (bucket_not_found) {
-                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
             } else if (!response.errors.empty()) {
-                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);
             }
         }
     }

data/ext/couchbase/operations/query_index_drop.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.
@@ -28,8 +28,7 @@ struct query_index_drop_response {
         std::uint64_t code;
         std::string message;
     };
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_problem> errors{};
 };
@@ -38,6 +37,7 @@ struct query_index_drop_request {
     using response_type = query_index_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::query;
 
@@ -73,11 +73,17 @@ struct query_index_drop_request {
 };
 
 query_index_drop_response
-make_response(std::error_code ec, query_index_drop_request& request, query_index_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, query_index_drop_request& request, query_index_drop_request::encoded_response_type&& encoded)
 {
-    query_index_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    query_index_drop_response response{ ctx };
+    if (!response.ctx.ec) {
+        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();
 
         if (response.status != "success") {
@@ -105,12 +111,12 @@ make_response(std::error_code ec, query_index_drop_request& request, query_index
             }
             if (index_not_found) {
                 if (!request.ignore_if_does_not_exist) {
-                    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);
                 }
             } else if (bucket_not_found) {
-                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
             } else if (!response.errors.empty()) {
-                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);
             }
         }
     }

data/ext/couchbase/operations/query_index_get_all.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.
@@ -39,8 +39,7 @@ struct query_index_get_all_response {
         std::optional<std::string> bucket_id{};
         std::optional<std::string> scope_id{};
     };
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_index> indexes{};
 };
@@ -49,6 +48,7 @@ struct query_index_get_all_request {
     using response_type = query_index_get_all_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::query;
 
@@ -75,12 +75,18 @@ struct query_index_get_all_request {
 };
 
 query_index_get_all_response
-make_response(std::error_code ec, query_index_get_all_request& request, query_index_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, query_index_get_all_request&, query_index_get_all_request::encoded_response_type&& encoded)
 {
-    query_index_get_all_response response{ request.client_context_id, ec };
-    if (!ec) {
+    query_index_get_all_response response{ ctx };
+    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.status = payload.at("status").get_string();
             if (response.status == "success") {
                 for (const auto& entry : payload.at("results").get_array()) {

data/ext/couchbase/operations/role_get_all.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 role_get_all_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::vector<rbac::role_and_description> roles{};
 };
 
@@ -36,6 +35,7 @@ struct role_get_all_request {
     using response_type = role_get_all_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;
 
@@ -52,17 +52,23 @@ struct role_get_all_request {
 };
 
 role_get_all_response
-make_response(std::error_code ec, role_get_all_request& request, role_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, role_get_all_request&, role_get_all_request::encoded_response_type&& encoded)
 {
-    role_get_all_response response{ request.client_context_id, ec };
-    if (!ec) {
+    role_get_all_response response{ ctx };
+    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;
+            }
             for (const auto& entry : payload.get_array()) {
                 response.roles.emplace_back(entry.as<rbac::role_and_description>());
             }
         } 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;