couchbase 3.0.2 → 3.0.3

data/ext/couchbase/operations/analytics_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.
@@ -29,8 +29,7 @@ struct analytics_index_create_response {
         std::string message;
     };
 
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<problem> errors{};
 };
@@ -39,6 +38,7 @@ struct analytics_index_create_request {
     using response_type = analytics_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::analytics;
 
@@ -79,11 +79,17 @@ struct analytics_index_create_request {
 };
 
 analytics_index_create_response
-make_response(std::error_code ec, analytics_index_create_request& request, analytics_index_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, analytics_index_create_request&, analytics_index_create_request::encoded_response_type&& encoded)
 {
-    analytics_index_create_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    analytics_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") {
@@ -113,13 +119,13 @@ make_response(std::error_code ec, analytics_index_create_request& request, analy
                 }
             }
             if (index_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 (dataset_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
             } else if (link_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::link_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);
             }
         }
     }

data/ext/couchbase/operations/analytics_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.
@@ -29,8 +29,7 @@ struct analytics_index_drop_response {
         std::string message;
     };
 
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<problem> errors{};
 };
@@ -39,6 +38,7 @@ struct analytics_index_drop_request {
     using response_type = analytics_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::analytics;
 
@@ -67,11 +67,17 @@ struct analytics_index_drop_request {
 };
 
 analytics_index_drop_response
-make_response(std::error_code ec, analytics_index_drop_request& request, analytics_index_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, analytics_index_drop_request&, analytics_index_drop_request::encoded_response_type&& encoded)
 {
-    analytics_index_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    analytics_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") {
@@ -97,11 +103,11 @@ make_response(std::error_code ec, analytics_index_drop_request& request, analyti
                 }
             }
             if (index_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 (dataset_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_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);
             }
         }
     }

data/ext/couchbase/operations/analytics_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.
@@ -36,8 +36,7 @@ struct analytics_index_get_all_response {
         std::string message;
     };
 
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<index> indexes{};
     std::vector<problem> errors{};
@@ -47,6 +46,7 @@ struct analytics_index_get_all_request {
     using response_type = analytics_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::analytics;
 
@@ -68,14 +68,18 @@ struct analytics_index_get_all_request {
 };
 
 analytics_index_get_all_response
-make_response(std::error_code ec,
-              analytics_index_get_all_request& request,
-              analytics_index_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, analytics_index_get_all_request&, analytics_index_get_all_request::encoded_response_type&& encoded)
 {
-    analytics_index_get_all_response response{ request.client_context_id, ec };
+    analytics_index_get_all_response response{ ctx };
 
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    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") {
             auto* results = payload.find("results");
@@ -100,7 +104,7 @@ make_response(std::error_code ec,
                     response.errors.emplace_back(err);
                 }
             }
-            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/analytics_link_connect.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.
@@ -29,8 +29,7 @@ struct analytics_link_connect_response {
         std::string message;
     };
 
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<problem> errors{};
 };
@@ -39,6 +38,7 @@ struct analytics_link_connect_request {
     using response_type = analytics_link_connect_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::analytics;
 
@@ -65,11 +65,17 @@ struct analytics_link_connect_request {
 };
 
 analytics_link_connect_response
-make_response(std::error_code ec, analytics_link_connect_request& request, analytics_link_connect_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, analytics_link_connect_request&, analytics_link_connect_request::encoded_response_type&& encoded)
 {
-    analytics_link_connect_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    analytics_link_connect_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") {
@@ -91,9 +97,9 @@ make_response(std::error_code ec, analytics_link_connect_request& request, analy
                 }
             }
             if (link_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::link_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);
             }
         }
     }

data/ext/couchbase/operations/analytics_link_disconnect.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.
@@ -29,8 +29,7 @@ struct analytics_link_disconnect_response {
         std::string message;
     };
 
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<problem> errors{};
 };
