Discussion :

[luffy45]

Bonjour,
Voila je vous expose mon problème, euh mon projet:

Nous devons développer un système de gestion de fichiers tolérant aux pannes.

Donc nous disposons de 4 serveurs en réseau, qui possèdent des fichiers. Un client peut se connecte à un serveur et peut soit telecharger un fichier, soit uploader un fichier.

Lorsqu'il uploade un fichier, celui-ci est récupéré en paquet(buffer de 512 octets) par le serveur et décide de l'envoyer en double exemplaire aux serveurs qu'il choisit en fonction de leur état de chargement.

Exemple:

Client -> Fichier F -> Serveur3
Serveur3 -> F1 -> Serveur2 et Serveur3, F2 -> Serveur4 et Serveur1,
F3-> Serveur 1 et Serveur4

Et lorsque le client veut télécharger le fichier F, Serveur3 se débrouille pour aller chercher les fichiers la où ils sont.


Je sais déjà comment gérer une application client/serveur multithread envoyer des fichier via sockets etc...

A priori, on aura besoin d'une SDD qui enregistre quels serveur ont quelles parties de quels fichiers(Arraylist, tableau a double entrée).

Aussi, si un serveur tombe en rade, tout les fichiers qu'il possédait se retrouve en 1 seul exemplaire, donc il faut redistribuer les fichiers sur les serveurs pour qu'il redevienne en double exemplaire.

Voilà en gros ce qu'il y a faire, un bon projet comme on les aime.

Merci pour vos indications.

[dinobogan]

Quel est le problème ?

[tchize_]

Et tu veux qu'on le fasse à ta place ou t'as juste un problème?

[luffy45]

Bah en fait, le problème c'est que je sais pas quelle SDD choisir exactement.
Et comment dire aux autres serveurs que, par exemple, Serveur3 a envoyé F1 à Serveur4 et Serveur1.

Et aussi lorsque le client veut télécharger un fichier comment le serveur arrive à trouver les parties du fichiers chez les serveurs.

Mais le plus important c'est la SDD, c'est ça qui me bloque.

Merci.

[dinobogan]

Ok, donc tu veux qu'on le fasse à ta place.

Sinon, c'est quoi un SDD ?

[tchize_]

pour déterminer ta structure de donnée, il n'y a pas d'avance, il te faut de l'huile de coude pour faire travailler le crayon/papier et du café pour faire travailler les méninges. Tu dois prendre tous tes besoins, mettre ça a plat sur papier et en déduire quels type de données il te faut en fonction de tes contraintes (performances?, checksum?, sécurité?, débit?, dedondance?). Une fois ça sur papier, tu affine tes conclusion jusqu'à atteindre quelque chose qui t'a l'air potable.

On pourrait te donner des solutions nous même, mais on le fera sans analyse et sans connaissance des besoin, donc leur valeur approximera 0, et j'aime pas donner des réponses qui ne servent à rien.

[tchize_]

Ok, donc tu veux qu'on le fasse à ta place.

Sinon, c'est quoi un SDD ?

Structure de données ou Sous Directeur de Développement ou Software Design Document ou Structured Descriptive Data ou....

C'est aussi le symbole monétaire du Soudan

[luffy45]

Ok, merci je vous redirai ce qu'il en est.

ps: j'ai pas demandé à ce que quelqu'un le fasse à ma place et en plus je dèteste ça.

[luffy45]

Bonjour,

Voila, j'ai trouvé ma SDD, une hashmap<String, ArrayList> qui pour un fichier donne la liste de ses parties avec les 2 serveurs dans lesquelles est stocké la partie.

Mais j'ai un pb, quand je découpe le fichier par 512 octets, et que je l'envoie au 2 autres serveurs quelquefois le fichier crée pèse 0ko au lieu de 1ko. Et ça me bloque pour pouvoir envoyer le fichier complet à un autre client .

Le code :

Envoi du paquet de 512 octets :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
OutputStream out1 = sock1.getOutputStream();
OutputStream out2 = sock2.getOutputStream();
 
out1.write(buffer);
out1.flush();
out1.close();
 
out2.write(buffer);
out2.flush();
out2.close();
 
sock1.close();
sock2.close();

Reception chez le serveur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
else if (message.indexOf("put") != -1) {
	InputStream in = socketServeur.getInputStream();
 
	byte[] buffer = new byte[512];
 
	FileOutputStream fout = new FileOutputStream("fichier/" +message.substring(4));
	while (in.read(buffer) != -1) {
		fout.write(buffer);
		fout.flush();
	}
	fout.close();
}

Voila, j'espère que vous m'aiderez à trouver la solution.
Merci.

[tchize_]

ton message tu le récupère comment. T'aurais pas mis un bufferedReader sur ta socket par hasard?

[nouknouk]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
	while (in.read(buffer) != -1) {
		fout.write(buffer);
		fout.flush();
	}
	fout.close();
}

Même si ça ne résoud pas ton souci, pour moi il y a une grôôsse boulette dans cette partie du code:

Soit la taille du buffer égale à 512 octets, comme dans ton code (au passage, c'est horrible une valeur en dure comme ça !)

- ton in.read(buffer) va lire entre 1 et 512 caractères sur la socket en fonction de la quantité de données qui arrivera au prochain paquet.

- après chaque read, tu décidés d'écrire ce qui a été lu dans un fichier MAIS ton fout.write(buffer) qui écrit le contenu dans le fichier, lui, va systématiquement écrire la totalité du contenu du buffer, donc systématiquement écrire 512 octets alors que peut-être seulement 100 octets ont été récupérés de la socket !

Fichiers corrompus à la réception quasi assurés !

Dans ce cas précis, l'entier retourné par 'read' te servira ainsi que write(byte[] b, int off, int len).

[luffy45]

Bah en fait j'ai déjà essayer de découper un fichier avec la même méthode mais dans un même dossier et puis essayer de le recoller, et ça marchait cependant en réseau y a des erreurs.

Soit la taille du buffer égale à 512 octets, comme dans ton code (au passage, c'est horrible une valeur en dure comme ça !)

Tu pourrais m'expliquer pourquoi c'est horrible de l'écrire en dur?

Dans ce cas précis, l'entier retourné par 'read' te servira ainsi que write(byte[] b, int off, int len).

Si j'ai bien compris je remplace fout.writer(buffer) par fout.write(buffer,0, entier retourné par le méthode read())?

[tchize_]

en local, ton buffer sera presque toujours plein, car il y a peu de cas qui peuvent provoquer une lecture partielle du fichier (même si la spécification ne te garanti jamais que t'aura tout ce que t'as demandé)
en réseau, il y a de forte chances que les paquets que tu lit sont partiels et liés à la taille des paquets tcp/ip. Il faut donc faire plusieurs lecture pour tout avoir.


Pour lire d'un flux dans un autre, le code est normalement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
int read=0;
byte[] buffer = ....;
while ( (read = input.read(buffer)) >=0)
    if (read>0)
        output.write(buffer,0,read);
output.close();

[luffy45]

C'est ce que je fais. Et même avec des BufferedInputstream et BufferedOUtputStream j'ai des "pertes" mais bizarrement quand je lance le debug "ligne aprés ligne" avec eclipse les parties arrivent toutes a bon port.

Donc je sais pas.

En même temps, le réseau n'est pas trés vaste puisque je lance les 4 serveurs en localhost, ça revient juste à copier des parties de fichiers d'un dossier à un autre.

[nouknouk]

Tu pourrais m'expliquer pourquoi c'est horrible de l'écrire en dur?

Il est conseillé de spécifier les valeurs constantes non pas au milieu du code lui-même, mais comme valeur static final.

Le jour où tu relis le code (ou le jour ou tu cherches à modifier cette valeur), une simple lecture du début de la définition de la classe te donne tout de suite l'ensemble des valeurs constantes qui sont utilisées dans le code.

Plus besoin de chercher partout dans le code ; en plus, si veux modifier une valeur qui apparait plusieurs à différents endroits du code, tu ne risques plus d'en oublier une dans le lot:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
public class MaClasse {
    public static final int SOCKET_READ_BUFFER_SIZE = 512;
 
    // tout plein de code de fonctions diverses.
    public void maFonction37() {
     int[] buffer = new int[SOCKET_READ_BUFFER_SIZE];
    }
    // tout plein de code de fonctions diverses.
}

Après ça ne change rien à l'exécution du code en elle-même, mais autant ne pas prendre de mauvaises habitudes

Et même avec des BufferedInputstream et BufferedOUtputStream j'ai des "pertes"

Plus tu seras précis, plus on pourra vite cibler l'origine du souci
- Les pertes sont-elles à un ou plusieurs endroits constants du fichier.
- Quelle taille fait le fichier testé ?
- Combien de pertes pour un même fichier.
- Quelle taille en octets pour chacune des 'pertes' (genre, au hasard, 512 octets ?)
- etc...

[tchize_]

ton "message" (qui vaut put) tu le récupère comment? J'ai l'impression que t'as préalablement branché un BufferedReader sur ton inputStream, et ça c'est pas bon du tout. Ce serait bien si on pouvait voir le code manipulant ta socket dans son intégralité (depuis la connection jusqu'au close)

PS: le fait d'utiliser localhost ne change rien au fait que tu peux avoir ded délais dans dans les sockets.

[luffy45]

Plus besoin de chercher partout dans le code ; en plus, si veux modifier une valeur qui apparait plusieurs à différents endroits du code, tu ne risques plus d'en oublier une dans le lot:
Code :


public class MaClasse {
public static final int SOCKET_READ_BUFFER_SIZE = 512;

// tout plein de code de fonctions diverses.
public void maFonction37() {
int[] buffer = new int[SOCKET_READ_BUFFER_SIZE];
}
// tout plein de code de fonctions diverses.
}

Après ça ne change rien à l'exécution du code en elle-même, mais autant ne pas prendre de mauvaises habitudes

Ok , merci pour le conseil, ça optimisera mon code.

Pour mon problème, j'explique en gros ce que je fais:

Un serveur possède 2 sockets d'écoute, une pour les clients et une pour les serveurs. Je lance un Thread pour attendre les connexions des clients et un autre pour les connexions des serveurs.

Un client se connecte à un serveur : il peut faire 3 requêtes:
-put nom_du_fichier : mettre un fichier sur le serveur.
-get nom_du_fichier : télécharger un fichier du serveur.
-dir : pour obtenir la liste des fichiers disponibles.

Pour l'instant je me concentre sur le put :
Le client envoie le fichier dans un Thread pour pouvoir effectuer plusieurs requêtes en même temps.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
fis = new FileInputStream(this.f);
			BufferedOutputStream bos = new BufferedOutputStream(sock.getOutputStream());
int byteLu;
while ((byteLu = fis.read(buffer)) >= 0) {
	bos.write(buffer, 0, byteLu);
	bos.flush();
}
bos.close();
out.close();
fis.close();
 
sock.close();

Et du côté du serveur, je lance un Thread, mais j'ouvre une autre socket d'ecoute qui sert seulement au transfert sur laquelle le client se connecte pour envoyer son fichier, et le serveur reçoit les bouts de fichier que je retransmets à 2 autres serveurs normalement les moins chargés mais pour le moment je fais un random :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
in = sock.getInputStream();
BufferedInputStream bis = new BufferedInputStream(in);
int byteLu;
 
while ((byteLu = bis.read(buffer)) >= 0) {
 
	int s1 = (int) (Math.random() * 4);
	int s2 = (int) (Math.random() * 4);
	while (s2 == s1) {
		s2 = (int) (Math.random() * 4);
	}
	String nom_paquet = fileName + seq;
	sock1 = new Socket(t[s1][0], Integer.parseInt(t[s1][1]));
				new PrintWriter(sock1.getOutputStream(), 
                                                          true).println("put "+nom_paquet);
 
	sock2 = new Socket(t[s2][0], Integer.parseInt(t[s2][1]));
				new PrintWriter(sock2.getOutputStream(), 
                                                          true).println("put "+nom_paquet);
 
	BufferedOutputStream bout1 = new 
                                   BufferedOutputStream(sock1.getOutputStream());
	BufferedOutputStream bout2 = new 
                                   BufferedOutputStream(sock2.getOutputStream());
 
	bout1.write(buffer, 0, byteLu);
	bout1.flush();
	bout1.close();
 
	bout2.write(buffer, 0, byteLu);
	bout2.flush();
	bout2.close();
 
	sock1.close();
	sock2.close();
 
	diffuser(nom_paquet,Integer.parseInt(t[s1][1]),Integer.parseInt(t[s2]
                                                                                               [1]));
	seq++;
}
 
in.close();

Pareil que pour le client, j'ai un tableau de serveur, j'en tire 2 au hasard, et je me connecte à 2 serveurs je leur envoi un "put + nom_du_paquet" (nom_du_fichier+numero_de_sequence) avec le code ci-dessous:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
BufferedReader lecture = new BufferedReader(new 
                              InputStreamReader(socketServeur.getInputStream()));
String message = lecture.readLine();
 
if (message.indexOf("put") != -1) {
	InputStream in = socketServeur.getInputStream();
	BufferedInputStream bis = new BufferedInputStream(in);
	byte[] buffer = new byte[BUFFER_SIZE];
 
	int byteLu;
	FileOutputStream fout = new FileOutputStream("fichier/" + 
                                                      message.substring(4),false);
	while ((byteLu = bis.read(buffer)) >=0) {
		fout.write(buffer ,0, byteLu);
		fout.flush();
		System.out.println("Paquet : "+message.substring(4) +" 
                                                                                enregistre.");
	}
	fout.close();
}

C'est là qu'est le problème puisque plusieurs fois ça n'entre pas dans la boucle while, donc ça crée seulement le fichier avec le FileOutputStream et le ferme, c'est tout.

Voila en gros ce que je fais.

[nouknouk]

Le fait d'utiliser localhost ne change rien au fait que tu peux avoir ded délais dans dans les sockets.

Ca change quand même pas mal de choses puisqu'on se rapproche pas mal des caractéristiques (latence, débit, ...) d'une lecture d'un fichier en local, voir même mieux.

Donc quand on fait un programme destiné à utiliser le réseau il faut toujours faire des tests (voir les tests) en simulant un réseau avec latence, gigue et perte de paquets importants (comparativement aux conditions 'réelles' moyennes d'une utilisation sur internet).

Quand on débute dans les problématiques réseau, il est d'autant plus fréquent qu'on tombe alors sur des bugs qui n'apparaissaient jamais lorsque client et serveur sont lancés sur la même machine, ou sur un réseau local .

Personnellement, le meilleur moyen pour tester est d'utiliser le module net netem sous linux (quitte à avoir un linux en live CD genre Ubuntu si le reste du temps on préfère développer sous un autre OS).

[tchize_]

code de ton serveur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
BufferedReader lecture = new BufferedReader(new 
                              InputStreamReader(socketServeur.getInputStream()));
String message = lecture.readLine();
 
if (message.indexOf("put") != -1) {
	InputStream in = socketServeur.getInputStream();

Comme je l'ai dit plus haut, utiliser un bufferedreader dans ton cas est un très mauvais plan. Le bufferedReader va lire bien plus loin que la ligne "put" dans le inputstream. Résultat, quand tu va attaquer directement le inputstream plus bas, il manquera ce que le bufferedreader a déjà lu au dela de put.

Dans ton cas, comme tu mélange du texte est du binaire, tu dois tout traiter en binaire et faire toi meme les conversion vers du text là ou ça s'applique.

[luffy45]

C'est bon j'ai réglé le pb comme tu l'as dit c'était a cause du BufferedReader, pour palier à ça en fait j'ai 3 socket d'ecoute par serveur, 1 pour la communication client/serveur, 1 pour la communication serveur/serveur et 1 pour le transfert.

Si c'est un put ou un get, je me connecte a la socket de transfert. Plus simple pour moi.

Merci.