Classes
struct	check_closed_visitor

struct	read_response_visitor

struct	write_request_visitor

Public Types
using	host_key = std::tuple<std::string, std::string, uint16_t>

using	raw_socket_ptr = std::unique_ptr<tcp::socket>

using	ssl_socket_ptr = std::unique_ptr<ssl::stream<tcp::socket>>

using	unix_socket_ptr = std::unique_ptr<local::stream_protocol::socket>

using	connection = std::variant<raw_socket_ptr, ssl_socket_ptr, unix_socket_ptr>

using	connection_map = std::map<host_key, connection>

using	unix_url_split_map = std::map<string, fc::url>

using	error_code = boost::system::error_code

using	deadline_type = boost::posix_time::ptime

Public Member Functions
	http_client_impl ()

void	add_cert (const std::string &cert_pem_string)

void	set_verify_peers (bool enabled)

template<typename SyncReadStream , typename Fn , typename CancelFn >
error_code	sync_do_with_deadline (SyncReadStream &s, deadline_type deadline, Fn f, CancelFn cf)

template<typename SyncReadStream , typename Fn >
error_code	sync_do_with_deadline (SyncReadStream &s, deadline_type deadline, Fn f)

template<typename SyncReadStream >
error_code	sync_connect_with_timeout (SyncReadStream &s, const std::string &host, const std::string &port, const deadline_type &deadline)

template<typename SyncReadStream >
error_code	sync_write_with_timeout (SyncReadStream &s, http::request< http::string_body > &req, const deadline_type &deadline)

template<typename SyncReadStream >
error_code	sync_read_with_timeout (SyncReadStream &s, boost::beast::flat_buffer &buffer, http::response< http::string_body > &res, const deadline_type &deadline)

host_key	url_to_host_key (const url &dest)

connection_map::iterator	create_unix_connection (const url &dest, const deadline_type &deadline)

connection_map::iterator	create_raw_connection (const url &dest, const deadline_type &deadline)

connection_map::iterator	create_ssl_connection (const url &dest, const deadline_type &deadline)

connection_map::iterator	create_connection (const url &dest, const deadline_type &deadline)

bool	check_closed (const connection_map::iterator &conn_itr)

connection_map::iterator	get_connection (const url &dest, const deadline_type &deadline)

variant	post_sync (const url &dest, const variant &payload, const fc::time_point &_deadline)

const fc::url &	get_unix_url (const std::string &full_url)

Public Attributes
boost::asio::io_context	_ioc

ssl::context	_sslc

connection_map	_connections

unix_url_split_map	_unix_url_paths

Detailed Description

Definition at line 32 of file http_client.cpp.

Member Typedef Documentation

◆ connection

using fc::http_client_impl::connection = std::variant<raw_socket_ptr, ssl_socket_ptr, unix_socket_ptr>

Definition at line 38 of file http_client.cpp.

◆ connection_map

using fc::http_client_impl::connection_map = std::map<host_key, connection>

Definition at line 39 of file http_client.cpp.

◆ deadline_type

using fc::http_client_impl::deadline_type = boost::posix_time::ptime

Definition at line 42 of file http_client.cpp.

◆ error_code

using fc::http_client_impl::error_code = boost::system::error_code

Definition at line 41 of file http_client.cpp.

◆ host_key

using fc::http_client_impl::host_key = std::tuple<std::string, std::string, uint16_t>

Definition at line 34 of file http_client.cpp.

◆ raw_socket_ptr

using fc::http_client_impl::raw_socket_ptr = std::unique_ptr<tcp::socket>

Definition at line 35 of file http_client.cpp.

◆ ssl_socket_ptr

using fc::http_client_impl::ssl_socket_ptr = std::unique_ptr<ssl::stream<tcp::socket>>

Definition at line 36 of file http_client.cpp.

◆ unix_socket_ptr

using fc::http_client_impl::unix_socket_ptr = std::unique_ptr<local::stream_protocol::socket>

Definition at line 37 of file http_client.cpp.

◆ unix_url_split_map

using fc::http_client_impl::unix_url_split_map = std::map<string, fc::url>

Definition at line 40 of file http_client.cpp.