@@ -39,6 +38,7 @@ struct analytics_link_disconnect_request {
     using response_type = analytics_link_disconnect_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::analytics;
 
@@ -62,13 +62,19 @@ struct analytics_link_disconnect_request {
 };
 
 analytics_link_disconnect_response
-make_response(std::error_code ec,
-              analytics_link_disconnect_request& request,
+make_response(error_context::http&& ctx,
+              analytics_link_disconnect_request&,
               analytics_link_disconnect_request::encoded_response_type&& encoded)
 {
-    analytics_link_disconnect_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    analytics_link_disconnect_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") {
@@ -90,9 +96,9 @@ make_response(std::error_code ec,
                 }
             }
             if (link_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::link_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);
             }
         }
     }

data/ext/couchbase/operations/bucket_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.
@@ -22,13 +22,13 @@
 #include <version.hxx>
 #include <operations/bucket_settings.hxx>
 #include <utils/url_codec.hxx>
+#include <error_context/http.hxx>
 
 namespace couchbase::operations
 {
 
 struct bucket_create_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string error_message{};
 };
 
@@ -36,6 +36,7 @@ struct bucket_create_request {
     using response_type = bucket_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;
 
@@ -107,22 +108,44 @@ struct bucket_create_request {
             case bucket_settings::conflict_resolution_type::unknown:
                 break;
         }
+        if (bucket.minimum_durability_level) {
+            switch (bucket.minimum_durability_level.value()) {
+                case protocol::durability_level::none:
+                    encoded.body.append("&durabilityMinLevel=none");
+                    break;
+                case protocol::durability_level::majority:
+                    encoded.body.append("&durabilityMinLevel=majority");
+                    break;
+                case protocol::durability_level::majority_and_persist_to_active:
+                    encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
+                    break;
+                case protocol::durability_level::persist_to_majority:
+                    encoded.body.append("&durabilityMinLevel=persistToMajority");
+                    break;
+            }
+        }
         return {};
     }
 };
 
 bucket_create_response
-make_response(std::error_code ec, bucket_create_request& request, bucket_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, bucket_create_request&, bucket_create_request::encoded_response_type&& encoded)
 {
-    bucket_create_response response{ request.client_context_id, ec };
-    if (!ec) {
+    bucket_create_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             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 400: {
-                response.ec = std::make_error_code(error::common_errc::invalid_argument);
-                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.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 auto* errors = payload.find("errors");
                 if (errors != nullptr) {
                     std::vector<std::string> error_list{};
@@ -138,7 +161,7 @@ make_response(std::error_code ec, bucket_create_request& request, bucket_create_
             case 202:
                 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/bucket_drop.hxx

@@ -18,19 +18,20 @@
 #pragma once
 
 #include <tao/json.hpp>
+#include <error_context/http.hxx>
 
 namespace couchbase::operations
 {
 
 struct bucket_drop_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
 };
 
 struct bucket_drop_request {
     using response_type = bucket_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;
 
@@ -47,19 +48,19 @@ struct bucket_drop_request {
 };
 
 bucket_drop_response
-make_response(std::error_code ec, bucket_drop_request& request, bucket_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, bucket_drop_request&, bucket_drop_request::encoded_response_type&& encoded)
 {
-    bucket_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
+    bucket_drop_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             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.ec = {};
+                response.ctx.ec = {};
                 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/bucket_flush.hxx

@@ -23,14 +23,14 @@ namespace couchbase::operations
 {
 
 struct bucket_flush_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
 };
 
 struct bucket_flush_request {
     using response_type = bucket_flush_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;
 
@@ -47,19 +47,19 @@ struct bucket_flush_request {
 };
 
 bucket_flush_response
-make_response(std::error_code ec, bucket_flush_request& request, bucket_flush_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, bucket_flush_request&, bucket_flush_request::encoded_response_type&& encoded)
 {
-    bucket_flush_response response{ request.client_context_id, ec };
-    if (!ec) {
+    bucket_flush_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             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.ec = {};
+                response.ctx.ec = {};
                 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;
         }
     }