couchbase 4.2.9 → 4.2.11-rc.1

package/deps/couchbase-cxx-client/core/impl/search_index_manager.cxx

@@ -29,6 +29,7 @@
 #include "core/utils/json.hxx"
 #include "internal_manager_error_context.hxx"
 
+#include <couchbase/scope_search_index_manager.hxx>
 #include <couchbase/search_index_manager.hxx>
 
 #include <memory>
@@ -145,19 +146,26 @@ class search_index_manager_impl
     {
     }
 
+    explicit search_index_manager_impl(core::cluster core, std::string bucket_name, std::string scope_name)
+      : core_{ std::move(core) }
+      , bucket_name_{ std::move(bucket_name) }
+      , scope_name_{ std::move(scope_name) }
+    {
+    }
+
     void get_index(std::string index_name,
                    const couchbase::get_search_index_options::built& options,
                    get_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_get_request{ std::move(index_name), {}, options.timeout },
+          core::operations::management::search_index_get_request{ std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), map_search_index(resp.index)); });
     }
 
     void get_all_indexes(const get_all_search_indexes_options::built& options, get_all_search_indexes_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_get_all_request{ {}, options.timeout },
+          core::operations::management::search_index_get_all_request{ bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), map_all_search_indexes(resp.indexes)); });
     }
 
@@ -165,30 +173,37 @@ class search_index_manager_impl
                       const upsert_search_index_options::built& options,
                       upsert_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_upsert_request{ map_search_index(search_index), {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_upsert_request{
+            map_search_index(search_index), bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void drop_index(std::string index_name, const drop_search_index_options::built& options, drop_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_drop_request{ std::move(index_name), {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_drop_request{ std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void get_indexed_documents_count(std::string index_name,
                                      const get_indexed_search_index_options::built& options,
                                      get_indexed_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_get_documents_count_request{ std::move(index_name), {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), resp.count); });
+        core_.execute(
+          core::operations::management::search_index_get_documents_count_request{
+            std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), resp.count); });
     }
 
     void pause_ingest(std::string index_name,
                       const pause_ingest_search_index_options::built& options,
                       pause_ingest_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_control_ingest_request{ std::move(index_name), true, {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_control_ingest_request{
+            std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void resume_ingest(std::string index_name,
@@ -196,7 +211,8 @@ class search_index_manager_impl
                        resume_ingest_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_control_ingest_request{ std::move(index_name), false, {}, options.timeout },
+          core::operations::management::search_index_control_ingest_request{
+            std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
@@ -204,16 +220,20 @@ class search_index_manager_impl
                         const allow_querying_search_index_options::built& options,
                         allow_querying_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_control_query_request{ std::move(index_name), true, {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_control_query_request{
+            std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void disallow_querying(std::string index_name,
                            const disallow_querying_search_index_options::built& options,
                            disallow_querying_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_control_query_request{ std::move(index_name), false, {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_control_query_request{
+            std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void freeze_plan(std::string index_name,
@@ -221,7 +241,8 @@ class search_index_manager_impl
                      freeze_plan_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_control_plan_freeze_request{ std::move(index_name), true, {}, options.timeout },
+          core::operations::management::search_index_control_plan_freeze_request{
+            std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
@@ -230,7 +251,8 @@ class search_index_manager_impl
                        unfreeze_plan_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_control_plan_freeze_request{ std::move(index_name), false, {}, options.timeout },
+          core::operations::management::search_index_control_plan_freeze_request{
+            std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
@@ -241,12 +263,14 @@ class search_index_manager_impl
     {
         core_.execute(
           core::operations::management::search_index_analyze_document_request{
-            std::move(index_name), std::move(document), {}, options.timeout },
+            std::move(index_name), std::move(document), bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), convert_analysis(resp.analysis)); });
     }
 
   private:
     core::cluster core_;
+    std::optional<std::string> bucket_name_{};
+    std::optional<std::string> scope_name_{};
 };
 
 search_index_manager::search_index_manager(core::cluster core)
@@ -466,4 +490,223 @@ search_index_manager::analyze_document(std::string index_name,
     });
     return barrier->get_future();
 }
+
+scope_search_index_manager::scope_search_index_manager(core::cluster core, std::string bucket_name, std::string scope_name)
+  : impl_(std::make_shared<search_index_manager_impl>(std::move(core), std::move(bucket_name), std::move(scope_name)))
+{
+}
+
+void
+scope_search_index_manager::get_index(std::string index_name,
+                                      const couchbase::get_search_index_options& options,
+                                      couchbase::get_search_index_handler&& handler) const
+{
+    return impl_->get_index(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::get_index(std::string index_name, const couchbase::get_search_index_options& options) const
+  -> std::future<std::pair<manager_error_context, management::search::index>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, management::search::index>>>();
+    get_index(std::move(index_name), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::get_all_indexes(const couchbase::get_all_search_indexes_options& options,
+                                            get_all_search_indexes_handler&& handler) const
+{
+    return impl_->get_all_indexes(options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::get_all_indexes(const couchbase::get_all_search_indexes_options& options) const
+  -> std::future<std::pair<manager_error_context, std::vector<management::search::index>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<management::search::index>>>>();
+    get_all_indexes(options,
+                    [barrier](auto ctx, auto result) mutable { barrier->set_value(std::make_pair(std::move(ctx), std::move(result))); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::upsert_index(const management::search::index& search_index,
+                                         const couchbase::upsert_search_index_options& options,
+                                         couchbase::upsert_search_index_handler&& handler) const
+{
+    return impl_->upsert_index(search_index, options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::upsert_index(const management::search::index& search_index,
+                                         const couchbase::upsert_search_index_options& options) const -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    upsert_index(search_index, options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::drop_index(std::string index_name,
+                                       const couchbase::drop_search_index_options& options,
+                                       couchbase::drop_search_index_handler&& handler) const
+{
+    return impl_->drop_index(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::drop_index(std::string index_name, const couchbase::drop_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    drop_index(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::get_indexed_documents_count(std::string index_name,
+                                                        const couchbase::get_indexed_search_index_options& options,
+                                                        couchbase::get_indexed_search_index_handler&& handler) const
+{
+    return impl_->get_indexed_documents_count(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::get_indexed_documents_count(std::string index_name, const get_indexed_search_index_options& options) const
+  -> std::future<std::pair<manager_error_context, std::uint64_t>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::uint64_t>>>();
+    get_indexed_documents_count(std::move(index_name), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::pause_ingest(std::string index_name,
+                                         const couchbase::pause_ingest_search_index_options& options,
+                                         couchbase::pause_ingest_search_index_handler&& handler) const
+{
+    return impl_->pause_ingest(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::pause_ingest(std::string index_name, const couchbase::pause_ingest_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    pause_ingest(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::resume_ingest(std::string index_name,
+                                          const couchbase::resume_ingest_search_index_options& options,
+                                          couchbase::resume_ingest_search_index_handler&& handler) const
+{
+    return impl_->resume_ingest(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::resume_ingest(std::string index_name, const couchbase::resume_ingest_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    resume_ingest(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::allow_querying(std::string index_name,
+                                           const couchbase::allow_querying_search_index_options& options,
+                                           couchbase::allow_querying_search_index_handler&& handler) const
+{
+    return impl_->allow_querying(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::allow_querying(std::string index_name, const couchbase::allow_querying_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    allow_querying(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::disallow_querying(std::string index_name,
+                                              const couchbase::disallow_querying_search_index_options& options,
+                                              couchbase::disallow_querying_search_index_handler&& handler) const
+{
+    return impl_->disallow_querying(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::disallow_querying(std::string index_name,
+                                              const couchbase::disallow_querying_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    disallow_querying(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::freeze_plan(std::string index_name,
+                                        const couchbase::freeze_plan_search_index_options& options,
+                                        couchbase::freeze_plan_search_index_handler&& handler) const
+{
+    return impl_->freeze_plan(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::freeze_plan(std::string index_name, const couchbase::freeze_plan_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    freeze_plan(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::unfreeze_plan(std::string index_name,
+                                          const couchbase::unfreeze_plan_search_index_options& options,
+                                          couchbase::unfreeze_plan_search_index_handler&& handler) const
+{
+    return impl_->unfreeze_plan(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::unfreeze_plan(std::string index_name, const couchbase::unfreeze_plan_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    unfreeze_plan(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::analyze_document(std::string index_name,
+                                             std::string document,
+                                             const couchbase::analyze_document_options& options,
+                                             couchbase::analyze_document_handler&& handler) const
+{
+    return impl_->analyze_document(std::move(index_name), std::move(document), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::analyze_document(std::string index_name,
+                                             std::string document,
+                                             const couchbase::analyze_document_options& options) const
+  -> std::future<std::pair<manager_error_context, std::vector<std::string>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<std::string>>>>();
+    analyze_document(std::move(index_name), std::move(document), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/search_request.cxx

@@ -0,0 +1,139 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present 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 "core/impl/encoded_search_query.hxx"
+
+#include <couchbase/search_request.hxx>
+
+namespace couchbase
+{
+class search_request_impl
+{
+  public:
+    explicit search_request_impl(std::optional<encoded_search_query> search_query,
+                                 std::optional<encoded_search_query> vector_search,
+                                 std::optional<vector_search_options::built> options)
+      : search_query_(std::move(search_query))
+      , vector_search_(std::move(vector_search))
+      , vector_search_options_(std::move(options))
+    {
+    }
+
+    static search_request_impl create(const search_query& query)
+    {
+        auto encoded = query.encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode the search_query");
+        }
+        return search_request_impl(encoded, {}, {});
+    }
+
+    static search_request_impl create(const vector_search& search)
+    {
+        auto encoded = search.encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode the vector_search");
+        }
+        return search_request_impl({}, encoded, search.options());
+    }
+
+    void search_query(const couchbase::search_query& query)
+    {
+        search_query_ = query.encode();
+        if (search_query_.value().ec) {
+            throw std::system_error(search_query_.value().ec, "unable to encode the search_query");
+        }
+    }
+
+    void vector_search(const couchbase::vector_search& search)
+    {
+        vector_search_ = search.encode();
+        if (vector_search_.value().ec) {
+            throw std::system_error(vector_search_.value().ec, "unable to encode the vector_search");
+        }
+        vector_search_options_ = search.options();
+    }
+
+    [[nodiscard]] std::optional<encoded_search_query> search_query() const
+    {
+        return search_query_;
+    }
+
+    [[nodiscard]] std::optional<encoded_search_query> vector_search() const
+    {
+        return vector_search_;
+    }
+
+    [[nodiscard]] std::optional<vector_search_options::built> vector_options() const
+    {
+        return vector_search_options_;
+    }
+
+  private:
+    std::optional<encoded_search_query> search_query_;
+    std::optional<encoded_search_query> vector_search_;
+    std::optional<vector_search_options::built> vector_search_options_;
+};
+
+search_request::search_request(const couchbase::search_query& query)
+  : impl_{ std::make_shared<search_request_impl>(search_request_impl::create(query)) }
+{
+}
+
+search_request::search_request(const couchbase::vector_search& search)
+  : impl_{ std::make_shared<search_request_impl>(search_request_impl::create(search)) }
+{
+}
+
+auto
+search_request::search_query(const couchbase::search_query& search_query) -> search_request&
+{
+    if (impl_->search_query().has_value()) {
+        throw std::invalid_argument("There can only be one search_query in a search request");
+    }
+    impl_->search_query(search_query);
+    return *this;
+}
+
+auto
+search_request::vector_search(const couchbase::vector_search& vector_search) -> search_request&
+{
+    if (impl_->vector_search().has_value()) {
+        throw std::invalid_argument("There can only be one vector_search in a search request");
+    }
+    impl_->vector_search(vector_search);
+    return *this;
+}
+
+[[nodiscard]] std::optional<encoded_search_query>
+search_request::search_query() const
+{
+    return impl_->search_query();
+}
+
+[[nodiscard]] std::optional<encoded_search_query>
+search_request::vector_search() const
+{
+    return impl_->vector_search();
+}
+
+[[nodiscard]] std::optional<couchbase::vector_search_options::built>
+search_request::vector_options()
+{
+    return impl_->vector_options();
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/vector_query.cxx

@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present 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 "encoded_search_query.hxx"
+
+#include <couchbase/vector_query.hxx>
+
+namespace couchbase
+{
+auto
+vector_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    built.query["field"] = vector_field_name_;
+
+    tao::json::value vector_values = tao::json::empty_array;
+    for (const auto value : vector_query_) {
+        vector_values.push_back(value);
+    }
+    built.query["vector"] = vector_values;
+    built.query["k"] = num_candidates_;
+    return built;
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/vector_search.cxx

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present 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 "encoded_search_query.hxx"
+
+#include <couchbase/vector_search.hxx>
+
+namespace couchbase
+{
+auto
+vector_search::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+
+    built.query = tao::json::empty_array;
+
+    for (const auto& query : vector_queries_) {
+        auto encoded = query.encode();
+        if (encoded.ec) {
+            return { encoded.ec };
+        }
+        built.query.push_back(encoded.query);
+    }
+    return built;
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/io/http_session.hxx

@@ -370,11 +370,12 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (ec) {
-            CB_LOG_ERROR("{} error on resolve: {}", info_.log_prefix(), ec.message());
+            CB_LOG_ERROR("{} error on resolve \"{}:{}\": {}", info_.log_prefix(), hostname_, service_, ec.message());
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
         endpoints_ = endpoints;
+        CB_LOG_TRACE("{} resolved \"{}:{}\" to {} endpoint(s)", info_.log_prefix(), hostname_, service_, endpoints_.size());
         do_connect(endpoints_.begin());
         deadline_timer_.async_wait(std::bind(&http_session::check_deadline, shared_from_this(), std::placeholders::_1));
     }
@@ -385,15 +386,17 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (it != endpoints_.end()) {
-            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+            CB_LOG_DEBUG("{} connecting to {}:{} (\"{}:{}\"), timeout={}ms",
                          info_.log_prefix(),
                          it->endpoint().address().to_string(),
                          it->endpoint().port(),
+                         hostname_,
+                         service_,
                          http_ctx_.options.connect_timeout.count());
             deadline_timer_.expires_after(http_ctx_.options.connect_timeout);
             stream_->async_connect(it->endpoint(), std::bind(&http_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
-            CB_LOG_ERROR("{} no more endpoints left to connect", info_.log_prefix());
+            CB_LOG_ERROR("{} no more endpoints left to connect, \"{}:{}\" is not reachable", info_.log_prefix(), hostname_, service_);
             stop();
         }
     }

package/deps/couchbase-cxx-client/core/io/http_session_manager.hxx

@@ -58,6 +58,12 @@ class http_session_manager
         meter_ = std::move(meter);
     }
 
+    auto configuration_capabilities() const -> configuration_capabilities
+    {
+        std::scoped_lock config_lock(config_mutex_);
+        return config_.capabilities;
+    }
+
     void update_config(topology::configuration config) override
     {
         std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
@@ -387,7 +393,7 @@ class http_session_manager
     cluster_options options_{};
 
     topology::configuration config_{};
-    std::mutex config_mutex_{};
+    mutable std::mutex config_mutex_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> idle_sessions_{};
     std::size_t next_index_{ 0 };

package/deps/couchbase-cxx-client/core/io/mcbp_command.hxx

@@ -289,6 +289,16 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               if (status == key_value_status_code::unknown_collection) {
                   return self->handle_unknown_collection();
               }
+              if (status == key_value_status_code::config_only) {
+                  CB_LOG_DEBUG(
+                    "{} server returned status 0x{:02x} ({}) meaning that the node does not serve data operations, requesting new "
+                    "configuration and retrying",
+                    self->session_->log_prefix(),
+                    msg.header.status(),
+                    status);
+                  self->manager_->fetch_config();
+                  return io::retry_orchestrator::maybe_retry(self->manager_, self, retry_reason::service_response_code_indicated, ec);
+              }
               if (error_code && error_code.value().has_retry_attribute()) {
                   reason = retry_reason::key_value_error_map_retry_indicated;
               } else {