Groupes J

JGroups est une bibliothèque pour une communication fiable de type un-à-un ou un-à-plusieurs écrite en langage Java .

Il peut être utilisé pour créer des groupes de processus dont les membres s'envoient des messages. JGroups permet aux développeurs de créer des applications multipoints (multicast) fiables lorsque la fiabilité est un problème de déploiement. JGroups évite également au développeur d'applications d'implémenter lui-même cette logique. Cela permet de gagner un temps de développement considérable et de déployer l'application dans différents environnements sans avoir à modifier le code.

• Création et suppression de groupes. Les membres du groupe peuvent être répartis sur des réseaux LAN ou WAN
• Rejoindre et quitter des groupes
• Détection d'adhésion et notification concernant les membres rejoints/quittés/en panne
• Détection et suppression des membres en panne
• Envoi et réception de messages de membre à groupe (point à multipoint)
• Envoi et réception de messages de membre à membre (point à point)

Ce code ci-dessous illustre l'implémentation d'un client IRC en ligne de commande simple utilisant JGroups :

classe publique Chat étend ReceiverAdapter { canal JChannel privé ;
public Chat ( chaîne d'accessoires , chaîne de nom ) { canal = nouveau JChannel ( accessoires ) . setName ( nom ) . setReceiver ( ceci ) . connect ( "ChatCluster" ); }
public void viewAccepted ( Afficher la vue ) { System . out . printf ( "** vue : %s " , vue ); }
public void receive ( Message msg ) { System . out . printf ( "de %s : %s " , msg . getSource (), msg . getObject ()); }
privé void send ( String line ) { try { channel . send ( new Message ( null , line )); } catch ( Exception e ) {} }
public void run () lève une exception { BufferedReader in = nouveau BufferedReader ( nouveau InputStreamReader ( System . in ));
while ( true ) { System . out . print ( "> " ); System . out . flush (); send ( in . readLine (). toLowerCase ()); } }
public void end () lève une exception { canal . close (); }
public static void start ( Chat client ) throws Exception { try { client . run (); } catch ( Exception e ) { } finally { client . end (); } }
public static void main ( String [] args ) lève une exception { String props = "udp.xml" ; String nom ;
pour ( int i = 0 ; i < args . length ; i ++ ) { si ( args [ i ] . equals ( "-props" )) { props = args [++ i ] ; continue ; }
si ( args [ i ] . equals ( "-name" )) { nom = args [++ i ] ; continuer ; }
Système . out . println ( "Chat [-props XML config] [-name nom]" ); 
return ; }
démarrer ( nouveau Chat ( props , nom )); } }

Un JChannel est instancié à partir d'une configuration XML (par exemple udp.xml). Le canal est le point de terminaison permettant de rejoindre un cluster.

Ensuite, le récepteur est défini, ce qui signifie que deux rappels seront invoqués :

• viewAccepted(Viewview)lorsqu'un nouveau membre rejoint ou qu'un membre existant quitte le cluster
• receive(Messagemsg)lorsqu'un message provenant d'un autre membre du cluster est reçu

Ensuite, le canal rejoint le cluster « ChatCluster ». À partir de maintenant, les messages peuvent être envoyés et reçus, et une nouvelle vue (incluant ce membre) sera installée dans tous les membres du cluster (y compris le membre nouvellement rejoint).

Tout ce qui est tapé dans la boucle principale entraîne la création d’un message à envoyer à tous les membres du cluster, y compris l’expéditeur.

Les instances de l'application de chat peuvent être exécutées dans le même processus, sur la même machine, sur différents hôtes du réseau local, sur des hôtes de différents réseaux ou dans le cloud. Le code reste le même ; seule la configuration doit être modifiée.

Par exemple, dans un réseau local, la multidiffusion IP peut être utilisée. Lorsque la multidiffusion IP est désactivée, TCP peut être utilisé comme transport. Lorsqu'il est exécuté dans le cloud, TCP plus un protocole de découverte de cloud seraient utilisés, et ainsi de suite...

La fonctionnalité la plus puissante de JGroups est sa pile de protocoles flexible, qui permet aux développeurs de l'adapter pour correspondre exactement aux exigences de leurs applications et aux caractéristiques de leur réseau. L'avantage est que vous ne payez que ce que vous utilisez. En mélangeant et en associant les protocoles, diverses exigences d'application différentes peuvent être satisfaites. JGroups est fourni avec un certain nombre de protocoles (mais tout le monde peut écrire le sien), par exemple

• Protocoles de transport : UDP ( IP multicast ), TCP
• Fragmentation de messages volumineux
• Protocoles de découverte pour découvrir l'appartenance initiale d'un nœud qui rejoint
• Transmission fiable des messages en monodiffusion et en multidiffusion. Les messages perdus sont retransmis
• Détection d'échec : les membres en panne sont exclus de l'adhésion
• Protocoles de commande : Fifo, Total Order (basé sur un séquenceur ou un jeton)
• Adhésion et notification des membres rejoints ou abandonnés
• Détection et fusion de partitions réseau (split brain)
• Contrôle de flux
• Cryptage et authentification (y compris prise en charge SASL)
• Compression

Les blocs de construction sont des classes superposées sur les canaux JGroups, qui fournissent des abstractions de niveau supérieur telles que

• RPC vers des nœuds individuels ou vers tous les nœuds du cluster
• Caches distribués
• Serrures distribuées
• Compteurs atomiques distribués
• Exécution de tâches distribuées