couchbase 3.5.1 → 3.5.2

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

@@ -25,109 +25,127 @@ namespace tao::json
 {
 template<>
 struct traits<couchbase::core::management::cluster::bucket_settings> {
-    template<template<typename...> class Traits>
-    static couchbase::core::management::cluster::bucket_settings as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::core::management::cluster::bucket_settings result;
-        result.name = v.at("name").get_string();
-        result.uuid = v.at("uuid").get_string();
-        const static std::uint64_t megabyte = 1024LLU * 1024LLU;
-        result.ram_quota_mb = v.at("quota").at("rawRAM").get_unsigned() / megabyte;
-        result.num_replicas = v.at("replicaNumber").template as<std::optional<std::uint32_t>>();
+  template<template<typename...> class Traits>
+  static auto as(const tao::json::basic_value<Traits>& v)
+    -> couchbase::core::management::cluster::bucket_settings
+  {
+    couchbase::core::management::cluster::bucket_settings result;
+    result.name = v.at("name").get_string();
+    result.uuid = v.at("uuid").get_string();
+    const static std::uint64_t megabyte = 1024LLU * 1024LLU;
+    result.ram_quota_mb = v.at("quota").at("rawRAM").get_unsigned() / megabyte;
+    result.num_replicas = v.at("replicaNumber").template as<std::optional<std::uint32_t>>();
 
-        if (auto* max_ttl = v.find("maxTTL"); max_ttl != nullptr) {
-            result.max_expiry = max_ttl->template as<std::optional<std::uint32_t>>();
-        }
+    if (auto* max_ttl = v.find("maxTTL"); max_ttl != nullptr) {
+      result.max_expiry = max_ttl->template as<std::optional<std::uint32_t>>();
+    }
 
-        if (auto* history_retention_default = v.find("historyRetentionCollectionDefault"); history_retention_default != nullptr) {
-            result.history_retention_collection_default = history_retention_default->template as<std::optional<bool>>();
-        }
-        if (auto* history_retention_bytes = v.find("historyRetentionBytes"); history_retention_bytes != nullptr) {
-            result.history_retention_bytes = history_retention_bytes->template as<std::optional<std::uint32_t>>();
-        }
-        if (auto* history_retention_duration = v.find("historyRetentionSeconds"); history_retention_duration != nullptr) {
-            result.history_retention_duration = history_retention_duration->template as<std::optional<std::uint32_t>>();
-        }
+    if (auto* history_retention_default = v.find("historyRetentionCollectionDefault");
+        history_retention_default != nullptr) {
+      result.history_retention_collection_default =
+        history_retention_default->template as<std::optional<bool>>();
+    }
+    if (auto* history_retention_bytes = v.find("historyRetentionBytes");
+        history_retention_bytes != nullptr) {
+      result.history_retention_bytes =
+        history_retention_bytes->template as<std::optional<std::uint32_t>>();
+    }
+    if (auto* history_retention_duration = v.find("historyRetentionSeconds");
+        history_retention_duration != nullptr) {
+      result.history_retention_duration =
+        history_retention_duration->template as<std::optional<std::uint32_t>>();
+    }
 
-        if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
-            result.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
-        } else if (str == "ephemeral") {
-            result.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
-        } else if (str == "memcached") {
-            result.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
-        }
+    if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
+      result.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
+    } else if (str == "ephemeral") {
+      result.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
+    } else if (str == "memcached") {
+      result.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
+    }
 
-        if (auto* compression_mode = v.find("compressionMode"); compression_mode != nullptr && compression_mode->is_string()) {
-            if (auto& str = compression_mode->get_string(); str == "active") {
-                result.compression_mode = couchbase::core::management::cluster::bucket_compression::active;
-            } else if (str == "passive") {
-                result.compression_mode = couchbase::core::management::cluster::bucket_compression::passive;
-            } else if (str == "off") {
-                result.compression_mode = couchbase::core::management::cluster::bucket_compression::off;
-            }
-        }
+    if (auto* compression_mode = v.find("compressionMode");
+        compression_mode != nullptr && compression_mode->is_string()) {
+      if (auto& str = compression_mode->get_string(); str == "active") {
+        result.compression_mode = couchbase::core::management::cluster::bucket_compression::active;
+      } else if (str == "passive") {
+        result.compression_mode = couchbase::core::management::cluster::bucket_compression::passive;
+      } else if (str == "off") {
+        result.compression_mode = couchbase::core::management::cluster::bucket_compression::off;
+      }
+    }
 
-        if (auto& str = v.at("evictionPolicy").get_string(); str == "valueOnly") {
-            result.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::value_only;
-        } else if (str == "fullEviction") {
-            result.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::full;
-        } else if (str == "noEviction") {
-            result.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::no_eviction;
-        } else if (str == "nruEviction") {
-            result.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used;
-        }
+    if (auto& str = v.at("evictionPolicy").get_string(); str == "valueOnly") {
+      result.eviction_policy =
+        couchbase::core::management::cluster::bucket_eviction_policy::value_only;
+    } else if (str == "fullEviction") {
+      result.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::full;
+    } else if (str == "noEviction") {
+      result.eviction_policy =
+        couchbase::core::management::cluster::bucket_eviction_policy::no_eviction;
+    } else if (str == "nruEviction") {
+      result.eviction_policy =
+        couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used;
+    }
 
-        if (auto* storage_backend = v.find("storageBackend"); storage_backend != nullptr && storage_backend->is_string()) {
-            if (const auto& str = storage_backend->get_string(); str == "couchstore") {
-                result.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
-            } else if (str == "magma") {
-                result.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::magma;
-            }
-        }
+    if (auto* storage_backend = v.find("storageBackend");
+        storage_backend != nullptr && storage_backend->is_string()) {
+      if (const auto& str = storage_backend->get_string(); str == "couchstore") {
+        result.storage_backend =
+          couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+      } else if (str == "magma") {
+        result.storage_backend =
+          couchbase::core::management::cluster::bucket_storage_backend::magma;
+      }
+    }
 
-        if (auto* min_level = v.find("durabilityMinLevel"); min_level != nullptr) {
-            if (auto& str = min_level->get_string(); str == "none") {
-                result.minimum_durability_level = couchbase::durability_level::none;
-            } else if (str == "majority") {
-                result.minimum_durability_level = couchbase::durability_level::majority;
-            } else if (str == "majorityAndPersistActive") {
-                result.minimum_durability_level = couchbase::durability_level::majority_and_persist_to_active;
-            } else if (str == "persistToMajority") {
-                result.minimum_durability_level = couchbase::durability_level::persist_to_majority;
-            }
-        }
+    if (auto* min_level = v.find("durabilityMinLevel"); min_level != nullptr) {
+      if (auto& str = min_level->get_string(); str == "none") {
+        result.minimum_durability_level = couchbase::durability_level::none;
+      } else if (str == "majority") {
+        result.minimum_durability_level = couchbase::durability_level::majority;
+      } else if (str == "majorityAndPersistActive") {
+        result.minimum_durability_level =
+          couchbase::durability_level::majority_and_persist_to_active;
+      } else if (str == "persistToMajority") {
+        result.minimum_durability_level = couchbase::durability_level::persist_to_majority;
+      }
+    }
 
-        if (auto& str = v.at("conflictResolutionType").get_string(); str == "lww") {
-            result.conflict_resolution_type = couchbase::core::management::cluster::bucket_conflict_resolution::timestamp;
-        } else if (str == "seqno") {
-            result.conflict_resolution_type = couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number;
-        } else if (str == "custom") {
-            result.conflict_resolution_type = couchbase::core::management::cluster::bucket_conflict_resolution::custom;
-        }
+    if (auto& str = v.at("conflictResolutionType").get_string(); str == "lww") {
+      result.conflict_resolution_type =
+        couchbase::core::management::cluster::bucket_conflict_resolution::timestamp;
+    } else if (str == "seqno") {
+      result.conflict_resolution_type =
+        couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number;
+    } else if (str == "custom") {
+      result.conflict_resolution_type =
+        couchbase::core::management::cluster::bucket_conflict_resolution::custom;
+    }
 
-        result.flush_enabled = v.at("controllers").find("flush") != nullptr;
-        if (const auto replica_index = v.find("replicaIndex")) {
-            result.replica_indexes = replica_index->get_boolean();
-        }
-        if (const auto caps = v.find("bucketCapabilities"); caps != nullptr) {
-            for (auto& cap : caps->get_array()) {
-                result.capabilities.emplace_back(cap.get_string());
-            }
-        }
-        for (auto& n : v.at("nodes").get_array()) {
-            couchbase::core::management::cluster::bucket_settings::node node;
-            node.status = n.at("status").get_string();
-            node.hostname = n.at("hostname").get_string();
-            node.version = n.at("version").get_string();
-            for (auto& s : n.at("services").get_array()) {
-                node.services.emplace_back(s.get_string());
-            }
-            for (auto& p : n.at("ports").get_object()) {
-                node.ports.emplace(p.first, p.second.template as<std::uint16_t>());
-            }
-            result.nodes.emplace_back(node);
-        }
-        return result;
+    result.flush_enabled = v.at("controllers").find("flush") != nullptr;
+    if (const auto replica_index = v.find("replicaIndex")) {
+      result.replica_indexes = replica_index->get_boolean();
+    }
+    if (const auto caps = v.find("bucketCapabilities"); caps != nullptr) {
+      for (auto& cap : caps->get_array()) {
+        result.capabilities.emplace_back(cap.get_string());
+      }
+    }
+    for (auto& n : v.at("nodes").get_array()) {
+      couchbase::core::management::cluster::bucket_settings::node node;
+      node.status = n.at("status").get_string();
+      node.hostname = n.at("hostname").get_string();
+      node.version = n.at("version").get_string();
+      for (auto& s : n.at("services").get_array()) {
+        node.services.emplace_back(s.get_string());
+      }
+      for (auto& p : n.at("ports").get_object()) {
+        node.ports.emplace(p.first, p.second.template as<std::uint16_t>());
+      }
+      result.nodes.emplace_back(node);
     }
+    return result;
+  }
 };
 } // namespace tao::json

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

