couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/ext/couchbase/operations/analytics_index_get_all.hxx

@@ -53,7 +53,7 @@ struct analytics_index_get_all_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         tao::json::value body{
             { "statement", "SELECT d.* FROM Metadata.`Index` d WHERE d.DataverseName <> \"Metadata\"" },
@@ -68,16 +68,18 @@ struct analytics_index_get_all_request {
 };
 
 analytics_index_get_all_response
-make_response(error_context::http&& ctx, analytics_index_get_all_request&, analytics_index_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const analytics_index_get_all_request& /* request */,
+              analytics_index_get_all_request::encoded_response_type&& encoded)
 {
-    analytics_index_get_all_response response{ ctx };
+    analytics_index_get_all_response response{ std::move(ctx) };
 
     if (!response.ctx.ec) {
         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);
+        } catch (const tao::json::pegtl::parse_error& e) {
+            response.ctx.ec = error::common_errc::parsing_failure;
             return response;
         }
         response.status = payload.at("status").get_string();
@@ -104,7 +106,7 @@ make_response(error_context::http&& ctx, analytics_index_get_all_request&, analy
                     response.errors.emplace_back(err);
                 }
             }
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/analytics_link.hxx

@@ -0,0 +1,39 @@
+/* -*- 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 <optional>
+#include <sstream>
+#include <string>
+
+#include <operations/analytics_link_azure_blob_external.hxx>
+#include <operations/analytics_link_couchbase_remote.hxx>
+#include <operations/analytics_link_s3_external.hxx>
+
+namespace couchbase::operations::analytics_link
+{
+template<typename analytics_link_type>
+std::string
+endpoint_from_link(const analytics_link_type& link)
+{
+    if (std::count(link.dataverse.begin(), link.dataverse.end(), '/') > 0) {
+        return fmt::format("/analytics/link/{}/{}", utils::string_codec::v2::path_escape(link.dataverse), link.link_name);
+    }
+    return "/analytics/link";
+}
+} // namespace couchbase::operations::analytics_link

data/ext/couchbase/operations/analytics_link_azure_blob_external.hxx

@@ -0,0 +1,145 @@
+/* -*- 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 <optional>
+#include <map>
+#include <string>
+
+#include <errors.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations::analytics_link
+{
+/**
+ * An external analytics link which uses the Microsoft Azure Blob Storage service.
+ * Only available as of 7.0 Developer Preview.
+ */
+struct azure_blob_external {
+    /**
+     * The name of this link.
+     */
+    std::string link_name{};
+
+    /**
+     * The dataverse that this link belongs to.
+     */
+    std::string dataverse{};
+
+    /**
+     * The connection string can be used as an authentication method, connectionString contains other authentication methods embedded inside
+     * the string. Only a single authentication method can be used. (e.g. "AccountName=myAccountName;AccountKey=myAccountKey").
+     */
+    std::optional<std::string> connection_string{};
+
+    /**
+     * Azure blob storage account name
+     */
+    std::optional<std::string> account_name{};
+
+    /**
+     * Azure blob storage account key
+     */
+    std::optional<std::string> account_key{};
+
+    /**
+     * Token that can be used for authentication
+     */
+    std::optional<std::string> shared_access_signature{};
+
+    /**
+     * Azure blob storage endpoint
+     */
+    std::optional<std::string> blob_endpoint{};
+
+    /**
+     * Azure blob endpoint suffix
+     */
+    std::optional<std::string> endpoint_suffix{};
+
+    [[nodiscard]] std::error_code validate() const
+    {
+        if (dataverse.empty() || link_name.empty()) {
+            return error::common_errc::invalid_argument;
+        }
+        if (connection_string.has_value() ||
+            (account_name.has_value() && (account_key.has_value() || shared_access_signature.has_value()))) {
+            return {};
+        }
+        return error::common_errc::invalid_argument;
+    }
+
+    [[nodiscard]] std::string encode() const
+    {
+        std::map<std::string, std::string> values{
+            { "type", "azureblob" },
+        };
+        if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
+            values["dataverse"] = dataverse;
+            values["name"] = link_name;
+        }
+        if (connection_string) {
+            values["connectionString"] = connection_string.value();
+        } else if (account_name) {
+            values["accountName"] = account_name.value();
+            if (account_key) {
+                values["accountKey"] = account_key.value();
+            } else if (shared_access_signature) {
+                values["sharedAccessSignature"] = shared_access_signature.value();
+            }
+        }
+        if (blob_endpoint) {
+            values["blobEndpoint"] = blob_endpoint.value();
+        }
+        if (endpoint_suffix) {
+            values["endpointSuffix"] = endpoint_suffix.value();
+        }
+        return utils::string_codec::v2::form_encode(values);
+    }
+};
+} // namespace couchbase::operations::analytics_link
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::operations::analytics_link::azure_blob_external> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::analytics_link::azure_blob_external as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::analytics_link::azure_blob_external result{};
+
+        result.link_name = v.at("name").get_string();
+        if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {
+            result.dataverse = dataverse->get_string();
+        } else {
+            result.dataverse = v.at("scope").get_string();
+        }
+
+        if (const auto* account_name = v.find("accountName"); account_name != nullptr && account_name->is_string()) {
+            result.account_name.emplace(account_name->get_string());
+        }
+        if (const auto* blob_endpoint = v.find("blobEndpoint"); blob_endpoint != nullptr && blob_endpoint->is_string()) {
+            result.blob_endpoint.emplace(blob_endpoint->get_string());
+        }
+        if (const auto* endpoint_suffix = v.find("endpointSuffix"); endpoint_suffix != nullptr && endpoint_suffix->is_string()) {
+            result.endpoint_suffix.emplace(endpoint_suffix->get_string());
+        }
+        return result;
+    }
+};
+} // namespace tao::json