Constructor & Destructor Documentation

◆ http_client_impl()

fc::http_client_impl::http_client_impl ( )

inline

Definition at line 44 of file http_client.cpp.

   :_ioc()
   ,_sslc(ssl::context::sslv23_client)
   {
      set_verify_peers(true);
   }

Here is the call graph for this function:

Member Function Documentation

◆ add_cert()

void fc::http_client_impl::add_cert ( const std::string & cert_pem_string )

inline

Definition at line 51 of file http_client.cpp.

                                                   {
      error_code ec;
      _sslc.add_certificate_authority(boost::asio::buffer(cert_pem_string.data(), cert_pem_string.size()), ec);
      FC_ASSERT(!ec, "Failed to add cert: ${msg}", ("msg", ec.message()));
   }

◆ check_closed()

bool fc::http_client_impl::check_closed ( const connection_map::iterator & conn_itr )

inline

Definition at line 248 of file http_client.cpp.

                                                               {
      if (std::visit(check_closed_visitor(), conn_itr->second)) {
         _connections.erase(conn_itr);
         return true;
      } else {
         return false;
      }
   }

◆ create_connection()

connection_map::iterator fc::http_client_impl::create_connection	(	const url &	dest,
		const deadline_type &	deadline )

inline

Definition at line 222 of file http_client.cpp.

                                                                                              {
      if (dest.proto() == "http") {
         return create_raw_connection(dest, deadline);
      } else if (dest.proto() == "https") {
         return create_ssl_connection(dest, deadline);
      } else if (dest.proto() == "unix") {
         return create_unix_connection(dest, deadline);
      } else {
         FC_THROW("Unknown protocol ${proto}", ("proto", dest.proto()));
      }
   }

Here is the call graph for this function:

◆ create_raw_connection()

connection_map::iterator fc::http_client_impl::create_raw_connection	(	const url &	dest,
		const deadline_type &	deadline )

inline

Definition at line 178 of file http_client.cpp.

                                                                                                  {
      auto key = url_to_host_key(dest);
      auto socket = std::make_unique<tcp::socket>(_ioc);
 
      error_code ec = sync_connect_with_timeout(*socket, *dest.host(), dest.port() ? std::to_string(*dest.port()) : "80", deadline);
      FC_ASSERT(!ec, "Failed to connect: ${message}", ("message",ec.message()));
 
      auto res = _connections.emplace(std::piecewise_construct,
                                      std::forward_as_tuple(key),
                                      std::forward_as_tuple(std::move(socket)));
 
      return res.first;
   }

Here is the call graph for this function:

◆ create_ssl_connection()

connection_map::iterator fc::http_client_impl::create_ssl_connection	(	const url &	dest,
		const deadline_type &	deadline )

inline

Definition at line 192 of file http_client.cpp.

                                                                                                  {
      auto key = url_to_host_key(dest);
      auto ssl_socket = std::make_unique<ssl::stream<tcp::socket>>(_ioc, _sslc);
 
      // Set SNI Hostname (many hosts need this to handshake successfully)
      if(!SSL_set_tlsext_host_name(ssl_socket->native_handle(), dest.host()->c_str()))
      {
         error_code ec{static_cast<int>(::ERR_get_error()), boost::asio::error::get_ssl_category()};
         FC_THROW("Unable to set SNI Host Name: ${msg}", ("msg", ec.message()));
      }
 
      ssl_socket->set_verify_callback(boost::asio::ssl::rfc2818_verification(*dest.host()));
 
      error_code ec = sync_connect_with_timeout(ssl_socket->next_layer(), *dest.host(), dest.port() ? std::to_string(*dest.port()) : "443", deadline);
      if (!ec) {
         ec = sync_do_with_deadline(ssl_socket->next_layer(), deadline, [&ssl_socket](std::optional<error_code>& final_ec) {
            ssl_socket->async_handshake(ssl::stream_base::client, [&final_ec](const error_code& ec) {
               final_ec.emplace(ec);
            });
         });
      }
      FC_ASSERT(!ec, "Failed to connect: ${message}", ("message",ec.message()));
 
      auto res = _connections.emplace(std::piecewise_construct,
                                      std::forward_as_tuple(key),
                                      std::forward_as_tuple(std::move(ssl_socket)));
 
      return res.first;
   }

Here is the call graph for this function:

◆ create_unix_connection()

connection_map::iterator fc::http_client_impl::create_unix_connection	(	const url &	dest,
		const deadline_type &	deadline )

inline

Definition at line 163 of file http_client.cpp.

                                                                                                  {
      auto key = url_to_host_key(dest);
      auto socket = std::make_unique<local::stream_protocol::socket>(_ioc);
 
      error_code ec;
      socket->connect(local::stream_protocol::endpoint(*dest.host()), ec);
      FC_ASSERT(!ec, "Failed to connect: ${message}", ("message",ec.message()));
 
      auto res = _connections.emplace(std::piecewise_construct,
                                      std::forward_as_tuple(key),
                                      std::forward_as_tuple(std::move(socket)));
 
      return res.first;
   }

Here is the call graph for this function:

◆ get_connection()

connection_map::iterator fc::http_client_impl::get_connection	(	const url &	dest,
		const deadline_type &	deadline )

inline

Definition at line 257 of file http_client.cpp.

                                                                                           {
      auto key = url_to_host_key(dest);
      auto conn_itr = _connections.find(key);
      if (conn_itr == _connections.end() || check_closed(conn_itr)) {
         return create_connection(dest, deadline);
      } else {
         return conn_itr;
      }
   }

◆ get_unix_url()

const fc::url & fc::http_client_impl::get_unix_url ( const std::string & full_url )

inline

Definition at line 399 of file http_client.cpp.

                                                        {
      unix_url_split_map::const_iterator found = _unix_url_paths.find(full_url);
      if(found != _unix_url_paths.end())
         return found->second;
 
      boost::filesystem::path socket_file(full_url);
      if(socket_file.is_relative())
         FC_THROW_EXCEPTION( parse_error_exception, "socket url cannot be relative (${url})", ("url", socket_file.string()));
      if(socket_file.empty())
         FC_THROW_EXCEPTION( parse_error_exception, "missing socket url");
      boost::filesystem::path url_path;
      do {
         if(boost::filesystem::status(socket_file).type() == boost::filesystem::socket_file)
            break;
         url_path = socket_file.filename() / url_path;
         socket_file = socket_file.remove_filename();
      } while(!socket_file.empty());
      if(socket_file.empty())
         FC_THROW_EXCEPTION( parse_error_exception, "couldn't discover socket path");
      url_path = "/" / url_path;
      return _unix_url_paths.emplace(full_url, fc::url("unix", socket_file.string(), ostring(), ostring(), url_path.string(), ostring(), ovariant_object(), std::optional<uint16_t>())).first->second;
   }

◆ post_sync()

variant fc::http_client_impl::post_sync	(	const url &	dest,
		const variant &	payload,
		const fc::time_point &	_deadline )

inline

Definition at line 303 of file http_client.cpp.

                                                                                             {
      static const deadline_type epoch(boost::gregorian::date(1970, 1, 1));
      auto deadline = epoch + boost::posix_time::microseconds(_deadline.time_since_epoch().count());
      FC_ASSERT(dest.host(), "No host set on URL");
 
      string path = dest.path() ? dest.path()->generic_string() : "/";
      if (dest.query()) {
         path = path + "?" + *dest.query();
      }
 
      string host_str = *dest.host();
      if (dest.port()) {
         auto port = *dest.port();
         auto proto_iter = default_proto_ports.find(dest.proto());
         if (proto_iter != default_proto_ports.end() && proto_iter->second != port) {
            host_str = host_str + ":" + std::to_string(port);
         }
      }
 
      http::request<http::string_body> req{http::verb::post, path, 11};
      req.set(http::field::host, host_str);
      req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
      req.set(http::field::content_type, "application/json");
      req.keep_alive(true);
      req.body() = json::to_string(payload, _deadline);
      req.prepare_payload();
 
      auto conn_iter = get_connection(dest, deadline);
      auto eraser = make_scoped_exit([this, &conn_iter](){
         _connections.erase(conn_iter);
      });
 
      // Send the HTTP request to the remote host
      error_code ec = std::visit(write_request_visitor(this, req, deadline), conn_iter->second);
      FC_ASSERT(!ec, "Failed to send request: ${message}", ("message",ec.message()));
 
      // This buffer is used for reading and must be persisted
      boost::beast::flat_buffer buffer;
 
      // Declare a container to hold the response
      http::response<http::string_body> res;
 
      // Receive the HTTP response
      ec = std::visit(read_response_visitor(this, buffer, res, deadline), conn_iter->second);
      FC_ASSERT(!ec, "Failed to read response: ${message}", ("message",ec.message()));
 
      // if the connection can be kept open, keep it open
      if (res.keep_alive()) {
         eraser.cancel();
      }
 
      fc::variant result;
      if( !res.body().empty() ) {
         try {
            result = json::from_string( res.body() );
         } catch( ... ) {}
      }
      if (res.result() == http::status::internal_server_error) {
         fc::exception_ptr excp;
         try {
            auto err_var = result.get_object()["error"].get_object();
            excp = std::make_shared<fc::exception>(err_var["code"].as_int64(), err_var["name"].as_string(), err_var["what"].as_string());
 
            if (err_var.contains("details")) {
               for (const auto& dvar : err_var["details"].get_array()) {
                  excp->append_log(FC_LOG_MESSAGE(error, dvar.get_object()["message"].as_string()));
               }
            }
         } catch( ... ) {
 
         }
 
         if (excp) {
            throw *excp;
         } else {
            FC_THROW("Request failed with 500 response, but response was not parseable");
         }
      } else if (res.result() == http::status::not_found) {
         FC_THROW("URL not found: ${url}", ("url", (std::string)dest));
      }
 
      return result;
   }

Here is the call graph for this function:

◆ set_verify_peers()

void fc::http_client_impl::set_verify_peers ( bool enabled )

inline

Definition at line 57 of file http_client.cpp.

                                       {
      if (enabled) {
         _sslc.set_verify_mode(ssl::verify_peer);
      } else {
         _sslc.set_verify_mode(ssl::verify_none);
      }
   }

Here is the caller graph for this function:

◆ sync_connect_with_timeout()

template<typename SyncReadStream >

error_code fc::http_client_impl::sync_connect_with_timeout	(	SyncReadStream &	s,
		const std::string &	host,
		const std::string &	port,
		const deadline_type &	deadline )

inline

Definition at line 110 of file http_client.cpp.

                                                                                                                                           {
      tcp::resolver local_resolver(_ioc);
      bool cancelled = false;
 
      auto res = sync_do_with_deadline(s, deadline, [&local_resolver, &cancelled, &s, &host, &port](std::optional<error_code>& final_ec){
         local_resolver.async_resolve(host, port, [&cancelled, &s, &final_ec](const error_code& ec, tcp::resolver::results_type resolved ){
            if (ec) {
               final_ec.emplace(ec);
               return;
            }
 
            if (!cancelled) {
               boost::asio::async_connect(s, resolved.begin(), resolved.end(), [&final_ec](const error_code& ec, tcp::resolver::iterator ){
                  final_ec.emplace(ec);
               });
            }
         });
      },[&local_resolver, &cancelled](){
         cancelled = true;
         local_resolver.cancel();
      });
 
      return res;
   };

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sync_do_with_deadline() [1/2]

template<typename SyncReadStream , typename Fn >

error_code fc::http_client_impl::sync_do_with_deadline	(	SyncReadStream &	s,
		deadline_type	deadline,
		Fn	f )

inline

Definition at line 103 of file http_client.cpp.

                                                                                      {
      return sync_do_with_deadline(s, deadline, f, [&s](){
         s.lowest_layer().cancel();
      });
   };

Here is the call graph for this function:

◆ sync_do_with_deadline() [2/2]

template<typename SyncReadStream , typename Fn , typename CancelFn >

error_code fc::http_client_impl::sync_do_with_deadline	(	SyncReadStream &	s,
		deadline_type	deadline,
		Fn	f,
		CancelFn	cf )

inline

Definition at line 66 of file http_client.cpp.

                                                                                                    {
      bool timer_expired = false;
      boost::asio::deadline_timer timer(_ioc);
 
      timer.expires_at(deadline);
      bool timer_cancelled = false;
      timer.async_wait([&timer_expired, &timer_cancelled] (const error_code&) {
         // the only non-success error_code this is called with is operation_aborted but since
         // we could have queued "success" when we cancelled the timer, we set a flag at the
         // safer scope and only respect that.
         if (!timer_cancelled) {
            timer_expired = true;
         }
      });
 
      std::optional<error_code> f_result;
      f(f_result);
 
      _ioc.restart();
      while (_ioc.run_one())
      {
         if (f_result) {
            timer_cancelled = true;
            timer.cancel();
         } else if (timer_expired) {
            cf();
         }
      }
 
      if (!timer_expired) {
         return *f_result;
      } else {
         return error_code(boost::system::errc::timed_out, boost::system::system_category());
      }
   }

Here is the caller graph for this function:

◆ sync_read_with_timeout()

template<typename SyncReadStream >

error_code fc::http_client_impl::sync_read_with_timeout	(	SyncReadStream &	s,
		boost::beast::flat_buffer &	buffer,
		http::response< http::string_body > &	res,
		const deadline_type &	deadline )

inline

Definition at line 145 of file http_client.cpp.

                                                                                                                                                           {
      return sync_do_with_deadline(s, deadline, [&s, &buffer, &res](std::optional<error_code>& final_ec){
         http::async_read(s, buffer, res, [&final_ec]( const error_code& ec, std::size_t ) {
            final_ec.emplace(ec);
         });
      });
   }

Here is the call graph for this function:

◆ sync_write_with_timeout()

template<typename SyncReadStream >

error_code fc::http_client_impl::sync_write_with_timeout	(	SyncReadStream &	s,
		http::request< http::string_body > &	req,
		const deadline_type &	deadline )

inline

Definition at line 136 of file http_client.cpp.

                                                                                                                            {
      return sync_do_with_deadline(s, deadline, [&s, &req](std::optional<error_code>& final_ec){
         http::async_write(s, req, [&final_ec]( const error_code& ec, std::size_t ) {
            final_ec.emplace(ec);
         });
      });
   }

Here is the call graph for this function:

◆ url_to_host_key()

host_key fc::http_client_impl::url_to_host_key ( const url & dest )

inline

Definition at line 153 of file http_client.cpp.

                                               {
      FC_ASSERT(dest.host(), "Provided URL has no host");
      uint16_t port = 80;
      if (dest.port()) {
         port = *dest.port();
      }
 
      return std::make_tuple(dest.proto(), *dest.host(), port);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _connections

connection_map fc::http_client_impl::_connections

Definition at line 424 of file http_client.cpp.

◆ _ioc

boost::asio::io_context fc::http_client_impl::_ioc

Definition at line 422 of file http_client.cpp.

◆ _sslc

ssl::context fc::http_client_impl::_sslc

Definition at line 423 of file http_client.cpp.

◆ _unix_url_paths

unix_url_split_map fc::http_client_impl::_unix_url_paths

Definition at line 425 of file http_client.cpp.

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

libraries/fc/src/network/http/http_client.cpp

Classes

Public Types

Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ connection

◆ connection_map

◆ deadline_type

◆ error_code

◆ host_key

◆ raw_socket_ptr

◆ ssl_socket_ptr

◆ unix_socket_ptr

◆ unix_url_split_map

Constructor & Destructor Documentation

◆ http_client_impl()

Member Function Documentation

◆ add_cert()

◆ check_closed()

◆ create_connection()

◆ create_raw_connection()

◆ create_ssl_connection()

◆ create_unix_connection()

◆ get_connection()

◆ get_unix_url()

◆ post_sync()

◆ set_verify_peers()

◆ sync_connect_with_timeout()

◆ sync_do_with_deadline() [1/2]

◆ sync_do_with_deadline() [2/2]

◆ sync_read_with_timeout()

◆ sync_write_with_timeout()

◆ url_to_host_key()

Member Data Documentation

◆ _connections

◆ _ioc

◆ _sslc

◆ _unix_url_paths