src/wrappergen/src/HXX2SALOME_GENERIC_CLASS_NAME_SRC/bin/runSalome.py

   1 #!/usr/bin/env python
   2 # Copyright (C) 2006-2016  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 usage="""USAGE: runSalome.py [options]
  22
  23 [command line options] :
  24 --help                        : affichage de l'aide
  25 --gui                         : lancement du GUI
  26 --logger                      : redirection des messages dans un fichier
  27 --xterm                       : les serveurs ouvrent une fen??tre xterm et les messages sont affich??s dans cette fen??tre
  28 --modules=module1,module2,... : o?? modulen est le nom d'un module Salome ?? charger dans le catalogue
  29 --containers=cpp,python,superv: lancement des containers cpp, python et de supervision
  30 --killall                     : arr??t des serveurs de salome
  31
  32  La variable d'environnement <modulen>_ROOT_DIR doit etre pr??alablement
  33  positionn??e (modulen doit etre en majuscule).
  34  KERNEL_ROOT_DIR est obligatoire.
  35 """
  36
  37 # -----------------------------------------------------------------------------
  38 #
  39 # Fonction d'arr??t de salome
  40 #
  41
  42 def killSalome():
  43     print("arret des serveurs SALOME")
  44     for pid, cmd in list(process_id.items()):
  45         print("arret du process %s : %s"% (pid, cmd[0]))
  46         try:
  47             os.kill(pid,signal.SIGKILL)
  48         except:
  49             print("  ------------------ process %s : %s inexistant"% (pid, cmd[0]))
  50     print("arret du naming service")
  51     os.system("killall -9 omniNames")
  52
  53 # -----------------------------------------------------------------------------
  54 #
  55 # Fonction message
  56 #
  57
  58 def message(code, msg=''):
  59     if msg: print(msg)
  60     sys.exit(code)
  61
  62 import sys,os,string,glob,time,signal,pickle,getopt
  63
  64 init_time=os.times()
  65 opts, args=getopt.getopt(sys.argv[1:], 'hmglxck:', ['help','modules=','gui','logger','xterm','containers=','killall'])
  66 modules_root_dir={}
  67 process_id={}
  68 liste_modules={}
  69 liste_containers={}
  70 with_gui=0
  71 with_logger=0
  72 with_xterm=0
  73
  74 with_container_cpp=0
  75 with_container_python=0
  76 with_container_superv=0
  77
  78 try:
  79     for o, a in opts:
  80         if o in ('-h', '--help'):
  81             print(usage)
  82             sys.exit(1)
  83         elif o in ('-g', '--gui'):
  84             with_gui=1
  85         elif o in ('-l', '--logger'):
  86             with_logger=1
  87         elif o in ('-x', '--xterm'):
  88             with_xterm=1
  89         elif o in ('-m', '--modules'):
  90             liste_modules = [x.upper() for x in a.split(',')]
  91         elif o in ('-c', '--containers'):
  92             liste_containers = [x.lower() for x in a.split(',')]
  93             for r in liste_containers:
  94                 if r not in ('cpp', 'python', 'superv'):
  95                     message(1, 'Invalid -c/--containers option: %s' % a)
  96             if 'cpp' in liste_containers:
  97                 with_container_cpp=1
  98             else:
  99                 with_container_cpp=0
 100             if 'python' in liste_containers:
 101                 with_container_python=1
 102             else:
 103                 with_container_python=0
 104             if 'superv' in liste_containers:
 105                 with_container_superv=1
 106             else:
 107                 with_container_superv=0
 108         elif o in ('-k', '--killall'):
 109             filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
 110             #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 111             found = 0
 112             try:
 113                 fpid=open(filedict, 'r')
 114                 found = 1
 115             except:
 116                 print("le fichier %s des process SALOME n'est pas accessible"% filedict)
 117
 118             if found:
 119                 process_id=pickle.load(fpid)
 120                 fpid.close()
 121                 killSalome()
 122                 process_id={}
 123                 os.remove(filedict)
 124
 125 except getopt.error as msg:
 126     print(usage)
 127     sys.exit(1)
 128
 129 # -----------------------------------------------------------------------------
 130 #
 131 # V??rification des variables d'environnement
 132 #
 133 try:
 134     kernel_root_dir=os.environ["KERNEL_ROOT_DIR"]
 135     modules_root_dir["KERNEL"]=kernel_root_dir
 136 except:
 137     print(usage)
 138     sys.exit(1)
 139
 140 for module in liste_modules :
 141     try:
 142         module=module.upper()
 143         module_root_dir=os.environ[module +"_ROOT_DIR"]
 144         modules_root_dir[module]=module_root_dir
 145     except:
 146         print(usage)
 147         sys.exit(1)
 148
 149 # il faut KERNEL en premier dans la liste des modules
 150 # - l'ordre des modules dans le catalogue sera identique
 151 # - la liste des modules presents dans le catalogue est exploit??e pour charger les modules CORBA python,
 152 #   il faut charger les modules python du KERNEL en premier
 153
 154 if "KERNEL" in liste_modules:liste_modules.remove("KERNEL")
 155 liste_modules[:0]=["KERNEL"]
 156 #print liste_modules
 157 #print modules_root_dir
 158
 159 os.environ["SALOMEPATH"]=":".join(list(modules_root_dir.values()))
 160 if "SUPERV" in liste_modules:with_container_superv=1
 161
 162
 163 # -----------------------------------------------------------------------------
 164 #
 165 # D??finition des classes d'objets pour le lancement des Server CORBA
 166 #
 167
 168 class Server:
 169     CMD=[]
 170     if with_xterm:
 171         ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-e']
 172     else:
 173         ARGS=[]
 174
 175     def run(self):
 176         args = self.ARGS+self.CMD
 177         #print "args = ", args
 178         pid = os.spawnvp(os.P_NOWAIT, args[0], args)
 179         process_id[pid]=self.CMD
 180
 181 class CatalogServer(Server):
 182     SCMD1=['SALOME_ModuleCatalog_Server','-common']
 183     SCMD2=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml']
 184
 185     def setpath(self,liste_modules):
 186         cata_path=[]
 187         for module in liste_modules:
 188             module_root_dir=modules_root_dir[module]
 189             module_cata=module+"Catalog.xml"
 190             print("   ", module_cata)
 191             cata_path.extend(glob.glob(os.path.join(module_root_dir,"share","salome","resources",module_cata)))
 192         self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 193
 194 class SalomeDSServer(Server):
 195     CMD=['SALOMEDS_Server']
 196
 197 class RegistryServer(Server):
 198     CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 199
 200 class ContainerCPPServer(Server):
 201     CMD=['SALOME_Container','FactoryServer','-ORBInitRef','NameService=corbaname::localhost']
 202
 203 class ContainerPYServer(Server):
 204     CMD=['SALOME_ContainerPy.py','FactoryServerPy','-ORBInitRef','NameService=corbaname::localhost']
 205
 206 class ContainerSUPERVServer(Server):
 207     CMD=['SALOME_Container','SuperVisionContainer','-ORBInitRef','NameService=corbaname::localhost']
 208
 209 class LoggerServer(Server):
 210     CMD=['SALOME_Logger_Server', 'logger.log']
 211
 212 class SessionLoader(Server):
 213     CMD=['SALOME_Session_Loader']
 214     if with_container_cpp:
 215         CMD=CMD+['CPP']
 216     if with_container_python:
 217         CMD=CMD+['PY']
 218     if with_container_superv:
 219         CMD=CMD+['SUPERV']
 220     if with_gui:
 221         CMD=CMD+['GUI']
 222
 223 class SessionServer(Server):
 224     CMD=['SALOME_Session_Server']
 225
 226 class NotifyServer(Server):
 227     CMD=['notifd','-c','${KERNEL_ROOT_DIR}/share/salome/resources/channel.cfg -DFactoryIORFileName=/tmp/${LOGNAME}_rdifact.ior -DChannelIORFileName=/tmp/${LOGNAME}_rdichan.ior']
 228
 229 # -----------------------------------------------------------------------------
 230 #
 231 # Fonction de test
 232 #
 233
 234 def test(clt):
 235     """
 236          Test function that creates an instance of HXX2SALOME_GENERIC_CLASS_NAME component
 237          usage : hello=test(clt)
 238     """
 239     # create an LifeCycleCORBA instance
 240     import LifeCycleCORBA
 241     lcc = LifeCycleCORBA.LifeCycleCORBA(clt.orb)
 242     import HXX2SALOME_GENERIC_CLASS_NAME_ORB
 243     hello = lcc.FindOrLoadComponent("FactoryServer", "HXX2SALOME_GENERIC_CLASS_NAME")
 244     return hello
 245
 246 # -----------------------------------------------------------------------------
 247 #
 248 # Fonctions helper pour ajouter des variables d'environnement
 249 #
 250
 251 def add_path(directory):
 252     os.environ["PATH"]=directory + ":" + os.environ["PATH"]
 253
 254 def add_ld_library_path(directory):
 255     os.environ["LD_LIBRARY_PATH"]=directory + ":" + os.environ["LD_LIBRARY_PATH"]
 256
 257 def add_python_path(directory):
 258     os.environ["PYTHONPATH"]=directory + ":" + os.environ["PYTHONPATH"]
 259     sys.path[:0]=[directory]
 260
 261 # -----------------------------------------------------------------------------
 262 #
 263 # initialisation des variables d'environnement
 264 #
 265
 266 python_version="python%d.%d" % sys.version_info[0:2]
 267
 268 #
 269 # Ajout du chemin d'acces aux executables de KERNEL dans le PATH
 270 #
 271
 272 add_path(os.path.join(kernel_root_dir,"bin","salome"))
 273 #print "PATH=",os.environ["PATH"]
 274
 275 #
 276 # Ajout des modules dans le LD_LIBRARY_PATH
 277 #
 278 for module in liste_modules:
 279     module_root_dir=modules_root_dir[module]
 280     add_ld_library_path(os.path.join(module_root_dir,"lib","salome"))
 281 #print "LD_LIBRARY_PATH=",os.environ["LD_LIBRARY_PATH"]
 282
 283 #
 284 # Ajout des modules dans le PYTHONPATH (KERNEL prioritaire, donc en dernier)
 285 #
 286
 287 liste_modules_reverse=liste_modules[:]
 288 liste_modules_reverse.reverse()
 289 #print liste_modules
 290 #print liste_modules_reverse
 291 for module in liste_modules_reverse:
 292     module_root_dir=modules_root_dir[module]
 293     add_python_path(os.path.join(module_root_dir,"bin","salome"))
 294     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome"))
 295     add_python_path(os.path.join(module_root_dir,"lib","salome"))
 296     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome","shared_modules"))
 297
 298 #print "PYTHONPATH=",sys.path
 299
 300 import orbmodule
 301
 302 #
 303 # -----------------------------------------------------------------------------
 304 #
 305
 306 def startGUI():
 307     import SALOME
 308     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 309
 310     #
 311     # Activation du GUI de Session Server
 312     #
 313
 314     session.GetInterface()
 315
 316 #
 317 # -----------------------------------------------------------------------------
 318 #
 319
 320 def startSalome():
 321
 322     #
 323     # Lancement Session Loader
 324     #
 325     SessionLoader().run()
 326
 327     #
 328     # Initialisation ORB et Naming Service
 329     #
 330     clt=orbmodule.client()
 331
 332     # (non obligatoire) Lancement Logger Server et attente de sa
 333     #  disponibilite dans le naming service
 334     #
 335     if with_logger:
 336         LoggerServer().run()
 337         clt.waitLogger("Logger")
 338
 339     #
 340     # Lancement Registry Server
 341     #
 342     RegistryServer().run()
 343
 344     #
 345     # Attente de la disponibilit?? du Registry dans le Naming Service
 346     #
 347     clt.waitNS("/Registry")
 348
 349     #
 350     # Lancement Catalog Server
 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     import SALOME_ModuleCatalog
 360     clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 361
 362     #
 363     # Lancement SalomeDS Server
 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     clt.waitNS("/myStudyManager")
 378
 379     #
 380     # Lancement Session Server
 381     #
 382     SessionServer().run()
 383
 384     #
 385     # Attente de la disponibilit?? du Session Server dans le Naming Service
 386     #
 387     import SALOME
 388     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 389
 390     #
 391     # Lancement containers
 392     #
 393     theComputer = os.getenv("HOSTNAME")
 394     theComputer = theComputer.split('.')[0]
 395
 396     #
 397     # Lancement Container C++ local
 398     #
 399     if with_container_cpp:
 400         ContainerCPPServer().run()
 401         #
 402         # Attente de la disponibilit?? du Container C++ local
 403         # dans le Naming Service
 404         #
 405         clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 406     #
 407     # Lancement Container Python local
 408     #
 409     if with_container_python:
 410         ContainerPYServer().run()
 411         #
 412         # Attente de la disponibilit?? du Container Python local
 413         #  dans le Naming Service
 414         #
 415         clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 416
 417     if with_container_superv:
 418         #
 419         # Lancement Container Supervision local
 420         #
 421         ContainerSUPERVServer().run()
 422         #
 423         # Attente de la disponibilit?? du Container Supervision local
 424         # dans le Naming Service
 425         #
 426         clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 427     #
 428     # Activation du GUI de Session Server
 429     #
 430     #session.GetInterface()
 431
 432     end_time = os.times()
 433     print()
 434     print("Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4]))
 435
 436     return clt
 437
 438 #
 439 # -----------------------------------------------------------------------------
 440 #
 441
 442 if __name__ == "__main__":
 443     clt=None
 444     try:
 445         clt = startSalome()
 446     except:
 447         print()
 448         print()
 449         print("--- erreur au lancement Salome ---")
 450
 451     #print process_id
 452
 453
 454     filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
 455     #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 456
 457     fpid=open(filedict, 'w')
 458     pickle.dump(process_id,fpid)
 459     fpid.close()
 460
 461     print("""
 462
 463  Sauvegarde du dictionnaire des process dans , %s
 464  Pour tuer les process SALOME, executer : python killSalome.py depuis
 465  une console, ou bien killSalome() depuis le present interpreteur,
 466  s'il n'est pas ferm??.
 467
 468  runSalome, avec l'option --killall, commence par tuer les process restants
 469  d'une execution pr??c??dente.
 470
 471  Pour lancer uniquement le GUI, executer startGUI() depuis le present interpreteur,
 472  s'il n'est pas ferm??.
 473
 474  """ % filedict)
 475
 476     #
 477     #  Impression arborescence Naming Service
 478     #
 479
 480     if clt != None:
 481         print()
 482         print(" --- registered objects tree in Naming Service ---")
 483         clt.showNS()
 484         session=clt.waitNS("/Kernel/Session")
 485         catalog=clt.waitNS("/Kernel/ModulCatalog")
 486         import socket
 487         container =  clt.waitNS("/Containers/" + socket.gethostname().split('.')[0] + "/FactoryServerPy")
 488
 489     if os.path.isfile("~/.salome/pystartup"):
 490         f=open(os.path.expanduser("~/.salome/pystartup"),'w')
 491         PYTHONSTARTUP=f.read()
 492         f.close()
 493     else:
 494         PYTHONSTARTUP="""
 495   # Add auto-completion and a stored history file of commands to your Python
 496   # interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
 497   # bound to the TAB key by default (you can change it - see readline docs).
 498   #
 499   # Store the history in ~/.salome/pyhistory,
 500   #
 501   import atexit
 502   import os
 503   import readline
 504   import rlcompleter
 505   readline.parse_and_bind('tab: complete')
 506
 507   historyPath = os.path.expanduser("~/.salome/pyhistory")
 508
 509   def save_history(historyPath=historyPath):
 510       import readline
 511       readline.write_history_file(historyPath)
 512
 513   if os.path.exists(historyPath):
 514       readline.read_history_file(historyPath)
 515
 516   atexit.register(save_history)
 517   del os, atexit, readline, rlcompleter, save_history, historyPath
 518   """
 519         f=open(os.path.expanduser("~/.salome/pystartup"),'w')
 520         f.write(PYTHONSTARTUP)
 521         f.close()
 522
 523     exec(PYTHONSTARTUP, {})