epee::levin::levin_client_async Class Reference

#include <levin_client_async.h>

Public Member Functions
	levin_client_async ()
	levin_client_async (const levin_client_async &)
	~levin_client_async ()
void	set_handler (levin_commands_handler *phandler, void(*destroy)(levin_commands_handler *)=NULL)
bool	connect (uint32_t ip, uint32_t port, uint32_t timeout)
bool	is_connected ()
bool	check_connection ()
bool	recv_n (SOCKET s, char *pbuff, size_t cb)
bool	recv_n (SOCKET s, std::string &buff)
bool	disconnect ()
void	loop_call_guard ()
void	on_leave_invoke ()
int	invoke (const GUID &target, int command, const std::string &in_buff, std::string &buff_out)
int	notify (const GUID &target, int command, const std::string &in_buff)

Detailed Description

Definition at line 52 of file levin_client_async.h.

Constructor & Destructor Documentation

levin_client_async() [1/2]

epee::levin::levin_client_async::levin_client_async ( )

inline

Definition at line 89 of file levin_client_async.h.

                            :m_pcommands_handler(NULL), commands_handler_destroy(NULL), m_is_stop(0), m_threads_count(0), m_invoke_data_ready(0), m_invoke_is_active(0)
        {}

levin_client_async() [2/2]

epee::levin::levin_client_async::levin_client_async ( const levin_client_async & )

inline

Definition at line 91 of file levin_client_async.h.

                                                       :m_pcommands_handler(NULL), commands_handler_destroy(NULL), m_is_stop(0), m_threads_count(0), m_invoke_data_ready(0), m_invoke_is_active(0)
        {}

~levin_client_async()

epee::levin::levin_client_async::~levin_client_async ( )

inline

Definition at line 93 of file levin_client_async.h.

        {
      boost::interprocess::ipcdetail::atomic_write32(&m_is_stop, 1);
      disconnect();
 
 
            while(boost::interprocess::ipcdetail::atomic_read32(&m_threads_count))
                ::Sleep(100);
 
            set_handler(NULL);
        }

Member Function Documentation

check_connection()

bool epee::levin::levin_client_async::check_connection ( )

inline

Definition at line 144 of file levin_client_async.h.

        {
            loop_call_guard();
            critical_region cr(m_cs);
 
            if(!is_connected())
            {
                if( !reconnect() )
                {
                    LOG_ERROR("Reconnect Failed. Failed to invoke() because not connected!");
                    return false;
                }
            }
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

connect()

bool epee::levin::levin_client_async::connect ( uint32_t ip, uint32_t port, uint32_t timeout )

inline

Definition at line 113 of file levin_client_async.h.

        {
            loop_call_guard();
            critical_region cr(m_connection_lock);
 
            m_timeout = timeout;
            bool res = false;
            CRITICAL_REGION_BEGIN(m_reciev_packet_lock);
            CRITICAL_REGION_BEGIN(m_send_lock);
            res = levin_client_impl::connect(ip, port, timeout);
            boost::interprocess::ipcdetail::atomic_inc32(&m_current_connection_index); 
            CRITICAL_REGION_END();
            CRITICAL_REGION_END();
            if(res && !boost::interprocess::ipcdetail::atomic_read32(&m_threads_count) )
            {
                //boost::interprocess::ipcdetail::atomic_write32(&m_is_stop, 0);//m_is_stop = false;
                boost::thread( boost::bind(&levin_duplex_client::reciever_thread, this) );
                boost::thread( boost::bind(&levin_duplex_client::handler_thread, this) );
                boost::thread( boost::bind(&levin_duplex_client::handler_thread, this) );
            }
 
            return res;
        }

disconnect()

bool epee::levin::levin_client_async::disconnect ( )

inline

Definition at line 201 of file levin_client_async.h.

        {
            //boost::interprocess::ipcdetail::atomic_write32(&m_is_stop, 1);//m_is_stop = true;
            loop_call_guard();
            critical_region cr(m_cs);           
            levin_client_impl::disconnect();
 
            CRITICAL_REGION_BEGIN(m_local_invoke_buff_lock);
            m_local_invoke_buff.clear();
            m_invoke_res = LEVIN_ERROR_CONNECTION_DESTROYED;
            CRITICAL_REGION_END();
            boost::interprocess::ipcdetail::atomic_write32(&m_invoke_data_ready, 1); //m_invoke_data_ready = true;
            m_invoke_cond.notify_all();
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

invoke()

int epee::levin::levin_client_async::invoke ( const GUID & target, int command, const std::string & in_buff, std::string & buff_out )

inline

Definition at line 227 of file levin_client_async.h.

        {
 
            critical_region cr_invoke(m_invoke_lock);
 
            boost::interprocess::ipcdetail::atomic_write32(&m_invoke_is_active, 1);
            boost::interprocess::ipcdetail::atomic_write32(&m_invoke_data_ready, 0);
            misc_utils::destr_ptr hdlr = misc_utils::add_exit_scope_handler(boost::bind(&levin_duplex_client::on_leave_invoke, this));
 
            loop_call_guard();
            
            if(!check_connection())             
                return LEVIN_ERROR_CONNECTION_DESTROYED;
 
 
            bucket_head head = {0};
            head.m_signature = LEVIN_SIGNATURE;
            head.m_cb = in_buff.size();
            head.m_have_to_return_data = true;
            head.m_id = target;
#ifdef TRACE_LEVIN_PACKETS_BY_GUIDS
            ::UuidCreate(&head.m_id);
#endif
            head.m_command = command;
            head.m_protocol_version = LEVIN_PROTOCOL_VER_1;
            head.m_flags = LEVIN_PACKET_REQUEST;
            LOG_PRINT("[" << m_socket <<"] Sending invoke data", LOG_LEVEL_4);
 
            CRITICAL_REGION_BEGIN(m_send_lock);
            LOG_PRINT_L4("[" << m_socket <<"] SEND " << sizeof(head));
            int res = ::send(m_socket, (const char*)&head, sizeof(head), 0);
            if(SOCKET_ERROR == res)
            {
                int err = ::WSAGetLastError();
                LOG_ERROR("Failed to send(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
                disconnect();
                return LEVIN_ERROR_CONNECTION_DESTROYED;
            }
            LOG_PRINT_L4("[" << m_socket <<"] SEND " << (int)in_buff.size());
            res = ::send(m_socket, in_buff.data(), (int)in_buff.size(), 0);
            if(SOCKET_ERROR == res)
            {
                int err = ::WSAGetLastError();
                LOG_ERROR("Failed to send(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
                disconnect();
                return LEVIN_ERROR_CONNECTION_DESTROYED;
            }
            CRITICAL_REGION_END();
            LOG_PRINT_L4("LEVIN_PACKET_SENT. [len=" << head.m_cb << ", flags=" << head.m_flags << ", is_cmd=" << head.m_have_to_return_data <<", cmd_id = " << head.m_command << ", pr_v=" << head.m_protocol_version << ", uid=" << string_tools::get_str_from_guid_a(head.m_id) << "]");
 
            //hard coded timeout in 10 minutes for maximum invoke period. if it happens, it could mean only some real troubles.
            boost::system_time timeout = boost::get_system_time()+ boost::posix_time::milliseconds(100);
            size_t timeout_count = 0;
            boost::unique_lock<boost::mutex> lock(m_invoke_event);
 
            while(!boost::interprocess::ipcdetail::atomic_read32(&m_invoke_data_ready))    
            {
                if(!m_invoke_cond.timed_wait(lock, timeout))
                {
                    if(timeout_count < 10)
                    {
                        //workaround to avoid freezing at timed_wait called after notify_all. 
                        timeout = boost::get_system_time()+ boost::posix_time::milliseconds(100);
                        ++timeout_count;
                        continue;
                    }else if(timeout_count == 10)
                    {
                        //workaround to avoid freezing at timed_wait called after notify_all. 
                        timeout = boost::get_system_time()+ boost::posix_time::minutes(10);
                        ++timeout_count;
                        continue;
                    }else
                    {
                        LOG_PRINT("[" << m_socket <<"] Timeout on waiting invoke result. ", LOG_LEVEL_0);
                        //disconnect();
                        return LEVIN_ERROR_CONNECTION_TIMEDOUT; 
                    }
                }
            }
            
            
            CRITICAL_REGION_BEGIN(m_local_invoke_buff_lock);
            buff_out.swap(m_local_invoke_buff);
            m_local_invoke_buff.clear();
            CRITICAL_REGION_END();
            return m_invoke_res;
        }   

Here is the call graph for this function:

Here is the caller graph for this function:

is_connected()

bool epee::levin::levin_client_async::is_connected ( )

inline

Definition at line 136 of file levin_client_async.h.

        {
            loop_call_guard();
            critical_region cr(m_cs);
            return levin_client_impl::is_connected();
        }

loop_call_guard()

void epee::levin::levin_client_async::loop_call_guard ( )

inline

Definition at line 217 of file levin_client_async.h.

        {
 
        }

Here is the caller graph for this function:

notify()

int epee::levin::levin_client_async::notify ( const GUID & target, int command, const std::string & in_buff )

inline

Definition at line 315 of file levin_client_async.h.

        {
            if(!check_connection())
                return LEVIN_ERROR_CONNECTION_DESTROYED;
 
            bucket_head head = {0};
            head.m_signature = LEVIN_SIGNATURE;
            head.m_cb = in_buff.size();
            head.m_have_to_return_data = false;
            head.m_id = target;
#ifdef TRACE_LEVIN_PACKETS_BY_GUIDS
            ::UuidCreate(&head.m_id);
#endif
            head.m_command = command;
            head.m_protocol_version = LEVIN_PROTOCOL_VER_1;
            head.m_flags = LEVIN_PACKET_REQUEST;
            CRITICAL_REGION_BEGIN(m_send_lock);
            LOG_PRINT_L4("[" << m_socket <<"] SEND " << sizeof(head));
            int res = ::send(m_socket, (const char*)&head, sizeof(head), 0);
            if(SOCKET_ERROR == res)
            {
                int err = ::WSAGetLastError();
                LOG_ERROR("Failed to send(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
                disconnect();
                return LEVIN_ERROR_CONNECTION_DESTROYED;
            }
            LOG_PRINT_L4("[" << m_socket <<"] SEND " << (int)in_buff.size());
            res = ::send(m_socket, in_buff.data(), (int)in_buff.size(), 0);
            if(SOCKET_ERROR == res)
            {
                int err = ::WSAGetLastError();
                LOG_ERROR("Failed to send(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
                disconnect();
                return LEVIN_ERROR_CONNECTION_DESTROYED;
            }
            CRITICAL_REGION_END();
            LOG_PRINT_L4("LEVIN_PACKET_SENT. [len=" << head.m_cb << ", flags=" << head.m_flags << ", is_cmd=" << head.m_have_to_return_data <<", cmd_id = " << head.m_command << ", pr_v=" << head.m_protocol_version << ", uid=" << string_tools::get_str_from_guid_a(head.m_id) << "]");
 
            return 1;
        }

Here is the call graph for this function:

on_leave_invoke()

void epee::levin::levin_client_async::on_leave_invoke ( )

inline

Definition at line 222 of file levin_client_async.h.

        {
            boost::interprocess::ipcdetail::atomic_write32(&m_invoke_is_active, 0);
        }

recv_n() [1/2]

bool epee::levin::levin_client_async::recv_n ( SOCKET s, char * pbuff, size_t cb )

inline

Definition at line 162 of file levin_client_async.h.

        {
            while(cb)
            {
                int res = ::recv(m_socket, pbuff, (int)cb, 0);
 
                if(SOCKET_ERROR == res)
                {
                    if(!m_connected)
                        return false;
 
                    int err = ::WSAGetLastError();
                    LOG_ERROR("Failed to recv(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
                    disconnect();
                    //reconnect();
                    return false;
                }else if(res == 0)
                {
                    disconnect();
                    //reconnect();
                    return false;
                }
                LOG_PRINT_L4("[" << m_socket <<"] RECV " << res);
                cb -= res;
                pbuff += res;
            }
 
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

recv_n() [2/2]

bool epee::levin::levin_client_async::recv_n ( SOCKET s, std::string & buff )

inline

Definition at line 194 of file levin_client_async.h.

        {   
            size_t cb_remain = buff.size();
            char*  m_current_ptr = (char*)buff.data();
            return recv_n(s, m_current_ptr, cb_remain);
        }

Here is the call graph for this function:

set_handler()

void epee::levin::levin_client_async::set_handler ( levin_commands_handler * phandler, void(* destroy )(levin_commands_handler *) = NULL )

inline

Definition at line 105 of file levin_client_async.h.

        {
            if (commands_handler_destroy && m_pcommands_handler)
                (*commands_handler_destroy)(m_pcommands_handler);
            m_pcommands_handler = phandler;
            m_pcommands_handler_destroy = destroy;
        }

---

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

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/contrib/epee/include/net/levin_client_async.h