couchbase 3.0.0 → 3.0.1

data/ext/couchbase/operations/user_get.hxx

@@ -0,0 +1,76 @@
+/* -*- 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 user_get_response {
+    std::string client_context_id;
+    std::error_code ec;
+    rbac::user_and_metadata user{};
+};
+
+struct user_get_request {
+    using response_type = user_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 username{};
+    rbac::auth_domain domain{ rbac::auth_domain::local };
+    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/users/{}/{}", domain, username);
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    }
+};
+
+user_get_response
+make_response(std::error_code ec, user_get_request& request, user_get_request::encoded_response_type encoded)
+{
+    user_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.user = payload.as<rbac::user_and_metadata>();
+            } break;
+            case 404:
+                response.ec = std::make_error_code(error::management_errc::user_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/user_get_all.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 user_get_all_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::vector<rbac::user_and_metadata> users{};
+};
+
+struct user_get_all_request {
+    using response_type = user_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;
+
+    rbac::auth_domain domain{ rbac::auth_domain::local };
+    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/users/{}", domain);
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    }
+};
+
+user_get_all_response
+make_response(std::error_code ec, user_get_all_request& request, user_get_all_request::encoded_response_type encoded)
+{
+    user_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.users.emplace_back(entry.as<rbac::user_and_metadata>());
+            }
+        } else {
+            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/user_upsert.hxx

@@ -0,0 +1,125 @@
+/* -*- 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 user_upsert_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::vector<std::string> errors{};
+};
+
+struct user_upsert_request {
+    using response_type = user_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::auth_domain domain{ rbac::auth_domain::local };
+    rbac::user user{};
+    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/users/{}/{}", domain, user.username);
+        std::vector<std::string> params{};
+        if (user.display_name) {
+            std::string param{};
+            utils::string_codec::url_encode(user.display_name.value(), param);
+            params.push_back(fmt::format("name={}", param));
+        }
+        if (user.password) {
+            std::string param{};
+            utils::string_codec::url_encode(user.password.value(), param);
+            params.push_back(fmt::format("password={}", param));
+        }
+        {
+            std::string encoded_groups = fmt::format("{}", fmt::join(user.groups, ","));
+            std::string param{};
+            utils::string_codec::url_encode(encoded_groups, param);
+            params.push_back(fmt::format("groups={}", param));
+        }
+        std::vector<std::string> encoded_roles{};
+        encoded_roles.reserve(user.roles.size());
+        for (const auto& role : user.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";
+    }
+};
+
+user_upsert_response
+make_response(std::error_code ec, user_upsert_request& request, user_upsert_request::encoded_response_type encoded)
+{
+    user_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/view_index_drop.hxx

@@ -40,7 +40,7 @@ struct view_index_drop_request {
     std::string document_name;
     design_document::name_space name_space;
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
         encoded.path =

data/ext/couchbase/operations/view_index_get.hxx

@@ -42,7 +42,7 @@ struct view_index_get_request {
     std::string document_name;
     design_document::name_space name_space;
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path =

data/ext/couchbase/operations/view_index_get_all.hxx

@@ -41,7 +41,7 @@ struct view_index_get_all_request {
     std::string bucket_name;
     design_document::name_space name_space;
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);

data/ext/couchbase/operations/view_index_upsert.hxx

@@ -39,7 +39,7 @@ struct view_index_upsert_request {
     std::string bucket_name;
     design_document document;
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body;
         body["views"] = tao::json::empty_object;

data/ext/couchbase/origin.hxx

@@ -24,10 +24,10 @@
 namespace couchbase
 {
 struct cluster_credentials {
-    std::string username;
-    std::string password;
-    std::string certificate_path;
-    std::string key_path;
+    std::string username{};
+    std::string password{};
+    std::string certificate_path{};
+    std::string key_path{};
 
     [[nodiscard]] bool uses_certificate() const
     {

data/ext/couchbase/platform/terminate_handler.cc

@@ -40,7 +40,7 @@ log_handled_exception()
     // seems to result in immediate process termination). As such skip logging
     // the exception here.
     return;
-#endif
+#else
     // Attempt to get the exception's what() message.
     try {
         static int tried_throw = 0;
@@ -54,6 +54,7 @@ log_handled_exception()
     } catch (...) {
         spdlog::critical("Caught unknown/unhandled exception.");
     }
+#endif
 }
 
 // Log the symbolified backtrace to this point.
@@ -80,8 +81,8 @@ log_backtrace()
 static void
 backtrace_terminate_handler()
 {
-    spdlog::critical("*** Fatal error encountered during exception handling (rev=\"" BACKEND_GIT_REVISION "\", compiler=\"" BACKEND_CXX_COMPILER
-                     "\", system=\"" BACKEND_SYSTEM "\", date=\"" BACKEND_BUILD_TIMESTAMP "\")***");
+    spdlog::critical("*** Fatal error encountered during exception handling (rev=\"" BACKEND_GIT_REVISION
+                     "\", compiler=\"" BACKEND_CXX_COMPILER "\", system=\"" BACKEND_SYSTEM "\", date=\"" BACKEND_BUILD_TIMESTAMP "\")***");
     log_handled_exception();
 
     if (should_include_backtrace) {
@@ -119,4 +120,4 @@ set_terminate_handler_print_backtrace(bool print)
     should_include_backtrace = print;
 }
 
-} // namespace couchbase::platform
+} // namespace couchbase::platform

data/ext/couchbase/protocol/client_opcode.hxx

@@ -133,76 +133,76 @@ struct fmt::formatter<couchbase::protocol::client_opcode> : formatter<string_vie
         string_view name = "unknown";
         switch (opcode) {
             case couchbase::protocol::client_opcode::get:
-                name = "get";
+                name = "get (0x00)";
                 break;
             case couchbase::protocol::client_opcode::upsert:
-                name = "upsert";
+                name = "upsert (0x01)";
                 break;
             case couchbase::protocol::client_opcode::insert:
-                name = "insert";
+                name = "insert (0x02)";
                 break;
             case couchbase::protocol::client_opcode::replace:
-                name = "replace";
+                name = "replace (0x03)";
                 break;
             case couchbase::protocol::client_opcode::remove:
-                name = "remove";
+                name = "remove (0x04)";
                 break;
             case couchbase::protocol::client_opcode::hello:
-                name = "hello";
+                name = "hello (0x1f)";
                 break;
             case couchbase::protocol::client_opcode::sasl_list_mechs:
-                name = "sasl_list_mechs";
+                name = "sasl_list_mechs (0x20)";
                 break;
             case couchbase::protocol::client_opcode::sasl_auth:
-                name = "sasl_auth";
+                name = "sasl_auth (0x21)";
                 break;
             case couchbase::protocol::client_opcode::sasl_step:
-                name = "sasl_step";
+                name = "sasl_step (0x22)";
                 break;
             case couchbase::protocol::client_opcode::select_bucket:
-                name = "select_bucket";
+                name = "select_bucket (0x89)";
                 break;
             case couchbase::protocol::client_opcode::subdoc_multi_lookup:
-                name = "subdoc_multi_lookup";
+                name = "subdoc_multi_lookup (0xd0)";
                 break;
             case couchbase::protocol::client_opcode::subdoc_multi_mutation:
-                name = "subdoc_multi_mutation";
+                name = "subdoc_multi_mutation (0xd1)";
                 break;
             case couchbase::protocol::client_opcode::get_cluster_config:
-                name = "get_cluster_config";
+                name = "get_cluster_config (0xb5)";
                 break;
             case couchbase::protocol::client_opcode::get_error_map:
-                name = "get_error_map";
+                name = "get_error_map (0xfe)";
                 break;
             case couchbase::protocol::client_opcode::invalid:
-                name = "invalid";
+                name = "invalid (0xff)";
                 break;
             case couchbase::protocol::client_opcode::get_collections_manifest:
-                name = "get_collections_manifest";
+                name = "get_collections_manifest (0xba)";
                 break;
             case couchbase::protocol::client_opcode::touch:
-                name = "touch";
+                name = "touch (0x1c)";
                 break;
             case couchbase::protocol::client_opcode::observe:
-                name = "observe";
+                name = "observe (0x92)";
                 break;
             case couchbase::protocol::client_opcode::get_and_lock:
-                name = "get_and_lock";
+                name = "get_and_lock (0x94)";
                 break;
             case couchbase::protocol::client_opcode::unlock:
-                name = "unlock";
+                name = "unlock (0x95)";
                 break;
             case couchbase::protocol::client_opcode::get_and_touch:
-                name = "get_and_touch";
+                name = "get_and_touch (0x1d)";
                 break;
             case couchbase::protocol::client_opcode::increment:
-                name = "increment";
+                name = "increment (0x05)";
                 break;
             case couchbase::protocol::client_opcode::decrement:
-                name = "decrement";
+                name = "decrement (0x06)";
                 break;
             case couchbase::protocol::client_opcode::get_collection_id:
-                name = "get_collection_uid";
+                name = "get_collection_uid (0xbb)";
                 break;
         }
         return formatter<string_view>::format(name, ctx);
@@ -217,46 +217,46 @@ struct fmt::formatter<couchbase::protocol::subdoc_opcode> : formatter<string_vie
         string_view name = "unknown";
         switch (opcode) {
             case couchbase::protocol::subdoc_opcode::get:
-                name = "get";
+                name = "get (0xc5)";
                 break;
             case couchbase::protocol::subdoc_opcode::exists:
-                name = "exists";
+                name = "exists (0xc6)";
                 break;
             case couchbase::protocol::subdoc_opcode::dict_add:
-                name = "dict_add";
+                name = "dict_add (0xc7)";
                 break;
             case couchbase::protocol::subdoc_opcode::dict_upsert:
-                name = "dict_upsert";
+                name = "dict_upsert (0xc8)";
                 break;
             case couchbase::protocol::subdoc_opcode::remove:
-                name = "remove";
+                name = "remove (0xc9)";
                 break;
             case couchbase::protocol::subdoc_opcode::replace:
-                name = "replace";
+                name = "replace (0xca)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_push_last:
-                name = "array_push_last";
+                name = "array_push_last (0xcb)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_push_first:
-                name = "array_push_first";
+                name = "array_push_first (0xcc)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_insert:
-                name = "array_insert";
+                name = "array_insert (0xcd)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_add_unique:
-                name = "array_add_unique";
+                name = "array_add_unique (0xce)";
                 break;
             case couchbase::protocol::subdoc_opcode::counter:
-                name = "counter";
+                name = "counter (0xcf)";
                 break;
             case couchbase::protocol::subdoc_opcode::get_count:
-                name = "get_count";
+                name = "get_count (0xd2)";
                 break;
             case couchbase::protocol::subdoc_opcode::get_doc:
-                name = "get_doc";
+                name = "get_doc (0x00)";
                 break;
             case couchbase::protocol::subdoc_opcode::set_doc:
-                name = "set_doc";
+                name = "set_doc (0x01)";
                 break;
         }
         return formatter<string_view>::format(name, ctx);