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