Salome HOME
[tuleap29134] : fix for runSalomeOld.py the defaut SSL mode in -t context
[modules/kernel.git] / bin / runSalome.py
index 6439d4e5486cc1d3bf5154ee1e8588aca63e6813..f89d1be6642f8a9cff9cbec08144945a61ec0cae 100755 (executable)
@@ -1,9 +1,6 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #  -*- coding: iso-8859-1 -*-
 #  -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+# Copyright (C) 2022 CEA/DEN, EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
 import sys, os, string, glob, time, pickle, re
 import orbmodule
 import setenv
 import sys, os, string, glob, time, pickle, re
 import orbmodule
 import setenv
-from launchConfigureParser import verbose
 from server import process_id, Server
 import json
 import subprocess
 from salomeContextUtils import ScriptAndArgsObjectEncoder
 from server import process_id, Server
 import json
 import subprocess
 from salomeContextUtils import ScriptAndArgsObjectEncoder
+import runSalomeNoServer
+import runSalomeCommon
+import platform
+import logging
+logger = logging.getLogger()
 
 # -----------------------------------------------------------------------------
 
 from killSalome import killAllPorts
 
 
 # -----------------------------------------------------------------------------
 
 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:
-        killMyPort(my_port)
-    except:
-        print "problem in killLocalPort()"
-        pass
-    pass
-
-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(%s)"%port
-        pass
-    pass
-
 def kill_salome(args):
     """
     Kill servers from previous SALOME executions, if needed;
 def kill_salome(args):
     """
     Kill servers from previous SALOME executions, if needed;
@@ -78,320 +49,6 @@ def kill_salome(args):
 
     if args['killall']:
         killAllPorts()
 
     if args['killall']:
         killAllPorts()
