bin/runSalome.py

   1 #!/usr/bin/env python
   2 #  -*- coding: iso-8859-1 -*-
   3 #  Copyright (C) 2007-2010  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.
  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 server import *
  33 from launchConfigureParser import verbose
  34 from server import process_id
  35
  36 if sys.platform == "win32":
  37   SEP = ";"
  38 else:
  39   SEP = ":"
  40
  41 # -----------------------------------------------------------------------------
  42
  43 from killSalome import killAllPorts
  44
  45 def killLocalPort():
  46     """
  47     kill servers from a previous SALOME exection, if needed,
  48     on the CORBA port given in args of runSalome
  49     """
  50
  51     from killSalomeWithPort import killMyPort
  52     my_port=str(args['port'])
  53     try:
  54         killMyPort(my_port)
  55     except:
  56         print "problem in killLocalPort()"
  57         pass
  58     pass
  59
  60 def givenPortKill(port):
  61     """
  62     kill servers from a previous SALOME exection, if needed,
  63     on the same CORBA port
  64     """
  65
  66     from killSalomeWithPort import killMyPort
  67     my_port=port
  68     try:
  69         killMyPort(my_port)
  70     except:
  71         print "problem in LocalPortKill(), killMyPort("<<port<<")"
  72         pass
  73     pass
  74
  75 def kill_salome(args):
  76     """
  77     Kill servers from previous SALOME executions, if needed;
  78     depending on args 'killall' or 'portkill', kill all executions,
  79     or only execution on the same CORBA port
  80     """
  81
  82     if args['killall']:
  83         killAllPorts()
  84     elif args['portkill']:
  85         givenPortKill(str(args['port']))
  86
  87 # -----------------------------------------------------------------------------
  88 #
  89 # Class definitions to launch CORBA Servers
  90 #
  91
  92 class InterpServer(Server):
  93     def __init__(self,args):
  94         self.args=args
  95         if sys.platform != "win32":
  96           env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  97           self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
  98         else:
  99           self.CMD=['cmd', '/c', 'start cmd.exe', '/K', 'python']
 100
 101     def run(self):
 102         global process_id
 103         command = self.CMD
 104         print "INTERPSERVER::command = ", command
 105         if sys.platform == "win32":
 106           import win32pm
 107           pid = win32pm.spawnpid( string.join(command, " "),'-nc' )
 108         else:
 109           pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 110         process_id[pid]=self.CMD
 111         self.PID = pid
 112
 113 # ---
 114
 115 def get_cata_path(list_modules,modules_root_dir):
 116     """Build a list of catalog paths (cata_path) to initialize the ModuleCatalog server
 117     """
 118     modules_cata={}
 119     cata_path=[]
 120
 121     for module in list_modules:
 122         if modules_root_dir.has_key(module):
 123             module_root_dir=modules_root_dir[module]
 124             module_cata=module+"Catalog.xml"
 125             cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources",module.lower(), module_cata)
 126
 127             if os.path.exists(cata_file):
 128                 cata_path.append(cata_file)
 129                 modules_cata[module]=cata_file
 130             else:
 131                 cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources", module_cata)
 132                 if os.path.exists(cata_file):
 133                     cata_path.append(cata_file)
 134                     modules_cata[module]=cata_file
 135
 136     for path in os.getenv("SALOME_CATALOGS_PATH","").split(SEP):
 137         if os.path.exists(path):
 138             for cata_file in glob.glob(os.path.join(path,"*Catalog.xml")):
 139                 module_name= os.path.basename(cata_file)[:-11]
 140                 if not modules_cata.has_key(module_name):
 141                     cata_path.append(cata_file)
 142                     modules_cata[module_name]=cata_file
 143
 144     return cata_path
 145
 146
 147
 148 class CatalogServer(Server):
 149     def __init__(self,args):
 150         self.args=args
 151         self.initArgs()
 152         self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
 153         self.SCMD2=[]
 154         home_dir=os.getenv('HOME')
 155         if home_dir is not None:
 156             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 157
 158     def setpath(self,modules_list,modules_root_dir):
 159         list_modules = modules_list[:]
 160         list_modules.reverse()
 161         if self.args["gui"] :
 162             list_modules = ["KERNEL", "GUI"] + list_modules
 163         else :
 164             list_modules = ["KERNEL"] + list_modules
 165
 166         cata_path=get_cata_path(list_modules,modules_root_dir)
 167
 168         self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
 169
 170 # ---
 171
 172 class SalomeDSServer(Server):
 173     def __init__(self,args):
 174         self.args=args
 175         self.initArgs()
 176         self.CMD=['SALOMEDS_Server']
 177
 178 # ---
 179
 180 class ConnectionManagerServer(Server):
 181     def __init__(self,args):
 182         self.args=args
 183         self.initArgs()
 184         self.CMD=['SALOME_ConnectionManagerServer']
 185
 186 # ---
 187
 188 class RegistryServer(Server):
 189     def __init__(self,args):
 190         self.args=args
 191         self.initArgs()
 192         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 193
 194 # ---
 195
 196 class ContainerCPPServer(Server):
 197     def __init__(self,args):
 198         self.args=args
 199         self.initArgs()
 200         self.CMD=['SALOME_Container','FactoryServer']
 201
 202 # ---
 203
 204 class ContainerPYServer(Server):
 205     def __init__(self,args):
 206         self.args=args
 207         self.initArgs()
 208         if sys.platform == "win32":
 209           self.CMD=[os.environ["PYTHONBIN"], '\"'+os.environ["KERNEL_ROOT_DIR"] + '/bin/salome/SALOME_ContainerPy.py'+'\"','FactoryServerPy']
 210         else:
 211           self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
 212
 213 # ---
 214
 215 class LoggerServer(Server):
 216     def __init__(self,args):
 217         self.args=args
 218         self.initArgs()
 219         from salome_utils import generateFileName
 220         if sys.platform == "win32": dirpath = os.environ["HOME"]
 221         else:                       dirpath = "/tmp"
 222         logfile = generateFileName( dirpath,
 223                                     prefix="logger",
 224                                     extension="log",
 225                                     with_username=True,
 226                                     with_hostname=True,
 227                                     with_port=True)
 228         print "==========================================================="
 229         print "Logger server: put log to the file:"
 230         print logfile
 231         print "==========================================================="
 232         self.CMD=['SALOME_Logger_Server', logfile]
 233         pass
 234     pass # end of LoggerServer class
 235
 236 # ---
 237
 238 class SessionServer(Server):
 239     def __init__(self,args,modules_list,modules_root_dir):
 240         self.args = args.copy()
 241         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 242         #self.args['xterm']=0
 243         #
 244         self.initArgs()
 245         self.SCMD1=['SALOME_Session_Server']
 246         self.SCMD2=[]
 247         if 'registry' in self.args['embedded']:
 248             self.SCMD1+=['--with','Registry',
 249                          '(','--salome_session','theSession',')']
 250         if 'moduleCatalog' in self.args['embedded']:
 251             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 252             home_dir=os.getenv('HOME')
 253             if home_dir is not None:
 254                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 255             self.SCMD2+=[')']
 256         if 'study' in self.args['embedded']:
 257             self.SCMD2+=['--with','SALOMEDS','(',')']
 258         if 'cppContainer' in self.args['embedded']:
 259             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 260         if 'SalomeAppEngine' in self.args['embedded']:
 261             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 262
 263         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 264             self.SCMD2+=['CPP']
 265         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 266             self.SCMD2+=['PY']
 267         if self.args['gui']:
 268             session_gui = True
 269             if self.args.has_key('session_gui'):
 270                 session_gui = self.args['session_gui']
 271             if session_gui:
 272                 self.SCMD2+=['GUI']
 273                 if self.args['splash']:
 274                     self.SCMD2+=['SPLASH']
 275                     pass
 276                 if self.args['study_hdf'] is not None:
 277                     self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
 278                     pass
 279                 pass
 280             pass
 281         if self.args['noexcepthandler']:
 282             self.SCMD2+=['noexcepthandler']
 283         if self.args.has_key('user_config'):
 284             self.SCMD2+=['--resources=%s'%self.args['user_config']]
 285         if self.args.has_key('modules'):
 286             list_modules = []
 287             #keep only modules with GUI
 288             for m in modules_list:
 289               fr1 = os.path.join(modules_root_dir[m],"share","salome","resources",m.lower(),"SalomeApp.xml")
 290               fr2 = os.path.join(modules_root_dir[m],"share","salome","resources","SalomeApp.xml")
 291               if os.path.exists(fr1) or os.path.exists(fr2):
 292                 list_modules.insert(0,m)
 293             self.SCMD2+=['--modules (%s)' % ":".join(list_modules)]
 294
 295         if self.args.has_key('pyscript') and len(self.args['pyscript']) > 0:
 296             self.SCMD2+=['--pyscript=%s'%(",".join(self.args['pyscript']))]
 297
 298     def setpath(self,modules_list,modules_root_dir):
 299         list_modules = modules_list[:]
 300         list_modules.reverse()
 301         if self.args["gui"] :
 302             list_modules = ["KERNEL", "GUI"] + list_modules
 303         else :
 304             list_modules = ["KERNEL"] + list_modules
 305
 306         cata_path=get_cata_path(list_modules,modules_root_dir)
 307
 308         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 309             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 310             self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
 311         else:
 312             self.CMD=self.SCMD1 + self.SCMD2
 313         if self.args.has_key('test'):
 314             self.CMD+=['-test'] + self.args['test']
 315         elif self.args.has_key('play'):
 316             self.CMD+=['-play'] + self.args['play']
 317
 318         if self.args["gdb_session"] or self.args["ddd_session"]:
 319             f = open(".gdbinit4salome", "w")
 320             f.write("set args ")
 321             args = " ".join(self.CMD[1:])
 322             args = args.replace("(", "\(")
 323             args = args.replace(")", "\)")
 324             f.write(args)
 325             f.write("\n")
 326             f.close()
 327             if self.args["ddd_session"]:
 328                 self.CMD = ["ddd", "--command=.gdbinit4salome", self.CMD[0]]
 329             elif self.args["gdb_session"]:
 330                 self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
 331                 pass
 332             pass
 333
 334         if self.args["valgrind_session"]:
 335             l = ["valgrind"]
 336             val = os.getenv("VALGRIND_OPTIONS")
 337             if val:
 338                 l += val.split()
 339                 pass
 340             self.CMD = l + self.CMD
 341             pass
 342
 343 # ---
 344
 345 class LauncherServer(Server):
 346     def __init__(self,args):
 347         self.args=args
 348         self.initArgs()
 349         self.SCMD1=['SALOME_LauncherServer']
 350         self.SCMD2=[]
 351         if args["gui"] :
 352             if 'registry' in self.args['embedded']:
 353                 self.SCMD1+=['--with','Registry',
 354                              '(','--salome_session','theSession',')']
 355             if 'moduleCatalog' in self.args['embedded']:
 356                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 357                 self.SCMD2+=['-personal',
 358                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 359             if 'study' in self.args['embedded']:
 360                 self.SCMD2+=['--with','SALOMEDS','(',')']
 361             if 'cppContainer' in self.args['embedded']:
 362                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 363
 364     def setpath(self,modules_list,modules_root_dir):
 365         list_modules = modules_list[:]
 366         list_modules.reverse()
 367         if self.args["gui"] :
 368             list_modules = ["KERNEL", "GUI"] + list_modules
 369         else :
 370             list_modules = ["KERNEL"] + list_modules
 371
 372         cata_path=get_cata_path(list_modules,modules_root_dir)
 373
 374         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 375             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 376             self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
 377         else:
 378             self.CMD=self.SCMD1 + self.SCMD2
 379
 380 class NotifyServer(Server):
 381     def __init__(self,args,modules_root_dir):
 382         self.args=args
 383         self.initArgs()
 384         self.modules_root_dir=modules_root_dir
 385         myLogName = os.environ["LOGNAME"]
 386         self.CMD=['notifd','-c',
 387                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/kernel/channel.cfg',
 388                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 389                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 390                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 391                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 392                   ]
 393
 394 #
 395 # -----------------------------------------------------------------------------
 396
 397 def startGUI():
 398     """Salome Session Graphic User Interface activation"""
 399     import Engines
 400     import SALOME
 401     import SALOMEDS
 402     import SALOME_ModuleCatalog
 403     import SALOME_Session_idl
 404     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 405     session.GetInterface()
 406
 407 # -----------------------------------------------------------------------------
 408
 409 def startSalome(args, modules_list, modules_root_dir):
 410     """Launch all SALOME servers requested by args"""
 411     init_time = os.times()
 412
 413     if verbose(): print "startSalome ", args
 414
 415     #
 416     # Initialisation ORB and Naming Service
 417     #
 418
 419     clt=orbmodule.client(args)
 420     # Save Naming service port name into
 421     # the file args["ns_port_log_file"]
 422     if args.has_key('ns_port_log_file'):
 423       home = os.environ['HOME']
 424       appli= os.environ.get("APPLI")
 425       if appli is not None:
 426         home='%s/%s'%(home,appli)
 427         pass
 428       file_name= '%s/%s'%(home, args["ns_port_log_file"])
 429       f = open(file_name, "w")
 430       f.write(os.environ['NSPORT'])
 431       f.close()
 432
 433     # Launch Logger Server (optional)
 434     # and wait until it is registered in naming service
 435     #
 436
 437     if args['logger']:
 438         myServer=LoggerServer(args)
 439         myServer.run()
 440         clt.waitLogger("Logger")
 441
 442     # Notify Server launch
 443     #
 444
 445     if sys.platform != "win32":
 446       if verbose(): print "Notify Server to launch"
 447
 448       myServer=NotifyServer(args,modules_root_dir)
 449       myServer.run()
 450
 451     # Launch  Session Server (to show splash ASAP)
 452     #
 453
 454     if args["gui"]:
 455         mySessionServ = SessionServer(args,modules_list,modules_root_dir)
 456         mySessionServ.setpath(modules_list,modules_root_dir)
 457         mySessionServ.run()
 458
 459     #
 460     # Launch Registry Server,
 461     # and wait until it is registered in naming service
 462     #
 463
 464     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 465         myServer=RegistryServer(args)
 466         myServer.run()
 467         if sys.platform == "win32":
 468           clt.waitNS("/Registry")
 469         else:
 470           clt.waitNSPID("/Registry",myServer.PID)
 471
 472     #
 473     # Launch Catalog Server,
 474     # and wait until it is registered in naming service
 475     #
 476
 477     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 478         cataServer=CatalogServer(args)
 479         cataServer.setpath(modules_list,modules_root_dir)
 480         cataServer.run()
 481         import SALOME_ModuleCatalog
 482         if sys.platform == "win32":
 483           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 484         else:
 485           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 486
 487     #
 488     # Launch SalomeDS Server,
 489     # and wait until it is registered in naming service
 490     #
 491
 492     #print "ARGS = ",args
 493     if ('study' not in args['embedded']) | (args["gui"] == 0):
 494         print "RunStudy"
 495         myServer=SalomeDSServer(args)
 496         myServer.run()
 497         if sys.platform == "win32":
 498           clt.waitNS("/myStudyManager")
 499         else:
 500           clt.waitNSPID("/myStudyManager",myServer.PID)
 501
 502     #
 503     # Launch LauncherServer
 504     #
 505
 506     myCmServer = LauncherServer(args)
 507     myCmServer.setpath(modules_list,modules_root_dir)
 508     myCmServer.run()
 509
 510     #
 511     # Launch ConnectionManagerServer
 512     #
 513
 514     myConnectionServer = ConnectionManagerServer(args)
 515     myConnectionServer.run()
 516
 517
 518     from Utils_Identity import getShortHostName
 519
 520     if os.getenv("HOSTNAME") == None:
 521         if os.getenv("HOST") == None:
 522             os.environ["HOSTNAME"]=getShortHostName()
 523         else:
 524             os.environ["HOSTNAME"]=os.getenv("HOST")
 525
 526     theComputer = getShortHostName()
 527
 528     #
 529     # Launch local C++ Container (FactoryServer),
 530     # and wait until it is registered in naming service
 531     #
 532
 533     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 534         myServer=ContainerCPPServer(args)
 535         myServer.run()
 536         if sys.platform == "win32":
 537           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 538         else:
 539           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 540
 541     #
 542     # Launch local Python Container (FactoryServerPy),
 543     # and wait until it is registered in naming service
 544     #
 545
 546     if 'pyContainer' in args['standalone']:
 547         myServer=ContainerPYServer(args)
 548         myServer.run()
 549         if sys.platform == "win32":
 550           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 551         else:
 552           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 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     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     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                 args['shutdown_servers'] = __utils__(args['port'])
 678                 pass
 679             pass
 680
 681         # run python scripts, passed via --execute option
 682         toimport = []
 683         if args.has_key('pyscript'):
 684             if args.has_key('gui') and args.has_key('session_gui'):
 685                 if not args['gui'] or not args['session_gui']:
 686                     toimport = args['pyscript']
 687
 688         for srcname in toimport :
 689             if srcname == 'killall':
 690                 clt.showNS()
 691                 killAllPorts()
 692                 sys.exit(0)
 693             else:
 694                 if os.path.isabs(srcname):
 695                     if os.path.exists(srcname):
 696                         execScript(srcname)
 697                     elif os.path.exists(srcname+".py"):
 698                         execScript(srcname+".py")
 699                     else:
 700                         print "Can't execute file %s" % srcname
 701                     pass
 702                 else:
 703                     found = False
 704                     for path in [os.getcwd()] + sys.path:
 705                         if os.path.exists(os.path.join(path,srcname)):
 706                             execScript(os.path.join(path,srcname))
 707                             found = True
 708                             break
 709                         elif os.path.exists(os.path.join(path,srcname+".py")):
 710                             execScript(os.path.join(path,srcname+".py"))
 711                             found = True
 712                             break
 713                         pass
 714                     if not found:
 715                         print "Can't execute file %s" % srcname
 716                         pass
 717                     pass
 718                 pass
 719             pass
 720         pass
 721     return clt
 722
 723 def execScript(script_path):
 724     print 'executing', script_path
 725     sys.path.insert(0, os.path.dirname(script_path))
 726     execfile(script_path,globals())
 727     del sys.path[0]
 728
 729 # -----------------------------------------------------------------------------
 730
 731 def registerEnv(args, modules_list, modules_root_dir):
 732     """
 733     Register args, modules_list, modules_root_dir in a file
 734     for further use, when SALOME is launched embedded in an other application.
 735     """
 736     if sys.platform == "win32":
 737       fileEnv = os.getenv('TEMP')
 738     else:
 739       fileEnv = '/tmp/'
 740
 741     fileEnv += os.getenv('USER') + "_" + str(args['port']) \
 742             + '_' + args['appname'].upper() + '_env'
 743     fenv=open(fileEnv,'w')
 744     pickle.dump((args, modules_list, modules_root_dir),fenv)
 745     fenv.close()
 746     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 747
 748 # -----------------------------------------------------------------------------
 749
 750 def searchFreePort(args, save_config=1):
 751     print "Searching for a free port for naming service:",
 752     #
 753     if sys.platform == "win32":
 754         tmp_file = os.getenv('TEMP');
 755     else:
 756         tmp_file = '/tmp'
 757     tmp_file = os.path.join(tmp_file, '.netstat_%s'%os.getpid())
 758     #
 759     ###status = os.system("netstat -ltn | grep -E :%s > /dev/null 2>&1"%(NSPORT))
 760     os.system( "netstat -a -n > %s" % tmp_file );
 761     f = open( tmp_file, 'r' );
 762     ports = f.readlines();
 763     f.close();
 764     os.remove( tmp_file );
 765     #
 766     def portIsUsed(port, data):
 767         regObj = re.compile( ".*tcp.*:([0-9]+).*:.*listen", re.IGNORECASE );
 768         for item in data:
 769             try:
 770                 p = int(regObj.match(item).group(1))
 771                 if p == port: return True
 772                 pass
 773             except:
 774                 pass
 775             pass
 776         return False
 777     #
 778     NSPORT=2810
 779     limit=NSPORT+100
 780     #
 781     while 1:
 782         if not portIsUsed(NSPORT, ports):
 783             print "%s - OK"%(NSPORT)
 784             #
 785             from salome_utils import generateFileName, getHostName
 786             hostname = getHostName()
 787             #
 788             home  = os.getenv("HOME")
 789             appli = os.getenv("APPLI")
 790             kwargs={}
 791             if appli is not None:
 792               home = os.path.join(home, appli,"USERS")
 793               kwargs["with_username"]=True
 794             #
 795             omniorb_config = generateFileName(home, prefix="omniORB",
 796                                               extension="cfg",
 797                                               hidden=True,
 798                                               with_hostname=True,
 799                                               with_port=NSPORT,
 800                                               **kwargs)
 801             orbdata = []
 802             initref = "NameService=corbaname::%s:%s"%(hostname, NSPORT)
 803             from omniORB import CORBA
 804             if CORBA.ORB_ID == "omniORB4":
 805                 orbdata.append("InitRef = %s"%(initref))
 806                 orbdata.append("giopMaxMsgSize = 2097152000  # 2 GBytes")
 807                 orbdata.append("traceLevel = 0 # critical errors only")
 808             else:
 809                 orbdata.append("ORBInitRef %s"%(initref))
 810                 orbdata.append("ORBgiopMaxMsgSize = 2097152000  # 2 GBytes")
 811                 orbdata.append("ORBtraceLevel = 0 # critical errors only")
 812                 pass
 813             orbdata.append("")
 814             f = open(omniorb_config, "w")
 815             f.write("\n".join(orbdata))
 816             f.close()
 817             #
 818             os.environ['OMNIORB_CONFIG'] = omniorb_config
 819             os.environ['NSPORT'] = "%s"%(NSPORT)
 820             os.environ['NSHOST'] = "%s"%(hostname)
 821             args['port'] = os.environ['NSPORT']
 822             #
 823             if save_config:
 824                 last_running_config = generateFileName(home, prefix="omniORB",
 825                                                        suffix="last",
 826                                                        extension="cfg",
 827                                                        hidden=True,
 828                                                        **kwargs)
 829                 try:
 830                     if sys.platform == "win32":
 831                         import shutil
 832                         shutil.copyfile(omniorb_config, last_running_config)
 833                     else:
 834                         try:
 835                             os.remove(last_running_config)
 836                         except OSError:
 837                             pass
 838                         os.symlink(omniorb_config, last_running_config)
 839                         pass
 840                     pass
 841                 except:
 842                     pass
 843             break
 844         print "%s"%(NSPORT),
 845         if NSPORT == limit:
 846             msg  = "\n"
 847             msg += "Can't find a free port to launch omniNames\n"
 848             msg += "Try to kill the running servers and then launch SALOME again.\n"
 849             raise RuntimeError, msg
 850         NSPORT=NSPORT+1
 851         pass
 852     return
 853
 854 # -----------------------------------------------------------------------------
 855
 856 def no_main():
 857     """Salome Launch, when embedded in other application"""
 858     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 859     fenv=open(fileEnv,'r')
 860     args, modules_list, modules_root_dir = pickle.load(fenv)
 861     fenv.close()
 862     kill_salome(args)
 863     searchFreePort(args, 0)
 864     clt = useSalome(args, modules_list, modules_root_dir)
 865     return clt
 866
 867 # -----------------------------------------------------------------------------
 868
 869 def main():
 870     """Salome launch as a main application"""
 871     from salome_utils import getHostName
 872     print "runSalome running on %s" % getHostName()
 873     args, modules_list, modules_root_dir = setenv.get_config()
 874     kill_salome(args)
 875     save_config = True
 876     if args.has_key('save_config'):
 877         save_config = args['save_config']
 878     searchFreePort(args, save_config)
 879     #setenv.main()
 880     setenv.set_env(args, modules_list, modules_root_dir)
 881     clt = useSalome(args, modules_list, modules_root_dir)
 882     return clt,args
 883
 884 # -----------------------------------------------------------------------------
 885
 886 if __name__ == "__main__":
 887    import user
 888    clt,args = main()