我正在尝试使用Boost beast::websocket websocket_client_async.cpp 示例,结合 websocket_server_async.cpp 使用。
按照示例,客户端 只是建立连接,向服务器发送一个字符串(服务器简单地回显),打印回复,关闭并退出。
我正在尝试修改客户端以保持会话活动,以便可以重复发送/接收字符串。因此,示例代码的 on_handshake
函数立即通过 ws_.async_write(...)
发送字符串,而我将其分离成自己的 write(...)
函数。
这是我修改后的 session
类:
using tcp = boost::asio::ip::tcp;
namespace websocket = boost::beast::websocket;
void fail(boost::system::error_code ec, char const* what)
{
std::cerr << what << ": " << ec.message() << "\n";
}
// Sends a WebSocket message and prints the response
class session : public std::enable_shared_from_this<session>
{
tcp::resolver resolver_;
websocket::stream<tcp::socket> ws_;
std::atomic<bool> io_in_progress_;
boost::beast::multi_buffer buffer_;
std::string host_;
public:
// Resolver and socket require an io_context
explicit session(boost::asio::io_context& ioc) : resolver_(ioc), ws_(ioc) {
io_in_progress_ = false;
}
bool io_in_progress() const {
return io_in_progress_;
}
// +---------------------+
// | The "open" sequence |
// +---------------------+
void open(char const* host, char const* port)
{
host_ = host;
// Look up the domain name
resolver_.async_resolve(host, port,
std::bind( &session::on_resolve, shared_from_this(),
std::placeholders::_1, std::placeholders::_2 )
);
}
void on_resolve(boost::system::error_code ec, tcp::resolver::results_type results)
{
if (ec)
return fail(ec, "resolve");
boost::asio::async_connect(
ws_.next_layer(), results.begin(), results.end(),
std::bind( &session::on_connect, shared_from_this(),
std::placeholders::_1 )
);
}
void on_connect(boost::system::error_code ec)
{
if (ec)
return fail(ec, "connect");
ws_.async_handshake(host_, "/",
std::bind( &session::on_handshake, shared_from_this(),
std::placeholders::_1 )
);
}
void on_handshake(boost::system::error_code ec)
{
if (ec)
return fail(ec, "handshake");
else {
std::cout << "Successful handshake with server.\n";
}
}
// +---------------------------+
// | The "write/read" sequence |
// +---------------------------+
void write(const std::string &text)
{
io_in_progress_ = true;
ws_.async_write(boost::asio::buffer(text),
std::bind( &session::on_write, shared_from_this(),
std::placeholders::_1, std::placeholders::_2 )
);
}
void on_write(boost::system::error_code ec, std::size_t bytes_transferred)
{
boost::ignore_unused(bytes_transferred);
if (ec)
return fail(ec, "write");
ws_.async_read(buffer_,
std::bind( &session::on_read, shared_from_this(),
std::placeholders::_1, std::placeholders::_2 )
);
}
void on_read(boost::system::error_code ec, std::size_t bytes_transferred)
{
io_in_progress_ = false; // end of write/read sequence
boost::ignore_unused(bytes_transferred);
if (ec)
return fail(ec, "read");
std::cout << boost::beast::buffers(buffer_.data()) << std::endl;
}
// +----------------------+
// | The "close" sequence |
// +----------------------+
void close()
{
io_in_progress_ = true;
ws_.async_close(websocket::close_code::normal,
std::bind( &session::on_close, shared_from_this(),
std::placeholders::_1)
);
}
void on_close(boost::system::error_code ec)
{
io_in_progress_ = false; // end of close sequence
if (ec)
return fail(ec, "close");
std::cout << "Socket closed successfully.\n";
}
};
问题在于,虽然连接正常工作并且我可以发送字符串,但是
on_read
回调函数从未被触发(除非我执行下面描述的丑陋的hack)。我的
main
代码如下:void wait_for_io(std::shared_ptr<session> psession, boost::asio::io_context &ioc)
{
// Continually try to run the ioc until the callbacks are finally
// triggered (as indicated by the session::io_in_progress_ flag)
while (psession->io_in_progress()) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
ioc.run();
}
}
int main(int argc, char** argv)
{
// Check command line arguments.
if (argc != 3) {
std::cerr << "usage info goes here...\n";
return EXIT_FAILURE;
}
const char *host = argv[1], *port = argv[2];
boost::asio::io_context ioc;
std::shared_ptr<session> p = std::make_shared<session>(ioc);
p->open(host, port);
ioc.run(); // This works. Connection is established and all callbacks are executed.
p->write("Hello world"); // String is sent & received by server,
// even before calling ioc.run()
// However, session::on_read callback is never
// reached.
ioc.run(); // This seems to be ignored and returns immediately, so
wait_for_io(p, ioc); // <-- so this hack is necessary
p->close(); // session::on_close is never reached
ioc.run(); // Again, this seems to be ignored and returns immediately, so
wait_for_io(p, ioc); // <-- this is necessary
return EXIT_SUCCESS;
}
如果我这样做:
p->write("Hello world");
while(1) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
我可以确认该字符串已被服务器发送和接收1,但未到达
session::on_read
回调函数。使用
p->close()
同样出现此问题。但是,如果我添加奇怪的
wait_for_io()
函数,一切都正常。我确定这是一个可怕的hack,但我无法弄清楚发生了什么。1注意:我可以确认消息已经到达服务器,因为我修改了服务器示例以将任何接收到的字符串打印到控制台。这是我所做的唯一修改。echo-to-client功能没有更改。
write
中调用了boost::asio::buffer(text)
。但是,在异步操作仍在运行时,text
可能会超出作用域。调用者有责任确保传递给流算法的内存缓冲区的生命周期至少保持有效,直到相应的完成处理程序被调用。 - Vinnie Falco