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 = 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                 self.SCMD2+=['-personal',
 402                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 403             if 'study' in self.args['embedded']:
 404                 self.SCMD2+=['--with','SALOMEDS','(',')']
 405             if 'cppContainer' in self.args['embedded']:
 406                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 407
 408     def setpath(self,modules_list,modules_root_dir):
 409         list_modules = modules_list[:]
 410         list_modules.reverse()
 411         if self.args["gui"] :
 412             list_modules = ["KERNEL", "GUI"] + list_modules
 413         else :
 414             list_modules = ["KERNEL"] + list_modules
 415
 416         cata_path=get_cata_path(list_modules,modules_root_dir)
 417
 418         if ("gui" in self.args) & ('moduleCatalog' in self.args['embedded']):
 419             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 420             self.CMD=self.SCMD1 + ['"' + '"::"'.join(cata_path) + '"'] + self.SCMD2
 421         else:
 422             self.CMD=self.SCMD1 + self.SCMD2
 423 #
 424 # -----------------------------------------------------------------------------
 425
 426 def startGUI(clt):
 427     """Salome Session Graphic User Interface activation"""
 428     import Engines
 429     import SALOME
 430     import SALOMEDS
 431     import SALOME_ModuleCatalog
 432     import SALOME_Session_idl
 433     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 434     session.GetInterface()
 435
 436 # -----------------------------------------------------------------------------
 437
 438 def startSalome(args, modules_list, modules_root_dir):
 439     """Launch all SALOME servers requested by args"""
 440     init_time = os.times()
 441
 442     if verbose(): print("startSalome ", args)
 443
 444     #
 445     # Set server launch command
 446     #
 447     if 'server_launch_mode' in args:
 448         Server.set_server_launch_mode(args['server_launch_mode'])
 449
 450     #
 451     # Wake up session option
 452     #
 453     if args['wake_up_session']:
 454         if "OMNIORB_CONFIG" not in os.environ:
 455             from salome_utils import generateFileName
 456             omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
 457             kwargs={}
 458             if omniorbUserPath is not None:
 459                 kwargs["with_username"]=True
 460
 461             last_running_config = generateFileName(omniorbUserPath, prefix="omniORB",
 462                                                    suffix="last",
 463                                                    extension="cfg",
 464                                                    hidden=True,
 465                                                    **kwargs)
 466             os.environ['OMNIORB_CONFIG'] = last_running_config
 467             pass
 468         pass
 469
 470     #
 471     # Initialisation ORB and Naming Service
 472     #
 473
 474     clt=orbmodule.client(args)
 475
 476     #
 477     # Wake up session option
 478     #
 479     if args['wake_up_session']:
 480         import Engines
 481         import SALOME
 482         import SALOMEDS
 483         import SALOME_ModuleCatalog
 484         import SALOME_Session_idl
 485         session = clt.waitNS("/Kernel/Session",SALOME.Session)
 486         status = session.GetStatSession()
 487         if status.activeGUI:
 488             from salome_utils import getPortNumber
 489             port = getPortNumber()
 490             msg  = "Warning :"
 491             msg += "\n"
 492             msg += "Session GUI for port number %s is already active."%(port)
 493             msg += "\n"
 494             msg += "If you which to wake up another session,"
 495             msg += "\n"
 496             msg += "please use variable OMNIORB_CONFIG"
 497             msg += "\n"
 498             msg += "to get the correct session object in naming service."
 499             sys.stdout.write(msg+"\n")
 500             sys.stdout.flush()
 501             return clt
 502         session.GetInterface()
 503         args["session_object"] = session
 504         return clt
 505
 506     # Launch Logger Server (optional)
 507     # and wait until it is registered in naming service
 508     #
 509
 510     if args['logger']:
 511         myServer=LoggerServer(args)
 512         myServer.run()
 513         clt.waitLogger("Logger")
 514
 515     # Launch  Session Server (to show splash ASAP)
 516     #
 517
 518     if args["gui"] and not args['launcher_only']:
 519         mySessionServ = SessionServer(args,args['modules'],modules_root_dir)
 520         mySessionServ.setpath(modules_list,modules_root_dir)
 521         mySessionServ.run()
 522
 523     #
 524     # Launch Registry Server,
 525     # and wait until it is registered in naming service
 526     #
 527
 528     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 529         myServer=RegistryServer(args)
 530         myServer.run()
 531         if sys.platform == "win32":
 532           clt.waitNS("/Registry")
 533         else:
 534           clt.waitNSPID("/Registry",myServer.PID)
 535
 536     #
 537     # Launch Catalog Server,
 538     # and wait until it is registered in naming service
 539     #
 540
 541     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 542         cataServer=CatalogServer(args)
 543         cataServer.setpath(modules_list,modules_root_dir)
 544         cataServer.run()
 545         import SALOME_ModuleCatalog
 546         if sys.platform == "win32":
 547           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 548         else:
 549           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 550
 551     #
 552     # Launch SalomeDS Server,
 553     # and wait until it is registered in naming service
 554     #
 555
 556     # print("ARGS = ",args)
 557     if ('study' not in args['embedded']) | (args["gui"] == 0):
 558         print("RunStudy")
 559         myServer=SalomeDSServer(args)
 560         myServer.run()
 561         if sys.platform == "win32":
 562           clt.waitNS("/Study")
 563         else:
 564           clt.waitNSPID("/Study",myServer.PID)
 565
 566     #
 567     # Launch LauncherServer
 568     #
 569
 570     if not 'launcher' in args:
 571       myCmServer = LauncherServer(args)
 572       myCmServer.setpath(modules_list,modules_root_dir)
 573       myCmServer.run()
 574
 575     #
 576     # Launch ConnectionManagerServer
 577     #
 578
 579     if not args['launcher_only']:
 580       myConnectionServer = ConnectionManagerServer(args)
 581       myConnectionServer.run()
 582
 583     from Utils_Identity import getShortHostName
 584
 585     if os.getenv("HOSTNAME") == None:
 586         if os.getenv("HOST") == None:
 587             os.environ["HOSTNAME"]=getShortHostName()
 588         else:
 589             os.environ["HOSTNAME"]=os.getenv("HOST")
 590
 591     theComputer = getShortHostName()
 592
 593     #
 594     # Launch local C++ Container (FactoryServer),
 595     # and wait until it is registered in naming service
 596     #
 597
 598     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 599         myServer=ContainerCPPServer(args, with_gui=args["gui"]!=0)
 600         myServer.run()
 601         if sys.platform == "win32":
 602           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 603         else:
 604           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 605
 606     if 'pyContainer' in args['standalone']:
 607         raise Exception('Python containers no longer supported')
 608
 609     #
 610     # Wait until Session Server is registered in naming service
 611     #
 612
 613     if args["gui"] and not args['launcher_only']:
 614 ##----------------
 615         import Engines
 616         import SALOME
 617         import SALOMEDS
 618         import SALOME_ModuleCatalog
 619         import SALOME_Session_idl
 620         if sys.platform == "win32":
 621           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 622         else:
 623           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 624         args["session_object"] = session
 625     end_time = os.times()
 626     if verbose(): print()
 627     print("Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 628                                                          - init_time[4]))
 629
 630     # ASV start GUI without Loader
 631     #if args['gui']:
 632     #    session.GetInterface()
 633
 634     #
 635     # additional external python interpreters
 636     #
 637     nbaddi=0
 638
 639     try:
 640         if 'interp' in args:
 641             nbaddi = args['interp']
 642     except:
 643         import traceback
 644         traceback.print_exc()
 645         print("-------------------------------------------------------------")
 646         print("-- to get an external python interpreter:runSalome --interp=1")
 647         print("-------------------------------------------------------------")
 648
 649     if verbose(): print("additional external python interpreters: ", nbaddi)
 650     if nbaddi:
 651         for i in range(nbaddi):
 652             print("i=",i)
 653             anInterp=InterpServer(args)
 654             anInterp.run()
 655
 656     # set PYTHONINSPECT variable (python interpreter in interactive mode)
 657     if args['pinter']:
 658         os.environ["PYTHONINSPECT"]="1"
 659         try:
 660             import readline
 661         except ImportError:
 662             pass
 663
 664     return clt
 665
 666 # -----------------------------------------------------------------------------
 667
 668 def useSalome(args, modules_list, modules_root_dir):
 669     """
 670     Launch all SALOME servers requested by args,
 671     save list of process, give info to user,
 672     show registered objects in Naming Service.
 673     """
 674     global process_id
 675
 676     clt=None
 677     try:
 678         clt = startSalome(args, modules_list, modules_root_dir)
 679     except:
 680         import traceback
 681         traceback.print_exc()
 682         print()
 683         print()
 684         print("--- Error during Salome launch ---")
 685
 686     # print(process_id)
 687
 688     from addToKillList import addToKillList
 689     from killSalomeWithPort import getPiDict
 690
 691     filedict = getPiDict(args['port'])
 692     for pid, cmd in list(process_id.items()):
 693         addToKillList(pid, cmd, args['port'])
 694         pass
 695
 696     if verbose(): print("""
 697     Saving of the dictionary of Salome processes in %s
 698     To kill SALOME processes from a console (kill all sessions from all ports):
 699       python killSalome.py
 700     To kill SALOME from the present interpreter, if it is not closed :
 701       killLocalPort()      --> kill this session
 702                                (use CORBA port from args of runSalome)
 703       givenPortKill(port)  --> kill a specific session with given CORBA port
 704       killAllPorts()       --> kill all sessions
 705
 706     runSalome, with --killall option, starts with killing
 707     the processes resulting from the previous execution.
 708     """%filedict)
 709
 710     #
 711     #  Print Naming Service directory list
 712     #
 713
 714     if clt != None:
 715         if verbose():
 716             print()
 717             print(" --- registered objects tree in Naming Service ---")
 718             clt.showNS()
 719             pass
 720
 721         if not args['gui'] or not args['session_gui']:
 722             if args['shutdown_servers']:
 723                 class __utils__(object):
 724                     def __init__(self, port):
 725                         self.port = port
 726                         import killSalomeWithPort
 727                         self.killSalomeWithPort = killSalomeWithPort
 728                         return
 729                     def __del__(self):
 730                         self.killSalomeWithPort.killMyPort(self.port)
 731                         return
 732                     pass
 733                 def func(s):
 734                     del s
 735                 import atexit
 736                 atexit.register(func, __utils__(args['port']))
 737                 pass
 738             pass
 739
 740         # run python scripts, passed as command line arguments
 741         toimport = []
 742         if 'gui' in args and 'session_gui' in args:
 743             if not args['gui'] or not args['session_gui']:
 744                 if 'study_hdf' in args:
 745                     toopen = args['study_hdf']
 746                     if toopen:
 747                         import salome
 748                         salome.salome_init(path=toopen)
 749                 if 'pyscript' in args:
 750                     toimport = args['pyscript']
 751         from salomeContextUtils import formatScriptsAndArgs
 752         command = formatScriptsAndArgs(toimport)
 753         if command:
 754             proc = subprocess.Popen(command, shell=True)
 755             addToKillList(proc.pid, command, args['port'])
 756             res = proc.wait()
 757             if res: sys.exit(1) # if there's an error when executing script, we should explicitly exit
 758
 759     return clt
 760
 761 def execScript(script_path):
 762     print('executing', script_path)
 763     sys.path.insert(0, os.path.realpath(os.path.dirname(script_path)))
 764     exec(compile(open(script_path).read(), script_path, 'exec'),globals())
 765     del sys.path[0]
 766
 767 # -----------------------------------------------------------------------------
 768
 769 def registerEnv(args, modules_list, modules_root_dir):
 770     """
 771     Register args, modules_list, modules_root_dir in a file
 772     for further use, when SALOME is launched embedded in an other application.
 773     """
 774     from salome_utils import getTmpDir
 775     fileEnv = getTmpDir()
 776     from salome_utils import getUserName
 777     fileEnv += getUserName() + "_" + str(args['port']) \
 778             + '_' + args['appname'].upper() + '_env'
 779     fenv=open(fileEnv,'w')
 780     pickle.dump((args, modules_list, modules_root_dir),fenv)
 781     fenv.close()
 782     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 783
 784 # -----------------------------------------------------------------------------
 785
 786 def no_main():
 787     """Salome Launch, when embedded in other application"""
 788     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 789     fenv=open(fileEnv,'r')
 790     args, modules_list, modules_root_dir = pickle.load(fenv)
 791     fenv.close()
 792     kill_salome(args)
 793     from searchFreePort import searchFreePort
 794     searchFreePort(args, 0)
 795     clt = useSalome(args, modules_list, modules_root_dir)
 796     return clt
 797
 798 # -----------------------------------------------------------------------------
 799
 800 def main(exeName=None):
 801     """Salome launch as a main application"""
 802
 803     # define folder to store omniorb config (initially in virtual application folder)
 804     try:
 805         from salomeContextUtils import setOmniOrbUserPath
 806         setOmniOrbUserPath()
 807     except Exception as e:
 808         print(e)
 809         sys.exit(1)
 810
 811     from salome_utils import getHostName
 812     keep_env = not os.getenv('SALOME_PLEASE_SETUP_ENVIRONMENT_AS_BEFORE')
 813     args, modules_list, modules_root_dir = setenv.get_config(exeName=exeName, keepEnvironment=keep_env)
 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, keepEnvironment=keep_env)
 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 #