Update for Net-TS Asio (API Change):

fix #769

The following classes are removed:

* handler_type
* async_result
* async_completion
* is_dynamic_buffer
* is_const_buffer_sequence
* is_mutable_buffer_sequence
* handler_alloc

Actions Required:

* Use BOOST_ASIO_HANDLER_TYPE instead of handler_type
* Use BOOST_ASIO_INITFN_RESULT_TYPE instead of async_result
* Use boost::asio::async_completion
* Use boost::asio::is_dynamic_buffer
* Use boost::asio::is_const_buffer_sequence
* Use boost::asio::is_mutable_buffer_sequence
* boost::asio::associated_allocator_t replaces handler_alloc

example/http/client/async-ssl/http_client_async_ssl.cpp

@@ -50,11 +50,11 @@ class session : public std::enable_shared_from_this<session>
     http::response<http::string_body> res_;
 
 public:
-    // Resolver and stream require an io_service
+    // Resolver and stream require an io_context
     explicit
-    session(boost::asio::io_service& ios, ssl::context& ctx)
-        : resolver_(ios)
-        , stream_(ios, ctx)
+    session(boost::asio::io_context& ioc, ssl::context& ctx)
+        : resolver_(ioc)
+        , stream_(ioc, ctx)
     {
     }
 
@@ -73,7 +73,9 @@ public:
         req_.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
 
         // Look up the domain name
