bin/runSalome.py

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