couchbase 3.0.2 → 3.0.3

data/ext/couchbase/operations/scope_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.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct scope_create_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::uint64_t uid{ 0 };
 };
 
@@ -36,6 +35,7 @@ struct scope_create_request {
     using response_type = scope_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::management;
 
@@ -55,31 +55,37 @@ struct scope_create_request {
 };
 
 scope_create_response
-make_response(std::error_code ec, scope_create_request& request, scope_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, scope_create_request&, scope_create_request::encoded_response_type&& encoded)
 {
-    scope_create_response response{ request.client_context_id, ec };
-    if (!ec) {
+    scope_create_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
                 if (encoded.body.find("Not allowed on this version") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                    response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 } else if (encoded.body.find("Scope with this name already exists") != std::string::npos) {
-                    response.ec = std::make_error_code(error::management_errc::scope_exists);
+                    response.ctx.ec = std::make_error_code(error::management_errc::scope_exists);
                 } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::feature_not_available);
+                    response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
                 } else {
-                    response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                    response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 }
                 break;
             case 404:
-                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);
                 break;
             case 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;
+                }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } 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/scope_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.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct scope_drop_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::uint64_t uid{ 0 };
 };
 
@@ -36,6 +35,7 @@ struct scope_drop_request {
     using response_type = scope_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;
 
@@ -53,27 +53,33 @@ struct scope_drop_request {
 };
 
 scope_drop_response
-make_response(std::error_code ec, scope_drop_request& request, scope_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, scope_drop_request&, scope_drop_request::encoded_response_type&& encoded)
 {
-    scope_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
+    scope_drop_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 break;
             case 404:
                 if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::scope_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
-                    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);
                 }
                 break;
             case 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;
+                }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } 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/scope_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 scope_get_all_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     collections_manifest manifest{};
 };
 
@@ -36,6 +35,7 @@ struct scope_get_all_request {
     using response_type = scope_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,22 +52,27 @@ struct scope_get_all_request {
 };
 
 scope_get_all_response
-make_response(std::error_code ec, scope_get_all_request& request, scope_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, scope_get_all_request&, scope_get_all_request::encoded_response_type&& encoded)
 {
-    scope_get_all_response response{ request.client_context_id, ec };
-    if (!ec) {
+    scope_get_all_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 break;
             case 404:
-                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);
                 break;
             case 200:
-                response.manifest = tao::json::from_string(encoded.body).as<collections_manifest>();
+                try {
+                    response.manifest = tao::json::from_string(encoded.body).as<collections_manifest>();
+                } catch (tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                    return response;
+                }
                 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/search_get_stats.hxx

@@ -24,8 +24,7 @@
 namespace couchbase::operations
 {
 struct search_index_stats_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string stats{};
 };
 
@@ -33,6 +32,7 @@ struct search_index_stats_request {
     using response_type = search_index_stats_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::search;
 
@@ -48,10 +48,10 @@ struct search_index_stats_request {
 };
 
 search_index_stats_response
-make_response(std::error_code ec, search_index_stats_request& request, search_index_stats_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, search_index_stats_request&, search_index_stats_request::encoded_response_type&& encoded)
 {
-    search_index_stats_response response{ request.client_context_id, ec };
-    if (!ec) {
+    search_index_stats_response response{ ctx };
+    if (!response.ctx.ec) {
         response.stats = encoded.body;
     }
     return response;

data/ext/couchbase/operations/search_index_analyze_document.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.
@@ -24,8 +24,7 @@
 namespace couchbase::operations
 {
 struct search_index_analyze_document_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::string error{};
     std::string analysis{};
@@ -35,6 +34,7 @@ struct search_index_analyze_document_request {
     using response_type = search_index_analyze_document_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::search;
 
@@ -56,14 +56,20 @@ struct search_index_analyze_document_request {
 };
 
 search_index_analyze_document_response
-make_response(std::error_code ec,
-              search_index_analyze_document_request& request,
+make_response(error_context::http&& ctx,
+              search_index_analyze_document_request&,
               search_index_analyze_document_request::encoded_response_type&& encoded)
 {
-    search_index_analyze_document_response response{ request.client_context_id, ec };
-    if (!ec) {
+    search_index_analyze_document_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 == "ok") {
                 response.analysis = tao::json::to_string(payload.at("analyzed"));
@@ -71,21 +77,27 @@ make_response(std::error_code ec,
             }
         } else if (encoded.status_code == 400) {
             if (encoded.body.find("no indexName:") != 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;
+            }
+            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;
             }
-            auto payload = tao::json::from_string(encoded.body);
             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("index with the same name already exists") != std::string::npos) {
-                response.ec = std::make_error_code(error::common_errc::index_exists);
+                response.ctx.ec = std::make_error_code(error::common_errc::index_exists);
                 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/search_index_control_ingest.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.
@@ -24,8 +24,7 @@
 namespace couchbase::operations
 {
 struct search_index_control_ingest_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::string error{};
 };
@@ -34,6 +33,7 @@ struct search_index_control_ingest_request {
     using response_type = search_index_control_ingest_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::search;
 
@@ -52,28 +52,40 @@ struct search_index_control_ingest_request {
 };
 
 search_index_control_ingest_response
-make_response(std::error_code ec,
-              search_index_control_ingest_request& request,
+make_response(error_context::http&& ctx,
+              search_index_control_ingest_request&,
               search_index_control_ingest_request::encoded_response_type&& encoded)
 {
-    search_index_control_ingest_response response{ request.client_context_id, ec };
-    if (!ec) {
+    search_index_control_ingest_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 == "ok") {
                 return response;
             }
         } else 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;
             }
         }
-        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/search_index_control_plan_freeze.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.
@@ -24,8 +24,7 @@
 namespace couchbase::operations
 {
 struct search_index_control_plan_freeze_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::string error{};
 };
@@ -34,6 +33,7 @@ struct search_index_control_plan_freeze_request {
     using response_type = search_index_control_plan_freeze_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::search;
 
@@ -52,28 +52,40 @@ struct search_index_control_plan_freeze_request {
 };
 
 search_index_control_plan_freeze_response
-make_response(std::error_code ec,
-              search_index_control_plan_freeze_request& request,
+make_response(error_context::http&& ctx,
+              search_index_control_plan_freeze_request&,
               search_index_control_plan_freeze_request::encoded_response_type&& encoded)
 {
-    search_index_control_plan_freeze_response response{ request.client_context_id, ec };
-    if (!ec) {
+    search_index_control_plan_freeze_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 == "ok") {
                 return response;
             }
         } else 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;
             }
         }
-        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;
 }