couchbase 3.0.0.beta.1 → 3.1.0

data/ext/couchbase/operations/rbac.hxx

@@ -0,0 +1,276 @@
+/* -*- 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 <string>
+#include <optional>
+#include <set>
+
+namespace couchbase::operations::rbac
+{
+
+struct role {
+    std::string name;
+    std::optional<std::string> bucket{};
+    std::optional<std::string> scope{};
+    std::optional<std::string> collection{};
+};
+
+struct role_and_description : public role {
+    std::string display_name{};
+    std::string description{};
+};
+
+struct origin {
+    std::string type;
+    std::optional<std::string> name{};
+};
+
+struct role_and_origins : public role {
+    std::vector<origin> origins{};
+};
+
+struct user {
+    std::string username;
+    std::optional<std::string> display_name{};
+    // names of the groups
+    std::set<std::string> groups{};
+    // only roles assigned directly to the user (not inherited from groups)
+    std::vector<role> roles{};
+    // write only, it is not populated on reads
+    std::optional<std::string> password{};
+};
+
+enum class auth_domain { unknown, local, external };
+
+struct user_and_metadata : public user {
+    auth_domain domain{ auth_domain::unknown };
+    // all roles associated with the user, including information about whether each role is innate or inherited from a group
+    std::vector<role_and_origins> effective_roles{};
+    // timestamp of last password change
+    std::optional<std::string> password_changed{};
+    std::set<std::string> external_groups{};
+};
+
+struct group {
+    std::string name;
+    std::optional<std::string> description{};
+    std::vector<role> roles{};
+    std::optional<std::string> ldap_group_reference{};
+};
+
+} // namespace couchbase::operations::rbac
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::operations::rbac::user_and_metadata> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::rbac::user_and_metadata as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::rbac::user_and_metadata result;
+        std::string domain = v.at("domain").get_string();
+        if (domain == "local") {
+            result.domain = couchbase::operations::rbac::auth_domain::local;
+        } else if (domain == "external") {
+            result.domain = couchbase::operations::rbac::auth_domain::external;
+        } else {
+            spdlog::error(R"("unexpected domain for user with metadata: "{}")", domain);
+        }
+        result.username = v.at("id").get_string();
+        {
+            const auto* display_name = v.find("name");
+            if (display_name != nullptr && !display_name->get_string().empty()) {
+                result.display_name = display_name->get_string();
+            }
+        }
+        result.password_changed = v.template optional<std::string>("password_change_date");
+        {
+            const auto* external_groups = v.find("external_groups");
+            if (external_groups != nullptr) {
+                for (const auto& group : external_groups->get_array()) {
+                    result.external_groups.insert(group.get_string());
+                }
+            }
+        }
+        {
+            const auto* groups = v.find("groups");
+            if (groups != nullptr) {
+                for (const auto& group : groups->get_array()) {
+                    result.groups.insert(group.get_string());
+                }
+            }
+        }
+        {
+            const auto* roles = v.find("roles");
+            if (roles != nullptr) {
+                for (const auto& entry : roles->get_array()) {
+                    couchbase::operations::rbac::role_and_origins role{};
+                    role.name = entry.at("role").get_string();
+                    {
+                        const auto* bucket = entry.find("bucket_name");
+                        if (bucket != nullptr && !bucket->get_string().empty()) {
+                            role.bucket = bucket->get_string();
+                        }
+                    }
+                    {
+                        const auto* scope = entry.find("scope_name");
+                        if (scope != nullptr && !scope->get_string().empty()) {
+                            role.scope = scope->get_string();
+                        }
+                    }
+                    {
+                        const auto* collection = entry.find("collection_name");
+                        if (collection != nullptr && !collection->get_string().empty()) {
+                            role.collection = collection->get_string();
+                        }
+                    }
+                    {
+                        const auto* origins = entry.find("origins");
+                        if (origins != nullptr) {
+                            bool has_user_origin = false;
+                            for (const auto& ent : origins->get_array()) {
+                                couchbase::operations::rbac::origin origin{};
+                                origin.type = ent.at("type").get_string();
+                                if (origin.type == "user") {
+                                    has_user_origin = true;
+                                }
+                                const auto* name = ent.find("name");
+                                if (name != nullptr) {
+                                    origin.name = name->get_string();
+                                }
+                                role.origins.push_back(origin);
+                            }
+                            if (has_user_origin) {
+                                result.roles.push_back(role);
+                            }
+                        } else {
+                            result.roles.push_back(role);
+                        }
+                    }
+                    result.effective_roles.push_back(role);
+                }
+            }
+        }
+        return result;
+    }
+};
+
+template<>
+struct traits<couchbase::operations::rbac::role_and_description> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::rbac::role_and_description as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::rbac::role_and_description result;
+        result.name = v.at("role").get_string();
+        result.display_name = v.at("name").get_string();
+        result.description = v.at("desc").get_string();
+        {
+            const auto* bucket = v.find("bucket_name");
+            if (bucket != nullptr && !bucket->get_string().empty()) {
+                result.bucket = bucket->get_string();
+            }
+        }
+        {
+            const auto* scope = v.find("scope_name");
+            if (scope != nullptr && !scope->get_string().empty()) {
+                result.scope = scope->get_string();
+            }
+        }
+        {
+            const auto* collection = v.find("collection_name");
+            if (collection != nullptr && !collection->get_string().empty()) {
+                result.collection = collection->get_string();
+            }
+        }
+        return result;
+    }
+};
+
+template<>
+struct traits<couchbase::operations::rbac::group> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::rbac::group as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::rbac::group result;
+        result.name = v.at("id").get_string();
+        {
+            const auto* desc = v.find("description");
+            if (desc != nullptr && !desc->get_string().empty()) {
+                result.description = desc->get_string();
+            }
+        }
+        {
+            const auto* ldap_ref = v.find("ldap_group_ref");
+            if (ldap_ref != nullptr && !ldap_ref->get_string().empty()) {
+                result.ldap_group_reference = ldap_ref->get_string();
+            }
+        }
+        {
+            const auto* roles = v.find("roles");
+            if (roles != nullptr) {
+                for (const auto& entry : roles->get_array()) {
+                    couchbase::operations::rbac::role role{};
+                    role.name = entry.at("role").get_string();
+                    {
+                        const auto* bucket = entry.find("bucket_name");
+                        if (bucket != nullptr && !bucket->get_string().empty()) {
+                            role.bucket = bucket->get_string();
+                        }
+                    }
+                    {
+                        const auto* scope = entry.find("scope_name");
+                        if (scope != nullptr && !scope->get_string().empty()) {
+                            role.scope = scope->get_string();
+                        }
+                    }
+                    {
+                        const auto* collection = entry.find("collection_name");
+                        if (collection != nullptr && !collection->get_string().empty()) {
+                            role.collection = collection->get_string();
+                        }
+                    }
+                    result.roles.push_back(role);
+                }
+            }
+        }
+        return result;
+    }
+};
+} // namespace tao::json
+
+template<>
+struct fmt::formatter<couchbase::operations::rbac::auth_domain> : formatter<string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::operations::rbac::auth_domain domain, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (domain) {
+            case couchbase::operations::rbac::auth_domain::unknown:
+                name = "unknown";
+                break;
+            case couchbase::operations::rbac::auth_domain::local:
+                name = "local";
+                break;
+            case couchbase::operations::rbac::auth_domain::external:
+                name = "external";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};

data/ext/couchbase/operations/role_get_all.hxx

@@ -0,0 +1,77 @@
+/* -*- 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 <version.hxx>
+#include <operations/rbac.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct role_get_all_response {
+    error_context::http ctx;
+    std::vector<rbac::role_and_description> roles{};
+};
+
+struct role_get_all_request {
+    using response_type = role_get_all_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::management;
+
+    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&)
+    {
+        encoded.method = "GET";
+        encoded.path = "/settings/rbac/roles";
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        return {};
+    }
+};
+
+role_get_all_response
+make_response(error_context::http&& ctx, role_get_all_request&, role_get_all_request::encoded_response_type&& encoded)
+{
+    role_get_all_response response{ ctx };
+    if (!response.ctx.ec) {
+        if (encoded.status_code == 200) {
+            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);
+                return response;
+            }
+            for (const auto& entry : payload.get_array()) {
+                response.roles.emplace_back(entry.as<rbac::role_and_description>());
+            }
+        } else {
+            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/scope_create.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *   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.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct scope_create_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::uint64_t uid{ 0 };
 };
 
@@ -36,6 +35,7 @@ struct scope_create_request {
     using response_type = scope_create_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::management;
 
@@ -44,37 +44,48 @@ struct scope_create_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
-        encoded.path = fmt::format("/pools/default/buckets/{}/collections", bucket_name);
+        encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
         encoded.body = fmt::format("name={}", utils::string_codec::form_encode(scope_name));
+        return {};
     }
 };
 
 scope_create_response
-make_response(std::error_code ec, scope_create_request& request, scope_create_request::encoded_response_type encoded)
+make_response(error_context::http&& ctx, scope_create_request&, scope_create_request::encoded_response_type&& encoded)
 {
-    scope_create_response response{ request.client_context_id, ec };
-    if (!ec) {
+    scope_create_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
                 if (encoded.body.find("Not allowed on this version") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                    response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                } else if (encoded.body.find("Scope with this name already exists") != std::string::npos) {
+                    response.ctx.ec = std::make_error_code(error::management_errc::scope_exists);
+                } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
+                    response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
                 } else {
-                    response.ec = std::make_error_code(error::management_errc::scope_exists);
+                    response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 }
                 break;
             case 404:
-                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 break;
             case 200: {
-                tao::json::value payload = tao::json::from_string(encoded.body);
+                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);
+                    return response;
+                }
                 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);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }

data/ext/couchbase/operations/scope_drop.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *   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.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct scope_drop_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::uint64_t uid{ 0 };
 };
 
@@ -36,6 +35,7 @@ struct scope_drop_request {
     using response_type = scope_drop_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::management;
 
@@ -44,35 +44,42 @@ struct scope_drop_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
-        encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}", bucket_name, scope_name);
+        encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}", bucket_name, scope_name);
+        return {};
     }
 };
 
 scope_drop_response
-make_response(std::error_code ec, scope_drop_request& request, scope_drop_request::encoded_response_type encoded)
+make_response(error_context::http&& ctx, scope_drop_request&, scope_drop_request::encoded_response_type&& encoded)
 {
-    scope_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
+    scope_drop_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 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);
+                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
-                    response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 }
                 break;
             case 200: {
-                tao::json::value payload = tao::json::from_string(encoded.body);
+                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);
+                    return response;
+                }
                 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);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }