Context Navigation

source: TOOLS/PACK_IPSL/launch_and_measureTime.sh @ 2011

Last change on this file since 2011 was 2010, checked in by aclsce, 11 years ago
Modified to go faster.
Property svn:executable set to ``*
File size: 22.4 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 > ${JOB_DIR}/taskFile.txt
61	cat ${JOB_DIR}/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 # retablissement du separateur de champ par defaut
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	sed -e "s/\(.*\)/rm -f${opt} \1/" $lst >> ${rmvedFiles}
258
259	# for file in $( cat $lst )
260	# do
261	# echo "rm -f${opt} $file" >> ${rmvedFiles}
262	# if [ "x$deleteFiles" == "x1" ]
263	# then
264	# rm -f${opt} $file
265	# fi
266	# done
267	done
268
269	# Pour les listes de type "debug" et "restart", les listes ne comportent
270	# que des liens : uniquement leur nom de base, pas leur path
271	# Il faut retrouver leur path, detruire le lien et le fichier qu'il pointe.
272
273	# Recherche de l'ensemble des fichiers a detruire : les liens + les donnees pointees par les liens
274	for lst in $( cat $setOfFileLstsToRmv \| grep -E '(restart_tar\|debug_tar)' )
275	do
276	# Recuperation du repertoire contenant les fichiers de liens
277	dir_containing_links=
278	is_debug_tar_lst=`echo $lst \| grep "debug_tar" \| wc -l `
279	if [ "x${is_debug_tar_lst}" != "x0" ]
280	then
281	dir_containing_links="DEBUG"
282	else
283	dir_containing_links="RESTART"
284	fi
285
286	tar_dir=$( dirname $lst )
287	simu_dir=$( dirname $tar_dir )
288
289	LINK_DIR="${simu_dir}/${dir_containing_links}"
290	if [ ! -d $LINK_DIR ]
291	then
292	echo "Suppression des donnees :" >> $badFailureFile
293	echo "Le repertoire sense contenir des liens symboliques :" >> $badFailureFile
294	echo "${LINK_DIR}" >> $badFailureFile
295	echo "n'existe pas." >> $badFailureFile
296	exit 1
297	fi
298
299	#
300	# ls sur le reperoire de lien et insertion du path absolu avant chaque lien.
301	ls -1 ${LINK_DIR} \| sed "s;^;${LINK_DIR}/;" >> ${linksToEraseFile}
302
303	# Recuperation des donnees reelles pointees par les liens.
304	ls -1 -lrt ${LINK_DIR} \| awk -F"->" '{print $2}' \| sed 's;^ ;;' >> ${realDataToEraseFile}
305	done
306
307	# Destruction des liens et des donnees pointees par les liens pour les listes
308	# de type "debug" et "restart"
309
310	# Destroy links
311
312	# for file in $( cat ${linksToEraseFile} )
313	# do
314	# echo "rm -f $file" >> ${rmvedFiles}
315	# if [ "x$deleteFiles" == "x1" ]
316	# then
317	# rm -f $file
318	# fi
319	# done
320
321	sed -e "s/\(.*\)/rm -f \1/" ${linksToEraseFile} >> ${rmvedFiles}
322
323	# Destroy real datas
324	# for file in $( cat ${realDataToEraseFile} )
325	# do
326	# echo "rm -f $file" >> ${rmvedFiles}
327	# if [ "x$deleteFiles" == "x1" ]
328	# then
329	# rm -f $file
330	# fi
331	# done
332
333	sed -e "s/\(.*\)/rm -f \1/" ${realDataToEraseFile} >> ${rmvedFiles}
334
335	if [ "x$deleteFiles" == "x1" ]
336	then
337	sh ${rmvedFiles}
338	fi
339
340	IFS=$old_IFS # retablissement du separateur de champ par defaut
341	}
342
343
344	export RANDOM=$$ # random seed
345	function gives_random_number
346	{
347	lim=$1
348	bit=-1
349	let "bit = RANDOM % $lim"
350	bit=$(( $bit + 1 )) # nb entre 1 et $limit
351	echo $bit
352	}
353
354	########## batch directives : begin ##########
355	#MSUB -r pack_ipsl # Nom du job
356	### mutable directives ###
357	#MSUB -o /ccc/dmfbuf/ipsl_logs/dsm/bacasable/ARNAUD/PSEUDO_DMNFS_PROGRESS/ARNAUD/IPSLCM5/R55C/detailed_pack_output/pack_ipsl_%I.o
358	#MSUB -e /ccc/dmfbuf/ipsl_logs/dsm/bacasable/ARNAUD/PSEUDO_DMNFS_PROGRESS/ARNAUD/IPSLCM5/R55C/detailed_pack_output/pack_ipsl_%I.e
359	#MSUB -n 16
360	#MSUB -T 1500
361	#MSUB -A tgcc0013
362	#MSUB -q standard
363	#MSUB -Qos test
364	########## batch directives : end ##########
365	set +x
366	export JOB_DIR=${TMP_MIGR_DATA}
367	export EXE_DIR=${LS_SUBCWD:-${PWD}}
368	source ${EXE_DIR}/DEM_utilities.sh
369
370	export badFailureFile=${USER_OUTPUT_PROGRESS}/badFailure.txt
371
372	export numCurrentTry=$( getNumeroOfCurrentTry )
373	export progressDir="${USER_OUTPUT_PROGRESS}/TRY__${numCurrentTry}"
374	if [ ! -e $progressDir ]
375	then
376	echo "Le repertoire de suivi :" >> $badFailureFile
377	echo "$progressDir" >> $badFailureFile
378	echo "n'existe pas. STOP." >> $badFailureFile
379	exit 1
380	fi
381	export numPrevInstance=$( getNumeroOfLastInstance $numCurrentTry )
382	export numNewInstance=$(( $numPrevInstance + 1 ))
383
384	export inputCmd="${progressDir}/inputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
385	export nextInputCmd="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
386	export output="${progressDir}/packOutput__try__${numCurrentTry}__instance__${numNewInstance}.log"
387	export reportFile="${progressDir}/report__try__${numCurrentTry}__instance__${numNewInstance}.log"
388	export checkFile="${progressDir}/check__try__${numCurrentTry}__instance__${numNewInstance}.log"
389	export checkFileTmp="${JOB_DIR}/checkTmp__try__${numCurrentTry}__instance__${numNewInstance}.txt"
390
391	export listsOfFilesToRemove="${progressDir}/listsToRmv__try__${numCurrentTry}__instance__${numNewInstance}.txt"
392	export removedFiles="${progressDir}/removedFiles__try__${numCurrentTry}__instance__${numNewInstance}.txt"
393
394	# Les 2 fichiers suivants sont crees pour la destruction des liens et des donnees pointes par ces liens
395	# dans le cas de listes de type "debug" ou "restart"
396	export linksToDestroyFile="${progressDir}/linksToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
397	export realDataToDestroyFile="${progressDir}/realDataToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
398
399	export noInterruptFile="${progressDir}/noInterrupt__try__${numCurrentTry}__instance__${numNewInstance}.txt"
400
401
402	if [ ${numCurrentTry} -le 1 ] && [ ${numNewInstance} -le 1 ]
403	then
404	# C'est le tout premier essai
405	# on construit la liste des taches a effectuer en inventoriant les fichiers *.liste
406	# dans les rep contenus dans le fichier "config_card.liste"
407	> ${inputCmd}
408	for CONFIG in $( awk '{print $1}' ${IGCM_DEM}/config_card.liste ) ; do
409
410	PATH_SIMU=$( dirname $CONFIG )
411	# echo "PATH_SIMU=$PATH_SIMU"
412
413	setOfListFiles=`find $PATH_SIMU -type f -name "*.list" `
414	for file in $setOfListFiles
415	do
416	echo "./process_list.sh $file" >> ${inputCmd}
417	done
418	done
419
420	else
421	# if try > 1 && inst == 1 ==> construction liste cmd avec fichiers try - 1, derniere instance
422	# dans ce dernier cas, gerer une eventuelle interruption au try - 1
423	# if try > 1 && inst > 1 ==> construction liste cmd avec fichiers try, instance precedente
424	if [ ${numNewInstance} -ge 2 ]
425	then
426	nextInputCmd_of_PrevInst="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numPrevInstance}.list"
427	if [ ! -e $nextInputCmd_of_PrevInst ]
428	then
429	echo "Le fichier suivant :" >> $badFailureFile
430	echo "$nextInputCmd_of_PrevInst" >> $badFailureFile
431	echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
432	exit 1
433	fi
434	cat $nextInputCmd_of_PrevInst > ${inputCmd}
435
436	else # numNewInstance == 1
437	numPrevTry=$(( $numCurrentTry - 1 ))
438	numLastInstInstanceInPrevTry=$( getNumeroOfLastInstance $numPrevTry )
439	noInterruptFile_prev_try="${progressDir}/noInterrupt__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
440	if [ ! -e ${noInterruptFile_prev_try} ]
441	then
442	# il y a eu interruption non prevue au dernier essai, il faut recomposer la liste des cmds avec les resultats
443	# de l'essai precedent, derniere instance
444	prevProgressDir="${USER_OUTPUT_PROGRESS}/TRY__${numPrevTry}"
445	nextInputCmd_of_LastInst="${prevProgressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
446	output_of_LastInst="${prevProgressDir}/packOutput__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.log"
447	inputCmd_of_LastInst="${prevProgressDir}/inputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
448	if [ ! -e $output_of_LastInst ] \|\| [ ! -e $inputCmd_of_LastInst ]
449	then
450	echo "Les fichiers suivants :" >> $badFailureFile
451	echo "$output_of_LastInst" >> $badFailureFile
452	echo "$inputCmd_of_LastInst" >> $badFailureFile
453	echo "n'existent pas. Il devrait exister. STOP." >> $badFailureFile
454	exit 1
455	fi
456
457	update_tasks_list ${nextInputCmd_of_LastInst} ${output_of_LastInst} ${inputCmd_of_LastInst}
458	cat $nextInputCmd_of_LastInst > ${inputCmd}
459
460
461	# Il faut aussi detruire les donnees correctement traitement a l'essai precedent, derniere instance.
462	listsOfFilesToRemoveFromPrevTry="${progressDir}/listsToRmvFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
463	removedFilesFromPrevTry="${progressDir}/removedFilesFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
464	linksToDestroyFileFromPrevTry="${progressDir}/linksToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
465	realDataToDestroyFileFromPrevTry="${progressDir}/realDataToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
466
467	searchListsToDestroy $output_of_LastInst $listsOfFilesToRemoveFromPrevTry ${inputCmd}
468	removeFilesInLists $listsOfFilesToRemoveFromPrevTry $removedFilesFromPrevTry $linksToDestroyFileFromPrevTry $realDataToDestroyFileFromPrevTry
469
470	else
471	nextInputCmd_of_LastInst="${progressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
472	if [ ! -e $nextInputCmd_of_LastInst ]
473	then
474	echo "Le fichier suivant :" >> $badFailureFile
475	echo "$nextInputCmd_of_LastInst" >> $badFailureFile
476	echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
477	exit 1
478	fi
479	cat $nextInputCmd_of_LastInst > ${inputCmd}
480	fi
481
482	fi
483	fi
484
485	# Initialisation du rapport : par defaut, les calculs ont ete interrompus
486	echo "No report. Le computation must have been interrupted." > $reportFile
487
488	# exit 0 # a virer
489
490	# a virer #########################################
491	# if [ ${numNewInstance} -ge 10 ]
492	# then
493	# echo >> $badFailureFile
494	# echo "10eme instance. STOP." >> $badFailureFile
495	# exit 1
496	# fi
497	###################################################
498	# startTime=$( getDateMilliSeconds ) # suppr
499	# echo "start time:$startTime" >> $timeHandlingFile # suppr
500	> $timeEndFile # added
501
502	ccc_mprun ./glost_launch -R $timeLimitBeforeEnd ${inputCmd} 2>${output}
503	if [ "x$?" != "x0" ]
504	then
505	echo "Temps limite atteint pour l'essai : ${numCurrentTry}; instance : ${numNewInstance}" >> $badFailureFile
506	fi
507
508	### ccc_mprun ./cmd_launch.exe ${inputCmd} 2>${output}
509
510	### ./cmd_launch.exe ${inputCmd} 2>${output}
511	### ccc_mprun -p standard -n ${BRIDGE_MSUB_NPROC} ./cmd_launch.exe ${inputCmd} 2>myIO/output.log
512	### mpirun -n 4 ./cmd_launch.exe myIO/inputCmd10.list 2>myIO/output.log
513
514	# meantime=$( getTimeDiffSeconds $startTime ) # suppr
515
516	endExecutionTime=$( getDateMilliSeconds )
517	echo "end time:$endExecutionTime" >> $timeEndFile
518
519
520
521	# echo "meantime ncrcat = $meantime"
522
523	# exit 0 # a virer
524
525	# Gestion des reprises :
526	# --------------------
527
528	update_report
529
530	update_tasks_list $nextInputCmd $output $inputCmd
531
532
533	# Verifications sur qq listes (dont le traitement semble correct) :
534	# ----------------------------------------------------------------------------------------
535	if [ "x${doYouWantCheck}" == "xyes" ]
536	then
537	if [ "x${nbListsToCheck}" == "x" ]
538	then
539	echo "nbre de listes a checker absent" >> $checkFile
540	echo "nbre de listes a checker absent" >> $badFailureFile
541	exit 1
542	fi
543	> $checkFileTmp
544	# ensemble des listes concatenees correctement
545	set_of_good_lists=`cat $output \| grep -e '^#executed by process' \| awk '{ if ($9==0){print $12} }' \| grep "output_ncrcat" `
546
547	# envoi des cmds de check dans fichier tmp
548	for lst in $set_of_good_lists
549	do
550	echo "./check_ncrcat_list.sh $lst" >> $checkFileTmp
551	done
552
553	# nombre de listes concatenees correctement
554	nb_of_good_lists=`cat $checkFileTmp \| wc -l `
555
556	# le nb de listes a checker ne peut exceder le nb de listes disponibles pour le check
557	if [ $nbListsToCheck -ge $nb_of_good_lists ]
558	then
559	nbListsToCheck=$nb_of_good_lists
560	fi
561	nbLstToCheck_tmp=$nbListsToCheck
562
563	while [ $nbLstToCheck_tmp -gt 0 ]
564	do
565	random_number=$( gives_random_number $nbLstToCheck_tmp ) # nb aleatoire entre 1 et $nbLstToCheck_tmp
566	checkCmd=`sed -n "${random_number}p" $checkFileTmp `
567	$checkCmd # on envoie la cmd de check
568	resCmd=$?
569	if [ "x${resCmd}" != "x0" ]
570	then
571	echo "$checkCmd ==> not OK ==> stop everything." >> $checkFile
572	echo "$checkCmd ==> not OK ==> stop everything." >> $badFailureFile
573	exit 1 # a retablir
574	else
575	echo "$checkCmd ==> OK" >> $checkFile
576	fi
577	sed -i "${random_number}d" $checkFileTmp # on retire la cmd qui vient d'etre effectuee du fichier tmp
578	nbLstToCheck_tmp=$(( $nbLstToCheck_tmp - 1 ))
579	done
580
581
582	rm $checkFileTmp
583	fi
584	# ----- Fin verif ------------------------------------------------------------------------
585
586
587	# Suppression des données des fichiers de listes correctement traitees -------------------
588	# Recherche des listes de fichiers de donnees a detruire :
589	# Parmi celles traitees, celles qui ont ete traitees correctement
590	> $listsOfFilesToRemove
591	> $removedFiles
592	> $linksToDestroyFile
593	> $realDataToDestroyFile
594
595	searchListsToDestroy $output $listsOfFilesToRemove $nextInputCmd
596
597	removeFilesInLists $listsOfFilesToRemove $removedFiles $linksToDestroyFile $realDataToDestroyFile
598
599
600
601	# ----- Fin suppression de donnees -------------------------------------------------------
602
603	# Si le fichier dans variable "noInterruptFile" inexistant, une interruption non prevue a eu lieu
604	echo "no interruption has occured" > ${noInterruptFile}
605
606	# exit 0 # a virer
607
608	# Tout s'est bien passe
609	# ----------------------
610	everythingOK=`cat $nextInputCmd \| wc -l `
611	if [ "x${everythingOK}" == "x0" ]
612	then
613	echo "Tout s'est fini correctement" >> $badFailureFile
614	exit 0
615	fi
616
617	# Y a t il progression entre avant traitements et apres ?
618	# ------------------------------------------------------
619	# Dans la fonction 'check_progress', on a besoin de verifier le code
620	# de retour du traitement des listes : en effet, si les 2 fichiers a comparer
621	# contiennent les memes fichiers de liste, il faut aussi que les codes de
622	# retour soient != 0.
623	file_to_get_lists_retCode=$output
624	resDiff=$( check_progress $inputCmd $nextInputCmd $file_to_get_lists_retCode )
625
626	# resDiff == 1 : fichiers differents
627	# resDiff == 0 : fichiers identiques
628	if [ "x${resDiff}" == "x0" ]
629	then
630	echo "Il n'y pas plus de progression" >> $badFailureFile
631	exit 1
632	fi
633
634	# On enchaine avec le meme script
635	ccc_msub ${TMP_MIGR_DATA}/launch_and_measureTime.sh

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

Download in other formats: