Protocole fiabilisé sur UDP

Récupérez le serveur LongSumServer.jar, qui prend en argument le port sur lequel il écoute. Par exemple, lancez-le sur votre machine par:

% java -jar LongSumServer.jar 7777 

Ce serveur implémente le protocole décrit ci-dessous.

Le client envoie des paquets contenant chacun un des nombres de la sommes avec leur position dans la somme et la taille (le nombre d'opérande) de la somme. Plus précisément, si le client veut réaliser la somme de n long : v0, ..., v(n-1), il envoie des paquets contenant 3 long (24 octets au total) en BigEndian. Le premier est un indice entre 0 et n-1, le deuxième est n et le troisième est le long de la somme.

--------------------------------------
|   i      |   n       |     vi      |
--------------------------------------

A la réception d'un tel paquet, le serveur revoie un paquet contenant un octet b suivit d'un long val en BigEndian.

--------------------------
|   b     |    val       |
--------------------------

Si le serveur n'a pas encore reçu tous les longs de la somme, b vaut 0 et val est la position du paquet reçu. Si le serveur a reçu tous les longs de la somme, b vaut 1 et val est la somme de tous les longs reçus.

Par exemple si le client veut faire la somme de 3 et 4, il pourra envoyer le paquet [0,2,3]. Il recevra le paquet [0,0] du serveur. Il enverra ensuite le paquet [1,2,4]. Il recevra le paquet [1,7] du serveur car le serveur a reçu tous les paquets du clients.

On veut dans un premier temps réaliser un client naïf qui a le comportement suivant. Il renvoie le paquet correspondant au premier long de la somme jusqu'à ce qu'il reçoive l'accusé de réception correspondant. Ensuite il passe au deuxième nombre, etc. Développez un client, LongSumClient, qui prend en argument l'adresse et le port du serveur. Vous partirez du fichier LongSumClient.java où l'on crée une liste de 500 longs dont on calcule la somme puis on appelle la méthode send qui doit réaliser la somme en passant par le serveur. On vérifie que les deux sommes sont égales.

Vous devez tester que votre client marche même en présence de pertes de paquets. Ce comportement se produit rarement sur un réseau local. Le programme UDPProxy.jar va nous permettre de le simuler sur votre machine. UDPProxy est un proxy UDP qui va perdre un certain pourcentage des paquets et qui va échanger aléatoirement l'ordre des paquets. Pour l'utiliser, lancez dans trois shell différents les trois applications suivantes:

$ java fr.upem.net.udp.LongSumServer 7777  
$ java -jar UDPProxy.jar 5555 localhost 7777 -long 
$ java fr.upem.net.udp.LongSumClient localhost 5555 

Dans cet example, UDPProxy écoute sur le port 5555 et renvoie les paquets vers localhost:7777.

Réaliser un client plus évolué qui a deux threads. Un thread envoie les paquets et l'autre qui reçoit les accusés de réceptions. Le thread qui reçoit mémorise les numéros des paquets reçus par le serveur dans un BitSet qui sera partagé avec le thread qui envoie. Le thread qui envoie utilise une DelayQueue pour gérer les paquets. Une DelayQueue est une structure permettant de mettre des objets en donnant un délai avant qu'ils ne soient autorisés à être repris dans la queue. Allez lire la javadoc sur cette classe, vous verrez que les objets que l'on met dans la DelayQueue doivent implémenter l'interface Delayed. La classse DelayedData.java vous donne un point de départ. Le principe du thread qui fait les envois est le suivant: il remplit la queue avec tous les paquets. Ensuite il prend un paquet de la queue (take) puis il vérifie si l'accusé de réception a été reçu. Si c'est le cas, il n'a rien faire et il recommence à prendre des paquets dans la queue. Si l'accusé de réception n'a pas été reçu, il envoie le paquet correspondant et il rajoute le paquet avec un délai égale au temps d'attente souhaité.

Réalisez maintenant le serveur UDPLongSumServer qui implémente les mêmes services que le LongSumServer.jar que vous avez utilisé pour tester vos clients dans l'exercice précédent.