fc::rpc::websocket_api_connection Class Reference

#include <websocket_api.hpp>

Inheritance diagram for fc::rpc::websocket_api_connection:

Collaboration diagram for fc::rpc::websocket_api_connection:

Public Member Functions
	websocket_api_connection (fc::http::websocket_connection &c)
	~websocket_api_connection ()
virtual variant	send_call (api_id_type api_id, string method_name, variants args=variants()) override
virtual variant	send_callback (uint64_t callback_id, variants args=variants()) override
virtual void	send_notice (uint64_t callback_id, variants args=variants()) override
Public Member Functions inherited from fc::api_connection
	api_connection ()
virtual	~api_connection ()
template<typename T >
api< T >	get_remote_api (api_id_type api_id=0)
variant	receive_call (api_id_type api_id, const string &method_name, const variants &args=variants()) const
variant	receive_callback (uint64_t callback_id, const variants &args=variants()) const
void	receive_notice (uint64_t callback_id, const variants &args=variants()) const
template<typename Interface >
api_id_type	register_api (const Interface &a)
template<typename Signature >
uint64_t	register_callback (const std::function< Signature > &cb)
std::vector< std::string >	get_method_names (api_id_type local_api_id=0) const

Protected Member Functions
std::string	on_message (const std::string &message, bool send_message=true)

Protected Attributes
fc::http::websocket_connection &	_connection
fc::rpc::state	_rpc_state

Additional Inherited Members
Public Attributes inherited from fc::api_connection
fc::signal< void()>	closed

Detailed Description

Definition at line 10 of file websocket_api.hpp.

Constructor & Destructor Documentation

websocket_api_connection()

fc::rpc::websocket_api_connection::websocket_api_connection

(

fc::http::websocket_connection &

c

)

Definition at line 10 of file websocket_api.cpp.

   : _connection(c)
{
   _rpc_state.add_method( "call", [this]( const variants& args ) -> variant
   {
      FC_ASSERT( args.size() == 3 && args[2].is_array() );
      api_id_type api_id;
      if( args[0].is_string() )
      {
         variants subargs;
         subargs.push_back( args[0] );
         variant subresult = this->receive_call( 1, "get_api_by_name", subargs );
         api_id = subresult.as_uint64();
      }
      else
         api_id = args[0].as_uint64();
 
      return this->receive_call(
         api_id,
         args[1].as_string(),
         args[2].get_array() );
   } );
 
   _rpc_state.add_method( "notice", [this]( const variants& args ) -> variant
   {
      FC_ASSERT( args.size() == 2 && args[1].is_array() );
      this->receive_notice( args[0].as_uint64(), args[1].get_array() );
      return variant();
   } );
 
   _rpc_state.add_method( "callback", [this]( const variants& args ) -> variant
   {
      FC_ASSERT( args.size() == 2 && args[1].is_array() );
      this->receive_callback( args[0].as_uint64(), args[1].get_array() );
      return variant();
   } );
 
   _rpc_state.on_unhandled( [&]( const std::string& method_name, const variants& args )
   {
      return this->receive_call( 0, method_name, args );
   } );
 
   _connection.on_message_handler( [&]( const std::string& msg ){ on_message(msg,true); } );
   _connection.on_http_handler( [&]( const std::string& msg ){ return on_message(msg,false); } );
   _connection.closed.connect( [this](){ closed(); } );
}

Here is the call graph for this function:

~websocket_api_connection()

fc::rpc::websocket_api_connection::~websocket_api_connection

(

)

Definition at line 6 of file websocket_api.cpp.

{
}

Member Function Documentation

on_message()

std::string fc::rpc::websocket_api_connection::on_message ( const std::string & message, bool send_message = true )

protected

Definition at line 84 of file websocket_api.cpp.

{
   wdump((message));
 
   auto handle_error = [&](const auto& e)
   {
      wdump((e.to_detail_string()));
      return e.to_detail_string();
   };
 
   try
   {
      auto var = fc::json::from_string(message);
      const auto& var_obj = var.get_object();
      if( var_obj.contains( "method" ) )
      {
         auto call = var.as<fc::rpc::request>();
         exception_ptr optexcept;
 
         auto handle_error_inner = [&](const auto& e)
         {
           if (!call.id)
           {
             return nullptr;
           }
 
           return e.dynamic_copy_exception();
         };
 
         try
         {
            auto result = _rpc_state.local_call( call.method, call.params );
            if( call.id )
            {
               auto reply = fc::json::to_string( response( *call.id, result ) );
               if( send_message )
                  _connection.send_message( reply );
               return reply;
            }
         }
         catch ( const std::bad_alloc& ) 
         {
            throw;
         } 
         catch ( const boost::interprocess::bad_alloc& ) 
         {
            throw;
         } 
         catch ( const fc::exception& e )
         {
            optexcept = handle_error_inner(e);
         }
         catch ( const std::exception& e )
         {
            optexcept = handle_error_inner(fc::std_exception_wrapper::from_current_exception(e));
         }
 
         if( optexcept ) {
 
               auto reply = fc::json::to_string( response( *call.id,  error_object{ 1, optexcept->to_detail_string(), fc::variant(*optexcept)}  ) );
               if( send_message )
                  _connection.send_message( reply );
 
               return reply;
         }
      }
      else
      {
         auto reply = var.as<fc::rpc::response>();
         _rpc_state.handle_reply( reply );
      }
   }
   catch ( const std::bad_alloc& ) 
   {
     throw;
   } 
   catch ( const boost::interprocess::bad_alloc& ) 
   {
     throw;
   } 
   catch ( const fc::exception& e )
   {
     return handle_error(e);
   }
   catch ( const std::exception& e)
   {
     return handle_error(fc::std_exception_wrapper::from_current_exception(e));
   }
   return string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_call()

variant fc::rpc::websocket_api_connection::send_call ( api_id_type api_id, string method_name, variants args = variants() )

overridevirtual

makes calls to the remote server

Implements fc::api_connection.

Definition at line 57 of file websocket_api.cpp.

{
   auto request = _rpc_state.start_remote_call(  "call", {api_id, std::move(method_name), std::move(args) } );
   _connection.send_message( fc::json::to_string(request) );
   return _rpc_state.wait_for_response( *request.id );
}

Here is the call graph for this function:

send_callback()

variant fc::rpc::websocket_api_connection::send_callback ( uint64_t callback_id, variants args = variants() )

overridevirtual

Implements fc::api_connection.

Definition at line 67 of file websocket_api.cpp.

{
   auto request = _rpc_state.start_remote_call( "callback", {callback_id, std::move(args) } );
   _connection.send_message( fc::json::to_string(request) );
   return _rpc_state.wait_for_response( *request.id );
}

Here is the call graph for this function:

send_notice()

void fc::rpc::websocket_api_connection::send_notice ( uint64_t callback_id, variants args = variants() )

overridevirtual

Implements fc::api_connection.

Definition at line 76 of file websocket_api.cpp.

{
   fc::rpc::request req{ std::optional<uint64_t>(), "notice", {callback_id, std::move(args)}};
   _connection.send_message( fc::json::to_string(req) );
}

Here is the call graph for this function:

Member Data Documentation

_connection

fc::http::websocket_connection& fc::rpc::websocket_api_connection::_connection

protected

Definition at line 32 of file websocket_api.hpp.

_rpc_state

fc::rpc::state fc::rpc::websocket_api_connection::_rpc_state

protected

Definition at line 33 of file websocket_api.hpp.

---

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

• libraries/fc/include/fc/rpc/websocket_api.hpp
• libraries/fc/src/rpc/websocket_api.cpp