salome.kernel 9.14.0__cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/nameserver.py

@@ -0,0 +1,134 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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, or (at your option) any later version.
+#
+# 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 os, sys, re, socket
+#import commands
+from salome.kernel.server import Server
+from salome.kernel.salome_utils import getHostName, makeDir
+from salome.kernel.launchConfigureParser import verbose
+
+# -----------------------------------------------------------------------------
+
+class NamingServer(Server):
+    #XTERM = ""
+    #USER = os.getenv('USER')
+    #if USER is None:
+    #  USER = 'anonymous'
+    #os.system("mkdir -m 777 -p /tmp/logs")
+    #LOGDIR = "/tmp/logs/" + USER
+
+    def initNSArgs(self):
+        from salome.kernel.salome_utils import getLogDir
+        upath = getLogDir()
+        makeDir(upath)
+
+        if verbose(): print("Name Service... ", end =' ')
+        hname = getHostName()
+
+        with open(os.environ["OMNIORB_CONFIG"]) as f:
+          ss = re.findall("NameService=corbaname::" + hname + ":\d+", f.read())
+          if verbose(): print("ss = ", ss, end=' ')
+        sl = ss[0]
+        ll = sl.split(':')
+        aPort = ll[-1]
+        #aPort=(ss.join().split(':'))[2];
+        #aPort=re.findall("\d+", ss[0])[0]
+
+        # \begin{E.A.}
+        # put the log files of omniNames in different directory with port reference,
+        # it is cleaner on linux and it is a fix for salome since it is impossible to
+        # remove the log files if the corresponding omniNames has not been killed.
+        # \end{E.A.}
+
+        upath = os.path.join(upath, "omniNames_%s"%(aPort))
+        try:
+          os.mkdir(upath)
+        except Exception:
+          # print("Can't create " + upath)
+          pass
+
+        #os.system("touch " + upath + "/dummy")
+        for fname in os.listdir(upath):
+          try:
+            os.remove(upath + "/" + fname)
+          except Exception:
+            pass
+        #os.system("rm -f " + upath + "/omninames* " + upath + "/dummy " + upath + "/*.log")
+
+        #aSedCommand="s/.*NameService=corbaname::" + hname + ":\([[:digit:]]*\)/\1/"
+        # print("sed command = ", aSedCommand)
+        #aPort = commands.getoutput("sed -e\"" + aSedCommand + "\"" + os.environ["OMNIORB_CONFIG"])
+        # print("port=", aPort)
+        if sys.platform == "win32":
+          # print("start omniNames -start " + aPort + " -logdir " + upath)
+          self.CMD = ['omniNames', '-start' , aPort , '-nohostname', '-logdir' , os.path.realpath(upath), '-errlog', os.path.realpath(os.path.join(upath,'omniNameErrors.log'))]
+          #os.system("start omniNames -start " + aPort + " -logdir " + upath)
+        else:
+          # get ip address on default interface (for instance eth0) to limit listening on this interface (cyber security request)
+          from subprocess import check_output
+          ips = check_output(['hostname', '--all-ip-addresses'])
+          if ips.strip():
+            ipDefault = ips.split()[0].decode()
+          else:
+            ip = check_output(['hostname', '--ip-address'])
+            ipDefault = ip.split()[-1].decode()
+          self.CMD = ['omniNames','-start' , aPort]
+          self.CMD += ['-logdir' , upath, '-errlog', upath+'/omniNameErrors.log']
+
+        if verbose(): print("... ok")
+        if verbose(): print("to list contexts and objects bound into the context with the specified name : showNS ")
+
+
+    def initArgs(self):
+        ld_path = "LD_LIBRARY_PATH"
+        Server.initArgs(self)
+        if sys.platform == "win32":
+          env_ld_library_path = ['env', f'{ld_path}=' + os.getenv("PATH")]
+        elif sys.platform == "darwin":
+          env_ld_library_path = ['env', 'DYLD_LIBRARY_PATH=' + os.getenv("DYLD_LIBRARY_PATH"), 'DYLD_FALLBACK_LIBRARY_PATH=' + os.getenv("DYLD_FALLBACK_LIBRARY_PATH")]
+        else:
+          env_ld_library_path = []
+          if ld_path in os.environ:
+            env_ld_library_path += [ 'env', f'{ld_path}=' + os.getenv( ld_path ) ]
+        self.CMD = ['xterm', '-e'] + env_ld_library_path + ['python3']
+        self.initNSArgs()
+
+# In LifeCycleCORBA, FactoryServer is started with rsh on the requested
+#    computer if this Container does not exist. Default is localhost.
+#    Others Containers are started with start_impl method of FactoryServer Container.
+# For using rsh it is necessary to have in the ${HOME} directory a .rhosts file
+# Warning : on RedHat the file /etc/hosts contains by default a line like :
+# 127.0.0.1               bordolex bordolex.paris1.matra-dtv.fr localhost.localdomain localhost
+#   (bordolex is the station name). omniNames on bordolex will be accessible from other
+#   computers only if the computer name is removed on that line like :
+#   127.0.0.1               bordolex.paris1.matra-dtv.fr localhost.localdomain localhost
+
+# To start dynamically Containers on several computers you need to
+# put in the ${OMNIORB_CONFIG} file a computer name instead of "localhost"
+# example : ORBInitRef NameService=corbaname::dm2s0017
+
+# If you need to use several omniNames running on the same computer, you have to :
+#1. put in your ${OMNIORB_CONFIG} file a computer name and port number
+# example : ORBInitRef NameService=corbaname::dm2s0017:1515
+#2. start omninames with this port number like in orbmodile.py
+# example : omniNames -start 1515 -logdir ${BaseDir}/logs/${Username} &

