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
  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_utilities 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         if verbose():
 217             print "==========================================================="
 218             print "Logger server: put log to the file:"
 219             print logfile
 220             print "==========================================================="
 221             pass
 222         self.CMD=['SALOME_Logger_Server', logfile]
 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 killSalomeWithPort import getPiDict
 637     filedict = getPiDict(args['port'])
 638
 639     process_ids = []
 640     try:
 641         fpid=open(filedict, 'r')
 642         process_ids=pickle.load(fpid)
 643         fpid.close()
 644     except:
 645         pass
 646
 647     fpid=open(filedict, 'w')
 648     process_ids.append(process_id)
 649     pickle.dump(process_ids,fpid)
 650     fpid.close()
 651
 652     if verbose(): print """
 653     Saving of the dictionary of Salome processes in %s
 654     To kill SALOME processes from a console (kill all sessions from all ports):
 655       python killSalome.py
 656     To kill SALOME from the present interpreter, if it is not closed :
 657       killLocalPort()      --> kill this session
 658                                (use CORBA port from args of runSalome)
 659       givenPortKill(port)  --> kill a specific session with given CORBA port
 660       killAllPorts()       --> kill all sessions
 661
 662     runSalome, with --killall option, starts with killing
 663     the processes resulting from the previous execution.
 664     """%filedict
 665
 666     #
 667     #  Impression arborescence Naming Service
 668     #
 669
 670     if clt != None:
 671         if verbose():
 672             print
 673             print " --- registered objects tree in Naming Service ---"
 674             clt.showNS()
 675             pass
 676
 677         # run python scripts, passed via --execute option
 678         toimport = []
 679         if args.has_key('pyscript'):
 680             if args.has_key('gui') and args.has_key('session_gui'):
 681                 if not args['gui'] or not args['session_gui']:
 682                     toimport = args['pyscript']
 683         i = 0
 684         while i < len( toimport ) :
 685             if toimport[ i ] == 'killall':
 686                 clt.showNS()
 687                 killAllPorts()
 688                 import sys
 689                 sys.exit(0)
 690             else:
 691                 scrname = toimport[ i ]
 692                 if len(scrname) > 2 and (len(scrname) - string.rfind(scrname, ".py") == 3):
 693                     print 'executing',scrname
 694                     doexec = 'execfile(\"%s\")'%scrname
 695                     exec doexec
 696                 else:
 697                     print 'importing',scrname
 698                     doimport = 'import ' + scrname
 699                     exec doimport
 700             i = i + 1
 701
 702     return clt
 703
 704 # -----------------------------------------------------------------------------
 705
 706 def registerEnv(args, modules_list, modules_root_dir):
 707     """
 708     Register args, modules_list, modules_root_dir in a file
 709     for further use, when SALOME is launched embedded in an other application.
 710     """
 711     if sys.platform == "win32":
 712       fileEnv = os.getenv('TEMP')
 713     else:
 714       fileEnv = '/tmp/'
 715
 716     fileEnv += os.getenv('USER') + "_" + str(args['port']) \
 717             + '_' + args['appname'].upper() + '_env'
 718     fenv=open(fileEnv,'w')
 719     pickle.dump((args, modules_list, modules_root_dir),fenv)
 720     fenv.close()
 721     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 722
 723 # -----------------------------------------------------------------------------
 724
 725 def searchFreePort(args, save_config=1):
 726     print "Searching for a free port for naming service:",
 727     NSPORT=2810
 728     limit=NSPORT
 729     limit=limit+10
 730     while 1:
 731         import os
 732         import re
 733         from os import getpid
 734         from os import system
 735
 736         if sys.platform == "win32":
 737             tmp_file = os.getenv('TEMP');
 738         else:
 739             tmp_file = '/tmp/'
 740         tmp_file += 'hostname_%s'%(getpid())
 741
 742 #       status = os.system("netstat -ltn | grep -E :%s > /dev/null 2>&1"%(NSPORT))
 743
 744         system( "netstat -a -n > %s" % tmp_file );
 745
 746         f = open( tmp_file, 'r' );
 747         lines = f.readlines();
 748         f.close();
 749
 750         pattern = "tcp.*:([0-9]+).*:.*listen";
 751         regObj = re.compile( pattern, re.IGNORECASE );
 752
 753         status = 1;
 754         for item in lines:
 755             m = regObj.search( item )
 756             if m:
 757                 try:
 758                     p = int( m.group(1) )
 759                     if p == NSPORT:
 760                         status = 0;
 761                         break;
 762                 except:
 763                     pass
 764             pass
 765
 766         if status == 1:
 767             print "%s - OK"%(NSPORT)
 768             #
 769             system('hostname > %s'%(tmp_file))
 770             f = open(tmp_file)
 771             myhost = f.read()
 772             myhost = myhost[:-1]
 773             f.close()
 774
 775             os.remove( tmp_file );
 776
 777             #
 778             home = os.environ['HOME']
 779             appli=os.environ.get("APPLI")
 780             if appli is not None:
 781                 home='%s/%s'%(home,appli)
 782                 pass
 783             #
 784             os.environ['OMNIORB_CONFIG'] = '%s/.omniORB_%s_%s.cfg'%(home, myhost, NSPORT)
 785             initref = "NameService=corbaname::%s:%s"%(myhost, NSPORT)
 786             os.environ['NSPORT'] = "%s"%(NSPORT)
 787             os.environ['NSHOST'] = "%s"%(myhost)
 788             f = open(os.environ['OMNIORB_CONFIG'], "w")
 789             import CORBA
 790             if CORBA.ORB_ID == "omniORB4":
 791                 initref += "\ngiopMaxMsgSize = 2097152000  # 2 GBytes";
 792                 initref += "\ntraceLevel = 0 # critical errors only";
 793                 f.write("InitRef = %s\n"%(initref))
 794             else:
 795                 initref += "\nORBgiopMaxMsgSize = 2097152000  # 2 GBytes";
 796                 initref += "\nORBtraceLevel = 0 # critical errors only";
 797                 f.write("ORBInitRef %s\n"%(initref))
 798                 pass
 799             f.close()
 800             args['port'] = os.environ['NSPORT']
 801             #
 802             if save_config:
 803                 from os import system
 804                 if sys.platform == "win32":
 805                     import shutil
 806                     shutil.copyfile( os.environ['OMNIORB_CONFIG'], "%s/.omniORB_last.cfg"%( home ) )
 807                 else:
 808                     system('ln -s -f %s %s/.omniORB_last.cfg'%(os.environ['OMNIORB_CONFIG'], home))
 809                 pass
 810             break
 811         print "%s"%(NSPORT),
 812         if NSPORT == limit:
 813             msg  = "\n"
 814             msg += "Can't find a free port to launch omniNames\n"
 815             msg += "Try to kill the running servers and then launch SALOME again.\n"
 816             raise msg
 817         NSPORT=NSPORT+1
 818         pass
 819     return
 820
 821 # -----------------------------------------------------------------------------
 822
 823 def no_main():
 824     """Salome Launch, when embedded in other application"""
 825     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 826     fenv=open(fileEnv,'r')
 827     args, modules_list, modules_root_dir = pickle.load(fenv)
 828     fenv.close()
 829     kill_salome(args)
 830     searchFreePort(args, 0)
 831     clt = useSalome(args, modules_list, modules_root_dir)
 832     return clt
 833
 834 # -----------------------------------------------------------------------------
 835
 836 def main():
 837     """Salome launch as a main application"""
 838     import sys
 839     print "runSalome running on ",os.getenv('HOSTNAME')
 840     args, modules_list, modules_root_dir = setenv.get_config()
 841     kill_salome(args)
 842     save_config = True
 843     if args.has_key('save_config'):
 844         save_config = args['save_config']
 845     searchFreePort(args, save_config)
 846     setenv.main()
 847     clt = useSalome(args, modules_list, modules_root_dir)
 848     return clt,args
 849
 850 # -----------------------------------------------------------------------------
 851
 852 if __name__ == "__main__":
 853    import user
 854    clt,args = main()