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