couchbase 3.0.0.alpha.4-x86_64-linux → 3.5.0-x86_64-linux

data/ext/third_party/asio/asio/src/examples/cpp11/executors/priority_scheduler.cpp

@@ -1,174 +0,0 @@
-#include <asio/dispatch.hpp>
-#include <asio/execution_context.hpp>
-#include <condition_variable>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <queue>
-
-using asio::dispatch;
-using asio::execution_context;
-
-class priority_scheduler : public execution_context
-{
-public:
-  // A class that satisfies the Executor requirements.
-  class executor_type
-  {
-  public:
-    executor_type(priority_scheduler& ctx, int pri) noexcept
-      : context_(ctx), priority_(pri)
-    {
-    }
-
-    priority_scheduler& context() const noexcept
-    {
-      return context_;
-    }
-
-    void on_work_started() const noexcept
-    {
-      // This executor doesn't count work. Instead, the scheduler simply runs
-      // until explicitly stopped.
-    }
-
-    void on_work_finished() const noexcept
-    {
-      // This executor doesn't count work. Instead, the scheduler simply runs
-      // until explicitly stopped.
-    }
-
-    template <class Func, class Alloc>
-    void dispatch(Func&& f, const Alloc& a) const
-    {
-      post(std::forward<Func>(f), a);
-    }
-
-    template <class Func, class Alloc>
-    void post(Func f, const Alloc& a) const
-    {
-      auto p(std::allocate_shared<item<Func>>(
-            typename std::allocator_traits<
-              Alloc>::template rebind_alloc<char>(a),
-            priority_, std::move(f)));
-      std::lock_guard<std::mutex> lock(context_.mutex_);
-      context_.queue_.push(p);
-      context_.condition_.notify_one();
-    }
-
-    template <class Func, class Alloc>
-    void defer(Func&& f, const Alloc& a) const
-    {
-      post(std::forward<Func>(f), a);
-    }
-
-    friend bool operator==(const executor_type& a,
-        const executor_type& b) noexcept
-    {
-      return &a.context_ == &b.context_;
-    }
-
-    friend bool operator!=(const executor_type& a,
-        const executor_type& b) noexcept
-    {
-      return &a.context_ != &b.context_;
-    }
-
-  private:
-    priority_scheduler& context_;
-    int priority_;
-  };
-
-  ~priority_scheduler() noexcept
-  {
-    shutdown();
-    destroy();
-  }
-
-  executor_type get_executor(int pri = 0) noexcept
-  {
-    return executor_type(*const_cast<priority_scheduler*>(this), pri);
-  }
-
-  void run()
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    for (;;)
-    {
-      condition_.wait(lock, [&]{ return stopped_ || !queue_.empty(); });
-      if (stopped_)
-        return;
-      auto p(queue_.top());
-      queue_.pop();
-      lock.unlock();
-      p->execute_(p);
-      lock.lock();
-    }
-  }
-
-  void stop()
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    stopped_ = true;
-    condition_.notify_all();
-  }
-
-private:
-  struct item_base
-  {
-    int priority_;
-    void (*execute_)(std::shared_ptr<item_base>&);
-  };
-
-  template <class Func>
-  struct item : item_base
-  {
-    item(int pri, Func f) : function_(std::move(f))
-    {
-      priority_ = pri;
-      execute_ = [](std::shared_ptr<item_base>& p)
-      {
-        Func tmp(std::move(static_cast<item*>(p.get())->function_));
-        p.reset();
-        tmp();
-      };
-    }
-
-    Func function_;
-  };
-
-  struct item_comp
-  {
-    bool operator()(
-        const std::shared_ptr<item_base>& a,
-        const std::shared_ptr<item_base>& b)
-    {
-      return a->priority_ < b->priority_;
-    }
-  };
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::priority_queue<
-    std::shared_ptr<item_base>,
-    std::vector<std::shared_ptr<item_base>>,
-    item_comp> queue_;
-  bool stopped_ = false;
-};
-
-int main()
-{
-  priority_scheduler sched;
-  auto low = sched.get_executor(0);
-  auto med = sched.get_executor(1);
-  auto high = sched.get_executor(2);
-  dispatch(low, []{ std::cout << "1\n"; });
-  dispatch(low, []{ std::cout << "11\n"; });
-  dispatch(med, []{ std::cout << "2\n"; });
-  dispatch(med, []{ std::cout << "22\n"; });
-  dispatch(high, []{ std::cout << "3\n"; });
-  dispatch(high, []{ std::cout << "33\n"; });
-  dispatch(high, []{ std::cout << "333\n"; });
-  dispatch(sched.get_executor(-1), [&]{ sched.stop(); });
-  sched.run();
-}

