stream client
v1.4.2
Il s'agit d'une bibliothèque légère, en tête uniquement, offrant des primitives de réseau côté client pour organiser et implémenter facilement la transmission de données avec des points de terminaison distants.
Cette bibliothèque:
Si vous écrivez des logiciels sur C ++, qui communique avec d'autres services en tant que client, vous êtes probablement déjà venu à acroser avec le problème - vous devez implémenter la couche de connectivité pour fournir un transport réseau à tous les services connexes. C'est exactement ce que cette bibliothèque a pour objectif de résoudre.
Les prises sont implémentées en plus de boost::asio::basic_socket et fournissent des classes avec le contrôle du délai d'attente, donc dans la plupart des cas, il suffit d'appeler Send () / Recea () / Write_Some () / Read_Some () avec une échéance ou un délai d'attente. Les données fournies aux opérations d'E / S doivent être enveloppées dans boost::asio::buffer . Fondamentalement, ces clients sont enveloppés boost::asio::ip Sockets et ont la même interface.
Classes de flux de clients:
stream_client::tcp_client - Client de socket Stream Plain TCP. Prend en charge Send () / Recive () pour les transferts admis de tampon entier avec write_some () / read_some () pour transférer au moins quelque chose.stream_client::udp_client - Client de socket UDP simple. Prend en charge uniquement () / recevoir () sans aucun accusé de réception conformément aux spécifications UDP.stream_client::ssl::ssl_client - Client TCP crypté SSL. Ont les mêmes fonctions que tcp_client Plus SSL PAPE et CONTRÔLE DE CONTEXTE.stream_client::http::http_client - client http. Enveloppe tcp_client avec boost::beast::http::parser et boost::beast::http::serializer et avoir effectué une fonction () pour passer des appels de réponse à la demande.stream_client::http::https_client - client https. Identique à http_client mais utilise le client ssl_client en dessous. 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 est implémenté autour de la même idée - faire de la synchronisation, résolver DNS chronométré, donc il utilise boost::asio::ip::basic_resolver pour effectuer une résolution réelle dans les délais spécifiés.
Il s'agit du modèle de classe avec un seul paramètre - Protocole de résultat, vous pouvez également spécifier le type de points de terminaison IP qui vous intéressent - IPv4, IPv6 ou les deux. Résolution effectuée avec l'appel RESOLOL () qui a une signature similaire aux opérations de sockets - vous êtes libre de spécifier le délai d'attente / la date limite ou d'utiliser un par défaut.
Cours de résolveur:
stream_client::resolver::tcp_resolver - Resolver qui renvoie l'itérateur de points de terminaison TCP.stream_client::resolver::udp_resolver - Resolver qui renvoie l'itérateur de points de terminaison UDP. 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 utilise Resolver pour effectuer une résolution DNS et mettre à jour la liste des points de terminaison et les utilise si vous êtes demandé avec new_Session () , pour créer une nouvelle prise du protocole spécifié. Le travail du résolveur DNS est enveloppé dans le thread d'arrière-plan qui s'est déclenché lors de la création ou s'il y avait une erreur dans l'ouverture d'une nouvelle prise.
Target Endpoint Point pour ouvrir une nouvelle prise sélectionnée au hasard à partir des résultats DNS, ce qui en fait un connecteur équilibré à un hôte distant. En outre, le connecteur permet de spécifier des délais d'attente séparés pour la résolution, la connexion et le fonctionnement des E / S de nouvelles prises.
Classes de connecteur:
stream_client::connector::tcp_connector - Connecteur TCP, pour obtenir stream_client::tcp_client Sockets.stream_client::connector::udp_connector - Connecteur UDP, pour obtenir stream_client::udp_client Sockets.stream_client::connector::ssl_connector - Connecteur TCP, pour obtenir stream_client::ssl::ssl_client SOCKETS.stream_client::connector::http_connector - Connecteur HTTP, pour obtenir stream_client::http::http_client Sockets.stream_client::connector::https_connector - Connecteur HTTPS, pour obtenir stream_client::http::https_client Sockets. 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ésente le conteneur occupé par des prises ouvertes. Utilise le connecteur pour ouvrir de nouvelles sockets dans le thread d'arrière-plan qui est déclenché une fois qu'il y a des endroits vacants dans la piscine. L'utilisateur peut appeler get_session () pour obtenir une prise à partir du pool et return_session () pour le rendre.
Il existe deux stratégies pour remplir la piscine:
stream_client::connector::greedy_strategy ). S'il y a des endroits vacants, il essaiera de les remplir de nouvelles sessions simultanément. C'est le défaut.stream_client::connector::conservative_strategy ). Essaiera de remplir jusqu'à 2/3 des endroits vacants du sondage. En cas d'échec, sera de retour pendant un certain temps et de réessayer plus tard. De plus, après les échecs, il ne créera qu'une seule nouvelle session. Les deux sont définis en termes d'interface stream_client::connector::pool_strategy , vous êtes donc libre d'en implémenter un nouveau.
Limites:
Compte tenu de cela, la meilleure stratégie pour utiliser un pool de connexion est telle:
Il est important de jeter les sockets en échec et de ne pas les réutiliser, ou la gestion de la réponse à la demande sera désagréable.
Pools de connexion:
stream_client::connector::tcp_pool - Pool of stream_client::tcp_client Sockets.stream_client::connector::udp_pool - Pool of stream_client::udp_client Sockets.stream_client::connector::ssl_pool - Pool of stream_client::ssl::ssl_client SOCKETS.stream_client::connector::http_pool - Pool of stream_client::http::http_client sockets.stream_client::connector::https_pool - Pool of stream_client::http::https_client sockets.Il existe également des alias pour les mêmes pools mais en utilisant une stratégie de reconnexion conservatrice:
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 ();
} La bibliothèque utilise l'interface de bûcheron de base implémentée en interne. Vous pouvez modifier le niveau de journalisation à l'aide stream_client::set_log_level() ou des fonctions stream_client::get_log_level() .
Ces niveaux sont pris en charge:
enum class log_level : int
{
trace = 0 ,
debug,
info,
warning,
error,
};Par défaut, la bibliothèque imprime les messages à Stdout avec un formatage décent. Si vous souhaitez écraser ce comportement, vous pouvez définir votre propre journaliste via:
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);Qui permet de remplacer l'instance de journalisation de l'utilisation d'un rappel avec une signature appropriée. Ces types sont définis comme:
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)>;Pour plus d'informations, veuillez consulter Logger.hpp.
Cette bibliothèque censée être quelque peu multiplateforme, cependant, elle a été testée et principalement utilisée sur Ubuntu et MacOS.
Préférez le bâtiment à l'extérieur.
sudo apt update
sudo apt install build-essential cmake libboost-dev libboost-system-dev libssl-devbrew install cmake pkg-config icu4c openssl boostPour construire:
cmake -H. -Bbuild
cmake --build ./buildPour installer (sudo peut être nécessaire):
cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=OFF -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build --target installOu tester:
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-failureToutes ces commandes supposent que vous êtes dans un dossier racine de flux-client
RelWithDebInfo par défaut.ON par défaut.OFF par défautOFF par défaut.OFF par défaut.OFF , ces options sont définies. Développé sur Tinkoff.ru en 2020.
Distributé sous la licence APCache 2.0 . Vous pouvez également obtenir cette licence sur https://www.apache.org/licenses/license-2.0.
Auteur - [email protected]
RETENUSERS COURANTS - [email protected], [email protected]
