couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/management/analytics_link_couchbase_remote.hxx

@@ -24,84 +24,91 @@
 namespace couchbase::core::management::analytics
 {
 enum class couchbase_link_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,
+  /**
+   * 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(couchbase_link_encryption_level level);
+auto
+to_string(couchbase_link_encryption_level level) -> std::string;
 
 struct couchbase_link_encryption_settings {
-    /**
-     * Specifies what level of encryption should be used.
-     */
-    couchbase_link_encryption_level level{ couchbase_link_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{};
+  /**
+   * Specifies what level of encryption should be used.
+   */
+  couchbase_link_encryption_level level{ couchbase_link_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.
+ * 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_link {
-    /**
-     * 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{};
-
-    couchbase_link_encryption_settings encryption{};
-
-    [[nodiscard]] std::error_code validate() const;
-
-    [[nodiscard]] std::string encode() const;
+  /**
+   * 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{};
+
+  couchbase_link_encryption_settings encryption{};
+
+  [[nodiscard]] auto validate() const -> std::error_code;
+
+  [[nodiscard]] auto encode() const -> std::string;
 };
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_link_couchbase_remote_json.hxx

@@ -25,39 +25,45 @@ namespace tao::json
 {
 template<>
 struct traits<couchbase::core::management::analytics::couchbase_remote_link> {
-    template<template<typename...> class Traits>
-    static couchbase::core::management::analytics::couchbase_remote_link as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::core::management::analytics::couchbase_remote_link result{};
+  template<template<typename...> class Traits>
+  static auto as(const tao::json::basic_value<Traits>& v)
+    -> couchbase::core::management::analytics::couchbase_remote_link
+  {
+    couchbase::core::management::analytics::couchbase_remote_link 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::core::management::analytics::couchbase_link_encryption_level::none;
-            } else if (level == "half") {
-                result.encryption.level = couchbase::core::management::analytics::couchbase_link_encryption_level::half;
-            } else if (level == "full") {
-                result.encryption.level = couchbase::core::management::analytics::couchbase_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;
+    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::core::management::analytics::couchbase_link_encryption_level::none;
+      } else if (level == "half") {
+        result.encryption.level =
+          couchbase::core::management::analytics::couchbase_link_encryption_level::half;
+      } else if (level == "full") {
+        result.encryption.level =
+          couchbase::core::management::analytics::couchbase_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

data/ext/couchbase/core/management/analytics_link_s3_external.cxx

@@ -25,34 +25,35 @@
 
 namespace couchbase::core::management::analytics
 {
-std::error_code
-s3_external_link::validate() const
+auto
+s3_external_link::validate() const -> std::error_code
 {
-    if (dataverse.empty() || link_name.empty() || access_key_id.empty() || secret_access_key.empty() || region.empty()) {
-        return errc::common::invalid_argument;
-    }
-    return {};
+  if (dataverse.empty() || link_name.empty() || access_key_id.empty() ||
+      secret_access_key.empty() || region.empty()) {
+    return errc::common::invalid_argument;
+  }
+  return {};
 }
 
-std::string
-s3_external_link::encode() const
+auto
+s3_external_link::encode() const -> std::string
 {
-    std::map<std::string, std::string> values{
-        { "type", "s3" },
-        { "accessKeyId", access_key_id },
-        { "secretAccessKey", secret_access_key },
-        { "region", region },
-    };
-    if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
-        values["dataverse"] = dataverse;
-        values["name"] = link_name;
-    }
-    if (session_token) {
-        values["sessionToken"] = session_token.value();
-    }
-    if (service_endpoint) {
-        values["serviceEndpoint"] = service_endpoint.value();
-    }
-    return utils::string_codec::v2::form_encode(values);
+  std::map<std::string, std::string> values{
+    { "type", "s3" },
+    { "accessKeyId", access_key_id },
+    { "secretAccessKey", secret_access_key },
+    { "region", region },
+  };
+  if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
+    values["dataverse"] = dataverse;
+    values["name"] = link_name;
+  }
+  if (session_token) {
+    values["sessionToken"] = session_token.value();
+  }
+  if (service_endpoint) {
+    values["serviceEndpoint"] = service_endpoint.value();
+  }
+  return utils::string_codec::v2::form_encode(values);
 }
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_link_s3_external.hxx

@@ -27,43 +27,43 @@ namespace couchbase::core::management::analytics
  * An external analytics link which uses the AWS S3 service to access data.
  */
 struct s3_external_link {
-    /**
-     * The name of this link.
-     */
-    std::string link_name{};
+  /**
+   * The name of this link.
+   */
+  std::string link_name{};
 
-    /**
-     * The dataverse that this link belongs to.
-     */
-    std::string dataverse{};
+  /**
+   * The dataverse that this link belongs to.
+   */
+  std::string dataverse{};
 
-    /**
-     * AWS S3 access key ID
-     */
-    std::string access_key_id{};
+  /**
+   * AWS S3 access key ID
+   */
+  std::string access_key_id{};
 
-    /**
-     * AWS S3 secret key
-     */
-    std::string secret_access_key{};
+  /**
+   * AWS S3 secret key
+   */
+  std::string secret_access_key{};
 
-    /**
-     * AWS S3 token if temporary credentials are provided. Only available in 7.0+
-     */
-    std::optional<std::string> session_token{};
+  /**
+   * AWS S3 token if temporary credentials are provided. Only available in 7.0+
+   */
+  std::optional<std::string> session_token{};
 
-    /**
-     * AWS S3 region
-     */
-    std::string region{};
+  /**
+   * AWS S3 region
+   */
+  std::string region{};
 
-    /**
-     * AWS S3 service endpoint
-     */
-    std::optional<std::string> service_endpoint{};
+  /**
+   * AWS S3 service endpoint
+   */
+  std::optional<std::string> service_endpoint{};
 
-    [[nodiscard]] std::error_code validate() const;
+  [[nodiscard]] auto validate() const -> std::error_code;
 
-    [[nodiscard]] std::string encode() const;
+  [[nodiscard]] auto encode() const -> std::string;
 };
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_link_s3_external_json.hxx

@@ -25,23 +25,25 @@ namespace tao::json
 {
 template<>
 struct traits<couchbase::core::management::analytics::s3_external_link> {
-    template<template<typename...> class Traits>
-    static couchbase::core::management::analytics::s3_external_link as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::core::management::analytics::s3_external_link result{};
+  template<template<typename...> class Traits>
+  static auto as(const tao::json::basic_value<Traits>& v)
+    -> couchbase::core::management::analytics::s3_external_link
+  {
+    couchbase::core::management::analytics::s3_external_link 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.access_key_id = v.at("accessKeyId").get_string();
-        result.region = v.at("region").get_string();
-        if (const auto* service_endpoint = v.find("serviceEndpoint"); service_endpoint != nullptr && service_endpoint->is_string()) {
-            result.service_endpoint.emplace(service_endpoint->get_string());
-        }
-        return 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.access_key_id = v.at("accessKeyId").get_string();
+    result.region = v.at("region").get_string();
+    if (const auto* service_endpoint = v.find("serviceEndpoint");
+        service_endpoint != nullptr && service_endpoint->is_string()) {
+      result.service_endpoint.emplace(service_endpoint->get_string());
+    }
+    return result;
+  }
 };
 } // namespace tao::json

data/ext/couchbase/core/management/bucket_settings.hxx

@@ -26,112 +26,130 @@
 
 namespace couchbase::core::management::cluster
 {
-enum class bucket_type { unknown, couchbase, memcached, ephemeral };
-enum class bucket_compression { unknown, off, active, passive };
+enum class bucket_type {
+  unknown,
+  couchbase,
+  memcached,
+  ephemeral
+};
+enum class bucket_compression {
+  unknown,
+  off,
+  active,
+  passive
+};
 enum class bucket_eviction_policy {
-    unknown,
+  unknown,
 
-    /**
-     * During ejection, everything (including key, metadata, and value) will be ejected.
-     *
-     * Full Ejection reduces the memory overhead requirement, at the cost of performance.
-     *
-     * This value is only valid for buckets of type COUCHBASE.
-     */
-    full,
+  /**
+   * During ejection, everything (including key, metadata, and value) will be ejected.
+   *
+   * Full Ejection reduces the memory overhead requirement, at the cost of performance.
+   *
+   * This value is only valid for buckets of type COUCHBASE.
+   */
+  full,
 
-    /**
-     * During ejection, only the value will be ejected (key and metadata will remain in memory).
-     *
-     * Value Ejection needs more system memory, but provides better performance than Full Ejection.
-     *
-     * This value is only valid for buckets of type COUCHBASE.
-     */
-    value_only,
+  /**
+   * During ejection, only the value will be ejected (key and metadata will remain in memory).
+   *
+   * Value Ejection needs more system memory, but provides better performance than Full Ejection.
+   *
+   * This value is only valid for buckets of type COUCHBASE.
+   */
+  value_only,
 
-    /**
-     * Couchbase Server keeps all data until explicitly deleted, but will reject
-     * any new data if you reach the quota (dedicated memory) you set for your bucket.
-     *
-     * This value is only valid for buckets of type EPHEMERAL.
-     */
-    no_eviction,
+  /**
+   * Couchbase Server keeps all data until explicitly deleted, but will reject
+   * any new data if you reach the quota (dedicated memory) you set for your bucket.
+   *
+   * This value is only valid for buckets of type EPHEMERAL.
+   */
+  no_eviction,
 
-    /**
-     * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
-     *
-     * This value is only valid for buckets of type EPHEMERAL.
-     */
-    not_recently_used,
+  /**
+   * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
+   *
+   * This value is only valid for buckets of type EPHEMERAL.
+   */
+  not_recently_used,
 };
 enum class bucket_conflict_resolution {
-    unknown,
-    /**
-     * Use timestamp conflict resolution.
-     *
-     * Timestamp-based conflict resolution (often referred to as Last Write Wins, or LWW) uses the document
-     * timestamp (stored in the CAS) to resolve conflicts. The timestamps associated with the most recent
-     * updates of source and target documents are compared. The document whose update has the more recent
-     * timestamp prevails.
-     */
-    timestamp,
+  unknown,
+  /**
+   * Use timestamp conflict resolution.
+   *
+   * Timestamp-based conflict resolution (often referred to as Last Write Wins, or LWW) uses the
+   * document timestamp (stored in the CAS) to resolve conflicts. The timestamps associated with the
+   * most recent updates of source and target documents are compared. The document whose update has
+   * the more recent timestamp prevails.
+   */
+  timestamp,
 
-    /**
-     * Use sequence number conflict resolution
-     *
-     * Conflicts can be resolved by referring to documents' sequence numbers. Sequence numbers are maintained
-     * per document, and are incremented on every document-update. The sequence numbers of source and
-     * target documents are compared; and the document with the higher sequence number prevails.
-     */
-    sequence_number,
+  /**
+   * Use sequence number conflict resolution
+   *
+   * Conflicts can be resolved by referring to documents' sequence numbers. Sequence numbers are
+   * maintained per document, and are incremented on every document-update. The sequence numbers of
+   * source and target documents are compared; and the document with the higher sequence number
+   * prevails.
+   */
+  sequence_number,
 
-    /**
-     * VOLATILE: This API is subject to change at any time.
-     *
-     * In Couchbase Server 7.1, this feature is only available in "developer-preview" mode. See the UI XDCR settings.
-     */
-    custom,
+  /**
+   * VOLATILE: This API is subject to change at any time.
+   *
+   * In Couchbase Server 7.1, this feature is only available in "developer-preview" mode. See the UI
+   * XDCR settings.
+   */
+  custom,
+};
+enum class bucket_storage_backend {
+  unknown,
+  couchstore,
+  magma
 };
-enum class bucket_storage_backend { unknown, couchstore, magma };
 
 struct bucket_settings {
-    struct node {
-        std::string hostname;
-        std::string status;
-        std::string version;
-        std::vector<std::string> services;
-        std::map<std::string, std::uint16_t> ports;
-    };
+  struct node {
+    std::string hostname;
+    std::string status;
+    std::string version;
+    std::vector<std::string> services;
+    std::map<std::string, std::uint16_t> ports;
+  };
 
-    std::string name;
-    std::string uuid;
-    std::uint64_t ram_quota_mb{ 0 }; // If not explicitly set, defaults to 100 on create_bucket, unset on update_bucket
-    cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
-    std::optional<std::uint32_t> max_expiry{};
-    bucket_compression compression_mode{ bucket_compression::unknown };
-    std::optional<couchbase::durability_level> minimum_durability_level{};
-    std::optional<std::uint32_t> num_replicas{};
-    std::optional<bool> replica_indexes{};
-    std::optional<bool> flush_enabled{};
-    bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
-    bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
-    std::optional<bool> history_retention_collection_default{};
-    std::optional<std::uint32_t> history_retention_bytes{};
-    std::optional<std::uint32_t> history_retention_duration{};
+  std::string name;
+  std::string uuid;
+  std::uint64_t ram_quota_mb{
+    0
+  }; // If not explicitly set, defaults to 100 on create_bucket, unset on update_bucket
+  cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
+  std::optional<std::uint32_t> max_expiry{};
+  bucket_compression compression_mode{ bucket_compression::unknown };
+  std::optional<couchbase::durability_level> minimum_durability_level{};
+  std::optional<std::uint32_t> num_replicas{};
+  std::optional<bool> replica_indexes{};
+  std::optional<bool> flush_enabled{};
+  bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
+  bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
+  std::optional<bool> history_retention_collection_default{};
+  std::optional<std::uint32_t> history_retention_bytes{};
+  std::optional<std::uint32_t> history_retention_duration{};
 
-    /**
-     * UNCOMMITTED: This API may change in the future
-     */
-    bucket_storage_backend storage_backend{ bucket_storage_backend::unknown };
+  /**
+   * UNCOMMITTED: This API may change in the future
+   */
+  bucket_storage_backend storage_backend{ bucket_storage_backend::unknown };
 
-    /**
-     * UNCOMMITTED: read-only attribute
-     */
-    std::vector<std::string> capabilities{};
+  /**
+   * UNCOMMITTED: read-only attribute
+   */
+  std::vector<std::string> capabilities{};
 
-    /**
-     * UNCOMMITTED: read-only attribute
-     */
-    std::vector<node> nodes{};
+  /**
+   * UNCOMMITTED: read-only attribute
+   */
+  std::vector<node> nodes{};
 };
 } // namespace couchbase::core::management::cluster