bin/runSalome.py

   1 #!/usr/bin/env python
   2
   3 usage="""USAGE: runSalome.py [options]
   4
   5 [command line options] :
   6 --help                        : affichage de l'aide
   7 --gui                         : lancement du GUI
   8 --logger                      : redirection des messages dans un fichier
   9 --xterm                       : les serveurs ouvrent une fenêtre xterm et les messages sont affichés dans cette fenêtre
  10 --modules=module1,module2,... : où modulen est le nom d'un module Salome à charger dans le catalogue
  11 --containers=cpp,python,superv: lancement des containers cpp, python et de supervision
  12 --killall                     : arrêt des serveurs de salome
  13
  14  La variable d'environnement <modulen>_ROOT_DIR doit etre préalablement
  15  positionnée (modulen doit etre en majuscule).
  16  KERNEL_ROOT_DIR est obligatoire.
  17 """
  18
  19 # -----------------------------------------------------------------------------
  20 #
  21 # Fonction d'arrêt de salome
  22 #
  23
  24 def killSalome():
  25    print "arret des serveurs SALOME"
  26    for pid, cmd in process_id.items():
  27       print "arret du process %s : %s"% (pid, cmd[0])
  28       try:
  29         os.kill(pid,signal.SIGKILL)
  30       except:
  31          print "  ------------------ process %s : %s inexistant"% (pid, cmd[0])
  32    print "arret du naming service"
  33    os.system("killall -9 omniNames")
  34
  35 # -----------------------------------------------------------------------------
  36 #
  37 # Fonction message
  38 #
  39
  40 def message(code, msg=''):
  41     if msg: print msg
  42     sys.exit(code)
  43
  44 import sys,os,string,glob,time,signal,pickle,getopt
  45
  46 init_time=os.times()
  47 opts, args=getopt.getopt(sys.argv[1:], 'hmglxck:', ['help','modules=','gui','logger','xterm','containers=','killall'])
  48 modules_root_dir={}
  49 process_id={}
  50 liste_modules={}
  51 liste_containers={}
  52 with_gui=0
  53 with_logger=0
  54 with_xterm=0
  55
  56 with_container_cpp=0
  57 with_container_python=0
  58 with_container_superv=0
  59
  60 try:
  61   for o, a in opts:
  62     if o in ('-h', '--help'):
  63       print usage
  64       sys.exit(1)
  65     elif o in ('-g', '--gui'):
  66       with_gui=1
  67     elif o in ('-l', '--logger'):
  68       with_logger=1
  69     elif o in ('-x', '--xterm'):
  70       with_xterm=1
  71     elif o in ('-m', '--modules'):
  72       liste_modules = [x.upper() for x in a.split(',')]
  73     elif o in ('-c', '--containers'):
  74       liste_containers = [x.lower() for x in a.split(',')]
  75       for r in liste_containers:
  76         if r not in ('cpp', 'python', 'superv'):
  77            message(1, 'Invalid -c/--containers option: %s' % a)
  78       if 'cpp' in liste_containers:
  79            with_container_cpp=1
  80       else:
  81            with_container_cpp=0
  82       if 'python' in liste_containers:
  83            with_container_python=1
  84       else:
  85            with_container_python=0
  86       if 'superv' in liste_containers:
  87            with_container_superv=1
  88       else:
  89            with_container_superv=0
  90     elif o in ('-k', '--killall'):
  91       filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
  92       #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
  93       found = 0
  94       try:
  95          fpid=open(filedict, 'r')
  96          found = 1
  97       except:
  98          print "le fichier %s des process SALOME n'est pas accessible"% filedict
  99
 100       if found:
 101          process_id=pickle.load(fpid)
 102          fpid.close()
 103          killSalome()
 104          process_id={}
 105          os.remove(filedict)
 106
 107 except getopt.error, msg:
 108   print usage
 109   sys.exit(1)
 110
 111 # -----------------------------------------------------------------------------
 112 #
 113 # Vérification des variables d'environnement
 114 #
 115 try:
 116   kernel_root_dir=os.environ["KERNEL_ROOT_DIR"]
 117   modules_root_dir["KERNEL"]=kernel_root_dir
 118 except:
 119   print usage
 120   sys.exit(1)
 121
 122 for module in liste_modules :
 123    try:
 124       module=module.upper()
 125       module_root_dir=os.environ[module +"_ROOT_DIR"]
 126       modules_root_dir[module]=module_root_dir
 127    except:
 128       print usage
 129       sys.exit(1)
 130
 131 # il faut KERNEL en premier dans la liste des modules
 132 # - l'ordre des modules dans le catalogue sera identique
 133 # - la liste des modules presents dans le catalogue est exploitée pour charger les modules CORBA python,
 134 #   il faut charger les modules python du KERNEL en premier
 135
 136 if "KERNEL" in liste_modules:liste_modules.remove("KERNEL")
 137 liste_modules[:0]=["KERNEL"]
 138 #print liste_modules
 139 #print modules_root_dir
 140
 141 os.environ["SALOMEPATH"]=":".join(modules_root_dir.values())
 142 if "SUPERV" in liste_modules:with_container_superv=1
 143
 144
 145 # -----------------------------------------------------------------------------
 146 #
 147 # Définition des classes d'objets pour le lancement des Server CORBA
 148 #
 149
 150 class Server:
 151    CMD=[]
 152    if with_xterm:
 153         ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-e']
 154    else:
 155         ARGS=[]
 156
 157    def run(self):
 158       args = self.ARGS+self.CMD
 159       #print "args = ", args
 160       pid = os.spawnvp(os.P_NOWAIT, args[0], args)
 161       process_id[pid]=self.CMD
 162
 163 class CatalogServer(Server):
 164    SCMD1=['SALOME_ModuleCatalog_Server','-common']
 165    SCMD2=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml']
 166
 167    def setpath(self,liste_modules):
 168       cata_path=[]
 169       for module in liste_modules:
 170           module_root_dir=modules_root_dir[module]
 171           module_cata=module+"Catalog.xml"
 172           print "   ", module_cata
 173           cata_path.extend(glob.glob(os.path.join(module_root_dir,"share","salome","resources",module_cata)))
 174       self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 175
 176 class SalomeDSServer(Server):
 177    CMD=['SALOMEDS_Server']
 178
 179 class RegistryServer(Server):
 180    CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 181
 182 class ContainerCPPServer(Server):
 183    CMD=['SALOME_Container','FactoryServer','-ORBInitRef','NameService=corbaname::localhost']
 184
 185 class ContainerPYServer(Server):
 186    CMD=['SALOME_ContainerPy.py','FactoryServerPy','-ORBInitRef','NameService=corbaname::localhost']
 187
 188 class ContainerSUPERVServer(Server):
 189    CMD=['SALOME_Container','SuperVisionContainer','-ORBInitRef','NameService=corbaname::localhost']
 190
 191 class LoggerServer(Server):
 192    CMD=['SALOME_Logger_Server', 'logger.log']
 193
 194 class SessionLoader(Server):
 195    CMD=['SALOME_Session_Loader']
 196    if with_container_cpp:
 197        CMD=CMD+['CPP']
 198    if with_container_python:
 199        CMD=CMD+['PY']
 200    if with_container_superv:
 201        CMD=CMD+['SUPERV']
 202    if with_gui:
 203        CMD=CMD+['GUI']
 204
 205 class SessionServer(Server):
 206    CMD=['SALOME_Session_Server']
 207
 208 class NotifyServer(Server):
 209    CMD=['notifd','-c','${KERNEL_ROOT_DIR}/share/salome/resources/channel.cfg -DFactoryIORFileName=/tmp/${LOGNAME}_rdifact.ior -DChannelIORFileName=/tmp/${LOGNAME}_rdichan.ior']
 210
 211 # -----------------------------------------------------------------------------
 212 #
 213 # Fonction de test
 214 #
 215
 216 def test(clt):
 217    # create an LifeCycleCORBA instance
 218    import LifeCycleCORBA
 219    lcc = LifeCycleCORBA.LifeCycleCORBA(clt.orb)
 220    med = lcc.FindOrLoadComponent("FactoryServer", "MED")
 221    #pycalc = lcc.FindOrLoadComponent("FactoryServerPy", "CalculatorPy")
 222
 223 # -----------------------------------------------------------------------------
 224 #
 225 # Fonctions helper pour ajouter des variables d'environnement
 226 #
 227
 228 def add_path(directory):
 229    os.environ["PATH"]=directory + ":" + os.environ["PATH"]
 230
 231 def add_ld_library_path(directory):
 232    os.environ["LD_LIBRARY_PATH"]=directory + ":" + os.environ["LD_LIBRARY_PATH"]
 233
 234 def add_python_path(directory):
 235    os.environ["PYTHONPATH"]=directory + ":" + os.environ["PYTHONPATH"]
 236    sys.path[:0]=[directory]
 237
 238 # -----------------------------------------------------------------------------
 239 #
 240 # initialisation des variables d'environnement
 241 #
 242
 243 python_version="python%d.%d" % sys.version_info[0:2]
 244
 245 #
 246 # Ajout du chemin d'acces aux executables de KERNEL dans le PATH
 247 #
 248
 249 add_path(os.path.join(kernel_root_dir,"bin","salome"))
 250 #print "PATH=",os.environ["PATH"]
 251
 252 #
 253 # Ajout des modules dans le LD_LIBRARY_PATH
 254 #
 255 for module in liste_modules:
 256     module_root_dir=modules_root_dir[module]
 257     add_ld_library_path(os.path.join(module_root_dir,"lib","salome"))
 258 #print "LD_LIBRARY_PATH=",os.environ["LD_LIBRARY_PATH"]
 259
 260 #
 261 # Ajout des modules dans le PYTHONPATH (KERNEL prioritaire, donc en dernier)
 262 #
 263
 264 liste_modules_reverse=liste_modules[:]
 265 liste_modules_reverse.reverse()
 266 #print liste_modules
 267 #print liste_modules_reverse
 268 for module in liste_modules_reverse:
 269     module_root_dir=modules_root_dir[module]
 270     add_python_path(os.path.join(module_root_dir,"bin","salome"))
 271     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome"))
 272     add_python_path(os.path.join(module_root_dir,"lib","salome"))
 273     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome","shared_modules"))
 274
 275 #print "PYTHONPATH=",sys.path
 276
 277 import orbmodule
 278
 279 #
 280 # -----------------------------------------------------------------------------
 281 #
 282
 283 def startGUI():
 284   import SALOME
 285   session=clt.waitNS("/Kernel/Session",SALOME.Session)
 286
 287   #
 288   # Activation du GUI de Session Server
 289   #
 290
 291   session.GetInterface()
 292
 293 #
 294 # -----------------------------------------------------------------------------
 295 #
 296
 297 def startSalome():
 298
 299   #
 300   # Lancement Session Loader
 301   #
 302
 303   if with_gui:
 304      SessionLoader().run()
 305
 306   #
 307   # Initialisation ORB et Naming Service
 308   #
 309
 310   clt=orbmodule.client()
 311
 312   # (non obligatoire) Lancement Logger Server et attente de sa disponibilite dans le naming service
 313   #
 314
 315   if with_logger:
 316         LoggerServer().run()
 317         clt.waitLogger("Logger")
 318
 319
 320   #
 321   # Lancement Registry Server
 322   #
 323
 324   RegistryServer().run()
 325
 326   #
 327   # Attente de la disponibilité du Registry dans le Naming Service
 328   #
 329
 330   clt.waitNS("/Registry")
 331
 332   #
 333   # Lancement Catalog Server
 334   #
 335
 336   cataServer=CatalogServer()
 337   cataServer.setpath(liste_modules)
 338   cataServer.run()
 339
 340   #
 341   # Attente de la disponibilité du Catalog Server dans le Naming Service
 342   #
 343
 344   import SALOME_ModuleCatalog
 345   clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 346
 347   #
 348   # Lancement SalomeDS Server
 349   #
 350
 351   os.environ["CSF_PluginDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
 352   os.environ["CSF_SALOMEDS_ResourcesDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
 353   SalomeDSServer().run()
 354
 355   if "GEOM" in liste_modules:
 356         print "GEOM OCAF Resources"
 357         os.environ["CSF_GEOMDS_ResourcesDefaults"]=os.path.join(modules_root_dir["GEOM"],"share","salome","resources")
 358
 359
 360   #
 361   # Attente de la disponibilité du SalomeDS dans le Naming Service
 362   #
 363
 364   clt.waitNS("/myStudyManager")
 365
 366   #
 367   # Lancement Session Server
 368   #
 369
 370   SessionServer().run()
 371
 372   #
 373   # Attente de la disponibilité du Session Server dans le Naming Service
 374   #
 375
 376   import SALOME
 377   session=clt.waitNS("/Kernel/Session",SALOME.Session)
 378
 379   #
 380   # Lancement Container C++ local
 381   #
 382   if with_container_cpp:
 383           ContainerCPPServer().run()
 384
 385           #
 386           # Attente de la disponibilité du Container C++ local dans le Naming Service
 387           #
 388
 389           theComputer = os.getenv("HOSTNAME")
 390           computerSplitName = theComputer.split('.')
 391           theComputer = computerSplitName[0]
 392
 393           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 394
 395   #
 396   # Lancement Container Python local
 397   #
 398
 399   if with_container_python:
 400           ContainerPYServer().run()
 401
 402           #
 403           # Attente de la disponibilité du Container Python local dans le Naming Service
 404           #
 405
 406           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 407
 408   if with_container_superv:
 409
 410         #
 411         # Lancement Container Supervision local
 412         #
 413
 414         ContainerSUPERVServer().run()
 415
 416         #
 417         # Attente de la disponibilité du Container Supervision local dans le Naming Service
 418         #
 419
 420         clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 421
 422
 423   #
 424   # Activation du GUI de Session Server
 425   #
 426
 427   #session.GetInterface()
 428
 429   end_time = os.times()
 430   print
 431   print "Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4])
 432
 433   return clt
 434
 435 #
 436 # -----------------------------------------------------------------------------
 437 #
 438
 439 if __name__ == "__main__":
 440    clt=None
 441    try:
 442       clt = startSalome()
 443    except:
 444       print
 445       print
 446       print "--- erreur au lancement Salome ---"
 447
 448    #print process_id
 449
 450
 451    filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
 452    #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 453
 454    fpid=open(filedict, 'w')
 455    pickle.dump(process_id,fpid)
 456    fpid.close()
 457
 458    print
 459    print "Sauvegarde du dictionnaire des process dans ", filedict
 460    print "Pour tuer les process SALOME, executer : python killSalome.py depuis"
 461    print "une console, ou bien killSalome() depuis le present interpreteur,"
 462    print "s'il n'est pas fermé."
 463    print
 464    print "runSalome, avec l'option --killall, commence par tuer les process restants d'une execution précédente."
 465    print
 466    print "Pour lancer uniquement le GUI, executer startGUI() depuis le present interpreteur,"
 467    print "s'il n'est pas fermé."
 468
 469    #
 470    #  Impression arborescence Naming Service
 471    #
 472
 473    if clt != None:
 474      print
 475      print " --- registered objects tree in Naming Service ---"
 476      clt.showNS()
 477