Discussion :

[dumoulex]

Bonjour,

J'ai un client/serveur sur un réseau local, a un moment, il y a copie de fichiers.

J'ai déjà créé des fonctions pour faire tout ça avec des buffers et tout ça, mais je m'aperçois que la vitesse de transfert est plutôt lente..

Quelle est la vitesse max de copie sur un réseau local ? elle devrait pouvoir atteindre (quasi) la vitesse de transfert du ssh non ?

si je copie mon fichier directement en copier/coller via le protocole smb, je vais a environ 5Mo/s. Si je fais via scp, je vais à plus de 10Mo/s

par contre, avec une copie via java, je mets... je sais même pas quelle est la vitesse, c'est tellement lent que je l'arrête avant...

j'ai essayé de changer la taille du buffer, rien y fait..

est il possible de copier avec java des gros fichiers tout en ayant un gros débit ?

si oui, comment fais on ?

voici comment je fais mes copie (je suppose que ce n'est pas le meilleur moyen !) :
serveur :

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
public int sendFile (String pathname) {
 
		int retour = Proprietes.ACK;
 
		File f = new File(pathname);
 
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		BufferedOutputStream bos = new BufferedOutputStream(baos);
		OutputStream os = null;
 
		try {
			os = socket.getOutputStream();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
 
		int[] aecrire = new int[TAILLE_BUFFER];
		int compteur = 0;
		long ouonestrendu = 0;
 
		int lu = -1;
 
		BufferedInputStream bis = null;
		try {
			bis = new BufferedInputStream(new FileInputStream(f));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
 
		try {
			lu = bis.read();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		//Tant qu'on est pas à la fin fu chier
		while(lu > -1) {
 
			//	On lit les données du fichier
			aecrire[compteur] = lu;
			try {
				lu = bis.read();
			} catch (IOException e) {
				e.printStackTrace();
			}
			compteur++;
 
			//Quand on a rempli le tableau, on envoie un paquet de TAILLE_BUFFER octets
			if(compteur == TAILLE_BUFFER){
 
				compteur=0;
				ouonestrendu++;
				//		On remplit le tampon
 
				for(int x=0;x<TAILLE_BUFFER;x++){
					try {
						bos.write(aecrire[x]);
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
 
				//	Et on l'envoie
				try {
					os.write(baos.toByteArray());
				} catch (IOException e) {
					e.printStackTrace();
				}
 
				baos.reset();
			}
		}
 
		//On envoie le dernier paquet
		//		On remplit le tampon
		for(int x=0 ; x<compteur ; x++){
			try {
				bos.write(aecrire[x]);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
 
		//Et on l'envoie
		try {
 
			bos.flush();
			os.write(baos.toByteArray());
			os.flush();
 
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("finished");			
		try {
 
			bos.close();
			baos.close();
 
		} catch (IOException e) {
			e.printStackTrace();
		}
		return retour;
	}

client :

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
44
45
46
47
 
FileOutputStream out = null;
BufferedOutputStream outBuffer = null;
 
try {
	out = new FileOutputStream(Configuration.getProperty("global.cheminDestinationVideo") + nomVideo);
	inBuffer = new BufferedInputStream(socket.getInputStream());
	outBuffer = new BufferedOutputStream(out);
} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (Exception e) {
	e.printStackTrace();
}
 
while(enCours){
 
	try {
 
		lu = inBuffer.read();
		outBuffer.write(lu);
 
	} catch (IOException e) {
		return -1;
	}
 
	cptTailleFichier++;
	cptTailleGeneral++;
 
	if (cptTailleFichier%ratioFichier == 0){
 
		/* le fichier courant vient de se terminer */
		if (cptTailleFichier == tailleFichier){
 
			/* on precise que la lecture du fichier est terminee */
			enCours = false;
		}
	}
}
	/* fermeture des flux */
	try {
		outBuffer.flush();
		outBuffer.close();
		out.flush();
		out.close();
	} catch (IOException e) {
		e.printStackTrace();
	}

[adiGuba]

Salut,

• C'est quoi tout ces try/catch ??? Lorsque tu as une erreur, tu l'affiches et tu continues comme si de rien n'était !?!?
• Pourquoi tu lis byte par byte ? Tu m'étonnes que ce soit lent tu fait plus de traitement qu'autre chose...
• Et bien sûr il manque tous les try/finally pour libérer les ressources

Te méthode sendFile() devrait plutôt ressembler à quelque chose comme cela :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
	public void sendFile(String pathname, OutputStream output) throws IOException {
		FileInputStream input = new FileInputStream(pathname);
		try {
			byte[] buffer = new byte[TAILLE_BUFFER];
			int len;
 
			while ( (len=input.read(buffer)) >= 0 ) {
				output.write(buffer, 0, len);
			}
		} finally {
			input.close();
		}
	}

Et pareil pour le client...

a++

[dumoulex]

merci de ta réponse,

j'ai purifié le code, sinon je dois poster trop de trucs, c'est pour ca qu'il y a polusieurs try/catch

j'y connaissais rien en copie de fichiers, donc je tente !

j'ai bien repris ta méthode, et je l'ai adapté coté client, donc j'ai
d'un coté
serveur :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
try {
	byte[] buffer = new byte[TAILLE_BUFFER];
	int len;
 
	while ( (len=input.read(buffer)) >= 0 ) {
		os.write(buffer, 0, len);
	}
} catch (IOException e) {
	e.printStackTrace();
} finally {
	input.close();
}

et client :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
try {
	byte[] buffer = new byte[TAILLE_BUFFER];
	int len;
 
	while ( (len=inBuffer.read(buffer)) >= 0 ) {
		out.write(buffer, 0, len);
	}
}catch (IOException e) {
	e.printStackTrace();		
}finally {
	inBuffer.close();
	out.close();
}

effectivement, je gagne un peu mais quasiment rien.

[adiGuba]

j'ai purifié le code, sinon je dois poster trop de trucs, c'est pour ca qu'il y a polusieurs try/catch

Euh... C'est pas très logique tout ca : pour "purifier" le code tu rajoutes des try/catch !?!?

effectivement, je gagne un peu mais quasiment rien.

C'est à dire ?


Et désolé mais si tu ne postes pas le code exact ca va être difficile de t'aider...

Sans compter que tu as toujours des try/catch inutile et que tes try/finally ne sont pas bon (il en faut un seul par flux)


a++

[dumoulex]

il y a une taille conseillée pour le buffer ? parce que j'ai tenté très faible comme très élevée, et j'ai pas vu une différence...

merci encore

[dumoulex]

par purifier je voulais dire que je notais pas tous les appels que je fais dans mes try,

mais effectivement, je vais tout virer, tu as raison

niveau temps ça se joue a rien, mon fichier de 30Mo met toujours une minute a se transférer...

sachant que j'ai des fichier de tests en gigas...

En fait une question intéressante serait, quelle vitesse max je peux espérer avec ce mode ?

merci beaucoup pour tes réponses en tout cas

[adiGuba]

il y a une taille conseillée pour le buffer ? parce que j'ai tenté très faible comme très élevée, et j'ai pas vu une différence...

En règle général on utilise 8192...

par purifier je voulais dire que je notais pas tous les appels que je fais dans mes try,

C'est surtout la quantité de try/catch qui pose problème...

niveau temps ça se joue a rien, mon fichier de 30Mo met toujours une minute a se transférer...

Cela me semble énorme quand même...

On pourrait voir le code exact que tu utilises ? Si possible une version "minimal" mais complète qui reproduise l'envoi et la réception...


a++

[dumoulex]

c'est bon, merci a vous, j'ai bien suivi, donc un seul bloc try,
le buffer est pour le moment à 1024*10,

voici le code

serveur :

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
 
public int sendFile (String pathname) throws IOException {
 
		int ret = Proprietes.ERR_UNKNOWN;
		OutputStream os = null;
		FileInputStream input = null;
 
		try {
			os = client.getOutputStream();
			input = new FileInputStream(pathname);
 
			byte[] buffer = new byte[TAILLE_BUFFER];
			int len;
 
			while ( (len=input.read(buffer)) >= 0 ) {
				os.write(buffer, 0, len);
			}
 
			ret = Proprietes.ACK;
 
		}finally {
			input.close();
			os.close();
		}
		return ret;
	}

et client :

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
 
	private int recuperationVideos(String nomVideo, int tailleFichier, int cptTailleGeneral, int pourCentGeneral) throws IOException {
 
		int lu = 0;
 
		FileOutputStream out = null;
		BufferedOutputStream outBuffer = null;
 
		out = new FileOutputStream(Configuration.getProperty("global.cheminDestinationVideo") + nomVideo);
		inBuffer = new BufferedInputStream(socket.getInputStream());
		outBuffer = new BufferedOutputStream(out);
 
		while(enCours){
 
			lu = inBuffer.read(buffer,0,lu);
			outBuffer.write(lu);				
		}
 
		/* fermeture des flux */
		outBuffer.flush();
		outBuffer.close();
		out.flush();
		out.close();
 
		return Proprietes.ACK;
	}

[dumoulex]

avec ce code, je monte à environ 10Mo/s sur le réseau local, ce qui est nickel.

merci à vous !