couchbase 3.5.0 → 3.5.1

data/ext/couchbase/core/impl/scan_result.cxx

@@ -0,0 +1,174 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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.
+ */
+
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/scan_result.hxx>
+#include <couchbase/scan_result_item.hxx>
+
+#include "core/range_scan_options.hxx"
+#include "core/scan_result.hxx"
+
+#include "internal_scan_result.hxx"
+
+#include <future>
+#include <memory>
+#include <optional>
+#include <system_error>
+#include <utility>
+
+namespace couchbase
+{
+namespace
+{
+auto
+to_scan_result_item(core::range_scan_item core_item) -> scan_result_item
+{
+    if (!core_item.body) {
+        return scan_result_item{ core_item.key };
+    }
+    return scan_result_item{
+        core_item.key,
+        core_item.body.value().cas,
+        couchbase::codec::encoded_value{ core_item.body.value().value, core_item.body.value().flags },
+        core_item.body.value().expiry_time(),
+    };
+}
+} // namespace
+
+internal_scan_result::internal_scan_result(core::scan_result core_result)
+  : core_result_{ std::move(core_result) }
+{
+}
+
+void
+internal_scan_result::next(scan_item_handler&& handler)
+{
+    return core_result_.next([handler = std::move(handler)](core::range_scan_item item, std::error_code ec) mutable {
+        if (ec == couchbase::errc::key_value::range_scan_completed) {
+            return handler({}, {});
+        }
+        if (ec) {
+            return handler(ec, {});
+        }
+        handler({}, to_scan_result_item(std::move(item)));
+    });
+}
+
+void
+internal_scan_result::cancel()
+{
+    return core_result_.cancel();
+}
+
+internal_scan_result::~internal_scan_result()
+{
+    cancel();
+}
+
+scan_result::scan_result(std::shared_ptr<couchbase::internal_scan_result> internal)
+  : internal_{ std::move(internal) }
+{
+}
+
+void
+scan_result::next(couchbase::scan_item_handler&& handler) const
+{
+    return internal_->next(std::move(handler));
+}
+
+auto
+scan_result::next() const -> std::future<std::pair<std::error_code, std::optional<scan_result_item>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<std::error_code, std::optional<scan_result_item>>>>();
+    internal_->next([barrier](auto ec, auto item) mutable { barrier->set_value({ ec, item }); });
+    return barrier->get_future();
+}
+
+void
+scan_result::cancel()
+{
+    if (internal_) {
+        return internal_->cancel();
+    }
+}
+
+auto
+scan_result::begin() -> scan_result::iterator
+{
+    return scan_result::iterator(internal_);
+}
+
+auto
+scan_result::end() -> scan_result::iterator
+{
+    return scan_result::iterator({ errc::key_value::range_scan_completed, {} });
+}
+
+scan_result::iterator::iterator(std::shared_ptr<internal_scan_result> internal)
+  : internal_{ std::move(internal) }
+{
+    fetch_item();
+}
+
+scan_result::iterator::iterator(std::pair<std::error_code, scan_result_item> item)
+  : item_{ std::move(item) }
+{
+}
+
+void
+scan_result::iterator::fetch_item()
+{
+    auto barrier = std::make_shared<std::promise<std::pair<std::error_code, scan_result_item>>>();
+    internal_->next([barrier](std::error_code ec, std::optional<scan_result_item> item) mutable {
+        if (ec) {
+            return barrier->set_value({ ec, {} });
+        }
+        if (!item.has_value()) {
+            return barrier->set_value({ errc::key_value::range_scan_completed, {} });
+        }
+        barrier->set_value({ {}, item.value() });
+    });
+    auto f = barrier->get_future();
+    item_ = f.get();
+}
+
+auto
+scan_result::iterator::operator*() -> std::pair<std::error_code, scan_result_item>
+{
+    return item_;
+}
+
+auto
+scan_result::iterator::operator++() -> scan_result::iterator&
+{
+    fetch_item();
+    return *this;
+}
+
+auto
+scan_result::iterator::operator==(const couchbase::scan_result::iterator& other) const -> bool
+{
+    return item_ == other.item_;
+}
+
+auto
+scan_result::iterator::operator!=(const couchbase::scan_result::iterator& other) const -> bool
+{
+    return item_ != other.item_;
+}
+} // namespace couchbase

data/ext/couchbase/core/io/mcbp_session.cxx

