Socket< T > Class Template Reference

#include "Socket.h"

Inheritance diagram for Socket< T >:

Public Member Functions
	Socket (tcp::socket &&socket)
virtual	~Socket ()
virtual void	Start ()=0
virtual bool	Update ()
boost::asio::ip::address	GetRemoteIpAddress () const
uint16	GetRemotePort () const
void	AsyncRead ()
void	AsyncReadWithCallback (void(T::*callback)(boost::system::error_code, std::size_t))
void	QueuePacket (MessageBuffer &&buffer)
bool	IsOpen () const
void	CloseSocket ()
void	DelayedCloseSocket ()
	Marks the socket for closing after write buffer becomes empty.
MessageBuffer &	GetReadBuffer ()

Protected Member Functions
virtual void	OnClose ()
virtual void	ReadHandler ()=0
bool	AsyncProcessQueue ()
void	SetNoDelay (bool enable)

Private Member Functions
void	ReadHandlerInternal (boost::system::error_code error, size_t transferredBytes)
void	WriteHandlerWrapper (boost::system::error_code, std::size_t)
bool	HandleQueue ()

Private Attributes
tcp::socket	_socket
boost::asio::ip::address	_remoteAddress
uint16	_remotePort
MessageBuffer	_readBuffer
std::queue< MessageBuffer >	_writeQueue
std::atomic< bool >	_closed
std::atomic< bool >	_closing
bool	_isWritingAsync

Detailed Description

template<class T>
class Socket< T >

Constructor & Destructor Documentation

Socket()

template<class T >

Socket< T >::Socket ( tcp::socket &&  socket )

inlineexplicit

                                        : _socket(std::move(socket)), _remoteAddress(_socket.remote_endpoint().address()),
        _remotePort(_socket.remote_endpoint().port()), _readBuffer(), _closed(false), _closing(false), _isWritingAsync(false)
    {
        _readBuffer.Resize(READ_BLOCK_SIZE);
    }

References Socket< T >::_readBuffer, READ_BLOCK_SIZE, and MessageBuffer::Resize().

~Socket()

template<class T >

virtual Socket< T >::~Socket ( )

inlinevirtual

    {
        _closed = true;
        boost::system::error_code error;
        _socket.close(error);
    }

References Socket< T >::_closed, and Socket< T >::_socket.

Member Function Documentation

AsyncProcessQueue()

template<class T >

bool Socket< T >::AsyncProcessQueue ( )

inlineprotected

    {
        if (_isWritingAsync)
            return false;
 
        _isWritingAsync = true;
 
#ifdef AC_SOCKET_USE_IOCP
        MessageBuffer& buffer = _writeQueue.front();
        _socket.async_write_some(boost::asio::buffer(buffer.GetReadPointer(), buffer.GetActiveSize()), std::bind(&Socket<T>::WriteHandler,
            this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
#else
        _socket.async_write_some(boost::asio::null_buffers(), std::bind(&Socket<T>::WriteHandlerWrapper,
            this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
#endif
        return false;
    }

References Socket< T >::_isWritingAsync, Socket< T >::_socket, Socket< T >::_writeQueue, MessageBuffer::GetActiveSize(), and MessageBuffer::GetReadPointer().

Referenced by Socket< T >::HandleQueue(), and Socket< T >::QueuePacket().

AsyncRead()

template<class T >

void Socket< T >::AsyncRead ( )

inline

    {
        if (!IsOpen())
        {
            return;
        }
 
        _readBuffer.Normalize();
        _readBuffer.EnsureFreeSpace();
 
        _socket.async_read_some(boost::asio::buffer(_readBuffer.GetWritePointer(), _readBuffer.GetRemainingSpace()),
            std::bind(&Socket<T>::ReadHandlerInternal, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
    }

References Socket< T >::_readBuffer, Socket< T >::_socket, MessageBuffer::EnsureFreeSpace(), MessageBuffer::GetRemainingSpace(), MessageBuffer::GetWritePointer(), Socket< T >::IsOpen(), and MessageBuffer::Normalize().

AsyncReadWithCallback()

template<class T >

void Socket< T >::AsyncReadWithCallback ( void(T::*)(boost::system::error_code, std::size_t)  callback )

inline

    {
        if (!IsOpen())
        {
            return;
        }
 
        _readBuffer.Normalize();
        _readBuffer.EnsureFreeSpace();
 
        _socket.async_read_some(boost::asio::buffer(_readBuffer.GetWritePointer(), _readBuffer.GetRemainingSpace()),
            std::bind(callback, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
    }

References Socket< T >::_readBuffer, Socket< T >::_socket, MessageBuffer::EnsureFreeSpace(), MessageBuffer::GetRemainingSpace(), MessageBuffer::GetWritePointer(), Socket< T >::IsOpen(), and MessageBuffer::Normalize().

CloseSocket()

template<class T >

void Socket< T >::CloseSocket ( )

inline

    {
        if (_closed.exchange(true))
            return;
 
        boost::system::error_code shutdownError;
        _socket.shutdown(boost::asio::socket_base::shutdown_send, shutdownError);
 
        if (shutdownError)
            LOG_DEBUG("network", "Socket::CloseSocket: {} errored when shutting down socket: {} ({})", GetRemoteIpAddress().to_string(),
                shutdownError.value(), shutdownError.message());
 
        OnClose();
    }

References Socket< T >::_closed, Socket< T >::_socket, Socket< T >::GetRemoteIpAddress(), LOG_DEBUG, and Socket< T >::OnClose().

Referenced by Socket< T >::HandleQueue(), and Socket< T >::ReadHandlerInternal().

DelayedCloseSocket()

template<class T >

void Socket< T >::DelayedCloseSocket ( )

inline

Marks the socket for closing after write buffer becomes empty.

{ _closing = true; }

References Socket< T >::_closing.

GetReadBuffer()

template<class T >

MessageBuffer & Socket< T >::GetReadBuffer ( )

inline

{ return _readBuffer; }

References Socket< T >::_readBuffer.

GetRemoteIpAddress()

template<class T >

boost::asio::ip::address Socket< T >::GetRemoteIpAddress ( ) const

inline

    {
        return _remoteAddress;
    }

References Socket< T >::_remoteAddress.

Referenced by Socket< T >::CloseSocket(), and Socket< T >::SetNoDelay().

GetRemotePort()

template<class T >

uint16 Socket< T >::GetRemotePort ( ) const

inline

    {
        return _remotePort;
    }

References Socket< T >::_remotePort.

HandleQueue()

template<class T >

bool Socket< T >::HandleQueue ( )

inlineprivate

    {
        if (_writeQueue.empty())
            return false;
 
        MessageBuffer& queuedMessage = _writeQueue.front();
 
        std::size_t bytesToSend = queuedMessage.GetActiveSize();
 
        boost::system::error_code error;
        std::size_t bytesSent = _socket.write_some(boost::asio::buffer(queuedMessage.GetReadPointer(), bytesToSend), error);
 
        if (error)
        {
            if (error == boost::asio::error::would_block || error == boost::asio::error::try_again)
            {
                return AsyncProcessQueue();
            }
 
            _writeQueue.pop();
 
            if (_closing && _writeQueue.empty())
            {
                CloseSocket();
            }
 
            return false;
        }
        else if (bytesSent == 0)
        {
            _writeQueue.pop();
 
            if (_closing && _writeQueue.empty())
            {
                CloseSocket();
            }
 
            return false;
        }
        else if (bytesSent < bytesToSend) // now n > 0
        {
            queuedMessage.ReadCompleted(bytesSent);
            return AsyncProcessQueue();
        }
 
        _writeQueue.pop();
 
        if (_closing && _writeQueue.empty())
        {
            CloseSocket();
        }
 
        return !_writeQueue.empty();
    }

References Socket< T >::_closing, Socket< T >::_socket, Socket< T >::_writeQueue, Socket< T >::AsyncProcessQueue(), Socket< T >::CloseSocket(), MessageBuffer::GetActiveSize(), MessageBuffer::GetReadPointer(), and MessageBuffer::ReadCompleted().

Referenced by Socket< T >::Update(), and Socket< T >::WriteHandlerWrapper().

IsOpen()

template<class T >

bool Socket< T >::IsOpen ( ) const

inline

{ return !_closed && !_closing; }

References Socket< T >::_closed, and Socket< T >::_closing.

Referenced by Socket< T >::AsyncRead(), and Socket< T >::AsyncReadWithCallback().

OnClose()

template<class T >

virtual void Socket< T >::OnClose ( )

inlineprotectedvirtual

Reimplemented in WorldSocket.

{ }

Referenced by Socket< T >::CloseSocket().

QueuePacket()

template<class T >

void Socket< T >::QueuePacket ( MessageBuffer &&  buffer )

inline

    {
        _writeQueue.push(std::move(buffer));
 
#ifdef AC_SOCKET_USE_IOCP
        AsyncProcessQueue();
#endif
    }

References Socket< T >::_writeQueue, and Socket< T >::AsyncProcessQueue().

ReadHandler()

template<class T >

virtual void Socket< T >::ReadHandler ( )

protectedpure virtual

Implemented in AuthSession, and WorldSocket.

Referenced by Socket< T >::ReadHandlerInternal().

ReadHandlerInternal()

template<class T >

void Socket< T >::ReadHandlerInternal ( boost::system::error_code  error, size_t  transferredBytes  )

inlineprivate

    {
        if (error)
        {
            CloseSocket();
            return;
        }
 
        _readBuffer.WriteCompleted(transferredBytes);
        ReadHandler();
    }

References Socket< T >::_readBuffer, Socket< T >::CloseSocket(), Socket< T >::ReadHandler(), and MessageBuffer::WriteCompleted().

SetNoDelay()

template<class T >

void Socket< T >::SetNoDelay ( bool  enable )

inlineprotected

    {
        boost::system::error_code err;
        _socket.set_option(tcp::no_delay(enable), err);
 
        if (err)
            LOG_DEBUG("network", "Socket::SetNoDelay: failed to set_option(boost::asio::ip::tcp::no_delay) for {} - {} ({})",
                GetRemoteIpAddress().to_string(), err.value(), err.message());
    }

References Socket< T >::_socket, Socket< T >::GetRemoteIpAddress(), and LOG_DEBUG.

Start()

template<class T >

virtual void Socket< T >::Start ( )

pure virtual

Implemented in AuthSession, and WorldSocket.

Update()

template<class T >

virtual bool Socket< T >::Update ( )

inlinevirtual

Reimplemented in AuthSession, and WorldSocket.

    {
        if (_closed)
        {
            return false;
        }
 
#ifndef AC_SOCKET_USE_IOCP
        if (_isWritingAsync || (_writeQueue.empty() && !_closing))
        {
            return true;
        }
 
        for (; HandleQueue();)
            ;
#endif
 
        return true;
    }

References Socket< T >::_closed, Socket< T >::_closing, Socket< T >::_isWritingAsync, Socket< T >::_writeQueue, and Socket< T >::HandleQueue().

WriteHandlerWrapper()

template<class T >

void Socket< T >::WriteHandlerWrapper ( boost::system::error_code  , std::size_t    )

inlineprivate

    {
        _isWritingAsync = false;
        HandleQueue();
    }

References Socket< T >::_isWritingAsync, and Socket< T >::HandleQueue().

Member Data Documentation

_closed

template<class T >

std::atomic<bool> Socket< T >::_closed

private

Referenced by Socket< T >::CloseSocket(), Socket< T >::IsOpen(), Socket< T >::Update(), and Socket< T >::~Socket().

_closing

template<class T >

std::atomic<bool> Socket< T >::_closing

private

Referenced by Socket< T >::DelayedCloseSocket(), Socket< T >::HandleQueue(), Socket< T >::IsOpen(), and Socket< T >::Update().

_isWritingAsync

template<class T >

bool Socket< T >::_isWritingAsync

private

Referenced by Socket< T >::AsyncProcessQueue(), Socket< T >::Update(), and Socket< T >::WriteHandlerWrapper().

_readBuffer

template<class T >

MessageBuffer Socket< T >::_readBuffer

private

Referenced by Socket< T >::AsyncRead(), Socket< T >::AsyncReadWithCallback(), Socket< T >::GetReadBuffer(), Socket< T >::ReadHandlerInternal(), and Socket< T >::Socket().

_remoteAddress

template<class T >

boost::asio::ip::address Socket< T >::_remoteAddress

private

Referenced by Socket< T >::GetRemoteIpAddress().

_remotePort

template<class T >

uint16 Socket< T >::_remotePort

private

Referenced by Socket< T >::GetRemotePort().

_socket

template<class T >

tcp::socket Socket< T >::_socket

private

Referenced by Socket< T >::AsyncProcessQueue(), Socket< T >::AsyncRead(), Socket< T >::AsyncReadWithCallback(), Socket< T >::CloseSocket(), Socket< T >::HandleQueue(), Socket< T >::SetNoDelay(), and Socket< T >::~Socket().

_writeQueue

template<class T >

std::queue<MessageBuffer> Socket< T >::_writeQueue

private

Referenced by Socket< T >::AsyncProcessQueue(), Socket< T >::HandleQueue(), Socket< T >::QueuePacket(), and Socket< T >::Update().