1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, 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 + "','";
60 Py_ACQUIRE_NEW_THREAD;
61 PyRun_SimpleString("import SALOME_Container\n");
62 PyRun_SimpleString((char*)myCommand.c_str());
63 Py_RELEASE_NEW_THREAD;
66 Container_proxy_impl_final:: ~Container_proxy_impl_final() {
72 // _fab_thread not deleted beacause fab_thread is managed
73 // by paco_fabrique_manager
77 Container_proxy_impl_final::Shutdown()
79 // We Start by destroying all the parallel object
80 std::list<Container_proxy_impl_final::proxy_object>::iterator itm;
81 for (itm = _par_obj_inst_list.begin(); itm != _par_obj_inst_list.end(); itm++)
85 ((*itm).proxy_corba_ref)->destroy();
87 catch(const CORBA::Exception& e)
89 // ignore this entry and continue
93 // ignore this entry and continue
96 // Destroy proxy object... parallel object nodes are
97 // destroyed into the Shutdown of each container nodes
98 _poa->deactivate_object(*((*itm).proxy_id));
100 delete (*itm).proxy_id;
101 if ((*itm).proxy_regist)
102 delete (*itm).proxy_regist;
105 // We call shutdown in each node
106 for (CORBA::ULong i = 0; i < _infos.nodes.length(); i++)
108 MESSAGE("Shutdown work node : " << i);
109 CORBA::Object_var object = _orb->string_to_object(_infos.nodes[i]);
110 Engines::Container_var node = Engines::Container::_narrow(object);
111 if (!CORBA::is_nil(node))
116 MESSAGE("Shutdown done node : " << i);
120 INFOS("Exception catch during Shutdown of node : " << i);
125 INFOS("Cannot shutdown node " << i << " ref is nil !");
129 INFOS("Shutdown Parallel Proxy");
130 _NS->Destroy_FullDirectory(_containerName.c_str());
131 _NS->Destroy_Name(_containerName.c_str());
132 if(!CORBA::is_nil(_orb))
136 // On intercepte cette méthode pour pouvoir ensuite
137 // déterminer si on doit créer une instance sequentielle
138 // ou parallèle d'un composant dans la méthode create_component_instance
140 Container_proxy_impl_final::load_component_Library(const char* componentName, CORBA::String_out reason)
142 MESSAGE("Begin of load_component_Library on proxy : " << componentName);
143 reason=CORBA::string_dup("");
145 std::string aCompName = componentName;
147 CORBA::Boolean ret = true;
148 if (_libtype_map.count(aCompName) == 0)
150 _numInstanceMutex.lock(); // lock to be alone
152 // Default lib is seq
153 _libtype_map[aCompName] = "seq";
155 // --- try dlopen C++ component
156 // If is not a C++ or failed then is maybe
157 // a seq component...
159 MESSAGE("Try to load C++ component");
161 std::string impl_name = string ("lib") + aCompName + string("Engine.so");
163 std::string impl_name = aCompName + string("Engine.dll");
167 handle = dlopen( impl_name.c_str() , RTLD_LAZY ) ;
169 handle = dlopen( impl_name.c_str() , 0 ) ;
173 _library_map[impl_name] = handle;
174 MESSAGE("Library " << impl_name << " loaded");
176 //Test if lib could contain a parallel component
178 std::string paco_test_fct_signature = aCompName + std::string("_isAPACO_Component");
179 INFOS("SIG is : " << paco_test_fct_signature);
180 PACO_TEST_FUNCTION paco_test_fct = NULL;
182 paco_test_fct = (PACO_TEST_FUNCTION)dlsym(handle, paco_test_fct_signature.c_str());
184 paco_test_fct = (PACO_TEST_FUNCTION)GetProcAddress((HINSTANCE)handle, paco_test_fct_signature.c_str());
188 // PaCO Component found
189 MESSAGE("PACO LIB FOUND");
190 _libtype_map[aCompName] = "par";
194 MESSAGE("SEQ LIB FOUND");
196 MESSAGE("dlerror() result is : " << dlerror());
202 MESSAGE("Error in importing Cpp component : " << impl_name);
204 MESSAGE("dlerror() result is : " << dlerror());
207 MESSAGE("Try to import Python component "<<componentName);
208 Py_ACQUIRE_NEW_THREAD;
209 PyObject *mainmod = PyImport_AddModule("__main__");
210 PyObject *globals = PyModule_GetDict(mainmod);
211 PyObject *pyCont = PyDict_GetItemString(globals, "pyCont");
212 PyObject *result = PyObject_CallMethod(pyCont,
213 (char*)"import_component",
214 (char*)"s",componentName);
215 std::string ret_p= PyString_AsString(result);
217 Py_RELEASE_NEW_THREAD;
219 if (ret_p=="") // import possible: Python component
221 MESSAGE("import Python: " << aCompName <<" OK");
225 MESSAGE("Error in importing Python component : " << aCompName);
229 _numInstanceMutex.unlock();
232 // Call load_component_Library in each node
235 for (CORBA::ULong i = 0; i < _infos.nodes.length(); i++)
237 MESSAGE("Call load_component_Library work node : " << i);
238 CORBA::Object_var object = _orb->string_to_object(_infos.nodes[i]);
239 Engines::Container_var node = Engines::Container::_narrow(object);
240 if (!CORBA::is_nil(node))
245 node->load_component_Library(componentName,reason);
246 MESSAGE("Call load_component_Library done node : " << i);
247 CORBA::string_free(reason);
251 INFOS("Exception catch during load_component_Library of node : " << i);
252 CORBA::string_free(reason);
258 INFOS("Cannot call load_component_Library node " << i << " ref is nil !");
264 // If ret is false -> lib is not loaded !
267 INFOS("Cannot call load_component_Library " << aCompName);
268 _libtype_map.erase(aCompName);
273 Engines::EngineComponent_ptr
274 Container_proxy_impl_final::create_component_instance(const char* componentName)
276 Engines::FieldsDict_var env = new Engines::FieldsDict;
278 Engines::EngineComponent_ptr compo = create_component_instance_env(componentName, env, reason);
279 CORBA::string_free(reason);
284 // Composant sequentiel -> on le créer sur le noeud 0 (on pourrait faire une répartition de charge)
285 // Composant parallèle -> création du proxy ici puis appel de la création de chaque objet participant
286 // au composant parallèle
287 Engines::EngineComponent_ptr
288 Container_proxy_impl_final::create_component_instance_env(const char* componentName,
289 const Engines::FieldsDict& env, CORBA::String_out reason)
291 reason=CORBA::string_dup("");
293 std::string aCompName = componentName;
294 if (_libtype_map.count(aCompName) == 0)
296 // Component is not loaded !
297 INFOS("Proxy: component is not loaded ! : " << aCompName);
298 return Engines::EngineComponent::_nil();
301 // If it is a sequential component
302 if (_libtype_map[aCompName] == "seq")
304 _numInstanceMutex.lock(); // lock on the instance number
306 _numInstanceMutex.unlock();
307 Engines::PACO_Container_proxy_impl::updateInstanceNumber();
308 return Engines::Container_proxy_impl::create_component_instance(componentName);
311 // Parallel Component !
312 Engines::EngineComponent_var component_proxy = Engines::EngineComponent::_nil();
314 // On commence par créer le proxy
316 std::string impl_name = string ("lib") + aCompName + string("Engine.so");
318 std::string impl_name = aCompName + string("Engine.dll");
320 void* handle = _library_map[impl_name];
321 std::string factory_name = aCompName + std::string("EngineProxy_factory");
323 MESSAGE("Creating component proxy : " << factory_name);
324 FACTORY_FUNCTION component_proxy_factory = (FACTORY_FUNCTION) dlsym(handle, factory_name.c_str());
326 if (!component_proxy_factory)
328 INFOS("Can't resolve symbol: " + factory_name);
330 INFOS("dlerror() result is : " << dlerror());
332 return Engines::EngineComponent::_nil() ;
335 _numInstanceMutex.lock() ; // lock on the instance number
337 int numInstance = _numInstance ;
338 _numInstanceMutex.unlock() ;
341 sprintf( aNumI , "%d" , numInstance ) ;
342 string instanceName = aCompName + "_inst_" + aNumI ;
343 string component_registerName = _containerName + "/" + instanceName;
345 // --- Instanciate required CORBA object
346 Container_proxy_impl_final::proxy_object * proxy = new Container_proxy_impl_final::proxy_object();
348 proxy->proxy_id = (component_proxy_factory) (_orb,
352 &(proxy->proxy_regist),
353 instanceName.c_str(),
354 _parallel_object_topology.total);
356 // --- get reference from id
357 CORBA::Object_var obj = _poa->id_to_reference(*(proxy->proxy_id));
358 component_proxy = Engines::EngineComponent::_narrow(obj);
359 proxy->proxy_corba_ref = component_proxy;
361 if (!CORBA::is_nil(component_proxy))
363 _cntInstances_map[impl_name] += 1;
364 _par_obj_inst_list.push_back(*proxy);
367 // --- register the engine under the name
368 // containerName(.dir)/instanceName(.object)
369 _NS->Register(component_proxy , component_registerName.c_str()) ;
370 MESSAGE(component_registerName.c_str() << " bound" ) ;
374 INFOS("The factory returns a nil object !");
375 return Engines::EngineComponent::_nil();
381 INFOS( "Exception catched in Proxy creation" );
382 return Engines::EngineComponent::_nil();
385 // Create on each node a work node
386 for (CORBA::ULong i = 0; i < _infos.nodes.length(); i++)
388 MESSAGE("Call create_paco_component_node_instance on work node : " << i);
389 CORBA::Object_var object = _orb->string_to_object(_infos.nodes[i]);
390 Engines::PACO_Container_var node = Engines::PACO_Container::_narrow(object);
391 if (!CORBA::is_nil(node))
395 node->create_paco_component_node_instance(componentName, _containerName.c_str());
396 MESSAGE("Call create_paco_component_node_instance done on node : " << i);
398 catch (SALOME::SALOME_Exception & ex)
400 INFOS("SALOME_EXCEPTION : " << ex.details.text);
401 return Engines::EngineComponent::_nil();
405 INFOS("Unknown Exception catch during create_paco_component_node_instance on node : " << i);
406 return Engines::EngineComponent::_nil();
411 INFOS("Cannot call create_paco_component_node_instance on node " << i << " ref is nil !");
412 return Engines::EngineComponent::_nil();
416 // Start Parallel object
417 PaCO::InterfaceManager_var paco_proxy = PaCO::InterfaceManager::_narrow(component_proxy);
420 return component_proxy;