couchbase 4.2.11 → 4.3.0

package/deps/couchbase-cxx-cache/mozilla-ca-bundle.crt

@@ -1,7 +1,7 @@
 ##
 ## Bundle of CA Root Certificates
 ##
-## Certificate data from Mozilla as of: Tue Dec 12 04:12:04 2023 GMT
+## Certificate data from Mozilla as of: Mon Mar 11 15:25:27 2024 GMT
 ##
 ## This is a bundle of X.509 certificates of public Certificate Authorities
 ## (CA). These were automatically extracted from Mozilla's root certificates
@@ -14,7 +14,7 @@
 ## Just configure this file as the SSLCACertificateFile.
 ##
 ## Conversion done with mk-ca-bundle.pl version 1.29.
-## SHA256: 1970dd65858925d68498d2356aea6d03f764422523c5887deca8ce3ba9e1f845
+## SHA256: 4d96bd539f4719e9ace493757afbe4a23ee8579de1c97fbebc50bba3c12e8c1e
 ##
 
 
@@ -3532,3 +3532,50 @@ dVwPaFsdZcJfMw8eD/A7hvWwTruc9+olBdytoptLFwG+Qt81IR2tq670v64fG9PiO/yzcnMcmyiQ
 iRM9HcEARwmWmjgb3bHPDcK0RPOWlc4yOo80nOAXx17Org3bhzjlP1v9mxnhMUF6cKojawHhRUzN
 lM47ni3niAIi9G7oyOzWPPO5std3eqx7
 -----END CERTIFICATE-----
+
+Telekom Security TLS ECC Root 2020
+==================================
+-----BEGIN CERTIFICATE-----
+MIICQjCCAcmgAwIBAgIQNjqWjMlcsljN0AFdxeVXADAKBggqhkjOPQQDAzBjMQswCQYDVQQGEwJE
+RTEnMCUGA1UECgweRGV1dHNjaGUgVGVsZWtvbSBTZWN1cml0eSBHbWJIMSswKQYDVQQDDCJUZWxl
+a29tIFNlY3VyaXR5IFRMUyBFQ0MgUm9vdCAyMDIwMB4XDTIwMDgyNTA3NDgyMFoXDTQ1MDgyNTIz
+NTk1OVowYzELMAkGA1UEBhMCREUxJzAlBgNVBAoMHkRldXRzY2hlIFRlbGVrb20gU2VjdXJpdHkg
+R21iSDErMCkGA1UEAwwiVGVsZWtvbSBTZWN1cml0eSBUTFMgRUNDIFJvb3QgMjAyMDB2MBAGByqG
+SM49AgEGBSuBBAAiA2IABM6//leov9Wq9xCazbzREaK9Z0LMkOsVGJDZos0MKiXrPk/OtdKPD/M1
+2kOLAoC+b1EkHQ9rK8qfwm9QMuU3ILYg/4gND21Ju9sGpIeQkpT0CdDPf8iAC8GXs7s1J8nCG6NC
+MEAwHQYDVR0OBBYEFONyzG6VmUex5rNhTNHLq+O6zd6fMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0P
+AQH/BAQDAgEGMAoGCCqGSM49BAMDA2cAMGQCMHVSi7ekEE+uShCLsoRbQuHmKjYC2qBuGT8lv9pZ
+Mo7k+5Dck2TOrbRBR2Diz6fLHgIwN0GMZt9Ba9aDAEH9L1r3ULRn0SyocddDypwnJJGDSA3PzfdU
+ga/sf+Rn27iQ7t0l
+-----END CERTIFICATE-----
+
+Telekom Security TLS RSA Root 2023
+==================================
+-----BEGIN CERTIFICATE-----
+MIIFszCCA5ugAwIBAgIQIZxULej27HF3+k7ow3BXlzANBgkqhkiG9w0BAQwFADBjMQswCQYDVQQG
+EwJERTEnMCUGA1UECgweRGV1dHNjaGUgVGVsZWtvbSBTZWN1cml0eSBHbWJIMSswKQYDVQQDDCJU
+ZWxla29tIFNlY3VyaXR5IFRMUyBSU0EgUm9vdCAyMDIzMB4XDTIzMDMyODEyMTY0NVoXDTQ4MDMy
+NzIzNTk1OVowYzELMAkGA1UEBhMCREUxJzAlBgNVBAoMHkRldXRzY2hlIFRlbGVrb20gU2VjdXJp
+dHkgR21iSDErMCkGA1UEAwwiVGVsZWtvbSBTZWN1cml0eSBUTFMgUlNBIFJvb3QgMjAyMzCCAiIw
+DQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAO01oYGA88tKaVvC+1GDrib94W7zgRJ9cUD/h3VC
+KSHtgVIs3xLBGYSJwb3FKNXVS2xE1kzbB5ZKVXrKNoIENqil/Cf2SfHVcp6R+SPWcHu79ZvB7JPP
+GeplfohwoHP89v+1VmLhc2o0mD6CuKyVU/QBoCcHcqMAU6DksquDOFczJZSfvkgdmOGjup5czQRx
+UX11eKvzWarE4GC+j4NSuHUaQTXtvPM6Y+mpFEXX5lLRbtLevOP1Czvm4MS9Q2QTps70mDdsipWo
+l8hHD/BeEIvnHRz+sTugBTNoBUGCwQMrAcjnj02r6LX2zWtEtefdi+zqJbQAIldNsLGyMcEWzv/9
+FIS3R/qy8XDe24tsNlikfLMR0cN3f1+2JeANxdKz+bi4d9s3cXFH42AYTyS2dTd4uaNir73Jco4v
+zLuu2+QVUhkHM/tqty1LkCiCc/4YizWN26cEar7qwU02OxY2kTLvtkCJkUPg8qKrBC7m8kwOFjQg
+rIfBLX7JZkcXFBGk8/ehJImr2BrIoVyxo/eMbcgByU/J7MT8rFEz0ciD0cmfHdRHNCk+y7AO+oML
+KFjlKdw/fKifybYKu6boRhYPluV75Gp6SG12mAWl3G0eQh5C2hrgUve1g8Aae3g1LDj1H/1Joy7S
+WWO/gLCMk3PLNaaZlSJhZQNg+y+TS/qanIA7AgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAdBgNV
+HQ4EFgQUtqeXgj10hZv3PJ+TmpV5dVKMbUcwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBS2
+p5eCPXSFm/c8n5OalXl1UoxtRzANBgkqhkiG9w0BAQwFAAOCAgEAqMxhpr51nhVQpGv7qHBFfLp+
+sVr8WyP6Cnf4mHGCDG3gXkaqk/QeoMPhk9tLrbKmXauw1GLLXrtm9S3ul0A8Yute1hTWjOKWi0Fp
+kzXmuZlrYrShF2Y0pmtjxrlO8iLpWA1WQdH6DErwM807u20hOq6OcrXDSvvpfeWxm4bu4uB9tPcy
+/SKE8YXJN3nptT+/XOR0so8RYgDdGGah2XsjX/GO1WfoVNpbOms2b/mBsTNHM3dA+VKq3dSDz4V4
+mZqTuXNnQkYRIer+CqkbGmVps4+uFrb2S1ayLfmlyOw7YqPta9BO1UAJpB+Y1zqlklkg5LB9zVtz
+aL1txKITDmcZuI1CfmwMmm6gJC3VRRvcxAIU/oVbZZfKTpBQCHpCNfnqwmbU+AGuHrS+w6jv/naa
+oqYfRvaE7fzbzsQCzndILIyy7MMAo+wsVRjBfhnu4S/yrYObnqsZ38aKL4x35bcF7DvB7L6Gs4a8
+wPfc5+pbrrLMtTWGS9DiP7bY+A4A7l3j941Y/8+LN+ljX273CXE2whJdV/LItM3z7gLfEdxquVeE
+HVlNjM7IDiPCtyaaEBRx/pOyiriA8A4QntOoUAw3gi/q4Iqd4Sw5/7W0cwDk90imc6y/st53BIe0
+o82bNSQ3+pCTE4FCxpgmdTdmQRCsu/WU48IxK63nI1bMNSWSs1A=
+-----END CERTIFICATE-----

package/deps/couchbase-cxx-cache/mozilla-ca-bundle.sha256

@@ -1 +1 @@
-ccbdfc2fe1a0d7bbbb9cc15710271acf1bb1afe4c8f1725fe95c4c7733fcbe5a  cacert.pem
+1794c1d4f7055b7d02c2170337b61b48a2ef6c90d77e95444fd2596f4cac609f  cacert.pem

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

@@ -157,10 +157,30 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
   public:
     explicit cluster_impl(couchbase::core::cluster core)
       : core_{ std::move(core) }
