1 #@ MODIF N_JDC Noyau DATE 14/09/2004 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.traiter_fin_exec('commande')
176 except AsException,e:
177 # une erreur a ete identifiee
179 traceback.print_exc()
180 self.cr.exception(str(e))
181 CONTEXT.unset_current_step()
184 etype, value, tb = sys.exc_info()
185 l= traceback.extract_tb(tb)
186 s= traceback.format_exception_only("Erreur de nom",e)[0][:-1]
187 message = "erreur de syntaxe, %s ligne %d" % (s,l[-1][1])
189 traceback.print_exc()
190 self.cr.exception(message)
191 CONTEXT.unset_current_step()
193 except self.UserError,exc_val:
194 self.traiter_user_exception(exc_val)
195 CONTEXT.unset_current_step()
196 self.traiter_fin_exec('commande')
200 # sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
201 # (tuple de 3 éléments)
202 if CONTEXT.debug : traceback.print_exc()
204 exc_typ,exc_val,exc_fr=sys.exc_info()
205 l=traceback.format_exception(exc_typ,exc_val,exc_fr)
206 self.cr.exception("erreur non prevue et non traitee prevenir la maintenance "+
207 self.nom+'\n'+ string.join(l))
208 del exc_typ,exc_val,exc_fr
209 CONTEXT.unset_current_step()
211 def traiter_fin_exec(self,mode,etape=None):
213 Cette methode realise un traitement final apres l'execution de toutes
214 les commandes en mode commande par commande ou par lot
215 Par defaut il n'y a pas de traitement. Elle doit etre surchargee
216 pour en introduire un
218 print "FIN D'EXECUTION",mode,etape
220 def traiter_user_exception(self,exc_val):
221 """Cette methode realise un traitement sur les exceptions utilisateur
222 Par defaut il n'y a pas de traitement. La méthode doit etre
223 surchargée pour en introduire un.
227 def register(self,etape):
229 Cette méthode ajoute etape dans la liste des etapes : self.etapes
230 et retourne un numéro d'enregistrement
232 self.etapes.append(etape)
233 return self.g_register(etape)
235 def o_register(self,sd):
237 Retourne un identificateur pour concept
240 nom=sd.idracine + self.SEP + `self.nsd`
243 def g_register(self,etape):
245 Retourne un identificateur pour etape
247 self.nstep=self.nstep+1
248 idetape=etape.idracine + self.SEP + `self.nstep`
251 def create_sdprod(self,etape,nomsd):
253 Intention : Cette methode doit fabriquer le concept produit retourne
254 par l'etape etape et le nommer.
255 Elle est appelée à l'initiative de l'etape
256 pendant le processus de construction de cette etape :
257 methode __call__ de la classe CMD (OPER ou MACRO)
258 Ce travail est réalisé par le contexte supérieur
259 (etape.parent) car dans certains cas, le concept ne doit
260 pas etre fabriqué mais l'etape doit simplement utiliser
261 un concept préexistant.
262 Cas 1 : etape.reuse != None : le concept est réutilisé
263 Cas 2 : l'étape appartient à une macro qui a déclaré un
264 concept de sortie qui doit etre produit par cette
266 Dans le cas du JDC, le deuxième cas ne peut pas se produire.
268 sd= etape.get_sd_prod()
269 if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None) :
270 # ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
271 # d un concept. Commande non reentrante ou reuse absent.
272 self.NommerSdprod(sd,nomsd)
275 def NommerSdprod(self,sd,sdnom,restrict='non'):
277 Nomme la SD apres avoir verifie que le nommage est possible : nom
279 Si le nom est deja utilise, leve une exception
280 Met le concept créé dans le concept global g_context
282 if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
284 o=self.sds_dict.get(sdnom,None)
285 if isinstance(o,ASSD):
286 raise AsException("Nom de concept deja defini : %s" % sdnom)
288 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
289 # Ajoute a la creation (appel de reg_sd).
290 self.sds_dict[sdnom]=sd
293 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
294 if restrict == 'non':
295 self.g_context[sdnom]=sd
299 Methode appelee dans l __init__ d un ASSD lors de sa creation
303 return self.o_register(sd)
305 def delete_concept_after_etape(self,etape,sd):
307 Met à jour les étapes du JDC qui sont après etape suite à
308 la disparition du concept sd
310 # Cette methode est définie dans le noyau mais ne sert que pendant
311 # la phase de creation des etapes et des concepts. Il n'y a aucun
312 # traitement particulier à réaliser.
313 # Dans d'autres conditions, il faut surcharger cette méthode
317 N_OBJECT.OBJECT.supprime(self)
318 for etape in self.etapes:
321 def get_file(self,unite=None,fic_origine=''):
323 Retourne le nom du fichier correspondant à un numero d'unité
324 logique (entier) ainsi que le source contenu dans le fichier
327 # Si le JDC est relié à une application maitre, on délègue la recherche
328 file,text= self.appli.get_file(unite,fic_origine)
332 if os.path.exists("fort."+str(unite)):
333 file= "fort."+str(unite)
335 raise AsException("Impossible de trouver le fichier correspondant"
336 " a l unite %s" % unite)
337 if not os.path.exists(file):
338 raise AsException("%s n'est pas un fichier existant" % unite)
342 if file == None : return None,None
343 text=string.replace(text,'\r\n','\n')
344 linecache.cache[file]=0,0,string.split(text,'\n'),file
347 def set_par_lot(self,par_lot):
349 Met le mode de traitement a PAR LOT
350 ou a COMMANDE par COMMANDE
351 en fonction de la valeur du mot cle PAR_LOT et
352 du contexte : application maitre ou pas
354 if self.appli == None:
355 # Pas d application maitre
358 # Avec application maitre
361 def accept(self,visitor):
363 Cette methode permet de parcourir l'arborescence des objets
364 en utilisant le pattern VISITEUR
366 visitor.visitJDC(self)
370 Cette methode a pour fonction d'ouvrir un interpreteur
371 pour que l'utilisateur entre des commandes interactivement
373 CONTEXT.set_current_step(self)
375 # Le module nommage utilise le module linecache pour accéder
376 # au source des commandes du jeu de commandes.
377 # Dans le cas d'un fichier, on accède au contenu de ce fichier
378 # Dans le cas de la console interactive, il faut pouvoir accéder
379 # aux commandes qui sont dans le buffer de la console
380 import linecache,code
381 console= code.InteractiveConsole(self.g_context,filename="<console>")
382 linecache.cache["<console>"]=0,0,console.buffer,"<console>"
383 banner="""***********************************************
384 * Interpreteur interactif %s
385 ***********************************************""" % self.code
386 console.interact(banner)
389 CONTEXT.unset_current_step()
391 def get_contexte_avant(self,etape):
393 Retourne le dictionnaire des concepts connus avant etape
394 On tient compte des commandes qui modifient le contexte
395 comme DETRUIRE ou les macros
396 Si etape == None, on retourne le contexte en fin de JDC
398 # L'étape courante pour laquelle le contexte a été calculé est
399 # mémorisée dans self.index_etape_courante
400 # XXX on pourrait faire mieux dans le cas PAR_LOT="NON" : en
402 # courante pendant le processus de construction des étapes.
403 # Si on insère des commandes (par ex, dans EFICAS), il faut préalablement
404 # remettre ce pointeur à 0
406 index_etape=self.etapes.index(etape)
408 index_etape=len(self.etapes)
409 if index_etape >= self.index_etape_courante:
410 # On calcule le contexte en partant du contexte existant
411 d=self.current_context
412 if self.index_etape_courante==0 and self.context_ini:
413 d.update(self.context_ini)
414 liste_etapes=self.etapes[self.index_etape_courante:index_etape]
416 d=self.current_context={}
417 if self.context_ini:d.update(self.context_ini)
418 liste_etapes=self.etapes
420 for e in liste_etapes:
425 self.index_etape_courante=index_etape
428 def get_global_contexte(self):
429 return self.g_context.copy()
431 def get_cmd(self,nomcmd):
433 Méthode pour recuperer la definition d'une commande
434 donnee par son nom dans les catalogues declares
437 for cata in self.cata:
438 if hasattr(cata,nomcmd):
439 return getattr(cata,nomcmd)