Context Navigation

source: TOOLS/PACK_IPSL/launch_and_measureTime.sh @ 1881

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

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

Download in other formats: