shackle

algema

Estrutura de cliente de rede Erlang de alto desempenho

Requisitos

• Erlang 19.0+

Características

• Contrapressão via backlog (proteção OOM)
• Implementação rápida de pool (random, round_robin)
• Tempos limite gerenciados
• Suporte multiprotocolo (SSL / TCP / UDP)
• Otimizado para desempenho
• Solicitar pipeline
• Mecanismo de reconexão inteligente (retirada exponencial)

Metas estruturais

• Reutilização
• Velocidade
• Simultaneidade
• Segurança

Como fazer

Implementando um cliente

- behavior ( shackle_client ).
- export ([
    init / 0 ,
    setup / 2 ,
    handle_request / 2 ,
    handle_data / 2 ,
    terminate / 1
]).

- record ( state , {
    buffer =       <<>> :: binary (),
    request_counter = 0 :: non_neg_integer ()
}).

- spec init ( Options :: term ()) ->
    { ok , State :: term ()} |
    { error , Reason :: term ()}.

init ( _Options ) ->
    { ok , # state {}}.

- spec setup ( Socket :: inet : socket (), State :: term ()) ->
    { ok , State :: term ()} |
    { error , Reason :: term (), State :: term ()}.

setup ( Socket , State ) ->
    case gen_tcp : send ( Socket , << " INIT " >>) of
        ok ->
            case gen_tcp : recv ( Socket , 0 ) of
                { ok , << " OK " >>} ->
                    { ok , State };
                { error , Reason } ->
                    { error , Reason , State }
            end ;
        { error , Reason } ->
            { error , Reason , State }
    end .

- spec handle_request ( Request :: term (), State :: term ()) ->
    { ok , RequestId :: external_request_id (), Data :: iodata (), State :: term ()}.

handle_request ( noop ,  State ) ->
    Data = arithmetic_protocol : request ( 0 , noop , 0 , 0 ),

    { ok , undefined , Data , State };
handle_request ({ Operation , A , B }, # state {
        request_counter = RequestCounter
    } = State ) ->

    RequestId = request_id ( RequestCounter ),
    Data = request ( RequestId , Operation , A , B ),

    { ok , RequestId , Data , State # state {
        request_counter = RequestCounter + 1
    }}.

- spec handle_data ( Data :: binary (), State :: term ()) ->
    { ok , [{ RequestId :: external_request_id (), Reply :: term ()}], State :: term ()}.

handle_data ( Data , # state {
        buffer = Buffer
    } = State ) ->

    Data2 = << Buffer / binary , Data / binary >>,
    { Replies , Buffer2 } = parse_replies ( Data2 , []),

    { ok , Replies , State # state {
        buffer = Buffer2
    }}.

- spec terminate ( State :: term ()) -> ok .

terminate ( _State ) -> ok .

Iniciando pool de clientes

 shackle_pool : start ( shackle_pool : name (), client (), client_options (), pool_options ())

opções_cliente:

Nome	Tipo	Padrão	Descrição
endereço	inet:endereço_ip() | inet:nome do host()	"127.0.0.1"	endereço do servidor (anteriormente ip)
porta	inet:número_porta()	indefinido	porta do servidor
protocolo	manilha_tcp | manilha_udp | manilha_ssl	shackle_tcp	protocolo do servidor
reconectar	booleano()	verdadeiro	reconectar conexões fechadas
reconnect_time_max	pos_inteiro() | infinidade	120.000	tempo máximo de reconexão em milissegundos
reconnect_time_min	pos_inteiro()	1000	tempo mínimo de reconexão em milissegundos
opções_de_soquete	[gen_tcp:connect_option() | gen_udp:opção()]	[]	opções passadas para o soquete

opções_de_pool:

Nome	Tipo	Padrão	Descrição
backlog_size	pos_inteiro() | infinidade	1024	número máximo de solicitações simultâneas por conexão
max_retries	não_neg_inteiro()	3	número máximo de tentativas para encontrar um servidor ativo
tamanho_da_piscina	pos_inteiro()	16	número de conexões
pool_strategy	aleatório | round_robin	aleatório	estratégia de seleção de conexão

Cliente de chamada/transmissão

 1 > shackle : call ( pool_name , { get , << " test " >>}).
{ ok , << " bar " >>}

2 > { ok , ReqId } = shackle : cast ( pool_name , { get , << " foo " >>}, 500 ).
{ ok , { anchor , anchor_client , # Ref < 0.0 . 0.2407 > }}

3 > shackle : receive_response ( ReqId ).
{ ok , << " bar " >>}

Telemetria

Shackle se integra à biblioteca de telemetria independente de backend. Consulte shackle_telemetry para obter a lista de eventos de telemetria que o shackle pode emitir.

Testes

make dialyzer
make eunit
make xref

Teste de desempenho

Para executar alvos de teste de desempenho você deve primeiro iniciar o servidor:

 ./bin/server.sh

Então você pode executar o bench ou profile de destino:

make bench
make profile

Clientes

Nome	Descrição
âncora	Cliente Memcached
nó aspike	Cliente Aerospike
bóia	Cliente HTTP 1.1
brilho	Produtor Kafka
marina	Cliente Cassandra CQL
estatísticasderl	Cliente StatsD

Licença

 The MIT License (MIT)

Copyright (c) 2015-2023 Louis-Philippe Gauthier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.