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