sysio::http_plugin Class Reference

#include <http_plugin.hpp>

Inheritance diagram for sysio::http_plugin:

Collaboration diagram for sysio::http_plugin:

Classes
struct	get_supported_apis_result

Public Member Functions
	http_plugin ()
virtual	~http_plugin ()
virtual void	set_program_options (options_description &, options_description &cfg) override
void	plugin_initialize (const variables_map &options)
void	plugin_startup ()
void	plugin_shutdown ()
void	handle_sighup () override
void	add_handler (const string &url, const url_handler &, int priority=appbase::priority::medium_low)
void	add_api (const api_description &api, int priority=appbase::priority::medium_low)
void	add_async_handler (const string &url, const url_handler &handler)
void	add_async_api (const api_description &api)
bool	is_on_loopback () const
bool	is_secure () const
bool	verbose_errors () const
get_supported_apis_result	get_supported_apis () const
fc::microseconds	get_max_response_time () const
Public Member Functions inherited from appbase::plugin< http_plugin >
	plugin ()
virtual	~plugin ()
virtual state	get_state () const override
virtual const std::string &	name () const override
virtual void	register_dependencies ()
virtual void	initialize (const variables_map &options) override
virtual void	startup () override
virtual void	shutdown () override
Public Member Functions inherited from appbase::abstract_plugin
virtual	~abstract_plugin ()

Static Public Member Functions
static void	set_defaults (const http_plugin_defaults config)
static void	handle_exception (const char *api_name, const char *call_name, const string &body, url_response_callback cb)

Additional Inherited Members
Public Types inherited from appbase::abstract_plugin
enum	state { registered , initialized , started , stopped }
Protected Member Functions inherited from appbase::plugin< http_plugin >
	plugin (const string &name)

Detailed Description

This plugin starts an HTTP server and dispatches queries to registered handles based upon URL. The handler is passed the URL that was requested and a callback method that should be called with the response code and body.

The handler will be called from the appbase application io_service thread. The callback can be called from any thread and will automatically propagate the call to the http thread.

The HTTP service will run in its own thread with its own io_service to make sure that HTTP request processing does not interfer with other plugins.

Definition at line 64 of file http_plugin.hpp.

Constructor & Destructor Documentation

http_plugin()

sysio::http_plugin::http_plugin

(

)

Definition at line 632 of file http_plugin.cpp.

                           :my(new http_plugin_impl()){
      app().register_config_type<https_ecdh_curve_t>();
   }

Here is the call graph for this function:

~http_plugin()

sysio::http_plugin::~http_plugin ( )

virtual

Definition at line 635 of file http_plugin.cpp.

{}

Member Function Documentation

add_api()

void sysio::http_plugin::add_api ( const api_description & api, int priority = appbase::priority::medium_low )

inline

