bin/runSalome.py

   1 #!/usr/bin/env python
   2 #  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 #  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   5 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   6 #
   7 #  This library is free software; you can redistribute it and/or
   8 #  modify it under the terms of the GNU Lesser General Public
   9 #  License as published by the Free Software Foundation; either
  10 #  version 2.1 of the License.
  11 #
  12 #  This library is distributed in the hope that it will be useful,
  13 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 #  Lesser General Public License for more details.
  16 #
  17 #  You should have received a copy of the GNU Lesser General Public
  18 #  License along with this library; if not, write to the Free Software
  19 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23 ## @package runSalome
  24 # \brief Module that provides services to launch SALOME
  25 #
  26 #
  27
  28 import sys, os, string, glob, time, pickle, re
  29 import orbmodule
  30 import setenv
  31 from server import *
  32 from launchConfigureParser import verbose
  33 #process_id = {} move to server.py
  34
  35 # -----------------------------------------------------------------------------
  36
  37 from killSalome import killAllPorts
  38
  39 def killLocalPort():
  40     """
  41     kill servers from a previous SALOME exection, if needed,
  42     on the CORBA port given in args of runSalome
  43     """
  44
  45     from killSalomeWithPort import killMyPort
  46     my_port=str(args['port'])
  47     try:
  48         killMyPort(my_port)
  49     except:
  50         print "problem in killLocalPort()"
  51         pass
  52     pass
  53
  54 def givenPortKill(port):
  55     """
  56     kill servers from a previous SALOME exection, if needed,
  57     on the same CORBA port
  58     """
  59
  60     from killSalomeWithPort import killMyPort
  61     my_port=port
  62     try:
  63         killMyPort(my_port)
  64     except:
  65         print "problem in LocalPortKill(), killMyPort("<<port<<")"
  66         pass
  67     pass
  68
  69 def kill_salome(args):
  70     """
  71     Kill servers from previous SALOME executions, if needed;
  72     depending on args 'killall' or 'portkill', kill all executions,
  73     or only execution on the same CORBA port
  74     """
  75
  76     if args['killall']:
  77         killAllPorts()
  78     elif args['portkill']:
  79         givenPortKill(str(args['port']))
  80
  81 # -----------------------------------------------------------------------------
  82 #
  83 # Definition des classes d'objets pour le lancement des Server CORBA
  84 #
  85
  86 class InterpServer(Server):
  87     def __init__(self,args):
  88         self.args=args
  89         env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  90         self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
  91         #self.CMD=['xterm', '-e', 'python']
  92
  93     def run(self):
  94         global process_id
  95         command = self.CMD
  96         print "INTERPSERVER::command = ", command
  97         if sys.platform == "win32":
  98           import win32pm
  99           pid = win32pm.spawnpid( string.join(command, " "),'-nc' )
 100         else:
 101           pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 102         process_id[pid]=self.CMD
 103         self.PID = pid
 104
 105 # ---
 106
 107 class CatalogServer(Server):
 108     def __init__(self,args):
 109         self.args=args
 110         self.initArgs()
 111         #if sys.platform == "win32":
 112         #        self.SCMD1=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_ModuleCatalog_Server' + ".exe",'-common']
 113         #else:
 114         self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
 115         self.SCMD2=[]
 116         home_dir=os.getenv('HOME')
 117         if home_dir is not None:
 118             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 119
 120     def setpath(self,modules_list,modules_root_dir):
 121         cata_path=[]
 122         list_modules = modules_list[:]
 123         list_modules.reverse()
 124         if self.args["gui"] :
 125             list_modules = ["KERNEL", "GUI"] + list_modules
 126         else :
 127             list_modules = ["KERNEL"] + list_modules
 128         for module in list_modules:
 129             if modules_root_dir.has_key(module):
 130                 module_root_dir=modules_root_dir[module]
 131                 module_cata=module+"Catalog.xml"
 132                 #print "   ", module_cata
 133                 if os.path.exists(os.path.join(module_root_dir,
 134                                                "share",setenv.salome_subdir,
 135                                                "resources",module.lower(),
 136                                                module_cata)):
 137                     cata_path.extend(
 138                         glob.glob(os.path.join(module_root_dir,
 139                                                "share",setenv.salome_subdir,
 140                                                "resources",module.lower(),
 141                                                module_cata)))
 142                 else:
 143                     cata_path.extend(
 144                         glob.glob(os.path.join(module_root_dir,
 145                                                "share",setenv.salome_subdir,
 146                                                "resources",
 147                                                module_cata)))
 148                 pass
 149             pass
 150         #self.CMD=self.SCMD1 + ['\"']+[string.join(cata_path,'\"::\"')] + ['\"'] + self.SCMD2
 151         self.CMD=self.SCMD1 + ['\"' + string.join(cata_path,'\"::\"') + '\"'] + self.SCMD2
 152
 153 # ---
 154
 155 class SalomeDSServer(Server):
 156     def __init__(self,args):
 157         self.args=args
 158         self.initArgs()
 159         self.CMD=['SALOMEDS_Server']
 160
 161 # ---
 162
 163 class ConnectionManagerServer(Server):
 164     def __init__(self,args):
 165         self.args=args
 166         self.initArgs()
 167         self.CMD=['SALOME_ConnectionManagerServer']
 168
 169 # ---
 170
 171 class RegistryServer(Server):
 172     def __init__(self,args):
 173         self.args=args
 174         self.initArgs()
 175         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 176
 177 # ---
 178
 179 class ContainerCPPServer(Server):
 180     def __init__(self,args):
 181         self.args=args
 182         self.initArgs()
 183         self.CMD=['SALOME_Container','FactoryServer']
 184
 185 # ---
 186
 187 class ContainerPYServer(Server):
 188     def __init__(self,args):
 189         self.args=args
 190         self.initArgs()
 191         if sys.platform == "win32":
 192           self.CMD=[os.environ["PYTHONBIN"], '\"'+os.environ["KERNEL_ROOT_DIR"] + '/bin/salome/SALOME_ContainerPy.py'+'\"','FactoryServerPy']
 193         else:
 194           self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
 195
 196 # ---
 197
 198 class ContainerSUPERVServer(Server):
 199     def __init__(self,args):
 200         self.args=args
 201         self.initArgs()
 202    #  if sys.platform == "win32":
 203 #          self.CMD=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_Container' + ".exe",'SuperVisionContainer']
 204 # else:
 205         self.CMD=['SALOME_Container','SuperVisionContainer']
 206
 207 # ---
 208
 209 class LoggerServer(Server):
 210     def __init__(self,args):
 211         self.args=args
 212         self.initArgs()
 213         from salome_utils import generateFileName
 214         if sys.platform == "win32": dirpath = os.environ["HOME"]
 215         else:                       dirpath = "/tmp"
 216         logfile = generateFileName( dirpath,
 217                                     prefix="logger",
 218                                     extension="log",
 219                                     with_username=True,
 220                                     with_hostname=True,
 221                                     with_port=True)
 222         print "==========================================================="
 223         print "Logger server: put log to the file:"
 224         print logfile
 225         print "==========================================================="
 226         self.CMD=['SALOME_Logger_Server', logfile]
 227         pass
 228     pass # end of LoggerServer class
 229
 230 # ---
 231
 232 class SessionServer(Server):
 233     def __init__(self,args):
 234         self.args = args.copy()
 235         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 236         #self.args['xterm']=0
 237         #
 238         self.initArgs()
 239         self.SCMD1=['SALOME_Session_Server']
 240         self.SCMD2=[]
 241         if 'registry' in self.args['embedded']:
 242             self.SCMD1+=['--with','Registry',
 243                          '(','--salome_session','theSession',')']
 244         if 'moduleCatalog' in self.args['embedded']:
 245             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 246             home_dir=os.getenv('HOME')
 247             if home_dir is not None:
 248                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 249             self.SCMD2+=[')']
 250         if 'study' in self.args['embedded']:
 251             self.SCMD2+=['--with','SALOMEDS','(',')']
 252         if 'cppContainer' in self.args['embedded']:
 253             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 254         if 'SalomeAppEngine' in self.args['embedded']:
 255             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 256
 257         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 258             self.SCMD2+=['CPP']
 259         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 260             self.SCMD2+=['PY']
 261         if 'supervContainer' in self.args['standalone']:
 262             self.SCMD2+=['SUPERV']
 263         if self.args['gui']:
 264             session_gui = True
 265             if self.args.has_key('session_gui'):
 266                 session_gui = self.args['session_gui']
 267             if session_gui:
 268                 self.SCMD2+=['GUI']
 269                 if self.args['splash']:
 270                     self.SCMD2+=['SPLASH']
 271                     pass
 272                 if self.args['study_hdf'] is not None:
 273                     self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
 274                     pass
 275                 pass
 276             pass
 277         if self.args['noexcepthandler']:
 278             self.SCMD2+=['noexcepthandler']
 279         if self.args.has_key('user_config'):
 280             self.SCMD2+=['--resources=%s'%self.args['user_config']]
 281         if self.args.has_key('modules'):
 282             self.SCMD2+=['--modules (%s)'%":".join(self.args['modules'])]
 283         if self.args.has_key('pyscript') and len(self.args['pyscript']) > 0:
 284             self.SCMD2+=['--pyscript=%s'%(",".join(self.args['pyscript']))]
 285
 286     def setpath(self,modules_list,modules_root_dir):
 287         cata_path=[]
 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         for module in list_modules:
 295             module_root_dir=modules_root_dir[module]
 296             module_cata=module+"Catalog.xml"
 297             #print "   ", module_cata
 298             if os.path.exists(os.path.join(module_root_dir,
 299                                            "share",setenv.salome_subdir,
 300                                            "resources",module.lower(),
 301                                            module_cata)):
 302                 cata_path.extend(
 303                     glob.glob(os.path.join(module_root_dir,"share",
 304                                            setenv.salome_subdir,"resources",
 305                                            module.lower(),module_cata)))
 306             else:
 307                 cata_path.extend(
 308                     glob.glob(os.path.join(module_root_dir,"share",
 309                                            setenv.salome_subdir,"resources",
 310                                            module_cata)))
 311             pass
 312         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 313             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 314             #self.CMD=self.SCMD1 + ['\"']+[string.join(cata_path,'\"::\"')] + ['\"'] + self.SCMD2
 315             self.CMD=self.SCMD1 + ['\"' + string.join(cata_path,'\"::\"') + '\"'] + self.SCMD2
 316         else:
 317             self.CMD=self.SCMD1 + self.SCMD2
 318         if self.args.has_key('test'):
 319             self.CMD+=['-test'] + self.args['test']
 320         elif self.args.has_key('play'):
 321             self.CMD+=['-play'] + self.args['play']
 322
 323         if self.args["gdb_session"]:
 324             f = open(".gdbinit4salome", "w")
 325             f.write("set args ")
 326             args = " ".join(self.CMD[1:])
 327             args = args.replace("(", "\(")
 328             args = args.replace(")", "\)")
 329             f.write(args)
 330             f.write("\n")
 331             f.close()
 332             self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
 333             pass
 334
 335 # ---
 336
 337 class LauncherServer(Server):
 338     def __init__(self,args):
 339         self.args=args
 340         self.initArgs()
 341         self.SCMD1=['SALOME_LauncherServer']
 342         self.SCMD2=[]
 343         if args["gui"] :
 344             if 'registry' in self.args['embedded']:
 345                 self.SCMD1+=['--with','Registry',
 346                              '(','--salome_session','theSession',')']
 347             if 'moduleCatalog' in self.args['embedded']:
 348                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 349                 self.SCMD2+=['-personal',
 350                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 351             if 'study' in self.args['embedded']:
 352                 self.SCMD2+=['--with','SALOMEDS','(',')']
 353             if 'cppContainer' in self.args['embedded']:
 354                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 355
 356     def setpath(self,modules_list,modules_root_dir):
 357         cata_path=[]
 358         list_modules = modules_list[:]
 359         list_modules.reverse()
 360         if self.args["gui"] :
 361             list_modules = ["GUI"] + list_modules
 362         for module in ["KERNEL"] + list_modules:
 363             if modules_root_dir.has_key(module):
 364                 module_root_dir=modules_root_dir[module]
 365                 module_cata=module+"Catalog.xml"
 366                 #print "   ", module_cata
 367                 if os.path.exists(os.path.join(module_root_dir,
 368                                                "share",setenv.salome_subdir,
 369                                                "resources",module.lower(),
 370                                                module_cata)):
 371                     cata_path.extend(
 372                         glob.glob(os.path.join(module_root_dir,"share",
 373                                                setenv.salome_subdir,"resources",
 374                                                module.lower(),module_cata)))
 375                 else:
 376                     cata_path.extend(
 377                         glob.glob(os.path.join(module_root_dir,"share",
 378                                                setenv.salome_subdir,"resources",
 379                                                module_cata)))
 380                 pass
 381             pass
 382         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 383             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 384         else:
 385             self.CMD=self.SCMD1 + self.SCMD2
 386
 387 class NotifyServer(Server):
 388     def __init__(self,args,modules_root_dir):
 389         self.args=args
 390         self.initArgs()
 391         self.modules_root_dir=modules_root_dir
 392         myLogName = os.environ["LOGNAME"]
 393         self.CMD=['notifd','-c',
 394                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/kernel/channel.cfg',
 395                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 396                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 397                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 398                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 399                   ]
 400
 401 #
 402 # -----------------------------------------------------------------------------
 403
 404 def startGUI():
 405     """Salome Session Graphic User Interface activation"""
 406     import Engines
 407     import SALOME
 408     import SALOMEDS
 409     import SALOME_ModuleCatalog
 410     reload(Engines)
 411     reload(SALOME)
 412     reload(SALOMEDS)
 413     import SALOME_Session_idl
 414     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 415     session.GetInterface()
 416
 417 # -----------------------------------------------------------------------------
 418
 419 def startSalome(args, modules_list, modules_root_dir):
 420     """Launch all SALOME servers requested by args"""
 421     init_time = os.times()
 422
 423     if verbose(): print "startSalome ", args
 424
 425     #
 426     # Initialisation ORB et Naming Service
 427     #
 428
 429     clt=orbmodule.client(args)
 430     # Save Naming service port name into
 431     # the file args["ns_port_log_file"]
 432     if args.has_key('ns_port_log_file'):
 433       home = os.environ['HOME']
 434       appli= os.environ.get("APPLI")
 435       if appli is not None:
 436         home='%s/%s'%(home,appli)
 437         pass
 438       file_name= '%s/%s'%(home, args["ns_port_log_file"])
 439       f = open(file_name, "w")
 440       f.write(os.environ['NSPORT'])
 441       f.close()
 442
 443     # (non obligatoire) Lancement Logger Server
 444     # et attente de sa disponibilite dans le naming service
 445     #
 446
 447     if args['logger']:
 448         myServer=LoggerServer(args)
 449         myServer.run()
 450         clt.waitLogger("Logger")
 451
 452     # Notify Server launch
 453     #
 454
 455     if sys.platform != "win32":
 456       if verbose(): print "Notify Server to launch"
 457
 458       myServer=NotifyServer(args,modules_root_dir)
 459       myServer.run()
 460
 461     # Lancement Session Server (to show splash ASAP)
 462     #
 463
 464     if args["gui"]:
 465         mySessionServ = SessionServer(args)
 466         mySessionServ.setpath(modules_list,modules_root_dir)
 467         mySessionServ.run()
 468
 469     #
 470     # Lancement Registry Server,
 471     # attente de la disponibilite du Registry dans le 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     # Lancement Catalog Server,
 484     # attente de la disponibilite du Catalog Server dans le Naming Service
 485     #
 486
 487
 488     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 489         cataServer=CatalogServer(args)
 490         cataServer.setpath(modules_list,modules_root_dir)
 491         cataServer.run()
 492         import SALOME_ModuleCatalog
 493         if sys.platform == "win32":
 494           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 495         else:
 496           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 497
 498     #
 499     # Lancement SalomeDS Server,
 500     # attente de la disponibilite du SalomeDS dans le Naming Service
 501     #
 502
 503     #print "ARGS = ",args
 504     if ('study' not in args['embedded']) | (args["gui"] == 0):
 505         print "RunStudy"
 506         myServer=SalomeDSServer(args)
 507         myServer.run()
 508         if sys.platform == "win32":
 509           clt.waitNS("/myStudyManager")
 510         else:
 511           clt.waitNSPID("/myStudyManager",myServer.PID)
 512
 513     #
 514     # Lancement LauncherServer
 515     #
 516
 517     myCmServer = LauncherServer(args)
 518     myCmServer.setpath(modules_list,modules_root_dir)
 519     myCmServer.run()
 520
 521     #
 522     # Launch ConnectionManagerServer
 523     #
 524
 525     myConnectionServer = ConnectionManagerServer(args)
 526     myConnectionServer.run()
 527
 528
 529     from Utils_Identity import getShortHostName
 530
 531     if os.getenv("HOSTNAME") == None:
 532         if os.getenv("HOST") == None:
 533             os.environ["HOSTNAME"]=getShortHostName()
 534         else:
 535             os.environ["HOSTNAME"]=os.getenv("HOST")
 536
 537     theComputer = getShortHostName()
 538
 539     #
 540     # Lancement Container C++ local,
 541     # attente de la disponibilite du Container C++ local dans le Naming Service
 542     #
 543
 544     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 545         myServer=ContainerCPPServer(args)
 546         myServer.run()
 547         if sys.platform == "win32":
 548           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 549         else:
 550           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 551
 552     #
 553     # Lancement Container Python local,
 554     # attente de la disponibilite du Container Python local
 555     # dans le Naming Service
 556     #
 557
 558     if 'pyContainer' in args['standalone']:
 559         myServer=ContainerPYServer(args)
 560         myServer.run()
 561         if sys.platform == "win32":
 562           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 563         else:
 564           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 565
 566     #
 567     # Lancement Container Supervision local,
 568     # attente de la disponibilite du Container Supervision local
 569     # dans le Naming Service
 570     #
 571
 572     if 'supervContainer' in args['standalone']:
 573         myServer=ContainerSUPERVServer(args)
 574         myServer.run()
 575         if sys.platform == "win32":
 576           clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 577         else:
 578           clt.waitNSPID("/Containers/" + theComputer + "/SuperVisionContainer",myServer.PID)
 579
 580     #
 581     # Attente de la disponibilite du Session Server dans le Naming Service
 582     #
 583
 584     if args["gui"]:
 585 ##----------------
 586         import Engines
 587         import SALOME
 588         import SALOMEDS
 589         import SALOME_ModuleCatalog
 590         reload(Engines)
 591         reload(SALOME)
 592         reload(SALOMEDS)
 593         import SALOME_Session_idl
 594         if sys.platform == "win32":
 595           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 596         else:
 597           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 598     end_time = os.times()
 599     if verbose(): print
 600     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 601                                                          - init_time[4])
 602
 603     # ASV start GUI without Loader
 604     #if args['gui']:
 605     #    session.GetInterface()
 606
 607     #
 608     # additionnal external python interpreters
 609     #
 610     nbaddi=0
 611
 612     try:
 613         if 'interp' in args:
 614             nbaddi = args['interp']
 615     except:
 616         import traceback
 617         traceback.print_exc()
 618         print "-------------------------------------------------------------"
 619         print "-- to get an external python interpreter:runSalome --interp=1"
 620         print "-------------------------------------------------------------"
 621
 622     print "additional external python interpreters: ", nbaddi
 623     if nbaddi:
 624         for i in range(nbaddi):
 625             print "i=",i
 626             anInterp=InterpServer(args)
 627             anInterp.run()
 628
 629     # set PYTHONINSPECT variable
 630     if args['pinter']:
 631         os.environ["PYTHONINSPECT"]="1"
 632         import readline
 633
 634     return clt
 635
 636 # -----------------------------------------------------------------------------
 637
 638 def useSalome(args, modules_list, modules_root_dir):
 639     """
 640     Launch all SALOME servers requested by args,
 641     save list of process, give info to user,
 642     show registered objects in Naming Service.
 643     """
 644     global process_id
 645
 646     clt=None
 647     try:
 648         clt = startSalome(args, modules_list, modules_root_dir)
 649     except:
 650         import traceback
 651         traceback.print_exc()
 652         print
 653         print
 654         print "--- Error during Salome launch ---"
 655
 656     #print process_id
 657
 658     from addToKillList import addToKillList
 659     from killSalomeWithPort import getPiDict
 660
 661     filedict = getPiDict(args['port'])
 662     for pid, cmd in process_id.items():
 663         addToKillList(pid, cmd, args['port'])
 664         pass
 665
 666     if verbose(): print """
 667     Saving of the dictionary of Salome processes in %s
 668     To kill SALOME processes from a console (kill all sessions from all ports):
 669       python killSalome.py
 670     To kill SALOME from the present interpreter, if it is not closed :
 671       killLocalPort()      --> kill this session
 672                                (use CORBA port from args of runSalome)
 673       givenPortKill(port)  --> kill a specific session with given CORBA port
 674       killAllPorts()       --> kill all sessions
 675
 676     runSalome, with --killall option, starts with killing
 677     the processes resulting from the previous execution.
 678     """%filedict
 679
 680     #
 681     #  Impression arborescence Naming Service
 682     #
 683
 684     if clt != None:
 685         if verbose():
 686             print
 687             print " --- registered objects tree in Naming Service ---"
 688             clt.showNS()
 689             pass
 690
 691         # run python scripts, passed via --execute option
 692         toimport = []
 693         if args.has_key('pyscript'):
 694             if args.has_key('gui') and args.has_key('session_gui'):
 695                 if not args['gui'] or not args['session_gui']:
 696                     toimport = args['pyscript']
 697         i = 0
 698         while i < len( toimport ) :
 699             if toimport[ i ] == 'killall':
 700                 clt.showNS()
 701                 killAllPorts()
 702                 import sys
 703                 sys.exit(0)
 704             else:
 705                 scrname = toimport[ i ]
 706                 if len(scrname) > 2 and (len(scrname) - string.rfind(scrname, ".py") == 3):
 707                     print 'executing',scrname
 708                     execfile(scrname,globals())
 709                 else:
 710                     print 'importing',scrname
 711                     doimport = 'import ' + scrname
 712                     exec doimport
 713             i = i + 1
 714
 715     return clt
 716
 717 # -----------------------------------------------------------------------------
 718
 719 def registerEnv(args, modules_list, modules_root_dir):
 720     """
 721     Register args, modules_list, modules_root_dir in a file
 722     for further use, when SALOME is launched embedded in an other application.
 723     """
 724     if sys.platform == "win32":
 725       fileEnv = os.getenv('TEMP')
 726     else:
 727       fileEnv = '/tmp/'
 728
 729     fileEnv += os.getenv('USER') + "_" + str(args['port']) \
 730             + '_' + args['appname'].upper() + '_env'
 731     fenv=open(fileEnv,'w')
 732     pickle.dump((args, modules_list, modules_root_dir),fenv)
 733     fenv.close()
 734     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 735
 736 # -----------------------------------------------------------------------------
 737
 738 def searchFreePort(args, save_config=1):
 739     print "Searching for a free port for naming service:",
 740     #
 741     if sys.platform == "win32":
 742         tmp_file = os.getenv('TEMP');
 743     else:
 744         tmp_file = '/tmp'
 745     tmp_file = os.path.join(tmp_file, '.netstat_%s'%os.getpid())
 746     #
 747     ###status = os.system("netstat -ltn | grep -E :%s > /dev/null 2>&1"%(NSPORT))
 748     os.system( "netstat -a -n > %s" % tmp_file );
 749     f = open( tmp_file, 'r' );
 750     ports = f.readlines();
 751     f.close();
 752     os.remove( tmp_file );
 753     #
 754     def portIsUsed(port, data):
 755         regObj = re.compile( "tcp.*:([0-9]+).*:.*listen", re.IGNORECASE );
 756         for item in data:
 757             try:
 758                 p = int(regObj.match(item).group(1))
 759                 if p == port: return True
 760                 pass
 761             except:
 762                 pass
 763             pass
 764         return False
 765     #
 766     NSPORT=2810
 767     limit=NSPORT+100
 768     #
 769     while 1:
 770         if not portIsUsed(NSPORT, ports):
 771             print "%s - OK"%(NSPORT)
 772             #
 773             from salome_utils import generateFileName, getHostName
 774             hostname = getHostName()
 775             #
 776             home  = os.getenv("HOME")
 777             appli = os.getenv("APPLI")
 778             kwargs={}
 779             if appli is not None:
 780               home = os.path.join(home, appli,"USERS")
 781               kwargs["with_username"]=True
 782             #
 783             omniorb_config = generateFileName(home, prefix="omniORB",
 784                                               extension="cfg",
 785                                               hidden=True,
 786                                               with_hostname=True,
 787                                               with_port=NSPORT,
 788                                               **kwargs)
 789             orbdata = []
 790             initref = "NameService=corbaname::%s:%s"%(hostname, NSPORT)
 791             from omniORB import CORBA
 792             if CORBA.ORB_ID == "omniORB4":
 793                 orbdata.append("InitRef = %s"%(initref))
 794                 orbdata.append("giopMaxMsgSize = 2097152000  # 2 GBytes")
 795                 orbdata.append("traceLevel = 0 # critical errors only")
 796             else:
 797                 orbdata.append("ORBInitRef %s"%(initref))
 798                 orbdata.append("ORBgiopMaxMsgSize = 2097152000  # 2 GBytes")
 799                 orbdata.append("ORBtraceLevel = 0 # critical errors only")
 800                 pass
 801             orbdata.append("")
 802             f = open(omniorb_config, "w")
 803             f.write("\n".join(orbdata))
 804             f.close()
 805             #
 806             os.environ['OMNIORB_CONFIG'] = omniorb_config
 807             os.environ['NSPORT'] = "%s"%(NSPORT)
 808             os.environ['NSHOST'] = "%s"%(hostname)
 809             args['port'] = os.environ['NSPORT']
 810             #
 811             if save_config:
 812                 last_running_config = generateFileName(home, prefix="omniORB",
 813                                                        suffix="last",
 814                                                        extension="cfg",
 815                                                        hidden=True,
 816                                                        **kwargs)
 817                 try:
 818                     if sys.platform == "win32":
 819                         import shutil
 820                         shutil.copyfile(omniorb_config, last_running_config)
 821                     else:
 822                         try:
 823                             os.remove(last_running_config)
 824                         except OSError:
 825                             pass
 826                         os.symlink(omniorb_config, last_running_config)
 827                         pass
 828                     pass
 829                 except:
 830                     pass
 831             break
 832         print "%s"%(NSPORT),
 833         if NSPORT == limit:
 834             msg  = "\n"
 835             msg += "Can't find a free port to launch omniNames\n"
 836             msg += "Try to kill the running servers and then launch SALOME again.\n"
 837             raise msg
 838         NSPORT=NSPORT+1
 839         pass
 840     return
 841
 842 # -----------------------------------------------------------------------------
 843
 844 def no_main():
 845     """Salome Launch, when embedded in other application"""
 846     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 847     fenv=open(fileEnv,'r')
 848     args, modules_list, modules_root_dir = pickle.load(fenv)
 849     fenv.close()
 850     kill_salome(args)
 851     searchFreePort(args, 0)
 852     clt = useSalome(args, modules_list, modules_root_dir)
 853     return clt
 854
 855 # -----------------------------------------------------------------------------
 856
 857 def main():
 858     """Salome launch as a main application"""
 859     import sys
 860     from salome_utils import getHostName
 861     print "runSalome running on %s" % getHostName()
 862     args, modules_list, modules_root_dir = setenv.get_config()
 863     kill_salome(args)
 864     save_config = True
 865     if args.has_key('save_config'):
 866         save_config = args['save_config']
 867     searchFreePort(args, save_config)
 868     #setenv.main()
 869     setenv.set_env(args, modules_list, modules_root_dir)
 870     clt = useSalome(args, modules_list, modules_root_dir)
 871     return clt,args
 872
 873 # -----------------------------------------------------------------------------
 874
 875 if __name__ == "__main__":
 876    import user
 877    clt,args = main()