stream client
v1.4.2
Dies ist eine leichte, nur Header-boost-basierte Bibliothek, die die privaten aufeinanderfolgenden Netzwerkprimitive bietet, um die Datenübertragung einfach mit Remote-Endpunkten zu organisieren und zu implementieren.
Diese Bibliothek:
Wenn Sie Software auf C ++ schreiben, die mit anderen Diensten als Kunden kommuniziert, sind Sie wahrscheinlich bereits mit dem Problem zurückgekommen - müssen die Konnektivitätsschicht implementieren, um den Netzwerktransport für alle zugehörigen Dienste bereitzustellen. Genau das zielen die Lösung dieser Bibliothek zu lösen.
Sockets werden über boost::asio::basic_socket implementiert und bieten Klassen mit Zeitlimitsteuerung. In den meisten Fällen reicht es aus, SEND () / Receise () / write_some () / read_some () mit einer Deadline oder Timeout aufzurufen. Daten, die zu E/A -Operationen geliefert wurden, sollten in boost::asio::buffer eingewickelt werden. Grundsätzlich sind diese Clients Timeout-umgewickelt boost::asio::ip Sockets und haben die gleiche Schnittstelle.
Client Streams -Klassen:
stream_client::tcp_client - einfacher TCP -Stream -Socket -Client. Unterstützt Send () / Rececive () für zugelassene Übertragungen des gesamten Puffers zusammen mit write_some () / read_some (), um zumindest etwas zu übertragen.stream_client::udp_client - einfacher UDP -Socket -Client. Unterstützt nur send () / recipt () ohne Bestätigung gemäß UDP -Spezifikationen.stream_client::ssl::ssl_client - SSL -zerbrechlicher TCP -Client. Haben Sie die gleichen Funktionen wie tcp_client Plus SSL Handshake und Kontextkontrolle.stream_client::http::http_client - http client. Wraps tcp_client mit boost::beast::http::parser und boost::beast::http::serializer und haben Sie die Funktion von Ausführen () , um Anforderungsanrufe zu tätigen.stream_client::http::https_client - https client. Wie http_client verwendet aber ssl_client Client darunter. const boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address::from_string( " 127.0.0.1 " ), 12345);
const std::chrono::milliseconds connect_timeout ( 1000 );
const std::chrono::milliseconds io_timeout ( 100 );
// this makes connected socket and may take up to connect_timeout time
stream_client::tcp_client client (endpoint, connect_timeout, io_timeout);
// send() operation will transmit all contents of send_data or throw an error;
// also it will throw boost::asio::error::timed_out after io_timeout.
const std::string send_data = " test data " ;
client.send(boost::asio::buffer(send_data.data(), send_data.size()));
// receive() operation will read send_data.size() size or throw an error;
// also it will throw boost::asio::error::timed_out after io_timeout.
std::string recv_data (send_data.size(), ' ');
client.receive(boost::asio::buffer(&recv_data[ 0 ], send_data.size()));
// there are also non-throw overloads to these functions which
// will set boost::system::error_code instead of exception; Resolver wird rund um die gleiche Idee implementiert - synchronisieren, zeitgesteuerte DNS -Resolver. Daher verwendet er boost::asio::ip::basic_resolver um die tatsächliche Auflösung innerhalb bestimmter Timeouts durchzuführen.
Es handelt sich um die Klassenvorlage mit einem einzelnen Parameter - Ergebnisprotokoll. Außerdem können Sie angeben, an welcher Art von IP -Endpunkten Sie interessiert sind - IPv4, IPv6 oder beides. Auflösung mit Resolve () Call mit einer ähnlichen Signatur wie Sockets -Operationen - Sie können freie Zeitüberschreitungen/Frist angeben oder Standardeinstellungen verwenden.
Resolver -Klassen:
stream_client::resolver::tcp_resolver - Resolver, der Iterator von TCP -Endpunkten zurückgibt.stream_client::resolver::udp_resolver - Resolver, der Iterator von UDP -Endpunkten zurückgibt. const std::chrono::milliseconds resolve_timeout ( 5000 );
stream_client::resolver::tcp_resolver resolver ( " localhost " , " 12345 " ,
resolve_timeout,
stream_client::resolver::ip_family::ipv4);
// resolve() guaranteed to return at least one endpoint or will throw an error;
// it will throw boost::asio::error::timed_out after resolve_timeout.
auto endpoints_it = resolver.resolve();
// returned iterator is an instance of boost::asio::ip::basic_resolver::iterator<Protocol>Connector verwendet Resolver, um die DNS -Auflösung durchzuführen und die Liste der Endpunkte zu aktualisieren, und verwendet sie, wenn sie mit New_Session () angefordert werden, um einen neuen Socket des angegebenen Protokolls zu erstellen. Die Arbeit des DNS -Resolvers ist in Hintergrund -Thread eingewickelt, das bei der Erstellung ausgelöst wird oder wenn es einen Fehler beim Öffnen eines neuen Sockels gab.
Zielendpunkt zum Öffnen einer neuen Socket, die zufällig aus den DNS -Ergebnissen ausgewählt wurde, wodurch es einen ausgewogenen Stecker zu einem Remote -Host macht. Außerdem ermöglicht der Anschluss, separate Zeitüberschreitungen für Auflösung, Verbindung und E/A -Betrieb neuer Sockets anzugeben.
Anschlussklassen:
stream_client::connector::tcp_connector - TCP -Anschluss, um stream_client::tcp_client Sockets zu erhalten.stream_client::connector::udp_connector - UDP Connector, um stream_client::udp_client Sockets zu erhalten.stream_client::connector::ssl_connector - TCP -Connector, um stream_client::ssl::ssl_client Sockets zu erhalten.stream_client::connector::http_connector - HTTP -Anschluss, um stream_client::http::http_client Sockets zu erhalten.stream_client::connector::https_connector - https connector, um stream_client::http::https_client Sockets zu erhalten. const std::chrono::milliseconds resolve_timeout ( 5000 );
const std::chrono::milliseconds connect_timeout ( 1000 );
const std::chrono::milliseconds io_timeout ( 100 );
// this will return immediately, starting background thread for name resolution
stream_client::connector::tcp_connector connector ( " localhost " , " 12345 " ,
resolve_timeout, connect_timeout, io_timeout,
stream_client::resolver::ip_family::ipv4);
// this will acquire new socket or throw;
// it will throw boost::asio::error::timed_out after connect_timeout
std::unique_ptr<stream_client::tcp_client> client = connector.new_session();
// use the client
const std::string send_data = " test data " ;
std::string recv_data (send_data.size(), ' ');
client-> send (boost::asio::buffer(send_data.data(), send_data.size()));
client-> receive (boost::asio::buffer(&recv_data[ 0 ], send_data.size()));Repräsentiert den Behälter, der mit geöffneten Sockeln besetzt ist. Verwendet einen Anschluss, um neue Sockets im Hintergrund -Thread zu öffnen, der ausgelöst wird, sobald es im Pool freie Stellen gibt. Der Benutzer kann Get_Session () anrufen, um einen Socket aus dem Pool zu erhalten, und return_session (), um ihn zurückzugeben.
Es gibt zwei Strategien, um den Pool nachzufüllen:
stream_client::connector::greedy_strategy ). Wenn es freie Orte gibt, wird versucht, sie gleichzeitig mit neuen Sitzungen zu füllen. Dies ist der Standard.stream_client::connector::conservative_strategy ). Wird versuchen, in der Umfrage bis zu 2/3 freie Orte zu füllen. Wenn ausfällt, wird es für einige Zeit zurückgegangen und später wiederholt. Außerdem wird es nach Fehlern nur eine neue Sitzung erstellen. Beide sind in Bezug auf stream_client::connector::pool_strategy Interface definiert, sodass Sie neue neue implementieren können.
Einschränkungen:
In Anbetracht dessen ist die beste Strategie für die Verwendung eines Verbindungspools:
Es ist wichtig, Steckdosen für Misserfolg zu verwerfen und sie nicht wiederzuverwenden, oder das Anfrage-Wirkungs-Management wird böse.
Verbindungspools:
stream_client::connector::tcp_pool - Pool von stream_client::tcp_client Sockets.stream_client::connector::udp_pool - Pool von stream_client::udp_client Sockets.stream_client::connector::ssl_pool - Pool von stream_client::ssl::ssl_client Sockets.stream_client::connector::http_pool - Pool von stream_client::http::http_client Sockets.stream_client::connector::https_pool - Pool von stream_client::http::https_client Sockets.Es gibt auch Aliase für dieselben Pools, aber die konservative Wiederverbindungsstrategie anwendet:
stream_client::connector::tcp_conservative_poolstream_client::connector::udp_conservative_poolstream_client::connector::ssl_conservative_poolstream_client::connector::http_conservative_poolstream_client::connector::https_conservative_pool const std::chrono::milliseconds resolve_timeout ( 5000 );
const std::chrono::milliseconds connect_timeout ( 1000 );
const std::chrono::milliseconds io_timeout ( 100 );
auto connector_pool =
std::make_shared<stream_client::connector::tcp_pool>( " localhost " , " 12345 " ,
resolve_timeout, connect_timeout, io_timeout,
stream_client::resolver::ip_family::ipv4);
const size_t threads_num = 10 ;
std::vector<std::thread> threads;
const std::string send_data = " test data " ;
std::mutex stdout_mutex;
for ( size_t i = 0 ; i < threads_num; ++i) {
threads. emplace_back ([&send_data, &stdout_mutex, connector_pool]() {
std::string recv_data (send_data. size (), ' ' );
auto client = connector_pool-> get_session ();
// both these calls will throw exception on error or timeout
client-> send ( boost::asio::buffer (send_data. data (), send_data. size ()));
client-> receive ( boost::asio::buffer (&recv_data[ 0 ], send_data. size ()));
// if there was no exception, return it
connector_pool-> return_session ( std::move (client));
const std::lock_guard<std::mutex> lk (stdout_mutex);
std::cout << std::this_thread::get_id () << " : " << recv_data << std::endl;
});
}
for ( auto & t : threads) {
t. join ();
} Die Bibliothek verwendet eine grundlegende Logger -Schnittstelle, die intern implementiert wurde. Sie können die Logger -Ebene mit stream_client::set_log_level() oder stream_client::get_log_level() ändern.
Diese Ebenen werden unterstützt:
enum class log_level : int
{
trace = 0 ,
debug,
info,
warning,
error,
};Standardmäßig druckt Bibliothek Nachrichten mit angemessener Formatierung an STDOut. Wenn Sie dieses Verhalten überschreiben möchten, können Sie Ihren eigenen Logger festlegen:
void stream_client::set_logger (std::shared_ptr<stream_client::log_interface> logger);
void stream_client::set_logger (stream_client::log_level level, stream_client::log_func_type log_func);Dies ermöglicht es, die Logger -Instanz zu überschreiben, wenn sie einen Rückruf mit der richtigen Signatur verwenden. Diese Typen werden definiert als:
class log_interface
{
public:
virtual void set_level (log_level level) noexcept = 0;
virtual log_level get_level () const noexcept = 0;
virtual void message (log_level level, const std::string& location, const std::string& message) const = 0;
};
using log_func_type = std::function< void (log_level level, const std::string& location, const std::string& message)>;Weitere Informationen finden Sie unter logger.hpp.
Diese Bibliothek soll etwas mehrfach Plattform sein, sie wurde jedoch getestet und hauptsächlich auf Ubuntu und MacOS verwendet.
Bevorzugen Sie das Gebäude außerhalb der Source.
sudo apt update
sudo apt install build-essential cmake libboost-dev libboost-system-dev libssl-devbrew install cmake pkg-config icu4c openssl boostZu bauen:
cmake -H. -Bbuild
cmake --build ./buildZu installieren (sudo kann erforderlich sein):
cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=OFF -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build --target installOder testen:
cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=ON -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build
cmake -E chdir ./build ctest --output-on-failureAlle diese Befehle gehen davon aus
RelWithDebInfo standardmäßig.ON .OFFOFF .OFF .OFF ist, wird diese Optionen festgelegt. Entwickelt in Tinkoff.ru im Jahr 2020.
Unter Apache -Lizenz 2.0 Lizenz distanziert. Sie können diese Lizenz auch unter https://www.apache.org/licenses/license-2.0 erhalten.
Autor - [email protected]
Aktuelle Wardierer - [email protected], [email protected]
