-// Copyright (C) 2006-2016 CEA/DEN, EDF R&D
+// Copyright (C) 2006-2021 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
#ifdef SALOME_KERNEL
#include "SALOME_NamingService.hxx"
#include "SALOME_LifeCycleCORBA.hxx"
+#include "SALOME_NamingService.hxx"
+#include "SALOME_ResourcesManager.hxx"
+#include "SALOME_ContainerManager.hxx"
+#include "SALOMEconfig.h"
+#include CORBA_CLIENT_HEADER(SALOME_ContainerManager)
+
#endif
#include <libxml/parser.h>
RuntimeSALOME* YACS::ENGINE::getSALOMERuntime()
{
- YASSERT(Runtime::_singleton);
- return dynamic_cast< RuntimeSALOME* >(Runtime::_singleton);
+ YASSERT(RuntimeSALOME::getSingleton());
+ return dynamic_cast< RuntimeSALOME* >(RuntimeSALOME::getSingleton());
}
/**
Py_InitializeEx(0); // do not install signal handlers
#endif
if (argc > 0 && argv != NULL)
- PySys_SetArgv(argc, argv);
+ {
+ wchar_t **changed_argv = new wchar_t*[argc];
+ for (int i = 0; i < argc; i++)
+ {
+ changed_argv[i] = Py_DecodeLocale(argv[i], NULL);
+ }
+ PySys_SetArgv(argc, changed_argv);
+ }
else
{
int pyArgc = 1;
char* pyArgv[1];
char defaultName[] = "SALOME_YACS_RUNTIME";
+ wchar_t **changed_pyArgv = new wchar_t*[pyArgc];
pyArgv[0] = defaultName;
- PySys_SetArgv(pyArgc, pyArgv);
+ for (int i = 0; i < pyArgc; i++)
+ {
+ changed_pyArgv[i] = Py_DecodeLocale(pyArgv[i], NULL);
+ }
+ PySys_SetArgv(pyArgc, changed_pyArgv);
}
+#if PY_VERSION_HEX < 0x03070000
PyEval_InitThreads(); /* Create (and acquire) the interpreter lock (for threads)*/
+#endif
PyEval_SaveThread(); /* Release the thread state */
//here we do not have the Global Interpreter Lock
}
if (PyDict_GetItemString(globals, "__builtins__") == NULL)
{
- PyObject *bimod = PyImport_ImportModule("__builtin__");
+ PyObject *bimod = PyImport_ImportModule("builtins");
if (bimod == NULL || PyDict_SetItemString(globals, "__builtins__", bimod) != 0)
Py_FatalError("can't add __builtins__ to __main__");
Py_DECREF(bimod);
{
goto out;
}
- _api = (omniORBpyAPI*)PyCObject_AsVoidPtr(pyapi);
+ _api = (omniORBpyAPI*)PyCapsule_GetPointer(pyapi,"_omnipy.API");
Py_DECREF(pyapi);
res=PyRun_String("\n"
"from omniORB import CORBA\n"
"from omniORB import any\n"
"orb = CORBA.ORB_init([], CORBA.ORB_ID)\n"
- "#print sys.getrefcount(orb)\n"
+ "#print(sys.getrefcount(orb))\n"
"try:\n"
" import SALOME\n"
"except:\n"
}
}
+std::vector< std::pair<std::string,int> > RuntimeSALOME::getCatalogOfComputeNodes() const
+{
+ CORBA::ORB_ptr orb(getOrb());
+ SALOME_NamingService namingService;
+ try
+ {
+ namingService.init_orb(orb);
+ }
+ catch(SALOME_Exception& e)
+ {
+ throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Unable to contact the SALOME Naming Service");
+ }
+ CORBA::Object_var obj(namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS));
+ if(CORBA::is_nil(obj))
+ throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Unable to access to the resource manager !");
+ Engines::ResourcesManager_var resManager(Engines::ResourcesManager::_narrow(obj));
+ if(CORBA::is_nil(resManager))
+ throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Internal error ! The entry attached to the res manager in NS does not have right type !");
+ std::vector< std::pair<std::string,int> > ret;
+ Engines::ResourceParameters params;
+ params.name = "";
+ params.hostname = "";
+ params.OS = "";
+ params.nb_proc = 0;
+ params.mem_mb = 0;
+ params.cpu_clock = 0;
+ params.nb_node = 0;
+ params.nb_proc_per_node = 0;
+ params.policy = "";
+ params.can_launch_batch_jobs = false;
+ params.can_run_containers = true;
+ params.componentList.length(0);
+ try
+ {
+ Engines::ResourceList_var resourceList;
+ resourceList = resManager->GetFittingResources(params);
+ ret.reserve(resourceList->length());
+ for(int i = 0; i<resourceList->length(); i++)
+ {
+ const char* resource_name = resourceList[i];
+ std::string std_resource_name = resource_name;
+ Engines::ResourceDefinition_var resource_definition
+ = resManager->GetResourceDefinition(resource_name);
+ int nb_cores = resource_definition->nb_node *
+ resource_definition->nb_proc_per_node;
+ ret.push_back(std::pair<std::string,int>(resource_name, nb_cores));
+ }
+ }
+ catch(SALOME::SALOME_Exception& e)
+ {
+ std::string message;
+ message=e.details.text.in();
+ throw Exception(message);
+ }
+
+ return ret;
+}
+
std::string RuntimeSALOME::getVersion() const
{
#ifdef YACS_DEVELOPMENT
*/
InputPort* RuntimeSALOME::adapt(InputPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
string imp_source=source->getNode()->getImplementation();
if(imp_source == PythonNode::IMPL_NAME)
*/
InputPort* RuntimeSALOME::adapt(InPropertyPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
return adaptNeutral((InputPort *)source,impl,type,init);
}
* \return an adaptated input port of type InputCorbaPort
*/
InputPort* RuntimeSALOME::adaptNeutralToCorba(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptNeutralToPython(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
//convertible type
return new PyNeutral(inport);
}
+ //last chance : an py output that is seq[objref] can be connected to a neutral input objref (P13268)
+ else if(type->kind()==Sequence && type->contentType()->kind()==Objref && inport->edGetType()->kind()==Objref)
+ {
+ return new PyNeutral(inport);
+ }
//non convertible type
stringstream msg;
msg << "Cannot connect Python output port with type: " << type->id() ;
* \return an input port of type InputXmlPort
*/
InputPort* RuntimeSALOME::adaptNeutralToXml(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
* \return an input port of type InputCppPort
*/
InputPort* RuntimeSALOME::adaptNeutralToCpp(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptNeutralToCpp(InputPort* inport" );
if(isAdaptableNeutralCpp(type,inport->edGetType()))
*/
InputPort* RuntimeSALOME::adaptNeutral(InputPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CppNode::IMPL_NAME)
{
*/
InputPort* RuntimeSALOME::adaptXmlToCorba(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(isAdaptableXmlCorba(type,inport->edGetType()))
{
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptXmlToPython(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->isAdaptable(type))
{
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptXmlToCpp(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptXmlToCpp(InputPort* inport" );
DEBTRACE(type->kind() << " " << inport->edGetType()->kind() );
* \return an adaptated input port of type Neutralxxxx
*/
InputPort* RuntimeSALOME::adaptXmlToNeutral(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->isAdaptable(type))
{
* \return an adaptated input port of type Xmlxxxx
*/
InputPort* RuntimeSALOME::adaptXmlToXml(InputXmlPort* inport,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(init)
return new ProxyPort(inport);
InputPort* RuntimeSALOME::adapt(InputXmlPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CORBANode::IMPL_NAME)
{
* \return an adaptator port of type InputCORBAPort
*/
InputPort* RuntimeSALOME::adaptCorbaToCorba(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(type->isA(inport->edGetType()))
{
*/
InputPort* RuntimeSALOME::adaptCorbaToPython(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
*/
InputPort* RuntimeSALOME::adaptCorbaToXml(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
*/
InputPort* RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport" );
if(isAdaptableCorbaCpp(type,inport->edGetType()))
*/
InputPort* RuntimeSALOME::adaptCorbaToNeutral(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
InputPort* RuntimeSALOME::adapt(InputCorbaPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CppNode::IMPL_NAME)
{
*/
InputPort* RuntimeSALOME::adaptPythonToPython(InputPyPort* inport,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(init)
return new PyInit(inport);
*/
InputPort* RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport" );
if(isAdaptablePyObjectCpp(type,inport->edGetType()))
*/
InputPort* RuntimeSALOME::adaptPythonToNeutral(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
*/
InputPort* RuntimeSALOME::adaptPythonToCorba(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
*/
InputPort* RuntimeSALOME::adaptPythonToXml(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
InputPort* RuntimeSALOME::adapt(InputPyPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CppNode::IMPL_NAME)
{
*/
InputPort* RuntimeSALOME::adaptCppToCorba(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToCorba(InputCppPort* inport)");
if(isAdaptableCppCorba(type,inport->edGetType()))
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptCppToPython(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToPython(InputCppPort* inport)");
if(isAdaptableCppPyObject(type,inport->edGetType()))
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptCppToCpp(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToCpp(InputPort* inport" );
DEBTRACE(type->kind() << " " << inport->edGetType()->kind() );
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptCppToNeutral(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToNeutral(InputPort* inport" );
DEBTRACE(type->kind() << " " << inport->edGetType()->kind() );
}
InputPort* RuntimeSALOME::adaptCppToXml(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToXml(InputCppPort* inport" );
if(isAdaptableCppXml(type,inport->edGetType()))
InputPort* RuntimeSALOME::adapt(InputCppPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
DEBTRACE("RuntimeSALOME::adapt(InputCppPort* source)");
if(impl == CORBANode::IMPL_NAME)
// return result;
// }
-CORBA::ORB_ptr RuntimeSALOME::getOrb()
+CORBA::ORB_ptr RuntimeSALOME::getOrb() const
{
return _orb;
}
-PyObject * RuntimeSALOME::getPyOrb()
+PyObject * RuntimeSALOME::getPyOrb() const
{
return _pyorb;
}
-PyObject * RuntimeSALOME::getBuiltins()
+PyObject * RuntimeSALOME::getBuiltins() const
{
return _bltins;
}
-DynamicAny::DynAnyFactory_ptr RuntimeSALOME::getDynFactory()
+DynamicAny::DynAnyFactory_ptr RuntimeSALOME::getDynFactory() const
{
return _dynFactory;
}
