stream client
v1.4.2
Esta é uma biblioteca leve, somente para cabeçalho, baseada em impulso, que fornece primitivas de rede do lado do cliente para organizar e implementar facilmente a transmissão de dados com pontos de extremidade remotos.
Esta biblioteca:
Se você estiver escrevendo software no C ++, que se comunica com outros serviços como cliente, provavelmente já veio com o problema - precisa implementar a camada de conectividade para fornecer transporte de rede a todos os serviços relacionados. É exatamente isso que o objetivo desta biblioteca de resolver.
Os soquetes são implementados no topo do boost::asio::basic_socket e fornecem aulas com controle de tempo limite; portanto, na maioria dos casos, é suficiente para ligar para send () / receba () / write_some () / read_wome () com um prazo ou tempo limite. Os dados fornecidos às operações de E/S devem ser envolvidos no boost::asio::buffer . Basicamente, esses clientes são boost::asio::ip Sockets e têm a mesma interface.
Cliente transmite aulas:
stream_client::tcp_client - cliente de soquete de fluxo TCP simples. Suporta send () / rececive () para transferências admitidas de buffer inteiro junto com write_some () / read_wer () para transferir pelo menos alguma coisa.stream_client::udp_client - cliente de soquete UDP simples. Suporta apenas send () / receba () sem qualquer reconhecimento conforme as especificações UDP.stream_client::ssl::ssl_client - cliente TCP criptografado por SSL. Tenha as mesmas funções que tcp_client Plus SSL Handshake e Controle de contexto.stream_client::http::http_client - cliente http. Envolva tcp_client com boost::beast::http::parser e boost::beast::http::serializer e tenha executado () função para fazer chamadas de reposição de solicitação.stream_client::http::https_client - cliente https. O mesmo que http_client , mas usa o cliente ssl_client abaixo. 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; O resolvedor é implementado em torno da mesma ideia - faça sincronização, resolvedor de DNS cronometrado; portanto, ele usa boost::asio::ip::basic_resolver para executar a resolução real dentro de tempo limite especificado.
É o modelo de classe com um único parâmetro - protocolo de resultado, você também pode especificar em que tipo de pontos de extremidade IP está interessado - IPv4, IPv6 ou ambos. Resolução realizada com a chamada Resolve (), que possui uma assinatura semelhante às operações de soquetes - você é livre para especificar o tempo limite/prazo ou usar o padrão.
Classes de resolver:
stream_client::resolver::tcp_resolver - Resolver que retorna o iterador dos pontos de extremidade do TCP.stream_client::resolver::udp_resolver - Resolver que retorna o iterador dos pontos de extremidade do 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>O Connector usa o Resolver para executar a resolução DNS e atualizar a lista de pontos de extremidade e os usa se solicitado com new_session () , para criar um novo soquete do protocolo especificado. O trabalho do resolvedor de DNS é envolvido no encadeamento de segundo plano que acionou a criação ou se houve um erro na abertura de um novo soquete.
Target endpoint para abrir um novo soquete selecionado aleatoriamente dos resultados do DNS, o que o torna o conector equilibrado para um host remoto. Além disso, o conector permite especificar tempos de tempo separados para resolução, conexão e operação de E/S de novos soquetes.
Classes de conector:
stream_client::connector::tcp_connector - Conector TCP, para obter stream_client::tcp_client .stream_client::connector::udp_connector - conector UDP, para obter stream_client::udp_client soquetes.stream_client::connector::ssl_connector - Conector TCP, para obter stream_client::ssl::ssl_client soques.stream_client::connector::http_connector - conector http, para obter stream_client::http::http_client soques.stream_client::connector::https_connector - conector https, para obter stream_client::http::https_client soques. 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()));Representa o recipiente ocupado com soquetes abertos. Usa o conector para abrir novos soquetes no encadeamento de segundo plano que é acionado quando houver locais vagos na piscina. O usuário pode ligar para get_session () para obter um soquete do pool e return_session () para devolvê -lo.
Existem duas estratégias para reabastecer a piscina:
stream_client::connector::greedy_strategy ). Se houver lugares vagos, tentará preenchê -los com novas sessões simultaneamente. Este é o padrão.stream_client::connector::conservative_strategy ). Tentará preencher até 2/3 de lugares vagos na pesquisa. Se falhar, voltará por algum tempo e tente novamente. Além disso, após falhas, ele criará apenas uma nova sessão. Ambos são definidos em termos de interface stream_client::connector::pool_strategy , para que você esteja livre para implementar o novo.
Limitações:
Considerando isso, a melhor estratégia para usar um pool de conexões é tal:
É importante descartar os soquetes na falha e não reutilizá-los, ou o gerenciamento de resposta-resposta será desagradável.
Pools de conexão:
stream_client::connector::tcp_pool - pool de stream_client::tcp_client .stream_client::connector::udp_pool - stream_client::udp_client SOQUETS.stream_client::connector::ssl_pool - pool de stream_client::ssl::ssl_client Sockets.stream_client::connector::http_pool - pool de stream_client::http::http_client soquetes.stream_client::connector::https_pool - pool de stream_client::http::https_client soquetes.Também existem aliases para as mesmas piscinas, mas usando a estratégia conservadora de reconexão:
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 ();
} A biblioteca usa interface básica de logger implementada internamente. Você pode modificar o nível do logger usando as funções stream_client::set_log_level() ou stream_client::get_log_level() .
Esses níveis são suportados:
enum class log_level : int
{
trace = 0 ,
debug,
info,
warning,
error,
};Por padrão, a biblioteca imprime as mensagens para stdout com formatação decente. Se você deseja substituir esse comportamento, você pode definir o seu próprio Logger 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);Que permite substituir a instância do logger de usar um retorno de chamada com a assinatura adequada. Esses tipos são define como:
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)>;Para mais informações, procure no Logger.hpp.
Essa biblioteca deveria ser um pouco multi-plataforma, no entanto, foi testada e usada principalmente no Ubuntu e MacOS.
Prefira o edifício fora da fonte.
sudo apt update
sudo apt install build-essential cmake libboost-dev libboost-system-dev libssl-devbrew install cmake pkg-config icu4c openssl boostPara construir:
cmake -H. -Bbuild
cmake --build ./buildPara instalar (sudo pode ser necessário):
cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=OFF -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build --target installOu teste:
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-failureTodos esses comandos assumem que você está na pasta raiz do fluxo de fluxo de fluxo
RelWithDebInfo por padrão.ON .OFF por padrãoOFF por padrão.OFF por padrão.OFF , essas opções serão definidas. Desenvolvido em tinkoff.ru em 2020.
Distribuído na licença Apache License 2.0 . Você também pode obter esta licença em https://www.apache.org/license/license-2.0.
Autor - [email protected]
Mantenedores atuais - [email protected], [email protected]
