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