@@ -479,6 +479,15 @@ class mcbp_session_impl
                             }
                             protocol::client_response<protocol::get_cluster_config_response_body> resp(std::move(msg), info);
                             if (resp.status() == key_value_status_code::success) {
+                                // MB-60405 fixes this for 7.6.2, but for earlier versions we need to protect against using a
+                                // config that has an empty vbucket map.  Ideally we don't timeout if we retry here, but a timeout
+                                // would be more acceptable than a crash and if we do timeout, we have a clear indication of the
+                                // problem (i.e. it is a server bug and we cannot use a config w/ an empty vbucket map).
+                                if (resp.body().config().vbmap && resp.body().config().vbmap->size() == 0) {
+                                    CB_LOG_WARNING("{} received a configuration with an empty vbucket map, retrying",
+                                                   session_->log_prefix_);
+                                    return complete(errc::network::configuration_not_available);
+                                }
                                 session_->update_configuration(resp.body().config());
                                 complete({});
                             } else if (resp.status() == key_value_status_code::not_found) {
@@ -1256,6 +1265,14 @@ class mcbp_session_impl
             return;
         }
         std::scoped_lock lock(config_mutex_);
+        // MB-60405 fixes this for 7.6.2, but for earlier versions we need to protect against using a
+        // config that has an empty vbucket map.  We should be okay to ignore at this point b/c we should
+        // already have a config w/ a non-empty vbucket map (bootstrap will not complete successfully
+        // unless we have a config w/ a non-empty vbucket map).
+        if (config.vbmap && config.vbmap->size() == 0) {
+            CB_LOG_DEBUG("{} received a configuration with an empty vbucket map, ignoring", log_prefix_);
+            return;
+        }
         if (config_) {
             if (config_->vbmap && config.vbmap && config_->vbmap->size() != config.vbmap->size()) {
                 CB_LOG_DEBUG("{} received a configuration with a different number of vbuckets, ignoring", log_prefix_);

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

@@ -44,6 +44,7 @@ enum class function_language_compatibility {
     version_6_0_0,
     version_6_5_0,
     version_6_6_2,
+    version_7_2_0,
 };
 
 enum class function_log_level {
@@ -184,5 +185,10 @@ struct function {
     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

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

@@ -175,6 +175,9 @@ struct traits<couchbase::core::management::eventing::function> {
                 } else if (language_compatibility_string == "6.6.2") {
                     result.settings.language_compatibility =
                       couchbase::core::management::eventing::function_language_compatibility::version_6_6_2;
+                } else if (language_compatibility_string == "7.2.0") {
+                    result.settings.language_compatibility =
+                      couchbase::core::management::eventing::function_language_compatibility::version_7_2_0;
                 }
             }
 
@@ -206,6 +209,11 @@ struct traits<couchbase::core::management::eventing::function> {
             }
         }
 
+        if (const auto* function_scope = v.find("function_scope"); function_scope != nullptr && function_scope->is_object()) {
+            result.internal.bucket_name = function_scope->template optional<std::string>("bucket");
+            result.internal.scope_name = function_scope->template optional<std::string>("scope");
+        }
+
         return result;
     }
 };

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

@@ -74,6 +74,11 @@ struct function_state {
     function_deployment_status deployment_status;
     function_processing_status processing_status;
     std::optional<bool> redeploy_required{};
+
+    struct {
+        std::optional<std::string> bucket_name{};
+        std::optional<std::string> scope_name{};
+    } internal{};
 };
 
 struct status {

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

@@ -67,6 +67,11 @@ struct traits<couchbase::core::management::eventing::status> {
                     function.status = couchbase::core::management::eventing::function_status::pausing;
                 }
 
+                if (const auto* function_scope = app.find("function_scope"); function_scope != nullptr && function_scope->is_object()) {
+                    function.internal.bucket_name = function_scope->template optional<std::string>("bucket");
+                    function.internal.scope_name = function_scope->template optional<std::string>("scope");
+                }
+
                 result.functions.emplace_back(function);
             }
         }

data/ext/couchbase/core/meta/features.hxx

@@ -131,3 +131,9 @@
  * Hooks in the transactions core are asynchronous (they have a callback parameter)
  */
 #define COUCHBASE_CXX_CLIENT_TRANSACTIONS_CORE_ASYNC_HOOKS
+
+/**
+ * Range scan is accessible from the public API
+ * couchbase::collection::scan()
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_PUBLIC_RANGE_SCAN 1

data/ext/couchbase/core/operations/document_query.cxx

@@ -76,15 +76,18 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
         }
         body["args"] = std::move(parameters);
     }
-    switch (profile) {
-        case couchbase::query_profile::phases:
-            body["profile"] = "phases";
-            break;
-        case couchbase::query_profile::timings:
-            body["profile"] = "timings";
-            break;
-        case couchbase::query_profile::off:
-            break;
+    if (profile.has_value()) {
+        switch (profile.value()) {
+            case couchbase::query_profile::phases:
+                body["profile"] = "phases";
+                break;
+            case couchbase::query_profile::timings:
+                body["profile"] = "timings";
+                break;
+            case couchbase::query_profile::off:
+                body["profile"] = "off";
+                break;
+        }
     }
     if (use_replica.has_value()) {
         if (context.config.capabilities.supports_read_from_replica()) {
@@ -397,15 +400,16 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
                             response.ctx.ec = errc::query::index_failure;
                         } else if (response.ctx.first_error_code >= 4000 && response.ctx.first_error_code < 5000) {
                             response.ctx.ec = errc::query::planning_failure;
-                        } else {
-                            auto common_ec =
-                              management::extract_common_query_error_code(response.ctx.first_error_code, response.ctx.first_error_message);
-                            if (common_ec) {
-                                response.ctx.ec = common_ec.value();
-                            }
                         }
                         break;
                 }
+                if (!response.ctx.ec) {
+                    auto common_ec =
+                      management::extract_common_query_error_code(response.ctx.first_error_code, response.ctx.first_error_message);
+                    if (common_ec) {
+                        response.ctx.ec = common_ec.value();
+                    }
+                }
             }
             if (!response.ctx.ec) {
                 CB_LOG_TRACE("Unexpected error returned by query engine: client_context_id=\"{}\", body={}",

data/ext/couchbase/core/operations/document_query.hxx

@@ -103,7 +103,7 @@ struct query_request {
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 
-    query_profile profile{ query_profile::off };
+    std::optional<query_profile> profile{};
 
     std::map<std::string, couchbase::core::json_string, std::less<>> raw{};
     std::vector<couchbase::core::json_string> positional_parameters{};

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

@@ -17,6 +17,7 @@
 
 #include "eventing_deploy_function.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,6 +29,11 @@ eventing_deploy_function_request::encode_to(encoded_request_type& encoded, http_
 {
     encoded.method = "POST";
     encoded.path = fmt::format("/api/v1/functions/{}/deploy", name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path += fmt::format("?bucket={}&scope={}",
+                                    utils::string_codec::v2::path_escape(bucket_name.value()),
+                                    utils::string_codec::v2::path_escape(scope_name.value()));
+    }
     return {};
 }
 

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

@@ -40,6 +40,9 @@ struct eventing_deploy_function_request {
 
     std::string name;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};

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

@@ -17,6 +17,7 @@
 
 #include "eventing_drop_function.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,6 +29,11 @@ eventing_drop_function_request::encode_to(encoded_request_type& encoded, http_co
 {
     encoded.method = "DELETE";
     encoded.path = fmt::format("/api/v1/functions/{}", name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path += fmt::format("?bucket={}&scope={}",
+                                    utils::string_codec::v2::path_escape(bucket_name.value()),
+                                    utils::string_codec::v2::path_escape(scope_name.value()));
+    }
     return {};
 }
 

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

@@ -40,6 +40,9 @@ struct eventing_drop_function_request {
 
     std::string name;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};

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

@@ -16,6 +16,7 @@
  */
 
 #include "eventing_get_all_functions.hxx"
+#include "core/management/eventing_function.hxx"
 #include "core/management/eventing_function_json.hxx"
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
@@ -55,7 +56,21 @@ eventing_get_all_functions_request::make_response(error_context::http&& ctx, con
         const auto& entries = payload.get_array();
         response.functions.reserve(entries.size());
         for (const auto& entry : entries) {
-            response.functions.emplace_back(entry.as<couchbase::core::management::eventing::function>());
+            bool include{};
+            auto function = entry.as<couchbase::core::management::eventing::function>();
+            if (bucket_name.has_value() && scope_name.has_value()) {
+                include = function.internal.bucket_name.has_value() && function.internal.scope_name.has_value() &&
+                          function.internal.bucket_name.value() == bucket_name.value() &&
+                          function.internal.scope_name.value() == scope_name.value();
+            } else {
+                include = (!function.internal.bucket_name.has_value() && !function.internal.scope_name.has_value()) ||
+                          (function.internal.bucket_name.has_value() && function.internal.scope_name.has_value() &&
+                           function.internal.bucket_name.value() == "*" && function.internal.scope_name.value() == "*");
+            }
+
+            if (include) {
+                response.functions.push_back(function);
+            }
         }
     }
     return response;

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

@@ -39,6 +39,9 @@ struct eventing_get_all_functions_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::http;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};

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

@@ -18,6 +18,7 @@
 #include "eventing_get_function.hxx"
 #include "core/management/eventing_function_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -29,6 +30,11 @@ eventing_get_function_request::encode_to(encoded_request_type& encoded, http_con
 {
     encoded.method = "GET";
     encoded.path = fmt::format("/api/v1/functions/{}", name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path += fmt::format("?bucket={}&scope={}",
+                                    utils::string_codec::v2::path_escape(bucket_name.value()),
+                                    utils::string_codec::v2::path_escape(scope_name.value()));
+    }
     return {};
 }
 

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

@@ -40,6 +40,8 @@ struct eventing_get_function_request {
     using error_context_type = error_context::http;
 
     std::string name;
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
 
     static const inline service_type type = service_type::eventing;
 

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

@@ -16,6 +16,7 @@
  */
 
 #include "eventing_get_status.hxx"
+#include "core/logger/logger.hxx"
 #include "core/management/eventing_status_json.hxx"
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
@@ -48,7 +49,24 @@ eventing_get_status_request::make_response(error_context::http&& ctx, const enco
             response.error.emplace(problem);
             return response;
         }
-        response.status = payload.as<couchbase::core::management::eventing::status>();
+        response.status = payload.as<core::management::eventing::status>();
+        std::vector<core::management::eventing::function_state> filtered_functions{};
+        for (const auto& function : response.status.functions) {
+            bool include{};
+            if (bucket_name.has_value() && scope_name.has_value()) {
+                include = function.internal.bucket_name.has_value() && function.internal.scope_name.has_value() &&
+                          function.internal.bucket_name.value() == bucket_name.value() &&
+                          function.internal.scope_name.value() == scope_name.value();
+            } else {
+                include = (!function.internal.bucket_name.has_value() && !function.internal.scope_name.has_value()) ||
+                          (function.internal.bucket_name.has_value() && function.internal.scope_name.has_value() &&
+                           function.internal.bucket_name.value() == "*" && function.internal.scope_name.value() == "*");
+            }
+            if (include) {
+                filtered_functions.push_back(function);
+            }
+        }
+        response.status.functions = std::move(filtered_functions);
     }
     return response;
 }

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

@@ -41,6 +41,9 @@ struct eventing_get_status_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::http;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};

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

@@ -16,7 +16,9 @@
  */
 
 #include "eventing_pause_function.hxx"
+
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,6 +30,11 @@ eventing_pause_function_request::encode_to(encoded_request_type& encoded, http_c
 {
     encoded.method = "POST";
     encoded.path = fmt::format("/api/v1/functions/{}/pause", name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path += fmt::format("?bucket={}&scope={}",
+                                    utils::string_codec::v2::path_escape(bucket_name.value()),
+                                    utils::string_codec::v2::path_escape(scope_name.value()));
+    }
     return {};
 }
 

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

@@ -40,6 +40,9 @@ struct eventing_pause_function_request {
 
     std::string name;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};

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

@@ -17,6 +17,7 @@
 
 #include "eventing_resume_function.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,6 +29,11 @@ eventing_resume_function_request::encode_to(encoded_request_type& encoded, http_
 {
     encoded.method = "POST";
     encoded.path = fmt::format("/api/v1/functions/{}/resume", name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path += fmt::format("?bucket={}&scope={}",
+                                    utils::string_codec::v2::path_escape(bucket_name.value()),
+                                    utils::string_codec::v2::path_escape(scope_name.value()));
+    }
     return {};
 }
 

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

@@ -40,6 +40,9 @@ struct eventing_resume_function_request {
 
     std::string name;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};

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

@@ -17,6 +17,7 @@
 
 #include "eventing_undeploy_function.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,6 +29,11 @@ eventing_undeploy_function_request::encode_to(encoded_request_type& encoded, htt
 {
     encoded.method = "POST";
     encoded.path = fmt::format("/api/v1/functions/{}/undeploy", name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path += fmt::format("?bucket={}&scope={}",
+                                    utils::string_codec::v2::path_escape(bucket_name.value()),
+                                    utils::string_codec::v2::path_escape(scope_name.value()));
+    }
     return {};
 }
 

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

@@ -40,6 +40,9 @@ struct eventing_undeploy_function_request {
 
     std::string name;
 
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+
     static const inline service_type type = service_type::eventing;
 
     std::optional<std::string> client_context_id{};