bin/runSalome.py

   1 #!/usr/bin/env python
   2 #  -*- coding: iso-8859-1 -*-
   3 #  Copyright (C) 2007-2008  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 ## @package runSalome
  25 # \brief Module that provides services to launch SALOME
  26 #
  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 # -----------------------------------------------------------------------------
  37
  38 from killSalome import killAllPorts
  39
  40 def killLocalPort():
  41     """
  42     kill servers from a previous SALOME exection, if needed,
  43     on the CORBA port given in args of runSalome
  44     """
  45
  46     from killSalomeWithPort import killMyPort
  47     my_port=str(args['port'])
  48     try:
  49         killMyPort(my_port)
  50     except:
  51         print "problem in killLocalPort()"
  52         pass
  53     pass
  54
  55 def givenPortKill(port):
  56     """
  57     kill servers from a previous SALOME exection, if needed,
  58     on the same CORBA port
  59     """
  60
  61     from killSalomeWithPort import killMyPort
  62     my_port=port
  63     try:
  64         killMyPort(my_port)
  65     except:
  66         print "problem in LocalPortKill(), killMyPort("<<port<<")"
  67         pass
  68     pass
  69
  70 def kill_salome(args):
  71     """
  72     Kill servers from previous SALOME executions, if needed;
  73     depending on args 'killall' or 'portkill', kill all executions,
  74     or only execution on the same CORBA port
  75     """
  76
  77     if args['killall']:
  78         killAllPorts()
  79     elif args['portkill']:
  80         givenPortKill(str(args['port']))
  81
  82 # -----------------------------------------------------------------------------
  83 #
  84 # Class definitions to launch CORBA Servers
  85 #
  86
  87 class InterpServer(Server):
  88     def __init__(self,args):
  89         self.args=args
  90         env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  91         self.CMD=['xterm', '-e']+ env_ld_library_path + ['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 LoggerServer(Server):
 199     def __init__(self,args):
 200         self.args=args
 201         self.initArgs()
 202         from salome_utils import generateFileName
 203         if sys.platform == "win32": dirpath = os.environ["HOME"]
 204         else:                       dirpath = "/tmp"
 205         logfile = generateFileName( dirpath,
 206                                     prefix="logger",
 207                                     extension="log",
 208                                     with_username=True,
 209                                     with_hostname=True,
 210                                     with_port=True)
 211         print "==========================================================="
 212         print "Logger server: put log to the file:"
 213         print logfile
 214         print "==========================================================="
 215         self.CMD=['SALOME_Logger_Server', logfile]
 216         pass
 217     pass # end of LoggerServer class
 218
 219 # ---
 220
 221 class SessionServer(Server):
 222     def __init__(self,args):
 223         self.args = args.copy()
 224         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 225         #self.args['xterm']=0
 226         #
 227         self.initArgs()
 228         self.SCMD1=['SALOME_Session_Server']
 229         self.SCMD2=[]
 230         if 'registry' in self.args['embedded']:
 231             self.SCMD1+=['--with','Registry',
 232                          '(','--salome_session','theSession',')']
 233         if 'moduleCatalog' in self.args['embedded']:
 234             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 235             home_dir=os.getenv('HOME')
 236             if home_dir is not None:
 237                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 238             self.SCMD2+=[')']
 239         if 'study' in self.args['embedded']:
 240             self.SCMD2+=['--with','SALOMEDS','(',')']
 241         if 'cppContainer' in self.args['embedded']:
 242             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 243         if 'SalomeAppEngine' in self.args['embedded']:
 244             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 245
 246         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 247             self.SCMD2+=['CPP']
 248         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 249             self.SCMD2+=['PY']
 250         if self.args['gui']:
 251             session_gui = True
 252             if self.args.has_key('session_gui'):
 253                 session_gui = self.args['session_gui']
 254             if session_gui:
 255                 self.SCMD2+=['GUI']
 256                 if self.args['splash']:
 257                     self.SCMD2+=['SPLASH']
 258                     pass
 259                 if self.args['study_hdf'] is not None:
 260                     self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
 261                     pass
 262                 pass
 263             pass
 264         if self.args['noexcepthandler']:
 265             self.SCMD2+=['noexcepthandler']
 266         if self.args.has_key('user_config'):
 267             self.SCMD2+=['--resources=%s'%self.args['user_config']]
 268         if self.args.has_key('modules'):
 269             self.SCMD2+=['--modules (%s)'%":".join(self.args['modules'])]
 270         if self.args.has_key('pyscript') and len(self.args['pyscript']) > 0:
 271             self.SCMD2+=['--pyscript=%s'%(",".join(self.args['pyscript']))]
 272
 273     def setpath(self,modules_list,modules_root_dir):
 274         cata_path=[]
 275         list_modules = modules_list[:]
 276         list_modules.reverse()
 277         if self.args["gui"] :
 278             list_modules = ["KERNEL", "GUI"] + list_modules
 279         else :
 280             list_modules = ["KERNEL"] + list_modules
 281         for module in list_modules:
 282             module_root_dir=modules_root_dir[module]
 283             module_cata=module+"Catalog.xml"
 284             #print "   ", module_cata
 285             if os.path.exists(os.path.join(module_root_dir,
 286                                            "share",setenv.salome_subdir,
 287                                            "resources",module.lower(),
 288                                            module_cata)):
 289                 cata_path.extend(
 290                     glob.glob(os.path.join(module_root_dir,"share",
 291                                            setenv.salome_subdir,"resources",
 292                                            module.lower(),module_cata)))
 293             else:
 294                 cata_path.extend(
 295                     glob.glob(os.path.join(module_root_dir,"share",
 296                                            setenv.salome_subdir,"resources",
 297                                            module_cata)))
 298             pass
 299         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 300             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 301             #self.CMD=self.SCMD1 + ['\"']+[string.join(cata_path,'\"::\"')] + ['\"'] + self.SCMD2
 302             self.CMD=self.SCMD1 + ['\"' + string.join(cata_path,'\"::\"') + '\"'] + self.SCMD2
 303         else:
 304             self.CMD=self.SCMD1 + self.SCMD2
 305         if self.args.has_key('test'):
 306             self.CMD+=['-test'] + self.args['test']
 307         elif self.args.has_key('play'):
 308             self.CMD+=['-play'] + self.args['play']
 309
 310         if self.args["gdb_session"] or self.args["ddd_session"]:
 311             f = open(".gdbinit4salome", "w")
 312             f.write("set args ")
 313             args = " ".join(self.CMD[1:])
 314             args = args.replace("(", "\(")
 315             args = args.replace(")", "\)")
 316             f.write(args)
 317             f.write("\n")
 318             f.close()
 319             if self.args["ddd_session"]:
 320                 self.CMD = ["ddd", "--command=.gdbinit4salome", self.CMD[0]]
 321             elif self.args["gdb_session"]:
 322                 self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
 323                 pass
 324             pass
 325
 326 # ---
 327
 328 class LauncherServer(Server):
 329     def __init__(self,args):
 330         self.args=args
 331         self.initArgs()
 332         self.SCMD1=['SALOME_LauncherServer']
 333         self.SCMD2=[]
 334         if args["gui"] :
 335             if 'registry' in self.args['embedded']:
 336                 self.SCMD1+=['--with','Registry',
 337                              '(','--salome_session','theSession',')']
 338             if 'moduleCatalog' in self.args['embedded']:
 339                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 340                 self.SCMD2+=['-personal',
 341                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 342             if 'study' in self.args['embedded']:
 343                 self.SCMD2+=['--with','SALOMEDS','(',')']
 344             if 'cppContainer' in self.args['embedded']:
 345                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 346
 347     def setpath(self,modules_list,modules_root_dir):
 348         cata_path=[]
 349         list_modules = modules_list[:]
 350         list_modules.reverse()
 351         if self.args["gui"] :
 352             list_modules = ["GUI"] + list_modules
 353         for module in ["KERNEL"] + list_modules:
 354             if modules_root_dir.has_key(module):
 355                 module_root_dir=modules_root_dir[module]
 356                 module_cata=module+"Catalog.xml"
 357                 #print "   ", module_cata
 358                 if os.path.exists(os.path.join(module_root_dir,
 359                                                "share",setenv.salome_subdir,
 360                                                "resources",module.lower(),
 361                                                module_cata)):
 362                     cata_path.extend(
 363                         glob.glob(os.path.join(module_root_dir,"share",
 364                                                setenv.salome_subdir,"resources",
 365                                                module.lower(),module_cata)))
 366                 else:
 367                     cata_path.extend(
 368                         glob.glob(os.path.join(module_root_dir,"share",
 369                                                setenv.salome_subdir,"resources",
 370                                                module_cata)))
 371                 pass
 372             pass
 373         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 374             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 375         else:
 376             self.CMD=self.SCMD1 + self.SCMD2
 377
 378 class NotifyServer(Server):
 379     def __init__(self,args,modules_root_dir):
 380         self.args=args
 381         self.initArgs()
 382         self.modules_root_dir=modules_root_dir
 383         myLogName = os.environ["LOGNAME"]
 384         self.CMD=['notifd','-c',
 385                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/kernel/channel.cfg',
 386                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 387                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 388                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 389                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 390                   ]
 391
 392 #
 393 # -----------------------------------------------------------------------------
 394
 395 def startGUI():
 396     """Salome Session Graphic User Interface activation"""
 397     import Engines
 398     import SALOME
 399     import SALOMEDS
 400     import SALOME_ModuleCatalog
 401     import SALOME_Session_idl
 402     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 403     session.GetInterface()
 404
 405 # -----------------------------------------------------------------------------
 406
 407 def startSalome(args, modules_list, modules_root_dir):
 408     """Launch all SALOME servers requested by args"""
 409     init_time = os.times()
 410
 411     if verbose(): print "startSalome ", args
 412
 413     #
 414     # Initialisation ORB and Naming Service
 415     #
 416
 417     clt=orbmodule.client(args)
 418     # Save Naming service port name into
 419     # the file args["ns_port_log_file"]
 420     if args.has_key('ns_port_log_file'):
 421       home = os.environ['HOME']
 422       appli= os.environ.get("APPLI")
 423       if appli is not None:
 424         home='%s/%s'%(home,appli)
 425         pass
 426       file_name= '%s/%s'%(home, args["ns_port_log_file"])
 427       f = open(file_name, "w")
 428       f.write(os.environ['NSPORT'])
 429       f.close()
 430
 431     # Launch Logger Server (optional)
 432     # and wait until it is registered in naming service
 433     #
 434
 435     if args['logger']:
 436         myServer=LoggerServer(args)
 437         myServer.run()
 438         clt.waitLogger("Logger")
 439
 440     # Notify Server launch
 441     #
 442
 443     if sys.platform != "win32":
 444       if verbose(): print "Notify Server to launch"
 445
 446       myServer=NotifyServer(args,modules_root_dir)
 447       myServer.run()
 448
 449     # Launch  Session Server (to show splash ASAP)
 450     #
 451
 452     if args["gui"]:
 453         mySessionServ = SessionServer(args)
 454         mySessionServ.setpath(modules_list,modules_root_dir)
 455         mySessionServ.run()
 456
 457     #
 458     # Launch Registry Server,
 459     # and wait until it is registered in naming service
 460     #
 461
 462     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 463         myServer=RegistryServer(args)
 464         myServer.run()
 465         if sys.platform == "win32":
 466           clt.waitNS("/Registry")
 467         else:
 468           clt.waitNSPID("/Registry",myServer.PID)
 469
 470     #
 471     # Launch Catalog Server,
 472     # and wait until it is registered in naming service
 473     #
 474
 475     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 476         cataServer=CatalogServer(args)
 477         cataServer.setpath(modules_list,modules_root_dir)
 478         cataServer.run()
 479         import SALOME_ModuleCatalog
 480         if sys.platform == "win32":
 481           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 482         else:
 483           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 484
 485     #
 486     # Launch SalomeDS Server,
 487     # and wait until it is registered in naming service
 488     #
 489
 490     #print "ARGS = ",args
 491     if ('study' not in args['embedded']) | (args["gui"] == 0):
 492         print "RunStudy"
 493         myServer=SalomeDSServer(args)
 494         myServer.run()
 495         if sys.platform == "win32":
 496           clt.waitNS("/myStudyManager")
 497         else:
 498           clt.waitNSPID("/myStudyManager",myServer.PID)
 499
 500     #
 501     # Launch LauncherServer
 502     #
 503
 504     myCmServer = LauncherServer(args)
 505     myCmServer.setpath(modules_list,modules_root_dir)
 506     myCmServer.run()
 507
 508     #
 509     # Launch ConnectionManagerServer
 510     #
 511
 512     myConnectionServer = ConnectionManagerServer(args)
 513     myConnectionServer.run()
 514
 515
 516     from Utils_Identity import getShortHostName
 517
 518     if os.getenv("HOSTNAME") == None:
 519         if os.getenv("HOST") == None:
 520             os.environ["HOSTNAME"]=getShortHostName()
 521         else:
 522             os.environ["HOSTNAME"]=os.getenv("HOST")
 523
 524     theComputer = getShortHostName()
 525
 526     #
 527     # Launch local C++ Container (FactoryServer),
 528     # and wait until it is registered in naming service
 529     #
 530
 531     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 532         myServer=ContainerCPPServer(args)
 533         myServer.run()
 534         if sys.platform == "win32":
 535           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 536         else:
 537           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 538
 539     #
 540     # Launch local Python Container (FactoryServerPy),
 541     # and wait until it is registered in naming service
 542     #
 543
 544     if 'pyContainer' in args['standalone']:
 545         myServer=ContainerPYServer(args)
 546         myServer.run()
 547         if sys.platform == "win32":
 548           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 549         else:
 550           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 551
 552     #
 553     # Wait until Session Server is registered in naming service
 554     #
 555
 556     if args["gui"]:
 557 ##----------------
 558         import Engines
 559         import SALOME
 560         import SALOMEDS
 561         import SALOME_ModuleCatalog
 562         import SALOME_Session_idl
 563         if sys.platform == "win32":
 564           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 565         else:
 566           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 567     end_time = os.times()
 568     if verbose(): print
 569     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 570                                                          - init_time[4])
 571
 572     # ASV start GUI without Loader
 573     #if args['gui']:
 574     #    session.GetInterface()
 575
 576     #
 577     # additionnal external python interpreters
 578     #
 579     nbaddi=0
 580
 581     try:
 582         if 'interp' in args:
 583             nbaddi = args['interp']
 584     except:
 585         import traceback
 586         traceback.print_exc()
 587         print "-------------------------------------------------------------"
 588         print "-- to get an external python interpreter:runSalome --interp=1"
 589         print "-------------------------------------------------------------"
 590
 591     print "additional external python interpreters: ", nbaddi
 592     if nbaddi:
 593         for i in range(nbaddi):
 594             print "i=",i
 595             anInterp=InterpServer(args)
 596             anInterp.run()
 597
 598     # set PYTHONINSPECT variable (python interpreter in interactive mode)
 599     if args['pinter']:
 600         os.environ["PYTHONINSPECT"]="1"
 601         import readline
 602
 603     return clt
 604
 605 # -----------------------------------------------------------------------------
 606
 607 def useSalome(args, modules_list, modules_root_dir):
 608     """
 609     Launch all SALOME servers requested by args,
 610     save list of process, give info to user,
 611     show registered objects in Naming Service.
 612     """
 613     global process_id
 614
 615     clt=None
 616     try:
 617         clt = startSalome(args, modules_list, modules_root_dir)
 618     except:
 619         import traceback
 620         traceback.print_exc()
 621         print
 622         print
 623         print "--- Error during Salome launch ---"
 624
 625     #print process_id
 626
 627     from addToKillList import addToKillList
 628     from killSalomeWithPort import getPiDict
 629
 630     filedict = getPiDict(args['port'])
 631     for pid, cmd in process_id.items():
 632         addToKillList(pid, cmd, args['port'])
 633         pass
 634
 635     if verbose(): print """
 636     Saving of the dictionary of Salome processes in %s
 637     To kill SALOME processes from a console (kill all sessions from all ports):
 638       python killSalome.py
 639     To kill SALOME from the present interpreter, if it is not closed :
 640       killLocalPort()      --> kill this session
 641                                (use CORBA port from args of runSalome)
 642       givenPortKill(port)  --> kill a specific session with given CORBA port
 643       killAllPorts()       --> kill all sessions
 644
 645     runSalome, with --killall option, starts with killing
 646     the processes resulting from the previous execution.
 647     """%filedict
 648
 649     #
 650     #  Print Naming Service directory list
 651     #
 652
 653     if clt != None:
 654         if verbose():
 655             print
 656             print " --- registered objects tree in Naming Service ---"
 657             clt.showNS()
 658             pass
 659
 660         if not args['gui'] or not args['session_gui']:
 661             if args['shutdown_servers']:
 662                 class __utils__(object):
 663                     def __init__(self, port):
 664                         self.port = port
 665                         import killSalomeWithPort
 666                         self.killSalomeWithPort = killSalomeWithPort
 667                         return
 668                     def __del__(self):
 669                         self.killSalomeWithPort.killMyPort(self.port)
 670                         return
 671                     pass
 672                 args['shutdown_servers'] = __utils__(args['port'])
 673                 pass
 674             pass
 675
 676         # run python scripts, passed via --execute option
 677         toimport = []
 678         if args.has_key('pyscript'):
 679             if args.has_key('gui') and args.has_key('session_gui'):
 680                 if not args['gui'] or not args['session_gui']:
 681                     toimport = args['pyscript']
 682         i = 0
 683         while i < len( toimport ) :
 684             if toimport[ i ] == 'killall':
 685                 clt.showNS()
 686                 killAllPorts()
 687                 sys.exit(0)
 688             else:
 689                 scrname = toimport[ i ]
 690                 if len(scrname) > 2 and (len(scrname) - string.rfind(scrname, ".py") == 3):
 691                     print 'executing',scrname
 692                     sys.path.insert( 0, os.path.dirname(scrname))
 693                     execfile(scrname,globals())
 694                     del sys.path[0]
 695                 else:
 696                     print 'importing',scrname
 697                     doimport = 'import ' + scrname
 698                     exec doimport
 699             i = i + 1
 700
 701     return clt
 702
 703 # -----------------------------------------------------------------------------
 704
 705 def registerEnv(args, modules_list, modules_root_dir):
 706     """
 707     Register args, modules_list, modules_root_dir in a file
 708     for further use, when SALOME is launched embedded in an other application.
 709     """
 710     if sys.platform == "win32":
 711       fileEnv = os.getenv('TEMP')
 712     else:
 713       fileEnv = '/tmp/'
 714
 715     fileEnv += os.getenv('USER') + "_" + str(args['port']) \
 716             + '_' + args['appname'].upper() + '_env'
 717     fenv=open(fileEnv,'w')
 718     pickle.dump((args, modules_list, modules_root_dir),fenv)
 719     fenv.close()
 720     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 721
 722 # -----------------------------------------------------------------------------
 723
 724 def searchFreePort(args, save_config=1):
 725     print "Searching for a free port for naming service:",
 726     #
 727     if sys.platform == "win32":
 728         tmp_file = os.getenv('TEMP');
 729     else:
 730         tmp_file = '/tmp'
 731     tmp_file = os.path.join(tmp_file, '.netstat_%s'%os.getpid())
 732     #
 733     ###status = os.system("netstat -ltn | grep -E :%s > /dev/null 2>&1"%(NSPORT))
 734     os.system( "netstat -a -n > %s" % tmp_file );
 735     f = open( tmp_file, 'r' );
 736     ports = f.readlines();
 737     f.close();
 738     os.remove( tmp_file );
 739     #
 740     def portIsUsed(port, data):
 741         regObj = re.compile( ".*tcp.*:([0-9]+).*:.*listen", re.IGNORECASE );
 742         for item in data:
 743             try:
 744                 p = int(regObj.match(item).group(1))
 745                 if p == port: return True
 746                 pass
 747             except:
 748                 pass
 749             pass
 750         return False
 751     #
 752     NSPORT=2810
 753     limit=NSPORT+100
 754     #
 755     while 1:
 756         if not portIsUsed(NSPORT, ports):
 757             print "%s - OK"%(NSPORT)
 758             #
 759             from salome_utils import generateFileName, getHostName
 760             hostname = getHostName()
 761             #
 762             home  = os.getenv("HOME")
 763             appli = os.getenv("APPLI")
 764             kwargs={}
 765             if appli is not None:
 766               home = os.path.join(home, appli,"USERS")
 767               kwargs["with_username"]=True
 768             #
 769             omniorb_config = generateFileName(home, prefix="omniORB",
 770                                               extension="cfg",
 771                                               hidden=True,
 772                                               with_hostname=True,
 773                                               with_port=NSPORT,
 774                                               **kwargs)
 775             orbdata = []
 776             initref = "NameService=corbaname::%s:%s"%(hostname, NSPORT)
 777             from omniORB import CORBA
 778             if CORBA.ORB_ID == "omniORB4":
 779                 orbdata.append("InitRef = %s"%(initref))
 780                 orbdata.append("giopMaxMsgSize = 2097152000  # 2 GBytes")
 781                 orbdata.append("traceLevel = 0 # critical errors only")
 782             else:
 783                 orbdata.append("ORBInitRef %s"%(initref))
 784                 orbdata.append("ORBgiopMaxMsgSize = 2097152000  # 2 GBytes")
 785                 orbdata.append("ORBtraceLevel = 0 # critical errors only")
 786                 pass
 787             orbdata.append("")
 788             f = open(omniorb_config, "w")
 789             f.write("\n".join(orbdata))
 790             f.close()
 791             #
 792             os.environ['OMNIORB_CONFIG'] = omniorb_config
 793             os.environ['NSPORT'] = "%s"%(NSPORT)
 794             os.environ['NSHOST'] = "%s"%(hostname)
 795             args['port'] = os.environ['NSPORT']
 796             #
 797             if save_config:
 798                 last_running_config = generateFileName(home, prefix="omniORB",
 799                                                        suffix="last",
 800                                                        extension="cfg",
 801                                                        hidden=True,
 802                                                        **kwargs)
 803                 try:
 804                     if sys.platform == "win32":
 805                         import shutil
 806                         shutil.copyfile(omniorb_config, last_running_config)
 807                     else:
 808                         try:
 809                             os.remove(last_running_config)
 810                         except OSError:
 811                             pass
 812                         os.symlink(omniorb_config, last_running_config)
 813                         pass
 814                     pass
 815                 except:
 816                     pass
 817             break
 818         print "%s"%(NSPORT),
 819         if NSPORT == limit:
 820             msg  = "\n"
 821             msg += "Can't find a free port to launch omniNames\n"
 822             msg += "Try to kill the running servers and then launch SALOME again.\n"
 823             raise RuntimeError, msg
 824         NSPORT=NSPORT+1
 825         pass
 826     return
 827
 828 # -----------------------------------------------------------------------------
 829
 830 def no_main():
 831     """Salome Launch, when embedded in other application"""
 832     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 833     fenv=open(fileEnv,'r')
 834     args, modules_list, modules_root_dir = pickle.load(fenv)
 835     fenv.close()
 836     kill_salome(args)
 837     searchFreePort(args, 0)
 838     clt = useSalome(args, modules_list, modules_root_dir)
 839     return clt
 840
 841 # -----------------------------------------------------------------------------
 842
 843 def main():
 844     """Salome launch as a main application"""
 845     from salome_utils import getHostName
 846     print "runSalome running on %s" % getHostName()
 847     args, modules_list, modules_root_dir = setenv.get_config()
 848     kill_salome(args)
 849     save_config = True
 850     if args.has_key('save_config'):
 851         save_config = args['save_config']
 852     searchFreePort(args, save_config)
 853     #setenv.main()
 854     setenv.set_env(args, modules_list, modules_root_dir)
 855     clt = useSalome(args, modules_list, modules_root_dir)
 856     return clt,args
 857
 858 # -----------------------------------------------------------------------------
 859
 860 if __name__ == "__main__":
 861    import user
 862    clt,args = main()