shackle

manille

Cadre client réseau Erlang haute performance

Exigences

• Erlang 19.0+

Caractéristiques

• Contre-pression via backlog (protection MOO)
• Implémentation rapide du pool (aléatoire, round_robin)
• Délais d'attente gérés
• Prise en charge multiprotocole (SSL/TCP/UDP)
• Optimisé pour les performances
• Pipelinisation des demandes
• Mécanisme de reconnexion intelligent (intervalle exponentiel)

Objectifs du cadre

• Réutilisabilité
• Vitesse
• Concurrence
• Sécurité

Comment faire

Implémentation d'un client

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

Démarrage du pool de clients

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

options_client :

Nom	Taper	Défaut	Description
adresse	inet:adresse_ip() | inet: nom d'hôte ()	"127.0.0.1"	adresse du serveur (anciennement ip)
port	inet:numéro_port()	indéfini	port du serveur
protocole	manille_tcp | manille_udp | manille_ssl	manille_tcp	protocole du serveur
reconnecter	booléen()	vrai	reconnecter les connexions fermées
reconnect_time_max	pos_entier() | infini	120000	temps de reconnexion maximum en millisecondes
reconnect_time_min	pos_entier()	1000	temps de reconnexion minimum en millisecondes
options_socket	[gen_tcp:connect_option() | gen_udp:option()]	[]	options passées au socket

pool_options :

Nom	Taper	Défaut	Description
backlog_size	pos_entier() | infini	1024	nombre maximum de requêtes simultanées par connexion
max_retries	non_neg_integer()	3	nombre maximum d'essais pour trouver un serveur actif
taille_piscine	pos_entier()	16	nombre de connexions
stratégie_pool	aléatoire | tournoi à la ronde	aléatoire	stratégie de sélection de connexion

Client d'appel/casting

 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 " >>}

Télémétrie

Shackle s'intègre à la bibliothèque de télémétrie indépendante du backend. Voir shackle_telemetry pour la liste des événements de télémétrie que shackle peut émettre.

Essais

make dialyzer
make eunit
make xref

Tests de performances

Pour exécuter des cibles de tests de performances, vous devez d'abord démarrer le serveur :

 ./bin/server.sh

Ensuite, vous pouvez exécuter le bench ou la cible profile :

make bench
make profile

Clientèle

Nom	Description
ancre	Client Memcaché
nœud aspike	Client Aerospike
bouée	Client HTTP 1.1
éclater	Producteur Kafka
marina	Cassandra Client CQL
statsderl	Client StatsD

Licence

 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.