source: TOOLS/PACK_IPSL/launch_and_measureTime.sh @ 1911

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