data/ext/third_party/asio/asio/src/examples/cpp11/fork/.gitignore

@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-daemon
-process_per_connection

data/ext/third_party/asio/asio/src/examples/cpp11/fork/daemon.cpp

@@ -1,189 +0,0 @@
-//
-// daemon.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/udp.hpp>
-#include <asio/signal_set.hpp>
-#include <array>
-#include <ctime>
-#include <iostream>
-#include <syslog.h>
-#include <unistd.h>
-
-using asio::ip::udp;
-
-class udp_daytime_server
-{
-public:
-  udp_daytime_server(asio::io_context& io_context)
-    : socket_(io_context, {udp::v4(), 13})
-  {
-    receive();
-  }
-
-private:
-  void receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(recv_buffer_), remote_endpoint_,
-        [this](std::error_code ec, std::size_t /*n*/)
-        {
-          if (!ec)
-          {
-            using namespace std; // For time_t, time and ctime;
-            time_t now = time(0);
-            std::string message = ctime(&now);
-
-            std::error_code ignored_ec;
-            socket_.send_to(asio::buffer(message),
-                remote_endpoint_, 0, ignored_ec);
-          }
-
-          receive();
-        });
-  }
-
-  udp::socket socket_;
-  udp::endpoint remote_endpoint_;
-  std::array<char, 1> recv_buffer_;
-};
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    // Initialise the server before becoming a daemon. If the process is
-    // started from a shell, this means any errors will be reported back to the
-    // user.
-    udp_daytime_server server(io_context);
-
-    // Register signal handlers so that the daemon may be shut down. You may
-    // also want to register for other signals, such as SIGHUP to trigger a
-    // re-read of a configuration file.
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait(
-        [&](std::error_code /*ec*/, int /*signo*/)
-        {
-          io_context.stop();
-        });
-
-    // Inform the io_context that we are about to become a daemon. The
-    // io_context cleans up any internal resources, such as threads, that may
-    // interfere with forking.
-    io_context.notify_fork(asio::io_context::fork_prepare);
-
-    // Fork the process and have the parent exit. If the process was started
-    // from a shell, this returns control to the user. Forking a new process is
-    // also a prerequisite for the subsequent call to setsid().
-    if (pid_t pid = fork())
-    {
-      if (pid > 0)
-      {
-        // We're in the parent process and need to exit.
-        //
-        // When the exit() function is used, the program terminates without
-        // invoking local variables' destructors. Only global variables are
-        // destroyed. As the io_context object is a local variable, this means
-        // we do not have to call:
-        //
-        //   io_context.notify_fork(asio::io_context::fork_parent);
-        //
-        // However, this line should be added before each call to exit() if
-        // using a global io_context object. An additional call:
-        //
-        //   io_context.notify_fork(asio::io_context::fork_prepare);
-        //
-        // should also precede the second fork().
-        exit(0);
-      }
-      else
-      {
-        syslog(LOG_ERR | LOG_USER, "First fork failed: %m");
-        return 1;
-      }
-    }
-
-    // Make the process a new session leader. This detaches it from the
-    // terminal.
-    setsid();
-
-    // A process inherits its working directory from its parent. This could be
-    // on a mounted filesystem, which means that the running daemon would
-    // prevent this filesystem from being unmounted. Changing to the root
-    // directory avoids this problem.
-    chdir("/");
-
-    // The file mode creation mask is also inherited from the parent process.
-    // We don't want to restrict the permissions on files created by the
-    // daemon, so the mask is cleared.
-    umask(0);
-
-    // A second fork ensures the process cannot acquire a controlling terminal.
-    if (pid_t pid = fork())
-    {
-      if (pid > 0)
-      {
-        exit(0);
-      }
-      else
-      {
-        syslog(LOG_ERR | LOG_USER, "Second fork failed: %m");
-        return 1;
-      }
-    }
-
-    // Close the standard streams. This decouples the daemon from the terminal
-    // that started it.
-    close(0);
-    close(1);
-    close(2);
-
-    // We don't want the daemon to have any standard input.
-    if (open("/dev/null", O_RDONLY) < 0)
-    {
-      syslog(LOG_ERR | LOG_USER, "Unable to open /dev/null: %m");
-      return 1;
-    }
-
-    // Send standard output to a log file.
-    const char* output = "/tmp/asio.daemon.out";
-    const int flags = O_WRONLY | O_CREAT | O_APPEND;
-    const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
-    if (open(output, flags, mode) < 0)
-    {
-      syslog(LOG_ERR | LOG_USER, "Unable to open output file %s: %m", output);
-      return 1;
-    }
-
-    // Also send standard error to the same log file.
-    if (dup(1) < 0)
-    {
-      syslog(LOG_ERR | LOG_USER, "Unable to dup output descriptor: %m");
-      return 1;
-    }
-
-    // Inform the io_context that we have finished becoming a daemon. The
-    // io_context uses this opportunity to create any internal file descriptors
-    // that need to be private to the new process.
-    io_context.notify_fork(asio::io_context::fork_child);
-
-    // The io_context can now be used normally.
-    syslog(LOG_INFO | LOG_USER, "Daemon started");
-    io_context.run();
-    syslog(LOG_INFO | LOG_USER, "Daemon stopped");
-  }
-  catch (std::exception& e)
-  {
-    syslog(LOG_ERR | LOG_USER, "Exception: %s", e.what());
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-}

