Context Navigation

source: TOOLS/PACK_IPSL/launch_and_measureTime.sh @ 1906

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

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

Download in other formats: