RubyGems - passenger - Versions diffs - 6.0.26 → 6.1.0 - Mend

passenger 6.0.26 → 6.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (915) hide show

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/select_reactor.hpp DELETED Viewed

@@ -1,126 +0,0 @@
-//
-// detail/impl/select_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
-#define BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include <boost/asio/detail/config.hpp>
-#if defined(BOOST_ASIO_HAS_IOCP) \
-  || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
-      && !defined(BOOST_ASIO_HAS_EPOLL) \
-      && !defined(BOOST_ASIO_HAS_KQUEUE) \
-      && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
-#if defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/win_iocp_io_context.hpp>
-#else // defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/scheduler.hpp>
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-#include <boost/asio/detail/push_options.hpp>
-namespace boost {
-namespace asio {
-namespace detail {
-inline void select_reactor::post_immediate_completion(
-    operation* op, bool is_continuation) const
-{
-  scheduler_.post_immediate_completion(op, is_continuation);
-}
-template <typename Time_Traits>
-void select_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-// Remove a timer queue from the reactor.
-template <typename Time_Traits>
-void select_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-template <typename Time_Traits>
-void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-    interrupter_.interrupt();
-}
-template <typename Time_Traits>
-std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-template <typename Time_Traits>
-void select_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-template <typename Time_Traits>
-void select_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(target, ops);
-  queue.move_timer(target, source);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-} // namespace detail
-} // namespace asio
-} // namespace boost
-#include <boost/asio/detail/pop_options.hpp>
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-       //   || (!defined(BOOST_ASIO_HAS_DEV_POLL)
-       //       && !defined(BOOST_ASIO_HAS_EPOLL)
-       //       && !defined(BOOST_ASIO_HAS_KQUEUE)
-       //       && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
-#endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/select_reactor.ipp DELETED Viewed

@@ -1,402 +0,0 @@
-//
-// detail/impl/select_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
-#define BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include <boost/asio/detail/config.hpp>
-#if defined(BOOST_ASIO_HAS_IOCP) \
-  || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
-      && !defined(BOOST_ASIO_HAS_EPOLL) \
-      && !defined(BOOST_ASIO_HAS_KQUEUE) \
-      && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
-#include <boost/asio/detail/fd_set_adapter.hpp>
-#include <boost/asio/detail/select_reactor.hpp>
-#include <boost/asio/detail/signal_blocker.hpp>
-#include <boost/asio/detail/socket_ops.hpp>
-#if defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/win_iocp_io_context.hpp>
-#else // defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/scheduler.hpp>
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-#include <boost/asio/detail/push_options.hpp>
-namespace boost {
-namespace asio {
-namespace detail {
-#if defined(BOOST_ASIO_HAS_IOCP)
-class select_reactor::thread_function
-{
-public:
-  explicit thread_function(select_reactor* r)
-    : this_(r)
-  {
-  }
-  void operator()()
-  {
-    this_->run_thread();
-  }
-private:
-  select_reactor* this_;
-};
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-select_reactor::select_reactor(boost::asio::execution_context& ctx)
-  : execution_context_service_base<select_reactor>(ctx),
-    scheduler_(use_service<scheduler_type>(ctx)),
-    mutex_(),
-    interrupter_(),
-#if defined(BOOST_ASIO_HAS_IOCP)
-    stop_thread_(false),
-    thread_(0),
-    restart_reactor_(this),
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-    shutdown_(false)
-{
-#if defined(BOOST_ASIO_HAS_IOCP)
-  boost::asio::detail::signal_blocker sb;
-  thread_ = new boost::asio::detail::thread(thread_function(this));
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-}
-select_reactor::~select_reactor()
-{
-  shutdown();
-}
-void select_reactor::shutdown()
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-#if defined(BOOST_ASIO_HAS_IOCP)
-  stop_thread_ = true;
-  if (thread_)
-    interrupter_.interrupt();
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-  lock.unlock();
-#if defined(BOOST_ASIO_HAS_IOCP)
-  if (thread_)
-  {
-    thread_->join();
-    delete thread_;
-    thread_ = 0;
-  }
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].get_all_operations(ops);
-  timer_queues_.get_all_timers(ops);
-  scheduler_.abandon_operations(ops);
-}
-void select_reactor::notify_fork(
-    boost::asio::execution_context::fork_event fork_ev)
-{
-#if defined(BOOST_ASIO_HAS_IOCP)
-  (void)fork_ev;
-#else // defined(BOOST_ASIO_HAS_IOCP)
-  if (fork_ev == boost::asio::execution_context::fork_child)
-    interrupter_.recreate();
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-}
-void select_reactor::init_task()
-{
-  scheduler_.init_task();
-}
-int select_reactor::register_descriptor(socket_type,
-    select_reactor::per_descriptor_data&)
-{
-  return 0;
-}
-int select_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue_[op_type].enqueue_operation(descriptor, op);
-  interrupter_.interrupt();
-  return 0;
-}
-void select_reactor::move_descriptor(socket_type,
-    select_reactor::per_descriptor_data&,
-    select_reactor::per_descriptor_data&)
-{
-}
-void select_reactor::call_post_immediate_completion(
-    operation* op, bool is_continuation, const void* self)
-{
-  static_cast<const select_reactor*>(self)->post_immediate_completion(
-      op, is_continuation);
-}
-void select_reactor::start_op(int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op, bool is_continuation,
-    bool, void (*on_immediate)(operation*, bool, const void*),
-    const void* immediate_arg)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (shutdown_)
-  {
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-  bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  scheduler_.work_started();
-  if (first)
-    interrupter_.interrupt();
-}
-void select_reactor::cancel_ops(socket_type descriptor,
-    select_reactor::per_descriptor_data&)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
-}
-void select_reactor::cancel_ops_by_key(socket_type descriptor,
-    select_reactor::per_descriptor_data&,
-    int op_type, void* cancellation_key)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  bool need_interrupt = op_queue_[op_type].cancel_operations_by_key(
-      descriptor, ops, cancellation_key, boost::asio::error::operation_aborted);
-  scheduler_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-void select_reactor::deregister_descriptor(socket_type descriptor,
-    select_reactor::per_descriptor_data&, bool)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
-}
-void select_reactor::deregister_internal_descriptor(
-    socket_type descriptor, select_reactor::per_descriptor_data&)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].cancel_operations(descriptor, ops);
-}
-void select_reactor::cleanup_descriptor_data(
-    select_reactor::per_descriptor_data&)
-{
-}
-void select_reactor::run(long usec, op_queue<operation>& ops)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-#if defined(BOOST_ASIO_HAS_IOCP)
-  // Check if the thread is supposed to stop.
-  if (stop_thread_)
-    return;
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-  // Set up the descriptor sets.
-  for (int i = 0; i < max_select_ops; ++i)
-    fd_sets_[i].reset();
-  fd_sets_[read_op].set(interrupter_.read_descriptor());
-  socket_type max_fd = 0;
-  bool have_work_to_do = !timer_queues_.all_empty();
-  for (int i = 0; i < max_select_ops; ++i)
-  {
-    have_work_to_do = have_work_to_do || !op_queue_[i].empty();
-    fd_sets_[i].set(op_queue_[i], ops);
-    if (fd_sets_[i].max_descriptor() > max_fd)
-      max_fd = fd_sets_[i].max_descriptor();
-  }
-#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Connection operations on Windows use both except and write fd_sets.
-  have_work_to_do = have_work_to_do || !op_queue_[connect_op].empty();
-  fd_sets_[write_op].set(op_queue_[connect_op], ops);
-  if (fd_sets_[write_op].max_descriptor() > max_fd)
-    max_fd = fd_sets_[write_op].max_descriptor();
-  fd_sets_[except_op].set(op_queue_[connect_op], ops);
-  if (fd_sets_[except_op].max_descriptor() > max_fd)
-    max_fd = fd_sets_[except_op].max_descriptor();
-#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
-  // We can return immediately if there's no work to do and the reactor is
-  // not supposed to block.
-  if (!usec && !have_work_to_do)
-    return;
-  // Determine how long to block while waiting for events.
-  timeval tv_buf = { 0, 0 };
-  timeval* tv = usec ? get_timeout(usec, tv_buf) : &tv_buf;
-  lock.unlock();
-  // Block on the select call until descriptors become ready.
-  boost::system::error_code ec;
-  int retval = socket_ops::select(static_cast<int>(max_fd + 1),
-      fd_sets_[read_op], fd_sets_[write_op], fd_sets_[except_op], tv, ec);
-  // Reset the interrupter.
-  if (retval > 0 && fd_sets_[read_op].is_set(interrupter_.read_descriptor()))
-  {
-    if (!interrupter_.reset())
-    {
-      lock.lock();
-#if defined(BOOST_ASIO_HAS_IOCP)
-      stop_thread_ = true;
-      scheduler_.post_immediate_completion(&restart_reactor_, false);
-#else // defined(BOOST_ASIO_HAS_IOCP)
-      interrupter_.recreate();
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-    }
-    --retval;
-  }
-  lock.lock();
-  // Dispatch all ready operations.
-  if (retval > 0)
-  {
-#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
-    // Connection operations on Windows use both except and write fd_sets.
-    fd_sets_[except_op].perform(op_queue_[connect_op], ops);
-    fd_sets_[write_op].perform(op_queue_[connect_op], ops);
-#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
-    // Exception operations must be processed first to ensure that any
-    // out-of-band data is read before normal data.
-    for (int i = max_select_ops - 1; i >= 0; --i)
-      fd_sets_[i].perform(op_queue_[i], ops);
-  }
-  timer_queues_.get_ready_timers(ops);
-}
-void select_reactor::interrupt()
-{
-  interrupter_.interrupt();
-}
-#if defined(BOOST_ASIO_HAS_IOCP)
-void select_reactor::run_thread()
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  while (!stop_thread_)
-  {
-    lock.unlock();
-    op_queue<operation> ops;
-    run(-1, ops);
-    scheduler_.post_deferred_completions(ops);
-    lock.lock();
-  }
-}
-void select_reactor::restart_reactor::do_complete(void* owner, operation* base,
-    const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/)
-{
-  if (owner)
-  {
-    select_reactor* reactor = static_cast<restart_reactor*>(base)->reactor_;
-    if (reactor->thread_)
-    {
-      reactor->thread_->join();
-      delete reactor->thread_;
-      reactor->thread_ = 0;
-    }
-    boost::asio::detail::mutex::scoped_lock lock(reactor->mutex_);
-    reactor->interrupter_.recreate();
-    reactor->stop_thread_ = false;
-    lock.unlock();
-    boost::asio::detail::signal_blocker sb;
-    reactor->thread_ =
-      new boost::asio::detail::thread(thread_function(reactor));
-  }
-}
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-void select_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-void select_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-timeval* select_reactor::get_timeout(long usec, timeval& tv)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  const long max_usec = 5 * 60 * 1000 * 1000;
-  usec = timer_queues_.wait_duration_usec(
-      (usec < 0 || max_usec < usec) ? max_usec : usec);
-  tv.tv_sec = usec / 1000000;
-  tv.tv_usec = usec % 1000000;
-  return &tv;
-}
-void select_reactor::cancel_ops_unlocked(socket_type descriptor,
-    const boost::system::error_code& ec)
-{
-  bool need_interrupt = false;
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    need_interrupt = op_queue_[i].cancel_operations(
-        descriptor, ops, ec) || need_interrupt;
-  scheduler_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-} // namespace detail
-} // namespace asio
-} // namespace boost
-#include <boost/asio/detail/pop_options.hpp>
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-       //   || (!defined(BOOST_ASIO_HAS_DEV_POLL)
-       //       && !defined(BOOST_ASIO_HAS_EPOLL)
-       //       && !defined(BOOST_ASIO_HAS_KQUEUE))
-       //       && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
-#endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/service_registry.hpp DELETED Viewed

