bin/runSalome.py

   1 #!/usr/bin/env python
   2
   3 import sys, os, string, glob, time, pickle
   4 from server import *
   5 import orbmodule
   6 import setenv
   7
   8 # -----------------------------------------------------------------------------
   9
  10 from killSalome import killAllPorts
  11
  12 def killLocalPort():
  13     """
  14     kill servers from a previous SALOME exection, if needed,
  15     on the CORBA port given in args of runSalome
  16     """
  17
  18     from killSalomeWithPort import killMyPort
  19     my_port=str(args['port'])
  20     try:
  21         killMyPort(my_port)
  22     except:
  23         print "problem in killLocalPort()"
  24         pass
  25     pass
  26
  27 def givenPortKill(port):
  28     """
  29     kill servers from a previous SALOME exection, if needed,
  30     on the same CORBA port
  31     """
  32
  33     from killSalomeWithPort import killMyPort
  34     my_port=port
  35     try:
  36         killMyPort(my_port)
  37     except:
  38         print "problem in LocalPortKill(), killMyPort("<<port<<")"
  39         pass
  40     pass
  41
  42 def kill_salome(args):
  43     """
  44     Kill servers from previous SALOME executions, if needed;
  45     depending on args 'killall' or 'portkill', kill all executions,
  46     or only execution on the same CORBA port
  47     """
  48
  49     if args['killall']:
  50         killAllPorts()
  51     elif args['portkill']:
  52         givenPortKill(str(args['port']))
  53
  54
  55 class InterpServer(Server):
  56     def __init__(self,args):
  57         self.args=args
  58         env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  59         self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
  60         #self.CMD=['xterm', '-e', 'python']
  61
  62     def run(self):
  63         global process_id
  64         command = self.CMD
  65         print "command = ", command
  66         if sys.platform == "win32":
  67           import win32pm
  68           pid = win32pm.spawnpid( string.join(command, " "),'-nc' )
  69         else:
  70           pid = os.spawnvp(os.P_NOWAIT, command[0], command)
  71         process_id[pid]=self.CMD
  72         self.PID = pid
  73
  74 # ---
  75
  76 class CatalogServer(Server):
  77     def __init__(self,args):
  78         self.args=args
  79         self.initArgs()
  80         #if sys.platform == "win32":
  81   #        self.SCMD1=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_ModuleCatalog_Server' + ".exe",'-common']
  82         #else:
  83         self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
  84         self.SCMD2=[]
  85         home_dir=os.getenv('HOME')
  86         if home_dir is not None:
  87             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
  88
  89     def setpath(self,modules_list,modules_root_dir):
  90         cata_path=[]
  91         list_modules = modules_list[:]
  92         list_modules.reverse()
  93         if self.args["gui"] :
  94             list_modules = ["KERNEL", "GUI"] + list_modules
  95         else :
  96             list_modules = ["KERNEL"] + list_modules
  97         for module in list_modules:
  98             if modules_root_dir.has_key(module):
  99                 module_root_dir=modules_root_dir[module]
 100                 module_cata=module+"Catalog.xml"
 101                 #print "   ", module_cata
 102                 cata_path.extend(
 103                     glob.glob(os.path.join(module_root_dir,
 104                                            "share",setenv.salome_subdir,
 105                                            "resources",module_cata)))
 106                 pass
 107             pass
 108         self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 109
 110 # ---
 111
 112 class SalomeDSServer(Server):
 113     def __init__(self,args):
 114         self.args=args
 115         self.initArgs()
 116 #       if sys.platform == "win32":
 117 #          self.CMD=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOMEDS_Server' + ".exe"]
 118 #       else:
 119         self.CMD=['SALOMEDS_Server']
 120
 121 # ---
 122
 123 class RegistryServer(Server):
 124     def __init__(self,args):
 125         self.args=args
 126         self.initArgs()
 127 #       if sys.platform == "win32":
 128 #          self.CMD=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_Registry_Server'+ ".exe", '--salome_session','theSession']
 129 #       else:
 130         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 131
 132 # ---
 133
 134 class ContainerCPPServer(Server):
 135     def __init__(self,args):
 136         self.args=args
 137         self.initArgs()
 138 #       if sys.platform == "win32":
 139 #          self.CMD=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_Container' + ".exe",'FactoryServer']
 140 #       else:
 141         self.CMD=['SALOME_Container','FactoryServer']
 142
 143 # ---
 144
 145 class ContainerPYServer(Server):
 146     def __init__(self,args):
 147         self.args=args
 148         self.initArgs()
 149         if sys.platform == "win32":
 150           self.CMD=[os.environ["PYTHONBIN"], '\"'+os.environ["KERNEL_ROOT_DIR"] + '/bin/salome/SALOME_ContainerPy.py'+'\"','FactoryServerPy']
 151         else:
 152           self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
 153
 154 # ---
 155
 156 class ContainerSUPERVServer(Server):
 157     def __init__(self,args):
 158         self.args=args
 159         self.initArgs()
 160 #       if sys.platform == "win32":
 161 #          self.CMD=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_Container' + ".exe",'SuperVisionContainer']
 162 #       else:
 163         self.CMD=['SALOME_Container','SuperVisionContainer']
 164
 165 # ---
 166
 167 class LoggerServer(Server):
 168     def __init__(self,args):
 169         self.args=args
 170         self.initArgs()
 171         self.CMD=['SALOME_Logger_Server', 'logger.log']
 172
 173 # ---
 174
 175 class SessionServer(Server):
 176     def __init__(self,args):
 177         self.args = args.copy()
 178         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 179         self.args['xterm']=0
 180         #
 181         self.initArgs()
 182 #       if sys.platform == "win32":
 183 #          self.SCMD1=[os.environ["GUI_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_Session_Server' + ".exe"]
 184 #       else:
 185         self.SCMD1=['SALOME_Session_Server']
 186
 187         self.SCMD2=[]
 188         if 'registry' in self.args['embedded']:
 189             self.SCMD1+=['--with','Registry',
 190                          '(','--salome_session','theSession',')']
 191         if 'moduleCatalog' in self.args['embedded']:
 192             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 193             home_dir=os.getenv('HOME')
 194             if home_dir is not None:
 195                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 196             self.SCMD2+=[')']
 197         if 'study' in self.args['embedded']:
 198             self.SCMD2+=['--with','SALOMEDS','(',')']
 199         if 'cppContainer' in self.args['embedded']:
 200             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 201         if 'SalomeAppEngine' in self.args['embedded']:
 202             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 203
 204         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 205             self.SCMD2+=['CPP']
 206         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 207             self.SCMD2+=['PY']
 208         if 'supervContainer' in self.args['containers'] or 'supervContainer' in self.args['standalone']:
 209             self.SCMD2+=['SUPERV']
 210         if self.args['gui']:
 211             self.SCMD2+=['GUI']
 212         if self.args['splash'] and self.args['gui']:
 213             self.SCMD2+=['SPLASH']
 214         if self.args['noexcepthandler']:
 215             self.SCMD2+=['noexcepthandler']
 216         if self.args.has_key('modules'):
 217             self.SCMD2+=['--modules (']
 218             for mod in self.args['modules']:
 219                 self.SCMD2+=[mod + ':']
 220             self.SCMD2+=[')']
 221
 222     def setpath(self,modules_list,modules_root_dir):
 223         cata_path=[]
 224         list_modules = modules_list[:]
 225         list_modules.reverse()
 226         if self.args["gui"] :
 227             list_modules = ["KERNEL", "GUI"] + list_modules
 228         else :
 229             list_modules = ["KERNEL"] + list_modules
 230         for module in list_modules:
 231             module_root_dir=modules_root_dir[module]
 232             module_cata=module+"Catalog.xml"
 233             #print "   ", module_cata
 234             cata_path.extend(
 235                 glob.glob(os.path.join(module_root_dir,"share",
 236                                        setenv.salome_subdir,"resources",
 237                                        module_cata)))
 238         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 239             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 240         else:
 241             self.CMD=self.SCMD1 + self.SCMD2
 242
 243 # ---
 244
 245 class ContainerManagerServer(Server):
 246     def __init__(self,args):
 247         self.args=args
 248         self.initArgs()
 249 #       if sys.platform == "win32":
 250 #          self.SCMD1=[os.environ["KERNEL_ROOT_DIR"] + "/win32/" + os.environ["BIN_ENV"] + "/" + 'SALOME_ContainerManagerServer' + ".exe"]
 251 #       else:
 252         self.SCMD1=['SALOME_ContainerManagerServer']
 253         self.SCMD2=[]
 254         if args["gui"] :
 255             if 'registry' in self.args['embedded']:
 256                 self.SCMD1+=['--with','Registry',
 257                              '(','--salome_session','theSession',')']
 258             if 'moduleCatalog' in self.args['embedded']:
 259                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 260                 self.SCMD2+=['-personal',
 261                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 262             if 'study' in self.args['embedded']:
 263                 self.SCMD2+=['--with','SALOMEDS','(',')']
 264             if 'cppContainer' in self.args['embedded']:
 265                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 266
 267     def setpath(self,modules_list,modules_root_dir):
 268         cata_path=[]
 269         list_modules = modules_list[:]
 270         list_modules.reverse()
 271         if self.args["gui"] :
 272             list_modules = ["GUI"] + list_modules
 273         for module in ["KERNEL"] + list_modules:
 274             if modules_root_dir.has_key(module):
 275                 module_root_dir=modules_root_dir[module]
 276                 module_cata=module+"Catalog.xml"
 277                 #print "   ", module_cata
 278                 cata_path.extend(
 279                     glob.glob(os.path.join(module_root_dir,"share",
 280                                            self.args['appname'],"resources",
 281                                            module_cata)))
 282                 pass
 283             pass
 284         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 285             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 286         else:
 287             self.CMD=self.SCMD1 + self.SCMD2
 288
 289 class NotifyServer(Server):
 290     def __init__(self,args,modules_root_dir):
 291         self.args=args
 292         self.initArgs()
 293         self.modules_root_dir=modules_root_dir
 294         myLogName = os.environ["LOGNAME"]
 295         self.CMD=['notifd','-c',
 296                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/channel.cfg',
 297                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 298                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 299                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 300                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 301                   ]
 302
 303 #
 304 # -----------------------------------------------------------------------------
 305
 306 def startGUI():
 307     """Salome Session Graphic User Interface activation"""
 308     import Engines
 309     import SALOME
 310     import SALOMEDS
 311     import SALOME_ModuleCatalog
 312     reload(Engines)
 313     reload(SALOME)
 314     reload(SALOMEDS)
 315     import SALOME_Session_idl
 316     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 317     session.GetInterface()
 318
 319 # -----------------------------------------------------------------------------
 320
 321 def startSalome(args, modules_list, modules_root_dir):
 322     """Launch all SALOME servers requested by args"""
 323     init_time = os.times()
 324
 325     print "startSalome ", args
 326
 327     #
 328     # Initialisation ORB et Naming Service
 329     #
 330
 331     clt=orbmodule.client(args)
 332
 333     # (non obligatoire) Lancement Logger Server
 334     # et attente de sa disponibilite dans le naming service
 335     #
 336
 337     if args['logger']:
 338         myServer=LoggerServer(args)
 339         myServer.run()
 340         clt.waitLogger("Logger")
 341
 342     # Notify Server launch
 343     #
 344
 345 #    print "Notify Server to launch"
 346
 347 #    myServer=NotifyServer(args,modules_root_dir)
 348 #    myServer.run()
 349
 350     # Lancement Session Server (to show splash ASAP)
 351     #
 352
 353     if args["gui"]:
 354         mySessionServ = SessionServer(args)
 355         mySessionServ.setpath(modules_list,modules_root_dir)
 356         mySessionServ.run()
 357
 358     #
 359     # Lancement Registry Server,
 360     # attente de la disponibilite du Registry dans le Naming Service
 361     #
 362
 363     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 364         myServer=RegistryServer(args)
 365         myServer.run()
 366         if sys.platform == "win32":
 367           clt.waitNS("/Registry")
 368         else:
 369           clt.waitNSPID("/Registry",myServer.PID)
 370
 371     #
 372     # Lancement Catalog Server,
 373     # attente de la disponibilite du Catalog Server dans le Naming Service
 374     #
 375
 376
 377     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 378         cataServer=CatalogServer(args)
 379         cataServer.setpath(modules_list,modules_root_dir)
 380         cataServer.run()
 381         import SALOME_ModuleCatalog
 382         if sys.platform == "win32":
 383           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 384         else:
 385           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 386
 387     #
 388     # Lancement SalomeDS Server,
 389     # attente de la disponibilite du SalomeDS dans le Naming Service
 390     #
 391
 392     os.environ["CSF_PluginDefaults"] \
 393     = os.path.join(modules_root_dir["KERNEL"],"share",
 394                    setenv.salome_subdir,"resources")
 395     os.environ["CSF_SALOMEDS_ResourcesDefaults"] \
 396     = os.path.join(modules_root_dir["KERNEL"],"share",
 397                    setenv.salome_subdir,"resources")
 398
 399     if "GEOM" in modules_list:
 400         print "GEOM OCAF Resources"
 401         os.environ["CSF_GEOMDS_ResourcesDefaults"] \
 402         = os.path.join(modules_root_dir["GEOM"],"share",
 403                        setenv.salome_subdir,"resources")
 404         print "GEOM Shape Healing Resources"
 405         os.environ["CSF_ShHealingDefaults"] \
 406         = os.path.join(modules_root_dir["GEOM"],"share",
 407                        setenv.salome_subdir,"resources")
 408
 409     print "ARGS = ",args
 410     if ('study' not in args['embedded']) | (args["gui"] == 0):
 411         print "RunStudy"
 412         myServer=SalomeDSServer(args)
 413         myServer.run()
 414         if sys.platform == "win32":
 415           clt.waitNS("/myStudyManager")
 416         else:
 417           clt.waitNSPID("/myStudyManager",myServer.PID)
 418
 419     #
 420     # Lancement ContainerManagerServer
 421     #
 422
 423     myCmServer = ContainerManagerServer(args)
 424     myCmServer.setpath(modules_list,modules_root_dir)
 425     myCmServer.run()
 426
 427
 428     from Utils_Identity import getShortHostName
 429
 430     if os.getenv("HOSTNAME") == None:
 431         #if os.getenv("HOST") == None:
 432             os.environ["HOSTNAME"]=getShortHostName()
 433         #else:
 434         #    os.environ["HOSTNAME"]=os.getenv("HOST")
 435
 436     theComputer = getShortHostName()
 437
 438     #
 439     # Lancement Container C++ local,
 440     # attente de la disponibilite du Container C++ local dans le Naming Service
 441     #
 442
 443     if 'cppContainer' in args['standalone']:
 444         myServer=ContainerCPPServer(args)
 445         myServer.run()
 446         if sys.platform == "win32":
 447           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 448         else:
 449           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 450
 451     #
 452     # Lancement Container Python local,
 453     # attente de la disponibilite du Container Python local
 454     # dans le Naming Service
 455     #
 456
 457     if 'pyContainer' in args['standalone']:
 458         myServer=ContainerPYServer(args)
 459         myServer.run()
 460         if sys.platform == "win32":
 461           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 462         else:
 463           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 464
 465     #
 466     # Lancement Container Supervision local,
 467     # attente de la disponibilite du Container Supervision local
 468     # dans le Naming Service
 469     #
 470
 471     if 'supervContainer' in args['standalone']:
 472         myServer=ContainerSUPERVServer(args)
 473         myServer.run()
 474         if sys.platform == "win32":
 475           clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 476         else:
 477           clt.waitNSPID("/Containers/" + theComputer + "/SuperVisionContainer",myServer.PID)
 478
 479     #
 480     # Attente de la disponibilite du Session Server dans le Naming Service
 481     #
 482
 483     if args["gui"]:
 484 ##----------------
 485         import Engines
 486         import SALOME
 487         import SALOMEDS
 488         import SALOME_ModuleCatalog
 489         reload(Engines)
 490         reload(SALOME)
 491         reload(SALOMEDS)
 492         import SALOME_Session_idl
 493         if sys.platform == "win32":
 494           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 495         else:
 496           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 497
 498     end_time = os.times()
 499     print
 500     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 501                                                          - init_time[4])
 502
 503     # ASV start GUI without Loader
 504     #if args['gui']:
 505     #    session.GetInterface()
 506
 507     #
 508     # additionnal external python interpreters
 509     #
 510     nbaddi=0
 511
 512     try:
 513         if 'interp' in args:
 514             if args['interp']:
 515                 nbaddi = int(args['interp'][0])
 516     except:
 517         import traceback
 518         traceback.print_exc()
 519         print "-------------------------------------------------------------"
 520         print "-- to get an external python interpreter:runSalome --interp=1"
 521         print "-------------------------------------------------------------"
 522
 523     print "additional external python interpreters: ", nbaddi
 524     if nbaddi:
 525         for i in range(nbaddi):
 526             print "i=",i
 527             anInterp=InterpServer(args)
 528             anInterp.run()
 529
 530     return clt
 531
 532 # -----------------------------------------------------------------------------
 533
 534 def useSalome(args, modules_list, modules_root_dir):
 535     """
 536     Launch all SALOME servers requested by args,
 537     save list of process, give info to user,
 538     show registered objects in Naming Service.
 539     """
 540     global process_id
 541
 542     clt=None
 543     try:
 544         clt = startSalome(args, modules_list, modules_root_dir)
 545     except:
 546         import traceback
 547         traceback.print_exc()
 548         print
 549         print
 550         print "--- erreur au lancement Salome ---"
 551
 552     #print process_id
 553
 554     from killSalomeWithPort import getPiDict
 555     filedict = getPiDict(args['port'])
 556
 557     process_ids = []
 558     try:
 559         fpid=open(filedict, 'r')
 560         process_ids=pickle.load(fpid)
 561         fpid.close()
 562     except:
 563         pass
 564
 565     fpid=open(filedict, 'w')
 566     process_ids.append(process_id)
 567     pickle.dump(process_ids,fpid)
 568     fpid.close()
 569
 570     print """
 571     Saving of the dictionary of Salome processes in %s
 572     To kill SALOME processes from a console (kill all sessions from all ports):
 573       python killSalome.py
 574     To kill SALOME from the present interpreter, if it is not closed :
 575       killLocalPort()      --> kill this session
 576                                (use CORBA port from args of runSalome)
 577       givenPortKill(port)  --> kill a specific session with given CORBA port
 578       killAllPorts()       --> kill all sessions
 579
 580     runSalome, with --killall option, starts with killing
 581     the processes resulting from the previous execution.
 582     """%filedict
 583
 584     #
 585     #  Impression arborescence Naming Service
 586     #
 587
 588     if clt != None:
 589         print
 590         print " --- registered objects tree in Naming Service ---"
 591         clt.showNS()
 592
 593     return clt
 594
 595 # -----------------------------------------------------------------------------
 596
 597 def registerEnv(args, modules_list, modules_root_dir):
 598     """
 599     Register args, modules_list, modules_root_dir in a file
 600     for further use, when SALOME is launched embedded in an other application.
 601     """
 602     fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
 603             + '_' + args['appname'].upper() + '_env'
 604     fenv=open(fileEnv,'w')
 605     pickle.dump((args, modules_list, modules_root_dir),fenv)
 606     fenv.close()
 607     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 608
 609 # -----------------------------------------------------------------------------
 610
 611 def no_main():
 612     """Salome Launch, when embedded in other application"""
 613     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 614     fenv=open(fileEnv,'r')
 615     args, modules_list, modules_root_dir = pickle.load(fenv)
 616     fenv.close()
 617     kill_salome(args)
 618     clt = useSalome(args, modules_list, modules_root_dir)
 619     return clt
 620
 621 # -----------------------------------------------------------------------------
 622
 623 def main():
 624     """Salome launch as a main application"""
 625     args, modules_list, modules_root_dir = setenv.get_config()
 626     kill_salome(args)
 627     #invokation of set_env moved to separate file setenv.py
 628     #set_env(args, modules_list, modules_root_dir)
 629     setenv.main()
 630     clt = useSalome(args, modules_list, modules_root_dir)
 631     return clt,args
 632
 633 # -----------------------------------------------------------------------------
 634
 635 if __name__ == "__main__":
 636    import user
 637    clt,args = main()