Tests d'un réseau

Version imprimable

Tests d'un réseau

Salut,

Premier post et premier script (champagne), réalisé pour mon stage en réseau.

L'objectif est d'améliorer la qualité de ce dernier, dispersé sur plusieurs sites, concernant quelques points précis. Il est donc crée d'aprés mes pauvres bases (je ne suis pas codeur, ça va se voir, lol), des sources internet et un peu d'aide extérieur. Mon but est de tester les performances (bande passante) du réseau pour en détecter les faiblesses concernant :
- le D/L FTP
- le D/L HTML
- le D/L HTML avec proxy

J'ai donc réalisé une série de "logs", auxquels j'ai ajouté de quoi mesurer les performances brutes :
- une liste de "ping(s)" simples
- le résultat d'un benchmark réseau, iperf.

Il faut d'abord créer une machine qui fera serveur FTP (compte anonymous), HTML et Iperf (en mode serveur), puis déposer un fichier nommé "fake" de plusieurs mégas (50 Mo pour mes tests), avant de placer la machine au plus proche du coeur de réseau. Sur la machine client, installer iperf sous linux (le reste des outils étant standard).

Pour les mesures de référence, lancer le script sur le client linux, elle aussi proche du coeur de réseau. Ensuite, déplacer le client linux en divers endroits du réseau et lancer le script, comparer les logs une fois les tests achevés, afin d'en tirer les conclusions.

Voilà, j'ai expliqué ce que j'ai voulu faire, et je met le tout ici avec l'espoir de retours de pros connaissant mieux le Bash que moi, afin de :
1- optimiser le script
2- apporter des modifications/retouches éventuelles
3- améliorer les tests (utilisation des outils, nouveaux outils ?)
4- évaluer la pertinence des tests réseaux (résultats en retour)

Tout feedback sera le bienvenu.
Merci.

Code:

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
#! /bin/bash
# bash script - Fedora Core 5
clear
 
# Déclaration de variables 
ip=$1
min_ip=1
max_ip=254
 
# Message d'indication si aucun paramètre
if [ $# -ne 1 ];
then
	clear
	echo "Veuillez entrer un paramètre."
	echo "Utilisation : `basename $0` [IP du serveur]"
	echo "-----------------------------------"
	exit 0
fi
 
# Test pour savoir si les octets sont des caractères numériques
function isNum
{
	if [ $# = 1 ];
	then
	tmp=`expr "$1" : '\([0-9]\{1,\}\)'`
 
		if [ "$1" = "$tmp" ];
		then
			echo 0
		else
			echo 1
		fi
	else
		echo 2
	fi
}
 
# Test pour savoir si les octets sont compris entre 0 et 255
function minMax
{
	if [ $# = 3 ];
	then
		nbr=$1
		min=$2
		max=$3
 
		if [ "$nbr" -ge "$min" -a "$nbr" -le "$max" ];
		then
			echo 0
		else
			echo 1
		fi
	else
		echo 2
	fi
}
 
# Routine de test pour la validité de l'adresse IP
for i in 1 2 3 4;
	do
	octet=`echo $ip | cut -d "." -f$i`
 
	if [ `isNum $octet` -eq 0 ];
		then
			if [ `minMax $octet $min_ip $max_ip` -eq 0 ];
			then
				echo "l'octet $i [$octet] est valide."
			else
				echo "l'octet $i [$octet] est incorrect."
				echo "Notation décimale IPv4 requise, sans adresse de réseau ni broadcast."
				exit 1
			fi
		else
			echo "L'octet $i [$octet] est incorrect."
			echo "Notation décimale IPv4 requise."
			exit 1
	fi
done
 
# Récupération ip/masque/broadcast de l'hôte (ici l'IP seul)
function hostip (){
	way=$1 #chemin de ifconfig ('sbin/ifconfig')
	eth=$2 #numéro d'interface ('eth0')
 
	mask1=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f1`
	mask2=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f2`
	mask3=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f3`
	mask4=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f4`
 
	ip1=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f1`
	ip2=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f2`
	ip3=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f3`
	ip4=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f4|cut -d ' ' -f1`
 
	mask=`$way $eth|grep Masque|cut -d ':' -f4`
	#echo $mask
	ethip=`$way $eth|grep Masque|cut -d ':' -f2|cut -d ' ' -f1`
	echo $ethip
	ip_res=$[${mask1} & ${ip1}]"."$[${mask2} & ${ip2}]"."$[${mask3} & ${ip3}]"."$[${mask4} & ${ip4}]
	#echo $ip_res
}
 
# Mesures basiques via ping
function Mping(){
	ping -c 30 $ip >> $log
}
 
# Mesures d'un téléchargement FTP
function Mftp(){
	wget -r -4 -a $log --progress=dot:mega --proxy=off --no-cache --no-proxy --no-passive-ftp --user anonymous --password anonymous ftp://$ip/fake
	rm -r $ip
}
 
# Mesures d'un téléchargement HTTP
function Mhttp(){
	wget -r -4 -a $log --progress=dot:mega --proxy=off --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
	rm -r $ip
}
 
# Mesures d'un téléchargement HTTP via un proxy
function Mhttpp(){
	export http_proxy="http://10.1.1.3:8080" #Utilisation de la variable d'environnement
	wget -r -4 -a $log --progress=dot:mega --proxy=on --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
	rm -r $ip
}
 
# Mesures en client/serveur iperf
function Miperf(){
	iperf -c $ip -P 0 -i 5 -f M -t 60 >> $log # sur 60 sec en TCP, 1 mesure/5 sec.
}
 
function Mcomplet(){
	echo "" >> $log
	echo "Mesure 1 : ping"
	echo "-------------------------------------------------------------" >> $log
	echo "Mesure 1 : ping" >> $log
	echo "-------------------------------------------------------------" >> $log
	Mping $log
 
	echo "" >> $log
	echo "Mesure 2 : wget FTP"
	echo "-------------------------------------------------------------" >> $log
	echo "Mesure 2 : wget FTP" >> $log
	echo "-------------------------------------------------------------" >> $log
	Mftp $log
 
	echo "" >> $log
	echo "Mesure 3 : wget HTTP"
	echo "-------------------------------------------------------------" >> $log
	echo "Mesure 3 : wget HTTP" >> $log
	echo "-------------------------------------------------------------" >> $log
	Mhttp $log
 
	echo "" >> $log
	echo "Mesure 4 : wget HTTP + Proxy"
	echo "-------------------------------------------------------------" >> $log
	echo "Mesure 4 : wget HTTP + Proxy" >> $log
	echo "-------------------------------------------------------------" >> $log
	Mhttpp $log
 
	echo "" >> $log
	echo "Mesure 5 : iperf"
	echo "-------------------------------------------------------------" >> $log
	echo "Mesure 5 : iperf" >> $log
	echo "-------------------------------------------------------------" >> $log
	Miperf $log
}
 
# Création du log et aiguillage vers le type de mesure adéquat.
function mesure () {
	# Indication à l'écran pour patienter
	echo "Veuillez patienter svp..."
 
	# Création du nom de fichier log
	log=$1
 
	# Liste la date et l'heure
	echo "------------------------------" > $log
	echo `date` >> $log
	echo "------------------------------" >> $log
	echo "" >> $log
 
	# Ajoute le nom d'hôte et l'adresse IP de l'interface 0
	echo `hostname` >> $log
	hostip '/sbin/ifconfig' 'eth0' >> $log
	echo "" >> $log
 
	# Ligne de séparation avant mesures
	echo "-------------------------------------------------------------" >> $log
	echo "" >> $log
 
	# Test sur le type de fichier log pour lancer le test approprié
	case $log in
		logping) Mping $log;;
		logftp) Mftp $log;;
		loghtml) Mhttp $log;;
		loghtmlp) Mhttpp $log;;
		logiperf) Miperf $log;;
		logcomplet) Mcomplet $log;;
	esac		
}
 
 
# Gestion du menu de choix pour le type de mesures à effectuer
function bye(){
	echo "Mesures terminées. Bonne journée !"
	echo "Les résultats sont dans le fichier '$log'"
	echo ":)"
}
 
function menu(){
	clear
	echo "-----------------------------------------------------"
	echo "|			  Choix du protocole de test		   |"
	echo "-----------------------------------------------------"
	echo "Appuyez sur une touche, puis validez. [7] pour quitter."
	echo ""
	select j in  'PING' 'FTP' 'HTTP' 'HTTP+PROXY' 'IPERF' 'TOUS' 'QUIT'
		do
			case $j in
				PING)
				mesure logping
				bye
				exit 0;;
 
				FTP)
				mesure logftp
				bye
				exit 0;;
 
				HTTP)
				mesure loghttp
				bye
				exit 0;;
 
				HTTP+PROXY)
				mesure loghttpp
				bye
				exit 0;;
 
				IPERF)
				mesure logiperf
				bye
				exit 0;;
 
				TOUS)
				mesure logcomplet
				bye
				exit 0;;
 
				QUIT)
				clear
				echo "Script terminé. Bonne journée."
				exit 0;;
 
				*)
				echo "Veuillez entrer un chiffre entre 1 et 6. Merci."
				echo "Touche '7' pour quitter, 'ctrl+d' pour interrompre";;
			esac
	done 
}
menu

A première vue, tu pourrais remplacer les fonctions isNum, minMax et le test IP par ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
function isIPv4 {
    if [ $# = 1 ]
    then
        printf $1 | grep -Eq '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
        return $?
    else
        return 2
    fi
}
 
isIPv4 $1 && echo "IP OK" || echo "IP pas OK"

31/05/2006, 10h08
.Nawak

Ok, merci.

La magie des expressions régulières... seulement, je l'utilise, je vois bien que ça fonctionne, mais je ne la comprend pas. Dans ton exemple, je suppose que l'expression test chaque octet, afin de savoir s'il est comprit entre 0 et 255, ou égal à 0 et 255.

Seulement, dans mon cas, il ne faut pas utiliser les adresses réseaux (0 sur le dernier octet) ni broadcast (255 sur le dernier octet). Par exemple :
192.168.1.1 - ok
10.1.150.90 - ok
172.82.56.5 - ok
192.168.1.0 - pas ok
172.25.254.255 - pas ok
Mais je ne suis pas capable de décortiquer l'expression régulière, je n'en ai pas les clefs, et la notation reste trés abstraite actuellement. Je n'en vois pas trop la logique.

Les regex sont plus facile à écrire qu'à lire (et surtout expliquer;) )

^ ancrage de début de chaîne
((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}

25[0-5] soit de 250 à 255 ou bien ...
2[0-4][0-9] soit de 200 à 249 ou bien ...
[01]?[0-9][0-9]?\. soit 01 (optionnels) suivit de 00 à 99 suivit du carctère point
{3} tout ce groupe 3 fois
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?) idem mais sans le point de fin
$ ancrage de fin de chaîne

Pour la capture de l'IP de ton interface, tu pourrais également faire ceci:
Code:

1 2 3 4 5 6 7 8 9 function hostIp { ethIp=$(ifconfig $1 | awk -v RS="" '{print substr($7, 5)}') ethBroadcast=$(ifconfig $1 | awk -v RS="" '{print substr($8, 7)}') return 0 } hostIp "eth0" echo $ethIp echo $ethBroadcast
Edit:

Citation:

Envoyé par .Nawak

Seulement, dans mon cas, il ne faut pas utiliser les adresses réseaux (0 sur le dernier octet) ni broadcast (255 sur le dernier octet). Par exemple :
192.168.1.1 - ok
10.1.150.90 - ok
172.82.56.5 - ok
192.168.1.0 - pas ok
172.25.254.255 - pas ok
Mais je ne suis pas capable de décortiquer l'expression régulière, je n'en ai pas les clefs, et la notation reste trés abstraite actuellement. Je n'en vois pas trop la logique.

Essaye en remplaçant le dernier groupe par

Code:

(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)

Le masque devient:

Code:

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)$

31/05/2006, 11h47
.Nawak

Merci beaucoup.

Avec les divers feedback que tu m'as donné, ainsi que ceux donnés sur fedora-france, j'ai remanié l'ensemble (ce n'est pas encore terminé, mais dans l'état, il marche, et ça fait largement moins de lignes).

Code:

édition

Bon, il reste à essayer de diminuer le nombre de fonctions, ou tout mettre dans la même, mais ça a déjà meilleur gueule. ça fait moins... "étalage de foire !"
:mrgreen:

Voilà, je pense avoir bien avancé là-dessus, et ça fait ce que je veux dans l'ensemble. Bon, ça pourrait être plus paramétrable, mais là, j'ai peur que cela devienne trop complexe, même si j'ai prit l'habitude d'annoter. Je trouve ça plutôt pas mal pour un premier script, non ?

Code:

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
#!/bin/bash
# bash script - Fedora Core 5
clear
 
# Localisation Fr
export LC_ALL="fr_FR.utf8"
export LANG="fr_FR.utf8"
export LANGUAGE="fr_FR.utf8"
export LESSCHARSET="latin1"
 
