X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=bin%2FrunSalome.py;h=722629ad4694265738e3dee09443f937a813f01c;hb=7abfafb698042a8635b7cbf9d2347937f2036ba8;hp=d390355841cbc090ebd911c2e1795c87a6a4cd9f;hpb=ac2ad9920aca0ee2622e6e1e7e9965de401ca2f1;p=modules%2Fkernel.git

diff --git a/bin/runSalome.py b/bin/runSalome.py
index d39035584..722629ad4 100755
--- a/bin/runSalome.py
+++ b/bin/runSalome.py
@@ -1,16 +1,247 @@
 #!/usr/bin/env python
 
+# Copyright (C) 2005  OPEN CASCADE, CEA, EDF R&D, LEG
+#           PRINCIPIA R&D, EADS CCR, Lip6, BV, CEDRAT
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either 
+# version 2.1 of the License.
+# 
+# This library is distributed in the hope that it will be useful 
+# but WITHOUT ANY WARRANTY; without even the implied warranty of 
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public  
+# License along with this library; if not, write to the Free Software 
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+# 
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+# 
+
 import sys, os, string, glob, time, pickle
+import orbmodule
+
+process_id = {}
+
+# salome_subdir variable is used for composing paths like $KERNEL_ROOT_DIR/share/salome/resources/kernel, etc.
+# before moving to SUIT-based gui, instead of salome_subdir there was args['appname'] used.
+# but after - 'appname'  = "SalomeApp", so using it in making the subdirectory is an error.
+salome_subdir = "salome"
+
+# -----------------------------------------------------------------------------
+
+def add_path(directory, variable_name):
+    """Function helper to add environment variables"""
+    if not os.environ.has_key(variable_name):
+        os.environ[variable_name] = ""
+        pass
+    if os.path.exists(directory):
+        newpath=[]
+        for _dir in os.environ[variable_name].split(":"):
+            if os.path.exists(_dir):
+                if not os.path.samefile(_dir, directory):
+                  newpath.append(_dir)
+            else:
+                if os.path.abspath(_dir) != os.path.abspath(directory):
+                  newpath.append(_dir)
+            pass
+        import string
+        newpath[:0] = [ directory ]
+        newpath = string.join(newpath,":")
+        os.environ[variable_name] = newpath
+        if variable_name == "PYTHONPATH":
+            sys.path[:0] = [directory]
+
+# -----------------------------------------------------------------------------
+
+def get_config():
+    """
+    Get list of modules, paths.
+    
+    Read args from launch configure xml file and command line options.
+    Check variables <module>_ROOT_DIR and set list of used modules.
+    Return args, modules_list, modules_root_dir    
+    """
+    
+    # read args from launch configure xml file and command line options
+    
+    import launchConfigureParser
+    args = launchConfigureParser.args
+    
+    # Check variables <module>_ROOT_DIR
+    # and set list of used modules (without KERNEL)
+
+    modules_list = []
+    if args.has_key("modules"):
+        modules_list += args["modules"]
+    # KERNEL must be last in the list to locate it at the first place in PATH
+    if args["gui"] :
+        modules_list[:0] = ["GUI"]
+    modules_list[:0] = ["KERNEL"]
+    modules_list.reverse()
+
+    modules_root_dir = {}
+
+    to_remove_list=[]
+    for module in modules_list :
+        module_variable=module+"_ROOT_DIR"
+        if not os.environ.has_key(module_variable):
+            print "*******************************************************"
+            print "*"
+            print "* Environment variable",module_variable,"must be set"
+            print "* Module", module, "will be not available"
+            print "*"
+            print "********************************************************"
+            to_remove_list.append(module)
+            continue
+            pass
+        module_root_dir = os.environ[module_variable]
+        modules_root_dir[module]=module_root_dir
+
+    for to_remove in to_remove_list:
+        modules_list.remove(to_remove)
+
+    while "KERNEL" in modules_list:
+        modules_list.remove("KERNEL")
+        pass
+
+    while "GUI" in modules_list:
+        modules_list.remove("GUI")
+        pass
+
+    if "SUPERV" in modules_list and not 'superv' in args['standalone']:
+        args['standalone'].append("superv")
+        pass
+   
+    return args, modules_list, modules_root_dir
+
+# -----------------------------------------------------------------------------
+
+def set_env(args, modules_list, modules_root_dir):
+    """Add to the PATH-variables modules specific paths"""
+    
+    python_version="python%d.%d" % sys.version_info[0:2]
+    modules_root_dir_list = []
+    if args["gui"] :
+        modules_list = modules_list[:] + ["GUI"] 
+    modules_list = modules_list[:] + ["KERNEL"] 
+    for module in modules_list :
+        if modules_root_dir.has_key(module):
+            module_root_dir = modules_root_dir[module]
+            modules_root_dir_list[:0] = [module_root_dir]
+            add_path(os.path.join(module_root_dir,"lib",salome_subdir),
+                     "LD_LIBRARY_PATH")
+            add_path(os.path.join(module_root_dir,"bin",salome_subdir),
+                     "PATH")
+            if os.path.exists(module_root_dir + "/examples") :
+                add_path(os.path.join(module_root_dir,"examples"),
+                         "PYTHONPATH")
+                pass
+            add_path(os.path.join(module_root_dir,"bin",salome_subdir),
+                     "PYTHONPATH")
+            add_path(os.path.join(module_root_dir,"lib",
+                                  python_version,"site-packages",
+                                  salome_subdir),
+                     "PYTHONPATH")
+            add_path(os.path.join(module_root_dir,"lib",salome_subdir),
+                     "PYTHONPATH")
+            add_path(os.path.join(module_root_dir,"lib",
+                                  python_version,"site-packages",
+                                  salome_subdir,
+                                  "shared_modules"),
+                     "PYTHONPATH")
+            pass
+        pass
 
-### read launch configure xml file and command line options
-import launchConfigureParser
-args = launchConfigureParser.args
 
-### kill servers if it is need
+    os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
+    
+    # set trace environment variable
+    
+    if not os.environ.has_key("SALOME_trace"):
+        os.environ["SALOME_trace"]="local"
+    if args['file']:
+        os.environ["SALOME_trace"]="file:"+args['file'][0]
+    if args['logger']:
+        os.environ["SALOME_trace"]="with_logger"
+
+    # set environment for SMESH plugins
+
+    if "SMESH" in modules_list:
+        os.environ["SMESH_MeshersList"]="StdMeshers"
+        if not os.environ.has_key("SALOME_StdMeshersResources"):
+            os.environ["SALOME_StdMeshersResources"] \
+            = modules_root_dir["SMESH"]+"/share/"+args["appname"]+"/resources/smesh"
+            pass
+        if args.has_key("SMESH_plugins"):
+            for plugin in args["SMESH_plugins"]:
+                plugin_root = ""
+                if os.environ.has_key(plugin+"_ROOT_DIR"):
+                    plugin_root = os.environ[plugin+"_ROOT_DIR"]
+                else:
+                    # workaround to avoid modifications of existing environment
+                    if os.environ.has_key(plugin.upper()+"_ROOT_DIR"):
+                        plugin_root = os.environ[plugin.upper()+"_ROOT_DIR"]
+                        pass
+                    pass
+                if plugin_root != "":
+                    os.environ["SMESH_MeshersList"] \
+                    = os.environ["SMESH_MeshersList"]+":"+plugin
+                    if not os.environ.has_key("SALOME_"+plugin+"Resources"):
+                        os.environ["SALOME_"+plugin+"Resources"] \
+                        = plugin_root+"/share/"+args["appname"]+"/resources/"+plugin.lower()
+                    add_path(os.path.join(plugin_root,"lib",python_version,
+                                          "site-packages",salome_subdir),
+                             "PYTHONPATH")
+                    add_path(os.path.join(plugin_root,"lib",salome_subdir),
+                             "PYTHONPATH")
+                    add_path(os.path.join(plugin_root,"lib",salome_subdir),
+                             "LD_LIBRARY_PATH")
+                    add_path(os.path.join(plugin_root,"bin",salome_subdir),
+                             "PYTHONPATH")
+                    add_path(os.path.join(plugin_root,"bin",salome_subdir),
+                             "PATH")
+            pass
+        pass
+
+    # set environment for SUPERV module
+    os.environ["ENABLE_MACRO_NODE"]="1"
+    # set resources variables if not yet set
+    # Done now by launchConfigureParser.py
+    #if os.getenv("GUI_ROOT_DIR"):
+        #if not os.getenv("SalomeAppConfig"): os.environ["SalomeAppConfig"] =  os.getenv("GUI_ROOT_DIR") + "/share/salome/resources/gui"
+
+    # set CSF_PluginDefaults variable only if it is not customized
+    # by the user
+    if not os.getenv("CSF_PluginDefaults"):
+        os.environ["CSF_PluginDefaults"] \
+        = os.path.join(modules_root_dir["KERNEL"],"share",
+                       salome_subdir,"resources","kernel")
+    os.environ["CSF_SALOMEDS_ResourcesDefaults"] \
+    = os.path.join(modules_root_dir["KERNEL"],"share",
+                   salome_subdir,"resources","kernel")
+
+    if "GEOM" in modules_list:
+        print "GEOM OCAF Resources"
+        os.environ["CSF_GEOMDS_ResourcesDefaults"] \
+        = os.path.join(modules_root_dir["GEOM"],"share",
+                       salome_subdir,"resources","geom")
+	print "GEOM Shape Healing Resources"
+        os.environ["CSF_ShHealingDefaults"] \
+        = os.path.join(modules_root_dir["GEOM"],"share",
+                       salome_subdir,"resources","geom")
+
+# -----------------------------------------------------------------------------
 
 from killSalome import killAllPorts
 
 def killLocalPort():
+    """
+    kill servers from a previous SALOME exection, if needed,
+    on the CORBA port given in args of runSalome
+    """
+    
     from killSalomeWithPort import killMyPort
     my_port=str(args['port'])
     try:
@@ -20,383 +251,532 @@ def killLocalPort():
         pass
     pass
     
