mirror of
https://github.com/boostorg/asio.git
synced 2026-01-23 17:32:07 +00:00
cb60b08ff5
The BOOST_ASIO_HANDLER_LOCATION((file_name, line, function_name)) macro
may be used to inform the handler tracking mechanism of a source
location. This macro declares an object that is placed on the stack.
When an asynchronous operation is launched with location information, it
outputs lines using the <action> 'n^m', prior to the 'n*m' line that
signifies the beginning of the asynchronous operation. For example:
@asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5
@asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330)
@asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62)
@asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51)
@asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send
@asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5
@asio|1589423304.861980|<7|
If std::source_location or std::experimental::source_location are
available, the use_awaitable_t token (when default-constructed or used
as a default completion token) will also cause handler tracking to
output a source location for each newly created asynchronous operation.
A use_awaitable_t object may also be explicitly constructed with location
information.
82 lines
1.9 KiB
C++
82 lines
1.9 KiB
C++
//
|
|
// echo_server.cpp
|
|
// ~~~~~~~~~~~~~~~
|
|
//
|
|
// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
#include <boost/asio/co_spawn.hpp>
|
|
#include <boost/asio/detached.hpp>
|
|
#include <boost/asio/io_context.hpp>
|
|
#include <boost/asio/ip/tcp.hpp>
|
|
#include <boost/asio/signal_set.hpp>
|
|
#include <boost/asio/write.hpp>
|
|
#include <cstdio>
|
|
|
|
using boost::asio::ip::tcp;
|
|
using boost::asio::awaitable;
|
|
using boost::asio::co_spawn;
|
|
using boost::asio::detached;
|
|
using boost::asio::use_awaitable;
|
|
namespace this_coro = boost::asio::this_coro;
|
|
|
|
#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
|
|
# define use_awaitable \
|
|
boost::asio::use_awaitable_t(__FILE__, __LINE__, __PRETTY_FUNCTION__)
|
|
#endif
|
|
|
|
awaitable<void> echo(tcp::socket socket)
|
|
{
|
|
try
|
|
{
|
|
char data[1024];
|
|
for (;;)
|
|
{
|
|
std::size_t n = co_await socket.async_read_some(boost::asio::buffer(data), use_awaitable);
|
|
co_await async_write(socket, boost::asio::buffer(data, n), use_awaitable);
|
|
}
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
std::printf("echo Exception: %s\n", e.what());
|
|
}
|
|
}
|
|
|
|
awaitable<void> listener()
|
|
{
|
|
auto executor = co_await this_coro::executor;
|
|
tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
|
|
for (;;)
|
|
{
|
|
tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
|
|
co_spawn(executor,
|
|
[socket = std::move(socket)]() mutable
|
|
{
|
|
return echo(std::move(socket));
|
|
},
|
|
detached);
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
try
|
|
{
|
|
boost::asio::io_context io_context(1);
|
|
|
|
boost::asio::signal_set signals(io_context, SIGINT, SIGTERM);
|
|
signals.async_wait([&](auto, auto){ io_context.stop(); });
|
|
|
|
co_spawn(io_context, listener, detached);
|
|
|
|
io_context.run();
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
std::printf("Exception: %s\n", e.what());
|
|
}
|
|
}
|