data/ext/third_party/asio/asio/src/examples/cpp11/fork/process_per_connection.cpp

@@ -1,162 +0,0 @@
-//
-// process_per_connection.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdlib>
-#include <iostream>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-using asio::ip::tcp;
-
-class server
-{
-public:
-  server(asio::io_context& io_context, unsigned short port)
-    : io_context_(io_context),
-      signal_(io_context, SIGCHLD),
-      acceptor_(io_context, {tcp::v4(), port}),
-      socket_(io_context)
-  {
-    wait_for_signal();
-    accept();
-  }
-
-private:
-  void wait_for_signal()
-  {
-    signal_.async_wait(
-        [this](std::error_code /*ec*/, int /*signo*/)
-        {
-          // Only the parent process should check for this signal. We can
-          // determine whether we are in the parent by checking if the acceptor
-          // is still open.
-          if (acceptor_.is_open())
-          {
-            // Reap completed child processes so that we don't end up with
-            // zombies.
-            int status = 0;
-            while (waitpid(-1, &status, WNOHANG) > 0) {}
-
-            wait_for_signal();
-          }
-        });
-  }
-
-  void accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket new_socket)
-        {
-          if (!ec)
-          {
-            // Take ownership of the newly accepted socket.
-            socket_ = std::move(new_socket);
-
-            // Inform the io_context that we are about to fork. The io_context
-            // cleans up any internal resources, such as threads, that may
-            // interfere with forking.
-            io_context_.notify_fork(asio::io_context::fork_prepare);
-
-            if (fork() == 0)
-            {
-              // Inform the io_context that the fork is finished and that this
-              // is the child process. The io_context uses this opportunity to
-              // create any internal file descriptors that must be private to
-              // the new process.
-              io_context_.notify_fork(asio::io_context::fork_child);
-
-              // The child won't be accepting new connections, so we can close
-              // the acceptor. It remains open in the parent.
-              acceptor_.close();
-
-              // The child process is not interested in processing the SIGCHLD
-              // signal.
-              signal_.cancel();
-
-              read();
-            }
-            else
-            {
-
-              // Inform the io_context that the fork is finished (or failed)
-              // and that this is the parent process. The io_context uses this
-              // opportunity to recreate any internal resources that were
-              // cleaned up during preparation for the fork.
-              io_context_.notify_fork(asio::io_context::fork_parent);
-
-              // The parent process can now close the newly accepted socket. It
-              // remains open in the child.
-              socket_.close();
-
-              accept();
-            }
-          }
-          else
-          {
-            std::cerr << "Accept error: " << ec.message() << std::endl;
-            accept();
-          }
-        });
-  }
-
-  void read()
-  {
-    socket_.async_read_some(asio::buffer(data_),
-        [this](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-            write(length);
-        });
-  }
-
-  void write(std::size_t length)
-  {
-    asio::async_write(socket_, asio::buffer(data_, length),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-            read();
-        });
-  }
-
-  asio::io_context& io_context_;
-  asio::signal_set signal_;
-  tcp::acceptor acceptor_;
-  tcp::socket socket_;
-  std::array<char, 1024> data_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: process_per_connection <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    using namespace std; // For atoi.
-    server s(io_context, atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-}

