Horizon::Networking::AsyncAcceptor Class Reference

Asynchronous acceptor for sockets. More...

#include <AsyncAcceptor.hpp>

Public Types
typedef std::function< void(std::shared_ptr< tcp::socket >, uint32_t thread_index)>	AcceptCallback

Public Member Functions
	~AsyncAcceptor ()
	AsyncAcceptor (boost::asio::io_context &io_context, std::string const &listen_ip, uint16_t port)
	Constructor of the AsyncAcceptor object. More...
template<class T >
void	AsyncAccept ()
void	async_accept_with_callback (AcceptCallback callback)
	Asynchronously accepts sockets and executes a callback function. More...
bool	bind ()
	Binds this instance to an endpoint, to listen for connections. More...
void	close ()
	Closes the acceptor across all threads. More...
bool	is_open ()
void	set_socket_factory (std::function< std::pair< std::shared_ptr< tcp::socket >, uint32_t >()> &&func)
	Sets the socket factory for the acceptor. More...

Private Member Functions
std::pair< std::shared_ptr< tcp::socket >, uint32_t >	default_socket_factory ()

Private Attributes
tcp::endpoint	_endpoint
std::shared_ptr< tcp::acceptor >	_acceptor
std::shared_ptr< tcp::socket >	_socket
std::atomic< bool >	_closed
std::function< std::pair< std::shared_ptr< tcp::socket >, uint32_t >()>	_socket_factory

Detailed Description

Asynchronous acceptor for sockets.

Member Typedef Documentation

AcceptCallback

typedef std::function<void(std::shared_ptr<tcp::socket>, uint32_t thread_index)> Horizon::Networking::AsyncAcceptor::AcceptCallback

Constructor & Destructor Documentation

~AsyncAcceptor()

Horizon::Networking::AsyncAcceptor::~AsyncAcceptor ( )

inline

    {
        _acceptor.reset();
        _socket.reset();
    }

References _acceptor, and _socket.

AsyncAcceptor()

Horizon::Networking::AsyncAcceptor::AsyncAcceptor ( boost::asio::io_context &  io_context, std::string const &  listen_ip, uint16_t  port  )

inline

Constructor of the AsyncAcceptor object.

Parameters

	[in|out]	io_context reference to the io_context object.
[in]	listen_ip	const reference to the ip address string for the acceptor to bind on.
[in]	port	port number for the acceptor to bind on.

    : _endpoint(boost::asio::ip::address::from_string(listen_ip), port),
    _acceptor(std::make_shared<tcp::acceptor>(io_context, tcp::endpoint(boost::asio::ip::address::from_string(listen_ip), port))),
    _socket(std::make_shared<tcp::socket>(io_context)), _closed(false), _socket_factory(std::bind(&AsyncAcceptor::default_socket_factory, this))
    {
    }

Member Function Documentation

async_accept_with_callback()

void Horizon::Networking::AsyncAcceptor::async_accept_with_callback ( AcceptCallback  callback )

inline

Asynchronously accepts sockets and executes a callback function.

This function is responsible for - 1) Listening for new connections on the main thread. 2) Executing the callback provided to this method whilst moving its ownership. 3) Execute recursively on successful acceptances until closed.

Parameters

[in]

callback

the callback function to execute (

See also

type AcceptCallback)

    {
        std::shared_ptr<tcp::socket> socket;
 
        uint32_t thread_index;
 
        std::tie(socket, thread_index) = _socket_factory();
 
        _acceptor->async_accept(*socket, [this, socket, callback, thread_index] (boost::system::error_code error)
            {
                if (!error) {
                    try {
                        socket->non_blocking(true);
                        callback(std::move(socket), thread_index);
                    } catch (boost::system::system_error const &err) {
                        HLog(error) << "Networking: AsyncAcceptor failed to initialize client's socket :" << err.what();
                    }
                }
 
                if (!_closed)
                    this->async_accept_with_callback(callback);
            });
    }