-if args['killall']:
-    killAllPorts()
-elif args['portkill']:
-    killLocalPort()
-	
-# -----------------------------------------------------------------------------
-#
-# Fonctions helper pour ajouter des variables d'environnement
-#
-
-def add_path(directory, variable_name):
-    if not os.environ.has_key(variable_name):
-        os.environ[variable_name] = ""
-        pass
-    os.environ[variable_name]=directory + ":" + os.environ[variable_name]
-    if variable_name=="PYTHONPATH":
-        sys.path[:0]=[directory]
-
-
-init_time = os.times()
-# -----------------------------------------------------------------------------
-#
-# Check variables <module>_ROOT_DIR and set list of used modules (without KERNEL)
-# Add to the PATH-variables modules' specific paths
-#
-modules_list = []
-if args.has_key("modules"):
-    modules_list += args["modules"]
-modules_list[:0] = ["KERNEL"] # KERNEL must be last in the list to locate it at the first place in PATH variables
-modules_list.reverse()
-
-modules_root_dir = {}
-modules_root_dir_list = []
-python_version="python%d.%d" % sys.version_info[0:2]
-
-to_remove_list=[]
-for module in modules_list :
-    module_variable=module.upper()+"_ROOT_DIR"
-    if not os.environ.has_key(module_variable):
-        print "*******************************************************************************"
-        print "*"
-        print "* Environment variable",module_variable,"must be set"
-        print "* Module", module, "will be not available"
-        print "*"
-        print "*******************************************************************************"
-        to_remove_list.append(module)
-        continue
+def givenPortKill(port):
+    """
+    kill servers from a previous SALOME exection, if needed,
+    on the same CORBA port
+    """
+    
+    from killSalomeWithPort import killMyPort
+    my_port=port
+    try:
+        killMyPort(my_port)
+    except:
+        print "problem in LocalPortKill(), killMyPort("<<port<<")"
         pass
-    module_root_dir = os.environ[module_variable]
-    modules_root_dir[module]=module_root_dir
-    modules_root_dir_list[:0] = [module_root_dir]
-    add_path(os.path.join(module_root_dir,"lib",args['appname']), "LD_LIBRARY_PATH")
-    add_path(os.path.join(module_root_dir,"bin",args['appname']), "PATH")
-    if os.path.exists(module_root_dir + "/examples") :
-        add_path(os.path.join(module_root_dir,"examples"), "PYTHONPATH")
-
-for to_remove in to_remove_list:
-    modules_list.remove(to_remove)
-
-while "KERNEL" in modules_list:
-    modules_list.remove("KERNEL")
     pass
 
-# KERNEL must be last in the list to locate it at the first place in PYTHONPATH variable
-list_modules = modules_list[:] + ["KERNEL"] 
-for module in list_modules:
-    module_root_dir = modules_root_dir[module]
-    add_path(os.path.join(module_root_dir,"bin",args['appname']), "PYTHONPATH")
-    add_path(os.path.join(module_root_dir,"lib",python_version,"site-packages",args['appname']), "PYTHONPATH")
-    add_path(os.path.join(module_root_dir,"lib",args['appname']), "PYTHONPATH")
-    add_path(os.path.join(module_root_dir,"lib",python_version,"site-packages",args['appname'],"shared_modules"), "PYTHONPATH")
-      
-#os.environ["SALOMEPATH"]=":".join(modules_root_dir.values())
-os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
-if "SUPERV" in modules_list and not 'superv' in args['standalone']:
-    args['standalone'].append("superv")
-    pass
-
-
+def kill_salome(args):
+    """
+    Kill servers from previous SALOME executions, if needed;
+    depending on args 'killall' or 'portkill', kill all executions,
+    or only execution on the same CORBA port
+    """
+
+    if args['killall']:
+        killAllPorts()
+    elif args['portkill']:
+        givenPortKill(str(args['port']))
+	
 # -----------------------------------------------------------------------------
 #
-# Définition des classes d'objets pour le lancement des Server CORBA
+# Definition des classes d'objets pour le lancement des Server CORBA
 #
 
 class Server:
-   CMD=[]
-   if args['xterm']:
-	ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
-   else:
-   	ARGS=[]	
-
-   def run(self):
-       global process_id
-       myargs=self.ARGS
-       if args['xterm']:
-           # (Debian) Transfert variable LD_LIBRARY_PATH aux shells fils (xterm)
-           env_ld_library_path=['env', 'LD_LIBRARY_PATH='+ os.getenv("LD_LIBRARY_PATH")]
-           myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
-       command = myargs + self.CMD
-       #print "command = ", command
-       pid = os.spawnvp(os.P_NOWAIT, command[0], command)
-       process_id[pid]=self.CMD
+    """Generic class for CORBA server launch"""
+
+    def initArgs(self):
+        self.PID=None
+        self.CMD=[]
+        self.ARGS=[]	
+        if self.args['xterm']:
+            self.ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
+
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+
+
+    def run(self):
+        global process_id
+        myargs=self.ARGS
+        if self.args['xterm']:
+            # (Debian) send LD_LIBRARY_PATH to children shells (xterm)
+            env_ld_library_path=['env', 'LD_LIBRARY_PATH='
+                                 + os.getenv("LD_LIBRARY_PATH")]
+            myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
+        command = myargs + self.CMD
+        print "command = ", command
+        pid = os.spawnvp(os.P_NOWAIT, command[0], command)
+        process_id[pid]=self.CMD
+        self.PID = pid
+
+
+class InterpServer(Server):
+    def __init__(self,args):
+        self.args=args
+        env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
+        self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
+        #self.CMD=['xterm', '-e', 'python']
+       
+    def run(self):
+        global process_id
+        command = self.CMD
+        #print "command = ", command
+        pid = os.spawnvp(os.P_NOWAIT, command[0], command)
+        process_id[pid]=self.CMD
+        self.PID = pid
+
+# ---
 
 class CatalogServer(Server):
-   SCMD1=['SALOME_ModuleCatalog_Server','-common']
-   SCMD2=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml'] 
-
-   def setpath(self,modules_list):
-      cata_path=[]
-      list_modules = modules_list[:]
-      list_modules.reverse()
-      for module in ["KERNEL"] + list_modules:
-          module_root_dir=modules_root_dir[module]
-          module_cata=module+"Catalog.xml"
-          print "   ", module_cata
-          cata_path.extend(glob.glob(os.path.join(module_root_dir,"share",args['appname'],"resources",module_cata)))
-      self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
+        self.SCMD2=[]
+        home_dir=os.getenv('HOME')
+        if home_dir is not None:
+            self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')] 
+
+    def setpath(self,modules_list,modules_root_dir):
+        cata_path=[]
+        list_modules = modules_list[:]
+        list_modules.reverse()
+        if self.args["gui"] :
+            list_modules = ["KERNEL", "GUI"] + list_modules
+        else :
+            list_modules = ["KERNEL"] + list_modules
+        for module in list_modules:
+            if modules_root_dir.has_key(module):
+                module_root_dir=modules_root_dir[module]
+                module_cata=module+"Catalog.xml"
+                #print "   ", module_cata
+                if os.path.exists(os.path.join(module_root_dir,
+                                               "share",salome_subdir,
+                                               "resources",module.lower(),
+                                               module_cata)):
+                    cata_path.extend(
+                        glob.glob(os.path.join(module_root_dir,
+                                               "share",salome_subdir,
+                                               "resources",module.lower(),
+                                               module_cata)))
+                else:
+                    cata_path.extend(
+                        glob.glob(os.path.join(module_root_dir,
+                                               "share",salome_subdir,
+                                               "resources",
+                                               module_cata)))
+                pass
+            pass
+        self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
+
+# ---
 
 class SalomeDSServer(Server):
-   CMD=['SALOMEDS_Server']
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.CMD=['SALOMEDS_Server']
+
+# ---
 
 class RegistryServer(Server):
-   CMD=['SALOME_Registry_Server', '--salome_session','theSession']
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
+
+# ---
 
 class ContainerCPPServer(Server):
-   #CMD=['SALOME_Container','FactoryServer','-ORBInitRef','NameService=corbaname::localhost']
-   CMD=['SALOME_Container','FactoryServer']
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.CMD=['SALOME_Container','FactoryServer']
+
+# ---
 
 class ContainerPYServer(Server):
-   #CMD=['SALOME_ContainerPy.py','FactoryServerPy','-ORBInitRef','NameService=corbaname::localhost']
-   CMD=['SALOME_ContainerPy.py','FactoryServerPy']
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
+
+# ---
 
 class ContainerSUPERVServer(Server):
-   #CMD=['SALOME_Container','SuperVisionContainer','-ORBInitRef','NameService=corbaname::localhost']
-   CMD=['SALOME_Container','SuperVisionContainer']
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.CMD=['SALOME_Container','SuperVisionContainer']
+
+# ---
 
 class LoggerServer(Server):
-   CMD=['SALOME_Logger_Server', 'logger.log']
-
-class SessionLoader(Server):
-   CMD=['SALOME_Session_Loader']
-   if "cpp" in args['containers']:
-       CMD=CMD+['CPP']
-   if "python" in args['containers']:
-       CMD=CMD+['PY']
-   if "superv" in args['containers']:
-       CMD=CMD+['SUPERV']
-   if args['gui']:
-       CMD=CMD+['GUI']
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.CMD=['SALOME_Logger_Server', 'logger.log']
+
+# ---
 
 class SessionServer(Server):
