#include <levin_protocol_handler_async.h>

Inheritance diagram for epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >:

Collaboration diagram for epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >:

Public Member Functions
	anvoke_handler (const callback_t &cb, uint64_t timeout, async_protocol_handler &con, int command)
virtual	~anvoke_handler ()
virtual bool	handle (int res, const epee::span< const uint8_t > buff, typename async_protocol_handler::connection_context &context)
virtual bool	is_timer_started () const
virtual void	cancel ()
virtual bool	cancel_timer ()
virtual void	reset_timer ()

Public Attributes
callback_t	m_cb
async_protocol_handler &	m_con
boost::asio::deadline_timer	m_timer
bool	m_timer_started
bool	m_cancel_timer_called
bool	m_timer_cancelled
uint64_t	m_timeout
int	m_command

Detailed Description

template<class t_connection_context = net_utils::connection_context_base>
template<class callback_t>
struct epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >

Definition at line 162 of file levin_protocol_handler_async.h.

Constructor & Destructor Documentation

◆ anvoke_handler()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::anvoke_handler	(	const callback_t &	cb,
		uint64_t	timeout,
		async_protocol_handler &	con,
		int	command )

inline

Definition at line 164 of file levin_protocol_handler_async.h.

      :m_cb(cb), m_timeout(timeout), m_con(con), m_timer(con.m_pservice_endpoint->get_io_service()), m_timer_started(false),
      m_cancel_timer_called(false), m_timer_cancelled(false), m_command(command)
    {
      if(m_con.start_outer_call())
      {
        MDEBUG(con.get_context_ref() << "anvoke_handler, timeout: " << timeout);
        m_timer.expires_from_now(boost::posix_time::milliseconds(timeout));
        m_timer.async_wait([&con, command, cb, timeout](const boost::system::error_code& ec)
        {
          if(ec == boost::asio::error::operation_aborted)
            return;
          MINFO(con.get_context_ref() << "Timeout on invoke operation happened, command: " << command << " timeout: " << timeout);
          epee::span<const uint8_t> fake;
          cb(LEVIN_ERROR_CONNECTION_TIMEDOUT, fake, con.get_context_ref());
          con.close();
          con.finish_outer_call();
        });
        m_timer_started = true;
      }
    }

Here is the call graph for this function:

◆ ~anvoke_handler()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

virtual epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::~anvoke_handler ( )

inlinevirtual

Definition at line 185 of file levin_protocol_handler_async.h.

186 {}

Member Function Documentation

◆ cancel()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

virtual void epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::cancel ( )

inlinevirtual

Implements epee::levin::async_protocol_handler< t_connection_context >::invoke_response_handler_base.

Definition at line 207 of file levin_protocol_handler_async.h.

    {
      if(cancel_timer())
      {
        epee::span<const uint8_t> fake;
        m_cb(LEVIN_ERROR_CONNECTION_DESTROYED, fake, m_con.get_context_ref());
        m_con.finish_outer_call();
      }
    }

Here is the call graph for this function:

◆ cancel_timer()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

virtual bool epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::cancel_timer ( )

inlinevirtual

Implements epee::levin::async_protocol_handler< t_connection_context >::invoke_response_handler_base.

Definition at line 216 of file levin_protocol_handler_async.h.

    {
      if(!m_cancel_timer_called)
      {
        m_cancel_timer_called = true;
        boost::system::error_code ignored_ec;
        m_timer_cancelled = 1 == m_timer.cancel(ignored_ec);
      }
      return m_timer_cancelled;
    }

Here is the caller graph for this function:

◆ handle()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

virtual bool epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::handle	(	int	res,
		const epee::span< const uint8_t >	buff,
		typename async_protocol_handler::connection_context &	context )

inlinevirtual

Implements epee::levin::async_protocol_handler< t_connection_context >::invoke_response_handler_base.

Definition at line 195 of file levin_protocol_handler_async.h.

    {
      if(!cancel_timer())
        return false;
      m_cb(res, buff, context);
      m_con.finish_outer_call();
      return true;
    }

Here is the call graph for this function:

◆ is_timer_started()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

virtual bool epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::is_timer_started ( ) const

inlinevirtual

Implements epee::levin::async_protocol_handler< t_connection_context >::invoke_response_handler_base.

Definition at line 203 of file levin_protocol_handler_async.h.

    {
      return m_timer_started;
    }

◆ reset_timer()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

virtual void epee::levin::async_protocol_handler< t_connection_context >::anvoke_handler< callback_t >::reset_timer ( )

inlinevirtual

Implements epee::levin::async_protocol_handler< t_connection_context >::invoke_response_handler_base.

Definition at line 226 of file levin_protocol_handler_async.h.

    {
      boost::system::error_code ignored_ec;
      if (!m_cancel_timer_called && m_timer.cancel(ignored_ec) > 0)
      {
        callback_t& cb = m_cb;
        uint64_t timeout = m_timeout;
        async_protocol_handler& con = m_con;
        int command = m_command;
        m_timer.expires_from_now(boost::posix_time::milliseconds(m_timeout));
        m_timer.async_wait([&con, cb, command, timeout](const boost::system::error_code& ec)
        {
          if(ec == boost::asio::error::operation_aborted)
            return;
          MINFO(con.get_context_ref() << "Timeout on invoke operation happened, command: " << command << " timeout: " << timeout);
          epee::span<const uint8_t> fake;
          cb(LEVIN_ERROR_CONNECTION_TIMEDOUT, fake, con.get_context_ref());
          con.close();
          con.finish_outer_call();
        });
      }
    }