# Create environment for virtual env
if venv_directory_path:
command = """# SALOME venv Configuration
-export SALOME_VENV_DIRECTORY=%s
+export SALOME_VENV_DIRECTORY=${HOME}/${APPLI}/venv
export PATH=${HOME}/${APPLI}/venv/bin:$PATH
export LD_LIBRARY_PATH=${HOME}/${APPLI}/venv/lib:$LD_LIBRARY_PATH
export PYTHONPATH=${HOME}/${APPLI}/venv/lib/python%s/site-packages
-""" % (venv_directory_path, versionPython)
+""" % (versionPython)
f.write(command)
pass
# Create environment for virtual env
if venv_directory_path:
command = """[SALOME venv Configuration]
-SALOME_VENV_DIRECTORY: %s
+SALOME_VENV_DIRECTORY: ${HOME}/${APPLI}/venv
ADD_TO_PATH: ${HOME}/${APPLI}/venv/bin
ADD_TO_LD_LIBRARY_PATH: ${HOME}/${APPLI}/venv/lib
ADD_TO_PYTHONPATH: ${HOME}/${APPLI}/venv/lib/python%s/site-packages
-""" % (venv_directory_path, versionPython)
+""" % (versionPython)
f.write(command)
pass
Usage: salome_test_driver_gui.py <timeout_delay> <test command> [test command arguments]
"""
-import sys
import os
-import subprocess
import signal
+import sys
# Timeout management
class TimeoutException(Exception):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-import unittest
-import tempfile
-
-import os
-import sys
-import imp
-from io import StringIO
-import multiprocessing
import logging
+import multiprocessing
+import sys
+import unittest
def new_instance(running_instances):
from salome_instance import SalomeInstance
ispython = True
break
pass
- fn.close()
except Exception:
pass
+ finally:
+ fn.close()
if not ispython and script_extension == ".py":
currentKey = "@PYTHONBIN@ "+currentScript
else:
# set environment by modules from the list
if port:
try:
- mod=__import__(module.lower()+"_setenv")
+ import importlib
+ mod=importlib.import_module(module.lower()+"_setenv")
mod.set_env(args)
pass
except Exception:
import os
import sys
import traceback
-import imp
+import importlib
from omniORB import CORBA, PortableServer
import SALOMEDS
import Engines, Engines__POA
ret=""
try:
if verbose(): print("try import ",componentName)
- __import__(componentName)
+ importlib.import_module(componentName)
if verbose(): print("import ",componentName," successful")
- except ImportError as e:
+ except ImportError:
#can't import python module componentName
#try to find it in python path
try:
- fp, pathname, description = imp.find_module(componentName)
- if fp:fp.close()
+ _specs = importlib.util.find_spec(componentName)
+ _module = importlib.util.module_from_spec(_specs)
+ _specs.loader.exec_module(_module)
#module file found in path
ret="Component "+componentName+": Python implementation found but it can't be loaded\n"
ret=ret+traceback.format_exc(10)
traceback.print_exc()
print("import ",componentName," not possible")
return ret
-
+
#-------------------------------------------------------------------------
def create_component_instance(self, componentName, instanceName):
comp_iors=""
ret=""
try:
- component=__import__(componentName)
+ component=importlib.import_module(componentName)
factory=getattr(component,componentName)
comp_i=factory(self._orb,
self._poa,
traceback.print_exc()
MESSAGE( "SALOME_Container_i::create_component_instance : NOT OK")
return comp_iors, ret
-
+
def create_pynode(self,nodeName,code):
try:
#
import os
import sys
-import string
+import importlib
from omniORB import CORBA, PortableServer
-import SALOMEDS
+import SALOMEDS
import Engines, Engines__POA
import salome_psutil
from SALOME_NamingServicePy import *
self._numInstance = self._numInstance +1
instanceName = nameToRegister + "_inst_" + repr(self._numInstance)
- component=__import__(componentName)
+ component=importlib.import_module(componentName)
factory=getattr(component,componentName)
comp_i=factory(self._orb, self._poa, self._this(), self._containerName,
instanceName, nameToRegister)
exec(the_command)
comp_o = comp_i._this()
return comp_o
-
+
#-------------------------------------------------------------------------
-
+
def import_component(self, componentName):
MESSAGE( "SALOME_Container_i::import_component" )
reason = ""
try:
if verbose(): print("try import %s" % componentName)
# try import component
- module=__import__(componentName)
+ module=importlib.import_module(componentName)
if verbose(): print("import %s is done successfully" % componentName)
# if import successfully, check that component is loadable
if not hasattr(module, componentName):
interfaceName = componentName
reason = self.import_component(componentName)
return reason == "", reason
-
+
#-------------------------------------------------------------------------
def create_component_instance_env(self, componentName, env):
instanceName = componentName + "_inst_" + repr(self._numInstance)
comp_iors=""
try:
- component=__import__(componentName)
+ component=importlib.import_module(componentName)
factory=getattr(component,componentName)
comp_i=factory(self._orb,
self._poa,
self._containerName,
instanceName,
componentName)
-
+
MESSAGE( "SALOME_Container_i::create_component_instance : OK")
comp_o = comp_i._this()
self._listInstances_map[instanceName] = comp_i
anEngine = self._listInstances_map[instance]
return anEngine._this()
return anEngine
-
+
#-------------------------------------------------------------------------
def create_python_service_instance(self, CompName):
return self.create_component_instance(CompName)
-
+
#-------------------------------------------------------------------------
def remove_impl(self, component):
return self._machineName
#-------------------------------------------------------------------------
-
+
def _get_machineName(self):
MESSAGE( "SALOME_ContainerPy_i::_get_MachineName" )
self._machineName = "localhost"
self._naming_service = naming_service
MESSAGE( str(Container_path) )
naming_service.Register(self._this(), Container_path)
-
+
#-------------------------------------------------------------------------
def start_impl(self, ContainerName):
break
num += 1
pass
-
+
shstr += " > "
shstr += fileName
shstr += " 2>&1 &"
-
+
#shstr += " > /tmp/"
#shstr += ContainerName
#shstr += ".log 2>&1 &"
-
+
MESSAGE( "SALOME_ContainerPy_i::start_impl " + "os.system(" + str(shstr) + ")" )
os.system( shstr )
count = 21
SALOME_ContainerPy_Gen_i.__init__(self, orb, poa, containerName)
naming_service = SALOME_Embedded_NamingService()
self._naming_service = naming_service._this()
-
+
def get_embedded_NS_if_ssl(self):
return self._naming_service
MESSAGE( str(sys.argv) )
containerName = sys.argv[1]
cpy_i = SALOME_ContainerPy_i(orb, poa, containerName)
- if verbose():print("SALOME_ContainerPy_i instance created ",cpy_i)
+ if verbose():print("SALOME_ContainerPy_i instance created ",cpy_i)
cpy_o = cpy_i._this()
if verbose():print("SALOME_ContainerPy_i instance activated ",cpy_o)
sys.stdout.flush()
"""
Get a SALOME CORBA component from its name
"""
+ import importlib
print("INF: getting component %s from CORBA module %s ..."%(componentName,corbaModule))
- __import__(corbaModule)
+ importlib.import_module(corbaModule)
component=salome.lcc.FindOrLoadComponent(containerType,componentName)
if component is None:
print("ERR: the SALOME component "+componentName+" can't be reached")
The function functionName is supposed here to return a boolean value
indicating if the test is OK (True) or NOT OK (False)
"""
- moduleName = modulePath.replace('/','.')
- __import__ (moduleName)
+ moduleName = modulePath.replace('/','.')
+ import importlib
+ importlib.import_module(moduleName)
module=sys.modules[moduleName]
func = getattr(module,functionName)
tabsize = 70-len(moduleName)-len(functionName)
- print("[TEST] %s.%s %s test in progress" % (moduleName, functionName,"."*tabsize))
+ print("[TEST] %s.%s %s test in progress" % (moduleName, functionName,"."*tabsize))
ok = func()
if ( ok ):
print("[TEST] %s.%s %s OK" % (moduleName, functionName,"."*tabsize))
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+import importlib
import sys
import unittest
for module in modules:
test_name = '{}_test'.format(module.lower())
try:
- __import__(test_name)
+ importlib.import_module(test_name)
test_module = sys.modules[test_name]
suite.addTest(loader.loadTestsFromModule(test_module))
except ImportError: