Context Navigation

source: TOOLS/PACK_IPSL/launch_and_measureTime.sh @ 1884

Last change on this file since 1884 was 1882, checked in by aclsce, 12 years ago
Modifications
Property svn:executable set to ``*
File size: 21.8 KB

Line
1	#!/bin/bash
2
3	function update_tasks_list
4	{
5	local tasksListFile=$1 # fichier contenant la nouvelle liste de cmds
6	touch $tasksListFile
7	local logFileOfPrevPack=$2 # fichier log de relatif a l'execution de la derniere liste de cmds
8	local tasksListFileOfPrevPack=$3 # fichier contenant la derniere liste de cmds
9
10	> $tasksListFile
11
12	old_IFS=$IFS # sauvegarde du séparateur de champ
13	IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne
14	for cmdReport in $( cat $logFileOfPrevPack \| grep -e '^#executed by process' )
15	do
16	local resCmd=`echo $cmdReport \| awk '{print $9}' `
17	# Status 50 = FAILED mais pas de ressoumission
18	if [ "x$resCmd" != "x0" ] && [ "x$resCmd" != "x50" ]
19	then
20	local cmdToPrint=`echo $cmdReport \| awk '{print $NF}' `
21	case "x$resCmd" in
22	x5)
23	newCmdToPrint=`echo $cmdToPrint \| sed 's;output_ncrcat;output_tar;' `
24	echo "./process_list.sh $newCmdToPrint" >> ${tasksListFile}
25	;;
26	x10)
27	echo "./process_list.sh $cmdToPrint" >> ${tasksListFile}
28	newCmdToPrint=`echo $cmdToPrint \| sed 's;output_ncrcat;output_tar;' `
29	echo "./process_list.sh $newCmdToPrint" >> ${tasksListFile}
30	;;
31	*)
32	echo "./process_list.sh $cmdToPrint" >> ${tasksListFile}
33	;;
34	esac
35	fi
36	done
37	IFS=$old_IFS # rétablissement du séparateur de champ par défaut
38
39	# Il faut aussi rajouter les cmds qui n'ont pas ete traitees du tout,
40	# par exemple en cas d'interruption du calculateur
41	# Pour cela, on boucle sur la derniere liste de cmds et on cherche dans le
42	# fichier log associe si certaines sont absentes. On remet ces commandes (absentes)
43	# dans la nouvelle liste
44	old_IFS=$IFS # sauvegarde du séparateur de champ
45	IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne
46	for cmd in $( cat $tasksListFileOfPrevPack )
47	do
48	local list=`echo $cmd \| awk '{print $NF}' `
49	hasListBeenTreated=`grep $list $logFileOfPrevPack \| wc -l `
50	if [ "x${hasListBeenTreated}" == "x0" ]
51	then
52	echo $cmd >> ${tasksListFile}
53	fi
54
55
56	done
57	IFS=$old_IFS # rétablissement du séparateur de champ par défaut
58
59	# Il peut arriver que 2 listes soient identiques, on empeche ce cas
60	cat ${tasksListFile} \| sort \| uniq > taskFile.txt
61	cat taskFile.txt > ${tasksListFile}
62
63	}
64
65	function getNumeroOfCurrentTry
66	{
67	local num_try="1"
68	tryNumFile=${USER_OUTPUT_PROGRESS}/numero_current_try.txt
69	if [ ! -e $tryNumFile ]
70	then
71	echo "Le fichier :" >> $badFailureFile
72	echo "$tryNumFile" >> $badFailureFile
73	echo "doit etre present dans le repertoire :" >> $badFailureFile
74	echo "${USER_OUTPUT_PROGRESS}" >> $badFailureFile
75	echo "et il doit contenir un numero d'essai" >> $badFailureFile
76	exit 1
77	fi
78	num_try=`head -n 1 $tryNumFile `
79	echo $num_try
80
81	}
82
83	function getNumeroOfLastInstance
84	{
85	local num_instance="0"
86	local numTry=$1
87	ici=$PWD
88	local progressDirectory="${USER_OUTPUT_PROGRESS}/TRY__${numTry}"
89	if [ ! -e $progressDirectory ]
90	then
91	echo "fonction getNumeroOfLastInstance :" >> $badFailureFile
92	echo "Le repertoire :" >> $badFailureFile
93	echo "$progressDirectory" >> $badFailureFile
94	echo "devrait exister. Il n'existe pas." >> $badFailureFile
95	exit 1
96	fi
97	cd $progressDirectory
98
99	listFiles=`ls \| grep -e "inputCmd__try__${numTry}__instance__[[:digit:]]\{1,2\}.list" `
100	for listFile in $listFiles
101	do
102	num=`echo $listFile \| awk -F"__" '{print $NF}' \| awk -F"." '{print $1}' `
103	if [ $num -gt $num_instance ]
104	then
105	num_instance=$num
106	fi
107	done
108	cd $ici
109	echo $num_instance
110
111
112	}
113
114
115	function check_progress
116	{
117	local file1=$1
118	local file2=$2
119	local file_to_get_retCode=$3
120	if [ "x${file1}" == "x" ] \|\| [ "x${file2}" == "x" ] \|\| [ "x${file_to_get_retCode}" == "x" ]
121	then
122	echo "check_progress : Le nom d'au moins 1 des 3 fichiers d'entree est vide" >> $badFailureFile
123	exit 1
124	fi
125
126	if [ ! -e $file1 ] \|\| [ ! -e $file2 ] \|\| [ ! -e ${file_to_get_retCode} ]
127	then
128	echo "check_progress : au moins un des 3 fichiers suivants n'existe pas :" >> $badFailureFile
129	echo "$file1" >> $badFailureFile
130	echo "$file2" >> $badFailureFile
131	echo "${file_to_get_retCode}" >> $badFailureFile
132	exit 1
133	fi
134	local nbLineFile1=`cat $file1 \| wc -l `
135	local nbLineFile2=`cat $file2 \| wc -l `
136	if [ $nbLineFile1 -ne $nbLineFile2 ]
137	then
138	echo 1
139	return
140	fi
141	# si l'on parvient a ce stade, c'est les 2 fichiers ont le meme
142	# nombre de lignes
143
144	old_IFS=$IFS # sauvegarde du séparateur de champ
145	IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne
146	for line in $( cat $file1 )
147	do
148	# echo $line
149	local isLineInFile2=`grep $line $file2 \| wc -l `
150	if [ $isLineInFile2 -eq 0 ]
151	then
152	echo 1
153	return
154	fi
155	done
156	IFS=$old_IFS # rétablissement du séparateur de champ par défaut
157
158	# Les codes de retour sont-ils != 0 ?
159	nbNonZeroCodes=`cat ${file_to_get_retCode} \| grep -e '^#executed by' \| awk '{ if ($9 != 0) {print $9} }' \| wc -l `
160	if [ $nbNonZeroCodes -gt 0 ]
161	then
162	echo 1
163	return
164	fi
165
166	echo 0
167	}
168
169
170	function update_report
171	{
172	> $reportFile # on vide le fichier rapport
173	echo "Execution of tasks :" >> $reportFile
174	echo "------------------" >> $reportFile
175	cat $inputCmd >> $reportFile
176	echo >> $reportFile
177	echo "Results of tasks :" >> $reportFile
178	echo "----------------" >> $reportFile
179	cat $output >> $reportFile
180	echo >> $reportFile
181	echo >> $reportFile
182
183	}
184
185	function searchListsToDestroy
186	{
187	outputToSearchIn=$1
188	listToRmvFile=$2
189	listsToProcessFile=$3
190	# On cherche les listes qui ont ete traitees correctement a la precedente etape de traitement
191	cat ${outputToSearchIn} \| grep -e '^#executed by' \| awk '{ if ($9 == 0) {print $12} }' >> ${listToRmvFile}
192
193	# Cependant, il se peut (cas du basculement de listes "output_ncrcat" vers "output_tar") que des listes soient
194	# encore a traiter alors que qu'il y a eu traitement correct.
195	# Ne pas supprimer ces listes (les retirer du fichier des listes a supprimer).
196	listToRmvFile_tmp="${listToRmvFile}_tmp"
197	cp $listToRmvFile $listToRmvFile_tmp
198
199	old_IFS=$IFS # sauvegarde du séparateur de champ
200	IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne
201	for list in $( cat $listToRmvFile_tmp \| grep "/output_ncrcat/" )
202	do
203	list_tar=`echo $list \| sed 's;output_ncrcat;output_tar;' `
204	isInLstsToProcess=`grep $list_tar $listsToProcessFile \| wc -l `
205	if [ "x${isInLstsToProcess}" != "x0" ]
206	then
207	lineNbInRmvFile=`grep -n $list $listToRmvFile \| awk -F":" '{print $1}' `
208	sed -i "${lineNbInRmvFile}d" ${listToRmvFile}
209	fi
210	done
211
212	for list in $( cat $listToRmvFile_tmp \| grep "/output_tar/" )
213	do
214	list_ncrcat=`echo $list \| sed 's;output_tar;output_ncrcat;' `
215	isInLstsToProcess=`grep $list_ncrcat $listsToProcessFile \| wc -l `
216	if [ "x${isInLstsToProcess}" != "x0" ]
217	then
218	lineNbInRmvFile=`grep -n $list $listToRmvFile \| awk -F":" '{print $1}' `
219	sed -i "${lineNbInRmvFile}d" ${listToRmvFile}
220	fi
221
222	# Si la liste est a detruire ET a traiter alors on l enleve de la liste a traiter
223	isInLstsToProcess=`grep $list $listsToProcessFile \| wc -l `
224	if [ "x${isInLstsToProcess}" != "x0" ]
225	then
226	lineNbInProcessFile=`grep -n $list $listsToProcessFile \| awk -F":" '{print $1}' `
227	sed -i "${lineNbInProcessFile}d" ${listsToProcessFile}
228	fi
229	done
230
231	IFS=$old_IFS # rétablissement du séparateur de champ par défaut
232
233	rm -f $listToRmvFile_tmp
234	}
235
236	function removeFilesInLists
237	{
238	setOfFileLstsToRmv=$1
239	rmvedFiles=$2
240	linksToEraseFile=$3
241	realDataToEraseFile=$4
242
243	old_IFS=$IFS # sauvegarde du séparateur de champ
244	IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne
245
246	# Suppression des donnees autres que celles de type "debug" et "restart".
247	for lst in $( cat $setOfFileLstsToRmv \| grep -v -E '(restart_tar\|debug_tar)' )
248	do
249	opt=
250	lstName=$( basename $lst )
251
252	if [ "${lstName}" == "tar_full_simul.list" ] \|\| [ "${lstName}" == "cp_files.list" ]
253	then
254	opt="r"
255	fi
256
257	for file in $( cat $lst )
258	do
259	echo "rm -f${opt} $file" >> ${rmvedFiles}
260	# rm -f${opt} $file
261	done
262	done
263
264	# Pour les listes de type "debug" et "restart", les listes ne comportent
265	# que des liens : uniquement leur nom de base, pas leur path
266	# Il faut retrouver leur path, detruire le lien et le fichier qu'il pointe.
267
268	# Recherche de l'ensemble des fichiers a detruire : les liens + les donnees pointees par les liens
269	for lst in $( cat $setOfFileLstsToRmv \| grep -E '(restart_tar\|debug_tar)' )
270	do
271	# Recuperation du repertoire contenant les fichiers de liens
272	dir_containing_links=
273	is_debug_tar_lst=`echo $lst \| grep "debug_tar" \| wc -l `
274	if [ "x${is_debug_tar_lst}" != "x0" ]
275	then
276	dir_containing_links="DEBUG"
277	else
278	dir_containing_links="RESTART"
279	fi
280
281	tar_dir=$( dirname $lst )
282	simu_dir=$( dirname $tar_dir )
283
284	LINK_DIR="${simu_dir}/${dir_containing_links}"
285	if [ ! -d $LINK_DIR ]
286	then
287	echo "Suppression des donnees :" >> $badFailureFile
288	echo "Le repertoire sense contenir des liens symboliques :" >> $badFailureFile
289	echo "${LINK_DIR}" >> $badFailureFile
290	echo "n'existe pas." >> $badFailureFile
291	exit 1
292	fi
293
294	#
295	# ls sur le reperoire de lien et insertion du path absolu avant chaque lien.
296	ls -1 ${LINK_DIR} \| sed "s;^;${LINK_DIR}/;" >> ${linksToEraseFile}
297
298	# Recuperation des donnees reelles pointees par les liens.
299	ls -1 -lrt ${LINK_DIR} \| awk -F"->" '{print $2}' \| sed 's;^ ;;' >> ${realDataToEraseFile}
300	done
301
302	# Destruction des liens et des donnees pointees par les liens pour les listes
303	# de type "debug" et "restart"
304
305	# Destroy links
306	for file in $( cat ${linksToEraseFile} )
307	do
308	echo "rm -f $file" >> ${rmvedFiles}
309	# rm -f $file
310	done
311
312	# Destroy real datas
313	for file in $( cat ${realDataToEraseFile} )
314	do
315	echo "rm -f $file" >> ${rmvedFiles}
316	# rm -f $file
317	done
318
319	IFS=$old_IFS # rétablissement du séparateur de champ par défaut
320	}
321
322
323	export RANDOM=$$ # random seed
324	function gives_random_number
325	{
326	lim=$1
327	bit=-1
328	let "bit = RANDOM % $lim"
329	bit=$(( $bit + 1 )) # nb entre 1 et $limit
330	echo $bit
331	}
332
333	########## batch directives : begin ##########
334	#MSUB -r pack_ipsl # Nom du job
335	### mutable directives ###
336	#MSUB -o /ccc/dmfbuf/ipsl_logs/dsm/bacasable/ARNAUD/PSEUDO_DMNFS_PROGRESS/zIGCM_OUT/IPSLCM5/detailed_pack_output/pack_ipsl_%I.o
337	#MSUB -e /ccc/dmfbuf/ipsl_logs/dsm/bacasable/ARNAUD/PSEUDO_DMNFS_PROGRESS/zIGCM_OUT/IPSLCM5/detailed_pack_output/pack_ipsl_%I.e
338	#MSUB -n 16
339	#MSUB -T 1500
340	#MSUB -A tgcc0013
341	#MSUB -q standard
342	#MSUB -Qos test
343	########## batch directives : end ##########
344
345	export JOB_DIR=${LS_SUBCWD:-${PWD}}
346	export EXE_DIR=${JOB_DIR}
347	source ${EXE_DIR}/DEM_utilities.sh
348
349	export badFailureFile=${USER_OUTPUT_PROGRESS}/badFailure.txt
350
351	export numCurrentTry=$( getNumeroOfCurrentTry )
352	export progressDir="${USER_OUTPUT_PROGRESS}/TRY__${numCurrentTry}"
353	if [ ! -e $progressDir ]
354	then
355	echo "Le repertoire de suivi :" >> $badFailureFile
356	echo "$progressDir" >> $badFailureFile
357	echo "n'existe pas. STOP." >> $badFailureFile
358	exit 1
359	fi
360	export numPrevInstance=$( getNumeroOfLastInstance $numCurrentTry )
361	export numNewInstance=$(( $numPrevInstance + 1 ))
362
363	export inputCmd="${progressDir}/inputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
364	export nextInputCmd="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
365	export output="${progressDir}/packOutput__try__${numCurrentTry}__instance__${numNewInstance}.log"
366	export reportFile="${progressDir}/report__try__${numCurrentTry}__instance__${numNewInstance}.log"
367	export checkFile="${progressDir}/check__try__${numCurrentTry}__instance__${numNewInstance}.log"
368	export checkFileTmp="checkTmp__try__${numCurrentTry}__instance__${numNewInstance}.txt"
369
370	export listsOfFilesToRemove="${progressDir}/listsToRmv__try__${numCurrentTry}__instance__${numNewInstance}.txt"
371	export removedFiles="${progressDir}/removedFiles__try__${numCurrentTry}__instance__${numNewInstance}.txt"
372
373	# Les 2 fichiers suivants sont crees pour la destruction des liens et des donnees pointes par ces liens
374	# dans le cas de listes de type "debug" ou "restart"
375	export linksToDestroyFile="${progressDir}/linksToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
376	export realDataToDestroyFile="${progressDir}/realDataToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
377
378	export noInterruptFile="${progressDir}/noInterrupt__try__${numCurrentTry}__instance__${numNewInstance}.txt"
379
380
381	if [ ${numCurrentTry} -le 1 ] && [ ${numNewInstance} -le 1 ]
382	then
383	# C'est le tout premier essai
384	# on construit la liste des taches a effectuer en inventoriant les fichiers *.liste
385	# dans les rep contenus dans le fichier "config_card.liste"
386	> ${inputCmd}
387	for CONFIG in $( awk '{print $1}' ${IGCM_DEM}/config_card.liste ) ; do
388
389	PATH_SIMU=$( dirname $CONFIG )
390	# echo "PATH_SIMU=$PATH_SIMU"
391
392	setOfListFiles=`find $PATH_SIMU -type f -name "*.list" `
393	for file in $setOfListFiles
394	do
395	echo "./process_list.sh $file" >> ${inputCmd}
396	done
397	done
398
399	else
400	# if try > 1 && inst == 1 ==> construction liste cmd avec fichiers try - 1, derniere instance
401	# dans ce dernier cas, gerer une eventuelle interruption au try - 1
402	# if try > 1 && inst > 1 ==> construction liste cmd avec fichiers try, instance precedente
403	if [ ${numNewInstance} -ge 2 ]
404	then
405	nextInputCmd_of_PrevInst="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numPrevInstance}.list"
406	if [ ! -e $nextInputCmd_of_PrevInst ]
407	then
408	echo "Le fichier suivant :" >> $badFailureFile
409	echo "$nextInputCmd_of_PrevInst" >> $badFailureFile
410	echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
411	exit 1
412	fi
413	cat $nextInputCmd_of_PrevInst > ${inputCmd}
414
415	else # numNewInstance == 1
416	numPrevTry=$(( $numCurrentTry - 1 ))
417	numLastInstInstanceInPrevTry=$( getNumeroOfLastInstance $numPrevTry )
418	noInterruptFile_prev_try="${progressDir}/noInterrupt__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
419	if [ ! -e ${noInterruptFile_prev_try} ]
420	then
421	# il y a eu interruption non prevue au dernier essai, il faut recomposer la liste des cmds avec les resultats
422	# de l'essai precedent, derniere instance
423	prevProgressDir="${USER_OUTPUT_PROGRESS}/TRY__${numPrevTry}"
424	nextInputCmd_of_LastInst="${prevProgressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
425	output_of_LastInst="${prevProgressDir}/packOutput__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.log"
426	inputCmd_of_LastInst="${prevProgressDir}/inputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
427	if [ ! -e $output_of_LastInst ] \|\| [ ! -e $inputCmd_of_LastInst ]
428	then
429	echo "Les fichiers suivants :" >> $badFailureFile
430	echo "$output_of_LastInst" >> $badFailureFile
431	echo "$inputCmd_of_LastInst" >> $badFailureFile
432	echo "n'existent pas. Il devrait exister. STOP." >> $badFailureFile
433	exit 1
434	fi
435
436	update_tasks_list ${nextInputCmd_of_LastInst} ${output_of_LastInst} ${inputCmd_of_LastInst}
437	cat $nextInputCmd_of_LastInst > ${inputCmd}
438
439
440	# Il faut aussi detruire les donnees correctement traitement a l'essai precedent, derniere instance.
441	listsOfFilesToRemoveFromPrevTry="${progressDir}/listsToRmvFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
442	removedFilesFromPrevTry="${progressDir}/removedFilesFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
443	linksToDestroyFileFromPrevTry="${progressDir}/linksToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
444	realDataToDestroyFileFromPrevTry="${progressDir}/realDataToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
445
446	searchListsToDestroy $output_of_LastInst $listsOfFilesToRemoveFromPrevTry ${inputCmd}
447	removeFilesInLists $listsOfFilesToRemoveFromPrevTry $removedFilesFromPrevTry $linksToDestroyFileFromPrevTry $realDataToDestroyFileFromPrevTry
448
449	else
450	nextInputCmd_of_LastInst="${progressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
451	if [ ! -e $nextInputCmd_of_LastInst ]
452	then
453	echo "Le fichier suivant :" >> $badFailureFile
454	echo "$nextInputCmd_of_LastInst" >> $badFailureFile
455	echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
456	exit 1
457	fi
458	cat $nextInputCmd_of_LastInst > ${inputCmd}
459	fi
460
461	fi
462	fi
463
464	# Initialisation du rapport : par defaut, les calculs ont ete interrompus
465	echo "No report. Le computation must have been interrupted." > $reportFile
466
467	# exit 0 # a virer
468
469	# a virer #########################################
470	# if [ ${numNewInstance} -ge 10 ]
471	# then
472	# echo >> $badFailureFile
473	# echo "10eme instance. STOP." >> $badFailureFile
474	# exit 1
475	# fi
476	###################################################
477	# startTime=$( getDateMilliSeconds ) # suppr
478	# echo "start time:$startTime" >> $timeHandlingFile # suppr
479	> $timeEndFile # added
480
481	ccc_mprun ./glost_launch -R $timeLimitBeforeEnd ${inputCmd} 2>${output}
482	if [ "x$?" != "x0" ]
483	then
484	echo "Temps limite atteint pour l'essai : ${numCurrentTry}; instance : ${numNewInstance}" >> $badFailureFile
485	fi
486
487	### ccc_mprun ./cmd_launch.exe ${inputCmd} 2>${output}
488
489	### ./cmd_launch.exe ${inputCmd} 2>${output}
490	### ccc_mprun -p standard -n ${BRIDGE_MSUB_NPROC} ./cmd_launch.exe ${inputCmd} 2>myIO/output.log
491	### mpirun -n 4 ./cmd_launch.exe myIO/inputCmd10.list 2>myIO/output.log
492
493	# meantime=$( getTimeDiffSeconds $startTime ) # suppr
494
495	endExecutionTime=$( getDateMilliSeconds )
496	echo "end time:$endExecutionTime" >> $timeEndFile
497
498
499
500	# echo "meantime ncrcat = $meantime"
501
502	# exit 0 # a virer
503
504	# Gestion des reprises :
505	# --------------------
506
507	update_report
508
509	update_tasks_list $nextInputCmd $output $inputCmd
510
511
512	# Verifications sur qq listes (dont le traitement semble correct) :
513	# ----------------------------------------------------------------------------------------
514	if [ "x${doYouWantCheck}" == "xyes" ]
515	then
516	if [ "x${nbListsToCheck}" == "x" ]
517	then
518	echo "nbre de listes a checker absent" >> $checkFile
519	echo "nbre de listes a checker absent" >> $badFailureFile
520	exit 1
521	fi
522	> $checkFileTmp
523	# ensemble des listes concatenees correctement
524	set_of_good_lists=`cat $output \| grep -e '^#executed by process' \| awk '{ if ($9==0){print $12} }' \| grep "output_ncrcat" `
525
526	# envoi des cmds de check dans fichier tmp
527	for lst in $set_of_good_lists
528	do
529	echo "./check_ncrcat_list.sh $lst" >> $checkFileTmp
530	done
531
532	# nombre de listes concatenees correctement
533	nb_of_good_lists=`cat $checkFileTmp \| wc -l `
534
535	# le nb de listes a checker ne peut exceder le nb de listes disponibles pour le check
536	if [ $nbListsToCheck -ge $nb_of_good_lists ]
537	then
538	nbListsToCheck=$nb_of_good_lists
539	fi
540	nbLstToCheck_tmp=$nbListsToCheck
541
542	while [ $nbLstToCheck_tmp -gt 0 ]
543	do
544	random_number=$( gives_random_number $nbLstToCheck_tmp ) # nb aleatoire entre 1 et $nbLstToCheck_tmp
545	checkCmd=`sed -n "${random_number}p" $checkFileTmp `
546	$checkCmd # on envoie la cmd de check
547	resCmd=$?
548	if [ "x${resCmd}" != "x0" ]
549	then
550	echo "$checkCmd ==> not OK ==> stop everything." >> $checkFile
551	echo "$checkCmd ==> not OK ==> stop everything." >> $badFailureFile
552	exit 1 # a retablir
553	else
554	echo "$checkCmd ==> OK" >> $checkFile
555	fi
556	sed -i "${random_number}d" $checkFileTmp # on retire la cmd qui vient d'etre effectuee du fichier tmp
557	nbLstToCheck_tmp=$(( $nbLstToCheck_tmp - 1 ))
558	done
559
560
561	rm $checkFileTmp
562	fi
563	# ----- Fin verif ------------------------------------------------------------------------
564
565
566	# Suppression des données des fichiers de listes correctement traitees -------------------
567	# Recherche des listes de fichiers de donnees a detruire :
568	# Parmi celles traitees, celles qui ont ete traitees correctement
569	> $listsOfFilesToRemove
570	> $removedFiles
571	> $linksToDestroyFile
572	> $realDataToDestroyFile
573
574	searchListsToDestroy $output $listsOfFilesToRemove $nextInputCmd
575
576	removeFilesInLists $listsOfFilesToRemove $removedFiles $linksToDestroyFile $realDataToDestroyFile
577
578
579
580	# ----- Fin suppression de donnees -------------------------------------------------------
581
582	# Si le fichier dans variable "noInterruptFile" inexistant, une interruption non prevue a eu lieu
583	echo "no interruption has occured" > ${noInterruptFile}
584
585	# exit 0 # a virer
586
587	# Tout s'est bien passe
588	# ----------------------
589	everythingOK=`cat $nextInputCmd \| wc -l `
590	if [ "x${everythingOK}" == "x0" ]
591	then
592	echo "Tout s'est fini correctement" >> $badFailureFile
593	exit 0
594	fi
595
596	# Y a t il progression entre avant traitements et apres ?
597	# ------------------------------------------------------
598	# Dans la fonction 'check_progress', on a besoin de verifier le code
599	# de retour du traitement des listes : en effet, si les 2 fichiers a comparer
600	# contiennent les memes fichiers de liste, il faut aussi que les codes de
601	# retour soient != 0.
602	file_to_get_lists_retCode=$output
603	resDiff=$( check_progress $inputCmd $nextInputCmd $file_to_get_lists_retCode )
604
605	# resDiff == 1 : fichiers differents
606	# resDiff == 0 : fichiers identiques
607	if [ "x${resDiff}" == "x0" ]
608	then
609	echo "Il n'y pas plus de progression" >> $badFailureFile
610	exit 1
611	fi
612
613	# On enchaine avec le meme script
614	ccc_msub launch_and_measureTime.sh

Note: See TracBrowser for help on using the repository browser.

Download in other formats: