diff --git a/doc/qbk/02_examples/_examples.qbk b/doc/qbk/02_examples/_examples.qbk index 0fefe3d9..81b26ca5 100644 --- a/doc/qbk/02_examples/_examples.qbk +++ b/doc/qbk/02_examples/_examples.qbk @@ -40,6 +40,10 @@ used to evaluate robustness. All asynchronous clients support timeouts. [HTTP, coroutine] [[path_link example/http/client/coro/http_client_coro.cpp http_client_coro.cpp]] [[path_link example/http/client/coro-ssl/http_client_coro_ssl.cpp http_client_coro_ssl.cpp]] +][ + [WebSocket, C++20 coroutine] + [[path_link example/http/client/awaitable/http_client_awaitable.cpp http_client_awaitable.cpp]] + [] ][ [HTTP crawl (asynchronous)] [[path_link example/http/client/crawl/http_crawl.cpp http_crawl.cpp]] @@ -72,6 +76,10 @@ before disconnecting. All asynchronous clients support timeouts. [WebSocket, coroutine] [[path_link example/websocket/client/coro/websocket_client_coro.cpp websocket_client_coro.cpp]] [[path_link example/websocket/client/coro-ssl/websocket_client_coro_ssl.cpp websocket_client_coro_ssl.cpp]] +][ + [WebSocket, C++20 coroutine] + [[path_link example/websocket/client/awaitable/websocket_client_awaitable.cpp websocket_client_awaitable.cpp]] + [] ]] [endsect] @@ -101,6 +109,9 @@ command line. All asynchronous servers support timeouts. [HTTP, stackless coroutine] [[path_link example/http/server/stackless/http_server_stackless.cpp http_server_stackless.cpp]] [[path_link example/http/server/stackless-ssl/http_server_stackless_ssl.cpp http_server_stackless_ssl.cpp]] +][ + [HTTP, C++ 20 coroutine] + [[path_link example/http/server/awaitable/http_server_awaitable.cpp http_server_awaitable.cpp]] ][ [HTTP, fast (optimized for speed)] [[path_link example/http/server/fast/http_server_fast.cpp http_server_fast.cpp]] @@ -137,6 +148,10 @@ support timeouts. [WebSocket, stackless coroutine] [[path_link example/websocket/server/stackless/websocket_server_stackless.cpp websocket_server_stackless.cpp]] [[path_link example/websocket/server/stackless-ssl/websocket_server_stackless_ssl.cpp websocket_server_stackless_ssl.cpp]] +][ + [HTTP, C++ 20 coroutine] + [[path_link example/websocket/server/awaitable/websocket_server_awaitable.cpp websocket_server_awaitable.cpp]] + [] ][ [WebSocket, fast (suited for benchmarks)] [[path_link example/websocket/server/fast/websocket_server_fast.cpp websocket_server_fast.cpp]] @@ -178,6 +193,19 @@ and illustrate the implementation of advanced features. ]] [[path_link example/advanced/server-flex/advanced_server_flex.cpp advanced_server_flex.cpp]] ][ + [Advanced, flex (plain + SSL) with awaitable] + [[itemized_list + [Timeouts] + [Multi-threaded] + [HTTP pipelining] + [Parser-oriented HTTP reading] + [Dual protocols: HTTP and WebSocket] + [Flexible ports: plain and SSL on the same port] + [Clean exit via SIGINT (CTRL+C) or SIGTERM (kill)] + [Usage of cancellation_signals] + ]] + [[path_link example/advanced/server-flex-awaitable/advanced_server_flex_awaitable.cpp advanced_server_flex_awaitable.cpp]] + ][ [Chat Server, multi-threaded] [[itemized_list [Multi-threaded] diff --git a/example/advanced/CMakeLists.txt b/example/advanced/CMakeLists.txt index af83e043..902020bb 100644 --- a/example/advanced/CMakeLists.txt +++ b/example/advanced/CMakeLists.txt @@ -9,3 +9,4 @@ add_subdirectory (server) add_subdirectory (server-flex) +add_subdirectory (server-flex-awaitable) diff --git a/example/advanced/Jamfile b/example/advanced/Jamfile index d1053a90..644246c1 100644 --- a/example/advanced/Jamfile +++ b/example/advanced/Jamfile @@ -11,3 +11,6 @@ build-project server ; # SSL build-project server-flex ; + +# C++20 +build-project server-flex-awaitable ; diff --git a/example/advanced/server-flex-awaitable/CMakeLists.txt b/example/advanced/server-flex-awaitable/CMakeLists.txt new file mode 100644 index 00000000..0ebee130 --- /dev/null +++ b/example/advanced/server-flex-awaitable/CMakeLists.txt @@ -0,0 +1,31 @@ +# +# 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 +# + +if (OPENSSL_FOUND) + GroupSources(include/boost/beast beast) + GroupSources(example/common common) + GroupSources(example/advanced/server-flex-awaitable "/") + + add_executable (advanced-server-flex-awaitable + ${BOOST_BEAST_FILES} + ${PROJECT_SOURCE_DIR}/example/common/server_certificate.hpp + Jamfile + advanced_server_flex_awaitable.cpp + ) + + set_property(TARGET advanced-server-flex-awaitable PROPERTY FOLDER "example-advanced-server") + + target_link_libraries (advanced-server-flex-awaitable + OpenSSL::SSL OpenSSL::Crypto + lib-asio + lib-asio-ssl + lib-beast + ) + +endif() diff --git a/example/advanced/server-flex-awaitable/Jamfile b/example/advanced/server-flex-awaitable/Jamfile new file mode 100644 index 00000000..3e211011 --- /dev/null +++ b/example/advanced/server-flex-awaitable/Jamfile @@ -0,0 +1,22 @@ +# +# 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 +# + +import ac ; + +project + : requirements + [ ac.check-library /boost/beast//lib-asio-ssl : /boost/beast//lib-asio-ssl/static : no ] + ; + +exe advanced-server-flex-awaitable : + advanced_server_flex_awaitable.cpp + : + coverage:no + ubasan:no + ; diff --git a/example/advanced/server-flex-awaitable/advanced_server_flex_awaitable.cpp b/example/advanced/server-flex-awaitable/advanced_server_flex_awaitable.cpp new file mode 100644 index 00000000..fb3b8a54 --- /dev/null +++ b/example/advanced/server-flex-awaitable/advanced_server_flex_awaitable.cpp @@ -0,0 +1,1188 @@ +// +// 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: Advanced server, flex (plain + SSL) +// +//------------------------------------------------------------------------------ + +#include "example/common/server_certificate.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_ASIO_HAS_CO_AWAIT) + + +namespace beast = boost::beast; // from +namespace http = beast::http; // from +namespace websocket = beast::websocket; // from +namespace net = boost::asio; // from +namespace ssl = boost::asio::ssl; // from +using tcp = boost::asio::ip::tcp; // from + +using executor_type = net::io_context::executor_type; +using executor_with_default = net::as_tuple_t>::executor_with_default; + + + +// Return a reasonable mime type based on the extension of a file. +beast::string_view +mime_type(beast::string_view path) +{ + using beast::iequals; + auto const ext = [&path] + { + auto const pos = path.rfind("."); + if(pos == beast::string_view::npos) + return beast::string_view{}; + return path.substr(pos); + }(); + if(iequals(ext, ".htm")) return "text/html"; + if(iequals(ext, ".html")) return "text/html"; + if(iequals(ext, ".php")) return "text/html"; + if(iequals(ext, ".css")) return "text/css"; + if(iequals(ext, ".txt")) return "text/plain"; + if(iequals(ext, ".js")) return "application/javascript"; + if(iequals(ext, ".json")) return "application/json"; + if(iequals(ext, ".xml")) return "application/xml"; + if(iequals(ext, ".swf")) return "application/x-shockwave-flash"; + if(iequals(ext, ".flv")) return "video/x-flv"; + if(iequals(ext, ".png")) return "image/png"; + if(iequals(ext, ".jpe")) return "image/jpeg"; + if(iequals(ext, ".jpeg")) return "image/jpeg"; + if(iequals(ext, ".jpg")) return "image/jpeg"; + if(iequals(ext, ".gif")) return "image/gif"; + if(iequals(ext, ".bmp")) return "image/bmp"; + if(iequals(ext, ".ico")) return "image/vnd.microsoft.icon"; + if(iequals(ext, ".tiff")) return "image/tiff"; + if(iequals(ext, ".tif")) return "image/tiff"; + if(iequals(ext, ".svg")) return "image/svg+xml"; + if(iequals(ext, ".svgz")) return "image/svg+xml"; + return "application/text"; +} + +// Append an HTTP rel-path to a local filesystem path. +// The returned path is normalized for the platform. +std::string +path_cat( + beast::string_view base, + beast::string_view path) +{ + if(base.empty()) + return std::string(path); + std::string result(base); +#ifdef BOOST_MSVC + char constexpr path_separator = '\\'; + if(result.back() == path_separator) + result.resize(result.size() - 1); + result.append(path.data(), path.size()); + for(auto& c : result) + if(c == '/') + c = path_separator; +#else + char constexpr path_separator = '/'; + if(result.back() == path_separator) + result.resize(result.size() - 1); + result.append(path.data(), path.size()); +#endif + return result; +} + +// Return a response for the given request. +// +// The concrete type of the response message (which depends on the +// request), is type-erased in message_generator. +template +http::message_generator +handle_request( + beast::string_view doc_root, + http::request>&& req) +{ + // Returns a bad request response + auto const bad_request = + [&req](beast::string_view why) + { + http::response res{http::status::bad_request, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, "text/html"); + res.keep_alive(req.keep_alive()); + res.body() = std::string(why); + res.prepare_payload(); + return res; + }; + + // Returns a not found response + auto const not_found = + [&req](beast::string_view target) + { + http::response res{http::status::not_found, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, "text/html"); + res.keep_alive(req.keep_alive()); + res.body() = "The resource '" + std::string(target) + "' was not found."; + res.prepare_payload(); + return res; + }; + + // Returns a server error response + auto const server_error = + [&req](beast::string_view what) + { + http::response res{http::status::internal_server_error, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, "text/html"); + res.keep_alive(req.keep_alive()); + res.body() = "An error occurred: '" + std::string(what) + "'"; + res.prepare_payload(); + return res; + }; + + // Make sure we can handle the method + if( req.method() != http::verb::get && + req.method() != http::verb::head) + return bad_request("Unknown HTTP-method"); + + // Request path must be absolute and not contain "..". + if( req.target().empty() || + req.target()[0] != '/' || + req.target().find("..") != beast::string_view::npos) + return bad_request("Illegal request-target"); + + // Build the path to the requested file + std::string path = path_cat(doc_root, req.target()); + if(req.target().back() == '/') + path.append("index.html"); + + // Attempt to open the file + beast::error_code ec; + http::file_body::value_type body; + body.open(path.c_str(), beast::file_mode::scan, ec); + + // Handle the case where the file doesn't exist + if(ec == beast::errc::no_such_file_or_directory) + return not_found(req.target()); + + // Handle an unknown error + if(ec) + return server_error(ec.message()); + + // Cache the size since we need it after the move + auto const size = body.size(); + + // Respond to HEAD request + if(req.method() == http::verb::head) + { + http::response res{http::status::ok, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, mime_type(path)); + res.content_length(size); + res.keep_alive(req.keep_alive()); + return res; + } + + // Respond to GET request + http::response res{ + std::piecewise_construct, + std::make_tuple(std::move(body)), + std::make_tuple(http::status::ok, req.version())}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, mime_type(path)); + res.content_length(size); + res.keep_alive(req.keep_alive()); + return res; +} + +//------------------------------------------------------------------------------ + +// Report a failure +void +fail(beast::error_code ec, char const* what) +{ + // ssl::error::stream_truncated, also known as an SSL "short read", + // indicates the peer closed the connection without performing the + // required closing handshake (for example, Google does this to + // improve performance). Generally this can be a security issue, + // but if your communication protocol is self-terminated (as + // it is with both HTTP and WebSocket) then you may simply + // ignore the lack of close_notify. + // + // https://github.com/boostorg/beast/issues/38 + // + // https://security.stackexchange.com/questions/91435/how-to-handle-a-malicious-ssl-tls-shutdown + // + // When a short read would cut off the end of an HTTP message, + // Beast returns the error beast::http::error::partial_message. + // Therefore, if we see a short read here, it has occurred + // after the message has been completed, so it is safe to ignore it. + + if(ec == net::ssl::error::stream_truncated) + return; + + std::cerr << what << ": " << ec.message() << "\n"; +} + +// A simple helper for cancellation_slot +struct cancellation_signals +{ + std::list sigs; + std::mutex mtx; + void emit(net::cancellation_type ct = net::cancellation_type::all) + { + std::lock_guard _(mtx); + + for (auto & sig : sigs) + sig.emit(ct); + } + + net::cancellation_slot slot() + { + std::lock_guard _(mtx); + + auto itr = std::find_if(sigs.begin(), sigs.end(), + [](net::cancellation_signal & sig) + { + return !sig.slot().has_handler(); + }); + + if (itr != sigs.end()) + return itr->slot(); + else + return sigs.emplace_back().slot(); + } +}; + +//------------------------------------------------------------------------------ + +// Echoes back all received WebSocket messages. +// This uses the Curiously Recurring Template Pattern so that +// the same code works with both SSL streams and regular sockets. +template +class websocket_session +{ + // Access the derived class, this is part of + // the Curiously Recurring Template Pattern idiom. + Derived& + derived() + { + return static_cast(*this); + } + + beast::flat_buffer buffer_; + + // Start the asynchronous operation + template + void + do_accept(http::request> req) + { + // Set suggested timeout settings for the websocket + derived().ws().set_option( + websocket::stream_base::timeout::suggested( + beast::role_type::server)); + + // Set a decorator to change the Server of the handshake + derived().ws().set_option( + websocket::stream_base::decorator( + [](websocket::response_type& res) + { + res.set(http::field::server, + std::string(BOOST_BEAST_VERSION_STRING) + + " advanced-server-flex"); + })); + + // Accept the websocket handshake + derived().ws().async_accept( + req, + beast::bind_front_handler( + &websocket_session::on_accept, + derived().shared_from_this())); + } + +private: + void + on_accept(beast::error_code ec) + { + if(ec) + return fail(ec, "accept"); + + // Read a message + do_read(); + } + + void + do_read() + { + // Read a message into our buffer + derived().ws().async_read( + buffer_, + beast::bind_front_handler( + &websocket_session::on_read, + derived().shared_from_this())); + } + + void + on_read( + beast::error_code ec, + std::size_t bytes_transferred) + { + boost::ignore_unused(bytes_transferred); + + // This indicates that the websocket_session was closed + if(ec == websocket::error::closed) + return; + + if(ec) + return fail(ec, "read"); + + // Echo the message + derived().ws().text(derived().ws().got_text()); + derived().ws().async_write( + buffer_.data(), + beast::bind_front_handler( + &websocket_session::on_write, + derived().shared_from_this())); + } + + void + on_write( + beast::error_code ec, + std::size_t bytes_transferred) + { + boost::ignore_unused(bytes_transferred); + + if(ec) + return fail(ec, "write"); + + // Clear the buffer + buffer_.consume(buffer_.size()); + + // Do another read + do_read(); + } + +public: + // Start the asynchronous operation + template + void + run(http::request> req) + { + // Accept the WebSocket upgrade request + do_accept(std::move(req)); + } +}; + +//------------------------------------------------------------------------------ + +// Handles a plain WebSocket connection +class plain_websocket_session + : public websocket_session + , public std::enable_shared_from_this +{ + websocket::stream ws_; + +public: + // Create the session + explicit + plain_websocket_session( + beast::tcp_stream&& stream) + : ws_(std::move(stream)) + { + } + + // Called by the base class + websocket::stream& + ws() + { + return ws_; + } +}; + +//------------------------------------------------------------------------------ + +// Handles an SSL WebSocket connection +class ssl_websocket_session + : public websocket_session + , public std::enable_shared_from_this +{ + websocket::stream< + beast::ssl_stream> ws_; + +public: + // Create the ssl_websocket_session + explicit + ssl_websocket_session( + beast::ssl_stream&& stream) + : ws_(std::move(stream)) + { + } + + // Called by the base class + websocket::stream< + beast::ssl_stream>& + ws() + { + return ws_; + } +}; + +//------------------------------------------------------------------------------ + +template +void +make_websocket_session( + beast::tcp_stream stream, + http::request> req) +{ + std::make_shared( + std::move(stream))->run(std::move(req)); +} + +template +void +make_websocket_session( + beast::ssl_stream stream, + http::request> req) +{ + std::make_shared( + std::move(stream))->run(std::move(req)); +} + +//------------------------------------------------------------------------------ + +// Handles an HTTP server connection. +// This uses the Curiously Recurring Template Pattern so that +// the same code works with both SSL streams and regular sockets. +template +class http_session +{ + std::shared_ptr doc_root_; + + // Access the derived class, this is part of + // the Curiously Recurring Template Pattern idiom. + Derived& + derived() + { + return static_cast(*this); + } + + static constexpr std::size_t queue_limit = 8; // max responses + std::vector response_queue_; + + // The parser is stored in an optional container so we can + // construct it from scratch it at the beginning of each new message. + boost::optional> parser_; + +protected: + beast::flat_buffer buffer_; + +public: + // Construct the session + http_session( + beast::flat_buffer buffer, + std::shared_ptr const& doc_root) + : doc_root_(doc_root) + , buffer_(std::move(buffer)) + { + } + + void + do_read() + { + // Construct a new parser for each message + parser_.emplace(); + + // Apply a reasonable limit to the allowed size + // of the body in bytes to prevent abuse. + parser_->body_limit(10000); + + // Set the timeout. + beast::get_lowest_layer( + derived().stream()).expires_after(std::chrono::seconds(30)); + + // Read a request using the parser-oriented interface + http::async_read( + derived().stream(), + buffer_, + *parser_, + beast::bind_front_handler( + &http_session::on_read, + derived().shared_from_this())); + } + + void + on_read(beast::error_code ec, std::size_t bytes_transferred) + { + boost::ignore_unused(bytes_transferred); + + // This means they closed the connection + if(ec == http::error::end_of_stream) + return derived().do_eof(); + + if(ec) + return fail(ec, "read"); + + // See if it is a WebSocket Upgrade + if(websocket::is_upgrade(parser_->get())) + { + // Disable the timeout. + // The websocket::stream uses its own timeout settings. + beast::get_lowest_layer(derived().stream()).expires_never(); + + // Create a websocket session, transferring ownership + // of both the socket and the HTTP request. + return make_websocket_session( + derived().release_stream(), + parser_->release()); + } + + // Send the response + queue_write(handle_request(*doc_root_, parser_->release())); + + // If we aren't at the queue limit, try to pipeline another request + if (response_queue_.size() < queue_limit) + do_read(); + } + + void + queue_write(http::message_generator response) + { + // Allocate and store the work + response_queue_.push_back(std::move(response)); + + // If there was no previous work, start the write + // loop + if (response_queue_.size() == 1) + do_write(); + } + + // Called to start/continue the write-loop. Should not be called when + // write_loop is already active. + // + // Returns `true` if the caller may initiate a new read + bool + do_write() + { + bool const was_full = + response_queue_.size() == queue_limit; + + if(! response_queue_.empty()) + { + http::message_generator msg = + std::move(response_queue_.front()); + response_queue_.erase(response_queue_.begin()); + + bool keep_alive = msg.keep_alive(); + + beast::async_write( + derived().stream(), + std::move(msg), + beast::bind_front_handler( + &http_session::on_write, + derived().shared_from_this(), + keep_alive)); + } + + return was_full; + } + + void + on_write( + bool keep_alive, + beast::error_code ec, + std::size_t bytes_transferred) + { + boost::ignore_unused(bytes_transferred); + + if(ec) + return fail(ec, "write"); + + if(! keep_alive) + { + // This means we should close the connection, usually because + // the response indicated the "Connection: close" semantic. + return derived().do_eof(); + } + + // Inform the queue that a write completed + if(do_write()) + { + // Read another request + do_read(); + } + } +}; + +//------------------------------------------------------------------------------ + +// Handles a plain HTTP connection +class plain_http_session + : public http_session + , public std::enable_shared_from_this +{ + beast::tcp_stream stream_; + +public: + // Create the session + plain_http_session( + beast::tcp_stream&& stream, + beast::flat_buffer&& buffer, + std::shared_ptr const& doc_root) + : http_session( + std::move(buffer), + doc_root) + , stream_(std::move(stream)) + { + } + + // Start the session + void + run() + { + this->do_read(); + } + + // Called by the base class + beast::tcp_stream& + stream() + { + return stream_; + } + + // Called by the base class + beast::tcp_stream + release_stream() + { + return std::move(stream_); + } + + // Called by the base class + void + do_eof() + { + // Send a TCP shutdown + beast::error_code ec; + stream_.socket().shutdown(tcp::socket::shutdown_send, ec); + + // At this point the connection is closed gracefully + } +}; + +//------------------------------------------------------------------------------ + +// Handles an SSL HTTP connection +class ssl_http_session + : public http_session + , public std::enable_shared_from_this +{ + beast::ssl_stream stream_; + +public: + // Create the http_session + ssl_http_session( + beast::tcp_stream&& stream, + ssl::context& ctx, + beast::flat_buffer&& buffer, + std::shared_ptr const& doc_root) + : http_session( + std::move(buffer), + doc_root) + , stream_(std::move(stream), ctx) + { + } + + // Start the session + void + run() + { + // Set the timeout. + beast::get_lowest_layer(stream_).expires_after(std::chrono::seconds(30)); + + // Perform the SSL handshake + // Note, this is the buffered version of the handshake. + stream_.async_handshake( + ssl::stream_base::server, + buffer_.data(), + beast::bind_front_handler( + &ssl_http_session::on_handshake, + shared_from_this())); + } + + // Called by the base class + beast::ssl_stream& + stream() + { + return stream_; + } + + // Called by the base class + beast::ssl_stream + release_stream() + { + return std::move(stream_); + } + + // Called by the base class + void + do_eof() + { + // Set the timeout. + beast::get_lowest_layer(stream_).expires_after(std::chrono::seconds(30)); + + // Perform the SSL shutdown + stream_.async_shutdown( + beast::bind_front_handler( + &ssl_http_session::on_shutdown, + shared_from_this())); + } + +private: + void + on_handshake( + beast::error_code ec, + std::size_t bytes_used) + { + if(ec) + return fail(ec, "handshake"); + + // Consume the portion of the buffer used by the handshake + buffer_.consume(bytes_used); + + do_read(); + } + + void + on_shutdown(beast::error_code ec) + { + if(ec) + return fail(ec, "shutdown"); + + // At this point the connection is closed gracefully + } +}; + +//------------------------------------------------------------------------------ + +// Detects SSL handshakes +class detect_session : public std::enable_shared_from_this +{ + beast::tcp_stream stream_; + ssl::context& ctx_; + std::shared_ptr doc_root_; + beast::flat_buffer buffer_; + +public: + explicit + detect_session( + tcp::socket&& socket, + ssl::context& ctx, + std::shared_ptr const& doc_root) + : stream_(std::move(socket)) + , ctx_(ctx) + , doc_root_(doc_root) + { + } + + // Launch the detector + void + run() + { + // We need to be executing within a strand to perform async operations + // on the I/O objects in this session. Although not strictly necessary + // for single-threaded contexts, this example code is written to be + // thread-safe by default. + net::dispatch( + stream_.get_executor(), + beast::bind_front_handler( + &detect_session::on_run, + this->shared_from_this())); + } + + void + on_run() + { + // Set the timeout. + stream_.expires_after(std::chrono::seconds(30)); + + beast::async_detect_ssl( + stream_, + buffer_, + beast::bind_front_handler( + &detect_session::on_detect, + this->shared_from_this())); + } + + void + on_detect(beast::error_code ec, bool result) + { + if(ec) + return fail(ec, "detect"); + + if(result) + { + // Launch SSL session + std::make_shared( + std::move(stream_), + ctx_, + std::move(buffer_), + doc_root_)->run(); + return; + } + + // Launch plain session + std::make_shared( + std::move(stream_), + std::move(buffer_), + doc_root_)->run(); + } +}; + +template +net::awaitable do_eof(Stream & stream) +{ + beast::error_code ec; + stream.socket().shutdown(tcp::socket::shutdown_send, ec); + co_return ; +} + +template +BOOST_ASIO_NODISCARD net::awaitable +do_eof(beast::ssl_stream & stream) +{ + co_await stream.async_shutdown(); +} + + +template +BOOST_ASIO_NODISCARD net::awaitable +run_websocket_session(Stream & stream, + beast::flat_buffer & buffer, + http::request> req, + const std::shared_ptr & doc_root) +{ + beast::websocket::stream ws{stream}; + + // Set suggested timeout settings for the websocket + ws.set_option( + websocket::stream_base::timeout::suggested( + beast::role_type::server)); + + // Set a decorator to change the Server of the handshake + ws.set_option( + websocket::stream_base::decorator( + [](websocket::response_type& res) + { + res.set(http::field::server, + std::string(BOOST_BEAST_VERSION_STRING) + + " advanced-server-flex"); + })); + + // Accept the websocket handshake + auto [ec] = co_await ws.async_accept(req); + if (ec) + co_return fail(ec, "accept"); + + while (true) + { + + + // Read a message + std::size_t bytes_transferred = 0u; + std::tie(ec, bytes_transferred) = co_await ws.async_read(buffer); + + // This indicates that the websocket_session was closed + if (ec == websocket::error::closed) + co_return; + if (ec) + co_return fail(ec, "read"); + + ws.text(ws.got_text()); + std::tie(ec, bytes_transferred) = co_await ws.async_write(buffer.data()); + + if (ec) + co_return fail(ec, "write"); + + // Clear the buffer + buffer.consume(buffer.size()); + } +} + + +template +BOOST_ASIO_NODISCARD net::awaitable +run_session(Stream & stream, beast::flat_buffer & buffer, const std::shared_ptr & doc_root) +{ + http::request_parser parser; + // Apply a reasonable limit to the allowed size + // of the body in bytes to prevent abuse. + parser.body_limit(10000); + + auto [ec, bytes_transferred] = co_await http::async_read(stream, buffer, parser); + + if(ec == http::error::end_of_stream) + co_await do_eof(stream); + + if(ec) + co_return fail(ec, "read"); + + // this can be + // while ((co_await net::this_coro::cancellation_state).cancelled() == net::cancellation_type::none) + // on most compilers + for (auto cs = co_await net::this_coro::cancellation_state; + cs.cancelled() == net::cancellation_type::none; + cs = co_await net::this_coro::cancellation_state) + { + if(websocket::is_upgrade(parser.get())) + { + // Disable the timeout. + // The websocket::stream uses its own timeout settings. + beast::get_lowest_layer(stream).expires_never(); + + co_await run_websocket_session(stream, buffer, parser.release(), doc_root); + co_return ; + } + + // we follow a different strategy then the other example: instead of queue responses, + // we always to one read & write in parallel. + + auto res = handle_request(*doc_root, parser.release()); + if (!res.keep_alive()) + { + http::message_generator msg{std::move(res)}; + auto [ec, sz] = co_await beast::async_write(stream, std::move(msg)); + if (ec) + fail(ec, "write"); + co_return ; + } + + http::message_generator msg{std::move(res)}; + + auto [_, ec_r, sz_r, ec_w, sz_w ] = + co_await net::experimental::make_parallel_group( + http::async_read(stream, buffer, parser, net::deferred), + beast::async_write(stream, std::move(msg), net::deferred)) + .async_wait(net::experimental::wait_for_all(), + net::as_tuple(net::use_awaitable_t{})); + + if (ec_r) + co_return fail(ec_r, "read"); + + if (ec_w) + co_return fail(ec_w, "write"); + + } + + +} + +BOOST_ASIO_NODISCARD net::awaitable +detect_session(typename beast::tcp_stream::rebind_executor::other stream, + net::ssl::context & ctx, + std::shared_ptr doc_root) +{ + beast::flat_buffer buffer; + + // Set the timeout. + stream.expires_after(std::chrono::seconds(30)); + // on_run + auto [ec, result] = co_await beast::async_detect_ssl(stream, buffer); + // on_detect + if (ec) + co_return fail(ec, "detect"); + + if(result) + { + using stream_type = typename beast::tcp_stream::rebind_executor::other; + beast::ssl_stream ssl_stream{std::move(stream), ctx}; + auto [ec, bytes_used] = co_await ssl_stream.async_handshake(net::ssl::stream_base::server, buffer.data()); + + if(ec) + co_return fail(ec, "handshake"); + + buffer.consume(bytes_used); + co_await run_session(ssl_stream, buffer, doc_root); + } + else + co_await run_session(stream, buffer, doc_root); + + +} + +bool init_listener(typename tcp::acceptor::rebind_executor::other & acceptor, + const tcp::endpoint &endpoint) +{ + beast::error_code ec; + // Open the acceptor + acceptor.open(endpoint.protocol(), ec); + if(ec) + { + fail(ec, "open"); + return false; + } + + // Allow address reuse + acceptor.set_option(net::socket_base::reuse_address(true), ec); + if(ec) + { + fail(ec, "set_option"); + return false; + } + + // Bind to the server address + acceptor.bind(endpoint, ec); + if(ec) + { + fail(ec, "bind"); + return false; + } + + // Start listening for connections + acceptor.listen( + net::socket_base::max_listen_connections, ec); + if(ec) + { + fail(ec, "listen"); + return false; + } + return true; + +} + +// Accepts incoming connections and launches the sessions. +BOOST_ASIO_NODISCARD net::awaitable + listen(ssl::context& ctx, + tcp::endpoint endpoint, + std::shared_ptr doc_root, + cancellation_signals & sig) +{ + typename tcp::acceptor::rebind_executor::other acceptor{co_await net::this_coro::executor}; + if (!init_listener(acceptor, endpoint)) + co_return; + + while ((co_await net::this_coro::cancellation_state).cancelled() == net::cancellation_type::none) + { + auto [ec, sock] = co_await acceptor.async_accept(); + const auto exec = sock.get_executor(); + using stream_type = typename beast::tcp_stream::rebind_executor::other; + if (!ec) + // We dont't need a strand, since the awaitable is an implicit strand. + net::co_spawn(exec, + detect_session(stream_type(std::move(sock)), ctx, doc_root), + net::bind_cancellation_slot(sig.slot(), net::detached)); + } +} + +//------------------------------------------------------------------------------ + +int main(int argc, char* argv[]) +{ + // Check command line arguments. + if (argc != 5) + { + std::cerr << + "Usage: advanced-server-flex-awaitable
\n" << + "Example:\n" << + " advanced-server-flex-awaitable 0.0.0.0 8080 . 1\n"; + return EXIT_FAILURE; + } + auto const address = net::ip::make_address(argv[1]); + auto const port = static_cast(std::atoi(argv[2])); + auto const doc_root = std::make_shared(argv[3]); + auto const threads = std::max(1, std::atoi(argv[4])); + + // The io_context is required for all I/O + net::io_context ioc{threads}; + + // The SSL context is required, and holds certificates + ssl::context ctx{ssl::context::tlsv12}; + + // This holds the self-signed certificate used by the server + load_server_certificate(ctx); + + // Cancellation-signal for SIGINT + cancellation_signals cancellation; + + // Create and launch a listening routine + net::co_spawn( + ioc, + listen(ctx, tcp::endpoint{address, port}, doc_root, cancellation), + net::bind_cancellation_slot(cancellation.slot(), net::detached)); + + + // Capture SIGINT and SIGTERM to perform a clean shutdown + net::signal_set signals(ioc, SIGINT, SIGTERM); + signals.async_wait( + [&](beast::error_code const&, int sig) + { + if (sig == SIGINT) + cancellation.emit(net::cancellation_type::all); + else + { + // Stop the `io_context`. This will cause `run()` + // to return immediately, eventually destroying the + // `io_context` and all of the sockets in it. + ioc.stop(); + } + }); + + // Run the I/O service on the requested number of threads + std::vector v; + v.reserve(threads - 1); + for(auto i = threads - 1; i > 0; --i) + v.emplace_back( + [&ioc] + { + ioc.run(); + }); + ioc.run(); + + // (If we get here, it means we got a SIGINT or SIGTERM) + + // Block until all the threads exit + for(auto& t : v) + t.join(); + + return EXIT_SUCCESS; +} + + +#else + +int main(int, char * []) +{ + std::printf("awaitables require C++20\n"); + return 1; +} + +#endif diff --git a/example/http/client/CMakeLists.txt b/example/http/client/CMakeLists.txt index f49b2e02..82e57e9b 100644 --- a/example/http/client/CMakeLists.txt +++ b/example/http/client/CMakeLists.txt @@ -8,6 +8,7 @@ # add_subdirectory (async) +add_subdirectory (awaitable) add_subdirectory (coro) add_subdirectory (crawl) add_subdirectory (sync) diff --git a/example/http/client/Jamfile b/example/http/client/Jamfile index e88477e8..d45dbe6f 100644 --- a/example/http/client/Jamfile +++ b/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 ; diff --git a/example/http/client/awaitable/CMakeLists.txt b/example/http/client/awaitable/CMakeLists.txt new file mode 100644 index 00000000..f18d0b94 --- /dev/null +++ b/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") diff --git a/example/http/client/awaitable/Jamfile b/example/http/client/awaitable/Jamfile new file mode 100644 index 00000000..7bfc7c17 --- /dev/null +++ b/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 + : + coverage:no + ubasan:no + ; diff --git a/example/http/client/awaitable/http_client_awaitable.cpp b/example/http/client/awaitable/http_client_awaitable.cpp new file mode 100644 index 00000000..93c0fa22 --- /dev/null +++ b/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 +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_ASIO_HAS_CO_AWAIT) + +#include +#include +#include +#include + +namespace beast = boost::beast; // from +namespace http = beast::http; // from +namespace net = boost::asio; // from +using tcp = boost::asio::ip::tcp; // from + +//------------------------------------------------------------------------------ + +// 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 +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 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 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 []\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 diff --git a/example/http/server/CMakeLists.txt b/example/http/server/CMakeLists.txt index 350b465a..075f8665 100644 --- a/example/http/server/CMakeLists.txt +++ b/example/http/server/CMakeLists.txt @@ -8,6 +8,7 @@ # add_subdirectory (async) +add_subdirectory (awaitable) add_subdirectory (coro) add_subdirectory (fast) add_subdirectory (small) diff --git a/example/http/server/Jamfile b/example/http/server/Jamfile index cb8ab104..f0119e45 100644 --- a/example/http/server/Jamfile +++ b/example/http/server/Jamfile @@ -13,6 +13,7 @@ build-project fast ; build-project small ; build-project stackless ; build-project sync ; +build-project awaitable ; # SSL build-project async-ssl ; diff --git a/example/http/server/awaitable/CMakeLists.txt b/example/http/server/awaitable/CMakeLists.txt new file mode 100644 index 00000000..3cfc4808 --- /dev/null +++ b/example/http/server/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/server/awaitable "/") + +add_executable (http-server-awaitable + ${BOOST_BEAST_FILES} + Jamfile + http_server_awaitable.cpp +) + +target_link_libraries(http-server-awaitable + lib-asio + lib-beast) + +set_property(TARGET http-server-awaitable PROPERTY FOLDER "example-http-server") diff --git a/example/http/server/awaitable/Jamfile b/example/http/server/awaitable/Jamfile new file mode 100644 index 00000000..3c3fada5 --- /dev/null +++ b/example/http/server/awaitable/Jamfile @@ -0,0 +1,16 @@ +# +# 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-server-awaitable : + http_server_awaitable.cpp + : + coverage:no + ubasan:no + no + ; diff --git a/example/http/server/awaitable/http_server_awaitable.cpp b/example/http/server/awaitable/http_server_awaitable.cpp new file mode 100644 index 00000000..64961da5 --- /dev/null +++ b/example/http/server/awaitable/http_server_awaitable.cpp @@ -0,0 +1,358 @@ +// +// 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 server, coroutine +// +//------------------------------------------------------------------------------ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_ASIO_HAS_CO_AWAIT) + +namespace beast = boost::beast; // from +namespace http = beast::http; // from +namespace net = boost::asio; // from +using tcp = boost::asio::ip::tcp; // from + +using tcp_stream = typename beast::tcp_stream::rebind_executor< + net::use_awaitable_t<>::executor_with_default>::other; + +// Return a reasonable mime type based on the extension of a file. +beast::string_view +mime_type(beast::string_view path) +{ + using beast::iequals; + auto const ext = [&path] + { + auto const pos = path.rfind("."); + if(pos == beast::string_view::npos) + return beast::string_view{}; + return path.substr(pos); + }(); + if(iequals(ext, ".htm")) return "text/html"; + if(iequals(ext, ".html")) return "text/html"; + if(iequals(ext, ".php")) return "text/html"; + if(iequals(ext, ".css")) return "text/css"; + if(iequals(ext, ".txt")) return "text/plain"; + if(iequals(ext, ".js")) return "application/javascript"; + if(iequals(ext, ".json")) return "application/json"; + if(iequals(ext, ".xml")) return "application/xml"; + if(iequals(ext, ".swf")) return "application/x-shockwave-flash"; + if(iequals(ext, ".flv")) return "video/x-flv"; + if(iequals(ext, ".png")) return "image/png"; + if(iequals(ext, ".jpe")) return "image/jpeg"; + if(iequals(ext, ".jpeg")) return "image/jpeg"; + if(iequals(ext, ".jpg")) return "image/jpeg"; + if(iequals(ext, ".gif")) return "image/gif"; + if(iequals(ext, ".bmp")) return "image/bmp"; + if(iequals(ext, ".ico")) return "image/vnd.microsoft.icon"; + if(iequals(ext, ".tiff")) return "image/tiff"; + if(iequals(ext, ".tif")) return "image/tiff"; + if(iequals(ext, ".svg")) return "image/svg+xml"; + if(iequals(ext, ".svgz")) return "image/svg+xml"; + return "application/text"; +} + +// Append an HTTP rel-path to a local filesystem path. +// The returned path is normalized for the platform. +std::string +path_cat( + beast::string_view base, + beast::string_view path) +{ + if(base.empty()) + return std::string(path); + std::string result(base); +#ifdef BOOST_MSVC + char constexpr path_separator = '\\'; + if(result.back() == path_separator) + result.resize(result.size() - 1); + result.append(path.data(), path.size()); + for(auto& c : result) + if(c == '/') + c = path_separator; +#else + char constexpr path_separator = '/'; + if(result.back() == path_separator) + result.resize(result.size() - 1); + result.append(path.data(), path.size()); +#endif + return result; +} + +// Return a response for the given request. +// +// The concrete type of the response message (which depends on the +// request), is type-erased in message_generator. +template +http::message_generator +handle_request( + beast::string_view doc_root, + http::request>&& req) +{ + // Returns a bad request response + auto const bad_request = + [&req](beast::string_view why) + { + http::response res{http::status::bad_request, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, "text/html"); + res.keep_alive(req.keep_alive()); + res.body() = std::string(why); + res.prepare_payload(); + return res; + }; + + // Returns a not found response + auto const not_found = + [&req](beast::string_view target) + { + http::response res{http::status::not_found, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, "text/html"); + res.keep_alive(req.keep_alive()); + res.body() = "The resource '" + std::string(target) + "' was not found."; + res.prepare_payload(); + return res; + }; + + // Returns a server error response + auto const server_error = + [&req](beast::string_view what) + { + http::response res{http::status::internal_server_error, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, "text/html"); + res.keep_alive(req.keep_alive()); + res.body() = "An error occurred: '" + std::string(what) + "'"; + res.prepare_payload(); + return res; + }; + + // Make sure we can handle the method + if( req.method() != http::verb::get && + req.method() != http::verb::head) + return bad_request("Unknown HTTP-method"); + + // Request path must be absolute and not contain "..". + if( req.target().empty() || + req.target()[0] != '/' || + req.target().find("..") != beast::string_view::npos) + return bad_request("Illegal request-target"); + + // Build the path to the requested file + std::string path = path_cat(doc_root, req.target()); + if(req.target().back() == '/') + path.append("index.html"); + + // Attempt to open the file + beast::error_code ec; + http::file_body::value_type body; + body.open(path.c_str(), beast::file_mode::scan, ec); + + // Handle the case where the file doesn't exist + if(ec == beast::errc::no_such_file_or_directory) + return not_found(req.target()); + + // Handle an unknown error + if(ec) + return server_error(ec.message()); + + // Cache the size since we need it after the move + auto const size = body.size(); + + // Respond to HEAD request + if(req.method() == http::verb::head) + { + http::response res{http::status::ok, req.version()}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, mime_type(path)); + res.content_length(size); + res.keep_alive(req.keep_alive()); + return res; + } + + // Respond to GET request + http::response res{ + std::piecewise_construct, + std::make_tuple(std::move(body)), + std::make_tuple(http::status::ok, req.version())}; + res.set(http::field::server, BOOST_BEAST_VERSION_STRING); + res.set(http::field::content_type, mime_type(path)); + res.content_length(size); + res.keep_alive(req.keep_alive()); + return res; +} + +//------------------------------------------------------------------------------ + + +// Handles an HTTP server connection +net::awaitable +do_session( + tcp_stream stream, + std::shared_ptr doc_root) +{ + beast::error_code ec; + + // This buffer is required to persist across reads + beast::flat_buffer buffer; + + // This lambda is used to send messages + for(;;) + try + { + // Set the timeout. + stream.expires_after(std::chrono::seconds(30)); + + // Read a request + http::request req; + co_await http::async_read(stream, buffer, req); + + // Handle the request + http::message_generator msg = + handle_request(*doc_root, std::move(req)); + + // Determine if we should close the connection + bool keep_alive = msg.keep_alive(); + + // Send the response + co_await beast::async_write(stream, std::move(msg), net::use_awaitable); + + if(! keep_alive) + { + // This means we should close the connection, usually because + // the response indicated the "Connection: close" semantic. + break; + } + } + catch (boost::system::system_error & se) + { + if (se.code() != http::error::end_of_stream ) + throw ; + } + + // Send a TCP shutdown + stream.socket().shutdown(tcp::socket::shutdown_send, ec); + + // At this point the connection is closed gracefully +} + +//------------------------------------------------------------------------------ + +// Accepts incoming connections and launches the sessions +net::awaitable +do_listen( + tcp::endpoint endpoint, + std::shared_ptr doc_root) +{ + // Open the acceptor + auto acceptor = net::use_awaitable.as_default_on(tcp::acceptor(co_await net::this_coro::executor)); + acceptor.open(endpoint.protocol()); + + // Allow address reuse + acceptor.set_option(net::socket_base::reuse_address(true)); + + // Bind to the server address + acceptor.bind(endpoint); + + // Start listening for connections + acceptor.listen(net::socket_base::max_listen_connections); + + for(;;) + boost::asio::co_spawn( + acceptor.get_executor(), + do_session(tcp_stream(co_await acceptor.async_accept()), doc_root), + [](std::exception_ptr e) + { + try + { + std::rethrow_exception(e); + } + catch (std::exception &e) { + std::cerr << "Error in session: " << e.what() << "\n"; + } + }); + +} + +int main(int argc, char* argv[]) +{ + // Check command line arguments. + if (argc != 5) + { + std::cerr << + "Usage: http-server-awaitable
\n" << + "Example:\n" << + " http-server-awaitable 0.0.0.0 8080 . 1\n"; + return EXIT_FAILURE; + } + auto const address = net::ip::make_address(argv[1]); + auto const port = static_cast(std::atoi(argv[2])); + auto const doc_root = std::make_shared(argv[3]); + auto const threads = std::max(1, std::atoi(argv[4])); + + // The io_context is required for all I/O + net::io_context ioc{threads}; + + // Spawn a listening port + boost::asio::co_spawn(ioc, + do_listen(tcp::endpoint{address, port}, doc_root), + [](std::exception_ptr e) + { + if (e) + try + { + std::rethrow_exception(e); + } + catch(std::exception & e) + { + std::cerr << "Error in acceptor: " << e.what() << "\n"; + } + }); + + // Run the I/O service on the requested number of threads + std::vector v; + v.reserve(threads - 1); + for(auto i = threads - 1; i > 0; --i) + v.emplace_back( + [&ioc] + { + ioc.run(); + }); + ioc.run(); + + return EXIT_SUCCESS; +} + +#else + +int main(int, char * []) +{ + std::printf("awaitables require C++20\n"); + return 1; +} + +#endif diff --git a/example/websocket/client/CMakeLists.txt b/example/websocket/client/CMakeLists.txt index 5d1300e2..1d09cd03 100644 --- a/example/websocket/client/CMakeLists.txt +++ b/example/websocket/client/CMakeLists.txt @@ -8,6 +8,7 @@ # add_subdirectory (async) +add_subdirectory (awaitable) add_subdirectory (coro) add_subdirectory (sync) diff --git a/example/websocket/client/Jamfile b/example/websocket/client/Jamfile index 94a45811..753b90d0 100644 --- a/example/websocket/client/Jamfile +++ b/example/websocket/client/Jamfile @@ -8,6 +8,7 @@ # build-project async ; +build-project awaitable ; build-project coro ; build-project sync ; diff --git a/example/websocket/client/awaitable/CMakeLists.txt b/example/websocket/client/awaitable/CMakeLists.txt new file mode 100644 index 00000000..b0929f16 --- /dev/null +++ b/example/websocket/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/websocket/client/awaitable "/") + +add_executable (websocket-client-awaitable + ${BOOST_BEAST_FILES} + Jamfile + websocket_client_awaitable.cpp +) + +target_link_libraries(websocket-client-awaitable + lib-asio + lib-beast) + +set_property(TARGET websocket-client-awaitable PROPERTY FOLDER "example-websocket-client") diff --git a/example/websocket/client/awaitable/Jamfile b/example/websocket/client/awaitable/Jamfile new file mode 100644 index 00000000..7c79aec6 --- /dev/null +++ b/example/websocket/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 websocket-client-awaitable : + websocket_client_awaitable.cpp + : + coverage:no + ubasan:no + ; diff --git a/example/websocket/client/awaitable/websocket_client_awaitable.cpp b/example/websocket/client/awaitable/websocket_client_awaitable.cpp new file mode 100644 index 00000000..0a28289f --- /dev/null +++ b/example/websocket/client/awaitable/websocket_client_awaitable.cpp @@ -0,0 +1,162 @@ +// +// 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: WebSocket client, coroutine +// +//------------------------------------------------------------------------------ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_ASIO_HAS_CO_AWAIT) + + +namespace beast = boost::beast; // from +namespace http = beast::http; // from +namespace websocket = beast::websocket; // from +namespace net = boost::asio; // from +using tcp = boost::asio::ip::tcp; // from + +//------------------------------------------------------------------------------ + +// Report a failure +void +fail(beast::error_code ec, char const* what) +{ + std::cerr << what << ": " << ec.message() << "\n"; +} + +// Sends a WebSocket message and prints the response +net::awaitable +do_session( + std::string host, + std::string port, + std::string text) +{ + // These objects perform our I/O + auto resolver = net::use_awaitable.as_default_on( + tcp::resolver(co_await net::this_coro::executor)); + auto ws = net::use_awaitable.as_default_on( + websocket::stream(co_await net::this_coro::executor)); + + // Look up the domain name + auto const results = co_await resolver.async_resolve(host, port); + + // Set a timeout on the operation + beast::get_lowest_layer(ws).expires_after(std::chrono::seconds(30)); + + // Make the connection on the IP address we get from a lookup + auto ep = co_await beast::get_lowest_layer(ws).async_connect(results); + + // Update the host_ string. This will provide the value of the + // Host HTTP header during the WebSocket handshake. + // See https://tools.ietf.org/html/rfc7230#section-5.4 + host += ':' + std::to_string(ep.port()); + + // Turn off the timeout on the tcp_stream, because + // the websocket stream has its own timeout system. + beast::get_lowest_layer(ws).expires_never(); + + // Set suggested timeout settings for the websocket + ws.set_option( + websocket::stream_base::timeout::suggested( + beast::role_type::client)); + + // Set a decorator to change the User-Agent of the handshake + ws.set_option(websocket::stream_base::decorator( + [](websocket::request_type& req) + { + req.set(http::field::user_agent, + std::string(BOOST_BEAST_VERSION_STRING) + + " websocket-client-coro"); + })); + + // Perform the websocket handshake + co_await ws.async_handshake(host, "/"); + + // Send the message + co_await ws.async_write(net::buffer(std::string(text))); + + // This buffer will hold the incoming message + beast::flat_buffer buffer; + + // Read a message into our buffer + co_await ws.async_read(buffer); + + // Close the WebSocket connection + co_await ws.async_close(websocket::close_code::normal); + + // If we get here then the connection is closed gracefully + + // The make_printable() function helps print a ConstBufferSequence + std::cout << beast::make_printable(buffer.data()) << std::endl; +} + +//------------------------------------------------------------------------------ + +int main(int argc, char** argv) +{ + // Check command line arguments. + if(argc != 4) + { + std::cerr << + "Usage: websocket-client-awaitable \n" << + "Example:\n" << + " websocket-client-awaitable echo.websocket.org 80 \"Hello, world!\"\n"; + return EXIT_FAILURE; + } + auto const host = argv[1]; + auto const port = argv[2]; + auto const text = argv[3]; + + // 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, text), + [](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 socket is closed. + ioc.run(); + + return EXIT_SUCCESS; +} + +#else + +int main(int, char * []) +{ + std::printf("awaitables require C++20\n"); + return 1; +} + +#endif diff --git a/example/websocket/server/CMakeLists.txt b/example/websocket/server/CMakeLists.txt index c5b8da5d..62cb221e 100644 --- a/example/websocket/server/CMakeLists.txt +++ b/example/websocket/server/CMakeLists.txt @@ -8,6 +8,7 @@ # add_subdirectory (async) +add_subdirectory (awaitable) add_subdirectory (chat-multi) add_subdirectory (coro) add_subdirectory (fast) diff --git a/example/websocket/server/Jamfile b/example/websocket/server/Jamfile index ccfd63fa..07a02b50 100644 --- a/example/websocket/server/Jamfile +++ b/example/websocket/server/Jamfile @@ -8,6 +8,7 @@ # build-project async ; +build-project awaitable ; build-project chat-multi ; build-project coro ; build-project fast ; diff --git a/example/websocket/server/awaitable/CMakeLists.txt b/example/websocket/server/awaitable/CMakeLists.txt new file mode 100644 index 00000000..2a99bc82 --- /dev/null +++ b/example/websocket/server/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/websocket/server/awaitable "/") + +add_executable (websocket-server-awaitable + ${BOOST_BEAST_FILES} + Jamfile + websocket_server_awaitable.cpp +) + +target_link_libraries(websocket-server-awaitable + lib-asio + lib-beast) + +set_property(TARGET websocket-server-awaitable PROPERTY FOLDER "example-websocket-server") diff --git a/example/websocket/server/awaitable/Jamfile b/example/websocket/server/awaitable/Jamfile new file mode 100644 index 00000000..0eddbe24 --- /dev/null +++ b/example/websocket/server/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 websocket-server-awaitable : + websocket_server_awaitable.cpp + : + coverage:no + ubasan:no + ; diff --git a/example/websocket/server/awaitable/websocket_server_awaitable.cpp b/example/websocket/server/awaitable/websocket_server_awaitable.cpp new file mode 100644 index 00000000..e7267315 --- /dev/null +++ b/example/websocket/server/awaitable/websocket_server_awaitable.cpp @@ -0,0 +1,181 @@ +// +// 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: WebSocket server, coroutine +// +//------------------------------------------------------------------------------ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_ASIO_HAS_CO_AWAIT) + +namespace beast = boost::beast; // from +namespace http = beast::http; // from +namespace websocket = beast::websocket; // from +namespace net = boost::asio; // from +using tcp = boost::asio::ip::tcp; // from + +using stream = websocket::stream< + typename beast::tcp_stream::rebind_executor< + typename net::use_awaitable_t<>::executor_with_default>::other>; + +//------------------------------------------------------------------------------ + +// Echoes back all received WebSocket messages +net::awaitable +do_session(stream ws) +{ + // Set suggested timeout settings for the websocket + ws.set_option( + websocket::stream_base::timeout::suggested( + beast::role_type::server)); + + // Set a decorator to change the Server of the handshake + ws.set_option(websocket::stream_base::decorator( + [](websocket::response_type& res) + { + res.set(http::field::server, + std::string(BOOST_BEAST_VERSION_STRING) + + " websocket-server-coro"); + })); + + // Accept the websocket handshake + co_await ws.async_accept(); + + for(;;) + try { + // This buffer will hold the incoming message + beast::flat_buffer buffer; + + // Read a message + co_await ws.async_read(buffer); + + // Echo the message back + ws.text(ws.got_text()); + co_await ws.async_write(buffer.data()); + + } + catch(boost::system::system_error & se) + { + if (se.code() != websocket::error::closed) + throw; + + } +} + +//------------------------------------------------------------------------------ + +// Accepts incoming connections and launches the sessions +net::awaitable +do_listen( + tcp::endpoint endpoint) +{ + + // Open the acceptor + auto acceptor = net::use_awaitable.as_default_on(tcp::acceptor(co_await net::this_coro::executor)); + acceptor.open(endpoint.protocol()); + + // Allow address reuse + acceptor.set_option(net::socket_base::reuse_address(true)); + + // Bind to the server address + acceptor.bind(endpoint); + + // Start listening for connections + acceptor.listen(net::socket_base::max_listen_connections); + + for(;;) + boost::asio::co_spawn( + acceptor.get_executor(), + do_session(stream(co_await acceptor.async_accept())), + [](std::exception_ptr e) + { + try + { + std::rethrow_exception(e); + } + catch (std::exception &e) { + std::cerr << "Error in session: " << e.what() << "\n"; + } + }); +} + +int main(int argc, char* argv[]) +{ + // Check command line arguments. + if (argc != 4) + { + std::cerr << + "Usage: websocket-server-awaitable
\n" << + "Example:\n" << + " websocket-server-awaitable 0.0.0.0 8080 1\n"; + return EXIT_FAILURE; + } + auto const address = net::ip::make_address(argv[1]); + auto const port = static_cast(std::atoi(argv[2])); + auto const threads = std::max(1, std::atoi(argv[3])); + + // The io_context is required for all I/O + net::io_context ioc(threads); + + // Spawn a listening port + boost::asio::co_spawn( + ioc, + do_listen(tcp::endpoint{address, port}), + [](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 on the requested number of threads + std::vector v; + v.reserve(threads - 1); + for(auto i = threads - 1; i > 0; --i) + v.emplace_back( + [&ioc] + { + ioc.run(); + }); + ioc.run(); + + return EXIT_SUCCESS; +} + +#else + +int main(int, char * []) +{ + std::printf("awaitables require C++20\n"); + return 1; +} + +#endif \ No newline at end of file