couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <version.hxx>
+#include <operations/bucket_settings.hxx>
+
+namespace couchbase::operations
+{
+
+struct cluster_developer_preview_enable_response {
+    std::string client_context_id;
+    std::error_code ec;
+};
+
+struct cluster_developer_preview_enable_request {
+    using response_type = cluster_developer_preview_enable_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "POST";
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.path = "/settings/developerPreview";
+        encoded.body = "enabled=true";
+    }
+};
+
+cluster_developer_preview_enable_response
+make_response(std::error_code ec, cluster_developer_preview_enable_request& request, scope_get_all_request::encoded_response_type encoded)
+{
+    cluster_developer_preview_enable_response response{ request.client_context_id, ec };
+    if (!ec) {
+        if (encoded.status_code != 200) {
+            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/collection_create.hxx

@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <version.hxx>
+#include <operations/bucket_settings.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct collection_create_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::uint64_t uid{ 0 };
+};
+
+struct collection_create_request {
+    using response_type = collection_create_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+    std::uint32_t max_expiry{ 0 };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "POST";
+        encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}", bucket_name, scope_name);
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.body = fmt::format("name={}", utils::string_codec::form_encode(collection_name));
+        if (max_expiry > 0) {
+            encoded.body.append(fmt::format("&maxTTL={}", max_expiry));
+        }
+    }
+};
+
+collection_create_response
+make_response(std::error_code ec, collection_create_request& request, collection_create_request::encoded_response_type encoded)
+{
+    collection_create_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 400:
+                if (encoded.body.find("Collection with this name already exists") != std::string::npos) {
+                    response.ec = std::make_error_code(error::management_errc::collection_exists);
+                } else {
+                    response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                }
+                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);
+                } else {
+                    response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                }
+                break;
+            case 200: {
+                tao::json::value payload = tao::json::from_string(encoded.body);
+                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);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/collection_drop.hxx

@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <version.hxx>
+#include <operations/bucket_settings.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct collection_drop_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::uint64_t uid{ 0 };
+};
+
+struct collection_drop_request {
+    using response_type = collection_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "DELETE";
+        encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}/{}", bucket_name, scope_name, collection_name);
+    }
+};
+
+collection_drop_response
+make_response(std::error_code ec, collection_drop_request& request, collection_drop_request::encoded_response_type encoded)
+{
+    collection_drop_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 400:
+                response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                break;
+            case 404:
+                if (encoded.body.find("Collection with this name is not found") != std::string::npos) {
+                    response.ec = std::make_error_code(error::common_errc::collection_not_found);
+                } else 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);
+                } else {
+                    response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                }
+                break;
+            case 200: {
+                tao::json::value payload = tao::json::from_string(encoded.body);
+                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);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/design_document.hxx

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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
+
+namespace couchbase::operations
+{
+struct design_document {
+    enum class name_space {
+        development,
+        production,
+    };
+
+    struct view {
+        std::string name;
+        std::optional<std::string> map;
+        std::optional<std::string> reduce;
+    };
+
+    std::string rev;
+    std::string name;
+    design_document::name_space ns;
+    std::map<std::string, view> views;
+};
+
+} // namespace couchbase::operations
+
+template<>
+struct fmt::formatter<couchbase::operations::design_document::name_space> : formatter<string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::operations::design_document::name_space ns, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (ns) {
+            case couchbase::operations::design_document::name_space::development:
+                name = "development";
+                break;
+
+            case couchbase::operations::design_document::name_space::production:
+                name = "production";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};

data/ext/couchbase/operations/document_analytics.hxx

@@ -0,0 +1,288 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <gsl/gsl>
+
+#include <spdlog/spdlog.h>
+
+#include <tao/json.hpp>
+
+#include <version.hxx>
+
+#include <errors.hxx>
+#include <mutation_token.hxx>
+#include <service_type.hxx>
+#include <platform/uuid.h>
+#include <timeout_defaults.hxx>
+#include <io/http_message.hxx>
+
+namespace couchbase::operations
+{
+struct analytics_response_payload {
+    struct analytics_metrics {
+        std::string elapsed_time;
+        std::string execution_time;
+        std::uint64_t result_count;
+        std::uint64_t result_size;
+        std::optional<std::uint64_t> sort_count;
+        std::optional<std::uint64_t> mutation_count;
+        std::optional<std::uint64_t> error_count;
+        std::optional<std::uint64_t> warning_count;
+    };
+
+    struct analytics_problem {
+        std::uint64_t code;
+        std::string message;
+    };
+
+    struct analytics_meta_data {
+        std::string request_id;
+        std::string client_context_id;
+        std::string status;
+        analytics_metrics metrics;
+        std::optional<std::string> signature;
+        std::optional<std::string> profile;
+        std::optional<std::vector<analytics_problem>> warnings;
+        std::optional<std::vector<analytics_problem>> errors;
+    };
+
+    analytics_meta_data meta_data{};
+    std::vector<std::string> rows{};
+};
+} // namespace couchbase::operations
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::operations::analytics_response_payload> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::analytics_response_payload as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::analytics_response_payload result;
+        result.meta_data.request_id = v.at("requestID").get_string();
+        result.meta_data.client_context_id = v.at("clientContextID").get_string();
+        result.meta_data.status = v.at("status").get_string();
+        const auto s = v.find("signature");
+        if (s != nullptr) {
+            result.meta_data.signature = tao::json::to_string(*s);
+        }
+
+        const auto p = v.find("profile");
+        if (p != nullptr) {
+            result.meta_data.profile = tao::json::to_string(*p);
+        }
+
+        const auto m = v.find("metrics");
+        if (m != nullptr) {
+            result.meta_data.metrics.result_count = m->at("resultCount").get_unsigned();
+            result.meta_data.metrics.result_size = m->at("resultSize").get_unsigned();
+            result.meta_data.metrics.elapsed_time = m->at("elapsedTime").get_string();
+            result.meta_data.metrics.execution_time = m->at("executionTime").get_string();
+            result.meta_data.metrics.sort_count = m->template optional<std::uint64_t>("sortCount");
+            result.meta_data.metrics.mutation_count = m->template optional<std::uint64_t>("mutationCount");
+            result.meta_data.metrics.error_count = m->template optional<std::uint64_t>("errorCount");
+            result.meta_data.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
+        }
+
+        const auto e = v.find("errors");
+        if (e != nullptr) {
+            std::vector<couchbase::operations::analytics_response_payload::analytics_problem> problems{};
+            for (auto& err : e->get_array()) {
+                couchbase::operations::analytics_response_payload::analytics_problem problem;
+                problem.code = err.at("code").get_unsigned();
+                problem.message = err.at("msg").get_string();
+                problems.emplace_back(problem);
+            }
+            result.meta_data.errors.emplace(problems);
+        }
+
+        const auto w = v.find("warnings");
+        if (w != nullptr) {
+            std::vector<couchbase::operations::analytics_response_payload::analytics_problem> problems{};
+            for (auto& warn : w->get_array()) {
+                couchbase::operations::analytics_response_payload::analytics_problem problem;
+                problem.code = warn.at("code").get_unsigned();
+                problem.message = warn.at("msg").get_string();
+                problems.emplace_back(problem);
+            }
+            result.meta_data.warnings.emplace(problems);
+        }
+        const auto r = v.find("results");
+        if (r != nullptr) {
+            result.rows.reserve(result.meta_data.metrics.result_count);
+            for (auto& row : r->get_array()) {
+                result.rows.emplace_back(tao::json::to_string(row));
+            }
+        }
+
+        return result;
+    }
+};
+} // namespace tao::json
+
+namespace couchbase::operations
+{
+struct analytics_response {
+    std::string client_context_id;
+    std::error_code ec;
+    analytics_response_payload payload{};
+};
+
+struct analytics_request {
+    using response_type = analytics_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    enum class scan_consistency_type { not_bounded, request_plus };
+
+    static const inline service_type type = service_type::analytics;
+
+    std::chrono::milliseconds timeout{ timeout_defaults::analytics_timeout };
+    std::string statement;
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    bool readonly{ false };
+    bool priority{ false };
+
+    std::optional<scan_consistency_type> scan_consistency{};
+
+    std::map<std::string, tao::json::value> raw{};
+    std::vector<tao::json::value> positional_parameters{};
+    std::map<std::string, tao::json::value> named_parameters{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        tao::json::value body{ { "statement", statement },
+                               { "client_context_id", client_context_id },
+                               { "timeout", fmt::format("{}ms", timeout.count()) } };
+        if (positional_parameters.empty()) {
+            for (auto& param : named_parameters) {
+                Expects(param.first.empty() == false);
+                std::string key = param.first;
+                if (key[0] != '$') {
+                    key.insert(key.begin(), '$');
+                }
+                body[key] = param.second;
+            }
+        } else {
+            body["args"] = positional_parameters;
+        }
+        if (readonly) {
+            body["readonly"] = true;
+        }
+        if (scan_consistency) {
+            switch (scan_consistency.value()) {
+                case scan_consistency_type::not_bounded:
+                    body["scan_consistency"] = "not_bounded";
+                    break;
+                case scan_consistency_type::request_plus:
+                    body["scan_consistency"] = "request_plus";
+                    break;
+            }
+        }
+        for (auto& param : raw) {
+            body[param.first] = param.second;
+        }
+        encoded.type = type;
+        encoded.headers["content-type"] = "application/json";
+        if (priority) {
+            encoded.headers["analytics-priority"] = "-1";
+        }
+        encoded.method = "POST";
+        encoded.path = "/query/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_response
+make_response(std::error_code ec, analytics_request& request, analytics_request::encoded_response_type encoded)
+{
+    analytics_response response{ request.client_context_id, ec };
+    if (!ec) {
+        response.payload = tao::json::from_string(encoded.body).as<analytics_response_payload>();
+        Expects(response.payload.meta_data.client_context_id == request.client_context_id);
+        if (response.payload.meta_data.status != "success") {
+            bool server_timeout = false;
+            bool job_queue_is_full = false;
+            bool dataset_not_found = false;
+            bool dataverse_not_found = false;
+            bool dataset_exists = false;
+            bool dataverse_exists = false;
+            bool link_not_found = false;
+            bool compilation_failure = false;
+
+            if (response.payload.meta_data.errors) {
+                for (const auto& error : *response.payload.meta_data.errors) {
+                    switch (error.code) {
+                        case 21002: /* Request timed out and will be cancelled */
+                            server_timeout = true;
+                            break;
+                        case 23007: /* Job queue is full with [string] jobs */
+                            job_queue_is_full = true;
+                            break;
+                        case 24044: /* Cannot find dataset [string] because there is no dataverse declared, nor an alias with name [string]!
+                                     */
+                        case 24045: /* Cannot find dataset [string] in dataverse [string] nor an alias with name [string]! */
+                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+                            dataset_not_found = true;
+                            break;
+                        case 24034: /* Cannot find dataverse with name [string] */
+                            dataverse_not_found = true;
+                            break;
+                        case 24040: /* A dataset with name [string] already exists in dataverse [string] */
+                            dataset_exists = true;
+                            break;
+                        case 24039: /* A dataverse with this name [string] already exists. */
+                            dataverse_exists = true;
+                            break;
+                        case 24006: /* Link [string] does not exist | Link [string] does not exist */
+                            link_not_found = true;
+                            break;
+                        default:
+                            if (error.code >= 24000 && error.code < 25000) {
+                                compilation_failure = true;
+                            }
+                    }
+                }
+            }
+            if (compilation_failure) {
+                response.ec = std::make_error_code(error::analytics_errc::compilation_failure);
+            } else if (link_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+            } else if (dataset_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+            } else if (dataverse_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::dataverse_not_found);
+            } else if (server_timeout) {
+                response.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
+            } else if (dataset_exists) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_exists);
+            } else if (dataverse_exists) {
+                response.ec = std::make_error_code(error::analytics_errc::dataverse_exists);
+            } else if (job_queue_is_full) {
+                response.ec = std::make_error_code(error::analytics_errc::job_queue_full);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations