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   if os.getenv("HOSTNAME") == None:
 396      if os.getenv("HOST") == None:
 397         os.environ["HOSTNAME"]="localhost"
 398      else:
 399         os.environ["HOSTNAME"]=os.getenv("HOST")
 400
 401   theComputer = os.getenv("HOSTNAME")
 402   computerSplitName = theComputer.split('.')
 403   theComputer = computerSplitName[0]
 404
 405   #
 406   # Lancement Container C++ local
 407   #
 408   if with_container_cpp:
 409           ContainerCPPServer().run()
 410
 411           #
 412           # Attente de la disponibilité du Container C++ local dans le Naming Service
 413           #
 414
 415           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 416
 417   #
 418   # Lancement Container Python local
 419   #
 420
 421   if with_container_python:
 422           ContainerPYServer().run()
 423
 424           #
 425           # Attente de la disponibilité du Container Python local dans le Naming Service
 426           #
 427
 428           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 429
 430   if with_container_superv:
 431
 432         #
 433         # Lancement Container Supervision local
 434         #
 435
 436         ContainerSUPERVServer().run()
 437
 438         #
 439         # Attente de la disponibilité du Container Supervision local dans le Naming Service
 440         #
 441
 442         clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 443
 444
 445   #
 446   # Activation du GUI de Session Server
 447   #
 448
 449   #session.GetInterface()
 450
 451   end_time = os.times()
 452   print
 453   print "Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4])
 454
 455   return clt
 456
 457 #
 458 # -----------------------------------------------------------------------------
 459 #
 460
 461 if __name__ == "__main__":
 462    clt=None
 463    try:
 464       clt = startSalome()
 465    except:
 466       print
 467       print
 468       print "--- erreur au lancement Salome ---"
 469
 470    #print process_id
 471
 472
 473    filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
 474    #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 475
 476    fpid=open(filedict, 'w')
 477    pickle.dump(process_id,fpid)
 478    fpid.close()
 479
 480    print
 481    print "Sauvegarde du dictionnaire des process dans ", filedict
 482    print "Pour tuer les process SALOME, executer : python killSalome.py depuis"
 483    print "une console, ou bien killSalome() depuis le present interpreteur,"
 484    print "s'il n'est pas fermé."
 485    print
 486    print "runSalome, avec l'option --killall, commence par tuer les process restants d'une execution précédente."
 487    print
 488    print "Pour lancer uniquement le GUI, executer startGUI() depuis le present interpreteur,"
 489    print "s'il n'est pas fermé."
 490
 491    #
 492    #  Impression arborescence Naming Service
 493    #
 494
 495    if clt != None:
 496      print
 497      print " --- registered objects tree in Naming Service ---"
 498      clt.showNS()
 499