-    elif args['portkill']:
-        givenPortKill(str(args['port']))
-
-# -----------------------------------------------------------------------------
-#
-# Class definitions to launch CORBA Servers
-#
-
-class InterpServer(Server):
-    def __init__(self,args):
-        self.args=args
-        if sys.platform != "win32":
-          env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
-          self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
-        else:
-          self.CMD=['cmd', '/c', 'start cmd.exe', '/K', 'python']
-
-    def run(self):
-        global process_id
-        command = self.CMD
-        print "INTERPSERVER::command = ", command
-        if sys.platform == "win32":
-          import win32pm
-          pid = win32pm.spawnpid( string.join(command, " "),'-nc' )
-        else:
-          pid = os.spawnvp(os.P_NOWAIT, command[0], command)
-        process_id[pid]=self.CMD
-        self.PID = pid
-
-# ---
-
-def get_cata_path(list_modules,modules_root_dir):
-    """Build a list of catalog paths (cata_path) to initialize the ModuleCatalog server
-    """
-    modules_cata={}
-    cata_path=[]
-
-    for module in list_modules:
-        if modules_root_dir.has_key(module):
-            module_root_dir=modules_root_dir[module]
-            module_cata=module+"Catalog.xml"
-            cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources",module.lower(), module_cata)
-
-            if os.path.exists(cata_file):
-                cata_path.append(cata_file)
-                modules_cata[module]=cata_file
-            else:
-                cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources", module_cata)
-                if os.path.exists(cata_file):
-                    cata_path.append(cata_file)
-                    modules_cata[module]=cata_file
-
-    for path in os.getenv("SALOME_CATALOGS_PATH","").split(os.pathsep):
-        if os.path.exists(path):
-            for cata_file in glob.glob(os.path.join(path,"*Catalog.xml")):
-                module_name= os.path.basename(cata_file)[:-11]
-                if not modules_cata.has_key(module_name):
-                    cata_path.append(cata_file)
-                    modules_cata[module_name]=cata_file
-
-    return cata_path
-
-_siman_name = None
-def simanStudyName(args):
-    global _siman_name
-    if _siman_name is None:
-        # siman session paramenters and checkout processing
-        _siman_name = ""
-        if 'siman' in args:
-            siman_data = []
-            for param in [ 'study', 'scenario', 'user']:
-                siman_param = "siman_%s"%param
-                if siman_param in args:
-                    siman_data.append(args[siman_param])
-                else:
-                    print "SIMAN %s must be defined using parameter --siman-%s=XXX" % (siman_param, siman_param)
-                    pass
-                pass
-            if len(siman_data) == 3:
-                _siman_name = "_".join(siman_data)
-                pass
-            pass
-        pass
-    return _siman_name
-
-class CatalogServer(Server):
-    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):
-        list_modules = modules_list[:]
-        list_modules.reverse()
-        if self.args["gui"] :
-            list_modules = ["KERNEL", "GUI"] + list_modules
-        else :
-            list_modules = ["KERNEL"] + list_modules
-
-        cata_path=get_cata_path(list_modules,modules_root_dir)
-
-        self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
-
-# ---
-
-class SalomeDSServer(Server):
-    def __init__(self,args):
-        self.args=args
-        self.initArgs()
-        self.CMD=['SALOMEDS_Server']
-
-# ---
-
-class ConnectionManagerServer(Server):
-    def __init__(self,args):
-        self.args=args
-        self.initArgs()
-        self.CMD=['SALOME_ConnectionManagerServer']
-
-# ---
-
-class RegistryServer(Server):
-    def __init__(self,args):
-        self.args=args
-        self.initArgs()
-        self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
-
-# ---
-
-class ContainerCPPServer(Server):
-    def __init__(self,args):
-        self.args=args
-        self.initArgs()
-        self.CMD=['SALOME_Container','FactoryServer']
-
-# ---
-
-class LoggerServer(Server):
-    def __init__(self,args):
-        self.args=args
-        self.initArgs()
-        from salome_utils import generateFileName, getLogDir
-        logfile = generateFileName( getLogDir(),
-                                    prefix="logger",
-                                    extension="log",
-                                    with_username=True,
-                                    with_hostname=True,
-                                    with_port=True)
-        print "==========================================================="
-        print "Logger server: put log to the file:"
-        print logfile
-        print "==========================================================="
-        self.CMD=['SALOME_Logger_Server', logfile]
-        pass
-    pass # end of LoggerServer class
-
-# ---
-
-class SessionServer(Server):
-    def __init__(self,args,modules_list,modules_root_dir):
-        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']:
-            raise Exception('Python containers no longer supported')
-        if self.args['gui']:
-            session_gui = True
-            if self.args.has_key('session_gui'):
-                session_gui = self.args['session_gui']
-            if session_gui:
-                self.SCMD2+=['GUI']
-                if self.args['splash']:
-                    self.SCMD2+=['SPLASH']
-                    pass
-                if self.args['study_hdf'] is not None:
-                    self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
-                    pass
-                if simanStudyName(self.args):
-                    self.SCMD2+=['--siman-study=%s'%simanStudyName(self.args)]
-                    pass
-                pass
-                if self.args.has_key('pyscript') and len(self.args['pyscript']) > 0:
-                    msg = json.dumps(self.args['pyscript'], cls=ScriptAndArgsObjectEncoder)
-                    self.SCMD2+=['--pyscript=%s'%(msg)]
-                    pass
-                pass
-            pass
-        if self.args['noexcepthandler']:
-            self.SCMD2+=['noexcepthandler']
-        if self.args.has_key('user_config'):
-            self.SCMD2+=['--resources=%s'%self.args['user_config']]
-        if self.args.has_key('modules'):
-            list_modules = []
-            #keep only modules with GUI
-            for m in modules_list:
-              if m not in modules_root_dir:
-                list_modules.insert(0,m)
-              else:
-                fr1 = os.path.join(modules_root_dir[m],"share","salome","resources",m.lower(),"SalomeApp.xml")
-                fr2 = os.path.join(modules_root_dir[m],"share","salome","resources","SalomeApp.xml")
-                if os.path.exists(fr1) or os.path.exists(fr2):
-                  list_modules.insert(0,m)
-            list_modules.reverse()
-            self.SCMD2+=['--modules (%s)' % ":".join(list_modules)]
-            pass
-        pass
-
-    def setpath(self,modules_list,modules_root_dir):
-        list_modules = modules_list[:]
-        list_modules.reverse()
-        if self.args["gui"] :
-            list_modules = ["KERNEL", "GUI"] + list_modules
-        else :
-            list_modules = ["KERNEL"] + list_modules
-
-        cata_path=get_cata_path(list_modules,modules_root_dir)
-
-        if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
-            #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
-            self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
-        else:
-            self.CMD=self.SCMD1 + self.SCMD2
-        if self.args.has_key('test'):
-            self.CMD+=['-test'] + self.args['test']
-        elif self.args.has_key('play'):
-            self.CMD+=['-play'] + self.args['play']
-
-        if self.args["gdb_session"] or self.args["ddd_session"]:
-            f = open(".gdbinit4salome", "w")
-            f.write("set args ")
-            args = " ".join(self.CMD[1:])
-            args = args.replace("(", "\(")
-            args = args.replace(")", "\)")
-            f.write(args)
-            f.write("\n")
-            f.close()
-            if self.args["ddd_session"]:
-                self.CMD = ["ddd", "--command=.gdbinit4salome", self.CMD[0]]
-            elif self.args["gdb_session"]:
-                self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
-                pass
-            pass
-
-        if self.args["valgrind_session"]:
-            l = ["valgrind"]
-            val = os.getenv("VALGRIND_OPTIONS")
-            if val:
-                l += val.split()
-                pass
-            self.CMD = l + self.CMD
-            pass
-
-# ---
-
-class LauncherServer(Server):
-    def __init__(self,args):
-        self.args=args
-        self.initArgs()
-        self.SCMD1=['SALOME_LauncherServer']
-        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):
-        list_modules = modules_list[:]
-        list_modules.reverse()
-        if self.args["gui"] :
-            list_modules = ["KERNEL", "GUI"] + list_modules
-        else :
-            list_modules = ["KERNEL"] + list_modules
-
-        cata_path=get_cata_path(list_modules,modules_root_dir)
-
-        if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
-            #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
-            self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
-        else:
-            self.CMD=self.SCMD1 + self.SCMD2
 #
 # -----------------------------------------------------------------------------
 
 #
 # -----------------------------------------------------------------------------
 
@@ -411,225 +68,46 @@ def startSalome(args, modules_list, modules_root_dir):
     """Launch all SALOME servers requested by args"""
     init_time = os.times()
 
     """Launch all SALOME servers requested by args"""
     init_time = os.times()
 
-    if verbose(): print "startSalome ", args
-
-    #
-    # Set server launch command
-    #
-    if args.has_key('server_launch_mode'):
-        Server.set_server_launch_mode(args['server_launch_mode'])
-
-    #
-    # Wake up session option
-    #
-    if args['wake_up_session']:
-        if "OMNIORB_CONFIG" not in os.environ:
-            from salome_utils import generateFileName
-            omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
-            kwargs={}
-            if omniorbUserPath is not None:
-                kwargs["with_username"]=True
-
-            last_running_config = generateFileName(omniorbUserPath, prefix="omniORB",
-                                                   suffix="last",
-                                                   extension="cfg",
-                                                   hidden=True,
-                                                   **kwargs)
-            os.environ['OMNIORB_CONFIG'] = last_running_config
-            pass
-        pass
-
-    #
-    # Initialisation ORB and Naming Service
-    #
-
-    clt=orbmodule.client(args)
-
-    #
-    # Wake up session option
-    #
-    if args['wake_up_session']:
-        import Engines
-        import SALOME
-        import SALOMEDS
-        import SALOME_ModuleCatalog
-        import SALOME_Session_idl
-        session = clt.waitNS("/Kernel/Session",SALOME.Session)
-        status = session.GetStatSession()
-        if status.activeGUI:
-            from salome_utils import getPortNumber
-            port = getPortNumber()
-            msg  = "Warning :"
-            msg += "\n"
-            msg += "Session GUI for port number %s is already active."%(port)
-            msg += "\n"
-            msg += "If you which to wake up another session,"
-            msg += "\n"
-            msg += "please use variable OMNIORB_CONFIG"
-            msg += "\n"
-            msg += "to get the correct session object in naming service."
-            sys.stdout.write(msg+"\n")
-            sys.stdout.flush()
-            return clt
-        session.GetInterface()
-        args["session_object"] = session
-        return clt
-
-    # Launch Logger Server (optional)
-    # and wait until it is registered in naming service
-    #
-
-    if args['logger']:
-        myServer=LoggerServer(args)
-        myServer.run()
-        clt.waitLogger("Logger")
+    logger.debug("startSalome : {} ".format(args))
 
 
-    # set siman python path before the session server launching to import scripts inside python console
-    if simanStudyName(args):
-        # MPV: use os.environ here because session server is launched in separated process and sys.path is missed in this case
-        from salome_utils import getTmpDir
-        ppath = os.path.join(getTmpDir, "SimanSalome", args['siman_study'],
-                             args['siman_scenario'], args['siman_user'])
-        os.environ["PYTHONPATH"] = ppath + os.pathsep + os.environ["PYTHONPATH"]
+    ior_fakens_filename = None
 
     # Launch  Session Server (to show splash ASAP)
     #
 
 
     # Launch  Session Server (to show splash ASAP)
     #
 
-    if args["gui"]:
-        mySessionServ = SessionServer(args,args['modules'],modules_root_dir)
+    if args["gui"] and not args['launcher_only']:
+        mySessionServ = runSalomeNoServer.NoSessionServer(args,args['modules'],modules_root_dir)
         mySessionServ.setpath(modules_list,modules_root_dir)
         mySessionServ.run()
         mySessionServ.setpath(modules_list,modules_root_dir)
         mySessionServ.run()
-
-    #
-    # Launch Registry Server,
-    # and wait until it is registered in naming service
-    #
-
-    if ('registry' not in args['embedded']) | (args["gui"] == 0) :
-        myServer=RegistryServer(args)
-        myServer.run()
-        if sys.platform == "win32":
-          clt.waitNS("/Registry")
-        else:
-          clt.waitNSPID("/Registry",myServer.PID)
-
-    #
-    # Launch Catalog Server,
-    # and wait until it is registered in 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
-        if sys.platform == "win32":
-          clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
-        else:
-          clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
-
-    #
-    # Launch SalomeDS Server,
-    # and wait until it is registered in naming service
-    #
-
-    #print "ARGS = ",args
-    if ('study' not in args['embedded']) | (args["gui"] == 0):
-        print "RunStudy"
-        myServer=SalomeDSServer(args)
-        myServer.run()
-        if sys.platform == "win32":
-          clt.waitNS("/myStudyManager")
-        else:
-          clt.waitNSPID("/myStudyManager",myServer.PID)
-
-    #
-    # Launch LauncherServer
-    #
-
-    myCmServer = LauncherServer(args)
-    myCmServer.setpath(modules_list,modules_root_dir)
-    myCmServer.run()
-
-    #
-    # Launch ConnectionManagerServer
-    #
-
-    myConnectionServer = ConnectionManagerServer(args)
-    myConnectionServer.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()
-
-    #
-    # Launch local C++ Container (FactoryServer),
-    # and wait until it is registered in naming service
-    #
-
-    if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
-        myServer=ContainerCPPServer(args)
-        myServer.run()
-        if sys.platform == "win32":
-          clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
-        else:
-          clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
-
-    if 'pyContainer' in args['standalone']:
-        raise Exception('Python containers no longer supported')
+        ior_fakens_filename = mySessionServ.iorfakens
+        logger.debug("Rendez-vous file for to retrieve IOR of session is \"{}\"".format(ior_fakens_filename))
+    
+    end_time = os.times()
 
     #
     # Wait until Session Server is registered in naming service
     #
 
     #
     # Wait until Session Server is registered in naming service
     #
-
-    if args["gui"]:
-##----------------
-        import Engines
-        import SALOME
-        import SALOMEDS
-        import SALOME_ModuleCatalog
-        import SALOME_Session_idl
-        if sys.platform == "win32":
-          session=clt.waitNS("/Kernel/Session",SALOME.Session)
-        else:
-          session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
-        args["session_object"] = session
-    end_time = os.times()
-    if verbose(): 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()
+    logger.debug("Start SALOME, elapsed time : %5.1f seconds"% (end_time[4] - init_time[4]))
 
     #
 
     #
-    # additionnal external python interpreters
+    # additional external python interpreters
     #
     nbaddi=0
 
     try:
         if 'interp' in args:
             nbaddi = args['interp']
     #
     nbaddi=0
 
     try:
         if 'interp' in args:
             nbaddi = args['interp']
-    except:
+    except Exception:
         import traceback
         traceback.print_exc()
         import traceback
         traceback.print_exc()
-        print "-------------------------------------------------------------"
-        print "-- to get an external python interpreter:runSalome --interp=1"
-        print "-------------------------------------------------------------"
+        logger.error("-------------------------------------------------------------")
+        logger.error("-- to get an external python interpreter:runSalome --interp=1")
+        logger.error("-------------------------------------------------------------")
 
 
-    if verbose(): print "additional external python interpreters: ", nbaddi
+    logger.debug("additional external python interpreters: {}".format(nbaddi))
     if nbaddi:
         for i in range(nbaddi):
     if nbaddi:
         for i in range(nbaddi):
-            print "i=",i
-            anInterp=InterpServer(args)
+            anInterp=runSalomeCommon.InterpServer(args)
             anInterp.run()
 
     # set PYTHONINSPECT variable (python interpreter in interactive mode)
             anInterp.run()
 
     # set PYTHONINSPECT variable (python interpreter in interactive mode)
@@ -640,28 +118,7 @@ def startSalome(args, modules_list, modules_root_dir):
         except ImportError:
             pass
 
         except ImportError:
             pass
 
-    # siman session paramenters and checkout processing
-    if simanStudyName(args):
-        print '**********************************************'
-        print "Siman study name= '" + simanStudyName(args) + "'"
-        import SALOMEDS
-        obj = clt.Resolve('myStudyManager')
-        myStudyManager = obj._narrow(SALOMEDS.StudyManager)
-        aNewStudy = myStudyManager.NewStudy(simanStudyName(args))
-        aSimS = myStudyManager.GetSimanStudy()
-        aSimS._set_StudyId(args['siman_study'])
-        aSimS._set_ScenarioId(args['siman_scenario'])
-        aSimS._set_UserId(args['siman_user'])
-        aSimS.CheckOut(aNewStudy)
-        # if session server is enabled, activate the created study
-        if args["gui"]:
-            print "Activate the SIMAN study in the SALOME GUI"
-            obj = clt.Resolve('/Kernel/Session')
-            mySession = obj._narrow(SALOME.Session)
-            mySession.emitMessage("simanCheckoutDone " + simanStudyName(args))
-        print '**********************************************'
-
-    return clt
+    return ior_fakens_filename
 
 # -----------------------------------------------------------------------------
 
 
 # -----------------------------------------------------------------------------
 
@@ -672,28 +129,25 @@ def useSalome(args, modules_list, modules_root_dir):
     show registered objects in Naming Service.
     """
     global process_id
     show registered objects in Naming Service.
     """
     global process_id
-
-    clt=None
+    ior_fakens_filename = None
     try:
     try:
-        clt = startSalome(args, modules_list, modules_root_dir)
-    except:
+        ior_fakens_filename = startSalome(args, modules_list, modules_root_dir)
+    except Exception:
         import traceback
         traceback.print_exc()
         import traceback
         traceback.print_exc()
-        print
-        print
-        print "--- Error during Salome launch ---"
+        logger.error("--- Error during Salome launch ---")
 
 
-    #print process_id
+    # print(process_id)
 
     from addToKillList import addToKillList
     from killSalomeWithPort import getPiDict
 
     filedict = getPiDict(args['port'])
 
     from addToKillList import addToKillList
     from killSalomeWithPort import getPiDict
 
     filedict = getPiDict(args['port'])
-    for pid, cmd in process_id.items():
+    for pid, cmd in list(process_id.items()):
         addToKillList(pid, cmd, args['port'])
         pass
 
         addToKillList(pid, cmd, args['port'])
         pass
 
-    if verbose(): print """
+    logger.debug("""
     Saving of the dictionary of Salome processes in %s
     To kill SALOME processes from a console (kill all sessions from all ports):
       python killSalome.py
     Saving of the dictionary of Salome processes in %s
     To kill SALOME processes from a console (kill all sessions from all ports):
       python killSalome.py
@@ -705,156 +159,107 @@ def useSalome(args, modules_list, modules_root_dir):
 
     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
-
-    #
-    #  Print Naming Service directory list
-    #
+    """%filedict)
 
 
-    if clt != None:
-        if verbose():
-            print
-            print " --- registered objects tree in Naming Service ---"
-            clt.showNS()
-            pass
-
-        if not args['gui'] or not args['session_gui']:
-            if args['shutdown_servers']:
-                class __utils__(object):
-                    def __init__(self, port):
-                        self.port = port
-                        import killSalomeWithPort
-                        self.killSalomeWithPort = killSalomeWithPort
-                        return
-                    def __del__(self):
-                        self.killSalomeWithPort.killMyPort(self.port)
-                        return
-                    pass
-                def func(s):
-                    del s
-                import atexit
-                atexit.register(func, __utils__(args['port']))
-                pass
-            pass
-
-        # run python scripts, passed as command line arguments
-        toimport = []
-        if args.has_key('gui') and args.has_key('session_gui'):
-            if not args['gui'] or not args['session_gui']:
-                if args.has_key('study_hdf'):
-                    toopen = args['study_hdf']
-                    if toopen:
-                        import salome
-                        salome.salome_init(toopen)
-                if args.has_key('pyscript'):
-                    toimport = args['pyscript']
-        from salomeContextUtils import formatScriptsAndArgs
-        command = formatScriptsAndArgs(toimport)
-        if command:
-            proc = subprocess.Popen(command, shell=True)
-            addToKillList(proc.pid, command, args['port'])
-            res = proc.wait()
-            if res: sys.exit(1) # if there's an error when executing script, we should explicitly exit
-
-    return clt
+    return ior_fakens_filename
 
 def execScript(script_path):
 
 def execScript(script_path):
-    print 'executing', script_path
+    print('executing', script_path)
     sys.path.insert(0, os.path.realpath(os.path.dirname(script_path)))
     sys.path.insert(0, os.path.realpath(os.path.dirname(script_path)))
-    execfile(script_path,globals())
+    exec(compile(open(script_path).read(), script_path, 'exec'),globals())
     del sys.path[0]
 
 # -----------------------------------------------------------------------------
 
     del sys.path[0]
 
 # -----------------------------------------------------------------------------
 
-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.
-    """
-    from salome_utils import getTmpDir
-    fileEnv = getTmpDir()
-    from salome_utils import getUserName
-    fileEnv += getUserName() + "_" + 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)
-    from searchFreePort import searchFreePort
-    searchFreePort(args, 0)
-    clt = useSalome(args, modules_list, modules_root_dir)
-    return clt
-
-# -----------------------------------------------------------------------------
-
-def main():
+def main(exeName=None):
     """Salome launch as a main application"""
     """Salome launch as a main application"""
-
-    # define folder to store omniorb config (initially in virtual application folder)
-    try:
-        from salomeContextUtils import setOmniOrbUserPath
-        setOmniOrbUserPath()
-    except Exception, e:
-        print e
-        sys.exit(1)
-
-    from salome_utils import getHostName
-    args, modules_list, modules_root_dir = setenv.get_config()
-    print "runSalome running on %s" % getHostName()
-
+    keep_env = not os.getenv('SALOME_PLEASE_SETUP_ENVIRONMENT_AS_BEFORE')
+    args, modules_list, modules_root_dir = setenv.get_config(exeName=exeName, keepEnvironment=keep_env)
+    runSalomeCommon.setVerbose(args["verbosity"])
     kill_salome(args)
     kill_salome(args)
-    save_config = True
-    if args.has_key('save_config'):
-        save_config = args['save_config']
     # --
     # --
-    test = True
-    if args['wake_up_session']:
-        test = False
-        pass
-    if test:
-        from searchFreePort import searchFreePort
-        searchFreePort(args, save_config, args.get('useport'))
-        pass
-    # --
-    #setenv.main()
-    setenv.set_env(args, modules_list, modules_root_dir)
-    clt = useSalome(args, modules_list, modules_root_dir)
-    return clt,args
+    setenv.set_env(args, modules_list, modules_root_dir, keepEnvironment=keep_env)
+    ior_fakens_filename = useSalome(args, modules_list, modules_root_dir)
+    # Management of -t <script.py>
+    toimport = []
+    env = os.environ
+    if 'gui' in args and 'session_gui' in args:
+        if not args['gui'] or not args['session_gui']:
+            if 'study_hdf' in args:
+                toopen = args['study_hdf']
+                if toopen:
+                    os.environ["PATH_TO_STUDY_FILE_TO_INITIATE"] = toopen
+                    logger.debug("An input Study has been specified {} -> pass it with PATH_TO_STUDY_FILE_TO_INITIATE env var".format(toopen))
+            if 'pyscript' in args:
+                toimport = args['pyscript']
+    from salomeContextUtils import formatScriptsAndArgs
+    from addToKillList import addToKillList
+    command = formatScriptsAndArgs(toimport, escapeSpaces=True)
+    if command:
+        logger.debug("Launching following shell command : {}".format(str(command)))
+        proc = subprocess.Popen(command, shell=True, env = env)
+        addToKillList(proc.pid, command)
+        res = proc.wait()
+        if res: sys.exit(1) 
+    return args, ior_fakens_filename
 
 # -----------------------------------------------------------------------------
 
 
 # -----------------------------------------------------------------------------
 
-def foreGround(clt, args):
+def foreGround(args, ior_fakens_filename):
     # --
     # --
-    if "session_object" not in args:
+    import os
+    gui_detected = False
+    dt = 0.1
+    nbtot = 100
+    nb = 0
+    if ior_fakens_filename is None:
+        logger.warn("No file set to host IOR of the fake naming server")
+        return
+    if not os.path.exists(ior_fakens_filename):
+        logger.warn("No file {} set to host IOR of the fake naming server does not exit !")
         return
         return
-    session = args["session_object"]
+    import CORBA
+    import Engines
+    import SALOME
+    from time import sleep
+    orb = CORBA.ORB_init([''], CORBA.ORB_ID)
+    ior_fakens = None
+    session = None
+    while True:
+        try:
+            ior_fakens = orb.string_to_object(open(ior_fakens_filename).read())
+            session = orb.string_to_object(ior_fakens.Resolve("/Kernel/Session").decode())
+        except Exception:
+            pass
+        if ( session is not None ) and (not CORBA.is_nil(session)):
+            try:
+                os.remove(ior_fakens_filename)
+                logger.debug("File {} has been removed".format(ior_fakens_filename))
+            except:
+                pass
+            logger.debug("Session in child process has been found ! yeah ! {}".format(str(session)))
+            break
+        sleep(dt)
+        nb += 1
+        logger.debug("Unfortunately Session not found into {} : Sleep and retry. {}/{}".format(ior_fakens_filename,nb,nbtot))
+        if nb == nbtot:
+            break
+    nb = 0
     # --
     # Wait until gui is arrived
     # tmax = nbtot * dt
     # --
     # --
     # Wait until gui is arrived
     # tmax = nbtot * dt
     # --