@@ -26,16 +26,16 @@
 namespace couchbase::core::management::views
 {
 struct design_document {
-    struct view {
-        std::string name;
-        std::optional<std::string> map{};
-        std::optional<std::string> reduce{};
-    };
-
-    std::optional<std::string> rev;
+  struct view {
     std::string name;
-    design_document_namespace ns;
-    std::map<std::string, view> views;
+    std::optional<std::string> map{};
+    std::optional<std::string> reduce{};
+  };
+
+  std::optional<std::string> rev;
+  std::string name;
+  design_document_namespace ns;
+  std::map<std::string, view> views;
 };
 
 } // namespace couchbase::core::management::views

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

@@ -30,165 +30,168 @@ namespace couchbase::core::management::eventing
 {
 
 struct function_keyspace {
-    std::string bucket;
-    std::optional<std::string> scope{};
-    std::optional<std::string> collection{};
+  std::string bucket;
+  std::optional<std::string> scope{};
+  std::optional<std::string> collection{};
 };
 
 enum class function_dcp_boundary {
-    everything,
-    from_now,
+  everything,
+  from_now,
 };
 
 enum class function_language_compatibility {
-    version_6_0_0,
-    version_6_5_0,
-    version_6_6_2,
-    version_7_2_0,
+  version_6_0_0,
+  version_6_5_0,
+  version_6_6_2,
+  version_7_2_0,
 };
 
 enum class function_log_level {
-    info,
-    error,
-    warning,
-    debug,
-    trace,
+  info,
+  error,
+  warning,
+  debug,
+  trace,
 };
 
 struct function_settings {
-    /** number of threads each worker utilizes */
-    std::optional<std::int64_t> cpp_worker_count{};
-    /** indicates where to start dcp stream from */
-    std::optional<function_dcp_boundary> dcp_stream_boundary{};
-    /** free form text for user to describe the handler. no functional role */
-    std::optional<std::string> description{};
-    /** indicates if the function is deployed */
-    std::optional<function_deployment_status> deployment_status{};
-    /** indicates if the function is running */
-    std::optional<function_processing_status> processing_status{};
-    /** level of detail in system logging */
-    std::optional<function_log_level> log_level{};
-    /** eventing language version this handler assumes in terms of syntax and behavior */
-    std::optional<function_language_compatibility> language_compatibility{};
-    /** maximum time the handler can run before it is forcefully terminated */
-    std::optional<std::chrono::seconds> execution_timeout{};
-    /** maximum number of libcouchbase connections that may be opened and pooled */
-    std::optional<std::int64_t> lcb_inst_capacity{};
-    /** number of retries of retriable libcouchbase failures. 0 keeps trying till execution_timeout */
-    std::optional<std::int64_t> lcb_retry_count{};
-    /** maximum time the lcb command is waited until completion before we terminate the request */
-    std::optional<std::chrono::seconds> lcb_timeout{};
-    /** consistency level used by n1ql statements in the handler */
-    std::optional<query_scan_consistency> query_consistency{};
-    /** number of timer shards. defaults to number of vbuckets */
-    std::optional<std::int64_t> num_timer_partitions{};
-    /** batch size for messages from producer to consumer */
-    std::optional<std::int64_t> sock_batch_size{};
-    /** duration to log stats from this handler */
-    std::optional<std::chrono::milliseconds> tick_duration{};
-    /** size limit of timer context object */
-    std::optional<std::int64_t> timer_context_size{};
-    /** key prefix for all data stored in metadata by this handler */
-    std::optional<std::string> user_prefix{};
-    /** maximum size in bytes the bucket cache can grow to */
-    std::optional<std::int64_t> bucket_cache_size{};
-    /** time in milliseconds after which a cached bucket object is considered stale */
-    std::optional<std::chrono::milliseconds> bucket_cache_age{};
-    /** maximum allowable curl call response in 'MegaBytes'. Setting the value to 0 lifts the upper limit off. This parameters affects v8
-     * engine stability since it defines the maximum amount of heap space acquired by a curl call */
-    std::optional<std::int64_t> curl_max_allowed_resp_size{};
-    /** automatically prepare all n1ql statements in the handler */
-    std::optional<bool> query_prepare_all{};
-    /** number of worker processes handler utilizes on each eventing node */
-    std::optional<std::int64_t> worker_count{};
-    /** code to automatically prepend to top of handler code */
-    std::vector<std::string> handler_headers{};
-    /** code to automatically append to bottom of handler code */
-    std::vector<std::string> handler_footers{};
-    /** enable rotating this handlers log() message files */
-    std::optional<bool> enable_app_log_rotation{};
-    /** directory to write content of log() message files */
-    std::optional<std::string> app_log_dir{};
-    /** rotate logs when file grows to this size in bytes approximately */
-    std::optional<std::int64_t> app_log_max_size{};
-    /** number of log() message files to retain when rotating */
-    std::optional<std::int64_t> app_log_max_files{};
-    /** number of seconds before writing a progress checkpoint */
-    std::optional<std::chrono::seconds> checkpoint_interval{};
+  /** number of threads each worker utilizes */
+  std::optional<std::int64_t> cpp_worker_count{};
+  /** indicates where to start dcp stream from */
+  std::optional<function_dcp_boundary> dcp_stream_boundary{};
+  /** free form text for user to describe the handler. no functional role */
+  std::optional<std::string> description{};
+  /** indicates if the function is deployed */
+  std::optional<function_deployment_status> deployment_status{};
+  /** indicates if the function is running */
+  std::optional<function_processing_status> processing_status{};
+  /** level of detail in system logging */
+  std::optional<function_log_level> log_level{};
+  /** eventing language version this handler assumes in terms of syntax and behavior */
+  std::optional<function_language_compatibility> language_compatibility{};
+  /** maximum time the handler can run before it is forcefully terminated */
+  std::optional<std::chrono::seconds> execution_timeout{};
+  /** maximum number of libcouchbase connections that may be opened and pooled */
+  std::optional<std::int64_t> lcb_inst_capacity{};
+  /** number of retries of retriable libcouchbase failures. 0 keeps trying till execution_timeout */
+  std::optional<std::int64_t> lcb_retry_count{};
+  /** maximum time the lcb command is waited until completion before we terminate the request */
+  std::optional<std::chrono::seconds> lcb_timeout{};
+  /** consistency level used by n1ql statements in the handler */
+  std::optional<query_scan_consistency> query_consistency{};
+  /** number of timer shards. defaults to number of vbuckets */
+  std::optional<std::int64_t> num_timer_partitions{};
+  /** batch size for messages from producer to consumer */
+  std::optional<std::int64_t> sock_batch_size{};
+  /** duration to log stats from this handler */
+  std::optional<std::chrono::milliseconds> tick_duration{};
+  /** size limit of timer context object */
+  std::optional<std::int64_t> timer_context_size{};
+  /** key prefix for all data stored in metadata by this handler */
+  std::optional<std::string> user_prefix{};
+  /** maximum size in bytes the bucket cache can grow to */
+  std::optional<std::int64_t> bucket_cache_size{};
+  /** time in milliseconds after which a cached bucket object is considered stale */
+  std::optional<std::chrono::milliseconds> bucket_cache_age{};
+  /** maximum allowable curl call response in 'MegaBytes'. Setting the value to 0 lifts the upper
+   * limit off. This parameters affects v8 engine stability since it defines the maximum amount of
+   * heap space acquired by a curl call */
+  std::optional<std::int64_t> curl_max_allowed_resp_size{};
+  /** automatically prepare all n1ql statements in the handler */
+  std::optional<bool> query_prepare_all{};
+  /** number of worker processes handler utilizes on each eventing node */
+  std::optional<std::int64_t> worker_count{};
+  /** code to automatically prepend to top of handler code */
+  std::vector<std::string> handler_headers{};
+  /** code to automatically append to bottom of handler code */
+  std::vector<std::string> handler_footers{};
+  /** enable rotating this handlers log() message files */
+  std::optional<bool> enable_app_log_rotation{};
+  /** directory to write content of log() message files */
+  std::optional<std::string> app_log_dir{};
+  /** rotate logs when file grows to this size in bytes approximately */
+  std::optional<std::int64_t> app_log_max_size{};
+  /** number of log() message files to retain when rotating */
+  std::optional<std::int64_t> app_log_max_files{};
+  /** number of seconds before writing a progress checkpoint */
+  std::optional<std::chrono::seconds> checkpoint_interval{};
 };
 
 enum class function_bucket_access {
-    read_only,
-    read_write,
+  read_only,
+  read_write,
 };
 
 struct function_bucket_binding {
-    /** symbolic name used in code to refer to this binding */
-    std::string alias;
-    /** name of the bucket with optional scope and collection */
-    function_keyspace name;
-    /** bucket access level (read or read+write) */
-    function_bucket_access access{ function_bucket_access::read_write };
+  /** symbolic name used in code to refer to this binding */
+  std::string alias;
+  /** name of the bucket with optional scope and collection */
+  function_keyspace name;
+  /** bucket access level (read or read+write) */
+  function_bucket_access access{ function_bucket_access::read_write };
 };
 
 struct function_url_no_auth {
 };
 
 struct function_url_auth_basic {
-    std::string username;
-    std::string password{};
+  std::string username;
+  std::string password{};
 };
 
 struct function_url_auth_digest {
-    std::string username;
-    std::string password{};
+  std::string username;
+  std::string password{};
 };
 
 struct function_url_auth_bearer {
-    std::string key{};
+  std::string key{};
 };
 
 struct function_url_binding {
-    std::string alias;
-    std::string hostname;
-    bool allow_cookies{ false };
-    bool validate_ssl_certificate{ true };
-    std::variant<function_url_no_auth, function_url_auth_basic, function_url_auth_digest, function_url_auth_bearer> auth{
-        function_url_no_auth{}
-    };
+  std::string alias;
+  std::string hostname;
+  bool allow_cookies{ false };
+  bool validate_ssl_certificate{ true };
+  std::variant<function_url_no_auth,
+               function_url_auth_basic,
+               function_url_auth_digest,
+               function_url_auth_bearer>
+    auth{ function_url_no_auth{} };
 };
 
 struct function_constant_binding {
-    /** alias name of the constant binding */
-    std::string alias;
-    /** literal value bound to the alias name */
-    std::string literal;
+  /** alias name of the constant binding */
+  std::string alias;
+  /** literal value bound to the alias name */
+  std::string literal;
 };
 
 struct function {
-    std::string name;
-    /** handler source code */
-    std::string code;
-    /** keyspace to store eventing checkpoints and timers */
-    eventing::function_keyspace metadata_keyspace{};
-    /** keyspace to listen to for document mutations */
-    eventing::function_keyspace source_keyspace{};
-    /** authoring tool. use 'external' if authored or edited outside eventing UI */
-    std::optional<std::string> version{};
-    /** enforces stricter validation for all settings and configuration fields */
-    std::optional<bool> enforce_schema{};
-    /** unique id of the the handler. generated by server */
-    std::optional<std::int64_t> handler_uuid{};
-    /** unique id of the deployment of the handler. generated by server */
-    std::optional<std::string> function_instance_id{};
-    std::vector<function_bucket_binding> bucket_bindings{};
-    std::vector<function_url_binding> url_bindings{};
-    std::vector<function_constant_binding> constant_bindings{};
-    function_settings settings{};
-
-    struct {
-        std::optional<std::string> bucket_name{};
-        std::optional<std::string> scope_name{};
-    } internal{};
+  std::string name;
+  /** handler source code */
+  std::string code;
+  /** keyspace to store eventing checkpoints and timers */
+  eventing::function_keyspace metadata_keyspace{};
+  /** keyspace to listen to for document mutations */
+  eventing::function_keyspace source_keyspace{};
+  /** authoring tool. use 'external' if authored or edited outside eventing UI */
+  std::optional<std::string> version{};
+  /** enforces stricter validation for all settings and configuration fields */
+  std::optional<bool> enforce_schema{};
+  /** unique id of the the handler. generated by server */
+  std::optional<std::int64_t> handler_uuid{};
+  /** unique id of the deployment of the handler. generated by server */
+  std::optional<std::string> function_instance_id{};
+  std::vector<function_bucket_binding> bucket_bindings{};
+  std::vector<function_url_binding> url_bindings{};
+  std::vector<function_constant_binding> constant_bindings{};
+  function_settings settings{};
+
+  struct {
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+  } internal{};
 };
 } // namespace couchbase::core::management::eventing