References _acceptor, _closed, _socket_factory, async_accept_with_callback(), and HLog.

Referenced by async_accept_with_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

AsyncAccept()

template<class T >

void Horizon::Networking::AsyncAcceptor::AsyncAccept

{
    _acceptor->async_accept(_socket, [this] (boost::system::error_code error)
       {
           if (!error) {
               try {
                   std::make_shared<T>(std::move(this->_socket))->start();
               } catch (boost::system::system_error const &err) {
                   std::cerr << "Network Error: failed to retrieve client's remote address " << err.what() << std::endl;
               }
           }
 
           if (!_closed)
               this->AsyncAccept<T>();
       });
}

References _acceptor, _closed, and _socket.

bind()

bool Horizon::Networking::AsyncAcceptor::bind ( )

inline

Binds this instance to an endpoint, to listen for connections.

    {
        boost::system::error_code errorCode;
 
        _acceptor->open(_endpoint.protocol(), errorCode);
 
        if (errorCode) {
            HLog(error) << "Failed to open acceptor " << errorCode.message().c_str();
            return false;
        }
 
        _acceptor->bind(_endpoint, errorCode);
 
        if (errorCode) {
            HLog(error) << "Could not bind to " << _endpoint.address().to_string().c_str() << ":" << _endpoint.port() << " - "
             << errorCode.message().c_str();
            return false;
        }
 
        _acceptor->listen(boost::asio::socket_base::max_connections, errorCode);
 
        if (errorCode) {
            HLog(error) << "Failed to start listening on " << _endpoint.address().to_string().c_str() << ":" << _endpoint.port() << " " << errorCode.message().c_str();
            return false;
        }
 
        return true;
    }

References _acceptor, _endpoint, and HLog.

close()

void Horizon::Networking::AsyncAcceptor::close ( )

inline

Closes the acceptor across all threads.

    {
        if (_closed.exchange(true))
            return;
 
        _socket->close();
 
        boost::system::error_code error;
        _acceptor->close(error);
 
        _acceptor.reset();
        _socket.reset();
        if (error)
            HLog(error) << "Failed to close acceptor: " << error.message().c_str();
    }

References _acceptor, _closed, _socket, and HLog.

default_socket_factory()

std::pair< std::shared_ptr< tcp::socket >, uint32_t > Horizon::Networking::AsyncAcceptor::default_socket_factory ( )

inlineprivate

{ return std::make_pair(_socket, 0); }

References _socket.

is_open()

bool Horizon::Networking::AsyncAcceptor::is_open ( )

inline

{ return !_closed.load(); }

References _closed.

set_socket_factory()

void Horizon::Networking::AsyncAcceptor::set_socket_factory ( std::function< std::pair< std::shared_ptr< tcp::socket >, uint32_t >()> &&  func )

inline

Sets the socket factory for the acceptor.

{ _socket_factory = func; }

References _socket_factory.

Member Data Documentation

_acceptor

std::shared_ptr<tcp::acceptor> Horizon::Networking::AsyncAcceptor::_acceptor

private

Referenced by async_accept_with_callback(), AsyncAccept(), bind(), close(), and ~AsyncAcceptor().

_closed

std::atomic<bool> Horizon::Networking::AsyncAcceptor::_closed

private

Referenced by async_accept_with_callback(), AsyncAccept(), close(), and is_open().

_endpoint

tcp::endpoint Horizon::Networking::AsyncAcceptor::_endpoint

private

Referenced by bind().

_socket

std::shared_ptr<tcp::socket> Horizon::Networking::AsyncAcceptor::_socket

private

Referenced by AsyncAccept(), close(), default_socket_factory(), and ~AsyncAcceptor().

_socket_factory

std::function<std::pair<std::shared_ptr<tcp::socket>, uint32_t>()> Horizon::Networking::AsyncAcceptor::_socket_factory

private

Referenced by async_accept_with_callback(), and set_socket_factory().

---

The documentation for this class was generated from the following file:

• src/Libraries/Networking/AsyncAcceptor.hpp