void start_listening() {
using boost::asio::ip::tcp;
system::error_code error;
tcp::resolver resolver(service_);
tcp::resolver::query query(address_, port_);
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
if (error) {
NETWORK_MESSAGE("Error resolving address: " << address_ << ':' << port_);
return;
}
tcp::endpoint endpoint = *endpoint_iterator;
acceptor_.open(endpoint.protocol(), error);
if (error) {
NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
return;
}
socket_options_base::acceptor_options(acceptor_);
acceptor_.bind(endpoint, error);
if (error) {
NETWORK_MESSAGE("Error binding to socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
return;
}
acceptor_.listen(tcp::socket::max_connections, error);
if (error) {
NETWORK_MESSAGE("Error listening on socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
return;
}
new_connection.reset(new sync_connection<Tag,Handler>(service_, handler_));
acceptor_.async_accept(new_connection->socket(),
boost::bind(&sync_server_base<Tag,Handler>::handle_accept,
this, boost::asio::placeholders::error));
listening_ = true;
}
void InitTCPServer(boost::asio::ip::tcp::acceptor& server, int server_port) {
boost::system::error_code server_ec;
boost::asio::ip::tcp::endpoint server_ep(boost::asio::ip::tcp::v4(),
server_port);
server.open(boost::asio::ip::tcp::v4(), server_ec);
ASSERT_EQ(0, server_ec.value()) << "Could not open server acceptor";
server.bind(server_ep, server_ec);
ASSERT_EQ(0, server_ec.value()) << "Could not bind server acceptor";
server.listen(boost::asio::socket_base::max_connections, server_ec);
ASSERT_EQ(0, server_ec.value()) << "Server acceptor could not listen";
}
PrivateData( int portNumber ) :
m_success(false),
m_endpoint(tcp::v4(), portNumber),
m_service(),
m_acceptor( m_service ),
m_thread()
{
m_acceptor.open( m_endpoint.protocol() );
m_acceptor.set_option( boost::asio::ip::tcp::acceptor::reuse_address(true));
m_acceptor.bind( m_endpoint );
m_acceptor.listen();
m_success = true;
}
http_sync_server(endpoint_type const& ep,
std::string const& root)
: sock_(ios_)
, acceptor_(ios_)
, root_(root)
{
acceptor_.open(ep.protocol());
acceptor_.bind(ep);
acceptor_.listen(
boost::asio::socket_base::max_connections);
acceptor_.async_accept(sock_,
std::bind(&http_sync_server::on_accept, this,
beast::asio::placeholders::error));
thread_ = std::thread{[&]{ ios_.run(); }};
}
/** Open a listening port.
@param ep The address and port to bind to.
@param ec Set to the error, if any occurred.
*/
void
open(tcp::endpoint const& ep, error_code& ec)
{
acceptor_.open(ep.protocol(), ec);
if(ec)
return fail("open", ec);
acceptor_.set_option(
boost::asio::socket_base::reuse_address{true});
acceptor_.bind(ep, ec);
if(ec)
return fail("bind", ec);
acceptor_.listen(
boost::asio::socket_base::max_connections, ec);
if(ec)
return fail("listen", ec);
do_accept();
}
sync_echo_server(bool server, endpoint_type ep)
: sock_(ios_)
, acceptor_(ios_)
{
error_code ec;
acceptor_.open(ep.protocol(), ec);
maybe_throw(ec, "open");
acceptor_.set_option(
boost::asio::socket_base::reuse_address{true});
acceptor_.bind(ep, ec);
maybe_throw(ec, "bind");
acceptor_.listen(
boost::asio::socket_base::max_connections, ec);
maybe_throw(ec, "listen");
acceptor_.async_accept(sock_,
std::bind(&sync_echo_server::on_accept, this,
beast::asio::placeholders::error));
thread_ = std::thread{[&]{ ios_.run(); }};
}
void start_listening() {
using boost::asio::ip::tcp;
system::error_code error;
tcp::resolver resolver(service_);
tcp::resolver::query query(address_, port_);
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
if (error) {
BOOST_NETWORK_MESSAGE("Error resolving address: " << address_ << ':'
<< port_);
boost::throw_exception(std::runtime_error("Error resolving address."));
}
tcp::endpoint endpoint = *endpoint_iterator;
acceptor_.open(endpoint.protocol(), error);
if (error) {
BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_
<< " -- reason: '" << error
<< '\'');
boost::throw_exception(std::runtime_error("Error opening socket."));
}
socket_options_base::acceptor_options(acceptor_);
acceptor_.bind(endpoint, error);
if (error) {
BOOST_NETWORK_MESSAGE("Error binding to socket: "
<< address_ << ':' << port_ << " -- reason: '"
<< error << '\'');
boost::throw_exception(std::runtime_error("Error binding to socket."));
}
acceptor_.listen(tcp::socket::max_connections, error);
if (error) {
BOOST_NETWORK_MESSAGE("Error listening on socket: "
<< address_ << ':' << port_ << " -- reason: '"
<< error << '\'');
boost::throw_exception(std::runtime_error("Error listening on socket."));
}
new_connection.reset(new sync_connection<Tag, Handler>(service_, handler_));
auto self = this->shared_from_this();
acceptor_.async_accept(
new_connection->socket(),
[=] (boost::system::error_code const &ec) { self->handle_accept(ec); });
listening_ = true;
}
inline server::server(const std::string& address,
const std::string& port,
std::size_t thread_pool_size,
request_handler& request_handler_)
: thread_pool_size_(thread_pool_size),
acceptor_(io_service_),
new_connection_(new connection(io_service_, request_handler_)),
request_handler_(request_handler_)
{
// Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
boost::asio::ip::tcp::resolver resolver(io_service_);
boost::asio::ip::tcp::resolver::query query(address, port);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
acceptor_.open(endpoint.protocol());
acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
acceptor_.bind(endpoint);
acceptor_.listen();
acceptor_.async_accept(new_connection_->socket(),
boost::bind(&server::handle_accept, this,
boost::asio::placeholders::error));
}
void start(const std::string & ip_addr, const std::string & port)
{
ip::tcp::resolver resolver(io_service_pool_.get_now_io_service());
ip::tcp::resolver::query query(ip_addr, port);
ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
boost::system::error_code ec;
acceptor_.open(endpoint.protocol(), ec);
if (ec) {
// Open endpoint error
std::cout << "async_asio_echo_serv_ex::start() - Error: (code = " << ec.value() << ") "
<< ec.message().c_str() << std::endl;
return;
}
boost::asio::socket_base::reuse_address option(true);
acceptor_.set_option(option);
acceptor_.bind(endpoint);
acceptor_.listen();
do_accept();
}