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

   1 #!/usr/bin/env python3
   2 # Copyright (C) 2006-2020  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     home_dir=os.path.expanduser("~")
 184     SCMD2=['-personal',os.path.join(home_dir,'Salome', 'resources', 'CatalogModulePersonnel.xml')]
 185
 186     def setpath(self,liste_modules):
 187         cata_path=[]
 188         for module in liste_modules:
 189             module_root_dir=modules_root_dir[module]
 190             module_cata=module+"Catalog.xml"
 191             print("   ", module_cata)
 192             cata_path.extend(glob.glob(os.path.join(module_root_dir,"share","salome","resources",module_cata)))
 193         self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 194
 195 class SalomeDSServer(Server):
 196     CMD=['SALOMEDS_Server']
 197
 198 class RegistryServer(Server):
 199     CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 200
 201 class ContainerCPPServer(Server):
 202     CMD=['SALOME_Container','FactoryServer','-ORBInitRef','NameService=corbaname::localhost']
 203
 204 class ContainerPYServer(Server):
 205     CMD=['SALOME_ContainerPy.py','FactoryServerPy','-ORBInitRef','NameService=corbaname::localhost']
 206
 207 class ContainerSUPERVServer(Server):
 208     CMD=['SALOME_Container','SuperVisionContainer','-ORBInitRef','NameService=corbaname::localhost']
 209
 210 class LoggerServer(Server):
 211     CMD=['SALOME_Logger_Server', 'logger.log']
 212
 213 class SessionLoader(Server):
 214     CMD=['SALOME_Session_Loader']
 215     if with_container_cpp:
 216         CMD=CMD+['CPP']
 217     if with_container_python:
 218         CMD=CMD+['PY']
 219     if with_container_superv:
 220         CMD=CMD+['SUPERV']
 221     if with_gui:
 222         CMD=CMD+['GUI']
 223
 224 class SessionServer(Server):
 225     CMD=['SALOME_Session_Server']
 226
 227 class NotifyServer(Server):
 228     CMD=['notifd','-c','${KERNEL_ROOT_DIR}/share/salome/resources/channel.cfg -DFactoryIORFileName=/tmp/${LOGNAME}_rdifact.ior -DChannelIORFileName=/tmp/${LOGNAME}_rdichan.ior']
 229
 230 # -----------------------------------------------------------------------------
 231 #
 232 # Fonction de test
 233 #
 234
 235 def test(clt):
 236     """
 237          Test function that creates an instance of HXX2SALOME_GENERIC_CLASS_NAME component
 238          usage : hello=test(clt)
 239     """
 240     # create an LifeCycleCORBA instance
 241     import LifeCycleCORBA
 242     lcc = LifeCycleCORBA.LifeCycleCORBA(clt.orb)
 243     import HXX2SALOME_GENERIC_CLASS_NAME_ORB
 244     hello = lcc.FindOrLoadComponent("FactoryServer", "HXX2SALOME_GENERIC_CLASS_NAME")
 245     return hello
 246
 247 # -----------------------------------------------------------------------------
 248 #
 249 # Fonctions helper pour ajouter des variables d'environnement
 250 #
 251
 252 def add_path(directory):
 253     os.environ["PATH"]=directory + ":" + os.environ["PATH"]
 254
 255 def add_ld_library_path(directory):
 256     os.environ["LD_LIBRARY_PATH"]=directory + ":" + os.environ["LD_LIBRARY_PATH"]
 257
 258 def add_python_path(directory):
 259     os.environ["PYTHONPATH"]=directory + ":" + os.environ["PYTHONPATH"]
 260     sys.path[:0]=[directory]
 261
 262 # -----------------------------------------------------------------------------
 263 #
 264 # initialisation des variables d'environnement
 265 #
 266
 267 python_version="python%d.%d" % sys.version_info[0:2]
 268
 269 #
 270 # Ajout du chemin d'acces aux executables de KERNEL dans le PATH
 271 #
 272
 273 add_path(os.path.join(kernel_root_dir,"bin","salome"))
 274 #print "PATH=",os.environ["PATH"]
 275
 276 #
 277 # Ajout des modules dans le LD_LIBRARY_PATH
 278 #
 279 for module in liste_modules:
 280     module_root_dir=modules_root_dir[module]
 281     add_ld_library_path(os.path.join(module_root_dir,"lib","salome"))
 282 #print "LD_LIBRARY_PATH=",os.environ["LD_LIBRARY_PATH"]
 283
 284 #
 285 # Ajout des modules dans le PYTHONPATH (KERNEL prioritaire, donc en dernier)
 286 #
 287
 288 liste_modules_reverse=liste_modules[:]
 289 liste_modules_reverse.reverse()
 290 #print liste_modules
 291 #print liste_modules_reverse
 292 for module in liste_modules_reverse:
 293     module_root_dir=modules_root_dir[module]
 294     add_python_path(os.path.join(module_root_dir,"bin","salome"))
 295     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome"))
 296     add_python_path(os.path.join(module_root_dir,"lib","salome"))
 297     add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome","shared_modules"))
 298
 299 #print "PYTHONPATH=",sys.path
 300
 301 import orbmodule
 302
 303 #
 304 # -----------------------------------------------------------------------------
 305 #
 306
 307 def startGUI():
 308     import SALOME
 309     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 310
 311     #
 312     # Activation du GUI de Session Server
 313     #
 314
 315     session.GetInterface()
 316
 317 #
 318 # -----------------------------------------------------------------------------
 319 #
 320
 321 def startSalome():
 322
 323     #
 324     # Lancement Session Loader
 325     #
 326     SessionLoader().run()
 327
 328     #
 329     # Initialisation ORB et Naming Service
 330     #
 331     clt=orbmodule.client()
 332
 333     # (non obligatoire) Lancement Logger Server et attente de sa
 334     #  disponibilite dans le naming service
 335     #
 336     if with_logger:
 337         LoggerServer().run()
 338         clt.waitLogger("Logger")
 339
 340     #
 341     # Lancement Registry Server
 342     #
 343     RegistryServer().run()
 344
 345     #
 346     # Attente de la disponibilit?? du Registry dans le Naming Service
 347     #
 348     clt.waitNS("/Registry")
 349
 350     #
 351     # Lancement Catalog Server
 352     #
 353     cataServer=CatalogServer()
 354     cataServer.setpath(liste_modules)
 355     cataServer.run()
 356
 357     #
 358     # Attente de la disponibilit?? du Catalog Server dans le Naming Service
 359     #
 360     import SALOME_ModuleCatalog
 361     clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 362
 363     #
 364     # Lancement SalomeDS Server
 365     #
 366     os.environ["CSF_PluginDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
 367     os.environ["CSF_SALOMEDS_ResourcesDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
 368     SalomeDSServer().run()
 369
 370     if "GEOM" in liste_modules:
 371         print("GEOM OCAF Resources")
 372         os.environ["CSF_GEOMDS_ResourcesDefaults"]=os.path.join(modules_root_dir["GEOM"],"share","salome","resources")
 373
 374
 375     #
 376     # Attente de la disponibilit?? du SalomeDS dans le Naming Service
 377     #
 378     clt.waitNS("/myStudyManager")
 379
 380     #
 381     # Lancement Session Server
 382     #
 383     SessionServer().run()
 384
 385     #
 386     # Attente de la disponibilit?? du Session Server dans le Naming Service
 387     #
 388     import SALOME
 389     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 390
 391     #
 392     # Lancement containers
 393     #
 394     theComputer = os.getenv("HOSTNAME")
 395     theComputer = theComputer.split('.')[0]
 396
 397     #
 398     # Lancement Container C++ local
 399     #
 400     if with_container_cpp:
 401         ContainerCPPServer().run()
 402         #
 403         # Attente de la disponibilit?? du Container C++ local
 404         # dans le Naming Service
 405         #
 406         clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 407     #
 408     # Lancement Container Python local
 409     #
 410     if with_container_python:
 411         ContainerPYServer().run()
 412         #
 413         # Attente de la disponibilit?? du Container Python local
 414         #  dans le Naming Service
 415         #
 416         clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 417
 418     if with_container_superv:
 419         #
 420         # Lancement Container Supervision local
 421         #
 422         ContainerSUPERVServer().run()
 423         #
 424         # Attente de la disponibilit?? du Container Supervision local
 425         # dans le Naming Service
 426         #
 427         clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 428     #
 429     # Activation du GUI de Session Server
 430     #
 431     #session.GetInterface()
 432
 433     end_time = os.times()
 434     print()
 435     print("Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4]))
 436
 437     return clt
 438
 439 #
 440 # -----------------------------------------------------------------------------
 441 #
 442
 443 if __name__ == "__main__":
 444     clt=None
 445     try:
 446         clt = startSalome()
 447     except:
 448         print()
 449         print()
 450         print("--- erreur au lancement Salome ---")
 451
 452     #print process_id
 453
 454
 455     filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
 456     #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 457
 458     fpid=open(filedict, 'w')
 459     pickle.dump(process_id,fpid)
 460     fpid.close()
 461
 462     print("""
 463
 464  Sauvegarde du dictionnaire des process dans , %s
 465  Pour tuer les process SALOME, executer : python killSalome.py depuis
 466  une console, ou bien killSalome() depuis le present interpreteur,
 467  s'il n'est pas ferm??.
 468
 469  runSalome, avec l'option --killall, commence par tuer les process restants
 470  d'une execution pr??c??dente.
 471
 472  Pour lancer uniquement le GUI, executer startGUI() depuis le present interpreteur,
 473  s'il n'est pas ferm??.
 474
 475  """ % filedict)
 476
 477     #
 478     #  Impression arborescence Naming Service
 479     #
 480
 481     if clt != None:
 482         print()
 483         print(" --- registered objects tree in Naming Service ---")
 484         clt.showNS()
 485         session=clt.waitNS("/Kernel/Session")
 486         catalog=clt.waitNS("/Kernel/ModulCatalog")
 487         import socket
 488         container =  clt.waitNS("/Containers/" + socket.gethostname().split('.')[0] + "/FactoryServerPy")
 489
 490     if os.path.isfile("~/.salome/pystartup"):
 491         f=open(os.path.expanduser("~/.salome/pystartup"),'w')
 492         PYTHONSTARTUP=f.read()
 493         f.close()
 494     else:
 495         PYTHONSTARTUP="""
 496   # Add auto-completion and a stored history file of commands to your Python
 497   # interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
 498   # bound to the TAB key by default (you can change it - see readline docs).
 499   #
 500   # Store the history in ~/.salome/pyhistory,
 501   #
 502   import atexit
 503   import os
 504   import readline
 505   import rlcompleter
 506   readline.parse_and_bind('tab: complete')
 507
 508   historyPath = os.path.expanduser("~/.salome/pyhistory")
 509
 510   def save_history(historyPath=historyPath):
 511       import readline
 512       readline.write_history_file(historyPath)
 513
 514   if os.path.exists(historyPath):
 515       readline.read_history_file(historyPath)
 516
 517   atexit.register(save_history)
 518   del os, atexit, readline, rlcompleter, save_history, historyPath
 519   """
 520         f=open(os.path.expanduser("~/.salome/pystartup"),'w')
 521         f.write(PYTHONSTARTUP)
 522         f.close()
 523
 524     exec(PYTHONSTARTUP, {})