bin/runSalome.py

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