1 | #!/bin/bash |
---|
2 | |
---|
3 | # |
---|
4 | # Fonctions utiles pour les scripts de Pack IPSL |
---|
5 | # |
---|
6 | |
---|
7 | function DEM_read_state { |
---|
8 | # Lire l'état du pack pour une simulation |
---|
9 | local L_CONFIG_FILE=${1} |
---|
10 | local L_CONFIG_CARD=${2} |
---|
11 | |
---|
12 | local L_OLD_STATE=$( grep ${L_CONFIG_CARD} ${L_CONFIG_FILE} | awk '{print $2}' ) |
---|
13 | |
---|
14 | if [ ${?} -eq 0 ] |
---|
15 | then |
---|
16 | echo ${L_OLD_STATE} |
---|
17 | return 0 |
---|
18 | else |
---|
19 | return 1 |
---|
20 | fi |
---|
21 | return 0 |
---|
22 | } |
---|
23 | |
---|
24 | function DEM_write_state { |
---|
25 | # Mettre à jour l'état du pack pour une simulation |
---|
26 | local L_CONFIG_FILE=${1} |
---|
27 | local L_CONFIG_CARD=${2} |
---|
28 | local L_NEW_STATE=${3} |
---|
29 | |
---|
30 | local L_MAX_TRY=10 L_TRY=0 L_CHECK L_PP |
---|
31 | |
---|
32 | # On essaye ${L_MAX_TRY} fois de mettre à jour le fichier |
---|
33 | while [ ${L_TRY} -le ${L_MAX_TRY} ] |
---|
34 | do |
---|
35 | if [[ ! -f ${L_CONFIG_FILE}.lock ]] |
---|
36 | then |
---|
37 | echo ${$} >> ${L_CONFIG_FILE}.lock ; chmod -w ${L_CONFIG_FILE}.lock |
---|
38 | L_CHECK=$( wc -l ${L_CONFIG_FILE}.lock | awk '{print $1}' ) |
---|
39 | if [[ ${L_CHECK} -gt 1 ]] |
---|
40 | then |
---|
41 | DEM_log -0 "Erreur. Plusieurs processus on pose un verrou sur ${L_CONFIG_FILE}" |
---|
42 | for L_PP in $( awk '{print $1}' ${L_CONFIG_FILE}.lock ) |
---|
43 | do |
---|
44 | DEM_log -0 "Erreur. Process : ${L_PP}" |
---|
45 | done |
---|
46 | return 1 |
---|
47 | fi |
---|
48 | |
---|
49 | local L_OLD_LINE=$( grep ${L_CONFIG_CARD} ${L_CONFIG_FILE} ) |
---|
50 | [[ ${?} -eq 0 ]] || ( return 1 ; ) |
---|
51 | if [[ ${L_OLD_LINE} = "" ]] |
---|
52 | then |
---|
53 | DEM_log -0 "Erreur. Dans le fichier : ${L_CONFIG_FILE}, Experience ${L_CONFIG_CARD} non trouvee" |
---|
54 | return 1 |
---|
55 | fi |
---|
56 | local L_OLD_STATE=$( echo ${L_OLD_LINE} | awk '{print $2}' ) |
---|
57 | [[ ${?} -eq 0 ]] || ( return 1 ; ) |
---|
58 | |
---|
59 | L_NEW_LINE="${L_CONFIG_CARD} ${L_NEW_STATE}" |
---|
60 | |
---|
61 | sed -i "s%${L_OLD_LINE}%${L_NEW_LINE}%" ${L_CONFIG_FILE} |
---|
62 | rm -f ${L_CONFIG_FILE}.lock |
---|
63 | break |
---|
64 | else |
---|
65 | (( L_TRY = L_TRY + 1 )) |
---|
66 | DEM_log -3 "Fichier ${L_CONFIG_FILE} en cours de modif par un autre processus. Essai ${L_TRY}" |
---|
67 | sleep 1 |
---|
68 | fi |
---|
69 | |
---|
70 | done |
---|
71 | |
---|
72 | if [[ ${L_TRY} -ge ${L_MAX_TRY} ]] |
---|
73 | then |
---|
74 | DEM_log -0 "Erreur. Verrou sur le fichier : ${L_CONFIG_FILE}" |
---|
75 | return 1 |
---|
76 | fi |
---|
77 | |
---|
78 | return 0 |
---|
79 | } |
---|
80 | |
---|
81 | function DEM_min { |
---|
82 | # Calcul du minimum d'un nombre quelconque d'entiers |
---|
83 | local l_min=${1} l_xx |
---|
84 | |
---|
85 | for l_xx in ${*:2:${#}} |
---|
86 | do |
---|
87 | [[ ${l_xx} -lt ${l_min} ]] && l_min=${l_xx} |
---|
88 | done |
---|
89 | echo ${l_min} |
---|
90 | } |
---|
91 | |
---|
92 | function DEM_max { |
---|
93 | # Calcul du maximum d'un nombre quelconque d'entiers |
---|
94 | local l_max=${1} l_xx |
---|
95 | |
---|
96 | for l_xx in ${*:2:${#}} |
---|
97 | do |
---|
98 | [[ ${l_xx} -gt ${l_max} ]] && l_max=${l_xx} |
---|
99 | done |
---|
100 | echo ${l_max} |
---|
101 | } |
---|
102 | |
---|
103 | function DEM_log { |
---|
104 | # Affichage d'un message sur stdout et dans un fichier de log |
---|
105 | # DEM_log [-0|-1|-2|-3] Message |
---|
106 | # |
---|
107 | local MESSAGE P_LINE L_NAME |
---|
108 | LOG_LEV=${LOG_LEV:-3} |
---|
109 | local OPTARG OPTIND L_LOG=1 |
---|
110 | local L_DEM_LOG=${DEM_LOG:-dem_log.${$}} |
---|
111 | |
---|
112 | while getopts 0123 L_NAME |
---|
113 | do |
---|
114 | case ${L_NAME} in |
---|
115 | ( 0 ) L_LOG=1 ;; |
---|
116 | ( 1 ) L_LOG=1 ;; |
---|
117 | ( 2 ) L_LOG=2 ;; |
---|
118 | ( 3 ) L_LOG=3 ;; |
---|
119 | esac |
---|
120 | done |
---|
121 | shift $(( ${OPTIND} - 1 )) |
---|
122 | |
---|
123 | if [[ ${L_LOG} -le ${LOG_LEV} ]] |
---|
124 | then |
---|
125 | MESSAGE=${*} |
---|
126 | P_LINE="$(date) - ${MESSAGE}" |
---|
127 | |
---|
128 | echo ${P_LINE} |
---|
129 | echo ${P_LINE} >> ${L_DEM_LOG} |
---|
130 | fi |
---|
131 | return |
---|
132 | } |
---|
133 | |
---|
134 | # gpdebug : fonctions de gestion des erreurs ######################################################## |
---|
135 | function DEM_errorSend { |
---|
136 | # Envoi d'un msg d'erreur au programme principal. |
---|
137 | # Suppression des processus du programme principal au fils emetteur de l'erreur |
---|
138 | |
---|
139 | echo "########## DEM_errorSend : Error detected ==> Sending an error..." |
---|
140 | |
---|
141 | msgToSend=${1} |
---|
142 | listPIDtoKill=${2} |
---|
143 | if [ "x${listPIDtoKill}" == "x" ] |
---|
144 | then |
---|
145 | listPIDtoKill=${listPID} |
---|
146 | fi |
---|
147 | # -------------------------------- |
---|
148 | # Verif du format de listPIDtoKill |
---|
149 | # -------------------------------- |
---|
150 | listPIDformat='^[[:digit:]]*\([[:blank:]][[:digit:]]*\)*$' |
---|
151 | isListPIDformatOK=`echo ${listPIDtoKill} | grep -e ${listPIDformat} | wc -l ` |
---|
152 | if [ "x$isListPIDformatOK" == "x0" ] |
---|
153 | then |
---|
154 | echo " Attention : le format de la liste de PID est incorrecte :" |
---|
155 | echo " $listPIDtoKill" |
---|
156 | kill -TERM ${listPID} |
---|
157 | fi |
---|
158 | |
---|
159 | |
---|
160 | # ----------------------------------- |
---|
161 | # Verif du Format du ${msgToSend} |
---|
162 | # ----------------------------------- |
---|
163 | errorFormat='^[^:]*\.sh:[[:digit:]]*:.*$' |
---|
164 | isErrorFormatOK=`echo ${msgToSend} | grep -e ${errorFormat} | wc -l ` |
---|
165 | if [ "x$isErrorFormatOK" == "x0" ] |
---|
166 | then |
---|
167 | echo " Attention : le format du message d'erreur est incorrect :" |
---|
168 | echo " $msgToSend" |
---|
169 | fi |
---|
170 | |
---|
171 | # Envoi du msg dans le fichier d'erreur |
---|
172 | # ------------------------------------- |
---|
173 | # test sur la var contenant le nom du fichier d'erreur |
---|
174 | if [ "x${errorMsgFile}" != "x${PWD}/errorMsg.txt" ] |
---|
175 | then |
---|
176 | echo " Le fichier d'erreur a un nom incorrect" |
---|
177 | fi |
---|
178 | |
---|
179 | echo $msgToSend > $errorMsgFile |
---|
180 | |
---|
181 | echo "killing ${listPIDtoKill}" |
---|
182 | kill -TERM ${listPIDtoKill} |
---|
183 | |
---|
184 | exit -1 # utile : sinon le script qui appelle cette fonction continue un peu l'exec --> pas propre |
---|
185 | } |
---|
186 | |
---|
187 | function DEM_errorReceive { |
---|
188 | # Récupération et affichage du msg d'erreur emis par un processus fils |
---|
189 | |
---|
190 | # Lecture du msg dans le fichier d'erreur |
---|
191 | # --------------------------------------- |
---|
192 | # test sur la var contenant le nom du fichier d'erreur |
---|
193 | if [ "x${errorMsgFile}" != "x${PWD}/errorMsg.txt" ] |
---|
194 | then |
---|
195 | echo " Le fichier d'erreur a un nom incorrect" |
---|
196 | exit -1 |
---|
197 | fi |
---|
198 | |
---|
199 | # Lecture |
---|
200 | errorReceived=`cat $errorMsgFile ` |
---|
201 | |
---|
202 | # ----------------------------------- |
---|
203 | # Verif du Format du ${errorReceived} |
---|
204 | # ----------------------------------- |
---|
205 | errorFormat='^[^:]*\.sh:[[:digit:]]*:.*$' |
---|
206 | isErrorFormatOK=`echo ${errorReceived} | grep -e ${errorFormat} | wc -l ` |
---|
207 | if [ "x$isErrorFormatOK" == "x0" ] |
---|
208 | then |
---|
209 | echo " Attention : le format du message d'erreur est incorrect :" |
---|
210 | echo " $errorReceived" |
---|
211 | exit -1 |
---|
212 | fi |
---|
213 | |
---|
214 | echo "########## DEM_errorReceive : $SCRIPT_NAME received an error..." |
---|
215 | echo $errorReceived |
---|
216 | |
---|
217 | # echo "Current PID:$$" |
---|
218 | # echo "FatherPID:$FatherPID" |
---|
219 | # On fait un bilan de la progression seulement si c'est une erreur bloquante : lorsque le proc pere est tue. |
---|
220 | if [ "x${FatherPID}" == "x$$" ] |
---|
221 | then |
---|
222 | ./showListsProgress.sh $FileParam |
---|
223 | fi |
---|
224 | |
---|
225 | exit -1 |
---|
226 | } |
---|
227 | |
---|
228 | # Verification de la version de nco chargee |
---|
229 | function check_nco_version |
---|
230 | { |
---|
231 | # nom du présent prog (pour gestion des erreurs) |
---|
232 | PROGNAME="DEM_utilities.sh" ######### |
---|
233 | . /etc/profile |
---|
234 | module list >& myModuleList.txt |
---|
235 | |
---|
236 | if [ "x$?" != "x0" ] |
---|
237 | then |
---|
238 | # echo "La commande module list a rencontre un pb !" |
---|
239 | DEM_errorSend "${PROGNAME}:${LINENO}:La commande module list a rencontre un pb !" |
---|
240 | fi |
---|
241 | |
---|
242 | if [ ! -e myModuleList.txt ] |
---|
243 | then |
---|
244 | # echo "Le fichier 'myModuleList.txt' n existe pas" |
---|
245 | DEM_errorSend "${PROGNAME}:${LINENO}:Le fichier 'myModuleList.txt' n'existe pas." |
---|
246 | fi |
---|
247 | |
---|
248 | # Presence de la chaine "n) nco/" ou n est un nombre |
---|
249 | ncoLines=` grep -e '[[:digit:]]*) nco/' myModuleList.txt ` |
---|
250 | # ncoLines=` grep -e '[[:digit:]]*) nco/' moduleList.txt ` |
---|
251 | # echo "ncoLines=${ncoLines}|" |
---|
252 | # echo "----------------------------------------" |
---|
253 | |
---|
254 | # Plus besoin du myModuleList.txt |
---|
255 | rm -f myModuleList.txt |
---|
256 | |
---|
257 | # La chaine "nco" est remplacee par le caractere "#" |
---|
258 | temp1=`echo $ncoLines | sed 's;nco;#;g' ` |
---|
259 | # echo "$temp1" |
---|
260 | # echo "----------------------------------------" |
---|
261 | |
---|
262 | # On supprime tout ce qui n'est pas "n) #/..." avec n un nombre et "..." une chaine sans blanc |
---|
263 | temp2=`echo $temp1 | sed 's;[[:blank:]]*[[:digit:]]*) [^#][^[:blank:]]*;;g' ` |
---|
264 | # echo "$temp2" |
---|
265 | # echo "----------------------------------------" |
---|
266 | |
---|
267 | |
---|
268 | # Recuperation du numero de version du nco au format x.y.z |
---|
269 | # C'est une liste de num de version (a priori ici, il pourrait y en avoir plusieurs, |
---|
270 | # mais dans les faits, les nco s'excluent les uns les autres) |
---|
271 | temp3=`echo $temp2 | sed 's;[[:blank:]]*[[:digit:]]*) #/;|;g' ` |
---|
272 | temp3=`echo $temp3 | sed 's;^|;;g' ` |
---|
273 | temp3=`echo $temp3 | sed 's;|; ;g' ` |
---|
274 | # echo "$temp3" |
---|
275 | # echo "----------------------------------------" |
---|
276 | |
---|
277 | # comptage du nombre de nco |
---|
278 | versionNCO= |
---|
279 | count=0 |
---|
280 | for ver in $temp3 |
---|
281 | do |
---|
282 | # echo "ver=$ver" |
---|
283 | versionNCO=$ver |
---|
284 | count=$(( $count + 1 )) |
---|
285 | done |
---|
286 | # echo "count=$count" |
---|
287 | |
---|
288 | # si aucun nco n'est charge, on sort. |
---|
289 | if [ $count -eq 0 ] |
---|
290 | then |
---|
291 | # echo "nco pas charge" |
---|
292 | DEM_errorSend "${PROGNAME}:${LINENO}:Aucun nco n'est charge" |
---|
293 | fi |
---|
294 | |
---|
295 | # si plus d'un nco sont charges, on sort (n'arrive jamais en pratique). |
---|
296 | if [ $count -gt 1 ] |
---|
297 | then |
---|
298 | DEM_errorSend "${PROGNAME}:${LINENO}:Au moins 2 versions de nco sont chargees" |
---|
299 | fi |
---|
300 | |
---|
301 | # Si un seul nco est charge, on supprime les "." de son numero de version (x.y.z ==> xyz) |
---|
302 | verNCOnumber=`echo $versionNCO | sed 's;[^[:digit:]];;g' ` |
---|
303 | # echo "versionNCO=$versionNCO" |
---|
304 | |
---|
305 | # On verifie que xyz est un nombre a 3 chiffres |
---|
306 | if ! [[ "$verNCOnumber" =~ ^[0-9]\{3\}$ ]] |
---|
307 | then |
---|
308 | # echo "verNCOnumber is not a number" |
---|
309 | DEM_errorSend "${PROGNAME}:${LINENO}:La variable verNCOnumber n'est pas un nombre --> $verNCOnumber" |
---|
310 | fi |
---|
311 | |
---|
312 | |
---|
313 | # On verifie que le num de version est >= 4.1.0 |
---|
314 | if [ $verNCOnumber -lt 410 ] |
---|
315 | then |
---|
316 | # echo "version < 4.1.0 . STOP." |
---|
317 | DEM_errorSend "${PROGNAME}:${LINENO}:La version de nco < 4.1.0 ==> $versionNCO" |
---|
318 | fi |
---|
319 | |
---|
320 | echo "La version de nco chargee est : $versionNCO" |
---|
321 | |
---|
322 | } |
---|
323 | |
---|
324 | function prepareMonitoringDir |
---|
325 | { |
---|
326 | # nom du présent prog (pour gestion des erreurs) |
---|
327 | PROGNAME="DEM_utilities.sh" ######### |
---|
328 | |
---|
329 | MonitoringDirDefined=`echo $MonitoringDir | grep "SuiviListes" | wc -l ` |
---|
330 | if [ "x${workFlowDirDefined}" == "x0" ] |
---|
331 | then |
---|
332 | DEM_errorSend "${PROGNAME}:${LINENO}:Le repertoire de suivi est mal defini." |
---|
333 | fi |
---|
334 | |
---|
335 | # Si l'option de forcage de toute les etapes est activee, |
---|
336 | # on vide le fichier |
---|
337 | if [ "x${execEveryStep}" == "x1" ] |
---|
338 | then |
---|
339 | echo "${MonitoringDir}:destruction..." |
---|
340 | rm -rf ${MonitoringDir} |
---|
341 | fi |
---|
342 | |
---|
343 | # Si le rep de suivi n'existe pas, on le créé. |
---|
344 | if [ ! -d ${MonitoringDir} ] |
---|
345 | then |
---|
346 | mkdir ${MonitoringDir} |
---|
347 | fi |
---|
348 | |
---|
349 | } |
---|
350 | |
---|
351 | function generalMonitoring |
---|
352 | { |
---|
353 | # Si l'etape courante a ete executee (correctement), on sort du script appelant cette fonction |
---|
354 | |
---|
355 | # nom du présent prog (pour gestion des erreurs) |
---|
356 | PROGNAME="DEM_utilities.sh" ######### |
---|
357 | |
---|
358 | currentStep=${1} |
---|
359 | |
---|
360 | stepMsg=`echo $currentStep | grep -e '^.*\.sh-->OK$' | wc -l ` |
---|
361 | if [ "x{stepMsg}" == "x0" ] |
---|
362 | then |
---|
363 | DEM_errorSend "${PROGNAME}:${LINENO}:Le nom de l'etape courante n'est pas au bon format !" |
---|
364 | fi |
---|
365 | |
---|
366 | currentStepScriptName=`echo $currentStep | sed 's;\.sh-->OK;;' ` |
---|
367 | |
---|
368 | # si le fichier de suivi general n'existe pas, il n'y a pas eu de passage de script de liste avant. |
---|
369 | # ==> on sort normalement |
---|
370 | if [ ! -e ${generalMonitorFile} ] |
---|
371 | then |
---|
372 | return 0 |
---|
373 | fi |
---|
374 | |
---|
375 | currentStepPassed=`grep ${currentStep} ${generalMonitorFile} | wc -l ` |
---|
376 | |
---|
377 | if [ "x${currentStepPassed}" != "x0" ] |
---|
378 | then |
---|
379 | echo "${currentStepScriptName} a deja ete passee ..." |
---|
380 | exit 0 |
---|
381 | fi |
---|
382 | |
---|
383 | } |
---|
384 | |
---|
385 | function createListingMonitoring_Check |
---|
386 | { |
---|
387 | |
---|
388 | # La presence de createListingOK.txt dans le sous rep (associe a un rep de param_AC.txt) du rep de suivi |
---|
389 | # indique que le bon deroulement de l'action de create_listing.sh sur le repertoire de param_AC.txt |
---|
390 | DIR=$(basename ${1}) |
---|
391 | MonitSubDir=${MonitoringDir}/${DIR} |
---|
392 | |
---|
393 | createListingOK=${MonitSubDir}/createListingOK.txt |
---|
394 | |
---|
395 | if [ -e $createListingOK ] |
---|
396 | then |
---|
397 | echo "create_listing a deja ete passe pour ${DIR}..." |
---|
398 | exit 0 |
---|
399 | fi |
---|
400 | |
---|
401 | } |
---|
402 | |
---|
403 | function createListingMonitoring_OK |
---|
404 | { |
---|
405 | |
---|
406 | # A partir du nom du rep courant (contenant des res de simulation), creation d'un sous rep de suivi |
---|
407 | DIR=$(basename ${1}) |
---|
408 | MonitSubDir=${MonitoringDir}/${DIR} |
---|
409 | mkdir $MonitSubDir |
---|
410 | |
---|
411 | # dans ce sous rep de suivi, creation d'un fichier dont la presence indique le bon deroulement |
---|
412 | # de l'action de create_listing.sh sur le repertoire en argument (celui contenant des simus) |
---|
413 | createListingOK=${MonitSubDir}/createListingOK.txt |
---|
414 | touch $createListingOK |
---|
415 | |
---|
416 | } |
---|
417 | |
---|
418 | function simuMonitoring_check |
---|
419 | { |
---|
420 | # nom du présent prog (pour gestion des erreurs) |
---|
421 | PROGNAME="DEM_utilities.sh" ######### |
---|
422 | |
---|
423 | currentStep=${1} |
---|
424 | config=${2} |
---|
425 | # echo "######### simuMonitoring_check --> config:$config" |
---|
426 | # former le nom du fichier de suivi de la simu a partir de "config" |
---|
427 | getSimuMonitFileName $config |
---|
428 | |
---|
429 | # si le fichier de suivi de simu n'existe pas, il n'y a pas eu de passage de script de liste avant. |
---|
430 | # ==> on sort normalement |
---|
431 | if [ ! -e ${simuMonitoringFile} ] |
---|
432 | then |
---|
433 | return 0 |
---|
434 | fi |
---|
435 | |
---|
436 | stepMsg=`echo $currentStep | grep -e '^.*\.sh-->OK$' | wc -l ` |
---|
437 | if [ "x{stepMsg}" == "x0" ] |
---|
438 | then |
---|
439 | DEM_errorSend "${PROGNAME}:${LINENO}:Le nom de l'etape courante n'est pas au bon format !" |
---|
440 | fi |
---|
441 | |
---|
442 | currentStepScriptName=`echo $currentStep | sed 's;\.sh-->OK;;' ` |
---|
443 | |
---|
444 | currentStepPassed=`grep ${currentStep} ${simuMonitoringFile} | wc -l ` |
---|
445 | |
---|
446 | # echo "######### simuMonitoring_check --> currentStep:$currentStep" |
---|
447 | # echo "######### simuMonitoring_check --> simuMonitoringFile:$simuMonitoringFile" |
---|
448 | # echo "######### simuMonitoring_check --> currentStepPassed:$currentStepPassed" |
---|
449 | if [ "x${currentStepPassed}" != "x0" ] |
---|
450 | then |
---|
451 | echo "${currentStepScriptName} a deja ete passee ..." |
---|
452 | # echo "-----------------------------------------------------------------------------" |
---|
453 | exit 0 |
---|
454 | fi |
---|
455 | |
---|
456 | } |
---|
457 | |
---|
458 | function simuMonitoring_OK |
---|
459 | { |
---|
460 | currentStep=${1} |
---|
461 | config=${2} |
---|
462 | # echo "######### simuMonitoring_OK --> config:$config" |
---|
463 | # former le nom du fichier de suivi de la simu a partir de "config" |
---|
464 | getSimuMonitFileName $config |
---|
465 | |
---|
466 | echo $currentStep >> $simuMonitoringFile |
---|
467 | } |
---|
468 | |
---|
469 | function getSimuMonitFileName |
---|
470 | { |
---|
471 | # nom du présent prog (pour gestion des erreurs) |
---|
472 | PROGNAME="DEM_utilities.sh" ######### |
---|
473 | |
---|
474 | config=${1} |
---|
475 | # echo "######### getSimuMonitFileName --> config:$config" |
---|
476 | configBaseName=$(basename ${config}) |
---|
477 | |
---|
478 | # On cherche dans quel sous rep du rep de suivi on va chercher le fichier de suivi de la simu |
---|
479 | listMonitSubDir=`ls -l ${MonitoringDir} | grep -e '^d' | awk '{print $NF}' ` |
---|
480 | |
---|
481 | # echo "######### getSimuMonitFileName --> listMonitSubDir:$listMonitSubDir" |
---|
482 | |
---|
483 | searchedDir= |
---|
484 | for dir in $listMonitSubDir |
---|
485 | do |
---|
486 | found=`echo $config | grep "/${dir}/" | wc -l ` |
---|
487 | if [ "x${found}" != "x0" ] |
---|
488 | then |
---|
489 | searchedDir=$dir |
---|
490 | break |
---|
491 | fi |
---|
492 | done |
---|
493 | |
---|
494 | if [ "x$searchedDir" == "x" ] |
---|
495 | then |
---|
496 | DEM_errorSend "${PROGNAME}:${LINENO}:Sous rep de suivi non trouve !" |
---|
497 | fi |
---|
498 | |
---|
499 | # On forme le nom du fichier de suivi pour la simu courante |
---|
500 | # ... on debarasse config du fichier de config |
---|
501 | repConfig=$(dirname $config) |
---|
502 | # ... on supprime du path tout ce qui est devant le nom du sous rep |
---|
503 | simu=`echo $repConfig | sed "s;^.*/$searchedDir;$searchedDir;" ` |
---|
504 | # ... remplacement des "/" par des "_#_" (les "/" ne sont pas acceptes dans les noms de fichiers) |
---|
505 | simuMonitoringFile=`echo $simu | sed 's;/;_#_;g' ` |
---|
506 | # ... On rajoute un ".txt" a la fin du nom de fichier |
---|
507 | simuMonitoringFile="${simuMonitoringFile}.txt" |
---|
508 | |
---|
509 | simuMonitoringFile="${MonitoringDir}/${searchedDir}/${simuMonitoringFile}" |
---|
510 | } |
---|
511 | |
---|
512 | # gpdebug : fin ##################################################################################### |
---|
513 | |
---|