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 # ---
 422
 423 class ContainerManagerServer(Server):
 424     def __init__(self,args):
 425         self.args=args
 426         self.initArgs()
 427         self.SCMD1=['SALOME_ContainerManagerServer']
 428         self.SCMD2=[]
 429         if 'registry' in self.args['embedded']:
 430             self.SCMD1+=['--with','Registry',
 431                          '(','--salome_session','theSession',')']
 432         if 'moduleCatalog' in self.args['embedded']:
 433             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 434             self.SCMD2+=['-personal',
 435                          '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 436         if 'study' in self.args['embedded']:
 437             self.SCMD2+=['--with','SALOMEDS','(',')']
 438         if 'cppContainer' in self.args['embedded']:
 439             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 440
 441     def setpath(self,modules_list,modules_root_dir):
 442         cata_path=[]
 443         list_modules = modules_list[:]
 444         list_modules.reverse()
 445         for module in ["KERNEL"] + list_modules:
 446             module_root_dir=modules_root_dir[module]
 447             module_cata=module+"Catalog.xml"
 448             print "   ", module_cata
 449             cata_path.extend(
 450                 glob.glob(os.path.join(module_root_dir,"share",
 451                                        self.args['appname'],"resources",
 452                                        module_cata)))
 453         if 'moduleCatalog' in self.args['embedded']:
 454             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 455         else:
 456             self.CMD=self.SCMD1 + self.SCMD2
 457
 458 class NotifyServer(Server):
 459     def __init__(self,args,modules_root_dir):
 460         self.args=args
 461         self.initArgs()
 462         self.modules_root_dir=modules_root_dir
 463         myLogName = os.environ["LOGNAME"]
 464         self.CMD=['notifd','-c',
 465                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/channel.cfg',
 466                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 467                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 468                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 469                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 470                   ]
 471
 472 #
 473 # -----------------------------------------------------------------------------
 474
 475 def startGUI():
 476     """Salome Session Graphic User Interface activation"""
 477     import SALOME
 478     import SALOME_Session_idl
 479     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 480     session.GetInterface()
 481
 482 # -----------------------------------------------------------------------------
 483
 484 def startSalome(args, modules_list, modules_root_dir):
 485     """Launch all SALOME servers requested by args"""
 486     init_time = os.times()
 487
 488     print "startSalome ", args
 489
 490     #
 491     # Initialisation ORB et Naming Service
 492     #
 493
 494     clt=orbmodule.client()
 495
 496     #
 497     # Lancement Session Server
 498     #
 499     mySessionServ = SessionServer(args)
 500     mySessionServ.setpath(modules_list,modules_root_dir)
 501     mySessionServ.run()
 502
 503     # (non obligatoire) Lancement Logger Server
 504     # et attente de sa disponibilite dans le naming service
 505     #
 506
 507     if args['logger']:
 508         myServer=LoggerServer(args)
 509         myServer.run()
 510         clt.waitLogger("Logger")
 511
 512     # Notify Server launch
 513     #
 514
 515     print "Notify Server to launch"
 516
 517     myServer=NotifyServer(args,modules_root_dir)
 518     myServer.run()
 519
 520     #
 521     # Lancement Registry Server,
 522     # attente de la disponibilite du Registry dans le Naming Service
 523     #
 524
 525     if 'registry' not in args['embedded']:
 526         myServer=RegistryServer(args)
 527         myServer.run()
 528         clt.waitNS("/Registry")
 529
 530     #
 531     # Lancement Catalog Server,
 532     # attente de la disponibilite du Catalog Server dans le Naming Service
 533     #
 534
 535
 536     if 'moduleCatalog' not in args['embedded']:
 537         cataServer=CatalogServer(args)
 538         cataServer.setpath(modules_list,modules_root_dir)
 539         cataServer.run()
 540         import SALOME_ModuleCatalog
 541         clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 542
 543     #
 544     # Lancement SalomeDS Server,
 545     # attente de la disponibilite du SalomeDS dans le Naming Service
 546     #
 547
 548     os.environ["CSF_PluginDefaults"] \
 549     = os.path.join(modules_root_dir["KERNEL"],"share",
 550                    salome_subdir,"resources")
 551     os.environ["CSF_SALOMEDS_ResourcesDefaults"] \
 552     = os.path.join(modules_root_dir["KERNEL"],"share",
 553                    salome_subdir,"resources")
 554
 555     if "GEOM" in modules_list:
 556         print "GEOM OCAF Resources"
 557         os.environ["CSF_GEOMDS_ResourcesDefaults"] \
 558         = os.path.join(modules_root_dir["GEOM"],"share",
 559                        salome_subdir,"resources")
 560         print "GEOM Shape Healing Resources"
 561         os.environ["CSF_ShHealingDefaults"] \
 562         = os.path.join(modules_root_dir["GEOM"],"share",
 563                        salome_subdir,"resources")
 564
 565     print "ARGS = ",args
 566     if 'study' not in args['embedded']:
 567         print "RunStudy"
 568         myServer=SalomeDSServer(args)
 569         myServer.run()
 570         clt.waitNS("/myStudyManager")
 571
 572     #
 573     # Lancement ContainerManagerServer
 574     #
 575
 576     myCmServer = ContainerManagerServer(args)
 577     myCmServer.setpath(modules_list,modules_root_dir)
 578     myCmServer.run()
 579
 580
 581     from Utils_Identity import getShortHostName
 582
 583     if os.getenv("HOSTNAME") == None:
 584         if os.getenv("HOST") == None:
 585             os.environ["HOSTNAME"]=getShortHostName()
 586         else:
 587             os.environ["HOSTNAME"]=os.getenv("HOST")
 588
 589     theComputer = getShortHostName()
 590
 591     #
 592     # Lancement Container C++ local,
 593     # attente de la disponibilite du Container C++ local dans le Naming Service
 594     #
 595
 596     if 'cppContainer' in args['standalone']:
 597         myServer=ContainerCPPServer(args)
 598         myServer.run()
 599         clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 600
 601     #
 602     # Lancement Container Python local,
 603     # attente de la disponibilite du Container Python local
 604     # dans le Naming Service
 605     #
 606
 607     if 'pyContainer' in args['standalone']:
 608         myServer=ContainerPYServer(args)
 609         myServer.run()
 610         clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 611
 612     #
 613     # Lancement Container Supervision local,
 614     # attente de la disponibilite du Container Supervision local
 615     # dans le Naming Service
 616     #
 617
 618     if 'supervContainer' in args['standalone']:
 619         myServer=ContainerSUPERVServer(args)
 620         myServer.run()
 621         clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 622 ##----------------
 623
 624     # Attente de la disponibilite du Session Server dans le Naming Service
 625     #
 626
 627     import SALOME
 628     import SALOME_Session_idl
 629     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 630
 631     end_time = os.times()
 632     print
 633     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 634                                                          - init_time[4])
 635
 636     # ASV start GUI without Loader
 637     #if args['gui']:
 638     #    session.GetInterface()
 639
 640     #
 641     # additionnal external python interpreters
 642     #
 643     nbaddi=0
 644
 645     try:
 646         if 'interp' in args:
 647             if args['interp']:
 648                 nbaddi = int(args['interp'][0])
 649     except:
 650         import traceback
 651         traceback.print_exc()
 652         print "-------------------------------------------------------------"
 653         print "-- to get an external python interpreter:runSalome --interp=1"
 654         print "-------------------------------------------------------------"
 655
 656     print "additional external python interpreters: ", nbaddi
 657     if nbaddi:
 658         for i in range(nbaddi):
 659             print "i=",i
 660             anInterp=InterpServer(args)
 661             anInterp.run()
 662
 663     return clt
 664
 665 # -----------------------------------------------------------------------------
 666
 667 def useSalome(args, modules_list, modules_root_dir):
 668     """
 669     Launch all SALOME servers requested by args,
 670     save list of process, give info to user,
 671     show registered objects in Naming Service.
 672     """
 673
 674     clt=None
 675     try:
 676         clt = startSalome(args, modules_list, modules_root_dir)
 677     except:
 678         import traceback
 679         traceback.print_exc()
 680         print
 681         print
 682         print "--- erreur au lancement Salome ---"
 683
 684     #print process_id
 685
 686 #    filedict = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
 687 #             + '_' + args['appname'].upper() + '_pidict'
 688 # replaced args['appname'] by "SALOME" because in killSalome.py use of 'SALOME' in file name is hardcoded.
 689     filedict = os.getenv("HOME") + '/' + os.getenv('USER') + "_" + str(args['port']) \
 690                + '_' + 'SALOME' + '_pidict'
 691     process_ids = []
 692     try:
 693         fpid=open(filedict, 'r')
 694         process_ids=pickle.load(fpid)
 695         fpid.close()
 696     except:
 697         pass
 698
 699     fpid=open(filedict, 'w')
 700     process_ids.append(process_id)
 701     pickle.dump(process_ids,fpid)
 702     fpid.close()
 703
 704     print """
 705     Saving of the dictionary of Salome processes in %s
 706     To kill SALOME processes from a console (kill all sessions from all ports):
 707       python killSalome.py
 708     To kill SALOME from the present interpreter, if it is not closed :
 709       killLocalPort()      --> kill this session
 710                                (use CORBA port from args of runSalome)
 711       givenPortKill(port)  --> kill a specific session with given CORBA port
 712       killAllPorts()       --> kill all sessions
 713
 714     runSalome, with --killall option, starts with killing
 715     the processes resulting from the previous execution.
 716     """%filedict
 717
 718     #
 719     #  Impression arborescence Naming Service
 720     #
 721
 722     if clt != None:
 723         print
 724         print " --- registered objects tree in Naming Service ---"
 725         clt.showNS()
 726
 727     return clt
 728
 729 # -----------------------------------------------------------------------------
 730
 731 def registerEnv(args, modules_list, modules_root_dir):
 732     """
 733     Register args, modules_list, modules_root_dir in a file
 734     for further use, when SALOME is launched embedded in an other application.
 735     """
 736     fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
 737             + '_' + args['appname'].upper() + '_env'
 738     fenv=open(fileEnv,'w')
 739     pickle.dump((args, modules_list, modules_root_dir),fenv)
 740     fenv.close()
 741     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 742
 743 # -----------------------------------------------------------------------------
 744
 745 def no_main():
 746     """Salome Launch, when embedded in other application"""
 747     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 748     fenv=open(fileEnv,'r')
 749     args, modules_list, modules_root_dir = pickle.load(fenv)
 750     fenv.close()
 751     kill_salome(args)
 752     clt = useSalome(args, modules_list, modules_root_dir)
 753     return clt
 754
 755 # -----------------------------------------------------------------------------
 756
 757 def main():
 758     """Salome launch as a main application"""
 759     args, modules_list, modules_root_dir = get_config()
 760     kill_salome(args)
 761     set_env(args, modules_list, modules_root_dir)
 762     clt = useSalome(args, modules_list, modules_root_dir)
 763     return clt,args
 764
 765 # -----------------------------------------------------------------------------
 766
 767 if __name__ == "__main__":
 768    import user
 769    clt,args = main()