bin/runSalome.py

   1 #!/usr/bin/env python3
   2 #  -*- coding: iso-8859-1 -*-
   3 # Copyright (C) 2007-2020  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.path.expanduser("~")
 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.path.expanduser("~")
 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 = self.args.get('session_gui', True)
 304             if not session_gui:
 305                 self.SCMD2+=['--hide-desktop']
 306             else:
 307                 if not self.args['splash']:
 308                     self.SCMD2+=['--hide-splash']
 309                     pass
 310                 if self.args['study_hdf'] is not None:
 311                     self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
 312                     pass
 313                 pass
 314                 if 'pyscript' in self.args and len(self.args['pyscript']) > 0:
 315                     msg = json.dumps(self.args['pyscript'], cls=ScriptAndArgsObjectEncoder)
 316                     self.SCMD2+=['--pyscript=%s'%(msg)]
 317                     pass
 318                 pass
 319             pass
 320         if self.args['noexcepthandler']:
 321             self.SCMD2+=['--no-exception-handler']
 322         if 'user_config' in self.args:
 323             self.SCMD2+=['--resources=%s'%self.args['user_config']]
 324         if 'modules' in self.args:
 325             list_modules = []
 326             #keep only modules with GUI
 327             for m in modules_list:
 328               if m not in modules_root_dir:
 329                 list_modules.insert(0,m)
 330               else:
 331                 fr1 = os.path.join(modules_root_dir[m],"share","salome","resources",m.lower(),"SalomeApp.xml")
 332                 fr2 = os.path.join(modules_root_dir[m],"share","salome","resources","SalomeApp.xml")
 333                 if os.path.exists(fr1) or os.path.exists(fr2):
 334                   list_modules.insert(0,m)
 335             list_modules.reverse()
 336             self.SCMD2+=['--modules (%s)' % ":".join(list_modules)]
 337             pass
 338         if 'language' in self.args:
 339             self.SCMD2+=['--language=%s' % self.args['language']]
 340         pass
 341
 342     def setpath(self,modules_list,modules_root_dir):
 343         list_modules = modules_list[:]
 344         list_modules.reverse()
 345         if self.args["gui"] :
 346             list_modules = ["KERNEL", "GUI"] + list_modules
 347         else :
 348             list_modules = ["KERNEL"] + list_modules
 349
 350         cata_path=get_cata_path(list_modules,modules_root_dir)
 351
 352         if ("gui" in self.args) & ('moduleCatalog' in self.args['embedded']):
 353             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 354             self.CMD=self.SCMD1 + ['"' + '"::"'.join(cata_path) + '"'] + self.SCMD2
 355         else:
 356             self.CMD=self.SCMD1 + self.SCMD2
 357         if 'test' in self.args:
 358             self.CMD+=['-test'] + self.args['test']
 359         elif 'play' in self.args:
 360             self.CMD+=['-play'] + self.args['play']
 361
 362         if self.args["gdb_session"] or self.args["ddd_session"]:
 363             f = open(".gdbinit4salome", "w")
 364             f.write("set args ")
 365             args = " ".join(self.CMD[1:])
 366             args = args.replace("(", "\(")
 367             args = args.replace(")", "\)")
 368             f.write(args)
 369             f.write("\n")
 370             f.close()
 371             if self.args["ddd_session"]:
 372                 self.CMD = ["ddd", "--command=.gdbinit4salome", self.CMD[0]]
 373             elif self.args["gdb_session"]:
 374                 self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
 375                 pass
 376             pass
 377
 378         if self.args["valgrind_session"]:
 379             l = ["valgrind"]
 380             val = os.getenv("VALGRIND_OPTIONS")
 381             if val:
 382                 l += val.split()
 383                 pass
 384             self.CMD = l + self.CMD
 385             pass
 386
 387 # ---
 388
 389 class LauncherServer(Server):
 390     def __init__(self,args):
 391         self.args=args
 392         self.initArgs()
 393         self.SCMD1=['SALOME_LauncherServer']
 394         self.SCMD2=[]
 395         if args["gui"] :
 396             if 'registry' in self.args['embedded']:
 397                 self.SCMD1+=['--with','Registry',
 398                              '(','--salome_session','theSession',')']
 399             if 'moduleCatalog' in self.args['embedded']:
 400                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 401                 home_dir=os.path.expanduser("~")
 402                 if home_dir is not None:
 403                     self.SCMD2=['-personal',os.path.join(home_dir,'Salome','resources','CatalogModulePersonnel.xml')]
 404                 self.SCMD2+=[')']
 405             if 'study' in self.args['embedded']:
 406                 self.SCMD2+=['--with','SALOMEDS','(',')']
 407             if 'cppContainer' in self.args['embedded']:
 408                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 409
 410     def setpath(self,modules_list,modules_root_dir):
 411         list_modules = modules_list[:]
 412         list_modules.reverse()
 413         if self.args["gui"] :
 414             list_modules = ["KERNEL", "GUI"] + list_modules
 415         else :
 416             list_modules = ["KERNEL"] + list_modules
 417
 418         cata_path=get_cata_path(list_modules,modules_root_dir)
 419
 420         if ("gui" in self.args) & ('moduleCatalog' in self.args['embedded']):
 421             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 422             self.CMD=self.SCMD1 + ['"' + '"::"'.join(cata_path) + '"'] + self.SCMD2
 423         else:
 424             self.CMD=self.SCMD1 + self.SCMD2
 425 #
 426 # -----------------------------------------------------------------------------
 427
 428 def startGUI(clt):
 429     """Salome Session Graphic User Interface activation"""
 430     import Engines
 431     import SALOME
 432     import SALOMEDS
 433     import SALOME_ModuleCatalog
 434     import SALOME_Session_idl
 435     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 436     session.GetInterface()
 437
 438 # -----------------------------------------------------------------------------
 439
 440 def startSalome(args, modules_list, modules_root_dir):
 441     """Launch all SALOME servers requested by args"""
 442     init_time = os.times()
 443
 444     if verbose(): print("startSalome ", args)
 445
 446     #
 447     # Set server launch command
 448     #
 449     if 'server_launch_mode' in args:
 450         Server.set_server_launch_mode(args['server_launch_mode'])
 451
 452     #
 453     # Wake up session option
 454     #
 455     if args['wake_up_session']:
 456         if "OMNIORB_CONFIG" not in os.environ:
 457             from salome_utils import generateFileName
 458             omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
 459             kwargs={}
 460             if omniorbUserPath is not None:
 461                 kwargs["with_username"]=True
 462
 463             last_running_config = generateFileName(omniorbUserPath, prefix="omniORB",
 464                                                    suffix="last",
 465                                                    extension="cfg",
 466                                                    hidden=True,
 467                                                    **kwargs)
 468             os.environ['OMNIORB_CONFIG'] = last_running_config
 469             pass
 470         pass
 471
 472     #
 473     # Initialisation ORB and Naming Service
 474     #
 475
 476     clt=orbmodule.client(args)
 477
 478     #
 479     # Wake up session option
 480     #
 481     if args['wake_up_session']:
 482         import Engines
 483         import SALOME
 484         import SALOMEDS
 485         import SALOME_ModuleCatalog
 486         import SALOME_Session_idl
 487         session = clt.waitNS("/Kernel/Session",SALOME.Session)
 488         status = session.GetStatSession()
 489         if status.activeGUI:
 490             from salome_utils import getPortNumber
 491             port = getPortNumber()
 492             msg  = "Warning :"
 493             msg += "\n"
 494             msg += "Session GUI for port number %s is already active."%(port)
 495             msg += "\n"
 496             msg += "If you which to wake up another session,"
 497             msg += "\n"
 498             msg += "please use variable OMNIORB_CONFIG"
 499             msg += "\n"
 500             msg += "to get the correct session object in naming service."
 501             sys.stdout.write(msg+"\n")
 502             sys.stdout.flush()
 503             return clt
 504         session.GetInterface()
 505         args["session_object"] = session
 506         return clt
 507
 508     # Launch Logger Server (optional)
 509     # and wait until it is registered in naming service
 510     #
 511
 512     if args['logger']:
 513         myServer=LoggerServer(args)
 514         myServer.run()
 515         clt.waitLogger("Logger")
 516
 517     # Launch  Session Server (to show splash ASAP)
 518     #
 519
 520     if args["gui"] and not args['launcher_only']:
 521         mySessionServ = SessionServer(args,args['modules'],modules_root_dir)
 522         mySessionServ.setpath(modules_list,modules_root_dir)
 523         mySessionServ.run()
 524
 525     #
 526     # Launch Registry Server,
 527     # and wait until it is registered in naming service
 528     #
 529
 530     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 531         myServer=RegistryServer(args)
 532         myServer.run()
 533         if sys.platform == "win32":
 534           clt.waitNS("/Registry")
 535         else:
 536           clt.waitNSPID("/Registry",myServer.PID)
 537
 538     #
 539     # Launch Catalog Server,
 540     # and wait until it is registered in naming service
 541     #
 542
 543     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 544         cataServer=CatalogServer(args)
 545         cataServer.setpath(modules_list,modules_root_dir)
 546         cataServer.run()
 547         import SALOME_ModuleCatalog
 548         if sys.platform == "win32":
 549           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 550         else:
 551           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 552
 553     #
 554     # Launch SalomeDS Server,
 555     # and wait until it is registered in naming service
 556     #
 557
 558     # print("ARGS = ",args)
 559     if ('study' not in args['embedded']) | (args["gui"] == 0):
 560         print("RunStudy")
 561         myServer=SalomeDSServer(args)
 562         myServer.run()
 563         if sys.platform == "win32":
 564           clt.waitNS("/Study")
 565         else:
 566           clt.waitNSPID("/Study",myServer.PID)
 567
 568     #
 569     # Launch LauncherServer
 570     #
 571
 572     if not 'launcher' in args:
 573       myCmServer = LauncherServer(args)
 574       myCmServer.setpath(modules_list,modules_root_dir)
 575       myCmServer.run()
 576
 577     #
 578     # Launch ConnectionManagerServer
 579     #
 580
 581     if not args['launcher_only']:
 582       myConnectionServer = ConnectionManagerServer(args)
 583       myConnectionServer.run()
 584
 585     from Utils_Identity import getShortHostName
 586
 587     if os.getenv("HOSTNAME") == None:
 588         if os.getenv("HOST") == None:
 589             os.environ["HOSTNAME"]=getShortHostName()
 590         else:
 591             os.environ["HOSTNAME"]=os.getenv("HOST")
 592
 593     theComputer = getShortHostName()
 594
 595     #
 596     # Launch local C++ Container (FactoryServer),
 597     # and wait until it is registered in naming service
 598     #
 599
 600     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 601         myServer=ContainerCPPServer(args, with_gui=args["gui"]!=0)
 602         myServer.run()
 603         if sys.platform == "win32":
 604           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 605         else:
 606           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 607
 608     if 'pyContainer' in args['standalone']:
 609         raise Exception('Python containers no longer supported')
 610
 611     #
 612     # Wait until Session Server is registered in naming service
 613     #
 614
 615     if args["gui"] and not args['launcher_only']:
 616 ##----------------
 617         import Engines
 618         import SALOME
 619         import SALOMEDS
 620         import SALOME_ModuleCatalog
 621         import SALOME_Session_idl
 622         if sys.platform == "win32":
 623           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 624         else:
 625           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 626         args["session_object"] = session
 627     end_time = os.times()
 628     if verbose(): print()
 629     print("Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 630                                                          - init_time[4]))
 631
 632     # ASV start GUI without Loader
 633     #if args['gui']:
 634     #    session.GetInterface()
 635
 636     #
 637     # additional external python interpreters
 638     #
 639     nbaddi=0
 640
 641     try:
 642         if 'interp' in args:
 643             nbaddi = args['interp']
 644     except:
 645         import traceback
 646         traceback.print_exc()
 647         print("-------------------------------------------------------------")
 648         print("-- to get an external python interpreter:runSalome --interp=1")
 649         print("-------------------------------------------------------------")
 650
 651     if verbose(): print("additional external python interpreters: ", nbaddi)
 652     if nbaddi:
 653         for i in range(nbaddi):
 654             print("i=",i)
 655             anInterp=InterpServer(args)
 656             anInterp.run()
 657
 658     # set PYTHONINSPECT variable (python interpreter in interactive mode)
 659     if args['pinter']:
 660         os.environ["PYTHONINSPECT"]="1"
 661         try:
 662             import readline
 663         except ImportError:
 664             pass
 665
 666     return clt
 667
 668 # -----------------------------------------------------------------------------
 669
 670 def useSalome(args, modules_list, modules_root_dir):
 671     """
 672     Launch all SALOME servers requested by args,
 673     save list of process, give info to user,
 674     show registered objects in Naming Service.
 675     """
 676     global process_id
 677
 678     clt=None
 679     try:
 680         clt = startSalome(args, modules_list, modules_root_dir)
 681     except:
 682         import traceback
 683         traceback.print_exc()
 684         print()
 685         print()
 686         print("--- Error during Salome launch ---")
 687
 688     # print(process_id)
 689
 690     from addToKillList import addToKillList
 691     from killSalomeWithPort import getPiDict
 692
 693     filedict = getPiDict(args['port'])
 694     for pid, cmd in list(process_id.items()):
 695         addToKillList(pid, cmd, args['port'])
 696         pass
 697
 698     if verbose(): print("""
 699     Saving of the dictionary of Salome processes in %s
 700     To kill SALOME processes from a console (kill all sessions from all ports):
 701       python killSalome.py
 702     To kill SALOME from the present interpreter, if it is not closed :
 703       killLocalPort()      --> kill this session
 704                                (use CORBA port from args of runSalome)
 705       givenPortKill(port)  --> kill a specific session with given CORBA port
 706       killAllPorts()       --> kill all sessions
 707
 708     runSalome, with --killall option, starts with killing
 709     the processes resulting from the previous execution.
 710     """%filedict)
 711
 712     #
 713     #  Print Naming Service directory list
 714     #
 715
 716     if clt != None:
 717         if verbose():
 718             print()
 719             print(" --- registered objects tree in Naming Service ---")
 720             clt.showNS()
 721             pass
 722
 723         if not args['gui'] or not args['session_gui']:
 724             if args['shutdown_servers']:
 725                 class __utils__(object):
 726                     def __init__(self, port):
 727                         self.port = port
 728                         import killSalomeWithPort
 729                         self.killSalomeWithPort = killSalomeWithPort
 730                         return
 731                     def __del__(self):
 732                         self.killSalomeWithPort.killMyPort(self.port)
 733                         return
 734                     pass
 735                 def func(s):
 736                     del s
 737                 import atexit
 738                 atexit.register(func, __utils__(args['port']))
 739                 pass
 740             pass
 741
 742         # run python scripts, passed as command line arguments
 743         toimport = []
 744         if 'gui' in args and 'session_gui' in args:
 745             if not args['gui'] or not args['session_gui']:
 746                 if 'study_hdf' in args:
 747                     toopen = args['study_hdf']
 748                     if toopen:
 749                         import salome
 750                         salome.salome_init(path=toopen)
 751                 if 'pyscript' in args:
 752                     toimport = args['pyscript']
 753         from salomeContextUtils import formatScriptsAndArgs
 754         command = formatScriptsAndArgs(toimport, escapeSpaces=True)
 755         if command:
 756             proc = subprocess.Popen(command, shell=True)
 757             addToKillList(proc.pid, command, args['port'])
 758             res = proc.wait()
 759             if res: sys.exit(1) # if there's an error when executing script, we should explicitly exit
 760
 761     return clt
 762
 763 def execScript(script_path):
 764     print('executing', script_path)
 765     sys.path.insert(0, os.path.realpath(os.path.dirname(script_path)))
 766     exec(compile(open(script_path).read(), script_path, 'exec'),globals())
 767     del sys.path[0]
 768
 769 # -----------------------------------------------------------------------------
 770
 771 def registerEnv(args, modules_list, modules_root_dir):
 772     """
 773     Register args, modules_list, modules_root_dir in a file
 774     for further use, when SALOME is launched embedded in an other application.
 775     """
 776     from salome_utils import getTmpDir
 777     fileEnv = getTmpDir()
 778     from salome_utils import getUserName
 779     fileEnv += getUserName() + "_" + str(args['port']) \
 780             + '_' + args['appname'].upper() + '_env'
 781     fenv=open(fileEnv,'w')
 782     pickle.dump((args, modules_list, modules_root_dir),fenv)
 783     fenv.close()
 784     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 785
 786 # -----------------------------------------------------------------------------
 787
 788 def no_main():
 789     """Salome Launch, when embedded in other application"""
 790     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 791     fenv=open(fileEnv,'r')
 792     args, modules_list, modules_root_dir = pickle.load(fenv)
 793     fenv.close()
 794     kill_salome(args)
 795     from searchFreePort import searchFreePort
 796     searchFreePort(args, 0)
 797     clt = useSalome(args, modules_list, modules_root_dir)
 798     return clt
 799
 800 # -----------------------------------------------------------------------------
 801
 802 def main(exeName=None):
 803     """Salome launch as a main application"""
 804
 805     # define folder to store omniorb config (initially in virtual application folder)
 806     try:
 807         from salomeContextUtils import setOmniOrbUserPath
 808         setOmniOrbUserPath()
 809     except Exception as e:
 810         print(e)
 811         sys.exit(1)
 812
 813     from salome_utils import getHostName
 814     keep_env = not os.getenv('SALOME_PLEASE_SETUP_ENVIRONMENT_AS_BEFORE')
 815     args, modules_list, modules_root_dir = setenv.get_config(exeName=exeName, keepEnvironment=keep_env)
 816     print("runSalome running on %s" % getHostName())
 817
 818     kill_salome(args)
 819     save_config = True
 820     if 'save_config' in args:
 821         save_config = args['save_config']
 822     # --
 823     test = True
 824     if args['wake_up_session']:
 825         test = False
 826         pass
 827     if test and not 'launcher' in args:
 828         from searchFreePort import searchFreePort
 829         searchFreePort(args, save_config, args.get('useport'))
 830         pass
 831     # --
 832     #setenv.main()
 833     setenv.set_env(args, modules_list, modules_root_dir, keepEnvironment=keep_env)
 834     clt = useSalome(args, modules_list, modules_root_dir)
 835     return clt,args
 836
 837 # -----------------------------------------------------------------------------
 838
 839 def foreGround(clt, args):
 840     # --
 841     if "session_object" not in args:
 842         return
 843     session = args["session_object"]
 844     # --
 845     # Wait until gui is arrived
 846     # tmax = nbtot * dt
 847     # --
 848     gui_detected = False
 849     dt = 0.1
 850     nbtot = 100
 851     nb = 0
 852     while 1:
 853         try:
 854             status = session.GetStatSession()
 855             gui_detected = status.activeGUI
 856         except:
 857             pass
 858         if gui_detected:
 859             break
 860         from time import sleep
 861         sleep(dt)
 862         nb += 1
 863         if nb == nbtot:
 864             break
 865         pass
 866     # --
 867     if not gui_detected:
 868         return
 869     # --
 870     from salome_utils import getPortNumber
 871     port = getPortNumber()
 872     # --
 873     server = Server({})
 874     if sys.platform == "win32":
 875       server.CMD = [os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", "--spy", "%s"%(os.getpid()), "%s"%(port)]
 876     else:
 877       server.CMD = ["killSalomeWithPort.py", "--spy", "%s"%(os.getpid()), "%s"%(port)]
 878     server.run()
 879     # os.system("killSalomeWithPort.py --spy %s %s &"%(os.getpid(), port))
 880     # --
 881     dt = 1.0
 882     try:
 883         while 1:
 884             try:
 885                 status = session.GetStatSession()
 886                 assert status.activeGUI
 887             except:
 888                 break
 889             from time import sleep
 890             sleep(dt)
 891             pass
 892         pass
 893     except KeyboardInterrupt:
 894         from killSalomeWithPort import killMyPort
 895         killMyPort(port)
 896         pass
 897     return
 898 #
 899
 900 def runSalome():
 901     clt,args = main()
 902     # --
 903     test = args['gui'] and args['session_gui']
 904     test = test or args['wake_up_session']
 905     # --
 906     # The next test covers the --pinter option or if var PYTHONINSPECT is set
 907     # --
 908     test = test and not os.environ.get('PYTHONINSPECT')
 909     # --
 910     # The next test covers the python -i $KERNEL_ROOT_DIR/bin/salome/runSalome.py case
 911     # --
 912     try:
 913         from ctypes import POINTER, c_int, cast, pythonapi
 914         iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
 915         test = test and not iflag_ptr.contents.value
 916     except:
 917         pass
 918     # --
 919     test = test and os.getenv("SALOME_TEST_MODE", "0") != "1"
 920     test = test and args['foreground']
 921     # --
 922     if test:
 923         foreGround(clt, args)
 924         pass
 925     pass
 926 #
 927
 928 # -----------------------------------------------------------------------------
 929
 930 if __name__ == "__main__":
 931     runSalome()
 932 #