-        resolver_.async_resolve({host, port},
+        resolver_.async_resolve(
+            host,
+            port,
             std::bind(
                 &session::on_resolve,
                 shared_from_this(),
@@ -84,7 +86,7 @@ public:
     void
     on_resolve(
         boost::system::error_code ec,
-        tcp::resolver::iterator result)
+        tcp::resolver::results_type results)
     {
         if(ec)
             return fail(ec, "resolve");
@@ -92,7 +94,8 @@ public:
         // Make the connection on the IP address we get from a lookup
         boost::asio::async_connect(
             stream_.next_layer(),
-            result,
+            results.begin(),
+            results.end(),
             std::bind(
                 &session::on_connect,
                 shared_from_this(),
@@ -202,8 +205,8 @@ int main(int argc, char** argv)
     auto const port = argv[2];
     auto const target = argv[3];
 
-    // The io_service is required for all I/O
-    boost::asio::io_service ios;
+    // The io_context is required for all I/O
+    boost::asio::io_context ioc;
 
     // The SSL context is required, and holds certificates
     ssl::context ctx{ssl::context::sslv23_client};
@@ -212,11 +215,11 @@ int main(int argc, char** argv)
     load_root_certificates(ctx);
 
     // Launch the asynchronous operation
-    std::make_shared<session>(ios, ctx)->run(host, port, target);
+    std::make_shared<session>(ioc, ctx)->run(host, port, target);
 
     // Run the I/O service. The call will return when
     // the get operation is complete.
-    ios.run();
+    ioc.run();
 
     return EXIT_SUCCESS;
 }

example/http/client/async/http_client_async.cpp

@@ -46,11 +46,11 @@ class session : public std::enable_shared_from_this<session>
     http::response<http::string_body> res_;
 
 public:
-    // Resolver and socket require an io_service
+    // Resolver and socket require an io_context
     explicit
-    session(boost::asio::io_service& ios)
-        : resolver_(ios)
-        , socket_(ios)
+    session(boost::asio::io_context& ioc)
+        : resolver_(ioc)
+        , socket_(ioc)
     {
     }
 
@@ -69,7 +69,9 @@ public:
         req_.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
 
         // Look up the domain name
-        resolver_.async_resolve({host, port},
+        resolver_.async_resolve(
+            host,
+            port,
             std::bind(
                 &session::on_resolve,
                 shared_from_this(),
@@ -80,13 +82,16 @@ public:
     void
     on_resolve(
         boost::system::error_code ec,
-        tcp::resolver::iterator result)
+        tcp::resolver::results_type results)
     {
         if(ec)
             return fail(ec, "resolve");
 
         // Make the connection on the IP address we get from a lookup
-        boost::asio::async_connect(socket_, result,
+        boost::asio::async_connect(
+            socket_,
+            results.begin(),
+            results.end(),
             std::bind(
                 &session::on_connect,
                 shared_from_this(),
@@ -168,15 +173,15 @@ int main(int argc, char** argv)
     auto const port = argv[2];
     auto const target = argv[3];
 
-    // The io_service is required for all I/O
-    boost::asio::io_service ios;
+    // The io_context is required for all I/O
+    boost::asio::io_context ioc;
 
     // Launch the asynchronous operation
-    std::make_shared<session>(ios)->run(host, port, target);
+    std::make_shared<session>(ioc)->run(host, port, target);
 
     // Run the I/O service. The call will return when
     // the get operation is complete.
-    ios.run();
+    ioc.run();
 
     return EXIT_SUCCESS;
 }

example/http/client/coro-ssl/http_client_coro_ssl.cpp

@@ -46,23 +46,23 @@ do_session(
     std::string const& host,
     std::string const& port,
     std::string const& target,
-    boost::asio::io_service& ios,
+    boost::asio::io_context& ioc,
     ssl::context& ctx,
     boost::asio::yield_context yield)
 {
     boost::system::error_code ec;
 
     // These objects perform our I/O
-    tcp::resolver resolver{ios};
-    ssl::stream<tcp::socket> stream{ios, ctx};
+    tcp::resolver resolver{ioc};
+    ssl::stream<tcp::socket> stream{ioc, ctx};
 
     // Look up the domain name
-    auto const lookup = resolver.async_resolve({host, port}, yield[ec]);
+    auto const results = resolver.async_resolve(host, port, yield[ec]);
     if(ec)
         return fail(ec, "resolve");
 
     // Make the connection on the IP address we get from a lookup
-    boost::asio::async_connect(stream.next_layer(), lookup, yield[ec]);
+    boost::asio::async_connect(stream.next_layer(), results.begin(), results.end(), yield[ec]);
     if(ec)
         return fail(ec, "connect");
 
@@ -126,8 +126,8 @@ int main(int argc, char** argv)
     auto const port = argv[2];
     auto const target = argv[3];
 
-    // The io_service is required for all I/O
-    boost::asio::io_service ios;
+    // The io_context is required for all I/O
+    boost::asio::io_context ioc;
 
     // The SSL context is required, and holds certificates
     ssl::context ctx{ssl::context::sslv23_client};
@@ -136,18 +136,18 @@ int main(int argc, char** argv)
     load_root_certificates(ctx);
 
     // Launch the asynchronous operation
-    boost::asio::spawn(ios, std::bind(
+    boost::asio::spawn(ioc, std::bind(
         &do_session,
         std::string(host),
         std::string(port),
         std::string(target),
-        std::ref(ios),
+        std::ref(ioc),
         std::ref(ctx),
         std::placeholders::_1));
 
     // Run the I/O service. The call will return when
     // the get operation is complete.
-    ios.run();
+    ioc.run();
 
     return EXIT_SUCCESS;
 }

example/http/client/coro/http_client_coro.cpp

@@ -42,22 +42,22 @@ do_session(
     std::string const& host,
     std::string const& port,
     std::string const& target,
-    boost::asio::io_service& ios,
+    boost::asio::io_context& ioc,
     boost::asio::yield_context yield)
 {
     boost::system::error_code ec;
 
     // These objects perform our I/O
-    tcp::resolver resolver{ios};
-    tcp::socket socket{ios};
+    tcp::resolver resolver{ioc};
+    tcp::socket socket{ioc};
 
     // Look up the domain name
-    auto const lookup = resolver.async_resolve({host, port}, yield[ec]);
+    auto const results = resolver.async_resolve(host, port, yield[ec]);
     if(ec)
         return fail(ec, "resolve");
 
     // Make the connection on the IP address we get from a lookup
-    boost::asio::async_connect(socket, lookup, yield[ec]);
+    boost::asio::async_connect(socket, results.begin(), results.end(), yield[ec]);
     if(ec)
         return fail(ec, "connect");
 
@@ -114,21 +114,21 @@ int main(int argc, char** argv)
     auto const port = argv[2];
     auto const target = argv[3];
 
-    // The io_service is required for all I/O
-    boost::asio::io_service ios;
+    // The io_context is required for all I/O
+    boost::asio::io_context ioc;
 
     // Launch the asynchronous operation
-    boost::asio::spawn(ios, std::bind(
+    boost::asio::spawn(ioc, std::bind(
         &do_session,
         std::string(host),
         std::string(port),
         std::string(target),
-        std::ref(ios),
+        std::ref(ioc),
         std::placeholders::_1));
 
     // Run the I/O service. The call will return when
     // the get operation is complete.
-    ios.run();
+    ioc.run();
 
     return EXIT_SUCCESS;
 }

example/http/client/crawl/http_crawl.cpp

@@ -18,10 +18,11 @@
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
 #include <boost/beast/version.hpp>
+#include <boost/asio/bind_executor.hpp>
 #include <boost/asio/connect.hpp>
 #include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/post.hpp>
 #include <boost/asio/strand.hpp>
-#include <boost/optional.hpp>
 #include <atomic>
 #include <chrono>
 #include <cstdlib>
@@ -43,16 +44,17 @@ namespace chrono = std::chrono;         // from <chrono>
 // This structure aggregates statistics on all the sites
 class crawl_report
 {
-    boost::asio::io_service& ios_;
-    boost::asio::io_service::strand strand_;
+    boost::asio::io_context& ioc_;
+    boost::asio::strand<
+        boost::asio::io_context::executor_type> strand_;
     std::atomic<std::size_t> index_;
     std::vector<char const*> const& hosts_;
     std::size_t count_ = 0;
 
 public:
-    crawl_report(boost::asio::io_service& ios)
-        : ios_(ios)
-        , strand_(ios_)
+    crawl_report(boost::asio::io_context& ioc)
+        : ioc_(ioc)
+        , strand_(ioc_.get_executor())
         , index_(0)
         , hosts_(urls_large_data())
     {
@@ -64,18 +66,19 @@ public:
     void
     aggregate(F const& f)
     {
-        ios_.post(strand_.wrap(
-        [&, f]
-        {
-            f(*this);
-            if(count_ % 100 == 0)
+        boost::asio::post(
+            strand_,
+            [&, f]
             {
-                std::cerr <<
-                    "Progress: " << count_ << " of " << hosts_.size() << "\n";
-                //std::cerr << *this;
-            }
-            ++count_;
-        }));
+                f(*this);
+                if(count_ % 100 == 0)
+                {
+                    std::cerr <<
+                        "Progress: " << count_ << " of " << hosts_.size() << "\n";
+                    //std::cerr << *this;
+                }
+                ++count_;
+            });
     }
 
     // Returns the next host to check
@@ -148,7 +151,8 @@ class worker : public std::enable_shared_from_this<worker>
     tcp::resolver resolver_;
     tcp::socket socket_;
     boost::asio::steady_timer timer_;
-    boost::asio::io_service::strand strand_;
+    boost::asio::strand<
+        boost::asio::io_context::executor_type> strand_;
     boost::beast::flat_buffer buffer_; // (Must persist between reads)
     http::request<http::empty_body> req_;
     http::response<http::string_body> res_;
@@ -156,16 +160,16 @@ class worker : public std::enable_shared_from_this<worker>
 public:
     worker(worker&&) = default;
 
-    // Resolver and socket require an io_service
+    // Resolver and socket require an io_context
     worker(
         crawl_report& report,
-        boost::asio::io_service& ios)
+        boost::asio::io_context& ioc)
         : report_(report)
-        , resolver_(ios)
-        , socket_(ios)
-        , timer_(ios,
+        , resolver_(ioc)
+        , socket_(ioc)
+        , timer_(ioc,
             (chrono::steady_clock::time_point::max)())
-        , strand_(ios)
+        , strand_(ioc.get_executor())
     {
         // Set up the common fields of the request
         req_.version(11);
@@ -200,7 +204,7 @@ public:
         }
 
         // Verify that the timer really expired since the deadline may have moved.
-        if(timer_.expires_at() <= chrono::steady_clock::now())
+        if(timer_.expiry() <= chrono::steady_clock::now())
         {
             socket_.shutdown(tcp::socket::shutdown_both, ec);
             socket_.close(ec);
@@ -209,10 +213,12 @@ public:
 
         // Wait on the timer
         timer_.async_wait(
-            strand_.wrap(std::bind(
-                &worker::on_timer,
-                shared_from_this(),
-                std::placeholders::_1)));
+            boost::asio::bind_executor(
+                strand_,
+                std::bind(
+                    &worker::on_timer,
+                    shared_from_this(),
+                    std::placeholders::_1)));
     }
 
     void
@@ -224,8 +230,7 @@ public:
         // nullptr means no more work
         if(! host)
         {
-            boost::system::error_code ec;
-            timer_.cancel(ec);
+            timer_.cancel_one();
             return;
         }
 
@@ -233,23 +238,26 @@ public:
         req_.set(http::field::host, host);
 
         // Set the timer
-        timer_.expires_from_now(chrono::seconds(timeout));
+        timer_.expires_after(chrono::seconds(timeout));
 
         // Set up an HTTP GET request message
         // Look up the domain name
         resolver_.async_resolve(
-            tcp::resolver::query{host, "http"},
-            strand_.wrap(std::bind(
-                &worker::on_resolve,
-                shared_from_this(),
-                std::placeholders::_1,
-                std::placeholders::_2)));
+            host,
+            "http",
+            boost::asio::bind_executor(
+                strand_,
+                std::bind(
+                    &worker::on_resolve,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2)));
     }
 
     void
     on_resolve(
         boost::system::error_code ec,
-        tcp::resolver::iterator result)
+        tcp::resolver::results_type results)
     {
         if(ec)
         {
@@ -262,16 +270,19 @@ public:
         }
 
         // Set the timer
-        timer_.expires_from_now(chrono::seconds(timeout));
+        timer_.expires_after(chrono::seconds(timeout));
 
         // Make the connection on the IP address we get from a lookup
         boost::asio::async_connect(
             socket_,
-            result,
-            strand_.wrap(std::bind(
-                &worker::on_connect,
-                shared_from_this(),
-                std::placeholders::_1)));
+            results.begin(),
+            results.end(),
+            boost::asio::bind_executor(
+                strand_,
+                std::bind(
+                    &worker::on_connect,
+                    shared_from_this(),
+                    std::placeholders::_1)));
     }
 
     void
@@ -288,17 +299,19 @@ public:
         }
 
         // Set the timer
-        timer_.expires_from_now(chrono::seconds(timeout));
+        timer_.expires_after(chrono::seconds(timeout));
 
         // Send the HTTP request to the remote host
         http::async_write(
             socket_,
             req_,
-            strand_.wrap(std::bind(
-                &worker::on_write,
-                shared_from_this(),
-                std::placeholders::_1,
-                std::placeholders::_2)));
+            boost::asio::bind_executor(
+                strand_,
+                std::bind(
+                    &worker::on_write,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2)));
     }
 
     void
@@ -319,18 +332,20 @@ public:
         }
         
         // Set the timer
-        timer_.expires_from_now(chrono::seconds(timeout));
+        timer_.expires_after(chrono::seconds(timeout));
 
         // Receive the HTTP response
         http::async_read(
             socket_,
             buffer_,
             res_,
-            strand_.wrap(std::bind(
-                &worker::on_read,
-                shared_from_this(),
-                std::placeholders::_1,
-                std::placeholders::_2)));
+            boost::asio::bind_executor(
+                strand_,
+                std::bind(
+                    &worker::on_read,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2)));
     }
 
     void
@@ -400,41 +415,41 @@ int main(int argc, char* argv[])
             "    http-crawl 100 1\n";
         return EXIT_FAILURE;
     }
-    auto const threads = std::max<std::size_t>(1, std::atoi(argv[1]));
+    auto const threads = std::max<int>(1, std::atoi(argv[1]));
 
-    // The io_service is required for all I/O
-    boost::asio::io_service ios{1};
+    // The io_context is required for all I/O
+    boost::asio::io_context ioc{1};
 
-    // The work keeps io_service::run from returning
-    boost::optional<boost::asio::io_service::work> work{ios};
+    // The work keeps io_context::run from returning
+    auto work = boost::asio::make_work_guard(ioc);
 
     // The report holds the aggregated statistics
-    crawl_report report{ios};
+    crawl_report report{ioc};
 
     timer t;
 
     // Create and launch the worker threads.
     std::vector<std::thread> workers;
     workers.reserve(threads + 1);
-    for(std::size_t i = 0; i < threads; ++i)
+    for(int i = 0; i < threads; ++i)
         workers.emplace_back(
         [&report]
         {
-            // We use a separate io_service for each worker because
+            // We use a separate io_context for each worker because
             // the asio resolver simulates asynchronous operation using
-            // a dedicated worker thread per io_service, and we want to
+            // a dedicated worker thread per io_context, and we want to
             // do a lot of name resolutions in parallel.
-            boost::asio::io_service ios{1};
-            std::make_shared<worker>(report, ios)->run();
-            ios.run();
+            boost::asio::io_context ioc{1};
+            std::make_shared<worker>(report, ioc)->run();
+            ioc.run();
         });
 
-    // Add another thread to run the main io_service which
+    // Add another thread to run the main io_context which
     // is used to aggregate the statistics
     workers.emplace_back(
-    [&ios]
+    [&ioc]
     {
-        ios.run();
+        ioc.run();
     });
 
     // Now block until all threads exit
@@ -442,11 +457,10 @@ int main(int argc, char* argv[])
     {
         auto& thread = workers[i];
 
-        // If this is the last thread, destroy the
+        // If this is the last thread, reset the
         // work object so that it can return from run.
-        //if(&thread == &workers.back())
         if(i == workers.size() - 1)
-            work = boost::none;
+            work.reset();
 
         // Wait for the thread to exit
         thread.join();

example/http/client/sync-ssl/http_client_sync_ssl.cpp

@@ -47,8 +47,8 @@ int main(int argc, char** argv)
         auto const port = argv[2];
         auto const target = argv[3];
 
-        // The io_service is required for all I/O
-        boost::asio::io_service ios;
+        // The io_context is required for all I/O
+        boost::asio::io_context ioc;
 
         // The SSL context is required, and holds certificates
         ssl::context ctx{ssl::context::sslv23_client};
@@ -57,14 +57,14 @@ int main(int argc, char** argv)
         load_root_certificates(ctx);
 
         // These objects perform our I/O
-        tcp::resolver resolver{ios};
-        ssl::stream<tcp::socket> stream{ios, ctx};
+        tcp::resolver resolver{ioc};
+        ssl::stream<tcp::socket> stream{ioc, ctx};
 
         // Look up the domain name
-        auto const lookup = resolver.resolve({host, port});
+        auto const results = resolver.resolve(host, port);
 
         // Make the connection on the IP address we get from a lookup
-        boost::asio::connect(stream.next_layer(), lookup);
+        boost::asio::connect(stream.next_layer(), results.begin(), results.end());
 
         // Perform the SSL handshake
         stream.handshake(ssl::stream_base::client);

example/http/client/sync/http_client_sync.cpp

@@ -45,18 +45,18 @@ int main(int argc, char** argv)
         auto const port = argv[2];
         auto const target = argv[3];
 
-        // The io_service is required for all I/O
-        boost::asio::io_service ios;
+        // The io_context is required for all I/O
+        boost::asio::io_context ioc;
 
         // These objects perform our I/O
-        tcp::resolver resolver{ios};
-        tcp::socket socket{ios};
+        tcp::resolver resolver{ioc};
+        tcp::socket socket{ioc};
 
         // Look up the domain name
-        auto const lookup = resolver.resolve({host, port});
+        auto const results = resolver.resolve(host, port);
 
         // Make the connection on the IP address we get from a lookup
-        boost::asio::connect(socket, lookup);
+        boost::asio::connect(socket, results.begin(), results.end());
 
         // Set up an HTTP GET request message
         http::request<http::string_body> req{http::verb::get, target, 11};