data/ext/third_party/asio/asio/src/examples/cpp11/futures/.gitignore

@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds

data/ext/third_party/asio/asio/src/examples/cpp11/futures/daytime_client.cpp

@@ -1,94 +0,0 @@
-//
-// daytime_client.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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)
-//
-
-#include <array>
-#include <future>
-#include <iostream>
-#include <thread>
-#include <asio/io_context.hpp>
-#include <asio/ip/udp.hpp>
-#include <asio/use_future.hpp>
-
-using asio::ip::udp;
-
-void get_daytime(asio::io_context& io_context, const char* hostname)
-{
-  try
-  {
-    udp::resolver resolver(io_context);
-
-    std::future<udp::resolver::results_type> endpoints =
-      resolver.async_resolve(
-          udp::v4(), hostname, "daytime",
-          asio::use_future);
-
-    // The async_resolve operation above returns the endpoints as a future
-    // value that is not retrieved ...
-
-    udp::socket socket(io_context, udp::v4());
-
-    std::array<char, 1> send_buf  = {{ 0 }};
-    std::future<std::size_t> send_length =
-      socket.async_send_to(asio::buffer(send_buf),
-          *endpoints.get().begin(), // ... until here. This call may block.
-          asio::use_future);
-
-    // Do other things here while the send completes.
-
-    send_length.get(); // Blocks until the send is complete. Throws any errors.
-
-    std::array<char, 128> recv_buf;
-    udp::endpoint sender_endpoint;
-    std::future<std::size_t> recv_length =
-      socket.async_receive_from(
-          asio::buffer(recv_buf),
-          sender_endpoint,
-          asio::use_future);
-
-    // Do other things here while the receive completes.
-
-    std::cout.write(
-        recv_buf.data(),
-        recv_length.get()); // Blocks until receive is complete.
-  }
-  catch (std::system_error& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: daytime_client <host>" << std::endl;
-      return 1;
-    }
-
-    // We run the io_context off in its own thread so that it operates
-    // completely asynchronously with respect to the rest of the program.
-    asio::io_context io_context;
-    auto work = asio::make_work_guard(io_context);
-    std::thread thread([&io_context](){ io_context.run(); });
-
-    get_daytime(io_context, argv[1]);
-
-    io_context.stop();
-    thread.join();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}