couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/ext/couchbase/operations/analytics_link_replace.hxx

@@ -0,0 +1,128 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <operations/analytics_link.hxx>
+#include <utils/name_codec.hxx>
+
+namespace couchbase::operations
+{
+struct analytics_link_replace_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    error_context::http ctx;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+template<typename analytics_link_type>
+struct analytics_link_replace_request {
+    using response_type = analytics_link_replace_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;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    analytics_link_type link{};
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
+    {
+        std::error_code ec = link.validate();
+        if (ec) {
+            return ec;
+        }
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.headers["accept"] = "application/json";
+        encoded.method = "PUT";
+        encoded.path = analytics_link::endpoint_from_link(link);
+        encoded.body = link.encode();
+        return {};
+    }
+};
+
+template<typename analytics_link_type>
+analytics_link_replace_response
+make_response(error_context::http&& ctx,
+              const analytics_link_replace_request<analytics_link_type>& /* request */,
+              typename analytics_link_replace_request<analytics_link_type>::encoded_response_type&& encoded)
+{
+    analytics_link_replace_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.body.empty() && response.ctx.http_status == 200) {
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = tao::json::from_string(encoded.body);
+        } catch (const tao::json::pegtl::parse_error&) {
+            auto colon = encoded.body.find(':');
+            if (colon == std::string::npos) {
+                response.ctx.ec = error::common_errc::parsing_failure;
+                return response;
+            }
+            auto code = static_cast<std::uint32_t>(std::stoul(encoded.body, 0));
+            auto msg = encoded.body.substr(colon + 1);
+            response.errors.emplace_back(analytics_link_replace_response::problem{ code, msg });
+        }
+        if (payload) {
+            response.status = payload.at("status").get_string();
+            if (response.status != "success") {
+                if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+                    for (const auto& error : errors->get_array()) {
+                        analytics_link_replace_response::problem err{
+                            error.at("code").as<std::uint32_t>(),
+                            error.at("msg").get_string(),
+                        };
+                        response.errors.emplace_back(err);
+                    }
+                }
+            }
+        }
+        bool link_not_found = false;
+        bool dataverse_does_not_exist = false;
+        for (const auto& err : response.errors) {
+            switch (err.code) {
+                case 24006: /* Link [string] does not exist */
+                    link_not_found = true;
+                    break;
+                case 24034: /* Cannot find dataverse with name [string] */
+                    dataverse_does_not_exist = true;
+                    break;
+            }
+        }
+        if (dataverse_does_not_exist) {
+            response.ctx.ec = error::analytics_errc::dataverse_not_found;
+        } else if (link_not_found) {
+            response.ctx.ec = error::analytics_errc::link_not_found;
+        } else {
+            response.ctx.ec = error::common_errc::internal_server_failure;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_link_s3_external.hxx

@@ -0,0 +1,122 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <optional>
+#include <sstream>
+#include <string>
+
+#include <errors.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations::analytics_link
+{
+/**
+ * An external analytics link which uses the AWS S3 service to access data.
+ */
+struct s3_external {
+    /**
+     * The name of this link.
+     */
+    std::string link_name{};
+
+    /**
+     * The dataverse that this link belongs to.
+     */
+    std::string dataverse{};
+
+    /**
+     * AWS S3 access key ID
+     */
+    std::string access_key_id{};
+
+    /**
+     * AWS S3 secret key
+     */
+    std::string secret_access_key{};
+
+    /**
+     * AWS S3 token if temporary credentials are provided. Only available in 7.0+
+     */
+    std::optional<std::string> session_token{};
+
+    /**
+     * AWS S3 region
+     */
+    std::string region{};
+
+    /**
+     * AWS S3 service endpoint
+     */
+    std::optional<std::string> service_endpoint{};
+
+    [[nodiscard]] std::error_code validate() const
+    {
+        if (dataverse.empty() || link_name.empty() || access_key_id.empty() || secret_access_key.empty() || region.empty()) {
+            return error::common_errc::invalid_argument;
+        }
+        return {};
+    }
+
+    [[nodiscard]] std::string encode() const
+    {
+        std::map<std::string, std::string> values{
+            { "type", "s3" },
+            { "accessKeyId", access_key_id },
+            { "secretAccessKey", secret_access_key },
+            { "region", region },
+        };
+        if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
+            values["dataverse"] = dataverse;
+            values["name"] = link_name;
+        }
+        if (session_token) {
+            values["sessionToken"] = session_token.value();
+        }
+        if (service_endpoint) {
+            values["serviceEndpoint"] = service_endpoint.value();
+        }
+        return utils::string_codec::v2::form_encode(values);
+    }
+};
+} // namespace couchbase::operations::analytics_link
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::operations::analytics_link::s3_external> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::analytics_link::s3_external as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::analytics_link::s3_external result{};
+
+        result.link_name = v.at("name").get_string();
+        if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {
+            result.dataverse = dataverse->get_string();
+        } else {
+            result.dataverse = v.at("scope").get_string();
+        }
+        result.access_key_id = v.at("accessKeyId").get_string();
+        result.region = v.at("region").get_string();
+        if (const auto* service_endpoint = v.find("serviceEndpoint"); service_endpoint != nullptr && service_endpoint->is_string()) {
+            result.service_endpoint.emplace(service_endpoint->get_string());
+        }
+        return result;
+    }
+};
+} // namespace tao::json

data/ext/couchbase/operations/bucket_create.hxx

@@ -44,7 +44,7 @@ struct bucket_create_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets");
@@ -129,23 +129,23 @@ struct bucket_create_request {
 };
 
 bucket_create_response
-make_response(error_context::http&& ctx, bucket_create_request&, bucket_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const bucket_create_request& /* request */, bucket_create_request::encoded_response_type&& encoded)
 {
-    bucket_create_response response{ ctx };
+    bucket_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 400: {
                 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);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
-                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = error::common_errc::invalid_argument;
                 auto* errors = payload.find("errors");
                 if (errors != nullptr) {
                     std::vector<std::string> error_list{};
@@ -161,7 +161,7 @@ make_response(error_context::http&& ctx, bucket_create_request&, bucket_create_r
             case 202:
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/bucket_drop.hxx

@@ -39,7 +39,7 @@ struct bucket_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}", name);
@@ -48,19 +48,19 @@ struct bucket_drop_request {
 };
 
 bucket_drop_response
-make_response(error_context::http&& ctx, bucket_drop_request&, bucket_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const bucket_drop_request& /* request */, bucket_drop_request::encoded_response_type&& encoded)
 {
-    bucket_drop_response response{ ctx };
+    bucket_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 200:
                 response.ctx.ec = {};
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/bucket_flush.hxx

@@ -38,7 +38,7 @@ struct bucket_flush_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush", name);
@@ -47,19 +47,19 @@ struct bucket_flush_request {
 };
 
 bucket_flush_response
-make_response(error_context::http&& ctx, bucket_flush_request&, bucket_flush_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const bucket_flush_request& /* request */, bucket_flush_request::encoded_response_type&& encoded)
 {
-    bucket_flush_response response{ ctx };
+    bucket_flush_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 200:
                 response.ctx.ec = {};
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/bucket_get.hxx

@@ -42,7 +42,7 @@ struct bucket_get_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/pools/default/buckets/{}", name);
@@ -51,24 +51,24 @@ struct bucket_get_request {
 };
 
 bucket_get_response
-make_response(error_context::http&& ctx, bucket_get_request&, bucket_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const bucket_get_request& /* request */, bucket_get_request::encoded_response_type&& encoded)
 {
-    bucket_get_response response{ ctx };
+    bucket_get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 200:
                 try {
                     response.bucket = tao::json::from_string(encoded.body).as<bucket_settings>();
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -41,7 +41,7 @@ struct bucket_get_all_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = "/pools/default/buckets";
@@ -50,15 +50,17 @@ struct bucket_get_all_request {
 };
 
 bucket_get_all_response
-make_response(error_context::http&& ctx, bucket_get_all_request&, bucket_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const bucket_get_all_request& /* request */,
+              bucket_get_all_request::encoded_response_type&& encoded)
 {
-    bucket_get_all_response response{ ctx };
+    bucket_get_all_response response{ std::move(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);
+        } catch (const tao::json::pegtl::parse_error& e) {
+            response.ctx.ec = error::common_errc::parsing_failure;
             return response;
         }
         const auto& entries = payload.get_array();

data/ext/couchbase/operations/bucket_settings.hxx

@@ -81,61 +81,52 @@ struct traits<couchbase::operations::bucket_settings> {
         result.ram_quota_mb = v.at("quota").at("rawRAM").get_unsigned() / megabyte;
         result.max_expiry = v.at("maxTTL").template as<std::uint32_t>();
         result.num_replicas = v.at("replicaNumber").template as<std::uint32_t>();
-        {
-            auto& str = v.at("bucketType").get_string();
-            if (str == "couchbase" || str == "membase") {
-                result.bucket_type = couchbase::operations::bucket_settings::bucket_type::couchbase;
-            } else if (str == "ephemeral") {
-                result.bucket_type = couchbase::operations::bucket_settings::bucket_type::ephemeral;
-            } else if (str == "memcached") {
-                result.bucket_type = couchbase::operations::bucket_settings::bucket_type::memcached;
-            }
+
+        if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
+            result.bucket_type = couchbase::operations::bucket_settings::bucket_type::couchbase;
+        } else if (str == "ephemeral") {
+            result.bucket_type = couchbase::operations::bucket_settings::bucket_type::ephemeral;
+        } else if (str == "memcached") {
+            result.bucket_type = couchbase::operations::bucket_settings::bucket_type::memcached;
         }
-        {
-            auto& str = v.at("compressionMode").get_string();
-            if (str == "active") {
-                result.compression_mode = couchbase::operations::bucket_settings::compression_mode::active;
-            } else if (str == "passive") {
-                result.compression_mode = couchbase::operations::bucket_settings::compression_mode::passive;
-            } else if (str == "off") {
-                result.compression_mode = couchbase::operations::bucket_settings::compression_mode::off;
-            }
+
+        if (auto& str = v.at("compressionMode").get_string(); str == "active") {
+            result.compression_mode = couchbase::operations::bucket_settings::compression_mode::active;
+        } else if (str == "passive") {
+            result.compression_mode = couchbase::operations::bucket_settings::compression_mode::passive;
+        } else if (str == "off") {
+            result.compression_mode = couchbase::operations::bucket_settings::compression_mode::off;
         }
-        {
-            auto& str = v.at("evictionPolicy").get_string();
-            if (str == "valueOnly") {
-                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::value_only;
-            } else if (str == "fullEviction") {
-                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::full;
-            } else if (str == "noEviction") {
-                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::no_eviction;
-            } else if (str == "nruEviction") {
-                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
-            }
+
+        if (auto& str = v.at("evictionPolicy").get_string(); str == "valueOnly") {
+            result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::value_only;
+        } else if (str == "fullEviction") {
+            result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::full;
+        } else if (str == "noEviction") {
+            result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::no_eviction;
+        } else if (str == "nruEviction") {
+            result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
         }
-        {
-            auto* min_level = v.find("durabilityMinLevel");
-            if (min_level != nullptr) {
-                auto& str = min_level->get_string();
-                if (str == "none") {
-                    result.minimum_durability_level = couchbase::protocol::durability_level::none;
-                } else if (str == "majority") {
-                    result.minimum_durability_level = couchbase::protocol::durability_level::majority;
-                } else if (str == "majorityAndPersistActive") {
-                    result.minimum_durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (str == "persistToMajority") {
-                    result.minimum_durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                }
+
+        if (auto* min_level = v.find("durabilityMinLevel"); min_level != nullptr) {
+            auto& str = min_level->get_string();
+            if (str == "none") {
+                result.minimum_durability_level = couchbase::protocol::durability_level::none;
+            } else if (str == "majority") {
+                result.minimum_durability_level = couchbase::protocol::durability_level::majority;
+            } else if (str == "majorityAndPersistActive") {
+                result.minimum_durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+            } else if (str == "persistToMajority") {
+                result.minimum_durability_level = couchbase::protocol::durability_level::persist_to_majority;
             }
         }
-        {
-            auto& str = v.at("conflictResolutionType").get_string();
-            if (str == "lww") {
-                result.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::timestamp;
-            } else if (str == "seqno") {
-                result.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::sequence_number;
-            }
+
+        if (auto& str = v.at("conflictResolutionType").get_string(); str == "lww") {
+            result.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::timestamp;
+        } else if (str == "seqno") {
+            result.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::sequence_number;
         }
+
         result.flush_enabled = v.at("controllers").find("flush") != nullptr;
         const auto ri = v.find("replicaIndex");
         if (ri) {