Créer un reseau en java

merci pour ta réponse il me semble que t bien compris le sujet mais ce que j arrive pas a comprendre c'est comment faire le relayage entre les machine par ce que les choses avec 2 machine sont plus simple en spécifiant que l'@ip source et @ip destination mais avec plusieurs machine intermédiaire ..........
et merci d'avance

Et bien en plus de transmettre le programme, tu vas transmettre l'adresse ip du client dans le contenu du message. Si la machine qui reçoit le message est le client, c'est fini, sinon elle doit avoir une table de routage pour savoir à qui (client ou serveur intermédiaire) renvoyer le message (programme+adresse ip).
Éventuellement la table de routage peut-être embarqué dans le message, c'est à dire que l'émetteur liste tous les serveurs intermédiaires par lequel le message doit passer.

Exemple :

Emetteur envoie [serveur1, serveur2, serveur3, client] au serveur1
Serveur 1 reçoit le message et envoi à serveur2 [serveur2, serveur3, client]
Serveur 2 reçoit le message et envoi à serveur3 [serveur3, client]
Serveur 3 reçoit le message et envoi à client [client]

je te remercie je pense que ce que tu dis comme principe sa peut marcher juste que j'ai peur a ce que cette solution soit nom valable dans le cas ou je doit passer a la 2etape qui est pouvoir acheminer le fichier en calculant le bon chemin dynamiquement et nom statiquement comme tu l a indiqué
j attend t réponse
merci d'avance

Statique ou dynamique, je ne suis pas sûr que ce problème intervienne dans ce que j'ai expliqué.

Dans mon exemple la liste "serveur1... client" n'est pas forcément statique. Le serveur1 peut très bien avoir construit dynamiquement ce chemin en fonction de l'état du réseau. En fait ça correspondrait à ce qu'on appelle un mode connecté. Le chemin est le même pour l'envoi de la donnée complète (ce que tu veux vu que chaque serveur doit exécuter le programme) contrairement à un mode non-connecté, où les différents paquets peuvent ne pas tous transiter par les même serveurs (ex. le début du programme va passer par Serveur2, alors que la fin passera par Serveur4)

Comme je l'ai mentionné plus haut, le chemin n'est pas obligé d'être embarqué, auquel cas, chaque serveur détermine, quand il l'a reçu, comment rediriger le message un peu plus près du destinataire.
Mais il y a différentes manières de gérées ces tables de routages, mais toutes ne sont pas dynamiques (en particulier l'administrateur d'un réseau local,peut définir lui même son mappage de manière totalement statique).

Donc statique ou dynamique, la différence n'est pas vraiment pertinente par rapport à ce que j'ai proposé, la pertinence vient quand tu cherches à savoir quel doit être le contenu de la liste (comment tu la construit au départ) et là le choix pourra être de le faire statiquement ou dynamiquement.

dnc en gros soit statique en déterminant des le départ la liste des noeud a suivre ou dynamiquement en se basant sur une valeur de métrique défini statiquement entre 2 machine afin de pouvoir choisir entre les chemin
mais franchement du faite que je suis débutant en prog socket java je vais essayer d'acheminer un message entre 2 machine en passant par un intermédiaire: client----->serveur1------>serveur je pense que déjà ca un premier pas tu pense que c 'est pas compliqué ca??
j'attende de toi si possible d'aide au niveau code
merci de ta compréhension vraiment tes message m'ont éclairé un peu le principe
merci d'avance

Il n'y a aucune raison que out, adr et in, soient des membres static de classe alors que ce sont des variables locales ! Je regarderai ton code en détail un peu plus tard, mais l'utilisation de Object(Out/In)putStream, je ne m'en servirait que pour récupérer l'en-tête. Par exemple une List<String> qui contient les adresses IP du serveur. Mais pour la suite je traiterai le stream comme dans mon exemple de fichier.

J'ai repris mon code de transfert de fichiers pour y rajouter un en-tête.

public class Serveur
{	
	public static void main(String...args) throws IOException 
	{
		// Ouverture d'une communication
		Socket sock = new ServerSocket(Commun.port).accept();
		ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
		
		// Réception de l'en-tête
		int n = in.readInt();
		
		String[] tab = new String[n];
		
		for (int i=0; i<n; i++)
			tab[i]=in.readUTF();
					
		// Réception du fichier
		Commun.transfert(
				in,
				new FileOutputStream(new File("D:\\test2.png")),
				true);
		
		// Fermeture de la communication
		sock.close();
		
		// Affichage de l'en-tête		
		for (String s : tab)
			System.out.println(s);
	} 
}

public class Client
{
	public static void main(String...args) throws IOException 
	{  
		// En-tête à envoyer
		String[] tab = {"Serveur1", "Serveur2", "Client"};
		
		// Ouverture de la communication
		Socket sock = new Socket(InetAddress.getLocalHost(),Commun.port);
		ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());

		// Envoi de l'en-tête
		out.writeInt(tab.length);
		for (int i=0; i<tab.length; i++)
			out.writeUTF(tab[i]);
				
		// Envoi du fichier
		Commun.transfert(
				new FileInputStream(new File("D:\\test1.png")),
				out,
				true);
		
		// Fermeture de la communication
		sock.close();
	} 
}

Si j'ai bien compris, le fichier transféré est un exécutable qui doit être lancé sur les serveurs cibles.
Ce n'est donc pas tout à fait pour remplacer les routeurs ;-)

Pour qu'une machine relaye un fichier, il faut qu'après avoir été serveur, il devienne client.
Effectivement, j'ai mis localhost dans l'exemple, mais l'adresse du serveur à joindre par la suite sera le premier de la liste de l'en-tête (qu'il faut donc enlever pour construire l'en-tête suivant)
Le client sera donc la machine jointe avec une liste vide.

oui j'ai bien compris ca mais tu pense pas qui il faut donner des adresses differentes au serveur intermediare pour que on puisse identifier les serveur du chemin emprunté et du faite que le teste c'est sur une machine local qui seront ses adresse local different ???
merci de votre comprehnssion.

Je ne comprends pas la fin de ta phrase : "et du faite que le teste c'est sur une machine local qui seront ses adresse local different ???"

Quant aux adresses différentes à donner au serveur intermédiaire, elles lui sont communiquées dans la liste qu'il reçoit. Si ce que tu veux c'est te "souvenir" par quels serveurs intermédiaires le message vient de passer, tu n'as qu'à rajouter un entier dans l'en-tête qui te servira d'indice. La liste sera donc inchangé tout au long du parcours, seul l'indice sera incrémenté pour identifier le serveur suivant à contacter.

parce que en fait le but c'est que chaque serveur intermediare doit avoir une adresse logique pour l'identifier, ca va aider surtout pour faire les table de routage au niveau de chaque serveur
sourceIP destinatioIP

Et bien dans ta liste tu envoies les adresses logique des serveurs, c'est d'ailleurs pour ça que j'avais mis en exemple tab = {"Serveur1", "Serveur2", "Client"};
Quand tu veux envoyer le fichier au prochain serveur tu utilise le code client sauf qu'au lieu d'avoir InetAddress.getLocalHost() comme dans mon code, tu dois avoir InetAddress.getByName(tab[0]);

Je ne mets pas serveur1, mais "serveur1", avec des guillemets, ce sont des String pas des variables (regarde le type de tab). Donc il n'y aura pas de problème à la compilation vu que Java ne regarde pas le contenu des String, seul le type l'intéresse.
Chaque machine a une adresse et un nom (voire plusieurs alias) que tu peux utiliser dans la liste.
Par exemple tu peux passer l'adresse "127.0.0.1", ou bien son nom "localhost", et bien évidemment c'est valable pour les noms et adresses de toutes les machines de ton réseau.
Evidemment si tu veux travailler en local ça va être un peu plus compliqué à tester, vu qu'il te faut un réseau, mais avec une machine virtuelle ça reste faisable.

Vu que tu n'as qu'une seule machine, tes tables de routage seront très limitées !
Mais dans l'absolu ton code doit pouvoir marcher si la liste des adresses ip sont ["localhost", "localhost", "localhost"] sans même avoir changer de port.
Lorsque le serveur reçoit le fichier (de lui même) il interrompt la communication, il peut donc réutiliser le même port pour relayer le fichier (à lui même du coup)

Pas faux aussi :-)

Tu ne peux pas ouvrir sock et sock2 en même temps sur le même port.
Il faut attendre que sock soit fermée (après le transfert) pour ouvrir sock2.
D'ailleurs ici ton sock2 ne sers à rien, tu peux le supprimer.

Moi j'avais mis le code client et serveur dans deux main, mais il faudrait plutôt en faire des méthodes static, vu que chaque serveur va devoir lancer les deux l'un après l'autre.

Pour t'éviter ta manipulation de "null" dans ton tableau tu peux utiliser une LinkedList et faire des removeFirst.

Voici un code, qui peut t'aider à bien continuer, je ne dis pas qu'il fonctionne correctement, d'ailleurs j'ai moi aussi des problèmes avec le bind mais si au lieu de faire des throws tu gère les Exception avec des try/catch ça devrait mieux passer (idée : si tu lèves BindException, tu fermes la socket, tu attends 1 seconde, et tu réessayes)

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

import java.net.ServerSocket;
import java.net.Socket;

import java.util.LinkedList;

public class Commun
{
	public static final int port = 9001;
	
	public static void transfert(String role, InputStream in, OutputStream out, boolean closeOnExit) throws IOException
	{
		System.err.println(role+" transfert");
		
		byte buf[] = new byte[1024];
		
		int n;
		while((n=in.read(buf))!=-1)
			out.write(buf,0,n);
		
		if (closeOnExit)
		{
			in.close();
			out.close();
		}
	}
	
	public static void envoi(String role, LinkedList<String> serveurs, File fichier) throws IOException
	{
		System.err.println(role+" envoi");
		// Ouverture de la communication
		Socket sock = new Socket(serveurs.getFirst(),Commun.port);
		ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
	
		// Envoi de l'en-tête
		out.writeInt(serveurs.size());
		for (String srv : serveurs)
			out.writeUTF(srv);
						
		// Envoi du fichier
		Commun.transfert(
			role,
			new FileInputStream(fichier),
			out,
			true);
		
		// Fermeture de la communication
		sock.close();
	}
	
	public static LinkedList<String> recevoir(String role, File fichier) throws IOException 
	{
		System.err.println(role+" recevoir");
					
		// Ouverture d'une communication
		Socket sock = new ServerSocket(Commun.port).accept();
		ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
		
		// Réception de l'en-tête
		int n = in.readInt();
		
		LinkedList<String> serveurs = new LinkedList<String>();
		
		for (int i=0; i<n; i++)
			serveurs.add(in.readUTF());
							
		// Réception du fichier
		Commun.transfert(
				role,
				in,
				new FileOutputStream(fichier),
				true);
		
		// Fermeture de la communication
		sock.close();
				
		return serveurs;
	} 
	
	public static void repeter(String role, LinkedList<String> serveurs, File fichier) throws IOException
	{		
		// Client
		if (serveurs!=null && serveurs.size()>0)
			envoi(role, serveurs,fichier);
		
		// Serveur
		serveurs = recevoir(role, fichier);
		serveurs.removeFirst();
		
		// On recommence
		repeter(role, serveurs, fichier);
	}
	
	public static void main(String...args) throws IOException
	{
		// Serveur
		new Thread() 
		{
			@Override
			public void run()
			{
				try {
					repeter("Thread 1",null,new File("D:\\test2.png"));
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}.start();
				
		final LinkedList<String> serveurs = new LinkedList<String>();
			serveurs.add("localhost");
			serveurs.add("localhost");
			serveurs.add("localhost");
		
		// Client
		new Thread() 
		{
			@Override
			public void run()
			{
				try {
					repeter("Thread 2",serveurs,new File("D:\\test1.png"));
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}.start();
	}
}

1) Tu copies-colles la classe Commun dans un fichier Commun.java, tu compiles et tu exécutes.

2) Tu copies-colles les classes A et B dans deux fichiers A.java et B.java, et tu exécutes A, puis B

Tu choisis l'une des deux méthodes au choix, ça fera la même chose (j'avais fait la deuxième uniquement parce que tu ne comprenais pas la première)
Je ne vois vraiment pas ce qu'il y a de compliqué à tester ça...

Comme je l'avait dit au moment où j'ai publié le code, il y a encore des bugs quand on est en local, parce qu'il faudrait temporiser entre le moment où on ferme la socket et le moment où on la réouvre.
Mais si tu testes ça sur plusieurs machines ça devrait aller.

Remarque : si tu as deux main différents, les threads ne servent plus à rien (voir les classes A et B)

C'est moi qui ait décidé dans la méthode repeter que le paramètre "serveurs" pouvait prendre la valeur null. Si on est client, on a une liste à envoyer, donc une liste avec plusieurs serveurs cibles (l'un après l'autre) mais lorsqu'on est serveur, on attend une liste, mais donc au départ on ne connait pas sa valeur, c'est pour ça qu'on met null.

null -> serveur attend une llste
non-null -> client envoie la liste

C'est un peu plus compliqué que ça, car le "serveur" devient à son tour "client" lorsqu'il a reçu des données. Donc on ne peut pas dire client=classeB ou serveur=classeA, c'est pour ça que j'avais préféré tout faire dans la classe Commun car en fait ils ont tous le même comportement.
La seule différence entre A et B, c'est qu'au lancement A envoie un fichier. Mais on peut très bien imaginer qu'on démarre tout le monde avec une classe B (ils attendent tous des fichiers) et de temps en temps on envoie un fichier (avec la classe A ou une autre).

oui je pense que j'ai compris la problématique
dnc pour pouvoir tester le transfert entre plusieur machine tu propose quoi comme code sur le client et le serveur si on va pas reprendre le code de la classe A et B
merci de votre comprehension

Tu dois lancer le programme role=B sur toutes tes machines. Et une fois que c'est fait envoyer un fichier avec le programme role=A, éventuellement modifié pour s'arrêter une fois le fichier envoyé, et attendre de voir ce que font les machines B avec. À la fin il est possible que tu ais une machine role=C, qui reçoive le fichier, mais là encore ce n'est qu'un cas particulier de B, où la liste arrive vide.

je pense que c'est pas claire s'il te plait pourrai tu me donner le code par ce que la ca commence a me prendre la tete
code client =?
code serveur=?
code commun =?
s'il te plait.
et merci de votre comprehension.