-      , transactions_{ std::make_shared<couchbase::core::transactions::transactions>(core_, core_.origin().second.options().transactions) }
     {
     }
 
+    explicit cluster_impl(couchbase::core::cluster core, std::shared_ptr<couchbase::core::transactions::transactions> transactions)
+      : core_{ std::move(core) }
+      , transactions_{ transactions }
+    {
+    }
+
+    void initialize_transactions(std::function<void(std::error_code)>&& handler)
+    {
+        return core::transactions::transactions::create(
+          core_,
+          core_.origin().second.options().transactions,
+          [self = shared_from_this(), handler = std::move(handler)](auto ec, auto txns) mutable {
+              if (ec) {
+                  return handler(ec);
+              }
+
+              self->transactions_ = txns;
+              handler({});
+          });
+    }
+
     void query(std::string statement, query_options::built options, query_handler&& handler) const
     {
         return core_.execute(
@@ -214,6 +234,13 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
                              });
     }
 
+    void notify_fork(fork_event event)
+    {
+        if (transactions_) {
+            transactions_->notify_fork(event);
+        }
+    }
+
     void close(core::utils::movable_function<void()> handler)
     {
         if (transactions_) {
@@ -258,6 +285,11 @@ cluster::cluster(core::cluster core)
 {
 }
 
+cluster::cluster(core::cluster core, std::shared_ptr<core::transactions::transactions> transactions)
+  : impl_{ std::make_shared<cluster_impl>(std::move(core), transactions) }
+{
+}
+
 void
 cluster::query(std::string statement, const query_options& options, query_handler&& handler) const
 {
@@ -361,9 +393,8 @@ cluster::connect(asio::io_context& io, const std::string& connection_string, con
   -> std::future<std::pair<cluster, std::error_code>>
 {
     auto barrier = std::make_shared<std::promise<std::pair<cluster, std::error_code>>>();
-    auto future = barrier->get_future();
-    connect(io, connection_string, options, [barrier](auto c, auto ec) { barrier->set_value({ std::move(c), ec }); });
-    return future;
+    connect(io, connection_string, options, [barrier](auto c, auto ec) mutable { barrier->set_value({ std::move(c), ec }); });
+    return barrier->get_future();
 }
 
 void
@@ -378,10 +409,25 @@ cluster::connect(asio::io_context& io,
         if (ec) {
             return handler({}, ec);
         }
-        handler(couchbase::cluster(std::move(core)), {});
+        auto cluster = couchbase::cluster(std::move(core));
+        return cluster.impl_->initialize_transactions([cluster, handler = std::move(handler)](std::error_code ec) mutable {
+            if (ec) {
+                return cluster.impl_->close([ec, handler = std::move(handler)]() mutable { return handler({}, ec); });
+            }
+            return handler(cluster, ec);
+        });
     });
 }
 
+auto
+cluster::notify_fork(fork_event event) -> void
+{
+    if (!impl_) {
+        return;
+    }
+    return impl_->notify_fork(event);
+}
+
 auto
 cluster::close() const -> void
 {

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

@@ -475,120 +475,129 @@ class collection_impl : public std::enable_shared_from_this<collection_impl>
     {
         auto request = std::make_shared<couchbase::core::impl::lookup_in_all_replicas_request>(
           bucket_name_, scope_name_, name_, std::move(document_key), specs, options.timeout);
-        core_.with_bucket_configuration(
+        core_.open_bucket(
           bucket_name_,
-          [core = core_, r = std::move(request), h = std::move(handler)](std::error_code ec,
-                                                                         const core::topology::configuration& config) mutable {
-              if (!config.capabilities.supports_subdoc_read_replica()) {
-                  ec = errc::common::feature_not_available;
-              }
-
+          [core = core_, bucket_name = bucket_name_, r = std::move(request), h = std::move(handler)](std::error_code ec) mutable {
               if (ec) {
-                  return h(core::make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, {}, {}, false),
-                           lookup_in_all_replicas_result{});
+                  h(core::make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, {}, {}, false),
+                    lookup_in_all_replicas_result{});
+                  return;
               }
-              struct replica_context {
-                  replica_context(core::impl::movable_lookup_in_all_replicas_handler handler, std::uint32_t expected_responses)
-                    : handler_(std::move(handler))
-                    , expected_responses_(expected_responses)
-                  {
-                  }
 
-                  core::impl::movable_lookup_in_all_replicas_handler handler_;
-                  std::uint32_t expected_responses_;
-                  bool done_{ false };
-                  std::mutex mutex_{};
-                  lookup_in_all_replicas_result result_{};
-              };
-              auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+              return core.with_bucket_configuration(
+                bucket_name,
+                [core = core, r = std::move(r), h = std::move(h)](std::error_code ec, const core::topology::configuration& config) mutable {
+                    if (!config.capabilities.supports_subdoc_read_replica()) {
+                        ec = errc::common::feature_not_available;
+                    }
 
-              for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
-                  core::document_id replica_id{ r->id() };
-                  replica_id.node_index(idx);
-                  core.execute(core::impl::lookup_in_replica_request{ std::move(replica_id), r->specs(), r->timeout() },
-                               [ctx](core::impl::lookup_in_replica_response&& resp) {
-                                   core::impl::movable_lookup_in_all_replicas_handler local_handler{};
-                                   {
-                                       const std::scoped_lock lock(ctx->mutex_);
-                                       if (ctx->done_) {
-                                           return;
-                                       }
-                                       --ctx->expected_responses_;
-                                       if (resp.ctx.ec()) {
-                                           if (ctx->expected_responses_ > 0) {
-                                               // just ignore the response
-                                               return;
-                                           }
-                                       } else {
-                                           std::vector<lookup_in_replica_result::entry> entries{};
-                                           for (const auto& field : resp.fields) {
-                                               lookup_in_replica_result::entry lookup_in_entry{};
-                                               lookup_in_entry.path = field.path;
-                                               lookup_in_entry.value = field.value;
-                                               lookup_in_entry.exists = field.exists;
-                                               lookup_in_entry.original_index = field.original_index;
-                                               lookup_in_entry.ec = field.ec;
-                                               entries.emplace_back(lookup_in_entry);
-                                           }
-                                           ctx->result_.emplace_back(resp.cas, entries, resp.deleted, true /* replica */);
-                                       }
-                                       if (ctx->expected_responses_ == 0) {
-                                           ctx->done_ = true;
-                                           std::swap(local_handler, ctx->handler_);
-                                       }
-                                   }
-                                   if (local_handler) {
-                                       if (!ctx->result_.empty()) {
-                                           resp.ctx.override_ec({});
-                                       }
-                                       return local_handler(std::move(resp.ctx), std::move(ctx->result_));
-                                   }
-                               });
-              }
+                    if (ec) {
+                        return h(core::make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, {}, {}, false),
+                                 lookup_in_all_replicas_result{});
+                    }
+                    struct replica_context {
+                        replica_context(core::impl::movable_lookup_in_all_replicas_handler handler, std::uint32_t expected_responses)
+                          : handler_(std::move(handler))
+                          , expected_responses_(expected_responses)
+                        {
+                        }
+
+                        core::impl::movable_lookup_in_all_replicas_handler handler_;
+                        std::uint32_t expected_responses_;
+                        bool done_{ false };
+                        std::mutex mutex_{};
+                        lookup_in_all_replicas_result result_{};
+                    };
+                    auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+
+                    for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
+                        core::document_id replica_id{ r->id() };
+                        replica_id.node_index(idx);
+                        core.execute(core::impl::lookup_in_replica_request{ std::move(replica_id), r->specs(), r->timeout() },
+                                     [ctx](core::impl::lookup_in_replica_response&& resp) {
+                                         core::impl::movable_lookup_in_all_replicas_handler local_handler{};
+                                         {
+                                             const std::scoped_lock lock(ctx->mutex_);
+                                             if (ctx->done_) {
+                                                 return;
+                                             }
+                                             --ctx->expected_responses_;
+                                             if (resp.ctx.ec()) {
+                                                 if (ctx->expected_responses_ > 0) {
+                                                     // just ignore the response
+                                                     return;
+                                                 }
+                                             } else {
+                                                 std::vector<lookup_in_replica_result::entry> entries{};
+                                                 for (const auto& field : resp.fields) {
+                                                     lookup_in_replica_result::entry lookup_in_entry{};
+                                                     lookup_in_entry.path = field.path;
+                                                     lookup_in_entry.value = field.value;
+                                                     lookup_in_entry.exists = field.exists;
+                                                     lookup_in_entry.original_index = field.original_index;
+                                                     lookup_in_entry.ec = field.ec;
+                                                     entries.emplace_back(lookup_in_entry);
+                                                 }
+                                                 ctx->result_.emplace_back(resp.cas, entries, resp.deleted, true /* replica */);
+                                             }
+                                             if (ctx->expected_responses_ == 0) {
+                                                 ctx->done_ = true;
+                                                 std::swap(local_handler, ctx->handler_);
+                                             }
+                                         }
+                                         if (local_handler) {
+                                             if (!ctx->result_.empty()) {
+                                                 resp.ctx.override_ec({});
+                                             }
+                                             return local_handler(std::move(resp.ctx), std::move(ctx->result_));
+                                         }
+                                     });
+                    }
 
-              core::operations::lookup_in_request active{ core::document_id{ r->id() } };
-              active.specs = r->specs();
-              active.timeout = r->timeout();
-              core.execute(active, [ctx](core::operations::lookup_in_response&& resp) {
-                  core::impl::movable_lookup_in_all_replicas_handler local_handler{};
-                  {
-                      const std::scoped_lock lock(ctx->mutex_);
-                      if (ctx->done_) {
-                          return;
-                      }
-                      --ctx->expected_responses_;
-                      if (resp.ctx.ec()) {
-                          if (ctx->expected_responses_ > 0) {
-                              // just ignore the response
-                              return;
-                          }
-                      } else {
-                          std::vector<lookup_in_replica_result::entry> entries{};
-                          for (const auto& field : resp.fields) {
-                              lookup_in_replica_result::entry lookup_in_entry{};
-                              lookup_in_entry.path = field.path;
-                              lookup_in_entry.value = field.value;
-                              lookup_in_entry.exists = field.exists;
-                              lookup_in_entry.original_index = field.original_index;
-                              lookup_in_entry.ec = field.ec;
-                              entries.emplace_back(lookup_in_entry);
-                          }
-                          ctx->result_.emplace_back(resp.cas, entries, resp.deleted, false /* active */);
-                      }
-                      if (ctx->expected_responses_ == 0) {
-                          ctx->done_ = true;
-                          std::swap(local_handler, ctx->handler_);
-                      }
-                  }
-                  if (local_handler) {
-                      if (!ctx->result_.empty()) {
-                          resp.ctx.override_ec({});
-                      }
-                      return local_handler(std::move(resp.ctx), std::move(ctx->result_));
-                  }
-              });
+                    core::operations::lookup_in_request active{ core::document_id{ r->id() } };
+                    active.specs = r->specs();
+                    active.timeout = r->timeout();
+                    core.execute(active, [ctx](core::operations::lookup_in_response&& resp) {
+                        core::impl::movable_lookup_in_all_replicas_handler local_handler{};
+                        {
+                            const std::scoped_lock lock(ctx->mutex_);
+                            if (ctx->done_) {
+                                return;
+                            }
+                            --ctx->expected_responses_;
+                            if (resp.ctx.ec()) {
+                                if (ctx->expected_responses_ > 0) {
+                                    // just ignore the response
+                                    return;
+                                }
+                            } else {
+                                std::vector<lookup_in_replica_result::entry> entries{};
+                                for (const auto& field : resp.fields) {
+                                    lookup_in_replica_result::entry lookup_in_entry{};
+                                    lookup_in_entry.path = field.path;
+                                    lookup_in_entry.value = field.value;
+                                    lookup_in_entry.exists = field.exists;
+                                    lookup_in_entry.original_index = field.original_index;
+                                    lookup_in_entry.ec = field.ec;
+                                    entries.emplace_back(lookup_in_entry);
+                                }
+                                ctx->result_.emplace_back(resp.cas, entries, resp.deleted, false /* active */);
+                            }
+                            if (ctx->expected_responses_ == 0) {
+                                ctx->done_ = true;
+                                std::swap(local_handler, ctx->handler_);
+                            }
+                        }
+                        if (local_handler) {
+                            if (!ctx->result_.empty()) {
+                                resp.ctx.override_ec({});
+                            }
+                            return local_handler(std::move(resp.ctx), std::move(ctx->result_));
+                        }
+                    });
+                });
           });
-    }
+    };
 
     void lookup_in_any_replica(std::string document_key,
                                const std::vector<core::impl::subdoc::command>& specs,
@@ -597,114 +606,120 @@ class collection_impl : public std::enable_shared_from_this<collection_impl>
     {
         auto request = std::make_shared<couchbase::core::impl::lookup_in_any_replica_request>(
           bucket_name_, scope_name_, name_, std::move(document_key), specs, options.timeout);
-        core_.with_bucket_configuration(
+        core_.open_bucket(
           bucket_name_,
-          [core = core_, r = std::move(request), h = std::move(handler)](std::error_code ec,
-                                                                         const core::topology::configuration& config) mutable {
-              if (!config.capabilities.supports_subdoc_read_replica()) {
-                  ec = errc::common::feature_not_available;
-              }
-              if (r->specs().size() > 16) {
-                  ec = errc::common::invalid_argument;
-              }
+          [core = core_, bucket_name = bucket_name_, r = std::move(request), h = std::move(handler)](std::error_code ec) mutable {
               if (ec) {
-                  return h(core::make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, {}, {}, false),
-                           lookup_in_replica_result{});
+                  h(core::make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, {}, {}, false),
+                    lookup_in_replica_result{});
+                  return;
               }
-              struct replica_context {
-                  replica_context(core::impl::movable_lookup_in_any_replica_handler handler, std::uint32_t expected_responses)
-                    : handler_(std::move(handler))
-                    , expected_responses_(expected_responses)
-                  {
-                  }
 
-                  core::impl::movable_lookup_in_any_replica_handler handler_;
-                  std::uint32_t expected_responses_;
-                  bool done_{ false };
-                  std::mutex mutex_{};
-              };
-              auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
-
-              for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
-                  core::document_id replica_id{ r->id() };
-                  replica_id.node_index(idx);
-                  core.execute(core::impl::lookup_in_replica_request{ std::move(replica_id), r->specs(), r->timeout() },
-                               [ctx](core::impl::lookup_in_replica_response&& resp) {
-                                   core::impl::movable_lookup_in_any_replica_handler local_handler;
-                                   {
-                                       const std::scoped_lock lock(ctx->mutex_);
-                                       if (ctx->done_) {
-                                           return;
-                                       }
-                                       --ctx->expected_responses_;
-                                       if (resp.ctx.ec()) {
-                                           if (ctx->expected_responses_ > 0) {
-                                               // just ignore the response
-                                               return;
-                                           }
-                                           // consider document irretrievable and give up
-                                           resp.ctx.override_ec(errc::key_value::document_irretrievable);
-                                       }
-                                       ctx->done_ = true;
-                                       std::swap(local_handler, ctx->handler_);
-                                   }
-                                   if (local_handler) {
-                                       std::vector<lookup_in_replica_result::entry> entries;
-                                       for (const auto& field : resp.fields) {
-                                           lookup_in_replica_result::entry entry{};
-                                           entry.path = field.path;
-                                           entry.original_index = field.original_index;
-                                           entry.exists = field.exists;
-                                           entry.value = field.value;
-                                           entry.ec = field.ec;
-                                           entries.emplace_back(entry);
-                                       }
-                                       return local_handler(
-                                         std::move(resp.ctx),
-                                         lookup_in_replica_result{ resp.cas, entries, resp.deleted, true /* replica */ });
-                                   }
-                               });
-              }
+              return core.with_bucket_configuration(
+                bucket_name,
+                [core = core, r = std::move(r), h = std::move(h)](std::error_code ec, const core::topology::configuration& config) mutable {
+                    if (!config.capabilities.supports_subdoc_read_replica()) {
+                        ec = errc::common::feature_not_available;
+                    }
+                    if (ec) {
+                        return h(core::make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, {}, {}, false),
+                                 lookup_in_replica_result{});
+                    }
+                    struct replica_context {
+                        replica_context(core::impl::movable_lookup_in_any_replica_handler handler, std::uint32_t expected_responses)
+                          : handler_(std::move(handler))
+                          , expected_responses_(expected_responses)
+                        {
+                        }
+
+                        core::impl::movable_lookup_in_any_replica_handler handler_;
+                        std::uint32_t expected_responses_;
+                        bool done_{ false };
+                        std::mutex mutex_{};
+                    };
+                    auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+
+                    for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
+                        core::document_id replica_id{ r->id() };
+                        replica_id.node_index(idx);
+                        core.execute(core::impl::lookup_in_replica_request{ std::move(replica_id), r->specs(), r->timeout() },
+                                     [ctx](core::impl::lookup_in_replica_response&& resp) {
+                                         core::impl::movable_lookup_in_any_replica_handler local_handler;
+                                         {
+                                             const std::scoped_lock lock(ctx->mutex_);
+                                             if (ctx->done_) {
+                                                 return;
+                                             }
+                                             --ctx->expected_responses_;
+                                             if (resp.ctx.ec()) {
+                                                 if (ctx->expected_responses_ > 0) {
+                                                     // just ignore the response
+                                                     return;
+                                                 }
+                                                 // consider document irretrievable and give up
+                                                 resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                                             }
+                                             ctx->done_ = true;
+                                             std::swap(local_handler, ctx->handler_);
+                                         }
+                                         if (local_handler) {
+                                             std::vector<lookup_in_replica_result::entry> entries;
+                                             for (const auto& field : resp.fields) {
+                                                 lookup_in_replica_result::entry entry{};
+                                                 entry.path = field.path;
+                                                 entry.original_index = field.original_index;
+                                                 entry.exists = field.exists;
+                                                 entry.value = field.value;
+                                                 entry.ec = field.ec;
+                                                 entries.emplace_back(entry);
+                                             }
+                                             return local_handler(
+                                               std::move(resp.ctx),
+                                               lookup_in_replica_result{ resp.cas, entries, resp.deleted, true /* replica */ });
+                                         }
+                                     });
+                    }
 
-              core::operations::lookup_in_request active{ core::document_id{ r->id() } };
-              active.specs = r->specs();
-              active.timeout = r->timeout();
-              core.execute(active, [ctx](core::operations::lookup_in_response&& resp) {
-                  core::impl::movable_lookup_in_any_replica_handler local_handler{};
-                  {
-                      const std::scoped_lock lock(ctx->mutex_);
-                      if (ctx->done_) {
-                          return;
-                      }
-                      --ctx->expected_responses_;
-                      if (resp.ctx.ec()) {
-                          if (ctx->expected_responses_ > 0) {
-                              // just ignore the response
-                              return;
-                          }
-                          // consider document irretrievable and give up
-                          resp.ctx.override_ec(errc::key_value::document_irretrievable);
-                      }
-                      ctx->done_ = true;
-                      std::swap(local_handler, ctx->handler_);
-                  }
-                  if (local_handler) {
-                      std::vector<lookup_in_replica_result::entry> entries;
-                      for (const auto& field : resp.fields) {
-                          lookup_in_replica_result::entry entry{};
-                          entry.path = field.path;
-                          entry.original_index = field.original_index;
-                          entry.exists = field.exists;
-                          entry.value = field.value;
-                          entry.ec = field.ec;
-                          entries.emplace_back(entry);
-                      }
-                      return local_handler(std::move(resp.ctx),
-                                           lookup_in_replica_result{ resp.cas, entries, resp.deleted, false /* active */ });
-                  }
-              });
+                    core::operations::lookup_in_request active{ core::document_id{ r->id() } };
+                    active.specs = r->specs();
+                    active.timeout = r->timeout();
+                    core.execute(active, [ctx](core::operations::lookup_in_response&& resp) {
+                        core::impl::movable_lookup_in_any_replica_handler local_handler{};
+                        {
+                            const std::scoped_lock lock(ctx->mutex_);
+                            if (ctx->done_) {
+                                return;
+                            }
+                            --ctx->expected_responses_;
+                            if (resp.ctx.ec()) {
+                                if (ctx->expected_responses_ > 0) {
+                                    // just ignore the response
+                                    return;
+                                }
+                                // consider document irretrievable and give up
+                                resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                            }
+                            ctx->done_ = true;
+                            std::swap(local_handler, ctx->handler_);
+                        }
+                        if (local_handler) {
+                            std::vector<lookup_in_replica_result::entry> entries;
+                            for (const auto& field : resp.fields) {
+                                lookup_in_replica_result::entry entry{};
+                                entry.path = field.path;
+                                entry.original_index = field.original_index;
+                                entry.exists = field.exists;
+                                entry.value = field.value;
+                                entry.ec = field.ec;
+                                entries.emplace_back(entry);
+                            }
+                            return local_handler(std::move(resp.ctx),
+                                                 lookup_in_replica_result{ resp.cas, entries, resp.deleted, false /* active */ });
+                        }
+                    });
+                });
           });
-    }
+    };
 
     void mutate_in(std::string document_key,
                    const std::vector<core::impl::subdoc::command>& specs,