bin/runSalome.py

   1 #!/usr/bin/env python
   2
   3 import sys, os, string, glob, time, pickle
   4 import orbmodule
   5
   6 process_id = {}
   7
   8 # salome_subdir variable is used for composing paths like $KERNEL_ROOT_DIR/share/salome/resources, etc.
   9 # before moving to SUIT-based gui, instead of salome_subdir there was args['appname'] used.
  10 # but after - 'appname'  = "SalomeApp", so using it in making the subdirectory is an error.
  11 salome_subdir = "salome"
  12
  13 # -----------------------------------------------------------------------------
  14
  15 def add_path(directory, variable_name):
  16     """Function helper to add environment variables"""
  17     if not os.environ.has_key(variable_name):
  18         os.environ[variable_name] = ""
  19         pass
  20     if os.path.exists(directory):
  21         newpath=[]
  22         for _dir in os.environ[variable_name].split(":"):
  23             if os.path.exists(_dir):
  24                 if not os.path.samefile(_dir, directory):
  25                   newpath.append(_dir)
  26             else:
  27                 if os.path.abspath(_dir) != os.path.abspath(directory):
  28                   newpath.append(_dir)
  29             pass
  30         import string
  31         newpath[:0] = [ directory ]
  32         newpath = string.join(newpath,":")
  33         os.environ[variable_name] = newpath
  34         if variable_name == "PYTHONPATH":
  35             sys.path[:0] = [directory]
  36
  37 # -----------------------------------------------------------------------------
  38
  39 def get_config():
  40     """
  41     Get list of modules, paths.
  42
  43     Read args from launch configure xml file and command line options.
  44     Check variables <module>_ROOT_DIR and set list of used modules.
  45     Return args, modules_list, modules_root_dir
  46     """
  47
  48     # read args from launch configure xml file and command line options
  49
  50     import launchConfigureParser
  51     args = launchConfigureParser.args
  52
  53     # Check variables <module>_ROOT_DIR
  54     # and set list of used modules (without KERNEL)
  55
  56     modules_list = []
  57     if args.has_key("modules"):
  58         modules_list += args["modules"]
  59     # KERNEL must be last in the list to locate it at the first place in PATH
  60     if args["gui"] :
  61         modules_list[:0] = ["GUI"]
  62     modules_list[:0] = ["KERNEL"]
  63     modules_list.reverse()
  64
  65     modules_root_dir = {}
  66
  67     to_remove_list=[]
  68     for module in modules_list :
  69         module_variable=module+"_ROOT_DIR"
  70         if not os.environ.has_key(module_variable):
  71             print "*******************************************************"
  72             print "*"
  73             print "* Environment variable",module_variable,"must be set"
  74             print "* Module", module, "will be not available"
  75             print "*"
  76             print "********************************************************"
  77             to_remove_list.append(module)
  78             continue
  79             pass
  80         module_root_dir = os.environ[module_variable]
  81         modules_root_dir[module]=module_root_dir
  82
  83     for to_remove in to_remove_list:
  84         modules_list.remove(to_remove)
  85
  86     while "KERNEL" in modules_list:
  87         modules_list.remove("KERNEL")
  88         pass
  89
  90     while "GUI" in modules_list:
  91         modules_list.remove("GUI")
  92         pass
  93
  94     if "SUPERV" in modules_list and not 'superv' in args['standalone']:
  95         args['standalone'].append("superv")
  96         pass
  97
  98     return args, modules_list, modules_root_dir
  99
 100 # -----------------------------------------------------------------------------
 101
 102 def set_env(args, modules_list, modules_root_dir):
 103     """Add to the PATH-variables modules specific paths"""
 104
 105     python_version="python%d.%d" % sys.version_info[0:2]
 106     modules_root_dir_list = []
 107     if args["gui"] :
 108         modules_list = modules_list[:] + ["GUI"]
 109     modules_list = modules_list[:] + ["KERNEL"]
 110     for module in modules_list :
 111         if modules_root_dir.has_key(module):
 112             module_root_dir = modules_root_dir[module]
 113             modules_root_dir_list[:0] = [module_root_dir]
 114             add_path(os.path.join(module_root_dir,"lib",salome_subdir),
 115                      "LD_LIBRARY_PATH")
 116             add_path(os.path.join(module_root_dir,"bin",salome_subdir),
 117                      "PATH")
 118             if os.path.exists(module_root_dir + "/examples") :
 119                 add_path(os.path.join(module_root_dir,"examples"),
 120                          "PYTHONPATH")
 121                 pass
 122             add_path(os.path.join(module_root_dir,"bin",salome_subdir),
 123                      "PYTHONPATH")
 124             add_path(os.path.join(module_root_dir,"lib",
 125                                   python_version,"site-packages",
 126                                   salome_subdir),
 127                      "PYTHONPATH")
 128             add_path(os.path.join(module_root_dir,"lib",salome_subdir),
 129                      "PYTHONPATH")
 130             add_path(os.path.join(module_root_dir,"lib",
 131                                   python_version,"site-packages",
 132                                   salome_subdir,
 133                                   "shared_modules"),
 134                      "PYTHONPATH")
 135             pass
 136         pass
 137
 138
 139     os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
 140
 141     # set trace environment variable
 142
 143     if not os.environ.has_key("SALOME_trace"):
 144         os.environ["SALOME_trace"]="local"
 145     if args['file']:
 146         os.environ["SALOME_trace"]="file:"+args['file'][0]
 147     if args['logger']:
 148         os.environ["SALOME_trace"]="with_logger"
 149
 150     # set environment for SMESH plugins
 151
 152     if "SMESH" in modules_list:
 153         os.environ["SMESH_MeshersList"]="StdMeshers"
 154         if not os.environ.has_key("SALOME_StdMeshersResources"):
 155             os.environ["SALOME_StdMeshersResources"] \
 156             = modules_root_dir["SMESH"]+"/share/"+args["appname"]+"/resources"
 157             pass
 158         if args.has_key("SMESH_plugins"):
 159             for plugin in args["SMESH_plugins"]:
 160                 plugin_root = ""
 161                 if os.environ.has_key(plugin+"_ROOT_DIR"):
 162                     plugin_root = os.environ[plugin+"_ROOT_DIR"]
 163                 else:
 164                     # workaround to avoid modifications of existing environment
 165                     if os.environ.has_key(plugin.upper()+"_ROOT_DIR"):
 166                         plugin_root = os.environ[plugin.upper()+"_ROOT_DIR"]
 167                         pass
 168                     pass
 169                 if plugin_root != "":
 170                     os.environ["SMESH_MeshersList"] \
 171                     = os.environ["SMESH_MeshersList"]+":"+plugin
 172                     if not os.environ.has_key("SALOME_"+plugin+"Resources"):
 173                         os.environ["SALOME_"+plugin+"Resources"] \
 174                         = plugin_root+"/share/"+args["appname"]+"/resources"
 175                     add_path(os.path.join(plugin_root,"lib",python_version,
 176                                           "site-packages",salome_subdir),
 177                              "PYTHONPATH")
 178                     add_path(os.path.join(plugin_root,"lib",salome_subdir),
 179                              "PYTHONPATH")
 180                     add_path(os.path.join(plugin_root,"lib",salome_subdir),
 181                              "LD_LIBRARY_PATH")
 182                     add_path(os.path.join(plugin_root,"bin",salome_subdir),
 183                              "PYTHONPATH")
 184                     add_path(os.path.join(plugin_root,"bin",salome_subdir),
 185                              "PATH")
 186             pass
 187         pass
 188
 189     # set environment for SUPERV module
 190     os.environ["ENABLE_MACRO_NODE"]="1"
 191     # set resources variables if not yet set
 192     # Done now by launchConfigureParser.py
 193     #if os.getenv("GUI_ROOT_DIR"):
 194         #if not os.getenv("SUITRoot"): os.environ["SUITRoot"] =  os.getenv("GUI_ROOT_DIR") + "/share/salome"
 195         #if not os.getenv("SalomeAppConfig"): os.environ["SalomeAppConfig"] =  os.getenv("GUI_ROOT_DIR") + "/share/salome/resources"
 196
 197     # set CSF_PluginDefaults variable only if it is not customized
 198     # by the user
 199     if not os.getenv("CSF_PluginDefaults"):
 200         os.environ["CSF_PluginDefaults"] \
 201         = os.path.join(modules_root_dir["KERNEL"],"share",
 202                        salome_subdir,"resources")
 203     os.environ["CSF_SALOMEDS_ResourcesDefaults"] \
 204     = os.path.join(modules_root_dir["KERNEL"],"share",
 205                    salome_subdir,"resources")
 206
 207     if "GEOM" in modules_list:
 208         print "GEOM OCAF Resources"
 209         os.environ["CSF_GEOMDS_ResourcesDefaults"] \
 210         = os.path.join(modules_root_dir["GEOM"],"share",
 211                        salome_subdir,"resources")
 212         print "GEOM Shape Healing Resources"
 213         os.environ["CSF_ShHealingDefaults"] \
 214         = os.path.join(modules_root_dir["GEOM"],"share",
 215                        salome_subdir,"resources")
 216
 217 # -----------------------------------------------------------------------------
 218
 219 from killSalome import killAllPorts
 220
 221 def killLocalPort():
 222     """
 223     kill servers from a previous SALOME exection, if needed,
 224     on the CORBA port given in args of runSalome
 225     """
 226
 227     from killSalomeWithPort import killMyPort
 228     my_port=str(args['port'])
 229     try:
 230         killMyPort(my_port)
 231     except:
 232         print "problem in killLocalPort()"
 233         pass
 234     pass
 235
 236 def givenPortKill(port):
 237     """
 238     kill servers from a previous SALOME exection, if needed,
 239     on the same CORBA port
 240     """
 241
 242     from killSalomeWithPort import killMyPort
 243     my_port=port
 244     try:
 245         killMyPort(my_port)
 246     except:
 247         print "problem in LocalPortKill(), killMyPort("<<port<<")"
 248         pass
 249     pass
 250
 251 def kill_salome(args):
 252     """
 253     Kill servers from previous SALOME executions, if needed;
 254     depending on args 'killall' or 'portkill', kill all executions,
 255     or only execution on the same CORBA port
 256     """
 257
 258     if args['killall']:
 259         killAllPorts()
 260     elif args['portkill']:
 261         givenPortKill(str(args['port']))
 262
 263 # -----------------------------------------------------------------------------
 264 #
 265 # Definition des classes d'objets pour le lancement des Server CORBA
 266 #
 267
 268 class Server:
 269     """Generic class for CORBA server launch"""
 270
 271     def initArgs(self):
 272         self.PID=None
 273         self.CMD=[]
 274         self.ARGS=[]
 275         if self.args['xterm']:
 276             self.ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
 277
 278     def __init__(self,args):
 279         self.args=args
 280         self.initArgs()
 281
 282
 283     def run(self):
 284         global process_id
 285         myargs=self.ARGS
 286         if self.args['xterm']:
 287             # (Debian) send LD_LIBRARY_PATH to children shells (xterm)
 288             env_ld_library_path=['env', 'LD_LIBRARY_PATH='
 289                                  + os.getenv("LD_LIBRARY_PATH")]
 290             myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
 291         command = myargs + self.CMD
 292         print "command = ", command
 293         pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 294         process_id[pid]=self.CMD
 295         self.PID = pid
 296
 297
 298 class InterpServer(Server):
 299     def __init__(self,args):
 300         self.args=args
 301         env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
 302         self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
 303         #self.CMD=['xterm', '-e', 'python']
 304
 305     def run(self):
 306         global process_id
 307         command = self.CMD
 308         #print "command = ", command
 309         pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 310         process_id[pid]=self.CMD
 311         self.PID = pid
 312
 313 # ---
 314
 315 class CatalogServer(Server):
 316     def __init__(self,args):
 317         self.args=args
 318         self.initArgs()
 319         self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
 320         self.SCMD2=[]
 321         home_dir=os.getenv('HOME')
 322         if home_dir is not None:
 323             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 324
 325     def setpath(self,modules_list,modules_root_dir):
 326         cata_path=[]
 327         list_modules = modules_list[:]
 328         list_modules.reverse()
 329         if self.args["gui"] :
 330             list_modules = ["KERNEL", "GUI"] + list_modules
 331         else :
 332             list_modules = ["KERNEL"] + list_modules
 333         for module in list_modules:
 334             if modules_root_dir.has_key(module):
 335                 module_root_dir=modules_root_dir[module]
 336                 module_cata=module+"Catalog.xml"
 337                 #print "   ", module_cata
 338                 cata_path.extend(
 339                     glob.glob(os.path.join(module_root_dir,
 340                                            "share",salome_subdir,
 341                                            "resources",module_cata)))
 342                 pass
 343             pass
 344         self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 345
 346 # ---
 347
 348 class SalomeDSServer(Server):
 349     def __init__(self,args):
 350         self.args=args
 351         self.initArgs()
 352         self.CMD=['SALOMEDS_Server']
 353
 354 # ---
 355
 356 class RegistryServer(Server):
 357     def __init__(self,args):
 358         self.args=args
 359         self.initArgs()
 360         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 361
 362 # ---
 363
 364 class ContainerCPPServer(Server):
 365     def __init__(self,args):
 366         self.args=args
 367         self.initArgs()
 368         self.CMD=['SALOME_Container','FactoryServer']
 369
 370 # ---
 371
 372 class ContainerPYServer(Server):
 373     def __init__(self,args):
 374         self.args=args
 375         self.initArgs()
 376         self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
 377
 378 # ---
 379
 380 class ContainerSUPERVServer(Server):
 381     def __init__(self,args):
 382         self.args=args
 383         self.initArgs()
 384         self.CMD=['SALOME_Container','SuperVisionContainer']
 385
 386 # ---
 387
 388 class LoggerServer(Server):
 389     def __init__(self,args):
 390         self.args=args
 391         self.initArgs()
 392         self.CMD=['SALOME_Logger_Server', 'logger.log']
 393
 394 # ---
 395
 396 class SessionServer(Server):
 397     def __init__(self,args):
 398         self.args = args.copy()
 399         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 400         self.args['xterm']=0
 401         #
 402         self.initArgs()
 403         self.SCMD1=['SALOME_Session_Server']
 404         self.SCMD2=[]
 405         if 'registry' in self.args['embedded']:
 406             self.SCMD1+=['--with','Registry',
 407                          '(','--salome_session','theSession',')']
 408         if 'moduleCatalog' in self.args['embedded']:
 409             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 410             home_dir=os.getenv('HOME')
 411             if home_dir is not None:
 412                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 413             self.SCMD2+=[')']
 414         if 'study' in self.args['embedded']:
 415             self.SCMD2+=['--with','SALOMEDS','(',')']
 416         if 'cppContainer' in self.args['embedded']:
 417             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 418         if 'SalomeAppEngine' in self.args['embedded']:
 419             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 420
 421         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 422             self.SCMD2+=['CPP']
 423         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 424             self.SCMD2+=['PY']
 425         if 'supervContainer' in self.args['containers'] or 'supervContainer' in self.args['standalone']:
 426             self.SCMD2+=['SUPERV']
 427         if self.args['gui']:
 428             self.SCMD2+=['GUI']
 429         if self.args['splash'] and self.args['gui']:
 430             self.SCMD2+=['SPLASH']
 431         if self.args['noexcepthandler']:
 432             self.SCMD2+=['noexcepthandler']
 433         if self.args.has_key('modules'):
 434             self.SCMD2+=['--modules (']
 435             for mod in self.args['modules']:
 436                 self.SCMD2+=[mod + ':']
 437             self.SCMD2+=[')']
 438
 439     def setpath(self,modules_list,modules_root_dir):
 440         cata_path=[]
 441         list_modules = modules_list[:]
 442         list_modules.reverse()
 443         if self.args["gui"] :
 444             list_modules = ["KERNEL", "GUI"] + list_modules
 445         else :
 446             list_modules = ["KERNEL"] + list_modules
 447         for module in list_modules:
 448             module_root_dir=modules_root_dir[module]
 449             module_cata=module+"Catalog.xml"
 450             #print "   ", module_cata
 451             cata_path.extend(
 452                 glob.glob(os.path.join(module_root_dir,"share",
 453                                        salome_subdir,"resources",
 454                                        module_cata)))
 455         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 456             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 457         else:
 458             self.CMD=self.SCMD1 + self.SCMD2
 459
 460 # ---
 461
 462 class ContainerManagerServer(Server):
 463     def __init__(self,args):
 464         self.args=args
 465         self.initArgs()
 466         self.SCMD1=['SALOME_ContainerManagerServer']
 467         self.SCMD2=[]
 468         if args["gui"] :
 469             if 'registry' in self.args['embedded']:
 470                 self.SCMD1+=['--with','Registry',
 471                              '(','--salome_session','theSession',')']
 472             if 'moduleCatalog' in self.args['embedded']:
 473                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 474                 self.SCMD2+=['-personal',
 475                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 476             if 'study' in self.args['embedded']:
 477                 self.SCMD2+=['--with','SALOMEDS','(',')']
 478             if 'cppContainer' in self.args['embedded']:
 479                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 480
 481     def setpath(self,modules_list,modules_root_dir):
 482         cata_path=[]
 483         list_modules = modules_list[:]
 484         list_modules.reverse()
 485         if self.args["gui"] :
 486             list_modules = ["GUI"] + list_modules
 487         for module in ["KERNEL"] + list_modules:
 488             if modules_root_dir.has_key(module):
 489                 module_root_dir=modules_root_dir[module]
 490                 module_cata=module+"Catalog.xml"
 491                 #print "   ", module_cata
 492                 cata_path.extend(
 493                     glob.glob(os.path.join(module_root_dir,"share",
 494                                            self.args['appname'],"resources",
 495                                            module_cata)))
 496                 pass
 497             pass
 498         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 499             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 500         else:
 501             self.CMD=self.SCMD1 + self.SCMD2
 502
 503 class NotifyServer(Server):
 504     def __init__(self,args,modules_root_dir):
 505         self.args=args
 506         self.initArgs()
 507         self.modules_root_dir=modules_root_dir
 508         myLogName = os.environ["LOGNAME"]
 509         self.CMD=['notifd','-c',
 510                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/channel.cfg',
 511                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 512                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 513                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 514                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 515                   ]
 516
 517 #
 518 # -----------------------------------------------------------------------------
 519
 520 def startGUI():
 521     """Salome Session Graphic User Interface activation"""
 522     import Engines
 523     import SALOME
 524     import SALOMEDS
 525     import SALOME_ModuleCatalog
 526     reload(Engines)
 527     reload(SALOME)
 528     reload(SALOMEDS)
 529     import SALOME_Session_idl
 530     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 531     session.GetInterface()
 532
 533 # -----------------------------------------------------------------------------
 534
 535 def startSalome(args, modules_list, modules_root_dir):
 536     """Launch all SALOME servers requested by args"""
 537     init_time = os.times()
 538
 539     print "startSalome ", args
 540
 541     #
 542     # Initialisation ORB et Naming Service
 543     #
 544
 545     clt=orbmodule.client()
 546
 547     # (non obligatoire) Lancement Logger Server
 548     # et attente de sa disponibilite dans le naming service
 549     #
 550
 551     if args['logger']:
 552         myServer=LoggerServer(args)
 553         myServer.run()
 554         clt.waitLogger("Logger")
 555
 556     # Notify Server launch
 557     #
 558
 559     print "Notify Server to launch"
 560
 561     myServer=NotifyServer(args,modules_root_dir)
 562     myServer.run()
 563
 564     # Lancement Session Server (to show splash ASAP)
 565     #
 566
 567     if args["gui"]:
 568         mySessionServ = SessionServer(args)
 569         mySessionServ.setpath(modules_list,modules_root_dir)
 570         mySessionServ.run()
 571
 572     #
 573     # Lancement Registry Server,
 574     # attente de la disponibilite du Registry dans le Naming Service
 575     #
 576
 577     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 578         myServer=RegistryServer(args)
 579         myServer.run()
 580         clt.waitNSPID("/Registry",myServer.PID)
 581
 582     #
 583     # Lancement Catalog Server,
 584     # attente de la disponibilite du Catalog Server dans le Naming Service
 585     #
 586
 587
 588     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 589         cataServer=CatalogServer(args)
 590         cataServer.setpath(modules_list,modules_root_dir)
 591         cataServer.run()
 592         import SALOME_ModuleCatalog
 593         clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 594
 595     #
 596     # Lancement SalomeDS Server,
 597     # attente de la disponibilite du SalomeDS dans le Naming Service
 598     #
 599
 600     #print "ARGS = ",args
 601     if ('study' not in args['embedded']) | (args["gui"] == 0):
 602         print "RunStudy"
 603         myServer=SalomeDSServer(args)
 604         myServer.run()
 605         clt.waitNSPID("/myStudyManager",myServer.PID)
 606
 607     #
 608     # Lancement ContainerManagerServer
 609     #
 610
 611     myCmServer = ContainerManagerServer(args)
 612     myCmServer.setpath(modules_list,modules_root_dir)
 613     myCmServer.run()
 614
 615
 616     from Utils_Identity import getShortHostName
 617
 618     if os.getenv("HOSTNAME") == None:
 619         if os.getenv("HOST") == None:
 620             os.environ["HOSTNAME"]=getShortHostName()
 621         else:
 622             os.environ["HOSTNAME"]=os.getenv("HOST")
 623
 624     theComputer = getShortHostName()
 625
 626     #
 627     # Lancement Container C++ local,
 628     # attente de la disponibilite du Container C++ local dans le Naming Service
 629     #
 630
 631     if 'cppContainer' in args['standalone']:
 632         myServer=ContainerCPPServer(args)
 633         myServer.run()
 634         clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 635
 636     #
 637     # Lancement Container Python local,
 638     # attente de la disponibilite du Container Python local
 639     # dans le Naming Service
 640     #
 641
 642     if 'pyContainer' in args['standalone']:
 643         myServer=ContainerPYServer(args)
 644         myServer.run()
 645         clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 646
 647     #
 648     # Lancement Container Supervision local,
 649     # attente de la disponibilite du Container Supervision local
 650     # dans le Naming Service
 651     #
 652
 653     if 'supervContainer' in args['standalone']:
 654         myServer=ContainerSUPERVServer(args)
 655         myServer.run()
 656         clt.waitNSPID("/Containers/" + theComputer + "/SuperVisionContainer",myServer.PID)
 657
 658     #
 659     # Attente de la disponibilite du Session Server dans le Naming Service
 660     #
 661
 662     if args["gui"]:
 663 ##----------------
 664         import Engines
 665         import SALOME
 666         import SALOMEDS
 667         import SALOME_ModuleCatalog
 668         reload(Engines)
 669         reload(SALOME)
 670         reload(SALOMEDS)
 671         import SALOME_Session_idl
 672         session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 673
 674     end_time = os.times()
 675     print
 676     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 677                                                          - init_time[4])
 678
 679     # ASV start GUI without Loader
 680     #if args['gui']:
 681     #    session.GetInterface()
 682
 683     #
 684     # additionnal external python interpreters
 685     #
 686     nbaddi=0
 687
 688     try:
 689         if 'interp' in args:
 690             if args['interp']:
 691                 nbaddi = int(args['interp'][0])
 692     except:
 693         import traceback
 694         traceback.print_exc()
 695         print "-------------------------------------------------------------"
 696         print "-- to get an external python interpreter:runSalome --interp=1"
 697         print "-------------------------------------------------------------"
 698
 699     print "additional external python interpreters: ", nbaddi
 700     if nbaddi:
 701         for i in range(nbaddi):
 702             print "i=",i
 703             anInterp=InterpServer(args)
 704             anInterp.run()
 705
 706     return clt
 707
 708 # -----------------------------------------------------------------------------
 709
 710 def useSalome(args, modules_list, modules_root_dir):
 711     """
 712     Launch all SALOME servers requested by args,
 713     save list of process, give info to user,
 714     show registered objects in Naming Service.
 715     """
 716
 717     clt=None
 718     try:
 719         clt = startSalome(args, modules_list, modules_root_dir)
 720     except:
 721         import traceback
 722         traceback.print_exc()
 723         print
 724         print
 725         print "--- erreur au lancement Salome ---"
 726
 727     #print process_id
 728
 729     from killSalomeWithPort import getPiDict
 730     filedict = getPiDict(args['port'])
 731
 732     process_ids = []
 733     try:
 734         fpid=open(filedict, 'r')
 735         process_ids=pickle.load(fpid)
 736         fpid.close()
 737     except:
 738         pass
 739
 740     fpid=open(filedict, 'w')
 741     process_ids.append(process_id)
 742     pickle.dump(process_ids,fpid)
 743     fpid.close()
 744
 745     print """
 746     Saving of the dictionary of Salome processes in %s
 747     To kill SALOME processes from a console (kill all sessions from all ports):
 748       python killSalome.py
 749     To kill SALOME from the present interpreter, if it is not closed :
 750       killLocalPort()      --> kill this session
 751                                (use CORBA port from args of runSalome)
 752       givenPortKill(port)  --> kill a specific session with given CORBA port
 753       killAllPorts()       --> kill all sessions
 754
 755     runSalome, with --killall option, starts with killing
 756     the processes resulting from the previous execution.
 757     """%filedict
 758
 759     #
 760     #  Impression arborescence Naming Service
 761     #
 762
 763     if clt != None:
 764         print
 765         print " --- registered objects tree in Naming Service ---"
 766         clt.showNS()
 767
 768     return clt
 769
 770 # -----------------------------------------------------------------------------
 771
 772 def registerEnv(args, modules_list, modules_root_dir):
 773     """
 774     Register args, modules_list, modules_root_dir in a file
 775     for further use, when SALOME is launched embedded in an other application.
 776     """
 777     fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
 778             + '_' + args['appname'].upper() + '_env'
 779     fenv=open(fileEnv,'w')
 780     pickle.dump((args, modules_list, modules_root_dir),fenv)
 781     fenv.close()
 782     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 783
 784 # -----------------------------------------------------------------------------
 785
 786 def no_main():
 787     """Salome Launch, when embedded in other application"""
 788     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 789     fenv=open(fileEnv,'r')
 790     args, modules_list, modules_root_dir = pickle.load(fenv)
 791     fenv.close()
 792     kill_salome(args)
 793     clt = useSalome(args, modules_list, modules_root_dir)
 794     return clt
 795
 796 # -----------------------------------------------------------------------------
 797
 798 def main():
 799     """Salome launch as a main application"""
 800     args, modules_list, modules_root_dir = get_config()
 801     kill_salome(args)
 802     set_env(args, modules_list, modules_root_dir)
 803     clt = useSalome(args, modules_list, modules_root_dir)
 804     return clt,args
 805
 806 # -----------------------------------------------------------------------------
 807
 808 if __name__ == "__main__":
 809    import user
 810    clt,args = main()