src/KERNEL_PY/__init__.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   5 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License, or (at your option) any later version.
  11 #
  12 # This library is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23
  24 #  File   : salome.py renamed as __init__.py for python packaging (gboulant)
  25 #  Author : Paul RASCLE, EDF
  26 #  Module : SALOME
  27 #
  28 """
  29 Module salome gives access to Salome resources.
  30
  31 variables:
  32
  33   - salome.orb             : CORBA
  34   - salome.naming_service  : instance of naming Service class
  35       - methods:
  36           - Resolve(name)  : find a CORBA object (ior) by its pathname
  37           - Register(name) : register a CORBA object under a pathname
  38
  39   - salome.lcc             : instance of lifeCycleCORBA class
  40       - methods:
  41           - FindOrLoadComponent(server,name) :
  42                            obtain an Engine (CORBA object)
  43                            or launch the Engine if not found,
  44                            with a Server name and an Engine name
  45
  46   - salome.sg              : salome object to communicate with the graphical user interface (if any)
  47       - methods:
  48          - updateObjBrowser():
  49
  50          - SelectedCount():      returns number of selected objects
  51          - getSelected(i):       returns entry of selected object number i
  52          - getAllSelected():     returns list of entry of selected objects
  53          - AddIObject(Entry):    select an existing Interactive object
  54          - RemoveIObject(Entry): remove object from selection
  55          - ClearIObjects():      clear selection
  56
  57          - Display(*Entry):
  58          - DisplayOnly(Entry):
  59          - Erase(Entry):
  60          - DisplayAll():
  61          - EraseAll():
  62
  63          - IDToObject(Entry):    returns CORBA reference from entry
  64
  65   - salome.myStudyName     : active Study Name
  66   - salome.myStudy         : the active Study itself (CORBA ior)
  67       - methods : defined in SALOMEDS.idl
  68
  69 """
  70 ## @package salome
  71 # Module salome gives access to Salome resources.
  72 #
  73 #  \param salome.orb             : CORBA orb object
  74 #  \param salome.naming_service  : instance of naming Service class (SALOME_NamingServicePy::SALOME_NamingServicePy_i)
  75 #  \param salome.lcc             : instance of lifeCycleCORBA class (SALOME_LifeCycleCORBA)
  76 #  \param salome.sg              : Salome object to communicate with the graphical user interface, if running (see interface in salome_iapp::SalomeOutsideGUI)
  77 #  \param salome.myStudyName     : active Study Name
  78 #  \param salome.myStudy         : the active Study (interface SALOMEDS::Study)
  79
  80 #
  81 # ==========================================================================
  82 #
  83 # The function extend_path is used here to aggregate in a single
  84 # virtual python package all the python sub-packages embedded in each
  85 # SALOME modules (python "namespace" pattern).
  86 #
  87 ROOT_PYTHONPACKAGE_NAME="salome"
  88 #
  89 # This root package name is expected to be found as a directory in
  90 # some paths of the sys.path variable, especially the paths
  91 # <MODULE_ROOT_DIR>/lib/pythonX.Y/site-packages/salome where are
  92 # installed the python files. These paths are theorically appended by
  93 # the SALOME main runner and should be in the sys.path at this point
  94 # of the application. The extend_path is looking then for directories
  95 # of the type:
  96 #
  97 # <MODULE_ROOT_DIR>/lib/pythonX.Y/site-packages/salome/<ROOT_PYTHONPACKAGE_NAME>
  98 #
  99 # And append them to the sys.path. These directories are supposed to
 100 # be the pieces to be aggregated as a single virtual python package.
 101 #
 102 import os, sys
 103 from salome_utils import verbose
 104
 105 MATCH_ENDING_PATTERN="site-packages" + os.path.sep + "salome"
 106
 107 def extend_path(pname):
 108     for dir in sys.path:
 109         if not isinstance(dir, str) or not os.path.isdir(dir) or not dir.endswith(MATCH_ENDING_PATTERN):
 110             continue
 111         subdir = os.path.join(dir, pname)
 112         # XXX This may still add duplicate entries to path on
 113         # case-insensitive filesystems
 114         if os.path.isdir(subdir) and subdir not in __path__:
 115             if verbose(): print("INFO - The directory %s is appended to sys.path" % subdir)
 116             __path__.append(subdir)
 117
 118 extend_path(ROOT_PYTHONPACKAGE_NAME)
 119 # ==========================================================================
 120 #
 121
 122 from salome_kernel import *
 123 from salome_study import *
 124 from salome_iapp import *
 125 import salome_study
 126
 127 #
 128 # The next block is workaround for the problem of shared symbols loading for the extension modules (e.g. SWIG-generated)
 129 # that causes RTTI unavailable in some cases. To solve this problem, sys.setdlopenflags() function is used.
 130 # Depending on the Python version and platform, the dlopen flags can be defined in the dl, DLFUN or ctypes module.
 131 #
 132 import sys
 133 flags = None
 134 if not flags:
 135     try:
 136         # dl module can be unavailable
 137         import dl
 138         flags = dl.RTLD_NOW | dl.RTLD_GLOBAL
 139     except Exception:
 140         pass
 141     pass
 142 if not flags:
 143     try:
 144         # DLFCN module can be unavailable
 145         import DLFCN
 146         flags = DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL
 147     except Exception:
 148         pass
 149     pass
 150 if not flags:
 151     try:
 152         # ctypes module can be unavailable
 153         import ctypes
 154         flags = ctypes.RTLD_GLOBAL
 155     except Exception:
 156         pass
 157     pass
 158
 159 # Disable -> bug with scipy, seems very dangerous to do that
 160 #if flags:
 161 #    sys.setdlopenflags(flags)
 162 #    pass
 163
 164 orb, lcc, naming_service, cm, sg, esm, dsm, modulcat = None,None,None,None,None,None,None,None
 165 myStudy, myStudyName = None,None
 166
 167 salome_initial=True
 168
 169 def standalone():
 170     pass
 171
 172 def withServers():
 173     import KernelBasis
 174     KernelBasis.setSSLMode(False)
 175
 176 def salome_init(path=None, embedded=False):
 177     import KernelBasis
 178     if KernelBasis.getSSLMode():
 179         if KernelBasis.getIOROfEmbeddedNS() == "":
 180             salome_init_without_session(path, embedded)
 181         else:
 182             salome_init_without_session_attached(path, embedded)
 183     else:
 184         salome_init_with_session(path, embedded)
 185
 186 def salome_init_without_session_common(path=None, embedded=False):
 187     from ORBConfigFile import writeORBConfigFileSSL
 188     OMNIORB_USER_PATH = "OMNIORB_USER_PATH"
 189     def RemoveOmniorbConfigFile():
 190         import os
 191         if "OMNIORB_CONFIG" in os.environ:
 192             fileToRemove = os.environ["OMNIORB_CONFIG"]
 193             if os.path.exists(fileToRemove):
 194                 os.unlink(fileToRemove)
 195
 196     if OMNIORB_USER_PATH in os.environ:
 197         import atexit
 198         writeORBConfigFileSSL(os.environ[OMNIORB_USER_PATH],kwargs={"with_pid":True})
 199         atexit.register(RemoveOmniorbConfigFile)
 200
 201     global lcc,naming_service,myStudy,orb,modulcat,sg
 202     import KernelBasis
 203     KernelBasis.setSSLMode(True)
 204     import KernelDS
 205     myStudy = KernelDS.myStudy()
 206     import CORBA
 207     orb=CORBA.ORB_init([''])
 208     import KernelModuleCatalog
 209     import SALOME_ModuleCatalog
 210     from salome_kernel import list_of_catalogs_regarding_environement
 211     modulcat = KernelModuleCatalog.myModuleCatalog( list_of_catalogs_regarding_environement() )
 212     #
 213     poa = orb.resolve_initial_references("RootPOA")
 214     poaManager = poa._get_the_POAManager()
 215     poaManager.activate()
 216     #
 217     sg = salome_iapp_init(embedded)
 218     salome_study_init_without_session(path)
 219     #
 220     from NamingService import NamingService
 221     naming_service = NamingService()
 222
 223 def salome_init_without_session(path=None, embedded=False):
 224     salome_init_without_session_common(path,embedded)
 225     global lcc,cm,dsm,esm
 226     import KernelLauncher
 227     cm = KernelLauncher.myContainerManager()
 228     from LifeCycleCORBA import LifeCycleCORBASSL
 229     lcc = LifeCycleCORBASSL()
 230     # create a FactoryServer Container servant
 231     import KernelContainer
 232     KernelContainer.myContainer()
 233     # activate poaManager to accept co-localized CORBA calls.
 234     from KernelSDS import GetDSMInstance
 235     import sys
 236     if hasattr(sys, 'argv'):
 237       argv = sys.argv
 238     else:
 239       argv = ['']
 240     dsm = GetDSMInstance(argv)
 241     # esm inherits from SALOME_CPythonHelper singleton already initialized by GetDSMInstance
 242     # esm inherits also from SALOME_ResourcesManager creation/initialization (concerning SingleThreadPOA POA) when KernelLauncher.GetContainerManager() has been called
 243     esm = KernelLauncher.GetExternalServer()
 244
 245 def salome_init_without_session_attached(path=None, embedded=False):
 246     """
 247     Configuration SSL inside a python interpretor launched in the SALOME_Container_No_NS_Serv.
 248     In this configuration,
 249     """
 250     salome_init_without_session_common(path,embedded)
 251     global lcc,cm,dsm,esm
 252     import CORBA
 253     orb=CORBA.ORB_init([''])
 254     import Engines
 255     import KernelBasis
 256     nsAbroad = orb.string_to_object( KernelBasis.getIOROfEmbeddedNS() )
 257     import SALOME
 258     CM_NAME_IN_NS = "/ContainerManager"
 259     cm = orb.string_to_object( nsAbroad.Resolve(CM_NAME_IN_NS).decode() )
 260     naming_service.Register(cm,CM_NAME_IN_NS)
 261     RM_NAME_IN_NS = "/ResourcesManager"
 262     rm = orb.string_to_object( nsAbroad.Resolve(RM_NAME_IN_NS).decode() )
 263     naming_service.Register(rm,RM_NAME_IN_NS)
 264     #
 265     from LifeCycleCORBA import LifeCycleCORBASSL
 266     lcc = LifeCycleCORBASSL()
 267     DSM_NAME_IN_NS = "/DataServerManager"
 268     dsm = orb.string_to_object( nsAbroad.Resolve(DSM_NAME_IN_NS).decode() )
 269     naming_service.Register(dsm,DSM_NAME_IN_NS)
 270     #
 271     ESM_NAME_IN_NS = "/ExternalServers"
 272     esm = orb.string_to_object( nsAbroad.Resolve(ESM_NAME_IN_NS).decode() )
 273     naming_service.Register(esm,ESM_NAME_IN_NS)
 274
 275 def salome_init_with_session(path=None, embedded=False):
 276     """
 277     Performs only once SALOME general purpose initialisation for scripts.
 278     Provides:
 279     orb             reference to CORBA
 280     lcc             a LifeCycleCorba instance
 281     naming_service  a naming service instance
 282     cm              reference to the container manager
 283     esm             reference to external server manager
 284     dsm             reference to shared dataserver manager
 285     modulcat        reference to modulecatalog instance
 286     sg              access to SALOME GUI (when linked with IAPP GUI)
 287     myStudy         active study itself (CORBA reference)
 288     myStudyName     active study name
 289     """
 290     global salome_initial
 291     global orb, lcc, naming_service, cm, esm, dsm, modulcat
 292     global sg
 293     global myStudy, myStudyName
 294     import KernelBasis
 295     KernelBasis.setSSLMode(False)
 296     try:
 297         if salome_initial:
 298             salome_initial=False
 299             sg = salome_iapp_init(embedded)
 300             orb, lcc, naming_service, cm, esm, dsm, modulcat = salome_kernel_init()
 301             myStudy, myStudyName = salome_study_init(path)
 302             pass
 303         pass
 304     except RuntimeError as inst:
 305         # wait a little to avoid trace mix
 306         import time
 307         time.sleep(0.2)
 308         x = inst
 309         print("salome.salome_init():", x)
 310         print("""
 311         ============================================
 312         May be there is no running SALOME session
 313         salome.salome_init() is intended to be used
 314         within an already running session
 315         ============================================
 316         """)
 317         raise
 318
 319 def salome_close():
 320     global salome_initial, myStudy, myStudyName
 321     try:
 322         # study can be clear either from GUI or directly with salome.myStudy.Clear()
 323         myStudy.Clear()
 324     except Exception:
 325         pass
 326     salome_initial=True
 327     salome_iapp_close()
 328     salome_study_close()
 329     myStudy, myStudyName = None, None
 330     import KernelBasis
 331     if KernelBasis.getSSLMode() and not KernelBasis.getGUIMode():
 332         import KernelDS
 333         KernelDS.KillGlobalSessionInstance()
 334         import KernelSDS
 335         KernelSDS.KillCPythonHelper()
 336     pass
 337
 338 def salome_NS():
 339     import CORBA
 340     import CosNaming
 341     orb = CORBA.ORB_init()
 342     ns0 = orb.resolve_initial_references("NameService")
 343     return ns0._narrow(CosNaming.NamingContext)
 344
 345 def salome_walk_on_containers(ns,root):
 346     import CosNaming
 347     it = ns.list(0)[1]
 348     if not it:
 349         return
 350     cont = True
 351     while cont:
 352         cont,obj = it.next_one()
 353         if cont:
 354             if obj.binding_name[0].kind == "object":
 355                 import Engines
 356                 corbaObj = ns.resolve(obj.binding_name)
 357                 if isinstance(corbaObj,Engines._objref_Container):
 358                     yield corbaObj,(root,obj.binding_name[0].id)
 359             else:
 360                 father = ns.resolve([obj.binding_name[0]])
 361                 for elt,elt2 in salome_walk_on_containers(father,root+[obj.binding_name[0].id]):
 362                     yield elt,elt2
 363             pass
 364         pass
 365     pass
 366
 367 def salome_shutdown_containers_with_session():
 368     salome_init()
 369     ns=salome_NS()
 370     li = [elt for elt in salome_walk_on_containers(ns,[""])]
 371     print("Number of containers in NS : {}".format(len(li)))
 372     for cont,(root,cont_name) in li:
 373         try:
 374             cont.Shutdown()
 375         except Exception:
 376             pass
 377         ref_in_ns = "/".join(root+[cont_name])
 378         naming_service.Destroy_Name(ref_in_ns)
 379     print("Number of containers in NS after clean : {}".format( len( list(salome_walk_on_containers(ns,[""])) )))
 380
 381 def salome_shutdown_containers_without_session():
 382     containersEntries = [elt for elt in naming_service.repr() if "/Containers/" == elt[:12]]
 383     for containerEntry in containersEntries:
 384         cont = naming_service.Resolve(containerEntry)
 385         try:
 386             cont.Shutdown()
 387         except:
 388             pass
 389
 390 def salome_shutdown_containers():
 391     import KernelBasis
 392     if KernelBasis.getSSLMode():
 393         salome_shutdown_containers_without_session()
 394     else:
 395         salome_shutdown_containers_with_session()
 396
 397 class SessionContextManager:
 398     def __enter__(self):
 399         standalone()
 400         salome_init()
 401     def __exit__(self, type, value, traceback):
 402         salome_close()
 403
 404 #to expose all objects to pydoc
 405 __all__=dir()