couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/operations/management/analytics_link_replace.cxx

@@ -28,59 +28,60 @@ namespace details
 analytics_link_replace_response
 make_analytics_link_replace_response(error_context::http&& ctx, const io::http_response& encoded)
 {
-    management::analytics_link_replace_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        if (encoded.body.data().empty() && response.ctx.http_status == 200) {
-            return response;
-        }
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            auto colon = encoded.body.data().find(':');
-            if (colon == std::string::npos) {
-                response.ctx.ec = errc::common::parsing_failure;
-                return response;
-            }
-            auto code = static_cast<std::uint32_t>(std::stoul(encoded.body.data()));
-            auto msg = encoded.body.data().substr(colon + 1);
-            response.errors.emplace_back(management::analytics_link_replace_response::problem{ code, msg });
-        }
-        if (payload.is_object()) {
-            response.status = payload.optional<std::string>("status").value_or("unknown");
-            if (response.status != "success") {
-                if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
-                    for (const auto& error : errors->get_array()) {
-                        management::analytics_link_replace_response::problem err{
-                            error.at("code").as<std::uint32_t>(),
-                            error.at("msg").get_string(),
-                        };
-                        response.errors.emplace_back(err);
-                    }
-                }
-            }
-        }
-        bool link_not_found = false;
-        bool dataverse_does_not_exist = false;
-        for (const auto& err : response.errors) {
-            switch (err.code) {
-                case 24006: /* Link [string] does not exist */
-                    link_not_found = true;
-                    break;
-                case 24034: /* Cannot find dataverse with name [string] */
-                    dataverse_does_not_exist = true;
-                    break;
-            }
-        }
-        if (dataverse_does_not_exist) {
-            response.ctx.ec = errc::analytics::dataverse_not_found;
-        } else if (link_not_found) {
-            response.ctx.ec = errc::analytics::link_not_found;
-        } else {
-            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  management::analytics_link_replace_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    if (encoded.body.data().empty() && response.ctx.http_status == 200) {
+      return response;
+    }
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      auto colon = encoded.body.data().find(':');
+      if (colon == std::string::npos) {
+        response.ctx.ec = errc::common::parsing_failure;
+        return response;
+      }
+      auto code = static_cast<std::uint32_t>(std::stoul(encoded.body.data()));
+      auto msg = encoded.body.data().substr(colon + 1);
+      response.errors.emplace_back(
+        management::analytics_link_replace_response::problem{ code, msg });
+    }
+    if (payload.is_object()) {
+      response.status = payload.optional<std::string>("status").value_or("unknown");
+      if (response.status != "success") {
+        if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+          for (const auto& error : errors->get_array()) {
+            management::analytics_link_replace_response::problem err{
+              error.at("code").as<std::uint32_t>(),
+              error.at("msg").get_string(),
+            };
+            response.errors.emplace_back(err);
+          }
         }
+      }
+    }
+    bool link_not_found = false;
+    bool dataverse_does_not_exist = false;
+    for (const auto& err : response.errors) {
+      switch (err.code) {
+        case 24006: /* Link [string] does not exist */
+          link_not_found = true;
+          break;
+        case 24034: /* Cannot find dataverse with name [string] */
+          dataverse_does_not_exist = true;
+          break;
+      }
+    }
+    if (dataverse_does_not_exist) {
+      response.ctx.ec = errc::analytics::dataverse_not_found;
+    } else if (link_not_found) {
+      response.ctx.ec = errc::analytics::link_not_found;
+    } else {
+      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
     }
-    return response;
+  }
+  return response;
 }
 } // namespace details
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_link_replace.hxx

@@ -27,14 +27,14 @@
 namespace couchbase::core::operations::management
 {
 struct analytics_link_replace_response {
-    struct problem {
-        std::uint32_t code;
-        std::string message;
-    };
+  struct problem {
+    std::uint32_t code;
+    std::string message;
+  };
 
-    error_context::http ctx;
-    std::string status{};
-    std::vector<problem> errors{};
+  error_context::http ctx;
+  std::string status{};
+  std::vector<problem> errors{};
 };
 
 namespace details
@@ -45,34 +45,37 @@ make_analytics_link_replace_response(error_context::http&& ctx, const io::http_r
 
 template<typename analytics_link_type>
 struct analytics_link_replace_request {
-    using response_type = analytics_link_replace_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = analytics_link_replace_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::analytics;
+  static const inline service_type type = service_type::analytics;
 
-    analytics_link_type link{};
+  analytics_link_type link{};
 
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
-    {
-        if (std::error_code ec = link.validate()) {
-            return ec;
-        }
-        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-        encoded.headers["accept"] = "application/json";
-        encoded.method = "PUT";
-        encoded.path = endpoint_from_analytics_link(link);
-        encoded.body = link.encode();
-        return {};
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& /* context */) const
+  {
+    if (std::error_code ec = link.validate()) {
+      return ec;
     }
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    encoded.headers["accept"] = "application/json";
+    encoded.method = "PUT";
+    encoded.path = endpoint_from_analytics_link(link);
+    encoded.body = link.encode();
+    return {};
+  }
 
-    [[nodiscard]] analytics_link_replace_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
-    {
-        return details::make_analytics_link_replace_response(std::move(ctx), encoded);
-    }
+  [[nodiscard]] analytics_link_replace_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const
+  {
+    return details::make_analytics_link_replace_response(std::move(ctx), encoded);
+  }
 };
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_link_utils.hxx

@@ -29,9 +29,11 @@ template<typename analytics_link_type>
 std::string
 endpoint_from_analytics_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";
+  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::core::operations::management

data/ext/couchbase/core/operations/management/analytics_problem.hxx

@@ -24,8 +24,8 @@ namespace couchbase::core::operations::management
 {
 
 struct analytics_problem {
-    std::uint32_t code;
-    std::string message;
+  std::uint32_t code;
+  std::string message;
 };
 
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/bucket_create.cxx

@@ -30,163 +30,172 @@ namespace couchbase::core::operations::management
 std::error_code
 bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "POST";
-    encoded.path = "/pools/default/buckets";
+  encoded.method = "POST";
+  encoded.path = "/pools/default/buckets";
 
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));
-    switch (bucket.bucket_type) {
-        case couchbase::core::management::cluster::bucket_type::couchbase:
-            encoded.body.append("&bucketType=couchbase");
-            break;
-        case couchbase::core::management::cluster::bucket_type::memcached:
-            encoded.body.append("&bucketType=memcached");
-            break;
-        case couchbase::core::management::cluster::bucket_type::ephemeral:
-            encoded.body.append("&bucketType=ephemeral");
-            break;
-        case couchbase::core::management::cluster::bucket_type::unknown:
-            break;
-    }
-    if (bucket.ram_quota_mb == 0) {
-        encoded.body.append(fmt::format("&ramQuotaMB={}", 100)); // If not explicitly set, set to prior default value of 100
-    } else {
-        encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
-    }
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));
+  switch (bucket.bucket_type) {
+    case couchbase::core::management::cluster::bucket_type::couchbase:
+      encoded.body.append("&bucketType=couchbase");
+      break;
+    case couchbase::core::management::cluster::bucket_type::memcached:
+      encoded.body.append("&bucketType=memcached");
+      break;
+    case couchbase::core::management::cluster::bucket_type::ephemeral:
+      encoded.body.append("&bucketType=ephemeral");
+      break;
+    case couchbase::core::management::cluster::bucket_type::unknown:
+      break;
+  }
+  if (bucket.ram_quota_mb == 0) {
+    encoded.body.append(fmt::format(
+      "&ramQuotaMB={}", 100)); // If not explicitly set, set to prior default value of 100
+  } else {
+    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+  }
 
