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