Definition at line 82 of file http_plugin.hpp.

                                                                                           {
           for (const auto& call : api)
              add_handler(call.first, call.second, priority);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

add_async_api()

void sysio::http_plugin::add_async_api ( const api_description & api )

inline

Definition at line 88 of file http_plugin.hpp.

                                                       {
           for (const auto& call : api)
              add_handler(call.first, call.second);
        }

Here is the call graph for this function:

add_async_handler()

void sysio::http_plugin::add_async_handler	(	const string &	url,
		const url_handler &	handler )

Definition at line 923 of file http_plugin.cpp.

                                                                                    {
      fc_ilog( logger, "add api url: ${c}", ("c", url) );
      my->url_handlers[url] = my->make_http_thread_url_handler(handler);
   }

add_handler()

void sysio::http_plugin::add_handler	(	const string &	url,
		const url_handler &	handler,
		int	priority = appbase::priority::medium_low )

Definition at line 918 of file http_plugin.cpp.

                                                                                            {
      fc_ilog( logger, "add api url: ${c}", ("c", url) );
      my->url_handlers[url] = my->make_app_thread_url_handler(priority, handler, my);
   }

Here is the caller graph for this function:

get_max_response_time()

fc::microseconds sysio::http_plugin::get_max_response_time

(

)

const

Returns

the configured http-max-response-time-ms

Definition at line 995 of file http_plugin.cpp.

                                                          {
      return my->max_response_time;
   }

get_supported_apis()

http_plugin::get_supported_apis_result sysio::http_plugin::get_supported_apis

(

)

const

Definition at line 984 of file http_plugin.cpp.

                                                                             {
      get_supported_apis_result result;
 
      for (const auto& handler : my->url_handlers) {
         if (handler.first != "/v1/node/get_supported_apis")
            result.apis.emplace_back(handler.first);
      }
 
      return result;
   }

handle_exception()

void sysio::http_plugin::handle_exception ( const char * api_name, const char * call_name, const string & body, url_response_callback cb )

static

Definition at line 928 of file http_plugin.cpp.

                                                                                                                                 {
      try {
         try {
            throw;
         } catch (chain::unknown_block_exception& e) {
            error_results results{400, "Unknown Block", error_results::error_info(e, verbose_http_errors)};
            cb( 400, fc::variant( results ));
         } catch (chain::invalid_http_request& e) {
            error_results results{400, "Invalid Request", error_results::error_info(e, verbose_http_errors)};
            cb( 400, fc::variant( results ));
         } catch (chain::unsatisfied_authorization& e) {
            error_results results{401, "UnAuthorized", error_results::error_info(e, verbose_http_errors)};
            cb( 401, fc::variant( results ));
         } catch (chain::tx_duplicate& e) {
            error_results results{409, "Conflict", error_results::error_info(e, verbose_http_errors)};
            cb( 409, fc::variant( results ));
         } catch (fc::eof_exception& e) {
            error_results results{422, "Unprocessable Entity", error_results::error_info(e, verbose_http_errors)};
            cb( 422, fc::variant( results ));
            fc_elog( logger, "Unable to parse arguments to ${api}.${call}", ("api", api_name)( "call", call_name ) );
            fc_dlog( logger, "Bad arguments: ${args}", ("args", body) );
         } catch (fc::exception& e) {
            error_results results{500, "Internal Service Error", error_results::error_info(e, verbose_http_errors)};
            cb( 500, fc::variant( results ));
            fc_dlog( logger, "Exception while processing ${api}.${call}: ${e}",
                     ("api", api_name)( "call", call_name )("e", e.to_detail_string()) );
         } catch (std::exception& e) {
            error_results results{500, "Internal Service Error", error_results::error_info(fc::exception( FC_LOG_MESSAGE( error, e.what())), verbose_http_errors)};
            cb( 500, fc::variant( results ));
            fc_elog( logger, "STD Exception encountered while processing ${api}.${call}",
                     ("api", api_name)( "call", call_name ) );
            fc_dlog( logger, "Exception Details: ${e}", ("e", e.what()) );
         } catch (...) {
            error_results results{500, "Internal Service Error",
               error_results::error_info(fc::exception( FC_LOG_MESSAGE( error, "Unknown Exception" )), verbose_http_errors)};
            cb( 500, fc::variant( results ));
            fc_elog( logger, "Unknown Exception encountered while processing ${api}.${call}",
                     ("api", api_name)( "call", call_name ) );
         }
      } catch (...) {
         std::cerr << "Exception attempting to handle exception for " << api_name << "." << call_name << std::endl;
      }
   }

Here is the caller graph for this function:

handle_sighup()

void sysio::http_plugin::handle_sighup ( )

overridevirtual

Reimplemented from appbase::plugin< http_plugin >.

Definition at line 894 of file http_plugin.cpp.

                                   {
      fc::logger::update( logger_name, logger );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

is_on_loopback()

bool sysio::http_plugin::is_on_loopback

(

)

const

Definition at line 972 of file http_plugin.cpp.

                                          {
      return (!my->listen_endpoint || my->listen_endpoint->address().is_loopback()) && (!my->https_listen_endpoint || my->https_listen_endpoint->address().is_loopback());
   }

is_secure()

bool sysio::http_plugin::is_secure

(

)

const

Definition at line 976 of file http_plugin.cpp.

                                     {
      return (!my->listen_endpoint || my->listen_endpoint->address().is_loopback());
   }

plugin_initialize()

void sysio::http_plugin::plugin_initialize

(

const variables_map &

options

)

Definition at line 715 of file http_plugin.cpp.

                                                                   {
      try {
         my->max_body_size = options.at( "max-body-size" ).as<uint32_t>();
         verbose_http_errors = options.at( "verbose-http-errors" ).as<bool>();
 
         my->thread_pool_size = options.at( "http-threads" ).as<uint16_t>();
         SYS_ASSERT( my->thread_pool_size > 0, chain::plugin_config_exception,
                     "http-threads ${num} must be greater than 0", ("num", my->thread_pool_size));
 
         auto max_bytes_mb = options.at( "http-max-bytes-in-flight-mb" ).as<int64_t>();
         SYS_ASSERT( (max_bytes_mb >= -1 && max_bytes_mb < std::numeric_limits<int64_t>::max() / (1024 * 1024)), chain::plugin_config_exception,
                     "http-max-bytes-in-flight-mb (${max_bytes_mb}) must be equal to or greater than -1 and less than ${max}", ("max_bytes_mb", max_bytes_mb) ("max", std::numeric_limits<int64_t>::max() / (1024 * 1024)) );
         if ( max_bytes_mb == -1 ) {
            my->max_bytes_in_flight = std::numeric_limits<size_t>::max();
         } else {
            my->max_bytes_in_flight = max_bytes_mb * 1024 * 1024;
         }
         my->max_response_time = fc::microseconds( options.at("http-max-response-time-ms").as<uint32_t>() * 1000 );
         
         my->validate_host = options.at("http-validate-host").as<bool>();
         if( options.count( "http-alias" )) {
            const auto& aliases = options["http-alias"].as<vector<string>>();
            my->valid_hosts.insert(aliases.begin(), aliases.end());
         }
 
         tcp::resolver resolver( app().get_io_service());
         if( options.count( "http-server-address" ) && options.at( "http-server-address" ).as<string>().length()) {
            string lipstr = options.at( "http-server-address" ).as<string>();
            string host = lipstr.substr( 0, lipstr.find( ':' ));
            string port = lipstr.substr( host.size() + 1, lipstr.size());
            tcp::resolver::query query( tcp::v4(), host.c_str(), port.c_str());
            try {
               my->listen_endpoint = *resolver.resolve( query );
               ilog( "configured http to listen on ${h}:${p}", ("h", host)( "p", port ));
            } catch ( const boost::system::system_error& ec ) {
               elog( "failed to configure http to listen on ${h}:${p} (${m})",
                     ("h", host)( "p", port )( "m", ec.what()));
            }
 
            // add in resolved hosts and ports as well
            if (my->listen_endpoint) {
               my->add_aliases_for_endpoint(*my->listen_endpoint, host, port);
            }
         }
 
         if( options.count( "unix-socket-path" ) && !options.at( "unix-socket-path" ).as<string>().empty()) {
            boost::filesystem::path sock_path = options.at("unix-socket-path").as<string>();
            if (sock_path.is_relative())
               sock_path = app().data_dir() / sock_path;
            my->unix_endpoint = asio::local::stream_protocol::endpoint(sock_path.string());
         }
 
         if( options.count( "https-server-address" ) && options.at( "https-server-address" ).as<string>().length()) {
            if( !options.count( "https-certificate-chain-file" ) ||
                options.at( "https-certificate-chain-file" ).as<string>().empty()) {
               elog( "https-certificate-chain-file is required for HTTPS" );
               return;
            }
            if( !options.count( "https-private-key-file" ) ||
                options.at( "https-private-key-file" ).as<string>().empty()) {
               elog( "https-private-key-file is required for HTTPS" );
               return;
            }
 
            string lipstr = options.at( "https-server-address" ).as<string>();
            string host = lipstr.substr( 0, lipstr.find( ':' ));
            string port = lipstr.substr( host.size() + 1, lipstr.size());
            tcp::resolver::query query( tcp::v4(), host.c_str(), port.c_str());
            try {
               my->https_listen_endpoint = *resolver.resolve( query );
               ilog( "configured https to listen on ${h}:${p} (TLS configuration will be validated momentarily)",
                     ("h", host)( "p", port ));
               my->https_cert_chain = options.at( "https-certificate-chain-file" ).as<string>();
               my->https_key = options.at( "https-private-key-file" ).as<string>();
            } catch ( const boost::system::system_error& ec ) {
               elog( "failed to configure https to listen on ${h}:${p} (${m})",
                     ("h", host)( "p", port )( "m", ec.what()));
            }
 
            // add in resolved hosts and ports as well
            if (my->https_listen_endpoint) {
               my->add_aliases_for_endpoint(*my->https_listen_endpoint, host, port);
            }
         }
 
         //watch out for the returns above when adding new code here
      } FC_LOG_AND_RETHROW()
   }

Here is the call graph for this function:

plugin_shutdown()

void sysio::http_plugin::plugin_shutdown

(

)

Definition at line 898 of file http_plugin.cpp.

                                     {
      if(my->server.is_listening())
         my->server.stop_listening();
      if(my->https_server.is_listening())
         my->https_server.stop_listening();
      if(my->unix_server.is_listening())
         my->unix_server.stop_listening();
 
      if( my->thread_pool ) {
         my->thread_pool->stop();
         my->thread_pool.reset();
      }
 
      // release http_plugin_impl_ptr shared_ptrs captured in url handlers
      my->url_handlers.clear();
 
      app().post( 0, [me = my](){} ); // keep my pointer alive until queue is drained
      fc_ilog( logger, "exit shutdown");
   }

Here is the call graph for this function:

plugin_startup()

void sysio::http_plugin::plugin_startup

(

)

Definition at line 804 of file http_plugin.cpp.

                                    {
 
      handle_sighup(); // setup logging
      app().post(appbase::priority::high, [this] ()
      {
         try {
            my->thread_pool.emplace( "http", my->thread_pool_size );
            if(my->listen_endpoint) {
               try {
                  my->create_server_for_endpoint(*my->listen_endpoint, my->server);
 
                  fc_ilog( logger, "start listening for http requests" );
                  my->server.listen(*my->listen_endpoint);
                  my->server.start_accept();
               } catch ( const fc::exception& e ){
                  fc_elog( logger, "http service failed to start: ${e}", ("e", e.to_detail_string()) );
                  throw;
               } catch ( const std::exception& e ){
                  fc_elog( logger, "http service failed to start: ${e}", ("e", e.what()) );
                  throw;
               } catch (...) {
                  fc_elog( logger, "error thrown from http io service" );
                  throw;
               }
            }
 
            if(my->unix_endpoint) {
               try {
                  my->unix_server.clear_access_channels(websocketpp::log::alevel::all);
                  my->unix_server.init_asio( &my->thread_pool->get_executor() );
                  my->unix_server.set_max_http_body_size(my->max_body_size);
                  my->unix_server.listen(*my->unix_endpoint);
                  // captures `this`, my needs to live as long as unix_server is handling requests
                  my->unix_server.set_http_handler([this](connection_hdl hdl) {
                     my->handle_http_request<detail::asio_local_with_stub_log>( my->unix_server.get_con_from_hdl(hdl));
                  });
                  my->unix_server.start_accept();
               } catch ( const fc::exception& e ){
                  fc_elog( logger, "unix socket service (${path}) failed to start: ${e}", ("e", e.to_detail_string())("path",my->unix_endpoint->path()) );
                  throw;
               } catch ( const std::exception& e ){
                  fc_elog( logger, "unix socket service (${path}) failed to start: ${e}", ("e", e.what())("path",my->unix_endpoint->path()) );
                  throw;
               } catch (...) {
                  fc_elog( logger, "error thrown from unix socket (${path}) io service", ("path",my->unix_endpoint->path()) );
                  throw;
               }
            }
 
            if(my->https_listen_endpoint) {
               try {
                  my->create_server_for_endpoint(*my->https_listen_endpoint, my->https_server);
                  my->https_server.set_tls_init_handler([this](websocketpp::connection_hdl hdl) -> ssl_context_ptr{
                     return my->on_tls_init(hdl);
                  });
 
                  fc_ilog( logger, "start listening for https requests" );
                  my->https_server.listen(*my->https_listen_endpoint);
                  my->https_server.start_accept();
               } catch ( const fc::exception& e ){
                  fc_elog( logger, "https service failed to start: ${e}", ("e", e.to_detail_string()) );
                  throw;
               } catch ( const std::exception& e ){
                  fc_elog( logger, "https service failed to start: ${e}", ("e", e.what()) );
                  throw;
               } catch (...) {
                  fc_elog( logger, "error thrown from https io service" );
                  throw;
               }
            }
 
            add_api({{
               std::string("/v1/node/get_supported_apis"),
               [&](string, string body, url_response_callback cb) mutable {
                  try {
                     if (body.empty()) body = "{}";
                     auto result = (*this).get_supported_apis();
                     cb(200, fc::variant(result));
                  } catch (...) {
                     handle_exception("node", "get_supported_apis", body, cb);
                  }
               }
            }});
         } catch (...) {
            fc_elog(logger, "http_plugin startup fails, shutting down");
            app().shutdown();
         }
      });
   }

Here is the call graph for this function:

set_defaults()

void sysio::http_plugin::set_defaults ( const http_plugin_defaults config )

static

Definition at line 55 of file http_plugin.cpp.

                                                                   {
      current_http_plugin_defaults = config;
   }

Here is the caller graph for this function:

set_program_options()

void sysio::http_plugin::set_program_options ( options_description & , options_description & cfg )

overridevirtual

Implements appbase::abstract_plugin.

Definition at line 637 of file http_plugin.cpp.

                                                                                       {
      if(current_http_plugin_defaults.default_unix_socket_path.length())
         cfg.add_options()
            ("unix-socket-path", bpo::value<string>()->default_value(current_http_plugin_defaults.default_unix_socket_path),
             "The filename (relative to data-dir) to create a unix socket for HTTP RPC; set blank to disable.");
      else
         cfg.add_options()
            ("unix-socket-path", bpo::value<string>(),
             "The filename (relative to data-dir) to create a unix socket for HTTP RPC; set blank to disable.");
 
      if(current_http_plugin_defaults.default_http_port)
         cfg.add_options()
            ("http-server-address", bpo::value<string>()->default_value("127.0.0.1:" + std::to_string(current_http_plugin_defaults.default_http_port)),
             "The local IP and port to listen for incoming http connections; set blank to disable.");
      else
         cfg.add_options()
            ("http-server-address", bpo::value<string>(),
             "The local IP and port to listen for incoming http connections; leave blank to disable.");
 
      cfg.add_options()
            ("https-server-address", bpo::value<string>(),
             "The local IP and port to listen for incoming https connections; leave blank to disable.")
 
            ("https-certificate-chain-file", bpo::value<string>(),
             "Filename with the certificate chain to present on https connections. PEM format. Required for https.")
 
            ("https-private-key-file", bpo::value<string>(),
             "Filename with https private key in PEM format. Required for https")
 
            ("https-ecdh-curve", bpo::value<https_ecdh_curve_t>()->notifier([this](https_ecdh_curve_t c) {
               my->https_ecdh_curve = c;
            })->default_value(SECP384R1),
            "Configure https ECDH curve to use: secp384r1 or prime256v1")
 
            ("access-control-allow-origin", bpo::value<string>()->notifier([this](const string& v) {
                my->access_control_allow_origin = v;
                fc_ilog( logger, "configured http with Access-Control-Allow-Origin: ${o}",
                         ("o", my->access_control_allow_origin) );
             }),
             "Specify the Access-Control-Allow-Origin to be returned on each request.")
 
            ("access-control-allow-headers", bpo::value<string>()->notifier([this](const string& v) {
                my->access_control_allow_headers = v;
                fc_ilog( logger, "configured http with Access-Control-Allow-Headers : ${o}",
                         ("o", my->access_control_allow_headers) );
             }),
             "Specify the Access-Control-Allow-Headers to be returned on each request.")
 
            ("access-control-max-age", bpo::value<string>()->notifier([this](const string& v) {
                my->access_control_max_age = v;
                fc_ilog( logger, "configured http with Access-Control-Max-Age : ${o}",
                         ("o", my->access_control_max_age) );
             }),
             "Specify the Access-Control-Max-Age to be returned on each request.")
 
            ("access-control-allow-credentials",
             bpo::bool_switch()->notifier([this](bool v) {
                my->access_control_allow_credentials = v;
                if( v ) fc_ilog( logger, "configured http with Access-Control-Allow-Credentials: true" );
             })->default_value(false),
             "Specify if Access-Control-Allow-Credentials: true should be returned on each request.")
            ("max-body-size", bpo::value<uint32_t>()->default_value(my->max_body_size),
             "The maximum body size in bytes allowed for incoming RPC requests")
            ("http-max-bytes-in-flight-mb", bpo::value<int64_t>()->default_value(500),
             "Maximum size in megabytes http_plugin should use for processing http requests. -1 for unlimited. 429 error response when exceeded." )
            ("http-max-response-time-ms", bpo::value<uint32_t>()->default_value(30),
             "Maximum time for processing a request.")
            ("verbose-http-errors", bpo::bool_switch()->default_value(false),
             "Append the error log to HTTP responses")
            ("http-validate-host", boost::program_options::value<bool>()->default_value(true),
             "If set to false, then any incoming \"Host\" header is considered valid")
            ("http-alias", bpo::value<std::vector<string>>()->composing(),
             "Additionaly acceptable values for the \"Host\" header of incoming HTTP requests, can be specified multiple times.  Includes http/s_server_address by default.")
            ("http-threads", bpo::value<uint16_t>()->default_value( my->thread_pool_size ),
             "Number of worker threads in http thread pool")
            ;
   }

verbose_errors()

bool sysio::http_plugin::verbose_errors

(

)

const

Definition at line 980 of file http_plugin.cpp.

                                         {
      return verbose_http_errors;
   }

---

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

• plugins/http_plugin/include/sysio/http_plugin/http_plugin.hpp
• plugins/http_plugin/http_plugin.cpp