-    if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::memcached && bucket.num_replicas.has_value()) {
-        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
-    }
-    if (bucket.max_expiry.has_value()) {
-        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
-    }
-    if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::ephemeral && bucket.replica_indexes.has_value()) {
-        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
-    }
-    if (bucket.history_retention_collection_default.has_value()) {
-        encoded.body.append(
-          fmt::format("&historyRetentionCollectionDefault={}", bucket.history_retention_collection_default.value() ? "true" : "false"));
-    }
-    if (bucket.history_retention_bytes.has_value()) {
-        encoded.body.append(fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
-    }
-    if (bucket.history_retention_duration.has_value()) {
-        encoded.body.append(fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
-    }
-    if (bucket.flush_enabled.has_value()) {
-        encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
-    }
+  if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::memcached &&
+      bucket.num_replicas.has_value()) {
+    encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
+  }
+  if (bucket.max_expiry.has_value()) {
+    encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
+  }
+  if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::ephemeral &&
+      bucket.replica_indexes.has_value()) {
+    encoded.body.append(
+      fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
+  }
+  if (bucket.history_retention_collection_default.has_value()) {
+    encoded.body.append(
+      fmt::format("&historyRetentionCollectionDefault={}",
+                  bucket.history_retention_collection_default.value() ? "true" : "false"));
+  }
+  if (bucket.history_retention_bytes.has_value()) {
+    encoded.body.append(
+      fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
+  }
+  if (bucket.history_retention_duration.has_value()) {
+    encoded.body.append(
+      fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
+  }
+  if (bucket.flush_enabled.has_value()) {
+    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
+  }
 
-    switch (bucket.eviction_policy) {
-        case couchbase::core::management::cluster::bucket_eviction_policy::full:
-            encoded.body.append("&evictionPolicy=fullEviction");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::value_only:
-            encoded.body.append("&evictionPolicy=valueOnly");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::no_eviction:
-            encoded.body.append("&evictionPolicy=noEviction");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used:
-            encoded.body.append("&evictionPolicy=nruEviction");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::unknown:
-            break;
-    }
-    switch (bucket.compression_mode) {
-        case couchbase::core::management::cluster::bucket_compression::off:
-            encoded.body.append("&compressionMode=off");
-            break;
-        case couchbase::core::management::cluster::bucket_compression::active:
-            encoded.body.append("&compressionMode=active");
-            break;
-        case couchbase::core::management::cluster::bucket_compression::passive:
-            encoded.body.append("&compressionMode=passive");
-            break;
-        case couchbase::core::management::cluster::bucket_compression::unknown:
-            break;
+  switch (bucket.eviction_policy) {
+    case couchbase::core::management::cluster::bucket_eviction_policy::full:
+      encoded.body.append("&evictionPolicy=fullEviction");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::value_only:
+      encoded.body.append("&evictionPolicy=valueOnly");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::no_eviction:
+      encoded.body.append("&evictionPolicy=noEviction");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used:
+      encoded.body.append("&evictionPolicy=nruEviction");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::unknown:
+      break;
+  }
+  switch (bucket.compression_mode) {
+    case couchbase::core::management::cluster::bucket_compression::off:
+      encoded.body.append("&compressionMode=off");
+      break;
+    case couchbase::core::management::cluster::bucket_compression::active:
+      encoded.body.append("&compressionMode=active");
+      break;
+    case couchbase::core::management::cluster::bucket_compression::passive:
+      encoded.body.append("&compressionMode=passive");
+      break;
+    case couchbase::core::management::cluster::bucket_compression::unknown:
+      break;
+  }
+  switch (bucket.conflict_resolution_type) {
+    case couchbase::core::management::cluster::bucket_conflict_resolution::timestamp:
+      encoded.body.append("&conflictResolutionType=lww");
+      break;
+    case couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number:
+      encoded.body.append("&conflictResolutionType=seqno");
+      break;
+    case couchbase::core::management::cluster::bucket_conflict_resolution::custom:
+      encoded.body.append("&conflictResolutionType=custom");
+      break;
+    case couchbase::core::management::cluster::bucket_conflict_resolution::unknown:
+      break;
+  }
+  if (bucket.minimum_durability_level.has_value()) {
+    switch (bucket.minimum_durability_level.value()) {
+      case durability_level::none:
+        encoded.body.append("&durabilityMinLevel=none");
+        break;
+      case durability_level::majority:
+        encoded.body.append("&durabilityMinLevel=majority");
+        break;
+      case durability_level::majority_and_persist_to_active:
+        encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
+        break;
+      case durability_level::persist_to_majority:
+        encoded.body.append("&durabilityMinLevel=persistToMajority");
+        break;
     }
-    switch (bucket.conflict_resolution_type) {
-        case couchbase::core::management::cluster::bucket_conflict_resolution::timestamp:
-            encoded.body.append("&conflictResolutionType=lww");
-            break;
-        case couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number:
-            encoded.body.append("&conflictResolutionType=seqno");
-            break;
-        case couchbase::core::management::cluster::bucket_conflict_resolution::custom:
-            encoded.body.append("&conflictResolutionType=custom");
-            break;
-        case couchbase::core::management::cluster::bucket_conflict_resolution::unknown:
-            break;
-    }
-    if (bucket.minimum_durability_level.has_value()) {
-        switch (bucket.minimum_durability_level.value()) {
-            case durability_level::none:
-                encoded.body.append("&durabilityMinLevel=none");
-                break;
-            case durability_level::majority:
-                encoded.body.append("&durabilityMinLevel=majority");
-                break;
-            case durability_level::majority_and_persist_to_active:
-                encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
-                break;
-            case durability_level::persist_to_majority:
-                encoded.body.append("&durabilityMinLevel=persistToMajority");
-                break;
-        }
-    }
-    switch (bucket.storage_backend) {
-        case couchbase::core::management::cluster::bucket_storage_backend::unknown:
-            break;
-        case couchbase::core::management::cluster::bucket_storage_backend::couchstore:
-            encoded.body.append("&storageBackend=couchstore");
-            break;
-        case couchbase::core::management::cluster::bucket_storage_backend::magma:
-            encoded.body.append("&storageBackend=magma");
-            break;
-    }
-    return {};
+  }
+  switch (bucket.storage_backend) {
+    case couchbase::core::management::cluster::bucket_storage_backend::unknown:
+      break;
+    case couchbase::core::management::cluster::bucket_storage_backend::couchstore:
+      encoded.body.append("&storageBackend=couchstore");
+      break;
+    case couchbase::core::management::cluster::bucket_storage_backend::magma:
+      encoded.body.append("&storageBackend=magma");
+      break;
+  }
+  return {};
 }
 bucket_create_response
-bucket_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+bucket_create_request::make_response(error_context::http&& ctx,
+                                     const encoded_response_type& encoded) const
 {
-    bucket_create_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 404:
-                response.ctx.ec = errc::common::bucket_not_found;
-                break;
-            case 400: {
-                tao::json::value payload{};
-                try {
-                    payload = utils::json::parse(encoded.body.data());
-                } catch (const tao::pegtl::parse_error&) {
-                    response.ctx.ec = errc::common::parsing_failure;
-                    return response;
-                }
-                response.ctx.ec = errc::common::invalid_argument;
-                auto* errors = payload.find("errors");
-                if (errors != nullptr) {
-                    std::vector<std::string> error_list{};
-                    for (const auto& [code, message] : errors->get_object()) {
-                        if (message.get_string().find("Bucket with given name already exists") != std::string::npos) {
-                            response.ctx.ec = errc::management::bucket_exists;
-                        }
-                        error_list.emplace_back(message.get_string());
-                    }
-                    if (!error_list.empty()) {
-                        response.error_message = utils::join_strings(error_list, ". ");
-                    }
-                }
-            } break;
-            case 200:
-            case 202:
-                break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
+  bucket_create_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 404:
+        response.ctx.ec = errc::common::bucket_not_found;
+        break;
+      case 400: {
+        tao::json::value payload{};
+        try {
+          payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+          response.ctx.ec = errc::common::parsing_failure;
+          return response;
+        }
+        response.ctx.ec = errc::common::invalid_argument;
+        auto* errors = payload.find("errors");
+        if (errors != nullptr) {
+          std::vector<std::string> error_list{};
+          for (const auto& [code, message] : errors->get_object()) {
+            if (message.get_string().find("Bucket with given name already exists") !=
+                std::string::npos) {
+              response.ctx.ec = errc::management::bucket_exists;
+            }
+            error_list.emplace_back(message.get_string());
+          }
+          if (!error_list.empty()) {
+            response.error_message = utils::join_strings(error_list, ". ");
+          }
         }
+      } break;
+      case 200:
+      case 202:
+        break;
+      default:
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        break;
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/bucket_create.hxx

@@ -27,26 +27,28 @@
 namespace couchbase::core::operations::management
 {
 struct bucket_create_response {
-    error_context::http ctx;
-    std::string error_message{};
+  error_context::http ctx;
+  std::string error_message{};
 };
 
 struct bucket_create_request {
-    using response_type = bucket_create_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = bucket_create_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::management;
+  static const inline service_type type = service_type::management;
 
-    couchbase::core::management::cluster::bucket_settings bucket{};
+  couchbase::core::management::cluster::bucket_settings bucket{};
 
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] bucket_create_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] bucket_create_response make_response(error_context::http&& ctx,
+                                                     const encoded_response_type& encoded) const;
 };
 
 } // namespace couchbase::core::operations::management