bin/runSalome.py

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