couchbase 3.5.5 → 3.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be863220c927e18f335ca7ef97f6ad19c48af740fb444d3cdb210c334aeb0a16
-  data.tar.gz: 72f2f6b4c6464e02ca76d8d7867e4aefca1199f9747046842dcbf4e707505138
+  metadata.gz: fbba46dc6215cb8801a07517e6a711ccd4f5a4791acd9268079c69bbc9a45151
+  data.tar.gz: be0b4ab79a765b7a167313d8c485be7bc17170e7b709f16abacb1aa003aba5a4
 SHA512:
-  metadata.gz: 023ddc717eb09127ad20a2c91106f55cbd3e1c787f4d9476a479ba1753e27638e2535fc445efafb16454c639a1f8e89de7959a63671d88542d3d49ce0a4dea3b
-  data.tar.gz: 38c123cf7ddd2dc4c6f2251f55ed9bdcf49d8cf0443cc0a42a86e165e99fe13affaccd59995da16f1c8b7aff65c281956cddb52ef8f15e3c17357edc82014d2e
+  metadata.gz: bd61a4250aa2e1f6ee69b44bf9bed1378653c778f946546fa521225f0f4e4f8562a27fff83cd1e27b9e594507a2b0ae42a706a53718b92384d7c2252ab8e8398
+  data.tar.gz: 2735a18eb2df270cf4689b9aabfa643339d4feb28ff45eb74d31f1dc2ac33755a9881e5b5a49c749e21fc86ca93b5f3bc87aa597fcdd5f911e04521be43d124c

data/README.md

@@ -23,7 +23,7 @@ The library has been tested with MRI 3.1, 3.2 and 3.3. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.5.5"
+gem "couchbase", "3.5.6"
 ```
 
 And then execute:

data/ext/cache/extconf_include.rb

@@ -3,6 +3,6 @@ cmake_flags << "-DCPM_USE_NAMED_CACHE_DIRECTORIES=ON"
 cmake_flags << "-DCPM_USE_LOCAL_PACKAGES=OFF"
 cmake_flags << "-DCPM_SOURCE_CACHE=#{File.expand_path('cache', __dir__)}"
 cmake_flags << "-DCOUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE_ROOT=#{File.expand_path('cache', __dir__)}"
-cmake_flags << "-DEXT_GIT_REVISION=987a0b43b2dd7530573acdc3655fef7d6cdd7d17"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=24dca979ec842ce200aaa1741f1271a4a61c837d"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.5-0-g24dca97"
+cmake_flags << "-DEXT_GIT_REVISION=6d89cab6c6a03726fb3bf1d8cccb9f07097fd7fb"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=b5b5145145e656d70962fe3cbb78f5af53eaaf63"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.6-0-gb5b5145"

data/ext/cache/mozilla-ca-bundle.crt

@@ -1,7 +1,7 @@
 ##
 ## Bundle of CA Root Certificates
 ##
-## Certificate data from Mozilla as of: Tue Dec 31 04:12:05 2024 GMT
+## Certificate data from Mozilla as of: Tue Feb 25 04:12:03 2025 GMT
 ##
 ## Find updated versions here: https://curl.se/docs/caextract.html
 ##
@@ -16,7 +16,7 @@
 ## Just configure this file as the SSLCACertificateFile.
 ##
 ## Conversion done with mk-ca-bundle.pl version 1.29.
-## SHA256: c99d6d3f8d3d4e47719ba2b648992f5b58b150128d3aca3c05c566d8dc98e116
+## SHA256: 620fd89c02acb0019f1899dab7907db5d20735904f5a9a0d3a8771a5857ac482
 ##
 
 
@@ -371,37 +371,6 @@ NU0LbbqhPcCT4H8js1WtciVORvnSFu+wZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6Lqj
 viOvrv1vA+ACOzB2+httQc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ
 -----END CERTIFICATE-----
 
-SwissSign Silver CA - G2
-========================
------BEGIN CERTIFICATE-----
-MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCQ0gxFTAT
-BgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMB4X
-DTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0NlowRzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3
-aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG
-9w0BAQEFAAOCAg8AMIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644
-N0MvFz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7brYT7QbNHm
-+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieFnbAVlDLaYQ1HTWBCrpJH
-6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH6ATK72oxh9TAtvmUcXtnZLi2kUpCe2Uu
-MGoM9ZDulebyzYLs2aFK7PayS+VFheZteJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5h
-qAaEuSh6XzjZG6k4sIN/c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5
-FZGkECwJMoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRHHTBs
-ROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTfjNFusB3hB48IHpmc
-celM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb65i/4z3GcRm25xBWNOHkDRUjvxF3X
-CO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOBrDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
-BAUwAwEB/zAdBgNVHQ4EFgQUF6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRB
-tjpbO8tFnb0cwpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0
-cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBAHPGgeAn0i0P
-4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShpWJHckRE1qTodvBqlYJ7YH39F
-kWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L
-3XWgwF15kIwb4FDm3jH+mHtwX6WQ2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx
-/uNncqCxv1yL5PqZIseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFa
-DGi8aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2Xem1ZqSqP
-e97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQRdAtq/gsD/KNVV4n+Ssuu
-WxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJ
-DIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ub
-DgEj8Z+7fNzcbBGXJbLytGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u
------END CERTIFICATE-----
-
 SecureTrust CA
 ==============
 -----BEGIN CERTIFICATE-----
@@ -3609,3 +3578,65 @@ AgEGMB0GA1UdDgQWBBTrQciu/NWeUUj1vYv0hyCTQSvT9DAKBggqhkjOPQQDAwNoADBlAjEA2S6J
 fl5OpBEHvVnCB96rMjhTKkZEBhd6zlHp4P9mLQlO4E/0BdGF9jVg3PVys0Z9AjBEmEYagoUeYWmJ
 SwdLZrWeqrqgHkHZAXQ6bkU6iYAZezKYVWOr62Nuk22rGwlgMU4=
 -----END CERTIFICATE-----
+
+D-TRUST BR Root CA 2 2023
+=========================
+-----BEGIN CERTIFICATE-----
+MIIFqTCCA5GgAwIBAgIQczswBEhb2U14LnNLyaHcZjANBgkqhkiG9w0BAQ0FADBIMQswCQYDVQQG
+EwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRSVVNUIEJSIFJvb3QgQ0Eg
+MiAyMDIzMB4XDTIzMDUwOTA4NTYzMVoXDTM4MDUwOTA4NTYzMFowSDELMAkGA1UEBhMCREUxFTAT
+BgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAGA1UEAxMZRC1UUlVTVCBCUiBSb290IENBIDIgMjAyMzCC
+AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK7/CVmRgApKaOYkP7in5Mg6CjoWzckjYaCT
+cfKri3OPoGdlYNJUa2NRb0kz4HIHE304zQaSBylSa053bATTlfrdTIzZXcFhfUvnKLNEgXtRr90z
+sWh81k5M/itoucpmacTsXld/9w3HnDY25QdgrMBM6ghs7wZ8T1soegj8k12b9py0i4a6Ibn08OhZ
+WiihNIQaJZG2tY/vsvmA+vk9PBFy2OMvhnbFeSzBqZCTRphny4NqoFAjpzv2gTng7fC5v2Xx2Mt6
+++9zA84A9H3X4F07ZrjcjrqDy4d2A/wl2ecjbwb9Z/Pg/4S8R7+1FhhGaRTMBffb00msa8yr5LUL
+QyReS2tNZ9/WtT5PeB+UcSTq3nD88ZP+npNa5JRal1QMNXtfbO4AHyTsA7oC9Xb0n9Sa7YUsOCIv
+x9gvdhFP/Wxc6PWOJ4d/GUohR5AdeY0cW/jPSoXk7bNbjb7EZChdQcRurDhaTyN0dKkSw/bSuREV
+MweR2Ds3OmMwBtHFIjYoYiMQ4EbMl6zWK11kJNXuHA7e+whadSr2Y23OC0K+0bpwHJwh5Q8xaRfX
+/Aq03u2AnMuStIv13lmiWAmlY0cL4UEyNEHZmrHZqLAbWt4NDfTisl01gLmB1IRpkQLLddCNxbU9
+CZEJjxShFHR5PtbJFR2kWVki3PaKRT08EtY+XTIvAgMBAAGjgY4wgYswDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUZ5Dw1t61GNVGKX5cq/ieCLxklRAwDgYDVR0PAQH/BAQDAgEGMEkGA1UdHwRC
+MEAwPqA8oDqGOGh0dHA6Ly9jcmwuZC10cnVzdC5uZXQvY3JsL2QtdHJ1c3RfYnJfcm9vdF9jYV8y
+XzIwMjMuY3JsMA0GCSqGSIb3DQEBDQUAA4ICAQA097N3U9swFrktpSHxQCF16+tIFoE9c+CeJyrr
+d6kTpGoKWloUMz1oH4Guaf2Mn2VsNELZLdB/eBaxOqwjMa1ef67nriv6uvw8l5VAk1/DLQOj7aRv
+U9f6QA4w9QAgLABMjDu0ox+2v5Eyq6+SmNMW5tTRVFxDWy6u71cqqLRvpO8NVhTaIasgdp4D/Ca4
+nj8+AybmTNudX0KEPUUDAxxZiMrcLmEkWqTqJwtzEr5SswrPMhfiHocaFpVIbVrg0M8JkiZmkdij
+YQ6qgYF/6FKC0ULn4B0Y+qSFNueG4A3rvNTJ1jxD8V1Jbn6Bm2m1iWKPiFLY1/4nwSPFyysCu7Ff
+/vtDhQNGvl3GyiEm/9cCnnRK3PgTFbGBVzbLZVzRHTF36SXDw7IyN9XxmAnkbWOACKsGkoHU6XCP
+pz+y7YaMgmo1yEJagtFSGkUPFaUA8JR7ZSdXOUPPfH/mvTWze/EZTN46ls/pdu4D58JDUjxqgejB
+WoC9EV2Ta/vH5mQ/u2kc6d0li690yVRAysuTEwrt+2aSEcr1wPrYg1UDfNPFIkZ1cGt5SAYqgpq/
+5usWDiJFAbzdNpQ0qTUmiteXue4Icr80knCDgKs4qllo3UCkGJCy89UDyibK79XH4I9TjvAA46jt
+n/mtd+ArY0+ew+43u3gJhJ65bvspmZDogNOfJA==
+-----END CERTIFICATE-----
+
+D-TRUST EV Root CA 2 2023
+=========================
+-----BEGIN CERTIFICATE-----
+MIIFqTCCA5GgAwIBAgIQaSYJfoBLTKCnjHhiU19abzANBgkqhkiG9w0BAQ0FADBIMQswCQYDVQQG
+EwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRSVVNUIEVWIFJvb3QgQ0Eg
+MiAyMDIzMB4XDTIzMDUwOTA5MTAzM1oXDTM4MDUwOTA5MTAzMlowSDELMAkGA1UEBhMCREUxFTAT
+BgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAGA1UEAxMZRC1UUlVTVCBFViBSb290IENBIDIgMjAyMzCC
+AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANiOo4mAC7JXUtypU0w3uX9jFxPvp1sjW2l1
+sJkKF8GLxNuo4MwxusLyzV3pt/gdr2rElYfXR8mV2IIEUD2BCP/kPbOx1sWy/YgJ25yE7CUXFId/
+MHibaljJtnMoPDT3mfd/06b4HEV8rSyMlD/YZxBTfiLNTiVR8CUkNRFeEMbsh2aJgWi6zCudR3Mf
+vc2RpHJqnKIbGKBv7FD0fUDCqDDPvXPIEysQEx6Lmqg6lHPTGGkKSv/BAQP/eX+1SH977ugpbzZM
+lWGG2Pmic4ruri+W7mjNPU0oQvlFKzIbRlUWaqZLKfm7lVa/Rh3sHZMdwGWyH6FDrlaeoLGPaxK3
+YG14C8qKXO0elg6DpkiVjTujIcSuWMYAsoS0I6SWhjW42J7YrDRJmGOVxcttSEfi8i4YHtAxq910
+7PncjLgcjmgjutDzUNzPZY9zOjLHfP7KgiJPvo5iR2blzYfi6NUPGJ/lBHJLRjwQ8kTCZFZxTnXo
+nMkmdMV9WdEKWw9t/p51HBjGGjp82A0EzM23RWV6sY+4roRIPrN6TagD4uJ+ARZZaBhDM7DS3LAa
+QzXupdqpRlyuhoFBAUp0JuyfBr/CBTdkdXgpaP3F9ev+R/nkhbDhezGdpn9yo7nELC7MmVcOIQxF
+AZRl62UJxmMiCzNJkkg8/M3OsD6Onov4/knFNXJHAgMBAAGjgY4wgYswDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUqvyREBuHkV8Wub9PS5FeAByxMoAwDgYDVR0PAQH/BAQDAgEGMEkGA1UdHwRC
+MEAwPqA8oDqGOGh0dHA6Ly9jcmwuZC10cnVzdC5uZXQvY3JsL2QtdHJ1c3RfZXZfcm9vdF9jYV8y
+XzIwMjMuY3JsMA0GCSqGSIb3DQEBDQUAA4ICAQCTy6UfmRHsmg1fLBWTxj++EI14QvBukEdHjqOS
+Mo1wj/Zbjb6JzkcBahsgIIlbyIIQbODnmaprxiqgYzWRaoUlrRc4pZt+UPJ26oUFKidBK7GB0aL2
+QHWpDsvxVUjY7NHss+jOFKE17MJeNRqrphYBBo7q3C+jisosketSjl8MmxfPy3MHGcRqwnNU73xD
+UmPBEcrCRbH0O1P1aa4846XerOhUt7KR/aypH/KH5BfGSah82ApB9PI+53c0BFLd6IHyTS9URZ0V
+4U/M5d40VxDJI3IXcI1QcB9WbMy5/zpaT2N6w25lBx2Eof+pDGOJbbJAiDnXH3dotfyc1dZnaVuo
+dNv8ifYbMvekJKZ2t0dT741Jj6m2g1qllpBFYfXeA08mD6iL8AOWsKwV0HFaanuU5nCT2vFp4LJi
+TZ6P/4mdm13NRemUAiKN4DV/6PEEeXFsVIP4M7kFMhtYVRFP0OUnR3Hs7dpn1mKmS00PaaLJvOwi
+S5THaJQXfuKOKD62xur1NGyfN4gHONuGcfrNlUhDbqNPgofXNJhuS5N5YHVpD/Aa1VP6IQzCP+k/
+HxiMkl14p3ZnGbuy6n/pcAlWVqOwDAstNl7F6cTVg8uGF5csbBNvh1qvSaYd2804BC5f4ko1Di1L
++KIkBI3Y4WNeApI02phhXBxvWHZks/wCuPWdCg==
+-----END CERTIFICATE-----

data/ext/cache/mozilla-ca-bundle.sha256

@@ -1 +1 @@
-a3f328c21e39ddd1f2be1cea43ac0dec819eaa20a90425d7da901a11531b3aa5  cacert.pem
+50a6277ec69113f00c5fd45f09e8b97a4b3e32daa35d3a95ab30137a55386cef  cacert.pem

data/ext/couchbase/CMakeLists.txt

@@ -21,7 +21,7 @@ endif()
 
 project(
   couchbase_cxx_client
-  VERSION "1.0.5"
+  VERSION "1.0.6"
   LANGUAGES CXX C)
 message(STATUS "Couchbase C++ client ${couchbase_cxx_client_VERSION} build ${couchbase_cxx_client_BUILD_NUMBER}, master: ${COUCHBASE_CXX_CLIENT_MASTER_PROJECT}")
 message(STATUS "System: ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_VERSION}, ${CMAKE_SYSTEM_PROCESSOR}")

data/ext/couchbase/core/bucket.cxx

@@ -356,7 +356,7 @@ public:
   void restart_sessions()
   {
     const std::scoped_lock lock(config_mutex_, sessions_mutex_);
-    if (!config_.has_value()) {
+    if (!config_) {
       return;
     }
 
@@ -512,37 +512,38 @@ public:
   }
 
   void with_configuration(
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler)
   {
     if (closed_) {
-      return handler(errc::network::configuration_not_available, topology::configuration{});
+      return handler(errc::network::configuration_not_available, nullptr);
     }
     if (configured_) {
-      std::optional<topology::configuration> config{};
+      std::shared_ptr<topology::configuration> config{};
       {
         const std::scoped_lock config_lock(config_mutex_);
         config = config_;
       }
       if (config) {
-        return handler({}, config.value());
+        return handler({}, config);
       }
-      return handler(errc::network::configuration_not_available, topology::configuration{});
+      return handler(errc::network::configuration_not_available, nullptr);
     }
     const std::scoped_lock lock(deferred_commands_mutex_);
     deferred_commands_.emplace([self = shared_from_this(), handler = std::move(handler)]() mutable {
       if (self->closed_ || !self->configured_) {
-        return handler(errc::network::configuration_not_available, topology::configuration{});
+        return handler(errc::network::configuration_not_available, nullptr);
       }
 
-      std::optional<topology::configuration> config{};
+      std::shared_ptr<topology::configuration> config{};
       {
         const std::scoped_lock config_lock(self->config_mutex_);
         config = self->config_;
       }
       if (config) {
-        return handler({}, config.value());
+        return handler({}, std::move(config));
       }
-      return handler(errc::network::configuration_not_available, topology::configuration{});
+      return handler(errc::network::configuration_not_available, nullptr);
     });
   }
 
@@ -715,7 +716,7 @@ public:
                      config_->rev_str(),
                      config.rev_str());
         return;
-      } else if (config_ < config) {
+      } else if (*config_ < config) {
         CB_LOG_DEBUG("{} will update the configuration old={} -> new={}",
                      log_prefix_,
                      config_->rev_str(),
@@ -742,7 +743,7 @@ public:
         added = config.nodes;
       }
       config_.reset();
-      config_ = config;
+      config_ = std::make_shared<topology::configuration>(config);
       configured_ = true;
 
       {
@@ -964,7 +965,7 @@ private:
   std::atomic_bool closed_{ false };
   std::atomic_bool configured_{ false };
 
-  std::optional<topology::configuration> config_{};
+  std::shared_ptr<topology::configuration> config_{};
   mutable std::mutex config_mutex_{};
 
   std::vector<std::shared_ptr<config_listener>> config_listeners_{};
@@ -1081,7 +1082,8 @@ bucket::bootstrap(utils::movable_function<void(std::error_code, topology::config
 
 void
 bucket::with_configuration(
-  utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
+  utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+    handler)
 {
   return impl_->with_configuration(std::move(handler));
 }

data/ext/couchbase/core/bucket.hxx

@@ -189,7 +189,8 @@ public:
   void update_config(topology::configuration config) override;
   void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
   void with_configuration(
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler);
 
   void on_configuration_update(std::shared_ptr<config_listener> handler);
   void close();

data/ext/couchbase/core/cluster.cxx

@@ -578,12 +578,12 @@ public:
         return self->with_bucket_configuration(
           bucket_name,
           [self, cap, request = std::move(request), handler = std::forward<Handler>(handler)](
-            std::error_code ec, const topology::configuration& config) mutable {
+            std::error_code ec, const std::shared_ptr<topology::configuration>& config) mutable {
             if (ec) {
               handler(request.make_response({ ec }, {}));
               return;
             }
-            if (!config.capabilities.has_bucket_capability(cap)) {
+            if (!config->capabilities.has_bucket_capability(cap)) {
               handler(request.make_response({ errc::common::feature_not_available }, {}));
               return;
             }
@@ -980,10 +980,11 @@ public:
 
   void with_bucket_configuration(
     const std::string& bucket_name,
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler)
   {
     if (stopped_) {
-      return handler(errc::network::cluster_closed, {});
+      return handler(errc::network::cluster_closed, nullptr);
     }
     if (auto bucket = find_bucket_by_name(bucket_name); bucket != nullptr) {
       return bucket->with_configuration(std::move(handler));
@@ -992,13 +993,13 @@ public:
       bucket_name,
       [self = shared_from_this(), bucket_name, handler = std::move(handler)](auto ec) mutable {
         if (ec) {
-          return handler(ec, {});
+          return handler(ec, nullptr);
         }
 
         if (auto bucket = self->find_bucket_by_name(bucket_name); bucket != nullptr) {
           return bucket->with_configuration(std::move(handler));
         }
-        return handler(errc::common::bucket_not_found, {});
+        return handler(errc::common::bucket_not_found, nullptr);
       });
   }
 
@@ -1326,7 +1327,8 @@ cluster::ping(std::optional<std::string> report_id,
 void
 cluster::with_bucket_configuration(
   const std::string& bucket_name,
-  utils::movable_function<void(std::error_code, topology::configuration)>&& handler) const
+  utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+    handler) const
 {
   if (impl_) {
     impl_->with_bucket_configuration(bucket_name, std::move(handler));

data/ext/couchbase/core/cluster.hxx

@@ -77,7 +77,8 @@ public:
 
   void with_bucket_configuration(
     const std::string& bucket_name,
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler) const;
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler) const;
 
   void execute(o::analytics_request request, mf<void(o::analytics_response)>&& handler) const;
   void execute(o::append_request request, mf<void(o::append_response)>&& handler) const;

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

@@ -79,8 +79,8 @@ cluster::cluster(std::shared_ptr<cluster_impl> impl)
 namespace
 {
 auto
-options_to_origin(const std::string& connection_string,
-                  const couchbase::cluster_options& options) -> core::origin
+options_to_origin(const std::string& connection_string, const couchbase::cluster_options& options)
+  -> core::origin
 {
   auto opts = options.build();
 
@@ -215,12 +215,27 @@ fork_event_to_asio(fork_event event) -> asio::execution_context::fork_event
 class cluster_impl : public std::enable_shared_from_this<cluster_impl>
 {
 public:
-  cluster_impl() = default;
+  cluster_impl(std::string connection_string, cluster_options options)
+    : connection_string_{ std::move(connection_string) }
+    , options_{ std::move(options) }
+  {
+  }
+
   cluster_impl(const cluster_impl&) = delete;
   cluster_impl(cluster_impl&&) = delete;
   auto operator=(const cluster_impl&) = delete;
   auto operator=(cluster_impl&&) = delete;
 
+  [[nodiscard]] auto connection_string() const -> const std::string&
+  {
+    return connection_string_;
+  }
+
+  [[nodiscard]] auto options() const -> const cluster_options&
+  {
+    return options_;
+  }
+
   ~cluster_impl()
   {
     std::promise<void> barrier;
@@ -238,12 +253,10 @@ public:
     future.get();
   }
 
-  void open(const std::string& connection_string,
-            const cluster_options& options,
-            cluster_connect_handler&& handler)
+  void open(cluster_connect_handler&& handler)
   {
     core_.open(
-      options_to_origin(connection_string, options),
+      options_to_origin(connection_string_, options_),
       [impl = shared_from_this(), handler = std::move(handler)](std::error_code ec) mutable {
         if (ec) {
           return handler(ec, {});
@@ -350,7 +363,7 @@ public:
     }
     io_.notify_fork(fork_event_to_asio(event));
 
-    if (transactions_) {
+    if (event != fork_event::child && transactions_) {
       transactions_->notify_fork(event);
     }
   }
@@ -393,6 +406,8 @@ private:
     }
   }
 
+  std::string connection_string_;
+  cluster_options options_;
   asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
   core::cluster core_{ io_ };
   std::shared_ptr<core::transactions::transactions> transactions_{ nullptr };
@@ -423,8 +438,8 @@ cluster::query(std::string statement, const query_options& options, query_handle
 }
 
 auto
-cluster::query(std::string statement,
-               const query_options& options) const -> std::future<std::pair<error, query_result>>
+cluster::query(std::string statement, const query_options& options) const
+  -> std::future<std::pair<error, query_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, query_result>>>();
   auto future = barrier->get_future();
@@ -500,9 +515,8 @@ cluster::search(std::string index_name,
 }
 
 auto
-cluster::search(std::string index_name,
-                search_request request,
-                const search_options& options) const -> std::future<std::pair<error, search_result>>
+cluster::search(std::string index_name, search_request request, const search_options& options) const
+  -> std::future<std::pair<error, search_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, search_result>>>();
   search(
@@ -513,8 +527,8 @@ cluster::search(std::string index_name,
 }
 
 auto
-cluster::connect(const std::string& connection_string,
-                 const cluster_options& options) -> std::future<std::pair<error, cluster>>
+cluster::connect(const std::string& connection_string, const cluster_options& options)
+  -> std::future<std::pair<error, cluster>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
   auto future = barrier->get_future();
@@ -535,8 +549,8 @@ cluster::connect(const std::string& connection_string,
     auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
     auto future = barrier->get_future();
     {
-      auto impl = std::make_shared<cluster_impl>();
-      impl->open(connection_string, options, [barrier](auto err, auto c) {
+      auto impl = std::make_shared<cluster_impl>(connection_string, options);
+      impl->open([barrier](auto err, auto c) {
         barrier->set_value({ std::move(err), std::move(c) });
       });
     }
@@ -552,7 +566,30 @@ cluster::notify_fork(fork_event event) -> void
   if (!impl_) {
     return;
   }
-  return impl_->notify_fork(event);
+  impl_->notify_fork(event);
+  if (event != fork_event::child) {
+    return;
+  }
+
+  auto new_impl = std::make_shared<cluster_impl>(impl_->connection_string(), impl_->options());
+  impl_.reset();
+
+  {
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto future = barrier->get_future();
+
+    new_impl->open([this, barrier, new_impl](const auto& err, const auto& /* c */) {
+      if (err.ec()) {
+        // TODO(SA): we should fall to background reconnect loop similar to Columnar build
+        CB_LOG_ERROR("Unable to reconnect instance after fork: {}", err.ec().message());
+        return;
+      }
+      impl_ = new_impl;
+      barrier->set_value();
+    });
+
+    future.get();
+  }
 }
 
 void

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

@@ -884,13 +884,14 @@ public:
         return core_.with_bucket_configuration(
           bucket_name_,
           [this, handler = std::move(handler), orchestrator_opts, core_scan_type](
-            std::error_code ec, const core::topology::configuration& config) mutable {
+            std::error_code ec,
+            const std::shared_ptr<core::topology::configuration>& config) mutable {
             if (ec) {
               return handler(
                 error(ec, "An error occurred when attempting to fetch the bucket configuration."),
                 {});
             }
-            if (!config.capabilities.supports_range_scan()) {
+            if (!config->capabilities.supports_range_scan()) {
               return handler(error(errc::common::feature_not_available,
                                    "This bucket does not support range scan."),
                              {});
@@ -913,7 +914,7 @@ public:
                         bucket_name_)),
                 {});
             }
-            if (!config.vbmap.has_value() || config.vbmap->empty()) {
+            if (!config->vbmap.has_value() || config->vbmap->empty()) {
               CB_LOG_WARNING("Unable to get vbucket map for `{}` - cannot perform scan operation",
                              bucket_name_);
               return handler(error(errc::common::request_canceled,
@@ -923,7 +924,7 @@ public:
 
             auto orchestrator = core::range_scan_orchestrator(core_.io_context(),
                                                               agent.value(),
-                                                              config.vbmap.value(),
+                                                              config->vbmap.value(),
                                                               scope_name_,
                                                               name_,
                                                               core_scan_type,
@@ -993,8 +994,8 @@ collection::get(std::string document_id, const get_options& options, get_handler
 }
 
 auto
-collection::get(std::string document_id,
-                const get_options& options) const -> std::future<std::pair<error, get_result>>
+collection::get(std::string document_id, const get_options& options) const
+  -> std::future<std::pair<error, get_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, get_result>>>();
   auto future = barrier->get_future();
@@ -1296,9 +1297,8 @@ collection::unlock(std::string document_id,
 }
 
 auto
-collection::unlock(std::string document_id,
-                   couchbase::cas cas,
-                   const unlock_options& options) const -> std::future<error>
+collection::unlock(std::string document_id, couchbase::cas cas, const unlock_options& options) const
+  -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
@@ -1409,8 +1409,9 @@ collection::scan(const couchbase::scan_type& scan_type,
 }
 
 auto
-collection::scan(const couchbase::scan_type& scan_type, const couchbase::scan_options& options)
-  const -> std::future<std::pair<error, scan_result>>
+collection::scan(const couchbase::scan_type& scan_type,
+                 const couchbase::scan_options& options) const
+  -> std::future<std::pair<error, scan_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, scan_result>>>();
   auto future = barrier->get_future();

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

@@ -96,24 +96,24 @@ number_of_replica_nodes_required(couchbase::replicate_to replicate_to) -> std::u
 }
 
 auto
-validate_replicas(const topology::configuration& config,
+validate_replicas(const std::shared_ptr<topology::configuration>& config,
                   couchbase::persist_to persist_to,
                   couchbase::replicate_to replicate_to) -> std::pair<std::error_code, std::uint32_t>
 {
-  if (config.node_locator != topology::configuration::node_locator_type::vbucket) {
+  if (config->node_locator != topology::configuration::node_locator_type::vbucket) {
     return { errc::common::feature_not_available, {} };
   }
 
   if (touches_replica(persist_to, replicate_to)) {
-    if (!config.num_replicas) {
+    auto number_of_replicas = config->num_replicas;
+    if (!number_of_replicas.has_value()) {
       return { errc::key_value::durability_impossible, {} };
     }
-    auto number_of_replicas = config.num_replicas.value();
     if (number_of_replica_nodes_required(persist_to) > number_of_replicas ||
         number_of_replica_nodes_required(replicate_to) > number_of_replicas) {
       return { errc::key_value::durability_impossible, {} };
     }
-    return { {}, number_of_replicas };
+    return { {}, number_of_replicas.value() };
   }
   return { {}, 0 };
 }
@@ -335,8 +335,8 @@ observe_poll(const cluster& core, std::shared_ptr<observe_context> ctx)
   const std::string bucket_name = ctx->bucket_name();
   core.with_bucket_configuration(
     bucket_name,
-    [core, ctx = std::move(ctx)](std::error_code ec,
-                                 const core::topology::configuration& config) mutable {
+    [core, ctx = std::move(ctx)](
+      std::error_code ec, const std::shared_ptr<core::topology::configuration>& config) mutable {
       if (ec) {
         return ctx->finish(ec);
       }

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

@@ -25,7 +25,7 @@ namespace couchbase::core::impl
 
 auto
 effective_nodes(const document_id& id,
-                const topology::configuration& config,
+                const std::shared_ptr<topology::configuration>& config,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>
 {
@@ -37,12 +37,12 @@ effective_nodes(const document_id& id,
   std::vector<readable_node> available_nodes{};
   std::vector<readable_node> local_nodes{};
 
-  for (std::size_t idx = 0U; idx <= config.num_replicas.value_or(0U); ++idx) {
-    auto [vbid, server] = config.map_key(id.key(), idx);
-    if (server.has_value() && server.value() < config.nodes.size()) {
+  for (std::size_t idx = 0U; idx <= config->num_replicas.value_or(0U); ++idx) {
+    auto [vbid, server] = config->map_key(id.key(), idx);
+    if (server.has_value() && server.value() < config->nodes.size()) {
       const bool is_replica = idx != 0;
       available_nodes.emplace_back(readable_node{ is_replica, idx });
-      if (preferred_server_group == config.nodes[server.value()].server_group) {
+      if (preferred_server_group == config->nodes[server.value()].server_group) {
         local_nodes.emplace_back(readable_node{ is_replica, idx });
       }
     }

data/ext/couchbase/core/impl/replica_utils.hxx

@@ -23,6 +23,7 @@
 
 #include "couchbase/read_preference.hxx"
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -42,7 +43,7 @@ struct readable_node {
  */
 auto
 effective_nodes(const document_id& id,
-                const topology::configuration& config,
+                const std::shared_ptr<topology::configuration>& config,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>;
 } // namespace couchbase::core::impl

data/ext/couchbase/core/logger/logger.cxx

@@ -322,7 +322,7 @@ create_file_logger(const configuration& logger_settings) -> std::optional<std::s
   if (error) {
     return error;
   }
-  file_logger = std::move(logger);
+  update_file_logger(logger);
   return {};
 }