From: Konstantin Leontev Date: Tue, 29 Nov 2022 12:18:11 +0000 (+0300) Subject: [bos #32522][EDF] SALOME on Demand. Clear copy-past __init__.py file. X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=c6a23455acdec686a50d1f845367792d9e4581a1;p=modules%2Fkernel.git [bos #32522][EDF] SALOME on Demand. Clear copy-past __init__.py file. --- diff --git a/bin/SalomeOnDemandTK/__init__.py b/bin/SalomeOnDemandTK/__init__.py index f675cf5ea..5a5954897 100644 --- a/bin/SalomeOnDemandTK/__init__.py +++ b/bin/SalomeOnDemandTK/__init__.py @@ -18,421 +18,13 @@ # 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 +# See https://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -# File : salome.py renamed as __init__.py for python packaging (gboulant) -# Author : Paul RASCLE, EDF -# Module : SALOME +# File : __init__.py +# Author : Konstantin Leontev, Open Cascade # """ -Module salome gives access to Salome resources. -variables: - - - salome.orb : CORBA - - salome.naming_service : instance of naming Service class - - methods: - - Resolve(name) : find a CORBA object (ior) by its pathname - - Register(name) : register a CORBA object under a pathname - - - salome.lcc : instance of lifeCycleCORBA class - - methods: - - FindOrLoadComponent(server,name) : - obtain an Engine (CORBA object) - or launch the Engine if not found, - with a Server name and an Engine name - - - salome.sg : salome object to communicate with the graphical user interface (if any) - - methods: - - updateObjBrowser(): - - - SelectedCount(): returns number of selected objects - - getSelected(i): returns entry of selected object number i - - getAllSelected(): returns list of entry of selected objects - - AddIObject(Entry): select an existing Interactive object - - RemoveIObject(Entry): remove object from selection - - ClearIObjects(): clear selection - - - Display(*Entry): - - DisplayOnly(Entry): - - Erase(Entry): - - DisplayAll(): - - EraseAll(): - - - IDToObject(Entry): returns CORBA reference from entry - - - salome.myStudyName : active Study Name - - salome.myStudy : the active Study itself (CORBA ior) - - methods : defined in SALOMEDS.idl """ -## @package salome -# Module salome gives access to Salome resources. -# -# \param salome.orb : CORBA orb object -# \param salome.naming_service : instance of naming Service class (SALOME_NamingServicePy::SALOME_NamingServicePy_i) -# \param salome.lcc : instance of lifeCycleCORBA class (SALOME_LifeCycleCORBA) -# \param salome.sg : Salome object to communicate with the graphical user interface, if running (see interface in salome_iapp::SalomeOutsideGUI) -# \param salome.myStudyName : active Study Name -# \param salome.myStudy : the active Study (interface SALOMEDS::Study) - -# -# ========================================================================== -# -# The function extend_path is used here to aggregate in a single -# virtual python package all the python sub-packages embedded in each -# SALOME modules (python "namespace" pattern). -# -ROOT_PYTHONPACKAGE_NAME="salome" -# -# This root package name is expected to be found as a directory in -# some paths of the sys.path variable, especially the paths -# /lib/pythonX.Y/site-packages/salome where are -# installed the python files. These paths are theorically appended by -# the SALOME main runner and should be in the sys.path at this point -# of the application. The extend_path is looking then for directories -# of the type: -# -# /lib/pythonX.Y/site-packages/salome/ -# -# And append them to the sys.path. These directories are supposed to -# be the pieces to be aggregated as a single virtual python package. -# -import os, sys -from salome_utils import verbose - -MATCH_ENDING_PATTERN="site-packages" + os.path.sep + "salome" - -def extend_path(pname): - for dir in sys.path: - if not isinstance(dir, str) or not os.path.isdir(dir) or not dir.endswith(MATCH_ENDING_PATTERN): - continue - subdir = os.path.join(dir, pname) - # XXX This may still add duplicate entries to path on - # case-insensitive filesystems - if os.path.isdir(subdir) and subdir not in __path__: - if verbose(): print("INFO - The directory %s is appended to sys.path" % subdir) - __path__.append(subdir) - -extend_path(ROOT_PYTHONPACKAGE_NAME) -# ========================================================================== -# - -from salome_kernel import * -from salome_study import * -from salome_iapp import * -import salome_study - -# -# The next block is workaround for the problem of shared symbols loading for the extension modules (e.g. SWIG-generated) -# that causes RTTI unavailable in some cases. To solve this problem, sys.setdlopenflags() function is used. -# Depending on the Python version and platform, the dlopen flags can be defined in the dl, DLFUN or ctypes module. -# -import sys -flags = None -if not flags: - try: - # dl module can be unavailable - import dl - flags = dl.RTLD_NOW | dl.RTLD_GLOBAL - except Exception: - pass - pass -if not flags: - try: - # DLFCN module can be unavailable - import DLFCN - flags = DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL - except Exception: - pass - pass -if not flags: - try: - # ctypes module can be unavailable - import ctypes - flags = ctypes.RTLD_GLOBAL - except Exception: - pass - pass - -# Disable -> bug with scipy, seems very dangerous to do that -#if flags: -# sys.setdlopenflags(flags) -# pass - -orb, lcc, naming_service, cm, sg, esm, dsm, modulcat = None,None,None,None,None,None,None,None -myStudy, myStudyName = None,None - -salome_initial=True - -def standalone(): - pass - -def withServers(): - import KernelBasis - KernelBasis.setSSLMode(False) - -def salome_init(path=None, embedded=False, iorfakensfile=None, forced=False): - """ - Initialize SALOME client process (that can also be server). - 3 modes of initialization exists: - - SSL mode (see salome_init_without_session) - - SSL mode attached in the context of python execution inside SALOME_Container_No_NS_Serv server (typically YACS) - - Classical mode (see salome_init_with_session) - :param iorfakensfile: filename inside which IOR of fake NS will be written - :param forced: tell if the multi-initialization protection mecanism of salome_init must be skiped of not - (typically in the context where a path to a study is given whereas a previous initialisation without it was done) - """ - if not forced: - if lcc is not None:# multi-initialization protection mecanism is based on lcc global var - return - PATH_TO_STUDY_FILE_TO_INITIATE = "PATH_TO_STUDY_FILE_TO_INITIATE" - import KernelBasis - if KernelBasis.getSSLMode(): - if KernelBasis.getIOROfEmbeddedNS() == "": - import os - # make runSalome.py -t study.hdf toto.py - if path is None and PATH_TO_STUDY_FILE_TO_INITIATE in os.environ: - path = os.environ[PATH_TO_STUDY_FILE_TO_INITIATE] - salome_init_without_session(path, embedded, iorfakensfile) - else: - salome_init_without_session_attached(path, embedded) - else: - salome_init_with_session(path, embedded) - -def salome_init_without_session_common(path=None, embedded=False): - from ORBConfigFile import writeORBConfigFileSSL - OMNIORB_USER_PATH = "OMNIORB_USER_PATH" - def RemoveOmniorbConfigFile(): - import os - if "OMNIORB_CONFIG" in os.environ: - fileToRemove = os.environ["OMNIORB_CONFIG"] - if os.path.exists(fileToRemove): - os.unlink(fileToRemove) - - if OMNIORB_USER_PATH in os.environ: - import atexit - writeORBConfigFileSSL(os.environ[OMNIORB_USER_PATH],kwargs={"with_pid":True}) - atexit.register(RemoveOmniorbConfigFile) - - global lcc,naming_service,myStudy,myStudyName,orb,modulcat,sg - import KernelBasis - KernelBasis.setSSLMode(True) - import KernelDS - myStudy = KernelDS.myStudy() - import CORBA - orb=CORBA.ORB_init(['']) - import KernelModuleCatalog - import SALOME_ModuleCatalog - from salome_kernel import list_of_catalogs_regarding_environement - modulcat = KernelModuleCatalog.myModuleCatalog( list_of_catalogs_regarding_environement() ) - # - poa = orb.resolve_initial_references("RootPOA") - poaManager = poa._get_the_POAManager() - poaManager.activate() - # - sg = salome_iapp_init(embedded) - salome_study_init_without_session(path) - # - from NamingService import NamingService - naming_service = NamingService() - myStudyName = myStudy.Name - -def salome_init_without_session(path=None, embedded=False, iorfakensfile=None): - """ - Force creation of all servants needed by SALOME session in the current process. - A Fake NamingService is created storing reference of all servants in the current process. - """ - salome_init_without_session_common(path,embedded) - global lcc,cm,dsm,esm - import KernelLauncher - cm = KernelLauncher.myContainerManager() - from LifeCycleCORBA import LifeCycleCORBASSL - lcc = LifeCycleCORBASSL() - # create a FactoryServer Container servant - import KernelContainer - KernelContainer.myContainer() - # activate poaManager to accept co-localized CORBA calls. - from KernelSDS import GetDSMInstance - import sys - if hasattr(sys, 'argv'): - argv = sys.argv - else: - argv = [''] - dsm = GetDSMInstance(argv) - # esm inherits from SALOME_CPythonHelper singleton already initialized by GetDSMInstance - # esm inherits also from SALOME_ResourcesManager creation/initialization (concerning SingleThreadPOA POA) when KernelLauncher.GetContainerManager() has been called - esm = KernelLauncher.GetExternalServer() - # - import KernelLogger - naming_service.Register(KernelLogger.myLogger(),"/Logger") - # - from NamingService import NamingService - if iorfakensfile is not None: - with open(iorfakensfile,"w") as iorfakensf: - iorfakensf.write(NamingService.IOROfNS()) - -def salome_init_without_session_attached(path=None, embedded=False): - """ - Configuration SSL inside a python interpretor launched in the SALOME_Container_No_NS_Serv. - In this configuration, a local FakeNamingService is created and remote objects are stored in it. - lcc is pointing to the FakeNamingService above. - """ - salome_init_without_session_common(path,embedded) - global lcc,cm,dsm,esm - import CORBA - orb=CORBA.ORB_init(['']) - import Engines - import KernelBasis - nsAbroad = orb.string_to_object( KernelBasis.getIOROfEmbeddedNS() ) - import SALOME - CM_NAME_IN_NS = "/ContainerManager" - cm = orb.string_to_object( nsAbroad.Resolve(CM_NAME_IN_NS).decode() ) - naming_service.Register(cm,CM_NAME_IN_NS) - RM_NAME_IN_NS = "/ResourcesManager" - rm = orb.string_to_object( nsAbroad.Resolve(RM_NAME_IN_NS).decode() ) - naming_service.Register(rm,RM_NAME_IN_NS) - # - from LifeCycleCORBA import LifeCycleCORBASSL - lcc = LifeCycleCORBASSL() - DSM_NAME_IN_NS = "/DataServerManager" - dsm = orb.string_to_object( nsAbroad.Resolve(DSM_NAME_IN_NS).decode() ) - naming_service.Register(dsm,DSM_NAME_IN_NS) - # - ESM_NAME_IN_NS = "/ExternalServers" - esm = orb.string_to_object( nsAbroad.Resolve(ESM_NAME_IN_NS).decode() ) - naming_service.Register(esm,ESM_NAME_IN_NS) - -def salome_init_with_session(path=None, embedded=False): - """ - Performs only once SALOME general purpose initialisation for scripts. - Provides: - orb reference to CORBA - lcc a LifeCycleCorba instance - naming_service a naming service instance - cm reference to the container manager - esm reference to external server manager - dsm reference to shared dataserver manager - modulcat reference to modulecatalog instance - sg access to SALOME GUI (when linked with IAPP GUI) - myStudy active study itself (CORBA reference) - myStudyName active study name - """ - global salome_initial - global orb, lcc, naming_service, cm, esm, dsm, modulcat - global sg - global myStudy, myStudyName - import KernelBasis - KernelBasis.setSSLMode(False) - try: - if salome_initial: - salome_initial=False - sg = salome_iapp_init(embedded) - orb, lcc, naming_service, cm, esm, dsm, modulcat = salome_kernel_init() - myStudy, myStudyName = salome_study_init(path) - pass - pass - except RuntimeError as inst: - # wait a little to avoid trace mix - import time - time.sleep(0.2) - x = inst - print("salome.salome_init_with_session():", x) - print(""" - ============================================ - May be there is no running SALOME session - salome.salome_init() is intended to be used - within an already running session - ============================================ - """) - raise - -def salome_close(): - global salome_initial, myStudy, myStudyName, lcc - try: - # study can be clear either from GUI or directly with salome.myStudy.Clear() - myStudy.Clear() - except Exception: - pass - salome_initial=True - salome_iapp_close() - salome_study_close() - myStudy, myStudyName = None, None - lcc = None # to salome_init to rebuild all in case of salome_init after salome_close - import KernelBasis - if KernelBasis.getSSLMode() and not KernelBasis.getGUIMode(): - import KernelDS - KernelDS.KillGlobalSessionInstance() - import KernelSDS - KernelSDS.KillCPythonHelper() - pass - -def salome_NS(): - import CORBA - import CosNaming - orb = CORBA.ORB_init() - ns0 = orb.resolve_initial_references("NameService") - return ns0._narrow(CosNaming.NamingContext) - -def salome_walk_on_containers(ns,root): - import CosNaming - it = ns.list(0)[1] - if not it: - return - cont = True - while cont: - cont,obj = it.next_one() - if cont: - if obj.binding_name[0].kind == "object": - import Engines - corbaObj = ns.resolve(obj.binding_name) - if isinstance(corbaObj,Engines._objref_Container): - yield corbaObj,(root,obj.binding_name[0].id) - else: - father = ns.resolve([obj.binding_name[0]]) - for elt,elt2 in salome_walk_on_containers(father,root+[obj.binding_name[0].id]): - yield elt,elt2 - pass - pass - pass - -def salome_shutdown_containers_with_session(): - salome_init() - ns=salome_NS() - li = [elt for elt in salome_walk_on_containers(ns,[""])] - print("Number of containers in NS : {}".format(len(li))) - for cont,(root,cont_name) in li: - try: - cont.Shutdown() - except Exception: - pass - ref_in_ns = "/".join(root+[cont_name]) - naming_service.Destroy_Name(ref_in_ns) - print("Number of containers in NS after clean : {}".format( len( list(salome_walk_on_containers(ns,[""])) ))) - -def salome_shutdown_containers_without_session(): - containersEntries = [elt for elt in naming_service.repr() if "/Containers/" == elt[:12]] - for containerEntry in containersEntries: - cont = naming_service.Resolve(containerEntry) - try: - cont.Shutdown() - except: - pass - -def salome_shutdown_containers(): - import KernelBasis - if KernelBasis.getSSLMode(): - salome_shutdown_containers_without_session() - else: - salome_shutdown_containers_with_session() - -class SessionContextManager: - def __enter__(self): - standalone() - salome_init() - def __exit__(self, type, value, traceback): - salome_close() - -#to expose all objects to pydoc -__all__=dir()