source: TOOLS/launch_and_measureTime.sh @ 2133

Last change on this file since 2133 was 2133, checked in by acosce, 11 years ago

New tools allows packing simulation already pack (so pack with a bigger frequency)

File size: 22.4 KB
Line 
1#!/bin/bash
2
3function 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
65function 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
83function 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
115function 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
170function 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
185function 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
236function 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
344export RANDOM=$$ # random seed
345function 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 -c 2
361#MSUB -x
362#MSUB -T 1500
363#MSUB -A tgcc0013
364#MSUB -q standard
365#MSUB -Q test
366########## batch directives : end ##########
367set +x
368export JOB_DIR=${TMP_MIGR_DATA}
369export EXE_DIR=${LS_SUBCWD:-${PWD}}
370source ${EXE_DIR}/DEM_utilities.sh
371
372export badFailureFile=${USER_OUTPUT_PROGRESS}/badFailure.txt
373
374export numCurrentTry=$( getNumeroOfCurrentTry )
375export progressDir="${USER_OUTPUT_PROGRESS}/TRY__${numCurrentTry}"
376if [ ! -e $progressDir ]
377then
378   echo "Le repertoire de suivi :" >> $badFailureFile
379   echo "$progressDir" >> $badFailureFile
380   echo "n'existe pas. STOP." >> $badFailureFile   
381   exit 1
382fi
383export numPrevInstance=$( getNumeroOfLastInstance $numCurrentTry )
384export numNewInstance=$(( $numPrevInstance + 1 ))
385
386export inputCmd="${progressDir}/inputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
387export nextInputCmd="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
388export output="${progressDir}/packOutput__try__${numCurrentTry}__instance__${numNewInstance}.log"
389export reportFile="${progressDir}/report__try__${numCurrentTry}__instance__${numNewInstance}.log"
390export checkFile="${progressDir}/check__try__${numCurrentTry}__instance__${numNewInstance}.log"
391export checkFileTmp="${JOB_DIR}/checkTmp__try__${numCurrentTry}__instance__${numNewInstance}.txt"
392
393export listsOfFilesToRemove="${progressDir}/listsToRmv__try__${numCurrentTry}__instance__${numNewInstance}.txt"
394export removedFiles="${progressDir}/removedFiles__try__${numCurrentTry}__instance__${numNewInstance}.txt"
395
396# Les 2 fichiers suivants sont crees pour la destruction des liens et des donnees pointes par ces liens
397# dans le cas de listes de type "debug" ou "restart"
398export linksToDestroyFile="${progressDir}/linksToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
399export realDataToDestroyFile="${progressDir}/realDataToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
400
401export noInterruptFile="${progressDir}/noInterrupt__try__${numCurrentTry}__instance__${numNewInstance}.txt"
402
403
404if [ ${numCurrentTry} -le 1 ] && [ ${numNewInstance} -le 1 ]
405then
406    # C'est le tout premier essai
407    # on construit la liste des taches a effectuer en inventoriant les fichiers *.liste
408    # dans les rep contenus dans le fichier "config_card.liste"
409    > ${inputCmd}
410    for CONFIG in $( awk '{print $1}' ${IGCM_DEM}/config_card.liste ) ; do
411   
412       PATH_SIMU=$( dirname $CONFIG )
413       # echo "PATH_SIMU=$PATH_SIMU"
414
415       setOfListFiles=`find $PATH_SIMU -type f -name "*.list" `
416       for file in $setOfListFiles
417       do
418            echo "./process_list.sh $file" >> ${inputCmd}
419       done     
420    done
421   
422else
423    # if try > 1 && inst == 1 ==> construction liste cmd avec fichiers try - 1, derniere instance
424    #                             dans ce dernier cas, gerer une eventuelle interruption au try - 1
425    # if try > 1 && inst > 1  ==> construction liste cmd avec fichiers try, instance precedente
426    if [ ${numNewInstance} -ge 2 ]
427    then
428        nextInputCmd_of_PrevInst="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numPrevInstance}.list"
429        if [ ! -e $nextInputCmd_of_PrevInst ]
430        then
431            echo "Le fichier suivant :" >> $badFailureFile
432            echo "$nextInputCmd_of_PrevInst" >> $badFailureFile
433            echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
434            exit 1
435        fi
436        cat $nextInputCmd_of_PrevInst > ${inputCmd}
437   
438    else # numNewInstance == 1
439        numPrevTry=$(( $numCurrentTry - 1 ))
440        numLastInstInstanceInPrevTry=$( getNumeroOfLastInstance $numPrevTry )
441        noInterruptFile_prev_try="${progressDir}/noInterrupt__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
442        if [ ! -e ${noInterruptFile_prev_try} ]
443        then
444            # il y a eu interruption non prevue au dernier essai, il faut recomposer la liste des cmds avec les resultats
445            # de l'essai precedent, derniere instance
446            prevProgressDir="${USER_OUTPUT_PROGRESS}/TRY__${numPrevTry}"
447            nextInputCmd_of_LastInst="${prevProgressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
448            output_of_LastInst="${prevProgressDir}/packOutput__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.log"
449            inputCmd_of_LastInst="${prevProgressDir}/inputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
450            if [ ! -e $output_of_LastInst ] || [ ! -e $inputCmd_of_LastInst ]
451            then
452                echo "Les fichiers suivants :" >> $badFailureFile
453                echo "$output_of_LastInst" >> $badFailureFile
454                echo "$inputCmd_of_LastInst" >> $badFailureFile
455                echo "n'existent pas. Il devrait exister. STOP." >> $badFailureFile
456                exit 1
457            fi
458           
459            update_tasks_list ${nextInputCmd_of_LastInst} ${output_of_LastInst} ${inputCmd_of_LastInst}
460            cat $nextInputCmd_of_LastInst > ${inputCmd}
461           
462           
463            # Il faut aussi detruire les donnees correctement traitement a l'essai precedent, derniere instance.
464            listsOfFilesToRemoveFromPrevTry="${progressDir}/listsToRmvFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
465            removedFilesFromPrevTry="${progressDir}/removedFilesFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
466            linksToDestroyFileFromPrevTry="${progressDir}/linksToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
467            realDataToDestroyFileFromPrevTry="${progressDir}/realDataToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
468                   
469            searchListsToDestroy $output_of_LastInst $listsOfFilesToRemoveFromPrevTry ${inputCmd}
470            removeFilesInLists $listsOfFilesToRemoveFromPrevTry $removedFilesFromPrevTry $linksToDestroyFileFromPrevTry $realDataToDestroyFileFromPrevTry
471           
472        else
473            nextInputCmd_of_LastInst="${progressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
474            if [ ! -e $nextInputCmd_of_LastInst ]
475            then
476                echo "Le fichier suivant :" >> $badFailureFile
477                echo "$nextInputCmd_of_LastInst" >> $badFailureFile
478                echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
479                exit 1
480            fi
481            cat $nextInputCmd_of_LastInst > ${inputCmd}
482        fi
483       
484    fi
485fi
486
487# Initialisation du rapport : par defaut, les calculs ont ete interrompus
488echo "No report. Le computation must have been interrupted." > $reportFile
489
490# exit 0 # a virer
491
492# a virer #########################################
493# if [ ${numNewInstance} -ge 10 ]
494# then
495#     echo >> $badFailureFile
496#     echo "10eme instance. STOP." >> $badFailureFile
497#     exit 1
498# fi
499###################################################
500# startTime=$( getDateMilliSeconds ) # suppr
501# echo "start time:$startTime" >> $timeHandlingFile # suppr
502> $timeEndFile # added
503
504ccc_mprun  ./glost_launch -R $timeLimitBeforeEnd ${inputCmd} 2>${output}
505if [ "x$?" != "x0" ]
506then
507   echo "Temps limite atteint pour l'essai : ${numCurrentTry}; instance : ${numNewInstance}" >> $badFailureFile
508fi
509
510### ccc_mprun  ./cmd_launch.exe ${inputCmd} 2>${output}
511
512###    ./cmd_launch.exe ${inputCmd} 2>${output}
513###    ccc_mprun -p standard -n ${BRIDGE_MSUB_NPROC} ./cmd_launch.exe ${inputCmd} 2>myIO/output.log
514###    mpirun -n 4 ./cmd_launch.exe myIO/inputCmd10.list 2>myIO/output.log
515
516# meantime=$( getTimeDiffSeconds $startTime ) # suppr
517
518endExecutionTime=$( getDateMilliSeconds )
519echo "end time:$endExecutionTime" >> $timeEndFile
520
521
522
523# echo "meantime ncrcat = $meantime"
524
525# exit 0 # a virer
526
527# Gestion des reprises :
528# --------------------
529
530update_report
531
532update_tasks_list $nextInputCmd $output $inputCmd
533
534
535# Verifications sur qq listes (dont le traitement semble correct) :
536# ----------------------------------------------------------------------------------------
537if [ "x${doYouWantCheck}" == "xyes" ]
538then
539    if [ "x${nbListsToCheck}" == "x" ]
540    then
541        echo "nbre de listes a checker absent" >> $checkFile
542        echo "nbre de listes a checker absent" >> $badFailureFile
543        exit 1
544    fi
545    > $checkFileTmp
546    # ensemble des listes concatenees correctement
547    set_of_good_lists=`cat $output | grep -e '^#executed by process' | awk '{ if ($9==0){print $12} }' | grep "output_ncrcat" `
548
549    # envoi des cmds de check dans fichier tmp
550    for lst in $set_of_good_lists
551    do
552       echo "./check_ncrcat_list.sh $lst" >> $checkFileTmp
553    done
554
555    # nombre de listes concatenees correctement
556    nb_of_good_lists=`cat $checkFileTmp | wc -l `
557
558    # le nb de listes a checker ne peut exceder le nb de listes disponibles pour le check
559    if [ $nbListsToCheck -ge $nb_of_good_lists ]
560    then
561        nbListsToCheck=$nb_of_good_lists
562    fi
563    nbLstToCheck_tmp=$nbListsToCheck
564
565    while [ $nbLstToCheck_tmp -gt 0 ]
566    do
567        random_number=$( gives_random_number $nbLstToCheck_tmp ) # nb aleatoire entre 1 et $nbLstToCheck_tmp
568        checkCmd=`sed -n "${random_number}p" $checkFileTmp `
569        $checkCmd # on envoie la cmd de check
570        resCmd=$?
571        if [ "x${resCmd}" != "x0" ]
572        then
573            echo "$checkCmd ==> not OK ==> stop everything." >> $checkFile
574            echo "$checkCmd ==> not OK ==> stop everything." >> $badFailureFile
575            exit 1 # a retablir
576        else
577            echo "$checkCmd ==> OK" >> $checkFile
578        fi
579        sed -i "${random_number}d" $checkFileTmp # on retire la cmd qui vient d'etre effectuee du fichier tmp
580        nbLstToCheck_tmp=$(( $nbLstToCheck_tmp - 1 ))
581    done
582
583
584    rm $checkFileTmp
585fi
586# ----- Fin verif ------------------------------------------------------------------------
587
588
589# Suppression des données des fichiers de listes correctement traitees -------------------
590# Recherche des listes de fichiers de donnees a detruire :
591# Parmi celles traitees, celles qui ont ete traitees correctement
592> $listsOfFilesToRemove
593> $removedFiles
594> $linksToDestroyFile
595> $realDataToDestroyFile
596
597searchListsToDestroy $output $listsOfFilesToRemove $nextInputCmd
598
599removeFilesInLists $listsOfFilesToRemove $removedFiles $linksToDestroyFile $realDataToDestroyFile
600
601
602
603# ----- Fin suppression de donnees -------------------------------------------------------
604
605# Si le fichier dans variable "noInterruptFile" inexistant, une interruption non prevue a eu lieu
606echo "no interruption has occured" > ${noInterruptFile}
607
608# exit 0 # a virer
609
610# Tout s'est bien passe
611# ----------------------
612everythingOK=`cat $nextInputCmd | wc -l `
613if [ "x${everythingOK}" == "x0" ]
614then
615    echo "Tout s'est fini correctement" >> $badFailureFile
616    exit 0
617fi
618
619# Y a t il progression entre avant traitements et apres ?
620# ------------------------------------------------------
621# Dans la fonction 'check_progress', on a besoin de verifier le code
622# de retour du traitement des listes : en effet, si les 2 fichiers a comparer
623# contiennent les memes fichiers de liste, il faut aussi que les codes de
624# retour soient != 0.
625file_to_get_lists_retCode=$output
626resDiff=$( check_progress $inputCmd $nextInputCmd $file_to_get_lists_retCode )
627
628# resDiff == 1 : fichiers differents
629# resDiff == 0 : fichiers identiques
630if [ "x${resDiff}" == "x0" ]
631then
632    echo "Il n'y pas plus de progression" >> $badFailureFile
633    exit 1
634fi
635
636# On enchaine avec le meme script
637ccc_msub ${TMP_MIGR_DATA}/launch_and_measureTime.sh
Note: See TracBrowser for help on using the repository browser.