bin/runSalome.py

   1 #!/usr/bin/env python3
   2 #  -*- coding: iso-8859-1 -*-
   3 # Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
   4 #
   5 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   6 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   7 #
   8 # This library is free software; you can redistribute it and/or
   9 # modify it under the terms of the GNU Lesser General Public
  10 # License as published by the Free Software Foundation; either
  11 # version 2.1 of the License, or (at your option) any later version.
  12 #
  13 # This library is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 # Lesser General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU Lesser General Public
  19 # License along with this library; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 #
  22 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  23 #
  24
  25 ## @package runSalome
  26 # \brief Module that provides services to launch SALOME
  27 #
  28
  29 import sys, os, string, glob, time, pickle, re
  30 import orbmodule
  31 import setenv
  32 from launchConfigureParser import verbose
  33 from server import process_id, Server
  34 import json
  35 import subprocess
  36 from salomeContextUtils import ScriptAndArgsObjectEncoder
  37
  38 # -----------------------------------------------------------------------------
  39
  40 from killSalome import killAllPorts
  41
  42 def killLocalPort():
  43     """
  44     kill servers from a previous SALOME execution, if needed,
  45     on the CORBA port given in args of runSalome
  46     """
  47
  48     from killSalomeWithPort import killMyPort
  49     my_port=str(args['port'])
  50     try:
  51         killMyPort(my_port)
  52     except:
  53         print("problem in killLocalPort()")
  54         pass
  55     pass
  56
  57 def givenPortKill(port):
  58     """
  59     kill servers from a previous SALOME execution, if needed,
  60     on the same CORBA port
  61     """
  62
  63     from killSalomeWithPort import killMyPort
  64     my_port=port
  65     try:
  66         killMyPort(my_port)
  67     except:
  68         print("problem in LocalPortKill(), killMyPort(%s)"%port)
  69         pass
  70     pass
  71
  72 def kill_salome(args):
  73     """
  74     Kill servers from previous SALOME executions, if needed;
  75     depending on args 'killall' or 'portkill', kill all executions,
  76     or only execution on the same CORBA port
  77     """
  78
  79     if args['killall']:
  80         killAllPorts()
  81     elif args['portkill']:
  82         givenPortKill(str(args['port']))
  83
  84 # -----------------------------------------------------------------------------
  85 #
  86 # Class definitions to launch CORBA Servers
  87 #
  88
  89 class InterpServer(Server):
  90     def __init__(self,args):
  91         self.args=args
  92         if sys.platform == "win32":
  93           self.CMD=['cmd', '/c', 'start cmd.exe', '/K', 'python']
  94         elif sys.platform == "darwin":
  95           env_ld_library_path=['env', 'DYLD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  96           self.CMD=['xterm', '-e'] + env_ld_library_path + ['python']
  97         else:
  98           env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  99           self.CMD=['xterm', '-e'] + env_ld_library_path + ['python']
 100
 101     def run(self):
 102         global process_id
 103         command = self.CMD
 104         print("INTERPSERVER::command = ", command)
 105         import subprocess
 106         pid = subprocess.Popen(command).pid
 107         process_id[pid]=self.CMD
 108         self.PID = pid
 109
 110 # ---
 111
 112 def get_cata_path(list_modules,modules_root_dir):
 113     """Build a list of catalog paths (cata_path) to initialize the ModuleCatalog server
 114     """
 115     modules_cata={}
 116     cata_path=[]
 117
 118     for module in list_modules:
 119         if module in modules_root_dir:
 120             module_root_dir=modules_root_dir[module]
 121             module_cata=module+"Catalog.xml"
 122             cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources",module.lower(), module_cata)
 123
 124             if os.path.exists(cata_file):
 125                 cata_path.append(cata_file)
 126                 modules_cata[module]=cata_file
 127             else:
 128                 cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources", module_cata)
 129                 if os.path.exists(cata_file):
 130                     cata_path.append(cata_file)
 131                     modules_cata[module]=cata_file
 132
 133     for path in os.getenv("SALOME_CATALOGS_PATH","").split(os.pathsep):
 134         if os.path.exists(path):
 135             for cata_file in glob.glob(os.path.join(path,"*Catalog.xml")):
 136                 module_name= os.path.basename(cata_file)[:-11]
 137                 if module_name not in modules_cata:
 138                     cata_path.append(cata_file)
 139                     modules_cata[module_name]=cata_file
 140
 141     return cata_path
 142
 143 class CatalogServer(Server):
 144     def __init__(self,args):
 145         self.args=args
 146         self.initArgs()
 147         self.SCMD1=['SALOME_ModuleCatalog_Server']
 148         if 'launcher' in self.args:
 149             pos = args['launcher'].find(":")
 150             if pos != -1:
 151               self.SCMD1+=['-ORBInitRef']
 152               machine = args['launcher'][0:pos]
 153               port = args['launcher'][pos+1:]
 154               self.SCMD1+=["NameService=corbaname::" + machine + ":" + port]
 155         self.SCMD1+=['-common']
 156         self.SCMD2=[]
 157         home_dir=os.getenv('HOME')
 158         if home_dir is not None:
 159             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 160
 161     def setpath(self,modules_list,modules_root_dir):
 162         list_modules = modules_list[:]
 163         list_modules.reverse()
 164         if self.args["gui"] :
 165             list_modules = ["KERNEL", "GUI"] + list_modules
 166         else :
 167             list_modules = ["KERNEL"] + list_modules
 168
 169         cata_path=get_cata_path(list_modules,modules_root_dir)
 170
 171         self.CMD=self.SCMD1 + ['"' + '"::"'.join(cata_path) + '"'] + self.SCMD2
 172
 173 # ---
 174
 175 class SalomeDSServer(Server):
 176     def __init__(self,args):
 177         self.args=args
 178         self.initArgs()
 179         self.CMD=['SALOMEDS_Server']
 180         if 'launcher' in self.args:
 181             pos = args['launcher'].find(":")
 182             if pos != -1:
 183               self.CMD+=['-ORBInitRef']
 184               machine = args['launcher'][0:pos]
 185               port = args['launcher'][pos+1:]
 186               self.CMD+=["NameService=corbaname::" + machine + ":" + port]
 187
 188 # ---
 189
 190 class ConnectionManagerServer(Server):
 191     def __init__(self,args):
 192         self.args=args
 193         self.initArgs()
 194         self.CMD=['SALOME_ConnectionManagerServer']
 195         if 'launcher' in self.args:
 196             pos = args['launcher'].find(":")
 197             if pos != -1:
 198               self.CMD+=['-ORBInitRef']
 199               machine = args['launcher'][0:pos]
 200               port = args['launcher'][pos+1:]
 201               self.CMD+=["NameService=corbaname::" + machine + ":" + port]
 202
 203
 204 # ---
 205
 206 class RegistryServer(Server):
 207     def __init__(self,args):
 208         self.args=args
 209         self.initArgs()
 210         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 211         if 'launcher' in self.args:
 212             pos = args['launcher'].find(":")
 213             if pos != -1:
 214               self.CMD+=['-ORBInitRef']
 215               machine = args['launcher'][0:pos]
 216               port = args['launcher'][pos+1:]
 217               self.CMD+=["NameService=corbaname::" + machine + ":" + port]
 218
 219 # ---
 220
 221 class ContainerCPPServer(Server):
 222     def __init__(self,args,with_gui=False):
 223         self.args=args
 224         self.initArgs()
 225         self.CMD=['SALOME_Container']
 226         if 'launcher' in self.args:
 227             pos = args['launcher'].find(":")
 228             if pos != -1:
 229               self.CMD+=['-ORBInitRef']
 230               machine = args['launcher'][0:pos]
 231               port = args['launcher'][pos+1:]
 232               self.CMD+=["NameService=corbaname::" + machine + ":" + port]
 233         self.CMD+=['FactoryServer']
 234         if not with_gui and self.args["valgrind_session"]:
 235             l = ["valgrind"]
 236             val = os.getenv("VALGRIND_OPTIONS")
 237             if val:
 238                 l += val.split()
 239                 pass
 240             self.CMD = l + self.CMD
 241             pass
 242
 243 # ---
 244
 245 class LoggerServer(Server):
 246     def __init__(self,args):
 247         self.args=args
 248         self.initArgs()
 249         from salome_utils import generateFileName, getLogDir
 250         logfile = generateFileName( getLogDir(),
 251                                     prefix="logger",
 252                                     extension="log",
 253                                     with_username=True,
 254                                     with_hostname=True,
 255                                     with_port=True)
 256         print("===========================================================")
 257         print("Logger server: put log to the file:")
 258         print(logfile)
 259         print("===========================================================")
 260         self.CMD=['SALOME_Logger_Server', logfile]
 261         pass
 262     pass # end of LoggerServer class
 263
 264 # ---
 265
 266 class SessionServer(Server):
 267     def __init__(self,args,modules_list,modules_root_dir):
 268         self.args = args.copy()
 269         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 270         #self.args['xterm']=0
 271         #
 272         self.initArgs()
 273         self.SCMD1=['SALOME_Session_Server']
 274         self.SCMD2=[]
 275         if 'launcher' in self.args:
 276             pos = args['launcher'].find(":")
 277             if pos != -1:
 278               self.SCMD1+=['-ORBInitRef']
 279               machine = args['launcher'][0:pos]
 280               port = args['launcher'][pos+1:]
 281               self.SCMD1+=["NameService=corbaname::" + machine + ":" + port]
 282         if 'registry' in self.args['embedded']:
 283             self.SCMD1+=['--with','Registry',
 284                          '(','--salome_session','theSession',')']
 285         if 'moduleCatalog' in self.args['embedded']:
 286             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 287             home_dir=os.getenv('HOME')
 288             if home_dir is not None:
 289                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 290             self.SCMD2+=[')']
 291         if 'study' in self.args['embedded']:
 292             self.SCMD2+=['--with','SALOMEDS','(',')']
 293         if 'cppContainer' in self.args['embedded']:
 294             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 295         if 'SalomeAppEngine' in self.args['embedded']:
 296             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 297
 298         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 299             self.SCMD2+=['CPP']
 300         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 301             raise Exception('Python containers no longer supported')
 302         if self.args['gui']:
 303             session_gui = True
 304             if 'session_gui' in self.args:
 305                 session_gui = self.args['session_gui']
 306             if session_gui:
 307                 self.SCMD2+=['GUI']
 308                 if self.args['splash']:
 309                     self.SCMD2+=['SPLASH']
 310                     pass
 311                 if self.args['study_hdf'] is not None:
 312                     self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
 313                     pass
 314                 pass
 315                 if 'pyscript' in self.args and len(self.args['pyscript']) > 0:
 316                     msg = json.dumps(self.args['pyscript'], cls=ScriptAndArgsObjectEncoder)
 317                     self.SCMD2+=['--pyscript=%s'%(msg)]
 318                     pass
 319                 pass
 320             pass
 321         if self.args['noexcepthandler']:
 322             self.SCMD2+=['noexcepthandler']
 323         if 'user_config' in self.args:
 324             self.SCMD2+=['--resources=%s'%self.args['user_config']]
 325         if 'modules' in self.args:
 326             list_modules = []
 327             #keep only modules with GUI
 328             for m in modules_list:
 329               if m not in modules_root_dir:
 330                 list_modules.insert(0,m)
 331               else:
 332                 fr1 = os.path.join(modules_root_dir[m],"share","salome","resources",m.lower(),"SalomeApp.xml")
 333                 fr2 = os.path.join(modules_root_dir[m],"share","salome","resources","SalomeApp.xml")
 334                 if os.path.exists(fr1) or os.path.exists(fr2):
 335                   list_modules.insert(0,m)
 336             list_modules.reverse()
 337             self.SCMD2+=['--modules (%s)' % ":".join(list_modules)]
 338             pass
 339         if 'language' in self.args:
 340             self.SCMD2+=['--language=%s' % self.args['language']]
 341         pass
 342
 343     def setpath(self,modules_list,modules_root_dir):
 344         list_modules = modules_list[:]
 345         list_modules.reverse()
 346         if self.args["gui"] :
 347             list_modules = ["KERNEL", "GUI"] + list_modules
 348         else :
 349             list_modules = ["KERNEL"] + list_modules
 350
 351         cata_path=get_cata_path(list_modules,modules_root_dir)
 352
 353         if ("gui" in self.args) & ('moduleCatalog' in self.args['embedded']):
 354             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 355             self.CMD=self.SCMD1 + ['"' + '"::"'.join(cata_path) + '"'] + self.SCMD2
 356         else:
 357             self.CMD=self.SCMD1 + self.SCMD2
 358         if 'test' in self.args:
 359             self.CMD+=['-test'] + self.args['test']
 360         elif 'play' in self.args:
 361             self.CMD+=['-play'] + self.args['play']
 362
 363         if self.args["gdb_session"] or self.args["ddd_session"]:
 364             f = open(".gdbinit4salome", "w")
 365             f.write("set args ")
 366             args = " ".join(self.CMD[1:])
 367             args = args.replace("(", "\(")
 368             args = args.replace(")", "\)")
 369             f.write(args)
 370             f.write("\n")
 371             f.close()
 372             if self.args["ddd_session"]:
 373                 self.CMD = ["ddd", "--command=.gdbinit4salome", self.CMD[0]]
 374             elif self.args["gdb_session"]:
 375                 self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
 376                 pass
 377             pass
 378
 379         if self.args["valgrind_session"]:
 380             l = ["valgrind"]
 381             val = os.getenv("VALGRIND_OPTIONS")
 382             if val:
 383                 l += val.split()
 384                 pass
 385             self.CMD = l + self.CMD
 386             pass
 387
 388 # ---
 389
 390 class LauncherServer(Server):
 391     def __init__(self,args):
 392         self.args=args
 393         self.initArgs()
 394         self.SCMD1=['SALOME_LauncherServer']
 395         self.SCMD2=[]
 396         if args["gui"] :
 397             if 'registry' in self.args['embedded']:
 398                 self.SCMD1+=['--with','Registry',
 399                              '(','--salome_session','theSession',')']
 400             if 'moduleCatalog' in self.args['embedded']:
 401                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 402                 self.SCMD2+=['-personal',
 403                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 404             if 'study' in self.args['embedded']:
 405                 self.SCMD2+=['--with','SALOMEDS','(',')']
 406             if 'cppContainer' in self.args['embedded']:
 407                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 408
 409     def setpath(self,modules_list,modules_root_dir):
 410         list_modules = modules_list[:]
 411         list_modules.reverse()
 412         if self.args["gui"] :
 413             list_modules = ["KERNEL", "GUI"] + list_modules
 414         else :
 415             list_modules = ["KERNEL"] + list_modules
 416
 417         cata_path=get_cata_path(list_modules,modules_root_dir)
 418
 419         if ("gui" in self.args) & ('moduleCatalog' in self.args['embedded']):
 420             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 421             self.CMD=self.SCMD1 + ['"' + '"::"'.join(cata_path) + '"'] + self.SCMD2
 422         else:
 423             self.CMD=self.SCMD1 + self.SCMD2
 424 #
 425 # -----------------------------------------------------------------------------
 426
 427 def startGUI(clt):
 428     """Salome Session Graphic User Interface activation"""
 429     import Engines
 430     import SALOME
 431     import SALOMEDS
 432     import SALOME_ModuleCatalog
 433     import SALOME_Session_idl
 434     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 435     session.GetInterface()
 436
 437 # -----------------------------------------------------------------------------
 438
 439 def startSalome(args, modules_list, modules_root_dir):
 440     """Launch all SALOME servers requested by args"""
 441     init_time = os.times()
 442
 443     if verbose(): print("startSalome ", args)
 444
 445     #
 446     # Set server launch command
 447     #
 448     if 'server_launch_mode' in args:
 449         Server.set_server_launch_mode(args['server_launch_mode'])
 450
 451     #
 452     # Wake up session option
 453     #
 454     if args['wake_up_session']:
 455         if "OMNIORB_CONFIG" not in os.environ:
 456             from salome_utils import generateFileName
 457             omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
 458             kwargs={}
 459             if omniorbUserPath is not None:
 460                 kwargs["with_username"]=True
 461
 462             last_running_config = generateFileName(omniorbUserPath, prefix="omniORB",
 463                                                    suffix="last",
 464                                                    extension="cfg",
 465                                                    hidden=True,
 466                                                    **kwargs)
 467             os.environ['OMNIORB_CONFIG'] = last_running_config
 468             pass
 469         pass
 470
 471     #
 472     # Initialisation ORB and Naming Service
 473     #
 474
 475     clt=orbmodule.client(args)
 476
 477     #
 478     # Wake up session option
 479     #
 480     if args['wake_up_session']:
 481         import Engines
 482         import SALOME
 483         import SALOMEDS
 484         import SALOME_ModuleCatalog
 485         import SALOME_Session_idl
 486         session = clt.waitNS("/Kernel/Session",SALOME.Session)
 487         status = session.GetStatSession()
 488         if status.activeGUI:
 489             from salome_utils import getPortNumber
 490             port = getPortNumber()
 491             msg  = "Warning :"
 492             msg += "\n"
 493             msg += "Session GUI for port number %s is already active."%(port)
 494             msg += "\n"
 495             msg += "If you which to wake up another session,"
 496             msg += "\n"
 497             msg += "please use variable OMNIORB_CONFIG"
 498             msg += "\n"
 499             msg += "to get the correct session object in naming service."
 500             sys.stdout.write(msg+"\n")
 501             sys.stdout.flush()
 502             return clt
 503         session.GetInterface()
 504         args["session_object"] = session
 505         return clt
 506
 507     # Launch Logger Server (optional)
 508     # and wait until it is registered in naming service
 509     #
 510
 511     if args['logger']:
 512         myServer=LoggerServer(args)
 513         myServer.run()
 514         clt.waitLogger("Logger")
 515
 516     # Launch  Session Server (to show splash ASAP)
 517     #
 518
 519     if args["gui"] and not args['launcher_only']:
 520         mySessionServ = SessionServer(args,args['modules'],modules_root_dir)
 521         mySessionServ.setpath(modules_list,modules_root_dir)
 522         mySessionServ.run()
 523
 524     #
 525     # Launch Registry Server,
 526     # and wait until it is registered in naming service
 527     #
 528
 529     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 530         myServer=RegistryServer(args)
 531         myServer.run()
 532         if sys.platform == "win32":
 533           clt.waitNS("/Registry")
 534         else:
 535           clt.waitNSPID("/Registry",myServer.PID)
 536
 537     #
 538     # Launch Catalog Server,
 539     # and wait until it is registered in naming service
 540     #
 541
 542     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 543         cataServer=CatalogServer(args)
 544         cataServer.setpath(modules_list,modules_root_dir)
 545         cataServer.run()
 546         import SALOME_ModuleCatalog
 547         if sys.platform == "win32":
 548           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 549         else:
 550           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 551
 552     #
 553     # Launch SalomeDS Server,
 554     # and wait until it is registered in naming service
 555     #
 556
 557     # print("ARGS = ",args)
 558     if ('study' not in args['embedded']) | (args["gui"] == 0):
 559         print("RunStudy")
 560         myServer=SalomeDSServer(args)
 561         myServer.run()
 562         if sys.platform == "win32":
 563           clt.waitNS("/Study")
 564         else:
 565           clt.waitNSPID("/Study",myServer.PID)
 566
 567     #
 568     # Launch LauncherServer
 569     #
 570
 571     if not 'launcher' in args:
 572       myCmServer = LauncherServer(args)
 573       myCmServer.setpath(modules_list,modules_root_dir)
 574       myCmServer.run()
 575
 576     #
 577     # Launch ConnectionManagerServer
 578     #
 579
 580     if not args['launcher_only']:
 581       myConnectionServer = ConnectionManagerServer(args)
 582       myConnectionServer.run()
 583
 584     from Utils_Identity import getShortHostName
 585
 586     if os.getenv("HOSTNAME") == None:
 587         if os.getenv("HOST") == None:
 588             os.environ["HOSTNAME"]=getShortHostName()
 589         else:
 590             os.environ["HOSTNAME"]=os.getenv("HOST")
 591
 592     theComputer = getShortHostName()
 593
 594     #
 595     # Launch local C++ Container (FactoryServer),
 596     # and wait until it is registered in naming service
 597     #
 598
 599     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 600         myServer=ContainerCPPServer(args, with_gui=args["gui"]!=0)
 601         myServer.run()
 602         if sys.platform == "win32":
 603           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 604         else:
 605           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 606
 607     if 'pyContainer' in args['standalone']:
 608         raise Exception('Python containers no longer supported')
 609
 610     #
 611     # Wait until Session Server is registered in naming service
 612     #
 613
 614     if args["gui"] and not args['launcher_only']:
 615 ##----------------
 616         import Engines
 617         import SALOME
 618         import SALOMEDS
 619         import SALOME_ModuleCatalog
 620         import SALOME_Session_idl
 621         if sys.platform == "win32":
 622           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 623         else:
 624           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 625         args["session_object"] = session
 626     end_time = os.times()
 627     if verbose(): print()
 628     print("Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 629                                                          - init_time[4]))
 630
 631     # ASV start GUI without Loader
 632     #if args['gui']:
 633     #    session.GetInterface()
 634
 635     #
 636     # additional external python interpreters
 637     #
 638     nbaddi=0
 639
 640     try:
 641         if 'interp' in args:
 642             nbaddi = args['interp']
 643     except:
 644         import traceback
 645         traceback.print_exc()
 646         print("-------------------------------------------------------------")
 647         print("-- to get an external python interpreter:runSalome --interp=1")
 648         print("-------------------------------------------------------------")
 649
 650     if verbose(): print("additional external python interpreters: ", nbaddi)
 651     if nbaddi:
 652         for i in range(nbaddi):
 653             print("i=",i)
 654             anInterp=InterpServer(args)
 655             anInterp.run()
 656
 657     # set PYTHONINSPECT variable (python interpreter in interactive mode)
 658     if args['pinter']:
 659         os.environ["PYTHONINSPECT"]="1"
 660         try:
 661             import readline
 662         except ImportError:
 663             pass
 664
 665     return clt
 666
 667 # -----------------------------------------------------------------------------
 668
 669 def useSalome(args, modules_list, modules_root_dir):
 670     """
 671     Launch all SALOME servers requested by args,
 672     save list of process, give info to user,
 673     show registered objects in Naming Service.
 674     """
 675     global process_id
 676
 677     clt=None
 678     try:
 679         clt = startSalome(args, modules_list, modules_root_dir)
 680     except:
 681         import traceback
 682         traceback.print_exc()
 683         print()
 684         print()
 685         print("--- Error during Salome launch ---")
 686
 687     # print(process_id)
 688
 689     from addToKillList import addToKillList
 690     from killSalomeWithPort import getPiDict
 691
 692     filedict = getPiDict(args['port'])
 693     for pid, cmd in list(process_id.items()):
 694         addToKillList(pid, cmd, args['port'])
 695         pass
 696
 697     if verbose(): print("""
 698     Saving of the dictionary of Salome processes in %s
 699     To kill SALOME processes from a console (kill all sessions from all ports):
 700       python killSalome.py
 701     To kill SALOME from the present interpreter, if it is not closed :
 702       killLocalPort()      --> kill this session
 703                                (use CORBA port from args of runSalome)
 704       givenPortKill(port)  --> kill a specific session with given CORBA port
 705       killAllPorts()       --> kill all sessions
 706
 707     runSalome, with --killall option, starts with killing
 708     the processes resulting from the previous execution.
 709     """%filedict)
 710
 711     #
 712     #  Print Naming Service directory list
 713     #
 714
 715     if clt != None:
 716         if verbose():
 717             print()
 718             print(" --- registered objects tree in Naming Service ---")
 719             clt.showNS()
 720             pass
 721
 722         if not args['gui'] or not args['session_gui']:
 723             if args['shutdown_servers']:
 724                 class __utils__(object):
 725                     def __init__(self, port):
 726                         self.port = port
 727                         import killSalomeWithPort
 728                         self.killSalomeWithPort = killSalomeWithPort
 729                         return
 730                     def __del__(self):
 731                         self.killSalomeWithPort.killMyPort(self.port)
 732                         return
 733                     pass
 734                 def func(s):
 735                     del s
 736                 import atexit
 737                 atexit.register(func, __utils__(args['port']))
 738                 pass
 739             pass
 740
 741         # run python scripts, passed as command line arguments
 742         toimport = []
 743         if 'gui' in args and 'session_gui' in args:
 744             if not args['gui'] or not args['session_gui']:
 745                 if 'study_hdf' in args:
 746                     toopen = args['study_hdf']
 747                     if toopen:
 748                         import salome
 749                         salome.salome_init(path=toopen)
 750                 if 'pyscript' in args:
 751                     toimport = args['pyscript']
 752         from salomeContextUtils import formatScriptsAndArgs
 753         command = formatScriptsAndArgs(toimport)
 754         if command:
 755             proc = subprocess.Popen(command, shell=True)
 756             addToKillList(proc.pid, command, args['port'])
 757             res = proc.wait()
 758             if res: sys.exit(1) # if there's an error when executing script, we should explicitly exit
 759
 760     return clt
 761
 762 def execScript(script_path):
 763     print('executing', script_path)
 764     sys.path.insert(0, os.path.realpath(os.path.dirname(script_path)))
 765     exec(compile(open(script_path).read(), script_path, 'exec'),globals())
 766     del sys.path[0]
 767
 768 # -----------------------------------------------------------------------------
 769
 770 def registerEnv(args, modules_list, modules_root_dir):
 771     """
 772     Register args, modules_list, modules_root_dir in a file
 773     for further use, when SALOME is launched embedded in an other application.
 774     """
 775     from salome_utils import getTmpDir
 776     fileEnv = getTmpDir()
 777     from salome_utils import getUserName
 778     fileEnv += getUserName() + "_" + str(args['port']) \
 779             + '_' + args['appname'].upper() + '_env'
 780     fenv=open(fileEnv,'w')
 781     pickle.dump((args, modules_list, modules_root_dir),fenv)
 782     fenv.close()
 783     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 784
 785 # -----------------------------------------------------------------------------
 786
 787 def no_main():
 788     """Salome Launch, when embedded in other application"""
 789     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 790     fenv=open(fileEnv,'r')
 791     args, modules_list, modules_root_dir = pickle.load(fenv)
 792     fenv.close()
 793     kill_salome(args)
 794     from searchFreePort import searchFreePort
 795     searchFreePort(args, 0)
 796     clt = useSalome(args, modules_list, modules_root_dir)
 797     return clt
 798
 799 # -----------------------------------------------------------------------------
 800
 801 def main(exeName=None):
 802     """Salome launch as a main application"""
 803
 804     # define folder to store omniorb config (initially in virtual application folder)
 805     try:
 806         from salomeContextUtils import setOmniOrbUserPath
 807         setOmniOrbUserPath()
 808     except Exception as e:
 809         print(e)
 810         sys.exit(1)
 811
 812     from salome_utils import getHostName
 813     args, modules_list, modules_root_dir = setenv.get_config(exeName=exeName)
 814     print("runSalome running on %s" % getHostName())
 815
 816     kill_salome(args)
 817     save_config = True
 818     if 'save_config' in args:
 819         save_config = args['save_config']
 820     # --
 821     test = True
 822     if args['wake_up_session']:
 823         test = False
 824         pass
 825     if test and not 'launcher' in args:
 826         from searchFreePort import searchFreePort
 827         searchFreePort(args, save_config, args.get('useport'))
 828         pass
 829     # --
 830     #setenv.main()
 831     setenv.set_env(args, modules_list, modules_root_dir)
 832     clt = useSalome(args, modules_list, modules_root_dir)
 833     return clt,args
 834
 835 # -----------------------------------------------------------------------------
 836
 837 def foreGround(clt, args):
 838     # --
 839     if "session_object" not in args:
 840         return
 841     session = args["session_object"]
 842     # --
 843     # Wait until gui is arrived
 844     # tmax = nbtot * dt
 845     # --
 846     gui_detected = False
 847     dt = 0.1
 848     nbtot = 100
 849     nb = 0
 850     while 1:
 851         try:
 852             status = session.GetStatSession()
 853             gui_detected = status.activeGUI
 854         except:
 855             pass
 856         if gui_detected:
 857             break
 858         from time import sleep
 859         sleep(dt)
 860         nb += 1
 861         if nb == nbtot:
 862             break
 863         pass
 864     # --
 865     if not gui_detected:
 866         return
 867     # --
 868     from salome_utils import getPortNumber
 869     port = getPortNumber()
 870     # --
 871     server = Server({})
 872     if sys.platform == "win32":
 873       server.CMD = [os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", "--spy", "%s"%(os.getpid()), "%s"%(port)]
 874     else:
 875       server.CMD = ["killSalomeWithPort.py", "--spy", "%s"%(os.getpid()), "%s"%(port)]
 876     server.run()
 877     # os.system("killSalomeWithPort.py --spy %s %s &"%(os.getpid(), port))
 878     # --
 879     dt = 1.0
 880     try:
 881         while 1:
 882             try:
 883                 status = session.GetStatSession()
 884                 assert status.activeGUI
 885             except:
 886                 break
 887             from time import sleep
 888             sleep(dt)
 889             pass
 890         pass
 891     except KeyboardInterrupt:
 892         from killSalomeWithPort import killMyPort
 893         killMyPort(port)
 894         pass
 895     return
 896 #
 897
 898 def runSalome():
 899     clt,args = main()
 900     # --
 901     test = args['gui'] and args['session_gui']
 902     test = test or args['wake_up_session']
 903     # --
 904     # The next test covers the --pinter option or if var PYTHONINSPECT is set
 905     # --
 906     test = test and not os.environ.get('PYTHONINSPECT')
 907     # --
 908     # The next test covers the python -i $KERNEL_ROOT_DIR/bin/salome/runSalome.py case
 909     # --
 910     try:
 911         from ctypes import POINTER, c_int, cast, pythonapi
 912         iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
 913         test = test and not iflag_ptr.contents.value
 914     except:
 915         pass
 916     # --
 917     test = test and os.getenv("SALOME_TEST_MODE", "0") != "1"
 918     test = test and args['foreground']
 919     # --
 920     if test:
 921         foreGround(clt, args)
 922         pass
 923     pass
 924 #
 925
 926 # -----------------------------------------------------------------------------
 927
 928 if __name__ == "__main__":
 929     runSalome()
 930 #