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
 259 os.environ["SALOME_trace"]="local"
 260 if with_logger:
 261    os.environ["SALOME_trace"]="with_logger"
 262    locdir=os.environ['PWD']
 263    libtracedir=os.path.join(locdir,"libSalomeTrace")
 264    libtrace = os.path.join(kernel_root_dir,"lib","salome","libSALOMELoggerClient.so.0.0.0")
 265    libtraceln = os.path.join(libtracedir,"libSALOMELocalTrace.so")
 266    aCommand = 'rm -rf ' + libtracedir + "; "
 267    aCommand += 'mkdir ' + libtracedir + "; "
 268    aCommand += 'ln -s ' + libtrace + " " + libtraceln + "; "
 269    aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0; "
 270    aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0.0.0; "
 271    os.system(aCommand)
 272    add_ld_library_path(libtracedir)
 273
 274 #print "LD_LIBRARY_PATH=",os.environ["LD_LIBRARY_PATH"]
 275
 276 #
 277 # Ajout des modules dans le PYTHONPATH (KERNEL prioritaire, donc en dernier)
 278 #
 279
 280 liste_modules_reverse=liste_modules[:]
 281 liste_modules_reverse.reverse()
 282 #print liste_modules
 283 #print liste_modules_reverse
 284 for module in liste_modules_reverse:
 285     module_root_dir=modules_root_dir[module]
 286     add_python_path(os.path.join(module_root_dir,"bin","salome"))
 287     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome"))
 288     add_python_path(os.path.join(module_root_dir,"lib","salome"))
 289     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome","shared_modules"))
 290
 291 #print "PYTHONPATH=",sys.path
 292
 293 import orbmodule
 294
 295 #
 296 # -----------------------------------------------------------------------------
 297 #
 298
 299 def startGUI():
 300   import SALOME
 301   session=clt.waitNS("/Kernel/Session",SALOME.Session)
 302
 303   #
 304   # Activation du GUI de Session Server
 305   #
 306
 307   session.GetInterface()
 308
 309 #
 310 # -----------------------------------------------------------------------------
 311 #
 312
 313 def startSalome():
 314
 315   #
 316   # Lancement Session Loader
 317   #
 318
 319   if with_gui:
 320      SessionLoader().run()
 321
 322   #
 323   # Initialisation ORB et Naming Service
 324   #
 325
 326   clt=orbmodule.client()
 327
 328   # (non obligatoire) Lancement Logger Server et attente de sa disponibilite dans le naming service
 329   #
 330
 331   if with_logger:
 332         LoggerServer().run()
 333         clt.waitLogger("Logger")
 334
 335
 336   #
 337   # Lancement Registry Server
 338   #
 339
 340   RegistryServer().run()
 341
 342   #
 343   # Attente de la disponibilité du Registry dans le Naming Service
 344   #
 345
 346   clt.waitNS("/Registry")
 347
 348   #
 349   # Lancement Catalog Server
 350   #
 351
 352   cataServer=CatalogServer()
 353   cataServer.setpath(liste_modules)
 354   cataServer.run()
 355
 356   #
 357   # Attente de la disponibilité du Catalog Server dans le Naming Service
 358   #
 359
 360   import SALOME_ModuleCatalog
 361   clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 362
 363   #
 364   # Lancement SalomeDS Server
 365   #
 366
 367   os.environ["CSF_PluginDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
 368   os.environ["CSF_SALOMEDS_ResourcesDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
 369   SalomeDSServer().run()
 370
 371   if "GEOM" in liste_modules:
 372         print "GEOM OCAF Resources"
 373         os.environ["CSF_GEOMDS_ResourcesDefaults"]=os.path.join(modules_root_dir["GEOM"],"share","salome","resources")
 374
 375
 376   #
 377   # Attente de la disponibilité du SalomeDS dans le Naming Service
 378   #
 379
 380   clt.waitNS("/myStudyManager")
 381
 382   #
 383   # Lancement Session Server
 384   #
 385
 386   SessionServer().run()
 387
 388   #
 389   # Attente de la disponibilité du Session Server dans le Naming Service
 390   #
 391
 392   import SALOME
 393   session=clt.waitNS("/Kernel/Session",SALOME.Session)
 394
 395
 396   theComputer = os.getenv("HOSTNAME")
 397   computerSplitName = theComputer.split('.')
 398   theComputer = computerSplitName[0]
 399
 400   #
 401   # Lancement Container C++ local
 402   #
 403   if with_container_cpp:
 404           ContainerCPPServer().run()
 405
 406           #
 407           # Attente de la disponibilité du Container C++ local dans le Naming Service
 408           #
 409
 410           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 411
 412   #
 413   # Lancement Container Python local
 414   #
 415
 416   if with_container_python:
 417           ContainerPYServer().run()
 418
 419           #
 420           # Attente de la disponibilité du Container Python local dans le Naming Service
 421           #
 422
 423           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 424
 425   if with_container_superv:
 426
 427         #
 428         # Lancement Container Supervision local
 429         #
 430
 431         ContainerSUPERVServer().run()
 432
 433         #
 434         # Attente de la disponibilité du Container Supervision local dans le Naming Service
 435         #
 436
 437         clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 438
 439
 440   #
 441   # Activation du GUI de Session Server
 442   #
 443
 444   #session.GetInterface()
 445
 446   end_time = os.times()
 447   print
 448   print "Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4])
 449
 450   return clt
 451
 452 #
 453 # -----------------------------------------------------------------------------
 454 #
 455
 456 if __name__ == "__main__":
 457    clt=None
 458    try:
 459       clt = startSalome()
 460    except:
 461       print
 462       print
 463       print "--- erreur au lancement Salome ---"
 464
 465    #print process_id
 466
 467
 468    filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
 469    #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 470
 471    fpid=open(filedict, 'w')
 472    pickle.dump(process_id,fpid)
 473    fpid.close()
 474
 475    print
 476    print "Sauvegarde du dictionnaire des process dans ", filedict
 477    print "Pour tuer les process SALOME, executer : python killSalome.py depuis"
 478    print "une console, ou bien killSalome() depuis le present interpreteur,"
 479    print "s'il n'est pas fermé."
 480    print
 481    print "runSalome, avec l'option --killall, commence par tuer les process restants d'une execution précédente."
 482    print
 483    print "Pour lancer uniquement le GUI, executer startGUI() depuis le present interpreteur,"
 484    print "s'il n'est pas fermé."
 485
 486    #
 487    #  Impression arborescence Naming Service
 488    #
 489
 490    if clt != None:
 491      print
 492      print " --- registered objects tree in Naming Service ---"
 493      clt.showNS()
 494