#!/bin/bash function update_tasks_list { local tasksListFile=$1 # fichier contenant la nouvelle liste de cmds touch $tasksListFile local logFileOfPrevPack=$2 # fichier log de relatif a l'execution de la derniere liste de cmds local tasksListFileOfPrevPack=$3 # fichier contenant la derniere liste de cmds > $tasksListFile old_IFS=$IFS # sauvegarde du séparateur de champ IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne for cmdReport in $( cat $logFileOfPrevPack | grep -e '^#executed by process' ) do local resCmd=`echo $cmdReport | awk '{print $9}' ` # Status 50 = FAILED mais pas de ressoumission if [ "x$resCmd" != "x0" ] && [ "x$resCmd" != "x50" ] then local cmdToPrint=`echo $cmdReport | awk '{print $NF}' ` case "x$resCmd" in x5) newCmdToPrint=`echo $cmdToPrint | sed 's;output_ncrcat;output_tar;' ` echo "./process_list.sh $newCmdToPrint" >> ${tasksListFile} ;; x10) echo "./process_list.sh $cmdToPrint" >> ${tasksListFile} newCmdToPrint=`echo $cmdToPrint | sed 's;output_ncrcat;output_tar;' ` echo "./process_list.sh $newCmdToPrint" >> ${tasksListFile} ;; *) echo "./process_list.sh $cmdToPrint" >> ${tasksListFile} ;; esac fi done IFS=$old_IFS # rétablissement du séparateur de champ par défaut # Il faut aussi rajouter les cmds qui n'ont pas ete traitees du tout, # par exemple en cas d'interruption du calculateur # Pour cela, on boucle sur la derniere liste de cmds et on cherche dans le # fichier log associe si certaines sont absentes. On remet ces commandes (absentes) # dans la nouvelle liste old_IFS=$IFS # sauvegarde du séparateur de champ IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne for cmd in $( cat $tasksListFileOfPrevPack ) do local list=`echo $cmd | awk '{print $NF}' ` hasListBeenTreated=`grep $list $logFileOfPrevPack | wc -l ` if [ "x${hasListBeenTreated}" == "x0" ] then echo $cmd >> ${tasksListFile} fi done IFS=$old_IFS # rétablissement du séparateur de champ par défaut # Il peut arriver que 2 listes soient identiques, on empeche ce cas cat ${tasksListFile} | sort | uniq > ${JOB_DIR}/taskFile.txt cat ${JOB_DIR}/taskFile.txt > ${tasksListFile} } function getNumeroOfCurrentTry { local num_try="1" tryNumFile=${USER_OUTPUT_PROGRESS}/numero_current_try.txt if [ ! -e $tryNumFile ] then echo "Le fichier :" >> $badFailureFile echo "$tryNumFile" >> $badFailureFile echo "doit etre present dans le repertoire :" >> $badFailureFile echo "${USER_OUTPUT_PROGRESS}" >> $badFailureFile echo "et il doit contenir un numero d'essai" >> $badFailureFile exit 1 fi num_try=`head -n 1 $tryNumFile ` echo $num_try } function getNumeroOfLastInstance { local num_instance="0" local numTry=$1 ici=$PWD local progressDirectory="${USER_OUTPUT_PROGRESS}/TRY__${numTry}" if [ ! -e $progressDirectory ] then echo "fonction getNumeroOfLastInstance :" >> $badFailureFile echo "Le repertoire :" >> $badFailureFile echo "$progressDirectory" >> $badFailureFile echo "devrait exister. Il n'existe pas." >> $badFailureFile exit 1 fi cd $progressDirectory listFiles=`ls | grep -e "inputCmd__try__${numTry}__instance__[[:digit:]]\{1,2\}.list" ` for listFile in $listFiles do num=`echo $listFile | awk -F"__" '{print $NF}' | awk -F"." '{print $1}' ` if [ $num -gt $num_instance ] then num_instance=$num fi done cd $ici echo $num_instance } function check_progress { local file1=$1 local file2=$2 local file_to_get_retCode=$3 if [ "x${file1}" == "x" ] || [ "x${file2}" == "x" ] || [ "x${file_to_get_retCode}" == "x" ] then echo "check_progress : Le nom d'au moins 1 des 3 fichiers d'entree est vide" >> $badFailureFile exit 1 fi if [ ! -e $file1 ] || [ ! -e $file2 ] || [ ! -e ${file_to_get_retCode} ] then echo "check_progress : au moins un des 3 fichiers suivants n'existe pas :" >> $badFailureFile echo "$file1" >> $badFailureFile echo "$file2" >> $badFailureFile echo "${file_to_get_retCode}" >> $badFailureFile exit 1 fi local nbLineFile1=`cat $file1 | wc -l ` local nbLineFile2=`cat $file2 | wc -l ` if [ $nbLineFile1 -ne $nbLineFile2 ] then echo 1 return fi # si l'on parvient a ce stade, c'est les 2 fichiers ont le meme # nombre de lignes old_IFS=$IFS # sauvegarde du séparateur de champ IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne for line in $( cat $file1 ) do # echo $line local isLineInFile2=`grep $line $file2 | wc -l ` if [ $isLineInFile2 -eq 0 ] then echo 1 return fi done IFS=$old_IFS # rétablissement du séparateur de champ par défaut # Les codes de retour sont-ils != 0 ? nbNonZeroCodes=`cat ${file_to_get_retCode} | grep -e '^#executed by' | awk '{ if ($9 != 0) {print $9} }' | wc -l ` if [ $nbNonZeroCodes -gt 0 ] then echo 1 return fi echo 0 } function update_report { > $reportFile # on vide le fichier rapport echo "Execution of tasks :" >> $reportFile echo "------------------" >> $reportFile cat $inputCmd >> $reportFile echo >> $reportFile echo "Results of tasks :" >> $reportFile echo "----------------" >> $reportFile cat $output >> $reportFile echo >> $reportFile echo >> $reportFile } function searchListsToDestroy { outputToSearchIn=$1 listToRmvFile=$2 listsToProcessFile=$3 # On cherche les listes qui ont ete traitees correctement a la precedente etape de traitement cat ${outputToSearchIn} | grep -e '^#executed by' | awk '{ if ($9 == 0) {print $12} }' >> ${listToRmvFile} # Cependant, il se peut (cas du basculement de listes "output_ncrcat" vers "output_tar") que des listes soient # encore a traiter alors que qu'il y a eu traitement correct. # Ne pas supprimer ces listes (les retirer du fichier des listes a supprimer). listToRmvFile_tmp="${listToRmvFile}_tmp" cp $listToRmvFile $listToRmvFile_tmp old_IFS=$IFS # sauvegarde du séparateur de champ IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne for list in $( cat $listToRmvFile_tmp | grep "/output_ncrcat/" ) do list_tar=`echo $list | sed 's;output_ncrcat;output_tar;' ` isInLstsToProcess=`grep $list_tar $listsToProcessFile | wc -l ` if [ "x${isInLstsToProcess}" != "x0" ] then lineNbInRmvFile=`grep -n $list $listToRmvFile | awk -F":" '{print $1}' ` sed -i "${lineNbInRmvFile}d" ${listToRmvFile} fi done for list in $( cat $listToRmvFile_tmp | grep "/output_tar/" ) do list_ncrcat=`echo $list | sed 's;output_tar;output_ncrcat;' ` isInLstsToProcess=`grep $list_ncrcat $listsToProcessFile | wc -l ` if [ "x${isInLstsToProcess}" != "x0" ] then lineNbInRmvFile=`grep -n $list $listToRmvFile | awk -F":" '{print $1}' ` sed -i "${lineNbInRmvFile}d" ${listToRmvFile} fi # Si la liste est a detruire ET a traiter alors on l enleve de la liste a traiter isInLstsToProcess=`grep $list $listsToProcessFile | wc -l ` if [ "x${isInLstsToProcess}" != "x0" ] then lineNbInProcessFile=`grep -n $list $listsToProcessFile | awk -F":" '{print $1}' ` sed -i "${lineNbInProcessFile}d" ${listsToProcessFile} fi done IFS=$old_IFS # retablissement du separateur de champ par defaut rm -f $listToRmvFile_tmp } function removeFilesInLists { setOfFileLstsToRmv=$1 rmvedFiles=$2 linksToEraseFile=$3 realDataToEraseFile=$4 old_IFS=$IFS # sauvegarde du séparateur de champ IFS=$'\n' # nouveau séparateur de champ, le caractère fin de ligne # Suppression des donnees autres que celles de type "debug" et "restart". for lst in $( cat $setOfFileLstsToRmv | grep -v -E '(restart_tar|debug_tar)' ) do opt= lstName=$( basename $lst ) if [ "${lstName}" == "tar_full_simul.list" ] || [ "${lstName}" == "cp_files.list" ] then opt="r" fi sed -e "s/\(.*\)/rm -f${opt} \1/" $lst >> ${rmvedFiles} # for file in $( cat $lst ) # do # echo "rm -f${opt} $file" >> ${rmvedFiles} # if [ "x$deleteFiles" == "x1" ] # then # rm -f${opt} $file # fi # done done # Pour les listes de type "debug" et "restart", les listes ne comportent # que des liens : uniquement leur nom de base, pas leur path # Il faut retrouver leur path, detruire le lien et le fichier qu'il pointe. # Recherche de l'ensemble des fichiers a detruire : les liens + les donnees pointees par les liens for lst in $( cat $setOfFileLstsToRmv | grep -E '(restart_tar|debug_tar)' ) do # Recuperation du repertoire contenant les fichiers de liens dir_containing_links= is_debug_tar_lst=`echo $lst | grep "debug_tar" | wc -l ` if [ "x${is_debug_tar_lst}" != "x0" ] then dir_containing_links="DEBUG" else dir_containing_links="RESTART" fi tar_dir=$( dirname $lst ) simu_dir=$( dirname $tar_dir ) LINK_DIR="${simu_dir}/${dir_containing_links}" if [ ! -d $LINK_DIR ] then echo "Suppression des donnees :" >> $badFailureFile echo "Le repertoire sense contenir des liens symboliques :" >> $badFailureFile echo "${LINK_DIR}" >> $badFailureFile echo "n'existe pas." >> $badFailureFile exit 1 fi # # ls sur le reperoire de lien et insertion du path absolu avant chaque lien. ls -1 ${LINK_DIR} | sed "s;^;${LINK_DIR}/;" >> ${linksToEraseFile} # Recuperation des donnees reelles pointees par les liens. ls -1 -lrt ${LINK_DIR} | awk -F"->" '{print $2}' | sed 's;^ ;;' >> ${realDataToEraseFile} done # Destruction des liens et des donnees pointees par les liens pour les listes # de type "debug" et "restart" # Destroy links # for file in $( cat ${linksToEraseFile} ) # do # echo "rm -f $file" >> ${rmvedFiles} # if [ "x$deleteFiles" == "x1" ] # then # rm -f $file # fi # done sed -e "s/\(.*\)/rm -f \1/" ${linksToEraseFile} >> ${rmvedFiles} # Destroy real datas # for file in $( cat ${realDataToEraseFile} ) # do # echo "rm -f $file" >> ${rmvedFiles} # if [ "x$deleteFiles" == "x1" ] # then # rm -f $file # fi # done sed -e "s/\(.*\)/rm -f \1/" ${realDataToEraseFile} >> ${rmvedFiles} if [ "x$deleteFiles" == "x1" ] then sh ${rmvedFiles} fi IFS=$old_IFS # retablissement du separateur de champ par defaut } export RANDOM=$$ # random seed function gives_random_number { lim=$1 bit=-1 let "bit = RANDOM % $lim" bit=$(( $bit + 1 )) # nb entre 1 et $limit echo $bit } ########## batch directives : begin ########## #MSUB -r pack_ipsl # Nom du job ### mutable directives ### #MSUB -o /ccc/dmfbuf/ipsl_logs/dsm/bacasable/ARNAUD/PSEUDO_DMNFS_PROGRESS/ARNAUD/IPSLCM5/R55C/detailed_pack_output/pack_ipsl_%I.o #MSUB -e /ccc/dmfbuf/ipsl_logs/dsm/bacasable/ARNAUD/PSEUDO_DMNFS_PROGRESS/ARNAUD/IPSLCM5/R55C/detailed_pack_output/pack_ipsl_%I.e #MSUB -n 16 #MSUB -c 2 #MSUB -x #MSUB -T 1500 #MSUB -A tgcc0013 #MSUB -q standard #MSUB -Q test ########## batch directives : end ########## set +x export JOB_DIR=${TMP_MIGR_DATA} export EXE_DIR=${LS_SUBCWD:-${PWD}} source ${EXE_DIR}/DEM_utilities.sh export badFailureFile=${USER_OUTPUT_PROGRESS}/badFailure.txt export numCurrentTry=$( getNumeroOfCurrentTry ) export progressDir="${USER_OUTPUT_PROGRESS}/TRY__${numCurrentTry}" if [ ! -e $progressDir ] then echo "Le repertoire de suivi :" >> $badFailureFile echo "$progressDir" >> $badFailureFile echo "n'existe pas. STOP." >> $badFailureFile exit 1 fi export numPrevInstance=$( getNumeroOfLastInstance $numCurrentTry ) export numNewInstance=$(( $numPrevInstance + 1 )) export inputCmd="${progressDir}/inputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list" export nextInputCmd="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list" export output="${progressDir}/packOutput__try__${numCurrentTry}__instance__${numNewInstance}.log" export reportFile="${progressDir}/report__try__${numCurrentTry}__instance__${numNewInstance}.log" export checkFile="${progressDir}/check__try__${numCurrentTry}__instance__${numNewInstance}.log" export checkFileTmp="${JOB_DIR}/checkTmp__try__${numCurrentTry}__instance__${numNewInstance}.txt" export listsOfFilesToRemove="${progressDir}/listsToRmv__try__${numCurrentTry}__instance__${numNewInstance}.txt" export removedFiles="${progressDir}/removedFiles__try__${numCurrentTry}__instance__${numNewInstance}.txt" # Les 2 fichiers suivants sont crees pour la destruction des liens et des donnees pointes par ces liens # dans le cas de listes de type "debug" ou "restart" export linksToDestroyFile="${progressDir}/linksToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt" export realDataToDestroyFile="${progressDir}/realDataToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt" export noInterruptFile="${progressDir}/noInterrupt__try__${numCurrentTry}__instance__${numNewInstance}.txt" if [ ${numCurrentTry} -le 1 ] && [ ${numNewInstance} -le 1 ] then # C'est le tout premier essai # on construit la liste des taches a effectuer en inventoriant les fichiers *.liste # dans les rep contenus dans le fichier "config_card.liste" > ${inputCmd} for CONFIG in $( awk '{print $1}' ${IGCM_DEM}/config_card.liste ) ; do PATH_SIMU=$( dirname $CONFIG ) # echo "PATH_SIMU=$PATH_SIMU" setOfListFiles=`find $PATH_SIMU -type f -name "*.list" ` for file in $setOfListFiles do echo "./process_list.sh $file" >> ${inputCmd} done done else # if try > 1 && inst == 1 ==> construction liste cmd avec fichiers try - 1, derniere instance # dans ce dernier cas, gerer une eventuelle interruption au try - 1 # if try > 1 && inst > 1 ==> construction liste cmd avec fichiers try, instance precedente if [ ${numNewInstance} -ge 2 ] then nextInputCmd_of_PrevInst="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numPrevInstance}.list" if [ ! -e $nextInputCmd_of_PrevInst ] then echo "Le fichier suivant :" >> $badFailureFile echo "$nextInputCmd_of_PrevInst" >> $badFailureFile echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile exit 1 fi cat $nextInputCmd_of_PrevInst > ${inputCmd} else # numNewInstance == 1 numPrevTry=$(( $numCurrentTry - 1 )) numLastInstInstanceInPrevTry=$( getNumeroOfLastInstance $numPrevTry ) noInterruptFile_prev_try="${progressDir}/noInterrupt__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt" if [ ! -e ${noInterruptFile_prev_try} ] then # il y a eu interruption non prevue au dernier essai, il faut recomposer la liste des cmds avec les resultats # de l'essai precedent, derniere instance prevProgressDir="${USER_OUTPUT_PROGRESS}/TRY__${numPrevTry}" nextInputCmd_of_LastInst="${prevProgressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list" output_of_LastInst="${prevProgressDir}/packOutput__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.log" inputCmd_of_LastInst="${prevProgressDir}/inputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list" if [ ! -e $output_of_LastInst ] || [ ! -e $inputCmd_of_LastInst ] then echo "Les fichiers suivants :" >> $badFailureFile echo "$output_of_LastInst" >> $badFailureFile echo "$inputCmd_of_LastInst" >> $badFailureFile echo "n'existent pas. Il devrait exister. STOP." >> $badFailureFile exit 1 fi update_tasks_list ${nextInputCmd_of_LastInst} ${output_of_LastInst} ${inputCmd_of_LastInst} cat $nextInputCmd_of_LastInst > ${inputCmd} # Il faut aussi detruire les donnees correctement traitement a l'essai precedent, derniere instance. listsOfFilesToRemoveFromPrevTry="${progressDir}/listsToRmvFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt" removedFilesFromPrevTry="${progressDir}/removedFilesFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt" linksToDestroyFileFromPrevTry="${progressDir}/linksToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt" realDataToDestroyFileFromPrevTry="${progressDir}/realDataToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt" searchListsToDestroy $output_of_LastInst $listsOfFilesToRemoveFromPrevTry ${inputCmd} removeFilesInLists $listsOfFilesToRemoveFromPrevTry $removedFilesFromPrevTry $linksToDestroyFileFromPrevTry $realDataToDestroyFileFromPrevTry else nextInputCmd_of_LastInst="${progressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list" if [ ! -e $nextInputCmd_of_LastInst ] then echo "Le fichier suivant :" >> $badFailureFile echo "$nextInputCmd_of_LastInst" >> $badFailureFile echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile exit 1 fi cat $nextInputCmd_of_LastInst > ${inputCmd} fi fi fi # Initialisation du rapport : par defaut, les calculs ont ete interrompus echo "No report. Le computation must have been interrupted." > $reportFile # exit 0 # a virer # a virer ######################################### # if [ ${numNewInstance} -ge 10 ] # then # echo >> $badFailureFile # echo "10eme instance. STOP." >> $badFailureFile # exit 1 # fi ################################################### # startTime=$( getDateMilliSeconds ) # suppr # echo "start time:$startTime" >> $timeHandlingFile # suppr > $timeEndFile # added ccc_mprun ./glost_launch -R $timeLimitBeforeEnd ${inputCmd} 2>${output} if [ "x$?" != "x0" ] then echo "Temps limite atteint pour l'essai : ${numCurrentTry}; instance : ${numNewInstance}" >> $badFailureFile fi ### ccc_mprun ./cmd_launch.exe ${inputCmd} 2>${output} ### ./cmd_launch.exe ${inputCmd} 2>${output} ### ccc_mprun -p standard -n ${BRIDGE_MSUB_NPROC} ./cmd_launch.exe ${inputCmd} 2>myIO/output.log ### mpirun -n 4 ./cmd_launch.exe myIO/inputCmd10.list 2>myIO/output.log # meantime=$( getTimeDiffSeconds $startTime ) # suppr endExecutionTime=$( getDateMilliSeconds ) echo "end time:$endExecutionTime" >> $timeEndFile # echo "meantime ncrcat = $meantime" # exit 0 # a virer # Gestion des reprises : # -------------------- update_report update_tasks_list $nextInputCmd $output $inputCmd # Verifications sur qq listes (dont le traitement semble correct) : # ---------------------------------------------------------------------------------------- if [ "x${doYouWantCheck}" == "xyes" ] then if [ "x${nbListsToCheck}" == "x" ] then echo "nbre de listes a checker absent" >> $checkFile echo "nbre de listes a checker absent" >> $badFailureFile exit 1 fi > $checkFileTmp # ensemble des listes concatenees correctement set_of_good_lists=`cat $output | grep -e '^#executed by process' | awk '{ if ($9==0){print $12} }' | grep "output_ncrcat" ` # envoi des cmds de check dans fichier tmp for lst in $set_of_good_lists do echo "./check_ncrcat_list.sh $lst" >> $checkFileTmp done # nombre de listes concatenees correctement nb_of_good_lists=`cat $checkFileTmp | wc -l ` # le nb de listes a checker ne peut exceder le nb de listes disponibles pour le check if [ $nbListsToCheck -ge $nb_of_good_lists ] then nbListsToCheck=$nb_of_good_lists fi nbLstToCheck_tmp=$nbListsToCheck while [ $nbLstToCheck_tmp -gt 0 ] do random_number=$( gives_random_number $nbLstToCheck_tmp ) # nb aleatoire entre 1 et $nbLstToCheck_tmp checkCmd=`sed -n "${random_number}p" $checkFileTmp ` $checkCmd # on envoie la cmd de check resCmd=$? if [ "x${resCmd}" != "x0" ] then echo "$checkCmd ==> not OK ==> stop everything." >> $checkFile echo "$checkCmd ==> not OK ==> stop everything." >> $badFailureFile exit 1 # a retablir else echo "$checkCmd ==> OK" >> $checkFile fi sed -i "${random_number}d" $checkFileTmp # on retire la cmd qui vient d'etre effectuee du fichier tmp nbLstToCheck_tmp=$(( $nbLstToCheck_tmp - 1 )) done rm $checkFileTmp fi # ----- Fin verif ------------------------------------------------------------------------ # Suppression des données des fichiers de listes correctement traitees ------------------- # Recherche des listes de fichiers de donnees a detruire : # Parmi celles traitees, celles qui ont ete traitees correctement > $listsOfFilesToRemove > $removedFiles > $linksToDestroyFile > $realDataToDestroyFile searchListsToDestroy $output $listsOfFilesToRemove $nextInputCmd removeFilesInLists $listsOfFilesToRemove $removedFiles $linksToDestroyFile $realDataToDestroyFile # ----- Fin suppression de donnees ------------------------------------------------------- # Si le fichier dans variable "noInterruptFile" inexistant, une interruption non prevue a eu lieu echo "no interruption has occured" > ${noInterruptFile} # exit 0 # a virer # Tout s'est bien passe # ---------------------- everythingOK=`cat $nextInputCmd | wc -l ` if [ "x${everythingOK}" == "x0" ] then echo "Tout s'est fini correctement" >> $badFailureFile exit 0 fi # Y a t il progression entre avant traitements et apres ? # ------------------------------------------------------ # Dans la fonction 'check_progress', on a besoin de verifier le code # de retour du traitement des listes : en effet, si les 2 fichiers a comparer # contiennent les memes fichiers de liste, il faut aussi que les codes de # retour soient != 0. file_to_get_lists_retCode=$output resDiff=$( check_progress $inputCmd $nextInputCmd $file_to_get_lists_retCode ) # resDiff == 1 : fichiers differents # resDiff == 0 : fichiers identiques if [ "x${resDiff}" == "x0" ] then echo "Il n'y pas plus de progression" >> $badFailureFile exit 1 fi # On enchaine avec le meme script ccc_msub ${TMP_MIGR_DATA}/launch_and_measureTime.sh