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

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -0,0 +1,62 @@
+/* -*- 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 bucket_get_all_response {
+    std::error_code ec;
+    std::vector<bucket_settings> buckets{};
+};
+
+struct bucket_get_all_request {
+    using response_type = bucket_get_all_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "GET";
+        encoded.path = "/pools/default/buckets";
+    }
+};
+
+bucket_get_all_response
+make_response(std::error_code ec, bucket_get_all_request&, bucket_get_all_request::encoded_response_type encoded)
+{
+    bucket_get_all_response response{ ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        const auto& entries = payload.get_array();
+        response.buckets.reserve(entries.size());
+        for (const auto& entry : entries) {
+            response.buckets.emplace_back(entry.as<bucket_settings>());
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_settings.hxx

@@ -0,0 +1,111 @@
+#pragma once
+
+namespace couchbase::operations
+{
+struct bucket_settings {
+    enum class bucket_type { unknown, couchbase, memcached, ephemeral };
+    enum class compression_mode { unknown, off, active, passive };
+    enum class ejection_policy { unknown, full, value_only };
+    enum class conflict_resolution_type { unknown, timestamp, sequence_number };
+    struct node {
+        std::string hostname;
+        std::string status;
+        std::string version;
+        std::vector<std::string> services;
+        std::map<std::string, std::uint16_t> ports;
+    };
+
+    std::string name;
+    std::string uuid;
+    bucket_type bucket_type{ bucket_type::unknown };
+    std::uint64_t ram_quota_mb{ 100 };
+    std::uint32_t max_expiry{ 0 };
+    compression_mode compression_mode{ compression_mode::unknown };
+    std::uint32_t num_replicas{ 1 };
+    bool replica_indexes{ false };
+    bool flush_enabled{ false };
+    ejection_policy ejection_policy{ ejection_policy::unknown };
+    conflict_resolution_type conflict_resolution_type{ conflict_resolution_type::unknown };
+    std::vector<std::string> capabilities{};
+    std::vector<node> nodes{};
+};
+} // namespace couchbase::operations
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::operations::bucket_settings> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::bucket_settings as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::bucket_settings result;
+        result.name = v.at("name").get_string();
+        result.uuid = v.at("uuid").get_string();
+        const static std::uint64_t megabyte = 1024 * 1024;
+        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;
+            }
+        }
+        {
+            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;
+            }
+        }
+        {
+            auto& str = v.at("evictionPolicy").get_string();
+            if (str == "valueOnly") {
+                result.ejection_policy = couchbase::operations::bucket_settings::ejection_policy::value_only;
+            } else if (str == "fullEviction") {
+                result.ejection_policy = couchbase::operations::bucket_settings::ejection_policy::full;
+            }
+        }
+        {
+            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;
+            }
+        }
+        result.flush_enabled = v.at("controllers").find("flush") != nullptr;
+        const auto ri = v.find("replicaIndex");
+        if (ri) {
+            result.replica_indexes = ri->get_boolean();
+        }
+        const auto caps = v.find("bucketCapabilities");
+        if (caps != nullptr) {
+            for (auto& cap : caps->get_array()) {
+                result.capabilities.emplace_back(cap.get_string());
+            }
+        }
+        for (auto& n : v.at("nodes").get_array()) {
+            couchbase::operations::bucket_settings::node node;
+            node.status = n.at("status").get_string();
+            node.hostname = n.at("hostname").get_string();
+            node.version = n.at("version").get_string();
+            for (auto& s : n.at("services").get_array()) {
+                node.services.emplace_back(s.get_string());
+            }
+            for (auto& p : n.at("ports").get_object()) {
+                node.ports.emplace(p.first, p.second.template as<std::uint16_t>());
+            }
+            result.nodes.emplace_back(node);
+        }
+        return result;
+    }
+};
+} // namespace tao::json

data/ext/couchbase/operations/bucket_update.hxx

@@ -0,0 +1,115 @@
+/* -*- 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 bucket_update_response {
+    std::error_code ec;
+    bucket_settings bucket{};
+    std::string error_message{};
+};
+
+struct bucket_update_request {
+    using response_type = bucket_update_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    bucket_settings bucket{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "POST";
+        encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
+
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
+        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
+        encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
+        switch (bucket.ejection_policy) {
+            case bucket_settings::ejection_policy::full:
+                encoded.body.append("&evictionPolicy=fullEviction");
+                break;
+            case bucket_settings::ejection_policy::value_only:
+                encoded.body.append("&evictionPolicy=valueOnly");
+                break;
+            case bucket_settings::ejection_policy::unknown:
+                break;
+        }
+        switch (bucket.compression_mode) {
+            case bucket_settings::compression_mode::off:
+                encoded.body.append("&compressionMode=off");
+                break;
+            case bucket_settings::compression_mode::active:
+                encoded.body.append("&compressionMode=active");
+                break;
+            case bucket_settings::compression_mode::passive:
+                encoded.body.append("&compressionMode=passive");
+                break;
+            case bucket_settings::compression_mode::unknown:
+                break;
+        }
+    }
+};
+
+bucket_update_response
+make_response(std::error_code ec, bucket_update_request&, bucket_update_request::encoded_response_type encoded)
+{
+    bucket_update_response response{ ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 404:
+                response.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);
+                auto* errors = payload.find("errors");
+                if (errors != nullptr) {
+                    std::vector<std::string> error_list{};
+                    for (auto& err : errors->get_object()) {
+                        error_list.emplace_back(err.second.get_string());
+                    }
+                    if (!error_list.empty()) {
+                        response.error_message = fmt::format("{}", fmt::join(error_list.begin(), error_list.end(), ". "));
+                    }
+                }
+            } break;
+            case 200:
+            case 202:
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -0,0 +1,60 @@
+/* -*- 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::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;
+
+    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&, scope_get_all_request::encoded_response_type encoded)
+{
+    cluster_developer_preview_enable_response response{ 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,86 @@
+/* -*- 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::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 };
+
+    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&, collection_create_request::encoded_response_type encoded)
+{
+    collection_create_response response{ ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 400:
+                response.ec = std::make_error_code(error::management_errc::collection_exists);
+                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,82 @@
+/* -*- 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::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;
+
+    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&, collection_drop_request::encoded_response_type encoded)
+{
+    collection_drop_response response{ 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