Descargar stream client - Descargar el código fuente stream client

Stream-cliente

Esta es una biblioteca liviana, solo para encabezado, basada en Boost, que proporciona primitivas de red del lado del cliente para organizar e implementar fácilmente la transmisión de datos con puntos finales remotos.

Esta biblioteca:

Inspirado y construido alrededor de Boost.asio.
Proporciona construcciones de alto nivel como conector y grupo de conexión.
Admite protocolos TCP / UDP / SSL / HTTP / HTTPS .
Utiliza enchufes con la misma interfaz que BOOST :: ASIO :: IP.
Permite el tiempo de espera/fecha límite transparente para todas las operaciones.
Requiere Boost 1.65+ o 1.66+ si planea usar el protocolo HTTP.

Por qué

Si está escribiendo software en C ++, que se comunica con otros servicios como cliente, probablemente ya llegó con el problema: necesite implementar la capa de conectividad para proporcionar transporte de red a todos los servicios relacionados. Esto es exactamente lo que tiene como objetivo resolver esta biblioteca.

Cómo usar

Bocadillos

Los sockets se implementan además de boost::asio::basic_socket y proporcionan clases con control de tiempo de espera, por lo que en la mayoría de los casos es suficiente simplemente llamar a Send () / Recibir () / Write_Some () / Read_Some () con una fecha límite o un tiempo de espera. Los datos suministrados a las operaciones de E/S deben envolverse en boost::asio::buffer . Básicamente, estos clientes están boost boost::asio::ip sockets y tienen la misma interfaz.

Clases de transmisión del cliente:

stream_client::tcp_client - Cliente de socket de transmisión TCP simple. Admite send () / rececive () para transferencias admitidas de búfer completo junto con write_some () / read_some () para transferir al menos algo.
stream_client::udp_client - Cliente de socket UDP simple. Admite solo enviar () / recibir () sin ningún reconocimiento según las especificaciones de UDP.
stream_client::ssl::ssl_client - cliente TCP cifrado SSL. Tenga las mismas funciones que tcp_client Plus SSL Handshake y Context Control.
stream_client::http::http_client - client http. Wraps tcp_client con boost::beast::http::parser and boost::beast::http::serializer y tener funciones real () para realizar llamadas de respuesta a la respuesta.
stream_client::http::https_client - client https. Igual que http_client pero usa el cliente ssl_client debajo.

Ejemplo

 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;

Resolución de DNS

El resolución se implementa en torno a la misma idea: haga sincronización, resolución DNS cronometrada, por lo tanto, usa boost::asio::ip::basic_resolver para realizar una resolución real dentro de tiempos de espera especificados.

Es la plantilla de clase con un solo parámetro - Protocolo de resultados, también puede especificar qué tipo de puntos finales IP le interesan: IPv4, IPv6 o ambos. Resolución realizada con la llamada Resolve () que tiene una firma similar a las operaciones de sockets: puede especificar el tiempo de espera/fecha límite o usar uno predeterminado.

Clases de resolución:

stream_client::resolver::tcp_resolver - resolución que devuelve el iterador de los puntos finales TCP.
stream_client::resolver::udp_resolver - resolución que devuelve el iterador de los puntos finales UDP.

Ejemplo

 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>

Conector

Connector usa resolución para realizar la resolución DNS y actualizar la lista de puntos finales y los usa si se solicita con new_session () , para crear un nuevo socket del protocolo especificado. El trabajo del resolución DNS está envuelto en un hilo de fondo que se activó en la creación o si había un error al abrir un nuevo socket.

El punto final de destino para abrir un nuevo socket seleccionado al azar de los resultados de DNS, lo que hace que sea un conector equilibrado a un host remoto. Además, el conector permite especificar tiempos de espera separados para resolución, conexión y operación de E/S de enchufes nuevos.

Clases de conector:

stream_client::connector::tcp_connector - conector tcp, para obtener stream_client::tcp_client sockets.
stream_client::connector::udp_connector - conector UDP, para obtener stream_client::udp_client sockets.
stream_client::connector::ssl_connector - conector tcp, para obtener stream_client::ssl::ssl_client sockets.
stream_client::connector::http_connector - conector http, para obtener stream_client::http::http_client sockets.
stream_client::connector::https_connector - conector https, para obtener stream_client::http::https_client sockets.

Ejemplo

 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()));

Grupo de conexión

Representa un contenedor ocupado con enchufes abiertos. Utiliza el conector para abrir enchufes nuevos en el hilo de fondo que se activa una vez que hay lugares vacantes en la piscina. El usuario puede llamar a get_session () para obtener un socket del grupo y return_session () para devolverlo.

Hay dos estrategias para rellenar el grupo:

Greedy ( stream_client::connector::greedy_strategy ). Si hay lugares vacantes, intentará llenarlos con nuevas sesiones simultáneamente. Este es el predeterminado.
conservador ( stream_client::connector::conservative_strategy ). Intentará llenar hasta 2/3 de lugares vacantes en la encuesta. Si falló, volverá por algún tiempo y volverá a intentarlo más tarde. Además, después de las fallas creará solo una nueva sesión.

Ambos se definen en términos de interfaz stream_client::connector::pool_strategy , por lo que puede implementar uno nuevo.

Limitaciones:

Los enchufes que ya están en la piscina no se verifican ni se mantienen de ninguna manera. Por lo tanto, el grupo no garantiza que todos los enchufes se abran en un punto arbitrario en el tiempo debido a la complejidad de tales controles para todos los protocolos compatibles.
Nada específico hecho con enchufes en su retorno dentro de return_session () . Por lo tanto, si tienen o tendrán datos pendientes para leer, permanecerá allí hasta la lectura.

Teniendo en cuenta esto, la mejor estrategia para usar un grupo de conexión es tal:

Ciéntalo, especificando todos los tiempos de espera como lo necesite.
Una vez creado, use get_session () para obtener el socket abierto.
Necesitaba operaciones de E/S en el enchufe.
Si 2-3 tiene éxito, devuélvalo de regreso con return_session () , de lo contrario, repita el punto 2.

Es importante descartar los enchufes en el fracaso y no reutilizarlos, o la gestión de solicitud de solicitud se volverá desagradable.

Piscinas de conexión:

stream_client::connector::tcp_pool - Pool of stream_client::tcp_client enchufes.
stream_client::connector::udp_pool - Pool of stream_client::udp_client Sockets.
stream_client::connector::ssl_pool - piscina de stream_client::ssl::ssl_client enchufes.
stream_client::connector::http_pool - Pool of stream_client::http::http_client enchufes.
stream_client::connector::https_pool - Pool of stream_client::http::https_client enchufes.

También hay alias para los mismos grupos pero utilizando una estrategia de reconexión conservadora:

stream_client::connector::tcp_conservative_pool
stream_client::connector::udp_conservative_pool
stream_client::connector::ssl_conservative_pool
stream_client::connector::http_conservative_pool
stream_client::connector::https_conservative_pool

Ejemplo

 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 ();
}

Explotación florestal

La biblioteca utiliza interfaz de registrador básico implementada internamente. Puede modificar el nivel de registro usando las funciones stream_client::set_log_level() o stream_client::get_log_level() .

Estos niveles son compatibles:

 enum class log_level : int
{
    trace = 0 ,
    debug,
    info,
    warning,
    error,
};

Por defecto, la biblioteca imprime mensajes a stdout con formato decente. Si desea sobrescribir este comportamiento, puede establecer su propio Logger a través de:

 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 sobrescribir la instancia del registrador de usar una devolución de llamada con la firma adecuada. Estos tipos se 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 obtener más información, busque dentro de Logger.hpp.

Cómo construir

Se supone que esta biblioteca es algo multiplataforma, sin embargo, se probó y se usó principalmente en Ubuntu y MacOS.
Prefiere un edificio fuera de casa.

Dependencias de Ubuntu

sudo apt update
sudo apt install build-essential cmake libboost-dev libboost-system-dev libssl-dev

dependencias de macOS

brew install cmake pkg-config icu4c openssl boost

Para construir:

cmake -H. -Bbuild
cmake --build ./build

Para instalar (se puede requerir sudo):

cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=OFF -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build --target install

O prueba:

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-failure

Todos estos comandos suponen que está en la carpeta de raíz de Stream-Client

Opciones de cmake

CMAKE_BUILD_TYPE - Tipo de compilación. RelWithDebInfo por defecto.
Build_shared_libs - Build Biblioteca compartida o estática. ON por defecto.
StreamClient_Build_Testing : construya pruebas o no. OFF por defecto
StreamClient_Build_ExAMPLES - CONSTRUIR Ejemplos de biblioteca o no. OFF por defecto.
StreamClient_Build_Docs - Build HTML (Sphinx) Documentos de referencia. OFF por defecto.
OPENSSL_USE_STATIC_LIBS - LINK STATICA O DINÁMICA CONTRA EN CONTRACIÓN DE OPENSSL. Si Build_shared_libs está OFF , entonces estas opciones están configuradas.
OPENSSL_ROOT_DIR - Carpeta dónde buscar OpenSSL. Establecido por PKG-Config de Brew por defecto.

Licencia

Desarrollado en tinkoff.ru en 2020.
Distribuida bajo la licencia Apache 2.0 . También puede obtener esta licencia en https://www.apache.org/licenses/license-2.0.