module_generator/astcompo.py

   1 import re, os
   2
   3 from gener import Component, Invalid, makedirs
   4
   5 from pyth_tmpl import pyinitEXEService, pyinitCEXEService, pyinitService
   6 from aster_tmpl import asterCEXEService, asterEXEService
   7 from aster_tmpl import asterService, asterEXECompo, asterCEXECompo, asterCompo
   8 from aster_tmpl import asterexeMakefile, astercexeMakefile, astercompoMakefile
   9 from aster_tmpl import comm, make_etude, cexe, exeaster
  10 from aster_tmpl import container, component
  11
  12 class ASTERComponent(Component):
  13   def __init__(self, name, services=None, libs="", rlibs="", aster_dir="",
  14                      python_path=None, argv=None, kind="lib", exe_path=None,
  15                      asrun=None, export_extras=""):
  16     self.aster_dir = aster_dir
  17     self.python_path = python_path or []
  18     self.argv = argv or []
  19     self.exe_path = exe_path
  20     self.asrun = asrun
  21     self.export_extras = export_extras
  22     Component.__init__(self, name, services, impl="ASTER", libs=libs,
  23                              rlibs=rlibs, kind=kind)
  24
  25   def validate(self):
  26     Component.validate(self)
  27     if not self.aster_dir:
  28       raise Invalid("aster_dir must be defined for component %s" % self.name)
  29
  30     kinds = ("lib", "cexe", "exe")
  31     if self.kind not in kinds:
  32       raise Invalid("kind must be one of %s" % kinds)
  33     if self.kind == "lib" and not self.python_path:
  34       raise Invalid("python_path must be defined for component %s" % self.name)
  35     if self.kind == "cexe" :
  36       if not self.exe_path:
  37         raise Invalid("exe_path must be defined for component %s" % self.name)
  38       if not self.asrun:
  39         raise Invalid("asrun must be defined for component %s" % self.name)
  40       if not os.path.exists(self.asrun):
  41         raise Invalid("asrun does not exist for component %s" % self.name)
  42     if self.kind == "exe" :
  43       if not self.exe_path:
  44         raise Invalid("exe_path must be defined for component %s" % self.name)
  45       if not self.asrun:
  46         raise Invalid("asrun must be defined for component %s" % self.name)
  47       if not os.path.exists(self.asrun):
  48         raise Invalid("asrun does not exist for component %s" % self.name)
  49
  50     for serv in self.services:
  51       #on ajoute un inport string de nom jdc en premier dans la liste des ports de chaque service
  52       serv.inport.insert(0, ("jdc", "string"))
  53
  54   def makeCompo(self, gen):
  55     filename = "%s.py" % self.name
  56     #on suppose que les composants ASTER sont homogenes (utilisent meme install)
  57     gen.aster = self.aster_dir
  58     if self.kind == "lib":
  59       return {"Makefile.am":astercompoMakefile.substitute(module=gen.module.name,
  60                                                           component=self.name),
  61              filename:self.makeaster(gen)}
  62     elif self.kind == "cexe":
  63       #creation de l'installation aster dans exe_path
  64       self.makecexepath(gen)
  65       return {"Makefile.am":astercexeMakefile.substitute(module=gen.module.name,
  66                                                          component=self.name),
  67              filename:self.makecexeaster(gen)}
  68     elif self.kind == "exe":
  69       #creation de l'installation aster dans exe_path
  70       self.makeexepath(gen)
  71       return {"Makefile.am":asterexeMakefile.substitute(module=gen.module.name,
  72                                                         component=self.name),
  73                self.name+".exe":exeaster.substitute(export=os.path.join(self.exe_path, "make_etude.export"), asrun=self.asrun),
  74                self.name+"_module.py":self.makeexeaster(gen)}
  75
  76   def makeexepath(self, gen):
  77     makedirs(self.exe_path)
  78     #patch to E_SUPERV.py
  79     fil = open(os.path.join(self.aster_dir, "bibpyt", "Execution", "E_SUPERV.py"))
  80     esuperv = fil.read()
  81     esuperv = re.sub("j=self.JdC", "self.jdc=j=self.JdC", esuperv)
  82     fil.close()
  83     #utilisation d'un programme principal python different
  84     fil = open(os.path.join(self.aster_dir, "config.txt"))
  85     config = fil.read()
  86     config = re.sub("Execution\/E_SUPERV.py", os.path.join(self.exe_path, "aster_component.py"), config)
  87     fil.close()
  88
  89     gen.makeFiles({
  90                    "aster_component.py":component.substitute(component=self.name),
  91                    "make_etude.export":make_etude.substitute(config=os.path.join(self.exe_path, "config.txt"),
  92                                                              comm=os.path.join(self.exe_path, self.name+".comm"),
  93                                                              extras=self.export_extras),
  94                    self.name+".comm":comm,
  95                    "config.txt":config,
  96                    "profile.sh":os.path.join(self.aster_dir, "profile.sh"),
  97                    "E_SUPERV.py":esuperv,
  98                   }, self.exe_path)
  99
 100   def makecexepath(self, gen):
 101     makedirs(self.exe_path)
 102     #patch to E_SUPERV.py
 103     fil = open(os.path.join(self.aster_dir, "bibpyt", "Execution", "E_SUPERV.py"))
 104     esuperv = fil.read()
 105     esuperv = re.sub("j=self.JdC", "self.jdc=j=self.JdC", esuperv)
 106     fil.close()
 107     #utilisation d'un programme principal python different
 108     fil = open(os.path.join(self.aster_dir, "config.txt"))
 109     config = fil.read()
 110     config = re.sub("Execution\/E_SUPERV.py", os.path.join(self.exe_path, "aster_container.py"), config)
 111     fil.close()
 112     gen.makeFiles({self.name+".exe":cexe.substitute(export=os.path.join(self.exe_path, "make_etude.export"),
 113                                                     asrun=self.asrun),
 114                    "aster_container.py":container,
 115                    "make_etude.export":make_etude.substitute(config=os.path.join(self.exe_path, "config.txt"),
 116                                                              comm=os.path.join(self.exe_path, self.name+".comm"),
 117                                                              extras=self.export_extras),
 118                    self.name+".comm":comm,
 119                    "config.txt":config,
 120                    "profile.sh":os.path.join(self.aster_dir, "profile.sh"),
 121                    "E_SUPERV.py":esuperv,
 122                   }, self.exe_path)
 123     #make exe executable
 124     os.chmod(os.path.join(self.exe_path, self.name+".exe"), 0777)
 125
 126   def makeexeaster(self, gen):
 127     services = []
 128     inits = []
 129     defs = []
 130     for serv in self.services:
 131       defs.append(serv.defs)
 132       params = []
 133       datas = []
 134       for name, typ in serv.inport:
 135         params.append(name)
 136         if typ == "pyobj":
 137           datas.append('"%s":cPickle.loads(%s)' % (name, name))
 138         else:
 139           datas.append('"%s":%s' % (name, name))
 140       #ajout de l'adresse du composant
 141       datas.append('"component":self.proxy.ptr()')
 142       dvars = "{"+','.join(datas)+"}"
 143       inparams = ",".join(params)
 144
 145       params = []
 146       datas = []
 147       for name, typ in serv.outport:
 148         params.append(name)
 149         if typ == "pyobj":
 150           datas.append('cPickle.dumps(j.g_context["%s"],-1)'%name)
 151         else:
 152           datas.append('j.g_context["%s"]'%name)
 153       outparams = ",".join(params)
 154       rvars = ",".join(datas)
 155
 156       service = asterEXEService.substitute(component=self.name,
 157                                            service=serv.name,
 158                                            inparams=inparams,
 159                                            outparams=outparams,
 160                                            body=serv.body,
 161                                            dvars=dvars, rvars=rvars)
 162       streams = []
 163       for name, typ, dep in serv.instream:
 164         streams.append('       calcium.create_calcium_port(self.proxy,"%s","%s","IN","%s")'% (name, typ, dep))
 165       instream = "\n".join(streams)
 166       streams = []
 167       for name, typ, dep in serv.outstream:
 168         streams.append('       calcium.create_calcium_port(self.proxy,"%s","%s","OUT","%s")'% (name, typ, dep))
 169       outstream = "\n".join(streams)
 170
 171       init = pyinitEXEService.substitute(component=self.name, service=serv.name,
 172                                          instream=instream, outstream=outstream)
 173       services.append(service)
 174       inits.append(init)
 175     return asterEXECompo.substitute(component=self.name, module=gen.module.name,
 176                                     servicesdef="\n".join(defs),
 177                                     servicesimpl="\n".join(services),
 178                                     initservice='\n'.join(inits),
 179                                     aster_dir=self.aster_dir)
 180
 181   def makecexeaster(self, gen):
 182     services = []
 183     inits = []
 184     defs = []
 185     for serv in self.services:
 186       defs.append(serv.defs)
 187       params = []
 188       datas = []
 189       for name, typ in serv.inport:
 190         params.append(name)
 191         if typ == "pyobj":
 192           datas.append('"%s":cPickle.loads(%s)' % (name, name))
 193         else:
 194           datas.append('"%s":%s' % (name, name))
 195       #ajout de l'adresse du composant
 196       datas.append('"component":self.proxy.ptr()')
 197       dvars = "{"+','.join(datas)+"}"
 198       inparams = ",".join(params)
 199
 200       params = []
 201       datas = []
 202       for name, typ in serv.outport:
 203         params.append(name)
 204         if typ == "pyobj":
 205           datas.append('cPickle.dumps(j.g_context["%s"],-1)'%name)
 206         else:
 207           datas.append('j.g_context["%s"]'%name)
 208       outparams = ",".join(params)
 209       rvars = ",".join(datas)
 210
 211       service = asterCEXEService.substitute(component=self.name,
 212                                             service=serv.name,
 213                                             inparams=inparams,
 214                                             outparams=outparams,
 215                                             body=serv.body,
 216                                             dvars=dvars, rvars=rvars)
 217       streams = []
 218       for name, typ, dep in serv.instream:
 219         streams.append('       calcium.create_calcium_port(self.proxy,"%s","%s","IN","%s")'% (name, typ, dep))
 220       instream = "\n".join(streams)
 221       streams = []
 222       for name, typ, dep in serv.outstream:
 223         streams.append('       calcium.create_calcium_port(self.proxy,"%s","%s","OUT","%s")'% (name, typ, dep))
 224       outstream = "\n".join(streams)
 225
 226       init = pyinitCEXEService.substitute(component=self.name,
 227                                           service=serv.name,
 228                                           instream=instream,
 229                                           outstream=outstream)
 230       services.append(service)
 231       inits.append(init)
 232     return asterCEXECompo.substitute(component=self.name,
 233                                      module=gen.module.name,
 234                                      servicesdef="\n".join(defs),
 235                                      servicesimpl="\n".join(services),
 236                                      initservice='\n'.join(inits),
 237                                      aster_dir=self.aster_dir)
 238   def getImpl(self):
 239     if self.kind == "cexe":
 240       return "CEXE", os.path.join(self.exe_path, self.name+".exe")
 241     else:
 242       return "SO", ""
 243
 244   def makeaster(self, gen):
 245     services = []
 246     inits = []
 247     defs = []
 248     for serv in self.services:
 249       defs.append(serv.defs)
 250       params = []
 251       datas = []
 252       for name, typ in serv.inport:
 253         params.append(name)
 254         if typ == "pyobj":
 255           datas.append('"%s":cPickle.loads(%s)' % (name, name))
 256         else:
 257           datas.append('"%s":%s' % (name, name))
 258       #ajout de l'adresse du composant
 259       datas.append('"component":self.proxy.ptr()')
 260       dvars = "{"+','.join(datas)+"}"
 261       inparams = ",".join(params)
 262
 263       params = []
 264       datas = []
 265       for name, typ in serv.outport:
 266         params.append(name)
 267         if typ == "pyobj":
 268           datas.append('cPickle.dumps(j.g_context["%s"],-1)'%name)
 269         else:
 270           datas.append('j.g_context["%s"]'%name)
 271       outparams = ",".join(params)
 272       rvars = ",".join(datas)
 273
 274       service = asterService.substitute(component=self.name, service=serv.name,
 275                                         inparams=inparams, outparams=outparams,
 276                                         body=serv.body,
 277                                         dvars=dvars, rvars=rvars)
 278       streams = []
 279       for name, typ, dep in serv.instream:
 280         streams.append('       calcium.create_calcium_port(self.proxy,"%s","%s","IN","%s")'% (name, typ, dep))
 281       instream = "\n".join(streams)
 282       streams = []
 283       for name, typ, dep in serv.outstream:
 284         streams.append('       calcium.create_calcium_port(self.proxy,"%s","%s","OUT","%s")'% (name, typ, dep))
 285       outstream = "\n".join(streams)
 286
 287       init = pyinitService.substitute(component=self.name, service=serv.name,
 288                                       instream=instream, outstream=outstream)
 289       services.append(service)
 290       inits.append(init)
 291
 292     python_path = ",".join([repr(p) for p in self.python_path])
 293     argv = ",".join([repr(p) for p in self.argv])
 294     return asterCompo.substitute(component=self.name, module=gen.module.name,
 295                                  servicesdef="\n".join(defs),
 296                                  servicesimpl="\n".join(services),
 297                                  initservice='\n'.join(inits),
 298                                  aster_dir=self.aster_dir,
 299                                  python_path=python_path, argv=argv)
 300