-   SCMD1=['SALOME_Session_Server']
-   SCMD2=[]
-   if 'registry' in args['embedded']:
-       SCMD1+=['--with','Registry','(','--salome_session','theSession',')']
-   if 'moduleCatalog' in args['embedded']:
-       SCMD1+=['--with','ModuleCatalog','(','-common']
-       SCMD2+=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
-   if 'study' in args['embedded']:
-       SCMD2+=['--with','SALOMEDS','(',')']
-   if 'cppContainer' in args['embedded']:
-       SCMD2+=['--with','Container','(','FactoryServer',')']
-
-   def setpath(self,modules_list):
-      cata_path=[]
-      list_modules = modules_list[:]
-      list_modules.reverse()
-      for module in ["KERNEL"] + list_modules:
-          module_root_dir=modules_root_dir[module]
-          module_cata=module+"Catalog.xml"
-          print "   ", module_cata
-          cata_path.extend(glob.glob(os.path.join(module_root_dir,"share",args['appname'],"resources",module_cata)))
-      if 'moduleCatalog' in args['embedded']:
-          self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
-      else:
-          self.CMD=self.SCMD1 + self.SCMD2
+    def __init__(self,args):
+        self.args = args.copy()
+        # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
+        self.args['xterm']=0
+        #
+        self.initArgs()
+        self.SCMD1=['SALOME_Session_Server']
+        self.SCMD2=[]
+        if 'registry' in self.args['embedded']:
+            self.SCMD1+=['--with','Registry',
+                         '(','--salome_session','theSession',')']
+        if 'moduleCatalog' in self.args['embedded']:
+            self.SCMD1+=['--with','ModuleCatalog','(','-common']
+            home_dir=os.getenv('HOME')
+            if home_dir is not None:
+                self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')] 
+            self.SCMD2+=[')']
+        if 'study' in self.args['embedded']:
+            self.SCMD2+=['--with','SALOMEDS','(',')']
+        if 'cppContainer' in self.args['embedded']:
+            self.SCMD2+=['--with','Container','(','FactoryServer',')']
+        if 'SalomeAppEngine' in self.args['embedded']:
+            self.SCMD2+=['--with','SalomeAppEngine','(',')']
+            
+        if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
+            self.SCMD2+=['CPP']
+        if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
+            self.SCMD2+=['PY']
+        if 'supervContainer' in self.args['containers'] or 'supervContainer' in self.args['standalone']:
+            self.SCMD2+=['SUPERV']
+        if self.args['gui']:
+            self.SCMD2+=['GUI']
+        if self.args['splash'] and self.args['gui']:
+            self.SCMD2+=['SPLASH']
+        if self.args['noexcepthandler']:
+            self.SCMD2+=['noexcepthandler']
+        if self.args.has_key('modules'):
+            self.SCMD2+=['--modules (']
+            for mod in self.args['modules']:
+                self.SCMD2+=[mod + ':']
+            self.SCMD2+=[')']    
+
+    def setpath(self,modules_list,modules_root_dir):
+        cata_path=[]
+        list_modules = modules_list[:]
+        list_modules.reverse()
+        if self.args["gui"] :
+            list_modules = ["KERNEL", "GUI"] + list_modules
+        else :
+            list_modules = ["KERNEL"] + list_modules
+        for module in list_modules:
+            module_root_dir=modules_root_dir[module]
+            module_cata=module+"Catalog.xml"
+            #print "   ", module_cata
+            if os.path.exists(os.path.join(module_root_dir,
+                                           "share",salome_subdir,
+                                           "resources",module.lower(),
+                                           module_cata)):
+                cata_path.extend(
+                    glob.glob(os.path.join(module_root_dir,"share",
+                                           salome_subdir,"resources",
+                                           module.lower(),module_cata)))
+            else:
+                cata_path.extend(
+                    glob.glob(os.path.join(module_root_dir,"share",
+                                           salome_subdir,"resources",
+                                           module_cata)))
+            pass
+        if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
+            self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
+        else:
+            self.CMD=self.SCMD1 + self.SCMD2
+      
+# ---
+
+class ContainerManagerServer(Server):
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+        self.SCMD1=['SALOME_ContainerManagerServer']
+        self.SCMD2=[]
+        if args["gui"] :
+            if 'registry' in self.args['embedded']:
+                self.SCMD1+=['--with','Registry',
+                             '(','--salome_session','theSession',')']
+            if 'moduleCatalog' in self.args['embedded']:
+                self.SCMD1+=['--with','ModuleCatalog','(','-common']
+                self.SCMD2+=['-personal',
+                             '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
+            if 'study' in self.args['embedded']:
+                self.SCMD2+=['--with','SALOMEDS','(',')']
+            if 'cppContainer' in self.args['embedded']:
+                self.SCMD2+=['--with','Container','(','FactoryServer',')']
+        
+    def setpath(self,modules_list,modules_root_dir):
+        cata_path=[]
+        list_modules = modules_list[:]
+        list_modules.reverse()
+        if self.args["gui"] :
+            list_modules = ["GUI"] + list_modules
+        for module in ["KERNEL"] + list_modules:
+            if modules_root_dir.has_key(module):
+                module_root_dir=modules_root_dir[module]
+                module_cata=module+"Catalog.xml"
+                #print "   ", module_cata
+                if os.path.exists(os.path.join(module_root_dir,
+                                               "share",salome_subdir,
+                                               "resources",module.lower(),
+                                               module_cata)):
+                    cata_path.extend(
+                        glob.glob(os.path.join(module_root_dir,"share",
+                                               self.args['appname'],"resources",
+                                               module.lower(),module_cata)))
+                else:
+                    cata_path.extend(
+                        glob.glob(os.path.join(module_root_dir,"share",
+                                               self.args['appname'],"resources",
+                                               module_cata)))
+                pass
+            pass
+        if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
+            self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
+        else:
+            self.CMD=self.SCMD1 + self.SCMD2
 
 class NotifyServer(Server):
-    myLogName = os.environ["LOGNAME"]
-    CMD=['notifd','-c',modules_root_dir["KERNEL"]+'/share/salome/resources/channel.cfg', '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior', '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior']
-
-# -----------------------------------------------------------------------------
-#
-# initialisation des variables d'environnement
-#
-
-os.environ["SALOME_trace"]="local"
-if args['logger']:
-   os.environ["SALOME_trace"]="with_logger"
-   locdir=os.environ['PWD']
-   libtracedir=os.path.join(locdir,"libSalomeTrace")
-   libtrace = os.path.join(modules_root_dir["KERNEL"],"lib",args['appname'],"libSALOMELoggerClient.so.0.0.0")
-   libtraceln = os.path.join(libtracedir,"libSALOMELocalTrace.so")
-   aCommand = 'rm -rf ' + libtracedir + "; "
-   aCommand += 'mkdir ' + libtracedir + "; "
-   aCommand += 'ln -s ' + libtrace + " " + libtraceln + "; "
-   aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0; "
-   aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0.0.0; "
-   os.system(aCommand)
-   add_path(libtracedir, "LD_LIBRARY_PATH")
-
-# set environment for SMESH plugins
-
-if "SMESH" in args["modules"]:
-    os.environ["SMESH_MeshersList"]="StdMeshers"
-    if not os.environ.has_key("SALOME_StdMeshersResources"):
-        os.environ["SALOME_StdMeshersResources"] = modules_root_dir["SMESH"]+"/share/"+args["appname"]+"/resources"
-        pass
-    if args.has_key("SMESH_plugins"):
-        for plugin in args["SMESH_plugins"]:
-            if os.environ.has_key(plugin.upper()+"_ROOT_DIR"):
-                os.environ["SMESH_MeshersList"]=os.environ["SMESH_MeshersList"]+":"+plugin
-                plugin_root = os.environ[plugin.upper()+"_ROOT_DIR"]
-                if not os.environ.has_key("SALOME_"+plugin+"Resources"):
-                    os.environ["SALOME_"+plugin+"Resources"] = plugin_root+"/share/"+args["appname"]+"/resources"
-                add_path(os.path.join(plugin_root,"lib",python_version,"site-packages",args['appname']), "PYTHONPATH")
-                add_path(os.path.join(plugin_root,"lib",args['appname']), "PYTHONPATH")
-                add_path(os.path.join(plugin_root,"lib",args['appname']), "LD_LIBRARY_PATH")
-                add_path(os.path.join(plugin_root,"bin",args['appname']), "PYTHONPATH")
-                add_path(os.path.join(plugin_root,"bin",args['appname']), "PATH")
-        pass
-    pass
-   
-import orbmodule
+    def __init__(self,args,modules_root_dir):
+        self.args=args
+        self.initArgs()
+        self.modules_root_dir=modules_root_dir
+        myLogName = os.environ["LOGNAME"]
+        self.CMD=['notifd','-c',
+                  self.modules_root_dir["KERNEL"] +'/share/salome/resources/kernel/channel.cfg',
+                  '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
+                  '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
+                  '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
+                  '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
+                  ]
 
 #
 # -----------------------------------------------------------------------------
-#
 
 def startGUI():
-  import SALOME
-  session=clt.waitNS("/Kernel/Session",SALOME.Session)
-
-  #
-  # Activation du GUI de Session Server
-  #
-	
-  session.GetInterface()
+    """Salome Session Graphic User Interface activation"""
+    import Engines
+    import SALOME
+    import SALOMEDS
+    import SALOME_ModuleCatalog
+    reload(Engines)
+    reload(SALOME)
+    reload(SALOMEDS)
+    import SALOME_Session_idl
+    session=clt.waitNS("/Kernel/Session",SALOME.Session)
+    session.GetInterface()
   
-#
 # -----------------------------------------------------------------------------
-#
 
-def startSalome():
+def startSalome(args, modules_list, modules_root_dir):
+    """Launch all SALOME servers requested by args"""
+    init_time = os.times()
 
-  #
-  # Lancement Session Loader
-  #
+    print "startSalome ", args
+    
+    #
+    # Initialisation ORB et Naming Service
+    #
+   
+    clt=orbmodule.client()
 
-  if args['gui']:
-     SessionLoader().run()
+    # (non obligatoire) Lancement Logger Server
+    # et attente de sa disponibilite dans le naming service
+    #
 
-  #
-  # Initialisation ORB et Naming Service
-  #
-   
-  clt=orbmodule.client()
-
-  # (non obligatoire) Lancement Logger Server et attente de sa disponibilite dans le naming service
-  #
-
-  if args['logger']:
-	LoggerServer().run()
-	clt.waitLogger("Logger")
-
-  # Notify Server launch
-  #
-  NotifyServer().run()
-
-  #
-  # Lancement Registry Server, attente de la disponibilité du Registry dans le Naming Service
-  #
-  if 'registry' not in args['embedded']:
-      RegistryServer().run()
-      clt.waitNS("/Registry")
-
-  #
-  # Lancement Catalog Server, attente de la disponibilité du Catalog Server dans le Naming Service
-  #
-
-  if 'moduleCatalog' not in args['embedded']:
-      cataServer=CatalogServer()
-      cataServer.setpath(modules_list)
-      cataServer.run()
-      import SALOME_ModuleCatalog
-      clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
-
-  #
-  # Lancement SalomeDS Server, attente de la disponibilité du SalomeDS dans le Naming Service
-  #
-
-  os.environ["CSF_PluginDefaults"]=os.path.join(modules_root_dir["KERNEL"],"share",args['appname'],"resources")
-  os.environ["CSF_SALOMEDS_ResourcesDefaults"]=os.path.join(modules_root_dir["KERNEL"],"share",args['appname'],"resources")
-
-  if "GEOM" in modules_list:
-	print "GEOM OCAF Resources"
-	os.environ["CSF_GEOMDS_ResourcesDefaults"]=os.path.join(modules_root_dir["GEOM"],"share",args['appname'],"resources")
-
-  if 'study' not in args['embedded']:
-      SalomeDSServer().run()
-      clt.waitNS("/myStudyManager")
-
-  #
-  # Lancement Session Server
-  #
-
-  mySessionServ=SessionServer()
-  mySessionServ.setpath(modules_list)
-  mySessionServ.run()
-
-  #
-  # Attente de la disponibilité du Session Server dans le Naming Service
-  #
-
-  #import SALOME
-  #session=clt.waitNS("/Kernel/Session",SALOME.Session)
-
-  if os.getenv("HOSTNAME") == None:
-     if os.getenv("HOST") == None:
-        os.environ["HOSTNAME"]="localhost"
-     else:
-        os.environ["HOSTNAME"]=os.getenv("HOST")
-
-  theComputer = os.getenv("HOSTNAME")
-  computerSplitName = theComputer.split('.')
-  theComputer = computerSplitName[0]
-  
-  #
-  # Lancement Container C++ local, attente de la disponibilité du Container C++ local dans le Naming Service
-  #
+    if args['logger']:
+        myServer=LoggerServer(args)
+        myServer.run()
+        clt.waitLogger("Logger")
 
-  if 'cppContainer' in args['standalone']:
-	  ContainerCPPServer().run()
-	  clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
+    # Notify Server launch
+    #
 
-  #
-  # Lancement Container Python local, attente de la disponibilité du Container Python local dans le Naming Service
-  #
+    print "Notify Server to launch"
 
-  if 'pyContainer' in args['standalone']:
-	  ContainerPYServer().run()
-	  clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
+    myServer=NotifyServer(args,modules_root_dir)
+    myServer.run()
 
-  #
-  # Lancement Container Supervision local, attente de la disponibilité du Container Supervision local dans le Naming Service
-  #
+    # Lancement Session Server (to show splash ASAP)
+    #
 
-  if 'supervContainer' in args['standalone']:
-      ContainerSUPERVServer().run()
-      clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
+    if args["gui"]:
+        mySessionServ = SessionServer(args)
+        mySessionServ.setpath(modules_list,modules_root_dir)
+        mySessionServ.run()
+
+    #
+    # Lancement Registry Server,
+    # attente de la disponibilite du Registry dans le Naming Service
+    #
 
-  end_time = os.times()
-  print
-  print "Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4])
+    if ('registry' not in args['embedded']) | (args["gui"] == 0) :
+        myServer=RegistryServer(args)
+        myServer.run()
+        clt.waitNSPID("/Registry",myServer.PID)
 
-  return clt
+    #
+    # Lancement Catalog Server,
+    # attente de la disponibilite du Catalog Server dans le Naming Service
+    #
+    
+
+    if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
+        cataServer=CatalogServer(args)
+        cataServer.setpath(modules_list,modules_root_dir)
+        cataServer.run()
+        import SALOME_ModuleCatalog
+        clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
+
+    #
+    # Lancement SalomeDS Server,
+    # attente de la disponibilite du SalomeDS dans le Naming Service
+    #
+
+    #print "ARGS = ",args
+    if ('study' not in args['embedded']) | (args["gui"] == 0):
+        print "RunStudy"
+        myServer=SalomeDSServer(args)
+        myServer.run()
+        clt.waitNSPID("/myStudyManager",myServer.PID)
+
+    #
+    # Lancement ContainerManagerServer
+    #
+    
+    myCmServer = ContainerManagerServer(args)
+    myCmServer.setpath(modules_list,modules_root_dir)
+    myCmServer.run()
+
+
+    from Utils_Identity import getShortHostName
+    
+    if os.getenv("HOSTNAME") == None:
+        if os.getenv("HOST") == None:
+            os.environ["HOSTNAME"]=getShortHostName()
+        else:
+            os.environ["HOSTNAME"]=os.getenv("HOST")
+
+    theComputer = getShortHostName()
+    
+    #
+    # Lancement Container C++ local,
+    # attente de la disponibilite du Container C++ local dans le Naming Service
+    #
+
+    if 'cppContainer' in args['standalone']:
+        myServer=ContainerCPPServer(args)
+        myServer.run()
+        clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
+
+    #
+    # Lancement Container Python local,
+    # attente de la disponibilite du Container Python local
+    # dans le Naming Service
+    #
+
+    if 'pyContainer' in args['standalone']:
+        myServer=ContainerPYServer(args)
+        myServer.run()
+        clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
+
+    #
+    # Lancement Container Supervision local,
+    # attente de la disponibilite du Container Supervision local
+    # dans le Naming Service
+    #
+
+    if 'supervContainer' in args['standalone']:
+        myServer=ContainerSUPERVServer(args)
+        myServer.run()
+        clt.waitNSPID("/Containers/" + theComputer + "/SuperVisionContainer",myServer.PID)
+
+    #
+    # Attente de la disponibilite du Session Server dans le Naming Service
+    #
+    
+    if args["gui"]:
+##----------------        
+        import Engines
+        import SALOME
+        import SALOMEDS
+        import SALOME_ModuleCatalog
+        reload(Engines)
+        reload(SALOME)
+        reload(SALOMEDS)
+        import SALOME_Session_idl
+        session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
+
+    end_time = os.times()
+    print
+    print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
+                                                         - init_time[4])
+
+    # ASV start GUI without Loader
+    #if args['gui']:
+    #    session.GetInterface()
+
+    #
+    # additionnal external python interpreters
+    #
+    nbaddi=0
+    
+    try:
+        if 'interp' in args:
+            if args['interp']:
+                nbaddi = int(args['interp'][0])
+    except:
+        import traceback
+        traceback.print_exc()
+        print "-------------------------------------------------------------"
+        print "-- to get an external python interpreter:runSalome --interp=1"
+        print "-------------------------------------------------------------"
+        
+    print "additional external python interpreters: ", nbaddi
+    if nbaddi:
+        for i in range(nbaddi):
+            print "i=",i
+            anInterp=InterpServer(args)
+            anInterp.run()
+    
+    return clt
 
-#
 # -----------------------------------------------------------------------------
-#
 
-process_id = {}
-if __name__ == "__main__":
+def useSalome(args, modules_list, modules_root_dir):
+    """
+    Launch all SALOME servers requested by args,
+    save list of process, give info to user,
+    show registered objects in Naming Service.
+    """
+    
     clt=None
     try:
-        clt = startSalome()
+        clt = startSalome(args, modules_list, modules_root_dir)
     except:
+        import traceback
+        traceback.print_exc()
         print
         print
         print "--- erreur au lancement Salome ---"
         
     #print process_id
-    
-    filedict='/tmp/'+os.getenv('USER')+"_"+str(args['port'])+'_'+args['appname'].upper()+'_pidict'
-    #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
-    
-    
+
+    from killSalomeWithPort import getPiDict
+    filedict = getPiDict(args['port'])
+
     process_ids = []
     try:
         fpid=open(filedict, 'r')
@@ -415,10 +795,13 @@ if __name__ == "__main__":
     To kill SALOME processes from a console (kill all sessions from all ports):
       python killSalome.py 
     To kill SALOME from the present interpreter, if it is not closed :
-      killLocalPort()  --> kill this session
-      killAllPorts()   --> kill all sessions
+      killLocalPort()      --> kill this session
+                               (use CORBA port from args of runSalome)
+      givenPortKill(port)  --> kill a specific session with given CORBA port 
+      killAllPorts()       --> kill all sessions
     
