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