1 // Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // SALOME_ParallelContainerProxy : implementation of container and engine for Parallel Kernel
24 // File : SALOME_ParallelContainerProxy_i.cxx
25 // Author : André RIBES, EDF
27 #include "SALOME_ParallelContainerProxy_i.hxx"
29 Container_proxy_impl_final::Container_proxy_impl_final(CORBA::ORB_ptr orb,
30 paco_fabrique_thread * fab_thread,
31 PortableServer::POA_ptr poa,
32 std::string containerName,
33 bool is_a_return_proxy) :
34 Engines::PACO_Container_proxy_impl(orb, fab_thread, is_a_return_proxy),
35 Engines::Container_proxy_impl(orb, fab_thread, is_a_return_proxy),
36 InterfaceManager_impl(orb, fab_thread, is_a_return_proxy)
39 _hostname = Kernel_Utils::GetHostname();
40 _containerName = _NS->BuildContainerNameForNS(containerName.c_str(), _hostname.c_str());
41 _poa = PortableServer::POA::_duplicate(poa);
43 _fab_thread = fab_thread;
45 // Add CORBA object to the poa
46 _id = _poa->activate_object(this);
49 // Init SALOME Naming Service
50 _NS = new SALOME_NamingService();
53 // Init Python container part
54 CORBA::Object_var container_node = _poa->id_to_reference(*_id);
55 CORBA::String_var sior = _orb->object_to_string(container_node);
56 std::string myCommand="pyCont = SALOME_Container.SALOME_Container_i('";
57 myCommand += _containerName + "','";
62 PyRun_SimpleString("import SALOME_Container\n");
63 PyRun_SimpleString((char*)myCommand.c_str());
67 Container_proxy_impl_final:: ~Container_proxy_impl_final() {
73 // _fab_thread not deleted because fab_thread is managed
74 // by paco_fabrique_manager
78 Container_proxy_impl_final::Shutdown()
80 // We Start by destroying all the parallel object
81 std::list<Container_proxy_impl_final::proxy_object>::iterator itm;
82 for (itm = _par_obj_inst_list.begin(); itm != _par_obj_inst_list.end(); itm++)
86 ((*itm).proxy_corba_ref)->destroy();
88 catch(const CORBA::Exception& e)
90 // ignore this entry and continue
94 // ignore this entry and continue
97 // Destroy proxy object... parallel object nodes are
98 // destroyed into the Shutdown of each container nodes
99 _poa->deactivate_object(*((*itm).proxy_id));
101 delete (*itm).proxy_id;
102 if ((*itm).proxy_regist)
103 delete (*itm).proxy_regist;
106 // We call shutdown in each node
107 for (CORBA::ULong i = 0; i < _infos.nodes.length(); i++)
109 MESSAGE("Shutdown work node : " << i);
110 CORBA::Object_var object = _orb->string_to_object(_infos.nodes[i]);
111 Engines::Container_var node = Engines::Container::_narrow(object);
112 if (!CORBA::is_nil(node))
117 MESSAGE("Shutdown done node : " << i);
121 INFOS("Exception catch during Shutdown of node : " << i);
126 INFOS("Cannot shutdown node " << i << " ref is nil !");
130 INFOS("Shutdown Parallel Proxy");
131 _NS->Destroy_FullDirectory(_containerName.c_str());
132 _NS->Destroy_Name(_containerName.c_str());
133 if(!CORBA::is_nil(_orb))
137 // On intercepte cette méthode pour pouvoir ensuite
138 // déterminer si on doit créer une instance sequentielle
139 // ou parallèle d'un composant dans la méthode create_component_instance
141 Container_proxy_impl_final::load_component_Library(const char* componentName, CORBA::String_out reason)
143 MESSAGE("Begin of load_component_Library on proxy : " << componentName);
144 reason=CORBA::string_dup("");
146 std::string aCompName = componentName;
148 CORBA::Boolean ret = true;
149 if (_libtype_map.count(aCompName) == 0)
151 _numInstanceMutex.lock(); // lock to be alone
153 // Default lib is seq
154 _libtype_map[aCompName] = "seq";
156 // --- try dlopen C++ component
157 // If is not a C++ or failed then is maybe
158 // a seq component...
160 MESSAGE("Try to load C++ component");
163 std::string impl_name = string ("lib") + aCompName + string("Engine.dylib");
165 std::string impl_name = string ("lib") + aCompName + string("Engine.so");
168 std::string impl_name = aCompName + string("Engine.dll");
172 handle = dlopen( impl_name.c_str() , RTLD_LAZY | RTLD_GLOBAL ) ;
174 handle = dlopen( impl_name.c_str() , 0 ) ;
178 _library_map[impl_name] = handle;
179 MESSAGE("Library " << impl_name << " loaded");
181 //Test if lib could contain a parallel component
183 std::string paco_test_fct_signature = aCompName + std::string("_isAPACO_Component");
184 INFOS("SIG is : " << paco_test_fct_signature);
185 PACO_TEST_FUNCTION paco_test_fct = NULL;
187 paco_test_fct = (PACO_TEST_FUNCTION)dlsym(handle, paco_test_fct_signature.c_str());
189 paco_test_fct = (PACO_TEST_FUNCTION)GetProcAddress((HINSTANCE)handle, paco_test_fct_signature.c_str());
193 // PaCO Component found
194 MESSAGE("PACO LIB FOUND");
195 _libtype_map[aCompName] = "par";
199 MESSAGE("SEQ LIB FOUND");
201 MESSAGE("dlerror() result is : " << dlerror());
207 MESSAGE("Error in importing Cpp component : " << impl_name);
209 MESSAGE("dlerror() result is : " << dlerror());
212 MESSAGE("Try to import Python component "<<componentName);
215 PyObject *mainmod = PyImport_AddModule("__main__");
216 PyObject *globals = PyModule_GetDict(mainmod);
217 PyObject *pyCont = PyDict_GetItemString(globals, "pyCont");
218 PyObject *result = PyObject_CallMethod(pyCont,
219 (char*)"import_component",
220 (char*)"s",componentName);
221 std::string ret_p= PyUnicode_AsUTF8(result);
225 if (ret_p=="") // import possible: Python component
227 MESSAGE("import Python: " << aCompName <<" OK");
231 MESSAGE("Error in importing Python component : " << aCompName);
235 _numInstanceMutex.unlock();
238 // Call load_component_Library in each node
241 for (CORBA::ULong i = 0; i < _infos.nodes.length(); i++)
243 MESSAGE("Call load_component_Library work node : " << i);
244 CORBA::Object_var object = _orb->string_to_object(_infos.nodes[i]);
245 Engines::Container_var node = Engines::Container::_narrow(object);
246 if (!CORBA::is_nil(node))
251 node->load_component_Library(componentName,reason);
252 MESSAGE("Call load_component_Library done node : " << i);
253 CORBA::string_free(reason);
257 INFOS("Exception catch during load_component_Library of node : " << i);
258 CORBA::string_free(reason);
264 INFOS("Cannot call load_component_Library node " << i << " ref is nil !");
270 // If ret is false -> lib is not loaded !
273 INFOS("Cannot call load_component_Library " << aCompName);
274 _libtype_map.erase(aCompName);
279 Engines::EngineComponent_ptr
280 Container_proxy_impl_final::create_component_instance(const char* componentName)
282 Engines::FieldsDict_var env = new Engines::FieldsDict;
284 Engines::EngineComponent_ptr compo = create_component_instance_env(componentName, env, reason);
285 CORBA::string_free(reason);
290 // Composant sequentiel -> on le créer sur le noeud 0 (on pourrait faire une répartition de charge)
291 // Composant parallèle -> création du proxy ici puis appel de la création de chaque objet participant
292 // au composant parallèle
293 Engines::EngineComponent_ptr
294 Container_proxy_impl_final::create_component_instance_env(const char* componentName,
295 const Engines::FieldsDict& env, CORBA::String_out reason)
297 reason=CORBA::string_dup("");
299 std::string aCompName = componentName;
300 if (_libtype_map.count(aCompName) == 0)
302 // Component is not loaded !
303 INFOS("Proxy: component is not loaded ! : " << aCompName);
304 return Engines::EngineComponent::_nil();
307 // If it is a sequential component
308 if (_libtype_map[aCompName] == "seq")
310 _numInstanceMutex.lock(); // lock on the instance number
312 _numInstanceMutex.unlock();
313 Engines::PACO_Container_proxy_impl::updateInstanceNumber();
314 return Engines::Container_proxy_impl::create_component_instance(componentName);
317 // Parallel Component !
318 Engines::EngineComponent_var component_proxy = Engines::EngineComponent::_nil();
320 // On commence par créer le proxy
323 std::string impl_name = string ("lib") + aCompName + string("Engine.dylib");
325 std::string impl_name = string ("lib") + aCompName + string("Engine.so");
328 std::string impl_name = aCompName + string("Engine.dll");
330 void* handle = _library_map[impl_name];
331 std::string factory_name = aCompName + std::string("EngineProxy_factory");
333 MESSAGE("Creating component proxy : " << factory_name);
334 FACTORY_FUNCTION component_proxy_factory = (FACTORY_FUNCTION) dlsym(handle, factory_name.c_str());
336 if (!component_proxy_factory)
338 INFOS("Can't resolve symbol: " + factory_name);
340 INFOS("dlerror() result is : " << dlerror());
342 return Engines::EngineComponent::_nil() ;
345 _numInstanceMutex.lock() ; // lock on the instance number
347 int numInstance = _numInstance ;
348 _numInstanceMutex.unlock() ;
351 sprintf( aNumI , "%d" , numInstance ) ;
352 string instanceName = aCompName + "_inst_" + aNumI ;
353 string component_registerName = _containerName + "/" + instanceName;
355 // --- Instantiate required CORBA object
356 Container_proxy_impl_final::proxy_object * proxy = new Container_proxy_impl_final::proxy_object();
358 proxy->proxy_id = (component_proxy_factory) (_orb,
362 &(proxy->proxy_regist),
363 instanceName.c_str(),
364 _parallel_object_topology.total);
366 // --- get reference from id
367 CORBA::Object_var obj = _poa->id_to_reference(*(proxy->proxy_id));
368 component_proxy = Engines::EngineComponent::_narrow(obj);
369 proxy->proxy_corba_ref = component_proxy;
371 if (!CORBA::is_nil(component_proxy))
373 _cntInstances_map[impl_name] += 1;
374 _par_obj_inst_list.push_back(*proxy);
377 // --- register the engine under the name
378 // containerName(.dir)/instanceName(.object)
379 _NS->Register(component_proxy , component_registerName.c_str()) ;
380 MESSAGE(component_registerName.c_str() << " bound" ) ;
384 INFOS("The factory returns a nil object !");
385 return Engines::EngineComponent::_nil();
391 INFOS( "Exception caught in Proxy creation" );
392 return Engines::EngineComponent::_nil();
395 // Create on each node a work node
396 for (CORBA::ULong i = 0; i < _infos.nodes.length(); i++)
398 MESSAGE("Call create_paco_component_node_instance on work node : " << i);
399 CORBA::Object_var object = _orb->string_to_object(_infos.nodes[i]);
400 Engines::PACO_Container_var node = Engines::PACO_Container::_narrow(object);
401 if (!CORBA::is_nil(node))
405 node->create_paco_component_node_instance(componentName, _containerName.c_str());
406 MESSAGE("Call create_paco_component_node_instance done on node : " << i);
408 catch (SALOME::SALOME_Exception & ex)
410 INFOS("SALOME_EXCEPTION : " << ex.details.text);
411 return Engines::EngineComponent::_nil();
415 INFOS("Unknown Exception catch during create_paco_component_node_instance on node : " << i);
416 return Engines::EngineComponent::_nil();
421 INFOS("Cannot call create_paco_component_node_instance on node " << i << " ref is nil !");
422 return Engines::EngineComponent::_nil();
426 // Start Parallel object
427 PaCO::InterfaceManager_var paco_proxy = PaCO::InterfaceManager::_narrow(component_proxy);
430 return component_proxy;