-    runSalome, with --killall option, starts with killing the processes resulting from the previous execution.
+    runSalome, with --killall option, starts with killing
+    the processes resulting from the previous execution.
     """%filedict
     
     #
@@ -429,3 +812,47 @@ if __name__ == "__main__":
         print
         print " --- registered objects tree in Naming Service ---"
         clt.showNS()
+
+    return clt
+
+# -----------------------------------------------------------------------------
+
+def registerEnv(args, modules_list, modules_root_dir):
+    """
+    Register args, modules_list, modules_root_dir in a file
+    for further use, when SALOME is launched embedded in an other application.
+    """
+    fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
+            + '_' + args['appname'].upper() + '_env'
+    fenv=open(fileEnv,'w')
+    pickle.dump((args, modules_list, modules_root_dir),fenv)
+    fenv.close()
+    os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
+
+# -----------------------------------------------------------------------------
+
+def no_main():
+    """Salome Launch, when embedded in other application"""
+    fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
+    fenv=open(fileEnv,'r')
+    args, modules_list, modules_root_dir = pickle.load(fenv)
+    fenv.close()
+    kill_salome(args)
+    clt = useSalome(args, modules_list, modules_root_dir)
+    return clt
+
+# -----------------------------------------------------------------------------
+
+def main():
+    """Salome launch as a main application"""
+    args, modules_list, modules_root_dir = get_config()
+    kill_salome(args)
+    set_env(args, modules_list, modules_root_dir)
+    clt = useSalome(args, modules_list, modules_root_dir)
+    return clt,args
+
+# -----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+   import user
+   clt,args = main()