@@ -1,95 +0,0 @@
-//
-// detail/impl/service_registry.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
-#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include <boost/asio/detail/push_options.hpp>
-namespace boost {
-namespace asio {
-namespace detail {
-template <typename Service>
-Service& service_registry::use_service()
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  factory_type factory = &service_registry::create<Service, execution_context>;
-  return *static_cast<Service*>(do_use_service(key, factory, &owner_));
-}
-template <typename Service>
-Service& service_registry::use_service(io_context& owner)
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  factory_type factory = &service_registry::create<Service, io_context>;
-  return *static_cast<Service*>(do_use_service(key, factory, &owner));
-}
-template <typename Service>
-void service_registry::add_service(Service* new_service)
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  return do_add_service(key, new_service);
-}
-template <typename Service>
-bool service_registry::has_service() const
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  return do_has_service(key);
-}
-template <typename Service>
-inline void service_registry::init_key(
-    execution_context::service::key& key, ...)
-{
-  init_key_from_id(key, Service::id);
-}
-#if !defined(BOOST_ASIO_NO_TYPEID)
-template <typename Service>
-void service_registry::init_key(execution_context::service::key& key,
-    enable_if_t<is_base_of<typename Service::key_type, Service>::value>*)
-{
-  key.type_info_ = &typeid(typeid_wrapper<Service>);
-  key.id_ = 0;
-}
-template <typename Service>
-void service_registry::init_key_from_id(execution_context::service::key& key,
-    const service_id<Service>& /*id*/)
-{
-  key.type_info_ = &typeid(typeid_wrapper<Service>);
-  key.id_ = 0;
-}
-#endif // !defined(BOOST_ASIO_NO_TYPEID)
-template <typename Service, typename Owner>
-execution_context::service* service_registry::create(void* owner)
-{
-  return new Service(*static_cast<Owner*>(owner));
-}
-} // namespace detail
-} // namespace asio
-} // namespace boost
-#include <boost/asio/detail/pop_options.hpp>
-#endif // BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP