You made do_session a non-static member function of a class. This means that you need an instance of the ClientSession object to invoke it on. You don't pass one in the std::bind() expression, which leads to confused error messages because there is no valid async_result<> specialization for your handler type. In fact, your handler type is simply invalid.
Make an instance, and use it:
auto cs = std::make_shared<NetTools::ClientSession>(
"no_auth_token", nullptr);
cs->StartSession();
Then inside StartSession you can use the current instance, this:
// Launch the asynchronous operation
net::spawn(ioc, std::bind(
&NetTools::ClientSession::do_session,
this, // <-- HERE
std::string(host),
std::string(port),
std::string(text),
std::ref(ioc),
std::ref(ctx),
std::placeholders::_1));
All code rolled into one:
Live On Coliru
#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/asio/ssl.hpp>
#include <memory>
#include "example/common/root_certificates.hpp"
#include <boost/asio/spawn.hpp>
#include <boost/beast/core.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/beast/websocket/ssl.hpp>
#include <functional>
#include <iostream>
#include <string>
namespace beast = boost::beast; // from <boost/beast.hpp>
namespace http = beast::http; // from <boost/beast/http.hpp>
namespace websocket = beast::websocket; // from <boost/beast/websocket.hpp>
namespace net = boost::asio; // from <boost/asio.hpp>
namespace ssl = boost::asio::ssl; // from <boost/asio/ssl.hpp>
using tcp = boost::asio::ip::tcp; // from <boost/asio/ip/tcp.hpp>
namespace spdlog { struct logger { }; }; // namespace spdlog
static auto constexpr s_target_path = "/.ws"; // for COLIRU demo, you had "/"
namespace NetTools {
class ClientSession
: public std::enable_shared_from_this<ClientSession>
{
private:
std::string auth_token;
std::shared_ptr<spdlog::logger> m_pLog;
public:
ClientSession(
std::string auth_token, std::shared_ptr<spdlog::logger> log)
: auth_token(std::move(auth_token))
, m_pLog(std::move(log))
{
}
int StartSession();
void do_session(
std::string host,
std::string const& port,
std::string const& text,
net::io_context& ioc,
ssl::context& ctx,
net::yield_context yield);
};
// Report a failure
void fail(beast::error_code ec, char const* what)
{
std::cerr << what << ": " << ec.message() << "\n";
}
} // namespace NetTools
//------------------------------------------------------------------------------
// Sends a WebSocket message and prints the response
void NetTools::ClientSession::do_session(
std::string host,
std::string const& port,
std::string const& text,
net::io_context& ioc,
ssl::context& ctx,
net::yield_context yield)
{
beast::error_code ec;
// These objects perform our I/O
tcp::resolver resolver(ioc);
websocket::stream<beast::ssl_stream<beast::tcp_stream>> ws(
ioc, ctx);
// Look up the domain name
auto const results =
resolver.async_resolve(host, port, yield[ec]);
if(ec)
return fail(ec, "resolve");
// 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 =
beast::get_lowest_layer(ws).async_connect(results, yield[ec]);
if(ec)
return fail(ec, "connect");
// Set SNI Hostname (many hosts need this to handshake
// successfully)
if(! SSL_set_tlsext_host_name(
ws.next_layer().native_handle(), host.c_str()))
{
ec = beast::error_code(
static_cast<int>(::ERR_get_error()),
net::error::get_ssl_category());
return fail(ec, "connect");
}
// 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());
// Set a timeout on the operation
beast::get_lowest_layer(ws).expires_after(
std::chrono::seconds(30));
// 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 SSL handshake
ws.next_layer().async_handshake(
ssl::stream_base::client, yield[ec]);
if(ec)
return fail(ec, "ssl_handshake");
// 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));
// Perform the websocket handshake
ws.async_handshake(host, s_target_path, yield[ec]);
if(ec)
return fail(ec, "handshake");
// Send the message
ws.async_write(net::buffer(std::string(text)), yield[ec]);
if(ec)
return fail(ec, "write");
// This buffer will hold the incoming message
beast::flat_buffer buffer;
// Read a message into our buffer
ws.async_read(buffer, yield[ec]);
if(ec)
return fail(ec, "read");
// Close the WebSocket connection
ws.async_close(websocket::close_code::normal, yield[ec]);
if(ec)
return fail(ec, "close");
// 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 NetTools::ClientSession::StartSession()
{
auto const host = "echo.websocket.events";
auto const port = "https";
auto const text = "Hello world!";
// The io_context is required for all I/O
net::io_context ioc;
// The SSL context is required, and holds certificates
ssl::context ctx{ssl::context::tlsv12_client};
// This holds the root certificate used for verification
load_root_certificates(ctx);
// Launch the asynchronous operation
net::spawn(
ioc,
std::bind(
&NetTools::ClientSession::do_session,
this,
std::string(host),
std::string(port),
std::string(text),
std::ref(ioc),
std::ref(ctx),
std::placeholders::_1));
// Run the I/O service. The call will return when
// the socket is closed.
ioc.run();
return 0;
}
int main()
{
auto cs = std::make_shared<NetTools::ClientSession>(
"no_auth_token", nullptr);
cs->StartSession();
}
Running locally against the https://echo.websocket.events/.ws service:
