couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

data/ext/couchbase/operations/analytics_link_disconnect.hxx

@@ -1,101 +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>
-
-namespace couchbase::operations
-{
-struct analytics_link_disconnect_response {
-    struct problem {
-        std::uint32_t code;
-        std::string message;
-    };
-
-    std::string client_context_id;
-    std::error_code ec;
-    std::string status{};
-    std::vector<problem> errors{};
-};
-
-struct analytics_link_disconnect_request {
-    using response_type = analytics_link_disconnect_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-
-    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 };
-
-    std::string dataverse_name{ "Default" };
-    std::string link_name;
-
-    void encode_to(encoded_request_type& encoded, http_context&)
-    {
-        tao::json::value body{
-            { "statement", fmt::format("DISCONNECT LINK `{}`.`{}`", dataverse_name, link_name) },
-        };
-        encoded.headers["content-type"] = "application/json";
-        encoded.method = "POST";
-        encoded.path = "/analytics/service";
-        encoded.body = tao::json::to_string(body);
-    }
-};
-
-analytics_link_disconnect_response
-make_response(std::error_code ec,
-              analytics_link_disconnect_request& request,
-              analytics_link_disconnect_request::encoded_response_type encoded)
-{
-    analytics_link_disconnect_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
-        response.status = payload.at("status").get_string();
-
-        if (response.status != "success") {
-            bool link_not_found = false;
-
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
-                for (const auto& error : errors->get_array()) {
-                    analytics_link_disconnect_response::problem err{
-                        error.at("code").as<std::uint32_t>(),
-                        error.at("msg").get_string(),
-                    };
-                    switch (err.code) {
-                        case 24006: /* Link [string] does not exist */
-                            link_not_found = true;
-                            break;
-                    }
-                    response.errors.emplace_back(err);
-                }
-            }
-            if (link_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
-            } else {
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
-            }
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_create.hxx

@@ -1,147 +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_create_response {
-    std::string client_context_id;
-    std::error_code ec;
-    std::string error_message{};
-};
-
-struct bucket_create_request {
-    using response_type = bucket_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;
-
-    bucket_settings bucket{};
-    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, http_context&)
-    {
-        encoded.method = "POST";
-        encoded.path = fmt::format("/pools/default/buckets");
-
-        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-        encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));
-        switch (bucket.bucket_type) {
-            case bucket_settings::bucket_type::couchbase:
-                encoded.body.append("&bucketType=couchbase");
-                break;
-            case bucket_settings::bucket_type::memcached:
-                encoded.body.append("&bucketType=memcached");
-                break;
-            case bucket_settings::bucket_type::ephemeral:
-                encoded.body.append("&bucketType=ephemeral");
-                break;
-            case bucket_settings::bucket_type::unknown:
-                break;
-        }
-        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.eviction_policy) {
-            case bucket_settings::eviction_policy::full:
-                encoded.body.append("&evictionPolicy=fullEviction");
-                break;
-            case bucket_settings::eviction_policy::value_only:
-                encoded.body.append("&evictionPolicy=valueOnly");
-                break;
-            case bucket_settings::eviction_policy::no_eviction:
-                encoded.body.append("&evictionPolicy=noEviction");
-                break;
-            case bucket_settings::eviction_policy::not_recently_used:
-                encoded.body.append("&evictionPolicy=nruEviction");
-                break;
-            case bucket_settings::eviction_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;
-        }
-        switch (bucket.conflict_resolution_type) {
-            case bucket_settings::conflict_resolution_type::timestamp:
-                encoded.body.append("&conflictResolutionType=lww");
-                break;
-            case bucket_settings::conflict_resolution_type::sequence_number:
-                encoded.body.append("&conflictResolutionType=seqno");
-                break;
-            case bucket_settings::conflict_resolution_type::unknown:
-                break;
-        }
-    }
-};
-
-bucket_create_response
-make_response(std::error_code ec, bucket_create_request& request, bucket_create_request::encoded_response_type encoded)
-{
-    bucket_create_response response{ request.client_context_id, 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/bucket_drop.hxx

@@ -1,68 +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::string client_context_id;
-    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 };
-    std::string client_context_id{ uuid::to_string(uuid::random()) };
-
-    void encode_to(encoded_request_type& encoded, http_context&)
-    {
-        encoded.method = "DELETE";
-        encoded.path = fmt::format("/pools/default/buckets/{}", name);
-    }
-};
-
-bucket_drop_response
-make_response(std::error_code ec, bucket_drop_request& request, bucket_drop_request::encoded_response_type encoded)
-{
-    bucket_drop_response response{ request.client_context_id, 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,68 +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::string client_context_id;
-    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 };
-    std::string client_context_id{ uuid::to_string(uuid::random()) };
-
-    void encode_to(encoded_request_type& encoded, http_context&)
-    {
-        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& request, bucket_flush_request::encoded_response_type encoded)
-{
-    bucket_flush_response response{ request.client_context_id, 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,72 +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::string client_context_id;
-    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 };
-    std::string client_context_id{ uuid::to_string(uuid::random()) };
-
-    void encode_to(encoded_request_type& encoded, http_context&)
-    {
-        encoded.method = "GET";
-        encoded.path = fmt::format("/pools/default/buckets/{}", name);
-    }
-};
-
-bucket_get_response
-make_response(std::error_code ec, bucket_get_request& request, bucket_get_request::encoded_response_type encoded)
-{
-    bucket_get_response response{ request.client_context_id, 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