# Déclaration de variables 
ip=$1
 
# Message d'indication si aucun paramètre
if [ $# != 1 ];
then
	clear
	echo "Veuillez entrer un paramètre."
	echo "Utilisation : $(basename $0) [IP du serveur]"
	echo "---------------------------------------------------------------"
	exit 0
fi
 
# Utilise le retour de la fonction testant la validité de l'IP
function wrong {
	echo "Notation décimale IPv4 requise."
	exit 0
}
 
# Test de validité IPv4 de l'adresse entrée (expression régulière)
function isIPv4 {
	if [ $# = 1 ]
	then
		printf $1 | grep -Eq '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)$'
		return $?
	else
		return 2
	fi
}
isIPv4 $ip && echo "IP validée." || wrong
 
# Récupération de l'ip, du masque de sous-réseau et de l'adresse de broadcast de l'hôte
function hostip {
	way=$1 #chemin de ifconfig ('sbin/ifconfig')
	eth=$2 #numéro d'interface ('eth0')
 
	for i in $(seq 4)
  	do
  		mask[$i]="$($way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f$i)"
		octet[$i]="$($way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f$i|cut -d ' ' -f1)"
	done
 
	# Variable donnant l'IP de l'hôte
	adress=${octet[1]}"."${octet[2]}"."${octet[3]}"."${octet[4]}
	#echo "$adress"
 
	# Variable donnant le masque de sous-réseau
	subnet=${mask[1]}"."${mask[2]}"."${mask[3]}"."${mask[4]}
	#echo "$subnet"
 
	# Variable donnant l'adresse du réseau
	network=$[${mask[1]} & ${octet[1]}]"."$[${mask[2]} & ${octet[2]}]"."$[${mask[3]} & ${octet[3]}]"."$[${mask[4]} & ${octet[4]}]
	#echo "$network"
 
	echo "IP de l'hôte : $adress"
	echo "Sous-réseau : $subnet"
	echo "Réseau : $network"
}
 
# Création du log et aiguillage vers le type de mesure adéquat.
function mesure () {
	# Indication à l'écran pour patienter
	echo "Veuillez patienter svp..."
 
	# Création du nom de fichier log
	log=$1
 
	# Liste la date et l'heure
	echo "---------------------------------------------------------------" > $log
	echo $(date) >> $log
	echo "---------------------------------------------------------------" >> $log
	echo "" >> $log
 
	# Ajoute le nom d'hôte et l'adresse IP de l'interface 0
	echo "Nom de l'hôte : $(hostname)" >> $log
	hostip '/sbin/ifconfig' 'eth0' >> $log
	echo "" >> $log
 
	# Ligne de séparation avant mesures
	echo "---------------------------------------------------------------" >> $log
	echo "" >> $log
 
	# Mesures basiques via ping
	function Mping(){
		ping -c 1 $ip > /dev/null #pour ne pas mesurer le premier délai (faussé)
		function MpingQoS(){
			case $1 in
			0x02) cmd="-c 10 -Q" type="QoS coût minimal";;
			0x04) cmd="-c 10 -Q" type="QoS fiabilité";;
			0x08) cmd="-c 10 -Q" type="QoS débit";;
			0x10) cmd="-c 10 -Q" type="QoS bas délai";;
			ff) cmd="-c 10 -p" type="paquet rempli";;
			esac
 
			echo "Ping '$type' ($1)" >> $log
			echo "---------------------------------------------------------------" >> $log
			ping $cmd $1 $ip >> $log
			echo "" >> $log
			echo "" >> $log
		}
		MpingQoS 0x02
		MpingQoS 0x04
		MpingQoS 0x08
		MpingQoS 0x10
		MpingQoS ff
	}
 
	# Mesures d'un téléchargement FTP
	function Mftp(){
		wget -r -4 -a $log --progress=dot:mega --proxy=off --no-cache --no-proxy --no-passive-ftp --user anonymous --password anonymous ftp://$ip/fake
		rm -r $ip
	}
 
	# Mesures d'un téléchargement HTTP
	function Mhttp(){
		wget -r -4 -a $log --progress=dot:mega --proxy=off --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
		rm -r $ip
	}
 
	# Mesures d'un téléchargement HTTP via un proxy
	function Mhttpp(){
		export http_proxy="http://10.1.1.3:8080" #Utilisation de la variable d'environnement
		wget -r -4 -a $log --progress=dot:mega --proxy=on --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
		rm -r $ip
	}
 
	# Mesures en client/serveur iperf
	function Miperf(){
		iperf -c $ip -P 0 -i 1 -f M -t 30 >> $log # sur 30 sec en TCP, 1 mesure/sec.
		echo "" >> $log
	}
 
	function Mall(){
		function boucle(){
			case $1 in
			1) nom="ping" mesure="Mping";;
			2) nom="wget FTP" mesure="Mftp";;
			3) nom="wget HTTP" mesure="Mhttp";;
			4) nom="wget HTTP + Proxy" mesure="Mhttpp";;
			5) nom="iperf" mesure="Miperf";;
			esac
 
			echo "" >> $log
			echo "Mesure $1 : $nom"
			echo "---------------------------------------------------------------" >> $log
			echo "Mesure $1 : $nom" >> $log
			echo "---------------------------------------------------------------" >> $log
			$mesure $log
		}
		for k in 1 2 3 4 5
		do
		boucle $k
		echo "" >> $log
		done
	}
 
	# Test sur le type de log pour lancer les instructions appropriées
	case $log in
		logping) Mping $log;;
		logftp) Mftp $log;;
		loghttp) Mhttp $log;;
		loghttpp) Mhttpp $log;;
		logiperf) Miperf $log;;
		logall) Mall $log;;
	esac		
}
 
# Libre choix : visualisation immédiate du log (ou non) 
function lire(){
	echo ""
	while test "$input" != [yYnN]
	do
		echo "Souhaitez-vous visualiser le fichier $log ? [y/n]"
		read input
		case "$input" in
			[yY])
			less $log
			echo "---------------------------------------------------------------"
			echo "Les résultats sont dans le fichier '$(pwd)/$log'"
			echo "---------------------------------------------------------------"
			exit 0;;
 
			[nN])
			echo "---------------------------------------------------------------"
			echo "Les résultats sont dans le fichier '$(pwd)/$log'"
			echo "---------------------------------------------------------------"
			exit 0;;
		esac
	done
}
 
# Gestion du menu de choix pour le type de mesures à effectuer
function menu(){
	clear
	echo "---------------------------------------------------------------"
	echo "|                   Choix du protocole de test                |"
	echo "---------------------------------------------------------------"
	echo "Appuyez sur une touche, puis validez. Touche [7] pour quitter."
	echo ""
	select j in  'PING' 'FTP' 'HTTP' 'HTTP+PROXY' 'IPERF' 'ALL' 'QUIT'
		do
			case $j in
				PING|FTP|HTTP|HTTP+PROXY|IPERF|ALL)
				mesure log$(echo $j|tr '[A-Z]' '[a-z]')
				echo "Mesures terminées. Bonne journée !"
				lire
				exit 0;;
 
				QUIT)
				clear
				echo "Script terminé. Bonne journée."
				exit 0;;
 
				*)
				echo "Veuillez entrer un chiffre entre 1 et 6. Merci."
				echo "Touche '7' pour quitter, 'ctrl+d' pour interrompre";;
			esac
	done 
}
menu

Si vous avez des remarques, des améliorations à apporter, n'hésitez pas.
Merci.
:mrgreen:

02/06/2006, 10h10
.Nawak

re,

J'ai montré le travail, et j'ai zappé 2 autres aspects qu'ils utilisent souvent :
- le partage SMB (partage windows)
- le partage NCP (Novell Netware)

J'ai eu une idée pour mesurer leurs taux de transfert, mais je ne sais pas comment la mettre en forme. Je suis une quiche en math (filière communication). Voici mon raisonnement :

D'abord, je paramètre un client samba et un client ncp.

Ensuite, je crée un script :
1- je récupère un temps 1 (en secondes)
2- j'éxcute une copie d'un fichier (cp)
3- je récupère un temps 2 (en secondes)

Finalement, je dois réaliser une formule... soit :
T = temps 2 - temps 1
P = poids du fichier en MegaOctets(fixe, que je pourrais hard-coder)
rappel : 1 octet = 1 byte = 8 bits

Maintenant, comment faire pour récupérer un taux dont l'unité serait le Kilobit/seconde ?
Première étape, comment récupérer le timer sous forme de secondes via le script ?
02/06/2006, 14h33
MarcG

regarde du coté de la commande unix time ... celle ci donne les temps d'execution de la commande ou script donné en argument.