awaitable examples.

Closes #2104.

example/http/client/CMakeLists.txt

@@ -8,6 +8,7 @@
 #
 
 add_subdirectory (async)
+add_subdirectory (awaitable)
 add_subdirectory (coro)
 add_subdirectory (crawl)
 add_subdirectory (sync)

example/http/client/Jamfile

@@ -11,6 +11,7 @@ build-project async ;
 build-project coro ;
 build-project crawl ;
 build-project sync ;
+build-project awaitable ;
 
 # SSL
 build-project async-ssl ;

example/http/client/awaitable/CMakeLists.txt

@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail 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)
+#
+# Official repository: https://github.com/boostorg/beast
+#
+
+GroupSources(include/boost/beast beast)
+GroupSources(example/http/client/awaitable "/")
+
+add_executable (http-client-awaitable
+    ${BOOST_BEAST_FILES}
+    Jamfile
+        http_client_awaitable.cpp
+    )
+
+target_link_libraries(http-client-awaitable
+    lib-asio
+    lib-beast)
+
+set_property(TARGET http-client-awaitable PROPERTY FOLDER "example-http-client")

example/http/client/awaitable/Jamfile

@@ -0,0 +1,15 @@
+#
+# Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail 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)
+#
+# Official repository: https://github.com/boostorg/beast
+#
+
+exe http-client-awaitable :
+    http_client_awaitable.cpp
+    :
+    <variant>coverage:<build>no
+    <variant>ubasan:<build>no
+    ;

example/http/client/awaitable/http_client_awaitable.cpp

@@ -0,0 +1,158 @@
+//
+// Copyright (c) 2022 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
+//
+// 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)
+//
+// Official repository: https://github.com/boostorg/beast
+//
+
+//------------------------------------------------------------------------------
+//
+// Example: HTTP client, coroutine
+//
+//------------------------------------------------------------------------------
+
+
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/asio/awaitable.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/use_awaitable.hpp>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <string>
+
+namespace beast = boost::beast;         // from <boost/beast.hpp>
+namespace http = beast::http;           // from <boost/beast/http.hpp>
+namespace net = boost::asio;            // from <boost/asio.hpp>
+using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>
+
+//------------------------------------------------------------------------------
+
+// Report a failure
+void
+fail(beast::error_code ec, char const* what)
+{
+    std::cerr << what << ": " << ec.message() << "\n";
+}
+
+// Performs an HTTP GET and prints the response
+net::awaitable<void>
+do_session(
+    std::string host,
+    std::string port,
+    std::string target,
+    int version)
+{
+    // These objects perform our I/O
+
+    auto resolver = net::use_awaitable.as_default_on(tcp::resolver(co_await net::this_coro::executor));
+    auto stream = net::use_awaitable.as_default_on(beast::tcp_stream(co_await net::this_coro::executor));
+
+    // Look up the domain name
+    auto const results = co_await resolver.async_resolve(host, port);
+
+    // Set the timeout.
+    stream.expires_after(std::chrono::seconds(30));
+
+    // Make the connection on the IP address we get from a lookup
+    co_await stream.async_connect(results);
+
+    // Set up an HTTP GET request message
+    http::request<http::string_body> req{http::verb::get, target, version};
+    req.set(http::field::host, host);
+    req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
+
+    // Set the timeout.
+    stream.expires_after(std::chrono::seconds(30));
+
+    // Send the HTTP request to the remote host
+    co_await http::async_write(stream, req);
+
+    // This buffer is used for reading and must be persisted
+    beast::flat_buffer b;
+
+    // Declare a container to hold the response
+    http::response<http::dynamic_body> res;
+
+    // Receive the HTTP response
+    co_await http::async_read(stream, b, res);
+
+    // Write the message to standard out
+    std::cout << res << std::endl;
+
+    // Gracefully close the socket
+    beast::error_code ec;
+    stream.socket().shutdown(tcp::socket::shutdown_both, ec);
+
+    // not_connected happens sometimes
+    // so don't bother reporting it.
+    //
+    if(ec && ec != beast::errc::not_connected)
+        throw boost::system::system_error(ec, "shutdown");
+
+    // If we get here then the connection is closed gracefully
+}
+
+//------------------------------------------------------------------------------
+
+int main(int argc, char** argv)
+{
+    // Check command line arguments.
+    if(argc != 4 && argc != 5)
+    {
+        std::cerr <<
+            "Usage: http-client-awaitable <host> <port> <target> [<HTTP version: 1.0 or 1.1(default)>]\n" <<
+            "Example:\n" <<
+            "    http-client-awaitable www.example.com 80 /\n" <<
+            "    http-client-awaitable www.example.com 80 / 1.0\n";
+        return EXIT_FAILURE;
+    }
+    auto const host = argv[1];
+    auto const port = argv[2];
+    auto const target = argv[3];
+    int version = argc == 5 && !std::strcmp("1.0", argv[4]) ? 10 : 11;
+
+    // The io_context is required for all I/O
+    net::io_context ioc;
+
+    // Launch the asynchronous operation
+    net::co_spawn(ioc,
+                  do_session(host, port, target, version),
+                  [](std::exception_ptr e)
+                  {
+                    if (e)
+                    try
+                    {
+                        std::rethrow_exception(e);
+                    }
+                    catch(std::exception & e)
+                    {
+                        std::cerr << "Error: " << e.what() << "\n";
+                    }
+                  });
+
+    // Run the I/O service. The call will return when
+    // the get operation is complete.
+    ioc.run();
+
+    return EXIT_SUCCESS;
+}
+
+#else
+
+int main(int, char * [])
+{
+    std::printf("awaitables require C++20\n");
+    return 1;
+}
+
+#endif