couchbase 4.2.11-rc.1 → 4.3.0

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,

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

@@ -38,8 +38,8 @@ query_error_context::to_json() const -> std::string
         { "retry_attempts", retry_attempts() },
         { "client_context_id", client_context_id_ },
         { "statement", statement_ },
-        { "method", statement_ },
-        { "path", statement_ },
+        { "method", method_ },
+        { "path", path_ },
         { "http_status", http_status_ },
         { "http_body", http_body_ },
         { "hostname", hostname_ },

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

@@ -30,6 +30,7 @@
 
 #include <asio/steady_timer.hpp>
 
+#include <algorithm>
 #include <utility>
 
 namespace couchbase

package/deps/couchbase-cxx-client/core/io/dns_client.cxx

@@ -285,6 +285,10 @@ dns_client::query_srv(const std::string& name,
                       const dns_config& config,
                       utils::movable_function<void(dns_srv_response&&)>&& handler)
 {
+    if (config.nameserver().empty()) {
+        return handler({ {} });
+    }
+
     std::error_code ec;
     auto address = asio::ip::make_address(config.nameserver(), ec);
     if (ec) {

package/deps/couchbase-cxx-client/core/io/dns_config.cxx

@@ -53,6 +53,7 @@ load_resolv_conf()
     fixed_info = (FIXED_INFO*)malloc(sizeof(FIXED_INFO));
     if (fixed_info == NULL) {
         CB_LOG_WARNING("Error allocating memory needed to call GetNetworkParams");
+        return {};
     }
     buf = sizeof(FIXED_INFO);
 
@@ -63,6 +64,7 @@ load_resolv_conf()
         fixed_info = (FIXED_INFO*)malloc(buf);
         if (fixed_info == NULL) {
             CB_LOG_WARNING("Error allocating memory needed to call GetNetworkParams");
+            return {};
         }
     }
 
@@ -86,10 +88,12 @@ load_resolv_conf()
         }
     } else {
         CB_LOG_WARNING("GetNetworkParams failed with error: {}", ret);
+        return {};
     }
 
-    if (fixed_info)
+    if (fixed_info) {
         free(fixed_info);
+    }
 
     if (dns_servers.size() > 0) {
         CB_LOG_DEBUG(
@@ -153,10 +157,17 @@ dns_config::system_config()
         std::error_code ec;
         asio::ip::make_address(nameserver, ec);
         if (ec) {
-            CB_LOG_DEBUG("Unable to parse \"{}\" as a network address, fall back to \"{}\"", nameserver, default_nameserver);
-            nameserver = default_nameserver;
+            std::string extra_info{};
+#ifndef _WIN32
+            extra_info = fmt::format(" in \"{}\"", default_resolv_conf_path);
+#endif
+            CB_LOG_WARNING("System DNS detection failed: unable to parse \"{}\" as a network address{}. DNS-SRV will not work "
+                           "unless nameserver is specified explicitly in the options.",
+                           nameserver,
+                           extra_info);
+        } else {
+            instance.nameserver_ = nameserver;
         }
-        instance.nameserver_ = nameserver;
     });
 
     return instance;

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

@@ -40,7 +40,7 @@ class dns_config
     [[nodiscard]] std::chrono::milliseconds timeout() const;
 
   private:
-    std::string nameserver_{ default_nameserver };
+    std::string nameserver_{};
     std::uint16_t port_{ default_port };
     std::chrono::milliseconds timeout_{ timeout_defaults::dns_srv_timeout };
 };