Time et smbclient

**.Nawak** · 06/06/2006, 11h18

Salut,

En fait, ce sont plusieurs questions en une (histoire de ne pas démultiplier les sujets). Plusieurs problèmes se posent à moi :

1° smbclient

smbclient -I 10.1.x.x //atelier/share nopass < externe (externe étant un fichier éxécutant un get et un exit)

Pour des tests réseau, je dois effectuer un log (mode "append") de la sortie d'un smbclient. Hors, la double redirection (>> monlog) ne fonctionne pas, et d'aprés le MAN, pas grand chose de prévu. Comment faire pour logguer ?

2° time
Dans le même ordre d'idée, je compte faire un "time" pour mesurer le temps en *secondes* du processus "smbclient", et pareillement, l'ajouter au log. Donc, première chose, comment afficher le format en secondes, et rien d'autres ? Seconde question, même problème que précédemment, comment logguer ?
Lorsque je fais un :

"time $(cp fichier temp) -o monlog --append"

bash me renvoie :

bash: -o: command not found

Alors qu'il est sensé le faire...

A terme, je souhaiterais récupérer dans un log le temps (en secondes) du processus "smbclient" dans lequel j'aurais éxécuté un "get", afin de pouvoir calculer un rapport "poids du fichier" / "secondes" sur un partage smb.

Pour imager, faire un (attention, ça va piquer les yeux) :

time -seconds $(smbclient -I 10.1.x.x //atelier/share nopass < externe) >> monlog

J'ai vraiment besoin d'aide, je nage complètement.
Merci.

**zul** · 06/06/2006, 11h40

Pour smbclient , bonne chance, c'est prévu pour être un client interactif. As tu regardé l'option --logfile ?

Pour time, le probleme c'est que tu appelle la builtin fonction de tn shell et pas le binaire ( probablement /usr/bin/time ). C'est /usr/bin/time qui supporte -o pas la builtin fonction.

**.Nawak** · 12/06/2006, 13h55

Ouf !

ça y est, j'ai trouvé comment faire, et mon script de test réseau à l'air de fonctionner. Il nécessite un serveur avec un partage SMB, un partage NPC, un serveur FTP, WEB et Iperf avec un nom de dossier partagé "FTP" et un faux fichier de quelques centaines de Mo nommé "fake".

Je me suis effectivemment basé sur "time" (la première fois, ce satané bash ne prenait pas la "vraie" commande, il fallait lui indiquer le chemin) pour créer une routine de calcul dans laquelle je passe l'éxécution d'une commande. Ainsi, je récupère un joli log formaté avec les mesures en Kbits et Mbits (pour mesurer la BP, c'est mieux).

Reste plus qu'à vérifier in situ et me créer des mesures étalons (référence). Voici le script, au cas où quelqu'un serait potentiellement interréssé :

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
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
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
#!/bin/bash
# bash script - Fedora Core 5
# nécessite les packages 'ncpfs' et 'iperf' (netware file system et client iperf)
# -----------------------------------------------------------------------------
# /!\ Doit être lancé en root pour le montage du partage NCP (netware)
# -----------------------------------------------------------------------------
clear
 
# Localisation Fr
export LC_ALL="fr_FR.utf8"
export LESSCHARSET="latin1"
 
# Ajout du chemin "/sbin" à la variable "$PATH" (pour 'ifconfig')
export PATH="$PATH:/sbin"
 
# Exportation de l'adresse IP du proxy (variable d'environnement)
export http_proxy="http://10.1.x.x:8080"
 
# Déclaration de variables (utilisés souvent par la suite)
ip=$1
log="tmp"
fichier="fake"
 
# Message d'indication si aucun paramètre
if [ $# != 1 ]
then
	clear
	echo "---------------------------------------------------------------"
	echo "Veuillez entrer l'adresse ip du serveur de tests."
	echo "Utilisation du script : $(basename $0) <server ip>"
	echo "---------------------------------------------------------------"
	exit 0
fi
 
# Utilise le retour de la fonction testant la validité de l'IP
function wrong(){
	echo "Adresse ip du serveur incorrecte. Vérifiez la syntaxe (IPv4)."
	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 1
	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(){
	for i in $(seq 4)
  	do
  		mask[$i]="$(ifconfig $1|grep Masque|cut -d ':' -f4|cut -d '.' -f$i)"
		octet[$i]="$(ifconfig $1|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]}
 
	# Variable donnant le masque de sous-réseau
	subnet=${mask[1]}"."${mask[2]}"."${mask[3]}"."${mask[4]}
 
	# 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 "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..."
 
	# Liste la date et l'heure
	echo "---------------------------------------------------------------" > $log
	echo $(date '+%d %B %Y %T') >> $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 'eth0' >> $log
	echo "" >> $log
	echo "---------------------------------------------------------------" >> $log
	echo "" >> $log
 
	# Appel avant chaque mesure pour que le log soit lisible
	function header(){
		echo "" >> $log
		echo "Mesure : $1"
		echo "---------------------------------------------------------------" >> $log
		echo "Mesure : $1" >> $log
		echo "---------------------------------------------------------------" >> $log
	}
 
	function calcul(){
		# /!\ L'emplacement de la cmd '/usr/bin/time' diffère d'un linux à l'autre
		secondes=$(/usr/bin/time -f "%e" $commande 2>&1 |tail -1) # Temps de copie
 
		Koctets=$(ls -s $fichier |cut -d' ' -f1) # Nombre de Ko (KBytes)
		Kbits=$(echo "$Koctets*8"|bc) # Conversion en Kilobits
		Mbits=$(echo "$Kbits/1000"|bc) # Conversion en Megabits
 
		Kbs=$(echo "$Kbits/$secondes"|bc) # Résultat en Kbits/sec
		Mbs=$(echo "$Mbits/$secondes"|bc) # Résultat en Mbits/sec
		echo "$Kbs Kbits/s" >> $log
		echo "$Mbs Mbits/s" >> $log
 
		rm fake > /dev/null
		rm -rf /tmp/* # Pour laisser un répertoire temporaire propre
	}
 
	# Fonction permettant de monter le NCP et d'envoyer le calcul
	function monter(){
		header "partage ncp sur $1"
 
		# Emplacement du point de montage temporaire
		point="/mnt/ncp"
		chemin="$point/userdisk/cdc/gip1/"
 
		# /!\ montage en root uniquement
		mkdir $point > /dev/null
		ncpmount -S $1 -A $1 -U gip1 -P gip $point
 
		# Instructions de calcul sur la commande "cp" (copy)
		commande="cp $chemin$fichier $fichier"
		calcul
 
		# Enlever le point de montage
		ncpumount $point
		rm -rf $point > /dev/null
	}
 
	# Choix entre les 2 réseaux NCP : 10.1 ou 10.2
	function Mncp(){
		while [ "$input" != 1-2 ]
		do
			echo "NCP (netware) sur quel réseau : 10.1.x.x (1) ou 10.2.x.x (2) ? [1/2]"
			read input
			case $input in
				"1")
				monter 10.1.x.x
				break;;
				"2")
				monter 10.2.x.x
				break;;
			esac
		done
	}
 
	# Mesures d'un téléchargement FTP
	function Mftp(){
		header "wget ftp"
		commande="wget -nH -4 -O $fichier --progress=dot:mega --proxy=off --cache=off --no-passive-ftp --user anonymous --password anonymous@test.com ftp://$ip/$fichier"
		calcul
	}
 
	# Mesures d'un téléchargement HTTP
	function Mhttp(){
		header "wget http"
		commande="wget -nH -4 -O $fichier --progress=dot:mega --proxy=off --cache=off --no-dns-cache http://$ip/$fichier"
		calcul
	}
 
	# Mesures d'un téléchargement HTTP via un proxy
	function Mhttpp(){
		header "wget http avec proxy"
		commande="wget -nH -4 -O $fichier --progress=dot:mega --proxy=on --cache=off --no-dns-cache http://$ip/$fichier"
		calcul
	}
 
	function Msmb(){
		header "partage smb"
		commande="smbget -u partage -p partage -w workgroup smb://$ip/FTP/$fichier"
		calcul
	}
 
	# Mesures en client/serveur iperf
	function Miperf(){
		header "iperf"
		iperf -c $ip -P 0 -i 10 -f m -t 60 >> $log # sur 60 sec en TCP, 1 mesure/10sec.
		echo "" >> $log
	}
 
	# Les mesures complètes dans un seul log
	function Mall(){
		# Choix entre les 2 réseaux NCP : 10.1 ou 10.2
		while [ "$input" != 1-2 ]
		do
			echo "NCP (netware) sur quel réseau : 10.1.x.x (1) ou 10.2.x.x (2) ? [1/2]"
			read input
			case $input in
				"1")
				ipncp=10.1.x.x
				break;;
				"2")
				ipncp=10.2.x.x
				break;;
			esac
		done
 
		# Mesures effectuées une à une
		function boucle(){
			case $k in
				1) nom="wget HTTP" mesure="Mhttp";;
				2) nom="wget HTTP avec le proxy" mesure="Mhttpp";;
				3) nom="wget FTP" mesure="Mftp";;
				4) nom="partage SMB" mesure="Msmb";;
				5) nom="partage NCP" mesure="monter $ipncp";;
				6) nom="client iperf" mesure="Miperf";;
			esac
			$mesure
		}
		for k in $(seq 6)
		do
			boucle $k
			echo "" >> $log
		done
	}
 
	# Test suivant le retour du menu pour lancer les instructions appropriées
	M$1
 
	# Instructions pour indiquer la fin des mesures dans le log
	echo "---------------------------------------------------------------" >> $log
	echo "Fin du script à $(date '+%T')" >> $log
	echo "---------------------------------------------------------------" >> $log
	echo "Mesures terminées. Bonne journée !"
	echo ""
}
 
function save(){
	function boucle(){
		until [ $nom ]
		do
			echo "Entrez le nom du fichier de sauvegarde (la terminaison '.log' sera ajoutée) :"
			read nom
		done
	}
	boucle
 
	while [ "$check" != yYnN ]
	do
		echo "êtes-vous certain d'utiliser '$nom(.log)' comme nom de sauvegarde ? [y/n]"
		read check
		case "$check" in
			[yY])
			mv $log $nom.log
			log="$nom.log"
			break;;
			[nN])
			nom=""
			boucle;;
		esac
	done
}
 
# Libre choix : visualisation immédiate du log (ou non) 
function lire(){
	function indicateur(){
		echo "---------------------------------------------------------------"
		echo "Les résultats sont dans le fichier '$(pwd)/$log'"
		echo "---------------------------------------------------------------"
		exit 0
	}
 
	while [ "$input" != yYnN ]
	do
		echo "Souhaitez-vous visualiser le fichier '$log' ? [y/n]"
		read input
		case "$input" in
			[yY])
			less $log
			indicateur;;
 
			[nN])
			indicateur;;
		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 [8] pour quitter."
	echo ""
	select j in 'HTTP' 'HTTP proxy' 'FTP' 'SMB' 'NCP' 'IPERF' 'ALL' 'QUIT'
		do
			case $j in
				FTP|HTTP|IPERF|SMB|NCP|ALL)
				mesure $(echo $j|tr '[A-Z]' '[a-z]')
				save
				lire
				exit 0;;
 
				'HTTP proxy')
				mesure httpp
				save
				lire
				exit 0;;
 
				QUIT)
				clear
				echo "Script terminé. Bonne journée."
				exit 0;;
 
				*)
				echo "Veuillez entrer un chiffre entre 1 et 7. Merci."
				echo "Touche '8' pour quitter, 'ctrl+d' pour interrompre";;
			esac
	done 
}
menu

Dernière question, j'ai ici une fonction qui ne me sert à quasiment rien, mis à part faire un "echo" et un "exit" si une erreur est commise sur le paramètre du script (l'ip du serveur). Je souhaiterais savoir comment simplifier l'écriture de ceci, en élminant la fonction :

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
# Utilise le retour de la fonction testant la validité de l'IP
function wrong(){
	echo "Adresse ip du serveur incorrecte. Vérifiez la syntaxe (IPv4)."
	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 1
	fi
}
isIPv4 $ip && echo "IP validée." || wrong

Merci.

Time et smbclient

Linux

Discussions similaires

Partager

Partager