salome/kernel/nstest_idl.py

@@ -0,0 +1,129 @@
+# Python stubs generated by omniidl from /tmp/kernel/idl/nstest.idl
+# DO NOT EDIT THIS FILE!
+
+import omniORB, _omnipy
+from omniORB import CORBA, PortableServer
+_0_CORBA = CORBA
+
+
+_omnipy.checkVersion(4,2, __file__, 1)
+
+try:
+    property
+except NameError:
+    def property(*args):
+        return None
+
+
+#
+# Start of module "NSTEST"
+#
+__name__ = "salome.kernel.NSTEST"
+_0_NSTEST = omniORB.openModule("salome.kernel.NSTEST", r"/tmp/kernel/idl/nstest.idl")
+_0_NSTEST__POA = omniORB.openModule("salome.kernel.NSTEST__POA", r"/tmp/kernel/idl/nstest.idl")
+
+
+# interface echo
+_0_NSTEST._d_echo = (omniORB.tcInternal.tv_objref, "IDL:NSTEST/echo:1.0", "echo")
+omniORB.typeMapping["IDL:NSTEST/echo:1.0"] = _0_NSTEST._d_echo
+_0_NSTEST.echo = omniORB.newEmptyClass()
+class echo :
+    _NP_RepositoryId = _0_NSTEST._d_echo[1]
+
+    def __init__(self, *args, **kw):
+        raise RuntimeError("Cannot construct objects of this type.")
+
+    _nil = CORBA.Object._nil
+
+
+_0_NSTEST.echo = echo
+_0_NSTEST._tc_echo = omniORB.tcInternal.createTypeCode(_0_NSTEST._d_echo)
+omniORB.registerType(echo._NP_RepositoryId, _0_NSTEST._d_echo, _0_NSTEST._tc_echo)
+
+# echo operations and attributes
+echo._d_getId = ((), (omniORB.tcInternal.tv_long, ), None)
+
+# echo object reference
+class _objref_echo (CORBA.Object):
+    _NP_RepositoryId = echo._NP_RepositoryId
+
+    def __init__(self, obj):
+        CORBA.Object.__init__(self, obj)
+
+    def getId(self, *args):
+        return self._obj.invoke("getId", _0_NSTEST.echo._d_getId, args)
+
+omniORB.registerObjref(echo._NP_RepositoryId, _objref_echo)
+_0_NSTEST._objref_echo = _objref_echo
+del echo, _objref_echo
+
+# echo skeleton
+__name__ = "salome.kernel.NSTEST__POA"
+class echo (PortableServer.Servant):
+    _NP_RepositoryId = _0_NSTEST.echo._NP_RepositoryId
+
+
+    _omni_op_d = {"getId": _0_NSTEST.echo._d_getId}
+
+echo._omni_skeleton = echo
+_0_NSTEST__POA.echo = echo
+omniORB.registerSkeleton(echo._NP_RepositoryId, echo)
+del echo
+__name__ = "salome.kernel.NSTEST"
+
+# interface aFactory
+_0_NSTEST._d_aFactory = (omniORB.tcInternal.tv_objref, "IDL:NSTEST/aFactory:1.0", "aFactory")
+omniORB.typeMapping["IDL:NSTEST/aFactory:1.0"] = _0_NSTEST._d_aFactory
+_0_NSTEST.aFactory = omniORB.newEmptyClass()
+class aFactory :
+    _NP_RepositoryId = _0_NSTEST._d_aFactory[1]
+
+    def __init__(self, *args, **kw):
+        raise RuntimeError("Cannot construct objects of this type.")
+
+    _nil = CORBA.Object._nil
+
+
+_0_NSTEST.aFactory = aFactory
+_0_NSTEST._tc_aFactory = omniORB.tcInternal.createTypeCode(_0_NSTEST._d_aFactory)
+omniORB.registerType(aFactory._NP_RepositoryId, _0_NSTEST._d_aFactory, _0_NSTEST._tc_aFactory)
+
+# aFactory operations and attributes
+aFactory._d_createInstance = ((), (omniORB.typeMapping["IDL:NSTEST/echo:1.0"], ), None)
+
+# aFactory object reference
+class _objref_aFactory (CORBA.Object):
+    _NP_RepositoryId = aFactory._NP_RepositoryId
+
+    def __init__(self, obj):
+        CORBA.Object.__init__(self, obj)
+
+    def createInstance(self, *args):
+        return self._obj.invoke("createInstance", _0_NSTEST.aFactory._d_createInstance, args)
+
+omniORB.registerObjref(aFactory._NP_RepositoryId, _objref_aFactory)
+_0_NSTEST._objref_aFactory = _objref_aFactory
+del aFactory, _objref_aFactory
+
+# aFactory skeleton
+__name__ = "salome.kernel.NSTEST__POA"
+class aFactory (PortableServer.Servant):
+    _NP_RepositoryId = _0_NSTEST.aFactory._NP_RepositoryId
+
+
+    _omni_op_d = {"createInstance": _0_NSTEST.aFactory._d_createInstance}
+
+aFactory._omni_skeleton = aFactory
+_0_NSTEST__POA.aFactory = aFactory
+omniORB.registerSkeleton(aFactory._NP_RepositoryId, aFactory)
+del aFactory
+__name__ = "salome.kernel.NSTEST"
+
+#
+# End of module "NSTEST"
+#
+__name__ = "salome.kernel.nstest_idl"
+
+_exported_modules = ( "salome.kernel.NSTEST", )
+
+# The end.

salome/kernel/omnipatch.py

@@ -0,0 +1,136 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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, or (at your option) any later version.
+#
+# 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
+#
+
+"""
+  This patch of omniORB is made to make it work with multiple interpreters
+  and to correct the problem of incomplete import of CORBA packages
+  in some situations common in SALOME
+
+  This patch add or modify functions in omniORB module.
+
+  In multiple interpreters context, omniORB module is meant to be shared among
+  all interpreters
+"""
+import sys,string,imp
+import omniORB
+# Map of partially-opened modules
+_partialModules = {}
+# Map of modules to share
+shared_imported={}
+
+# Function to return a Python module for the required IDL module name
+def openModule(mname, fname=None):
+    # Salome modification start
+    # Be sure to use the right module dictionary
+    import sys
+    # Salome modification end
+
+    if mname == "CORBA":
+        mod = sys.modules["omniORB.CORBA"]
+        # Salome modification start
+        shared_imported[mname]=mod
+        # Salome modification end
+
+    elif mname in sys.modules:
+        mod = sys.modules[mname]
+
+        if mname in _partialModules:
+            pmod = _partialModules[mname]
+            mod.__dict__.update(pmod.__dict__)
+            del _partialModules[mname]
+        # Salome modification start
+        shared_imported[mname]=mod
+        # Salome modification end
+
+    elif mname in _partialModules:
+        mod = _partialModules[mname]
+
+    # Salome modification start
+    elif shared_imported.get(mname) :
+        mod = shared_imported[mname]
+    # Salome modification end
+
+    else:
+        mod = newModule(mname)
+
+
+    if not hasattr(mod, "__doc__") or mod.__doc__ is None:
+        mod.__doc__ = "omniORB IDL module " + mname + "\n\n" + \
+                      "Generated from:\n\n"
+
+    if fname is not None:
+        mod.__doc__ = mod.__doc__ + "  " + fname + "\n"
+
+    return mod
+
+# Function to create a new module, and any parent modules which do not
+# already exist
+def newModule(mname):
+    # Salome modification start
+    # Be sure to use the right module dictionary
+    import sys
+    # Salome modification end
+
+    mlist   = string.split(mname, ".")
+    current = ""
+    mod     = None
+
+    for name in mlist:
+        current = current + name
+
+        if current in sys.modules:
+            mod = sys.modules[current]
+
+        elif current in _partialModules:
+            mod = _partialModules[current]
+
+        else:
+            newmod = imp.new_module(current)
+            if mod: setattr(mod, name, newmod)
+            _partialModules[current] = mod = newmod
+
+        current = current + "."
+
+    return mod
+
+# Function to update a module with the partial module store in the
+# partial module map
+def updateModule(mname):
+    # Salome modification start
+    # Be sure to use the right module dictionary
+    import sys
+    # Salome modification end
+    if mname in _partialModules:
+        pmod = _partialModules[mname]
+        mod  = sys.modules[mname]
+        mod.__dict__.update(pmod.__dict__)
+        del _partialModules[mname]
+
+    # Salome modification start
+    shared_imported[mname]=sys.modules[mname]
+    # Salome modification end
+
+omniORB.updateModule=updateModule
+omniORB.newModule=newModule
+omniORB.openModule=openModule
+

salome/kernel/orbmodule.py

@@ -0,0 +1,246 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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, or (at your option) any later version.
+#
+# 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
+#
+
+## @package orbmodule
+# \brief Module that provides a client for %SALOME
+#
+
+import sys,os,time
+import string
+from salome.kernel.nameserver import NamingServer
+from omniORB import CORBA
+from salome.kernel.launchConfigureParser import verbose
+
+# Import the stubs for the Naming service
+import CosNaming
+
+# -----------------------------------------------------------------------------
+
+class client:
+    """Client for SALOME"""
+
+    def __init__(self,args=None):
+      # Initialise the ORB
+
+      if args is not None and 'launcher' in args:
+        pos = args['launcher'].find(":")
+        if pos != -1:
+          machine = args['launcher'][0:pos]
+          port = args['launcher'][pos+1:]
+          sys.argv.append('-ORBInitRef')
+          sys.argv.append("NameService=corbaname::" + machine + ":" + port)
+          print("Connect to naming service on machine: "+machine+" port: "+port)
+      self.orb=CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
+
+      # Initialise the Naming Service
+      self.initNS(args or {})
+
+    # --------------------------------------------------------------------------
+
+    def initNS(self,args):
+      # Obtain a reference to the root naming context
+      obj = self.orb.resolve_initial_references("NameService")
+      try:
+          self.rootContext = obj._narrow(CosNaming.NamingContext)
+          return
+      except (CORBA.TRANSIENT,CORBA.OBJECT_NOT_EXIST,CORBA.COMM_FAILURE):
+          self.rootContext = None
+          if verbose(): print("Launch Naming Service++", end=' ')
+
+      # On lance le Naming Server (doit etre dans le PATH)
+      test = True
+      if args != None and 'wake_up_session' in args and args['wake_up_session']:
+        test = False
+        pass
+      if test:
+        NamingServer(args).run()
+        pass
+      print("Searching Naming Service ", end=' ')
+      ncount=0
+      delta=0.1
+      while(ncount < 100):
+          ncount += 1
+          try:
+              obj = self.orb.resolve_initial_references("NameService")
+              self.rootContext = obj._narrow(CosNaming.NamingContext)
+              break
+          except (CORBA.TRANSIENT,CORBA.OBJECT_NOT_EXIST,CORBA.COMM_FAILURE):
+              self.rootContext = None
+              sys.stdout.write('+')
+              sys.stdout.flush()
+              time.sleep(delta)
+
+      if self.rootContext is None:
+          print("Failed to narrow the root naming context")
+          sys.exit(1)
+      print(" found in %s seconds " % ((ncount-1)*delta))
+
+    # --------------------------------------------------------------------------
+
+    def showNScontext(self,context,dec=''):
+      if not context:
+        print("[NS] No context")
+        return
+      else:
+        print(context)
+
+      _,bi = context.list(0)
+      if bi is not None:
+        ok,b = bi.next_one()
+        while(ok):
+            for s in b.binding_name :
+              print("%s%s.%s" %(dec,s.id,s.kind))
+              if s.kind == "dir":
+                  obj = context.resolve([s])
+                  scontext = obj._narrow(CosNaming.NamingContext)
+                  self.showNScontext(scontext,dec=dec+'  ')
+            ok,b = bi.next_one()
+
+    # --------------------------------------------------------------------------
+
+    def showNS(self):
+      """ Show the content of SALOME naming service """
+      self.showNScontext(self.rootContext)
+
+    # --------------------------------------------------------------------------
+
+    def Resolve(self, Path):
+      resolve_path = Path.split('/')
+      if resolve_path[0] == '': del resolve_path[0]
+      dir_path = resolve_path[:-1]
+      context_name = []
+      for e in dir_path:
+        context_name.append(CosNaming.NameComponent(e,"dir"))
+      context_name.append(CosNaming.NameComponent(resolve_path[-1],"object"))
+
+      try:
+          obj = self.rootContext.resolve(context_name)
+      except CosNaming.NamingContext.NotFound as ex:
+          obj = None
+      except CosNaming.NamingContext.InvalidName as ex:
+          obj = None
+      except CosNaming.NamingContext.CannotProceed as ex:
+          obj = None
+      except (CORBA.TRANSIENT,CORBA.OBJECT_NOT_EXIST,CORBA.COMM_FAILURE):
+          obj = None
+      return obj
+
+    # --------------------------------------------------------------------------
+
+    def waitNS(self,name,typobj=None,maxcount=240):
+      count = 0
+      delta = 0.5
+      print("Searching %s in Naming Service " % name, end=' ')
+      while(1):
+          count += 1
+          if count > maxcount : raise RuntimeError("Impossible de trouver %s" % name)
+          obj = self.Resolve(name)
+          if obj :
+              print(" found in %s seconds " % ((count-1)*delta))
+              break
+          else:
+              sys.stdout.write('+')
+              sys.stdout.flush()
+              time.sleep(delta)
+
+      if typobj is None:return obj
+
+      nobj = obj._narrow(typobj)
+      if nobj is None:
+            print("%s exists but is not a %s" % (name,typobj))
+      return nobj
+
+    if sys.platform != "win32":
+      def waitNSPID(self, theName, thePID, theTypObj = None):
+        aCount = 0
+        aDelta = 0.5
+        anObj = None
+        print("Searching %s in Naming Service " % theName, end=' ')
+        while(1):
+          try:
+            os.kill(thePID,0)
+          except Exception:
+            raise RuntimeError("Process %d for %s not found" % (thePID,theName))
+          aCount += 1
+          anObj = self.Resolve(theName)
+          if anObj:
+            print(" found in %s seconds " % ((aCount-1)*aDelta))
+            break
+          else:
+            sys.stdout.write('+')
+            sys.stdout.flush()
+            time.sleep(aDelta)
+            pass
+          pass
+  
+        if theTypObj is None:
+          return anObj
+  
+        anObject = anObj._narrow(theTypObj)
+        if anObject is None:
+          print("%s exists but is not a %s" % (theName,theTypObj))
+        return anObject
+
+
+    # --------------------------------------------------------------------------
+
+    def ResolveLogger(self, name):
+      context_name = []
+      context_name.append(CosNaming.NameComponent(name,""))
+
+      try:
+          obj = self.rootContext.resolve(context_name)
+      except CosNaming.NamingContext.NotFound as ex:
+          obj = None
+      except CosNaming.NamingContext.InvalidName as ex:
+          obj = None
+      except CosNaming.NamingContext.CannotProceed as ex:
+          obj = None
+      except (CORBA.TRANSIENT,CORBA.OBJECT_NOT_EXIST,CORBA.COMM_FAILURE):
+          obj = None
+      return obj
+
+    # --------------------------------------------------------------------------
+
+    def waitLogger(self,name,typobj=None,maxcount=40):
+      count = 0
+      delta = 0.5
+      print("Searching %s in Naming Service " % name, end=' ')
+      while(1):
+          count += 1
+          if count > maxcount : raise RuntimeError("Impossible de trouver %s" % name)
+          obj = self.ResolveLogger(name)
+          if obj :
+              print(" found in %s seconds " % ((count-1)*delta))
+              break
+          else:
+              sys.stdout.write('+')
+              sys.stdout.flush()
+              time.sleep(delta)
+
+      if typobj is None:return obj
+
+      nobj = obj._narrow(typobj)
+      if nobj is None:
+            print("%s exists but is not a %s" % (name,typobj))
+      return nobj