-    gui_detected = False
-    dt = 0.1
-    nbtot = 100
-    nb = 0
+    session_pid = None
     while 1:
         try:
             status = session.GetStatSession()
             gui_detected = status.activeGUI
     while 1:
         try:
             status = session.GetStatSession()
             gui_detected = status.activeGUI
-        except:
+            session_pid = session.getPID()
+            logger.debug("Process of the session under monitoring {}".format(session_pid))
+        except Exception:
             pass
         if gui_detected:
             break
             pass
         if gui_detected:
             break
-        from time import sleep
         sleep(dt)
         nb += 1
         if nb == nbtot:
         sleep(dt)
         nb += 1
         if nb == nbtot:
@@ -867,41 +272,34 @@ def foreGround(clt, args):
     from salome_utils import getPortNumber
     port = getPortNumber()
     # --
     from salome_utils import getPortNumber
     port = getPortNumber()
     # --
-    server = Server({})
-    if sys.platform == "win32":
-      server.CMD = [os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", "--spy", "%s"%(os.getpid()), "%s"%(port)]
-    else:
-      server.CMD = ["killSalomeWithPort.py", "--spy", "%s"%(os.getpid()), "%s"%(port)]
-    server.run()
-    # os.system("killSalomeWithPort.py --spy %s %s &"%(os.getpid(), port))
-    # --
     dt = 1.0
     try:
         while 1:
             try:
                 status = session.GetStatSession()
                 assert status.activeGUI
     dt = 1.0
     try:
         while 1:
             try:
                 status = session.GetStatSession()
                 assert status.activeGUI
-            except:
+            except Exception:
+                logger.debug("Process of the session under monitoring {} has vanished !".format(session_pid))
                 break
             from time import sleep
             sleep(dt)
             pass
         pass
     except KeyboardInterrupt:
                 break
             from time import sleep
             sleep(dt)
             pass
         pass
     except KeyboardInterrupt:
-        from killSalomeWithPort import killMyPort
-        killMyPort(port)
-        pass
+        logger.debug("Keyboard requested : killing all process attached to port {}".format(port))
+    finally:
+        from killSalomeWithPort import killProcessSSL
+        killProcessSSL(port,[session_pid])
     return
 #
 
 def runSalome():
     return
 #
 
 def runSalome():
-    import user
-    clt,args = main()
+    args, ior_fakens_filename = main()
     # --
     test = args['gui'] and args['session_gui']
     test = test or args['wake_up_session']
     # --
     # --
     test = args['gui'] and args['session_gui']
     test = test or args['wake_up_session']
     # --
-    # The next test covers the --pinter option or var PYTHONINSPECT setted
+    # The next test covers the --pinter option or if var PYTHONINSPECT is set
     # --
     test = test and not os.environ.get('PYTHONINSPECT')
     # --
     # --
     test = test and not os.environ.get('PYTHONINSPECT')
     # --
@@ -911,14 +309,16 @@ def runSalome():
         from ctypes import POINTER, c_int, cast, pythonapi
         iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
         test = test and not iflag_ptr.contents.value
         from ctypes import POINTER, c_int, cast, pythonapi
         iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
         test = test and not iflag_ptr.contents.value
-    except:
+    except Exception:
         pass
     # --
         pass
     # --
-    test = test and os.getenv("SALOME_TEST_MODE", "0") != "1"
+#    test = test and os.getenv("SALOME_TEST_MODE", "0") != "1"
     test = test and args['foreground']
     # --
     if test:
     test = test and args['foreground']
     # --
     if test:
-        foreGround(clt, args)
+        from time import sleep
+        sleep(3.0)
+        foreGround(args, ior_fakens_filename)
         pass
     pass
 #
         pass
     pass
 #