data/ext/couchbase/operations/analytics_link_connect.hxx

@@ -19,7 +19,7 @@
 
 #include <tao/json.hpp>
 
-#include <version.hxx>
+#include <utils/name_codec.hxx>
 
 namespace couchbase::operations
 {
@@ -46,15 +46,16 @@ struct analytics_link_connect_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
     std::string dataverse_name{ "Default" };
-    std::string link_name;
+    std::string link_name{ "Local" };
     bool force{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         std::string with_clause = force ? "WITH {\"force\": true}" : "";
 
         tao::json::value body{
-            { "statement", fmt::format("CONNECT LINK `{}`.`{}` {}", dataverse_name, link_name, with_clause) },
+            { "statement",
+              fmt::format("CONNECT LINK {}.`{}` {}", utils::analytics::uncompound_name(dataverse_name), link_name, with_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
@@ -65,15 +66,17 @@ struct analytics_link_connect_request {
 };
 
 analytics_link_connect_response
-make_response(error_context::http&& ctx, analytics_link_connect_request&, analytics_link_connect_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const analytics_link_connect_request& /* request */,
+              analytics_link_connect_request::encoded_response_type&& encoded)
 {
-    analytics_link_connect_response response{ ctx };
+    analytics_link_connect_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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);
+        } catch (const tao::json::pegtl::parse_error& e) {
+            response.ctx.ec = error::common_errc::parsing_failure;
             return response;
         }
         response.status = payload.at("status").get_string();
@@ -81,8 +84,7 @@ make_response(error_context::http&& ctx, analytics_link_connect_request&, analyt
         if (response.status != "success") {
             bool link_not_found = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_link_connect_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -97,9 +99,9 @@ make_response(error_context::http&& ctx, analytics_link_connect_request&, analyt
                 }
             }
             if (link_not_found) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::link_not_found);
+                response.ctx.ec = error::analytics_errc::link_not_found;
             } else {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
             }
         }
     }

data/ext/couchbase/operations/analytics_link_couchbase_remote.hxx

@@ -0,0 +1,220 @@
+/* -*- 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 <optional>
+#include <map>
+#include <string>
+
+#include <errors.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations::analytics_link
+{
+enum class encryption_level {
+    /**
+     * Connect to the remote Couchbase cluster using an unsecured channel. Send the password in plaintext.
+     */
+    none,
+
+    /**
+     * Connect to the remote Couchbase cluster using an unsecured channel. Send the password securely using SASL.
+     */
+    half,
+
+    /**
+     * Connect to the remote Couchbase cluster using a channel secured by TLS. If a password is used, it is sent over the secure channel.
+     *
+     * Requires specifying the certificate to trust.
+     */
+    full,
+};
+
+std::string
+to_string(encryption_level level)
+{
+    switch (level) {
+        case encryption_level::none:
+            return "none";
+
+        case encryption_level::half:
+            return "half";
+
+        case encryption_level::full:
+            return "full";
+    }
+    return "none";
+}
+
+struct encryption_settings {
+    /**
+     * Specifies what level of encryption should be used.
+     */
+    encryption_level level{ encryption_level::none };
+
+    /**
+     * Provides a certificate to use for connecting when encryption level is set to 'full'.  Required when 'encryption_level' is set to
+     * 'full'.
+     */
+    std::optional<std::string> certificate{};
+
+    /**
+     * Provides a client certificate to use for connecting when encryption level is set to 'full'.  Cannot be set if a username/password are
+     * used.
+     */
+    std::optional<std::string> client_certificate{};
+
+    /**
+     * Provides a client key to use for connecting when encryption level is set to 'full'.  Cannot be set if a username/password are used.
+     */
+    std::optional<std::string> client_key{};
+};
+
+/**
+ * A remote analytics link which uses a Couchbase data service that is not part of the same cluster as the Analytics Service.
+ */
+struct couchbase_remote {
+    /**
+     * The name of this link.
+     */
+    std::string link_name{};
+
+    /**
+     * The dataverse that this link belongs to.
+     */
+    std::string dataverse{};
+
+    /**
+     * The hostname of the target Couchbase cluster.
+     */
+    std::string hostname{};
+
+    /**
+     * The username to use for authentication with the remote cluster. Optional if client-certificate authentication is being used.
+     */
+    std::optional<std::string> username{};
+
+    /**
+     * The password to use for authentication with the remote cluster. Optional if client-certificate authentication is being used.
+     */
+    std::optional<std::string> password{};
+
+    encryption_settings encryption{};
+
+    [[nodiscard]] std::error_code validate() const
+    {
+        if (dataverse.empty() || link_name.empty() || hostname.empty()) {
+            return error::common_errc::invalid_argument;
+        }
+        switch (encryption.level) {
+            case encryption_level::none:
+            case encryption_level::half:
+                if (/* username and password must be provided */ username.has_value() && password.has_value() &&
+                    /* and client certificate and key must be empty */
+                    (!encryption.client_certificate.has_value() && !encryption.client_key.has_value())) {
+
+                    return {};
+                }
+                return error::common_errc::invalid_argument;
+
+            case encryption_level::full:
+                if (/* certificate must be provided and */ encryption.certificate.has_value() &&
+                    (/* either username/password must be set */ (username.has_value() && password.has_value() &&
+                                                                 !encryption.client_certificate.has_value() &&
+                                                                 !encryption.client_key.has_value()) ||
+                     /* or client certificate/key must be set */ (!username.has_value() && !password.has_value() &&
+                                                                  encryption.client_certificate.has_value() &&
+                                                                  encryption.client_key.has_value()))) {
+                    return {};
+                }
+                return error::common_errc::invalid_argument;
+        }
+        return {};
+    }
+
+    [[nodiscard]] std::string encode() const
+    {
+        std::map<std::string, std::string> values{
+            { "type", "couchbase" },
+            { "hostname", hostname },
+            { "encryption", to_string(encryption.level) },
+        };
+        if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
+            values["dataverse"] = dataverse;
+            values["name"] = link_name;
+        }
+        if (username) {
+            values["username"] = username.value();
+        }
+        if (password) {
+            values["password"] = password.value();
+        }
+        if (encryption.certificate) {
+            values["certificate"] = encryption.certificate.value();
+        }
+        if (encryption.client_certificate) {
+            values["clientCertificate"] = encryption.client_certificate.value();
+        }
+        if (encryption.client_key) {
+            values["clientKey"] = encryption.client_key.value();
+        }
+        return utils::string_codec::v2::form_encode(values);
+    }
+};
+} // namespace couchbase::operations::analytics_link
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::operations::analytics_link::couchbase_remote> {
+    template<template<typename...> class Traits>
+    static couchbase::operations::analytics_link::couchbase_remote as(const tao::json::basic_value<Traits>& v)
+    {
+        couchbase::operations::analytics_link::couchbase_remote result{};
+
+        result.link_name = v.at("name").get_string();
+        if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {
+            result.dataverse = dataverse->get_string();
+        } else {
+            result.dataverse = v.at("scope").get_string();
+        }
+        result.hostname = v.at("activeHostname").get_string();
+        if (const auto* encryption = v.find("encryption"); encryption != nullptr && encryption->is_string()) {
+            const auto& level = encryption->get_string();
+            if (level == "none") {
+                result.encryption.level = couchbase::operations::analytics_link::encryption_level::none;
+            } else if (level == "half") {
+                result.encryption.level = couchbase::operations::analytics_link::encryption_level::half;
+            } else if (level == "full") {
+                result.encryption.level = couchbase::operations::analytics_link::encryption_level::full;
+            }
+        }
+        if (const auto* username = v.find("username"); username != nullptr && username->is_string()) {
+            result.username.emplace(username->get_string());
+        }
+        if (const auto* certificate = v.find("certificate"); certificate != nullptr && certificate->is_string()) {
+            result.encryption.certificate.emplace(certificate->get_string());
+        }
+        if (const auto* client_certificate = v.find("clientCertificate");
+            client_certificate != nullptr && client_certificate->is_string()) {
+            result.encryption.client_certificate.emplace(client_certificate->get_string());
+        }
+        return result;
+    }
+};
+} // namespace tao::json