couchbase 3.8.2 → 3.9.0

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

@@ -15,6 +15,8 @@
  *   limitations under the License.
  */
 
+#include <couchbase/build_config.hxx>
+
 #include "core/cluster.hxx"
 
 #include "analytics.hxx"
@@ -23,6 +25,7 @@
 #include "core/cluster_options.hxx"
 #include "core/core_sdk_shim.hxx"
 #include "core/io/ip_protocol.hxx"
+#include "core/io/streams.hxx"
 #include "core/origin.hxx"
 #include "core/tls_verify_mode.hxx"
 #include "core/tracing/constants.hxx"
@@ -36,6 +39,7 @@
 #include "observability_recorder.hxx"
 #include "query.hxx"
 #include "search.hxx"
+#include "wait_until_ready.hxx"
 
 #include <couchbase/analytics_index_manager.hxx>
 #include <couchbase/analytics_options.hxx>
@@ -46,6 +50,7 @@
 #include <couchbase/cluster_options.hxx>
 #include <couchbase/diagnostics_options.hxx>
 #include <couchbase/diagnostics_result.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/error.hxx>
 #include <couchbase/fork_event.hxx>
 #include <couchbase/ip_protocol.hxx>
@@ -175,6 +180,8 @@ options_to_origin(const std::string& connection_string, cluster_options::built o
   user_options.server_group = opts.network.server_group;
 
   user_options.enable_compression = opts.compression.enabled;
+  user_options.compression_min_size = opts.compression.min_size;
+  user_options.compression_min_ratio = opts.compression.min_ratio;
 
   user_options.enable_metrics = opts.metrics.enabled;
   if (opts.metrics.enabled) {
@@ -325,6 +332,28 @@ public:
       });
   }
 
+  // The open notify_fork(child) starts and does not wait for. Requests issued meanwhile wait in the
+  // core for the bootstrap. A failed open leaves the core closed, so they then get cluster_closed.
+  //
+  // The handler captures `this`. It runs inline when open() fails or succeeds without I/O, and
+  // otherwise on the IO thread before do_close() joins it: do_close() closes the core first, which
+  // completes a pending open.
+  void reopen()
+  {
+    opened_future_ = opened_.get_future().share();
+    core_.open(options_to_origin(connection_string_, options_), [this](std::error_code ec) {
+      if (ec) {
+        CB_LOG_ERROR("Unable to reconnect instance after fork: {}", ec.message());
+      }
+      opened_.set_value();
+    });
+    // Created now, not after the bootstrap, so transactions() never sees it unset and nothing
+    // writes it from the IO thread. The requests its cleanup issues wait in the core for the
+    // bootstrap.
+    transactions_ =
+      std::make_shared<core::transactions::transactions>(core_, options_.transactions);
+  }
+
   void query(std::string statement, query_options::built options, query_handler&& handler) const
   {
     auto obs_rec = create_observability_recorder(
@@ -341,6 +370,22 @@ public:
       });
   }
 
+  void query_stream(std::string statement,
+                    query_options::built options,
+                    query_stream_handler&& handler) const
+  {
+    // Instrument the streaming operation exactly like the buffered query(): build the recorder,
+    // thread its operation span into the request as parent_span, and hand the recorder to the
+    // stream so it finishes (latency metric + span end) at the terminal.
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::query, core::service_type::query, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+    auto request = core::impl::build_query_request(
+      std::move(statement), {}, std::move(options), obs_rec->operation_span());
+    core::impl::dispatch_query_stream(
+      core_, std::move(request), std::move(obs_rec), std::move(handler));
+  }
+
   void analytics_query(std::string statement,
                        analytics_options::built options,
                        analytics_handler&& handler) const
@@ -359,10 +404,36 @@ public:
       });
   }
 
+  void analytics_query_stream(std::string statement,
+                              analytics_options::built options,
+                              analytics_stream_handler&& handler) const
+  {
+    // Instrument the streaming operation exactly like the buffered analytics_query() (see
+    // query_stream above for the recorder lifetime).
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::analytics, core::service_type::analytics, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+    auto request = core::impl::build_analytics_request(
+      std::move(statement), std::move(options), {}, {}, obs_rec->operation_span());
+    core::impl::dispatch_analytics_stream(
+      core_, std::move(request), std::move(obs_rec), std::move(handler));
+  }
+
   void ping(const ping_options::built& options, ping_handler&& handler) const
   {
     auto obs_rec = create_observability_recorder(
       core::tracing::operation::ping, std::nullopt, options.parent_span);
+#ifdef COUCHBASE_CXX_CLIENT_BUILD_COUCHBASE2
+    if (core_.is_protostellar()) {
+      // couchbase2 is a thin gRPC client with no per-service sessions to actively probe, and RFC 77
+      // defines no ping semantics for it. Mirror Java/Go/.NET, which surface ping as
+      // feature_not_available on this protocol, rather than returning a misleading empty report.
+      obs_rec->finish(errc::common::feature_not_available);
+      return handler(error{ errc::common::feature_not_available,
+                            "ping is not supported over the couchbase2 protocol" },
+                     {});
+    }
+#endif
     return core_.ping(
       options.report_id,
       {},
@@ -378,6 +449,16 @@ public:
   {
     auto obs_rec = create_observability_recorder(
       core::tracing::operation::diagnostics, std::nullopt, options.parent_span);
+#ifdef COUCHBASE_CXX_CLIENT_BUILD_COUCHBASE2
+    if (core_.is_protostellar()) {
+      // No per-service sessions exist to report on over couchbase2, and the RFC 77 Diagnostics
+      // section is empty. Mirror Java/Go/.NET (feature_not_available) instead of an empty report.
+      obs_rec->finish(errc::common::feature_not_available);
+      return handler(error{ errc::common::feature_not_available,
+                            "diagnostics is not supported over the couchbase2 protocol" },
+                     {});
+    }
+#endif
     return core_.diagnostics(
       options.report_id,
       [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
@@ -386,6 +467,20 @@ public:
       });
   }
 
+  void wait_until_ready(std::chrono::milliseconds timeout,
+                        const wait_until_ready_options::built& options,
+                        wait_until_ready_handler&& handler) const
+  {
+    return core::impl::wait_until_ready(core_,
+                                        std::nullopt,
+                                        timeout,
+                                        options.desired_state,
+                                        core::impl::to_core_service_types(options.service_types),
+                                        [handler = std::move(handler)](std::error_code ec) mutable {
+                                          return handler(couchbase::error{ ec });
+                                        });
+  }
+
   void search(std::string index_name,
               couchbase::search_request request,
               const search_options::built& options,
@@ -466,7 +561,7 @@ public:
       } catch (...) {
         // Undo everything this prepare did, then report. Returning stopped and threadless
         // would hang ~cluster_impl, which waits on a completion only the IO thread can
-        // deliver -- the same hazard as the fork_child/fork_parent path below. The fork
+        // deliver -- the same hazard as the fork_parent path below. The fork
         // must not go ahead, but the cluster stays usable and destructible.
         //
         // The io_context comes back first: restarting cleanup spawns workers that issue KV
@@ -487,21 +582,12 @@ public:
         }
         throw;
       }
-    } else {
-      // TODO(CXXCBC-913): disown this cluster's sockets here, instead of leaving it to the
-      // reconnect. epoll_reactor::notify_fork(fork_child) below re-registers every
-      // descriptor inherited from the parent into the child's new epoll instance, so
-      // from here until those sockets are closed the child polls file descriptions the
-      // parent is still using. Closing them is at least no longer destructive -- see
-      // stream_impl::close(), which detaches a socket it did not open rather than
-      // shutting it down -- but it happens on the reconnect path, asynchronously, and
-      // only once the replaced impl is destroyed.
+    } else if (event == fork_event::parent) {
       io_.restart();
       try {
         io_.notify_fork(fork_event_to_asio(event));
       } catch (...) {
-        // notify_fork() throws if re-registering a descriptor with the new
-        // epoll instance fails. The io_context is unusable after that (asio says
+        // A service's notify_fork() threw. The io_context is unusable after that (asio says
         // to destroy it), but destruction itself needs a runner: do_close()
         // waits on a completion only the IO thread can deliver, so returning
         // from here stopped and threadless would hang ~cluster_impl instead of
@@ -514,6 +600,29 @@ public:
       io_thread_ = std::thread{ [&io = io_] {
         io.run();
       } };
+    } else {
+      // The sockets of this io_context share open file descriptions with the parent, and their
+      // pending reads, writes and timers belong to the parent's sessions. The child detaches every
+      // registered stream and socket, then runs the inherited core's teardown to completion. The
+      // teardown cannot reach the parent's connections through them.
+      //
+      // close() comes before the fixup. It sets stopped_, so if the fixup throws, ~cluster_impl
+      // still completes without a runner.
+      std::promise<void> closed;
+      auto closed_future = closed.get_future();
+      core_.close([closed = std::move(closed)]() mutable {
+        closed.set_value();
+      });
+      // The fixup gives the child its own reactor, and on kqueue it is the only code that repairs
+      // kqueue_fd_. It must come before the detach: releasing a socket removes it from the
+      // reactor, and until the fixup that reactor is the parent's.
+      io_.notify_fork(fork_event_to_asio(event));
+      core::io::detach_inherited_sockets(io_);
+      io_.restart();
+      io_thread_ = std::thread{ [&io = io_] {
+        io.run();
+      } };
+      closed_future.get();
     }
 
     // prepare was handled above, before the io_context was stopped. The child does
@@ -529,6 +638,13 @@ public:
     // Spawn new thread to avoid joining IO thread from the same thread
     std::thread([self = shared_from_this(), handler = std::move(handler)]() mutable {
       self->do_close();
+      // Drop the reference before signalling completion, not after. handler() is what releases
+      // the caller's wait, so anything this thread still owns afterwards outlives that wait. When
+      // this is the last reference, releasing it later means ~cluster_impl -- which starts another
+      // thread and joins the IO thread -- runs unsynchronised with the caller, and a caller that
+      // returns from main() leaves those threads running while static destructors tear down the
+      // gRPC and abseil singletons underneath them.
+      self.reset();
       handler();
     }).detach();
   }
@@ -538,14 +654,33 @@ public:
     return core_;
   }
 
-  [[nodiscard]] auto transactions() const -> std::shared_ptr<core::transactions::transactions>
+  [[nodiscard]] auto core_transactions() const
+    -> const std::shared_ptr<core::transactions::transactions>&
   {
     return transactions_;
   }
 
+  [[nodiscard]] auto transactions() const -> std::shared_ptr<transactions::transactions>
+  {
+    return std::make_shared<transactions::transactions>(transactions_);
+  }
+
 private:
   void do_close()
   {
+    if (opened_future_.valid() &&
+        opened_future_.wait_for(std::chrono::seconds::zero()) != std::future_status::ready) {
+      // Closing the core fails the pending bootstrap and releases the requests the transactions
+      // cleanup holds, so neither wait below runs to bootstrap_timeout. The second core_.close()
+      // further down finds the core stopped and returns at once.
+      std::promise<void> core_stopped;
+      auto f = core_stopped.get_future();
+      core_.close([core_stopped = std::move(core_stopped)]() mutable {
+        core_stopped.set_value();
+      });
+      f.get();
+      opened_future_.wait();
+    }
     if (auto txns = std::move(transactions_); txns != nullptr) {
       // blocks until cleanup is finished
       txns->close();
@@ -580,7 +715,10 @@ private:
   cluster_options::built options_;
   asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
   core::cluster core_{ io_ };
-  std::shared_ptr<core::transactions::transactions> transactions_{ nullptr };
+  std::shared_ptr<couchbase::core::transactions::transactions> transactions_{ nullptr };
+  // Set by reopen(); fulfilled once its open has finished, either way. do_close() reads it.
+  std::promise<void> opened_{};
+  std::shared_future<void> opened_future_{};
   std::thread io_thread_{ [&io = io_] {
     io.run();
   } };
@@ -601,6 +739,19 @@ extract_core_cluster(const couchbase::cluster& cluster) -> const core::cluster&
   return reinterpret_cast<const std::shared_ptr<cluster_impl>*>(&cluster)->get()->core();
 }
 
+/*
+ * This function exists only for usage in the unit tests, and might be removed at any moment.
+ * Avoid using it unless it is absolutely necessary.
+ */
+auto
+extract_core_transactions(const couchbase::cluster& cluster)
+  -> const std::shared_ptr<core::transactions::transactions>&
+{
+  return reinterpret_cast<const std::shared_ptr<cluster_impl>*>(&cluster)
+    ->get()
+    ->core_transactions();
+}
+
 void
 cluster::query(std::string statement, const query_options& options, query_handler&& handler) const
 {
@@ -619,6 +770,26 @@ cluster::query(std::string statement, const query_options& options) const
   return future;
 }
 
+void
+cluster::query_stream(std::string statement,
+                      const query_options& options,
+                      query_stream_handler&& handler) const
+{
+  return impl_->query_stream(std::move(statement), options.build(), std::move(handler));
+}
+
+auto
+cluster::query_stream(std::string statement, const query_options& options) const
+  -> std::future<std::pair<error, query_stream_result>>
+{
+  auto barrier = std::make_shared<std::promise<std::pair<error, query_stream_result>>>();
+  auto future = barrier->get_future();
+  query_stream(std::move(statement), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
+}
+
 void
 cluster::analytics_query(std::string statement,
                          const analytics_options& options,
@@ -639,6 +810,26 @@ cluster::analytics_query(std::string statement, const analytics_options& options
   return future;
 }
 
+void
+cluster::analytics_query_stream(std::string statement,
+                                const analytics_options& options,
+                                analytics_stream_handler&& handler) const
+{
+  return impl_->analytics_query_stream(std::move(statement), options.build(), std::move(handler));
+}
+
+auto
+cluster::analytics_query_stream(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<error, analytics_stream_result>>
+{
+  auto barrier = std::make_shared<std::promise<std::pair<error, analytics_stream_result>>>();
+  auto future = barrier->get_future();
+  analytics_query_stream(std::move(statement), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
+}
+
 void
 cluster::ping(const couchbase::ping_options& options, couchbase::ping_handler&& handler) const
 {
@@ -674,6 +865,26 @@ cluster::diagnostics(const couchbase::diagnostics_options& options) const
   return barrier->get_future();
 }
 
+void
+cluster::wait_until_ready(std::chrono::milliseconds timeout,
+                          const couchbase::wait_until_ready_options& options,
+                          couchbase::wait_until_ready_handler&& handler) const
+{
+  return impl_->wait_until_ready(timeout, options.build(), std::move(handler));
+}
+
+auto
+cluster::wait_until_ready(std::chrono::milliseconds timeout,
+                          const couchbase::wait_until_ready_options& options) const
+  -> std::future<error>
+{
+  auto barrier = std::make_shared<std::promise<error>>();
+  wait_until_ready(timeout, options, [barrier](auto err) mutable {
+    barrier->set_value(std::move(err));
+  });
+  return barrier->get_future();
+}
+
 void
 cluster::search(std::string index_name,
                 search_request request,
@@ -751,34 +962,10 @@ cluster::notify_fork(fork_event event) -> void
     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());
-      }
-      // Adopt the new impl either way. Leaving impl_ null on failure turned the
-      // child's next operation into a segfault, because every data-plane method
-      // dereferences impl_ unchecked; an impl that failed to open reports
-      // errc::network::cluster_closed instead, which is what a caller already gets
-      // from a handle it acquired before the fork.
-      impl_ = new_impl;
-      // Always fulfill the barrier. Returning early here used to hang this
-      // function forever: `barrier` is still owned by the enclosing scope below,
-      // so the promise is never destroyed and future.get() never sees a
-      // broken_promise either -- a failed post-fork reconnect just wedged the
-      // caller.
-      barrier->set_value();
-    });
-
-    future.get();
-  }
+  impl_ = std::make_shared<cluster_impl>(impl_->connection_string(), impl_->options());
+  // Does not wait for the bootstrap: a cluster whose nodes do not answer would hold the child for
+  // the bootstrap timeout. The child has one thread here, so nothing reads impl_ concurrently.
+  impl_->reopen();
 #endif
 }