couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/couchbase/operations/document_view.hxx

@@ -89,7 +89,7 @@ struct document_view_request {
     enum class sort_order { ascending, descending };
     std::optional<sort_order> order;
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         std::vector<std::string> query_string;
 

data/ext/couchbase/operations/group_drop.hxx

@@ -0,0 +1,71 @@
+/* -*- 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/rbac.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct group_drop_response {
+    std::string client_context_id;
+    std::error_code ec;
+};
+
+struct group_drop_request {
+    using response_type = group_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("/settings/rbac/groups/{}", name);
+    }
+};
+
+group_drop_response
+make_response(std::error_code ec, group_drop_request& request, group_drop_request::encoded_response_type encoded)
+{
+    group_drop_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 200:
+                break;
+            case 404:
+                response.ec = std::make_error_code(error::management_errc::group_not_found);
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/group_get.hxx

@@ -0,0 +1,75 @@
+/* -*- 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/rbac.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct group_get_response {
+    std::string client_context_id;
+    std::error_code ec;
+    rbac::group group{};
+};
+
+struct group_get_request {
+    using response_type = group_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("/settings/rbac/groups/{}", name);
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    }
+};
+
+group_get_response
+make_response(std::error_code ec, group_get_request& request, group_get_request::encoded_response_type encoded)
+{
+    group_get_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 200: {
+                tao::json::value payload = tao::json::from_string(encoded.body);
+                response.group = payload.as<rbac::group>();
+            } break;
+            case 404:
+                response.ec = std::make_error_code(error::management_errc::group_not_found);
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/group_get_all.hxx

@@ -0,0 +1,70 @@
+/* -*- 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/rbac.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct group_get_all_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::vector<rbac::group> groups{};
+};
+
+struct group_get_all_request {
+    using response_type = group_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 };
+    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("/settings/rbac/groups");
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    }
+};
+
+group_get_all_response
+make_response(std::error_code ec, group_get_all_request& request, group_get_all_request::encoded_response_type encoded)
+{
+    group_get_all_response response{ request.client_context_id, ec };
+    if (!ec) {
+        if (encoded.status_code == 200) {
+            tao::json::value payload = tao::json::from_string(encoded.body);
+            for (const auto& entry : payload.get_array()) {
+                response.groups.emplace_back(entry.as<rbac::group>());
+            }
+        } else {
+            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/group_upsert.hxx

@@ -0,0 +1,118 @@
+/* -*- 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 <spdlog/spdlog.h>
+
+#include <platform/uuid.h>
+#include <io/http_message.hxx>
+#include <operations/rbac.hxx>
+#include <utils/url_codec.hxx>
+#include <timeout_defaults.hxx>
+#include <errors.hxx>
+
+namespace couchbase::operations
+{
+
+struct group_upsert_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::vector<std::string> errors{};
+};
+
+struct group_upsert_request {
+    using response_type = group_upsert_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    rbac::group group{};
+    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 = "PUT";
+        encoded.path = fmt::format("/settings/rbac/groups/{}", group.name);
+        std::vector<std::string> params{};
+        if (group.description) {
+            std::string param{};
+            utils::string_codec::url_encode(group.description.value(), param);
+            params.push_back(fmt::format("description={}", param));
+        }
+        if (group.ldap_group_reference) {
+            std::string param{};
+            utils::string_codec::url_encode(group.ldap_group_reference.value(), param);
+            params.push_back(fmt::format("ldap_group_ref={}", param));
+        }
+        std::vector<std::string> encoded_roles{};
+        encoded_roles.reserve(group.roles.size());
+        for (const auto& role : group.roles) {
+            std::string spec = role.name;
+            if (role.bucket) {
+                spec += fmt::format("[{}", role.bucket.value());
+                if (role.scope) {
+                    spec += fmt::format(":{}", role.scope.value());
+                    if (role.collection) {
+                        spec += fmt::format(":{}", role.collection.value());
+                    }
+                }
+                spec += "]";
+            }
+            encoded_roles.push_back(spec);
+        }
+        if (!encoded_roles.empty()) {
+            std::string concatenated = fmt::format("{}", fmt::join(encoded_roles, ","));
+            std::string param{};
+            utils::string_codec::url_encode(concatenated, param);
+            params.push_back(fmt::format("roles={}", param));
+        }
+        encoded.body = fmt::format("{}", fmt::join(params, "&"));
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    }
+};
+
+group_upsert_response
+make_response(std::error_code ec, group_upsert_request& request, group_upsert_request::encoded_response_type encoded)
+{
+    group_upsert_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 200:
+                break;
+            case 400: {
+                response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                tao::json::value payload = tao::json::from_string(encoded.body);
+                const auto* errors = payload.find("errors");
+                if (errors != nullptr && errors->is_object()) {
+                    for (const auto& entry : errors->get_object()) {
+                        response.errors.emplace_back(fmt::format("{}: {}", entry.first, entry.second.get_string()));
+                    }
+                }
+            } break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_build_deferred.hxx

@@ -45,7 +45,7 @@ struct query_index_build_deferred_request {
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value body{

data/ext/couchbase/operations/query_index_create.hxx

@@ -55,7 +55,7 @@ struct query_index_create_request {
     std::optional<int> num_replicas{};
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value with{};

data/ext/couchbase/operations/query_index_drop.hxx

@@ -51,7 +51,7 @@ struct query_index_drop_request {
     bool ignore_if_does_not_exist{ false };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         std::string keyspace = fmt::format("`{}`", bucket_name);

data/ext/couchbase/operations/query_index_get_all.hxx

@@ -56,14 +56,15 @@ struct query_index_get_all_request {
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value body{
             { "statement",
               fmt::format(
                 R"(SELECT idx.* FROM system:indexes AS idx WHERE ((keyspace_id = "{}" AND bucket_id IS MISSING) OR (bucket_id = "{}")) AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
-                bucket_name, bucket_name) },
+                bucket_name,
+                bucket_name) },
             { "client_context_id", client_context_id }
         };
         encoded.method = "POST";

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 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);
+    }
+};