couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.0-x86_64-linux

data/ext/couchbase/operations/bucket_drop.hxx

@@ -1,66 +0,0 @@
-/* -*- 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>
-
-namespace couchbase::operations
-{
-
-struct bucket_drop_response {
-    std::error_code ec;
-};
-
-struct bucket_drop_request {
-    using response_type = bucket_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 name;
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.method = "DELETE";
-        encoded.path = fmt::format("/pools/default/buckets/{}", name);
-    }
-};
-
-bucket_drop_response
-make_response(std::error_code ec, bucket_drop_request&, bucket_drop_request::encoded_response_type encoded)
-{
-    bucket_drop_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 200:
-                response.ec = {};
-                break;
-            default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
-                break;
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_flush.hxx

@@ -1,66 +0,0 @@
-/* -*- 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>
-
-namespace couchbase::operations
-{
-
-struct bucket_flush_response {
-    std::error_code ec;
-};
-
-struct bucket_flush_request {
-    using response_type = bucket_flush_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 name;
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.method = "POST";
-        encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush", name);
-    }
-};
-
-bucket_flush_response
-make_response(std::error_code ec, bucket_flush_request&, bucket_flush_request::encoded_response_type encoded)
-{
-    bucket_flush_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 200:
-                response.ec = {};
-                break;
-            default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
-                break;
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_get.hxx

@@ -1,70 +0,0 @@
-/* -*- 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_response {
-    std::error_code ec;
-    bucket_settings bucket{};
-};
-
-struct bucket_get_request {
-    using response_type = bucket_get_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 name;
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.method = "GET";
-        encoded.path = fmt::format("/pools/default/buckets/{}", name);
-    }
-};
-
-bucket_get_response
-make_response(std::error_code ec, bucket_get_request&, bucket_get_request::encoded_response_type encoded)
-{
-    bucket_get_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 200:
-                response.bucket = tao::json::from_string(encoded.body).as<bucket_settings>();
-                break;
-            default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
-                break;
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -1,63 +0,0 @@
-/* -*- 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;
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    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

@@ -1,111 +0,0 @@
-#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

@@ -1,116 +0,0 @@
-/* -*- 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;
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    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

@@ -1,61 +0,0 @@
-/* -*- 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;
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    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

@@ -1,91 +0,0 @@
-/* -*- 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 };
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    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:
-                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