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