bin/runSalome.py

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