1 #@ MODIF N_JDC Noyau DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
2 # -*- coding: iso-8859-1 -*-
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
9 # (AT YOUR OPTION) ANY LATER VERSION.
11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
18 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
21 # ======================================================================
25 Ce module contient la classe JDC qui sert à interpréter un jeu de commandes
29 import os,string,traceback
30 import types,sys,linecache
35 from N_Exception import AsException
36 from N_ASSD import ASSD
38 class JDC(N_OBJECT.OBJECT):
40 Cette classe interprete un jeu de commandes fourni sous
41 la forme d'une chaine de caractères
45 Attributs d'instance :
57 from N_utils import SEP
59 def __init__(self,definition=None,procedure=None,cata=None,
60 cata_ord_dico=None,parent=None,
61 nom='SansNom',appli=None,context_ini=None,**args):
62 self.procedure=procedure
63 self.definition = definition
65 if type(self.cata) != types.TupleType and cata != None:
66 self.cata=(self.cata,)
67 self.cata_ordonne_dico=cata_ord_dico
71 self.context_ini=context_ini
72 # On conserve les arguments supplémentaires. Il est possible de passer
73 # des informations globales au JDC par ce moyen. Il pourrait etre plus
74 # sur de mettre en place le mecanisme des mots-cles pour verifier la
75 # validité des valeurs passées.
77 # On initialise avec les parametres de la definition puis on
78 # update avec ceux du JDC
79 self.args=self.definition.args
80 self.args.update(args)
85 self.regles=definition.regles
86 self.code = definition.code
91 # Creation de l objet compte rendu pour collecte des erreurs
93 self.cr = self.CR(debut = "CR phase d'initialisation",
94 fin = "fin CR phase d'initialisation")
96 # Liste pour stocker tous les concepts produits dans le JDC
98 # Dictionnaire pour stocker tous les concepts du JDC (acces rapide par le nom)
102 self.current_context={}
103 self.condition_context={}
104 self.index_etape_courante=0
105 self.UserError="UserError"
110 Cette methode compile la chaine procedure
111 Si des erreurs se produisent, elles sont consignées dans le
115 if self.appli != None :
116 self.appli.affiche_infos('Compilation du fichier de commandes en cours ...')
117 self.proc_compile=compile(self.procedure,self.nom,'exec')
118 except SyntaxError,e:
119 if CONTEXT.debug : traceback.print_exc()
120 l=traceback.format_exception_only(SyntaxError,e)
121 self.cr.exception("Compilation impossible : "+string.join(l))
124 def exec_compile(self):
126 Cette méthode execute le jeu de commandes compilé dans le contexte
127 self.g_context de l'objet JDC
129 CONTEXT.set_current_step(self)
130 # Le module nommage utilise le module linecache pour accéder
131 # au source des commandes du jeu de commandes.
132 # Dans le cas d'un fichier, on accède au contenu de ce fichier
133 # Dans le cas d'une chaine de caractères il faut accéder
134 # aux commandes qui sont dans la chaine
136 linecache.cache[self.nom]=0,0,string.split(self.procedure,'\n'),self.nom
138 exec self.exec_init in self.g_context
139 for obj_cata in self.cata:
140 if type(obj_cata) == types.ModuleType :
141 init2 = "from "+obj_cata.__name__+" import *"
142 exec init2 in self.g_context
144 # Initialisation du contexte global pour l'évaluation des conditions de BLOC
145 # On utilise une copie de l'initialisation du contexte du jdc
146 self.condition_context=self.g_context.copy()
148 # Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
149 # le contexte initial (--> permet d'évaluer un JDC en récupérant un contexte
150 # d'un autre par exemple)
151 if self.context_ini :
152 self.g_context.update(self.context_ini)
153 # Update du dictionnaire des concepts
154 for sdnom,sd in self.context_ini.items():
155 if isinstance(sd,ASSD):self.sds_dict[sdnom]=sd
157 if self.appli != None :
158 self.appli.affiche_infos('Interprétation du fichier de commandes en cours ...')
159 # On sauve le contexte pour garder la memoire des constantes
160 # En mode edition (EFICAS) ou lors des verifications le contexte
162 # mais les constantes sont perdues
163 self.const_context=self.g_context
164 exec self.proc_compile in self.g_context
166 CONTEXT.unset_current_step()
167 if self.appli != None : self.appli.affiche_infos('')
170 # Exception utilise pour interrompre un jeu
171 # de commandes avant la fin
172 # Fonctionnement normal, ne doit pas etre considere comme une erreur
173 CONTEXT.unset_current_step()
174 self.affiche_fin_exec()
175 self.traiter_fin_exec('commande')
177 except AsException,e:
178 # une erreur a ete identifiee
180 traceback.print_exc()
181 self.cr.exception(str(e))
182 CONTEXT.unset_current_step()
185 etype, value, tb = sys.exc_info()
186 l= traceback.extract_tb(tb)
187 s= traceback.format_exception_only("Erreur de nom",e)[0][:-1]
188 message = "erreur de syntaxe, %s ligne %d" % (s,l[-1][1])
190 traceback.print_exc()
191 self.cr.exception(message)
192 CONTEXT.unset_current_step()
194 except self.UserError,exc_val:
195 self.traiter_user_exception(exc_val)
196 CONTEXT.unset_current_step()
197 self.traiter_fin_exec('commande')
201 # sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
202 # (tuple de 3 éléments)
203 if CONTEXT.debug : traceback.print_exc()
205 exc_typ,exc_val,exc_fr=sys.exc_info()
206 l=traceback.format_exception(exc_typ,exc_val,exc_fr)
207 self.cr.exception("erreur non prevue et non traitee prevenir la maintenance "+
208 self.nom+'\n'+ string.join(l))
209 del exc_typ,exc_val,exc_fr
210 CONTEXT.unset_current_step()
212 def affiche_fin_exec(self):
214 Cette methode realise l'affichage final des statistiques de temps
215 apres l'execution de toutes
216 les commandes en mode commande par commande ou par lot
217 Elle doit etre surchargee pour en introduire un
221 def traiter_fin_exec(self,mode,etape=None):
223 Cette methode realise un traitement final apres l'execution de toutes
224 les commandes en mode commande par commande ou par lot
225 Par defaut il n'y a pas de traitement. Elle doit etre surchargee
226 pour en introduire un
228 print "FIN D'EXECUTION",mode,etape
230 def traiter_user_exception(self,exc_val):
231 """Cette methode realise un traitement sur les exceptions utilisateur
232 Par defaut il n'y a pas de traitement. La méthode doit etre
233 surchargée pour en introduire un.
237 def register(self,etape):
239 Cette méthode ajoute etape dans la liste des etapes : self.etapes
240 et retourne un numéro d'enregistrement
242 self.etapes.append(etape)
243 return self.g_register(etape)
245 def o_register(self,sd):
247 Retourne un identificateur pour concept
250 nom=sd.idracine + self.SEP + `self.nsd`
253 def g_register(self,etape):
255 Retourne un identificateur pour etape
257 self.nstep=self.nstep+1
258 idetape=etape.idracine + self.SEP + `self.nstep`
261 def create_sdprod(self,etape,nomsd):
263 Intention : Cette methode doit fabriquer le concept produit retourne
264 par l'etape etape et le nommer.
265 Elle est appelée à l'initiative de l'etape
266 pendant le processus de construction de cette etape :
267 methode __call__ de la classe CMD (OPER ou MACRO)
268 Ce travail est réalisé par le contexte supérieur
269 (etape.parent) car dans certains cas, le concept ne doit
270 pas etre fabriqué mais l'etape doit simplement utiliser
271 un concept préexistant.
272 Cas 1 : etape.reuse != None : le concept est réutilisé
273 Cas 2 : l'étape appartient à une macro qui a déclaré un
274 concept de sortie qui doit etre produit par cette
276 Dans le cas du JDC, le deuxième cas ne peut pas se produire.
278 sd= etape.get_sd_prod()
279 if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None) :
280 # ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
281 # d un concept. Commande non reentrante ou reuse absent.
282 self.NommerSdprod(sd,nomsd)
285 def NommerSdprod(self,sd,sdnom,restrict='non'):
287 Nomme la SD apres avoir verifie que le nommage est possible : nom
289 Si le nom est deja utilise, leve une exception
290 Met le concept créé dans le concept global g_context
292 if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
294 o=self.sds_dict.get(sdnom,None)
295 if isinstance(o,ASSD):
296 raise AsException("Nom de concept deja defini : %s" % sdnom)
298 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
299 # Ajoute a la creation (appel de reg_sd).
300 self.sds_dict[sdnom]=sd
303 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
304 if restrict == 'non':
305 self.g_context[sdnom]=sd
309 Methode appelee dans l __init__ d un ASSD lors de sa creation
313 return self.o_register(sd)
315 def delete_concept_after_etape(self,etape,sd):
317 Met à jour les étapes du JDC qui sont après etape suite à
318 la disparition du concept sd
320 # Cette methode est définie dans le noyau mais ne sert que pendant
321 # la phase de creation des etapes et des concepts. Il n'y a aucun
322 # traitement particulier à réaliser.
323 # Dans d'autres conditions, il faut surcharger cette méthode
327 N_OBJECT.OBJECT.supprime(self)
328 for etape in self.etapes:
331 def get_file(self,unite=None,fic_origine=''):
333 Retourne le nom du fichier correspondant à un numero d'unité
334 logique (entier) ainsi que le source contenu dans le fichier
337 # Si le JDC est relié à une application maitre, on délègue la recherche
338 file,text= self.appli.get_file(unite,fic_origine)
342 if os.path.exists("fort."+str(unite)):
343 file= "fort."+str(unite)
345 raise AsException("Impossible de trouver le fichier correspondant"
346 " a l unite %s" % unite)
347 if not os.path.exists(file):
348 raise AsException("%s n'est pas un fichier existant" % unite)
352 if file == None : return None,None
353 text=string.replace(text,'\r\n','\n')
354 linecache.cache[file]=0,0,string.split(text,'\n'),file
357 def set_par_lot(self,par_lot):
359 Met le mode de traitement a PAR LOT
360 ou a COMMANDE par COMMANDE
361 en fonction de la valeur du mot cle PAR_LOT et
362 du contexte : application maitre ou pas
364 if self.appli == None:
365 # Pas d application maitre
368 # Avec application maitre
371 def accept(self,visitor):
373 Cette methode permet de parcourir l'arborescence des objets
374 en utilisant le pattern VISITEUR
376 visitor.visitJDC(self)
380 Cette methode a pour fonction d'ouvrir un interpreteur
381 pour que l'utilisateur entre des commandes interactivement
383 CONTEXT.set_current_step(self)
385 # Le module nommage utilise le module linecache pour accéder
386 # au source des commandes du jeu de commandes.
387 # Dans le cas d'un fichier, on accède au contenu de ce fichier
388 # Dans le cas de la console interactive, il faut pouvoir accéder
389 # aux commandes qui sont dans le buffer de la console
390 import linecache,code
391 console= code.InteractiveConsole(self.g_context,filename="<console>")
392 linecache.cache["<console>"]=0,0,console.buffer,"<console>"
393 banner="""***********************************************
394 * Interpreteur interactif %s
395 ***********************************************""" % self.code
396 console.interact(banner)
399 CONTEXT.unset_current_step()
401 def get_contexte_avant(self,etape):
403 Retourne le dictionnaire des concepts connus avant etape
404 On tient compte des commandes qui modifient le contexte
405 comme DETRUIRE ou les macros
406 Si etape == None, on retourne le contexte en fin de JDC
408 # L'étape courante pour laquelle le contexte a été calculé est
409 # mémorisée dans self.index_etape_courante
410 # XXX on pourrait faire mieux dans le cas PAR_LOT="NON" : en
412 # courante pendant le processus de construction des étapes.
413 # Si on insère des commandes (par ex, dans EFICAS), il faut préalablement
414 # remettre ce pointeur à 0
416 index_etape=self.etapes.index(etape)
418 index_etape=len(self.etapes)
419 if index_etape >= self.index_etape_courante:
420 # On calcule le contexte en partant du contexte existant
421 d=self.current_context
422 if self.index_etape_courante==0 and self.context_ini:
423 d.update(self.context_ini)
424 liste_etapes=self.etapes[self.index_etape_courante:index_etape]
426 d=self.current_context={}
427 if self.context_ini:d.update(self.context_ini)
428 liste_etapes=self.etapes
430 for e in liste_etapes:
435 self.index_etape_courante=index_etape
438 def get_global_contexte(self):
439 return self.g_context.copy()
441 def get_cmd(self,nomcmd):
443 Méthode pour recuperer la definition d'une commande
444 donnee par son nom dans les catalogues declares
447 for cata in self.cata:
448 if hasattr(cata,nomcmd):
449 return getattr(cata,nomcmd)
451 def append_reset(self,etape):
453 Ajoute une etape provenant d'un autre jdc a la liste des etapes
454 et remet à jour la parenté de l'étape et des concepts
456 self.etapes.append(etape)
458 etape.reset_jdc(self)