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