1 // Copyright (C) 2006-2019 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include "RuntimeSALOME.hxx"
21 #include "PythonNode.hxx"
22 #include "PythonPorts.hxx"
23 #include "TypeCode.hxx"
24 #include "AutoGIL.hxx"
25 #include "Container.hxx"
26 #include "SalomeContainer.hxx"
27 #include "SalomeHPContainer.hxx"
28 #include "SalomeContainerTmpForHP.hxx"
29 #include "ConversionException.hxx"
31 #include "PyStdout.hxx"
39 #define getpid _getpid
42 #if PY_VERSION_HEX < 0x02050000
43 typedef int Py_ssize_t;
47 #include "YacsTrace.hxx"
49 using namespace YACS::ENGINE;
52 const char PythonEntry::SCRIPT_FOR_SIMPLE_SERIALIZATION[]="import pickle\n"
53 "def pickleForVarSimplePyth2009(val):\n"
54 " return pickle.dumps(val,-1)\n"
57 const char PythonNode::IMPL_NAME[]="Python";
58 const char PythonNode::KIND[]="Python";
60 const char PythonNode::SCRIPT_FOR_SERIALIZATION[]="import pickle\n"
61 "def pickleForDistPyth2009(kws):\n"
62 " return pickle.dumps(((),kws),-1)\n"
64 "def unPickleForDistPyth2009(st):\n"
65 " args=pickle.loads(st)\n"
68 const char PythonNode::REMOTE_NAME[]="remote";
70 const char PythonNode::DPL_INFO_NAME[]="my_dpl_localization";
72 const char PyFuncNode::SCRIPT_FOR_SERIALIZATION[]="import pickle\n"
73 "def pickleForDistPyth2009(*args,**kws):\n"
74 " return pickle.dumps((args,kws),-1)\n"
76 "def unPickleForDistPyth2009(st):\n"
77 " args=pickle.loads(st)\n"
81 PythonEntry::PythonEntry():_context(0),_pyfuncSer(0),_pyfuncUnser(0),_pyfuncSimpleSer(0)
85 PythonEntry::~PythonEntry()
88 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
89 // not Py_XDECREF of _pyfuncUnser because it is returned by PyDict_GetItem -> borrowed
90 // not Py_XDECREF of _pyfuncSer because it is returned by PyDict_GetItem -> borrowed
94 void PythonEntry::commonRemoteLoadPart1(InlineNode *reqNode)
96 DEBTRACE( "---------------PythonEntry::CommonRemoteLoad function---------------" );
97 Container *container(reqNode->getContainer());
98 bool isContAlreadyStarted(false);
101 isContAlreadyStarted=container->isAlreadyStarted(reqNode);
102 if(!isContAlreadyStarted)
106 container->start(reqNode);
110 reqNode->setErrorDetails(e.what());
117 std::string what("PythonEntry::CommonRemoteLoad : a load operation requested on \"");
118 what+=reqNode->getName(); what+="\" with no container specified.";
119 reqNode->setErrorDetails(what);
120 throw Exception(what);
124 Engines::Container_var GetContainerObj(InlineNode *reqNode, bool& isStandardCont)
126 isStandardCont = false;
127 Container *container(reqNode->getContainer());
128 Engines::Container_var objContainer(Engines::Container::_nil());
130 throw YACS::Exception("No container specified !");
131 SalomeContainer *containerCast0(dynamic_cast<SalomeContainer *>(container));
132 SalomeHPContainerBase *containerCast1(dynamic_cast<SalomeHPContainerBase *>(container));
135 isStandardCont = true;
136 objContainer=containerCast0->getContainerPtr(reqNode);
138 else if(containerCast1)
140 objContainer=containerCast1->getContainerPtr(reqNode);
143 throw YACS::Exception("Unrecognized type of container ! Salome one is expected for PythonNode/PyFuncNode !");
144 if(CORBA::is_nil(objContainer))
145 throw YACS::Exception("Container corba pointer is NULL for PythonNode !");
149 Engines::Container_var PythonEntry::commonRemoteLoadPart2(InlineNode *reqNode, bool& isInitializeRequested)
151 bool isStandardCont(true);
152 Engines::Container_var objContainer(GetContainerObj(reqNode,isStandardCont));
153 isInitializeRequested=false;
158 createRemoteAdaptedPyInterpretor(objContainer);
162 Engines::PyNodeBase_var dftPyScript(retrieveDftRemotePyInterpretorIfAny(objContainer));
163 if(CORBA::is_nil(dftPyScript))
165 isInitializeRequested=true;
166 createRemoteAdaptedPyInterpretor(objContainer);
169 assignRemotePyInterpretor(dftPyScript);
172 catch( const SALOME::SALOME_Exception& ex )
174 std::string msg="Exception on remote python node creation ";
176 msg += ex.details.text.in();
177 reqNode->setErrorDetails(msg);
178 throw Exception(msg);
180 Engines::PyNodeBase_var pynode(getRemoteInterpreterHandle());
181 if(CORBA::is_nil(pynode))
182 throw Exception("In PythonNode the ref in NULL ! ");
186 void PythonEntry::commonRemoteLoadPart3(InlineNode *reqNode, Engines::Container_ptr objContainer, bool isInitializeRequested)
188 Container *container(reqNode->getContainer());
189 Engines::PyNodeBase_var pynode(getRemoteInterpreterHandle());
193 const char *picklizeScript(getSerializationScript());
194 PyObject *res=PyRun_String(picklizeScript,Py_file_input,_context,_context);
195 PyObject *res2(PyRun_String(SCRIPT_FOR_SIMPLE_SERIALIZATION,Py_file_input,_context,_context));
196 if(res == NULL || res2==NULL)
198 std::string errorDetails;
199 PyObject* new_stderr = newPyStdOut(errorDetails);
200 reqNode->setErrorDetails(errorDetails);
201 PySys_SetObject((char*)"stderr", new_stderr);
203 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
204 Py_DECREF(new_stderr);
205 throw Exception("Error during load");
207 Py_DECREF(res); Py_DECREF(res2);
208 _pyfuncSer=PyDict_GetItemString(_context,"pickleForDistPyth2009");
209 _pyfuncUnser=PyDict_GetItemString(_context,"unPickleForDistPyth2009");
210 _pyfuncSimpleSer=PyDict_GetItemString(_context,"pickleForVarSimplePyth2009");
211 if(_pyfuncSer == NULL)
213 std::string errorDetails;
214 PyObject *new_stderr(newPyStdOut(errorDetails));
215 reqNode->setErrorDetails(errorDetails);
216 PySys_SetObject((char*)"stderr", new_stderr);
218 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
219 Py_DECREF(new_stderr);
220 throw Exception("Error during load");
222 if(_pyfuncUnser == NULL)
224 std::string errorDetails;
225 PyObject *new_stderr(newPyStdOut(errorDetails));
226 reqNode->setErrorDetails(errorDetails);
227 PySys_SetObject((char*)"stderr", new_stderr);
229 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
230 Py_DECREF(new_stderr);
231 throw Exception("Error during load");
233 if(_pyfuncSimpleSer == NULL)
235 std::string errorDetails;
236 PyObject *new_stderr(newPyStdOut(errorDetails));
237 reqNode->setErrorDetails(errorDetails);
238 PySys_SetObject((char*)"stderr", new_stderr);
240 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
241 Py_DECREF(new_stderr);
242 throw Exception("Error during load");
245 if(isInitializeRequested)
246 {//This one is called only once at initialization in the container if an init-script is specified.
249 std::string zeInitScriptKey(container->getProperty(HomogeneousPoolContainer::INITIALIZE_SCRIPT_KEY));
250 if(!zeInitScriptKey.empty())
251 pynode->executeAnotherPieceOfCode(zeInitScriptKey.c_str());
253 catch( const SALOME::SALOME_Exception& ex )
255 std::string msg="Exception on PythonNode::loadRemote python invocation of initializisation py script !";
257 msg += ex.details.text.in();
258 reqNode->setErrorDetails(msg);
259 throw Exception(msg);
261 DEBTRACE( "---------------End PyNode::loadRemote function---------------" );
265 std::string PythonEntry::GetContainerLog(const std::string& mode, Container *container, const Task *askingTask)
273 SalomeContainer *containerCast(dynamic_cast<SalomeContainer *>(container));
274 SalomeHPContainer *objContainer2(dynamic_cast<SalomeHPContainer *>(container));
277 Engines::Container_var objContainer(containerCast->getContainerPtr(askingTask));
278 CORBA::String_var logname = objContainer->logfilename();
281 std::string::size_type pos = msg.find(":");
282 msg=msg.substr(pos+1);
284 else if(objContainer2)
286 msg="Remote PythonNode is on HP Container : no log because no info of the location by definition of HP Container !";
290 msg="Not implemented yet for container log for that type of container !";
295 msg = "Container no longer reachable";
300 void PythonEntry::commonRemoteLoad(InlineNode *reqNode)
302 commonRemoteLoadPart1(reqNode);
303 bool isInitializeRequested;
304 Engines::Container_var objContainer(commonRemoteLoadPart2(reqNode,isInitializeRequested));
305 commonRemoteLoadPart3(reqNode,objContainer,isInitializeRequested);
308 PythonNode::PythonNode(const PythonNode& other, ComposedNode *father):InlineNode(other,father),_autoSqueeze(other._autoSqueeze)
310 _implementation=IMPL_NAME;
313 _context=PyDict_New();
314 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
317 msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
318 _errorDetails=msg.str();
319 throw Exception(msg.str());
324 PythonNode::PythonNode(const std::string& name):InlineNode(name)
326 _implementation=IMPL_NAME;
329 _context=PyDict_New();
330 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
333 msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
334 _errorDetails=msg.str();
335 throw Exception(msg.str());
340 PythonNode::~PythonNode()
342 if(!CORBA::is_nil(_pynode))
344 _pynode->UnRegister();
348 void PythonNode::checkBasicConsistency() const throw(YACS::Exception)
350 DEBTRACE("checkBasicConsistency");
351 InlineNode::checkBasicConsistency();
355 res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
358 std::string error="";
359 PyObject* new_stderr = newPyStdOut(error);
360 PySys_SetObject((char*)"stderr", new_stderr);
362 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
363 Py_DECREF(new_stderr);
364 throw Exception(error);
371 void PythonNode::load()
373 DEBTRACE( "---------------PyNode::load function---------------" );
374 if(_mode==PythonNode::REMOTE_NAME)
380 void PythonNode::loadLocal()
382 DEBTRACE( "---------------PyNode::loadLocal function---------------" );
386 void PythonNode::loadRemote()
388 commonRemoteLoad(this);
391 void PythonNode::execute()
393 if(_mode==PythonNode::REMOTE_NAME)
399 void PythonNode::executeRemote()
401 DEBTRACE( "++++++++++++++ PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
403 throw Exception("DistributedPythonNode badly loaded");
405 if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
408 commonRemoteLoadPart2(this,dummy);
409 _pynode->assignNewCompiledCode(getScript().c_str());
412 std::unique_ptr<Engines::pickledArgs> serializationInputCorba(new Engines::pickledArgs);
415 PyObject *args(0),*ob(0);
416 //===========================================================================
417 // Get inputs in input ports, build a Python dict and pickle it
418 //===========================================================================
420 std::list<InputPort *>::iterator iter2;
422 for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); ++iter2)
424 InputPyPort *p=(InputPyPort *)*iter2;
426 PyDict_SetItemString(args,p->getName().c_str(),ob);
430 PyObject_Print(args,stderr,Py_PRINT_RAW);
433 PyObject *serializationInput(PyObject_CallFunctionObjArgs(_pyfuncSer,args,NULL));
435 //The pickled string may contain NULL characters so use PyString_AsStringAndSize
436 char *serializationInputC(0);
438 if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
439 throw Exception("DistributedPythonNode problem in python pickle");
440 serializationInputCorba->length(len);
441 for(int i=0; i < len ; i++)
442 (*serializationInputCorba.get())[i]=serializationInputC[i];
443 Py_DECREF(serializationInput);
446 //get the list of output argument names
447 std::list<OutputPort *>::iterator iter;
448 Engines::listofstring myseq;
449 myseq.length(getNumberOfOutputPorts());
451 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
453 OutputPyPort *p=(OutputPyPort *)*iter;
454 myseq[pos]=p->getName().c_str();
455 DEBTRACE( "port name: " << p->getName() );
456 DEBTRACE( "port kind: " << p->edGetType()->kind() );
457 DEBTRACE( "port pos : " << pos );
460 //===========================================================================
461 // Execute in remote Python node
462 //===========================================================================
463 DEBTRACE( "-----------------starting remote python invocation-----------------" );
464 Engines::pickledArgs *resultCorba(nullptr);
467 //pass outargsname and dict serialized
468 resultCorba=_pynode->execute(myseq,*(serializationInputCorba.get()));
470 catch( const SALOME::SALOME_Exception& ex )
472 std::string msg="Exception on remote python invocation";
474 msg += ex.details.text.in();
476 throw Exception(msg);
478 if(!CORBA::is_nil(_pynode))
480 _pynode->UnRegister();
482 serializationInputCorba.reset(nullptr);
483 _pynode = Engines::PyScriptNode::_nil();
486 Engines::Container_var cont(GetContainerObj(this,dummy));
487 cont->removePyScriptNode(getName().c_str());
488 DEBTRACE( "-----------------end of remote python invocation-----------------" );
489 //===========================================================================
490 // Get results, unpickle and put them in output ports
491 //===========================================================================
492 auto length(resultCorba->length());
493 char *resultCorbaC(reinterpret_cast<char *>(resultCorba->get_buffer()));
496 PyObject *args(0),*ob(0);
497 PyObject* resultPython=PyMemoryView_FromMemory(resultCorbaC,length,PyBUF_READ);
498 args = PyTuple_New(1);
499 PyTuple_SetItem(args,0,resultPython);
500 PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
501 delete resultCorba; resultCorba=nullptr;
504 if (finalResult == NULL)
506 std::stringstream msg;
507 msg << "Conversion with pickle of output ports failed !";
508 msg << " : " << __FILE__ << ":" << __LINE__;
509 _errorDetails=msg.str();
510 throw YACS::ENGINE::ConversionException(msg.str());
513 DEBTRACE( "-----------------PythonNode::outputs-----------------" );
515 if(finalResult == Py_None)
517 else if(PyTuple_Check(finalResult))
518 nres=PyTuple_Size(finalResult);
520 if(getNumberOfOutputPorts() != nres)
522 std::string msg="Number of output arguments : Mismatch between definition and execution";
523 Py_DECREF(finalResult);
525 throw Exception(msg);
531 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
533 OutputPyPort *p=(OutputPyPort *)*iter;
534 DEBTRACE( "port name: " << p->getName() );
535 DEBTRACE( "port kind: " << p->edGetType()->kind() );
536 DEBTRACE( "port pos : " << pos );
537 if(PyTuple_Check(finalResult))
538 ob=PyTuple_GetItem(finalResult,pos) ;
541 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
545 Py_DECREF(finalResult);
547 catch(ConversionException& ex)
549 Py_DECREF(finalResult);
550 _errorDetails=ex.what();
554 squeezeMemoryRemote();
556 DEBTRACE( "++++++++++++++ ENDOF PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
559 void PythonNode::executeLocal()
561 DEBTRACE( "++++++++++++++ PyNode::executeLocal: " << getName() << " ++++++++++++++++++++" );
565 DEBTRACE( "---------------PyNode::inputs---------------" );
566 list<InputPort *>::iterator iter2;
567 for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
569 InputPyPort *p=(InputPyPort *)*iter2;
570 DEBTRACE( "port name: " << p->getName() );
571 DEBTRACE( "port kind: " << p->edGetType()->kind() );
572 PyObject* ob=p->getPyObj();
573 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
575 PyObject_Print(ob,stderr,Py_PRINT_RAW);
578 int ier=PyDict_SetItemString(_context,p->getName().c_str(),ob);
579 DEBTRACE( "after PyDict_SetItemString:ob refcnt: " << ob->ob_refcnt );
582 DEBTRACE( "---------------End PyNode::inputs---------------" );
585 DEBTRACE( "----------------PyNode::calculation---------------" );
587 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
589 std::ostringstream stream;
590 stream << "/tmp/PythonNode_";
593 PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
597 PyObject* new_stderr = newPyStdOut(_errorDetails);
598 PySys_SetObject((char*)"stderr", new_stderr);
600 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
601 Py_DECREF(new_stderr);
602 throw Exception("Error during execution");
604 PyObject *res = PyEval_EvalCode( code, _context, _context);
608 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
611 if(PyErr_Occurred ())
614 PyObject* new_stderr = newPyStdOut(_errorDetails);
615 PySys_SetObject((char*)"stderr", new_stderr);
616 ofstream errorfile(stream.str().c_str());
617 if (errorfile.is_open())
619 errorfile << _script;
623 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
624 Py_DECREF(new_stderr);
625 throw Exception("Error during execution");
628 DEBTRACE( "-----------------PyNode::outputs-----------------" );
629 list<OutputPort *>::iterator iter;
632 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
634 OutputPyPort *p=(OutputPyPort *)*iter;
635 DEBTRACE( "port name: " << p->getName() );
636 DEBTRACE( "port kind: " << p->edGetType()->kind() );
637 PyObject *ob=PyDict_GetItemString(_context,p->getName().c_str());
640 std::string msg="Error during execution: there is no variable ";
641 msg=msg+p->getName()+" in node context";
643 throw Exception(msg);
645 DEBTRACE( "PyNode::outputs::ob refcnt: " << ob->ob_refcnt );
647 PyObject_Print(ob,stderr,Py_PRINT_RAW);
653 catch(ConversionException& ex)
655 _errorDetails=ex.what();
660 DEBTRACE( "-----------------End PyNode::outputs-----------------" );
662 DEBTRACE( "++++++++++++++ End PyNode::execute: " << getName() << " ++++++++++++++++++++" );
665 void PythonNode::squeezeMemorySafe()
668 if(_mode==PythonNode::REMOTE_NAME)
669 this->squeezeMemoryRemote();
671 this->squeezeMemory();
674 void PythonNode::squeezeMemory()
676 for(auto p : _setOfInputPort)
678 PyDict_DelItemString(_context,p->getName().c_str());
679 InputPyPort *p2(static_cast<InputPyPort *>(p));
680 if(p2->canSafelySqueezeMemory())
683 for(auto p : _setOfOutputPort)
685 PyDict_DelItemString(_context,p->getName().c_str());
686 OutputPyPort *p2(static_cast<OutputPyPort *>(p));
687 p2->putWithoutForward(Py_None);
691 void PythonNode::squeezeMemoryRemote()
693 for(auto p : _setOfInputPort)
695 InputPyPort *p2(static_cast<InputPyPort *>(p));
696 if(p2->canSafelySqueezeMemory())
699 for(auto p : _setOfOutputPort)
701 OutputPyPort *p2(static_cast<OutputPyPort *>(p));
702 p2->putWithoutForward(Py_None);
706 std::string PythonNode::getContainerLog()
708 return PythonEntry::GetContainerLog(_mode,_container,this);
711 void PythonNode::shutdown(int level)
713 DEBTRACE("PythonNode::shutdown " << level);
714 if(_mode=="local")return;
717 if(!CORBA::is_nil(_pynode)) _pynode->UnRegister();
718 _pynode=Engines::PyScriptNode::_nil();
719 _container->shutdown(level);
723 Node *PythonNode::simpleClone(ComposedNode *father, bool editionOnly) const
725 return new PythonNode(*this,father);
728 void PythonNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
730 if(!CORBA::is_nil(_pynode))
731 _pynode->UnRegister();
732 _pynode=objContainer->createPyScriptNode(getName().c_str(),getScript().c_str());
736 Engines::PyNodeBase_var PythonNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
738 Engines::PyScriptNode_var ret(objContainer->getDefaultPyScriptNode(getName().c_str()));
739 if(!CORBA::is_nil(ret))
743 return Engines::PyNodeBase::_narrow(ret);
746 void PythonNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
748 if(!CORBA::is_nil(_pynode))
750 Engines::PyScriptNode_var tmpp(Engines::PyScriptNode::_narrow(remoteInterp));
751 if(_pynode->_is_equivalent(tmpp))
753 _pynode->UnRegister();
757 if(!CORBA::is_nil(_pynode))
758 _pynode->UnRegister();
759 _pynode=Engines::PyScriptNode::_narrow(remoteInterp);
762 Engines::PyNodeBase_var PythonNode::getRemoteInterpreterHandle()
764 return Engines::PyNodeBase::_narrow(_pynode);
767 //! Create a new node of same type with a given name
768 PythonNode* PythonNode::cloneNode(const std::string& name)
770 PythonNode* n=new PythonNode(name);
771 n->setScript(_script);
772 list<InputPort *>::iterator iter;
773 for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
775 InputPyPort *p=(InputPyPort *)*iter;
776 DEBTRACE( "port name: " << p->getName() );
777 DEBTRACE( "port kind: " << p->edGetType()->kind() );
778 n->edAddInputPort(p->getName(),p->edGetType());
780 list<OutputPort *>::iterator iter2;
781 for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
783 OutputPyPort *p=(OutputPyPort *)*iter2;
784 DEBTRACE( "port name: " << p->getName() );
785 DEBTRACE( "port kind: " << p->edGetType()->kind() );
786 n->edAddOutputPort(p->getName(),p->edGetType());
791 void PythonNode::applyDPLScope(ComposedNode *gfn)
793 std::vector< std::pair<std::string,int> > ret(getDPLScopeInfo(gfn));
800 std::size_t sz(ret.size());
802 for(std::size_t i=0;i<sz;i++)
804 const std::pair<std::string,int>& p(ret[i]);
805 PyObject *elt(PyTuple_New(2));
806 PyTuple_SetItem(elt,0,PyUnicode_FromString(p.first.c_str()));
807 PyTuple_SetItem(elt,1,PyLong_FromLong(p.second));
808 PyList_SetItem(ob,i,elt);
811 if(_mode==REMOTE_NAME)
813 Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);
816 PyObject *serializationInput(PyObject_CallFunctionObjArgs(_pyfuncSimpleSer,ob,NULL));
818 char *serializationInputC(0);
820 if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
821 throw Exception("DistributedPythonNode problem in python pickle");
822 serializationInputCorba->length(len);
823 for(int i=0; i < len ; i++)
824 serializationInputCorba[i]=serializationInputC[i];
825 Py_XDECREF(serializationInput);
827 _pynode->defineNewCustomVar(DPL_INFO_NAME,serializationInputCorba);
832 PyDict_SetItemString(_context,DPL_INFO_NAME,ob);
837 PyFuncNode::PyFuncNode(const PyFuncNode& other, ComposedNode *father):InlineFuncNode(other,father),_pyfunc(0)
839 _implementation = PythonNode::IMPL_NAME;
842 _context=PyDict_New();
843 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
844 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
847 msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
848 _errorDetails=msg.str();
849 throw Exception(msg.str());
854 PyFuncNode::PyFuncNode(const std::string& name): InlineFuncNode(name),_pyfunc(0)
857 _implementation = PythonNode::IMPL_NAME;
858 DEBTRACE( "PyFuncNode::PyFuncNode " << name );
861 _context=PyDict_New();
862 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
863 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
866 msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
867 _errorDetails=msg.str();
868 throw Exception(msg.str());
873 PyFuncNode::~PyFuncNode()
875 if(!CORBA::is_nil(_pynode))
877 _pynode->UnRegister();
881 void PyFuncNode::init(bool start)
883 initCommonPartWithoutStateManagement(start);
884 if(_state == YACS::DISABLED)
886 exDisabledState(); // to refresh propagation of DISABLED state
889 if(start) //complete initialization
890 setState(YACS::READY);
891 else if(_state > YACS::LOADED)// WARNING FuncNode has internal vars (CEA usecase) ! Partial initialization (inside a loop). Exclusivity of funcNode.
892 setState(YACS::TORECONNECT);
895 void PyFuncNode::checkBasicConsistency() const throw(YACS::Exception)
897 DEBTRACE("checkBasicConsistency");
898 InlineFuncNode::checkBasicConsistency();
902 res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
905 std::string error="";
906 PyObject* new_stderr = newPyStdOut(error);
907 PySys_SetObject((char*)"stderr", new_stderr);
909 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
910 Py_DECREF(new_stderr);
911 throw Exception(error);
918 void PyFuncNode::load()
920 DEBTRACE( "---------------PyfuncNode::load function---------------" );
921 if(_mode==PythonNode::REMOTE_NAME)
927 void PyFuncNode::loadRemote()
929 commonRemoteLoad(this);
932 void PyFuncNode::loadLocal()
934 DEBTRACE( "---------------PyFuncNode::load function " << getName() << " ---------------" );
938 list<OutputPort *>::iterator iter;
939 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
941 OutputPyPort *p=(OutputPyPort *)*iter;
942 DEBTRACE( "port name: " << p->getName() );
943 DEBTRACE( "port kind: " << p->edGetType()->kind() );
949 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
951 std::ostringstream stream;
952 stream << "/tmp/PythonNode_";
955 PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
959 PyObject* new_stderr = newPyStdOut(_errorDetails);
960 PySys_SetObject((char*)"stderr", new_stderr);
962 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
963 Py_DECREF(new_stderr);
964 throw Exception("Error during execution");
966 PyObject *res = PyEval_EvalCode( code, _context, _context);
970 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
971 if(PyErr_Occurred ())
974 PyObject* new_stderr = newPyStdOut(_errorDetails);
975 PySys_SetObject((char*)"stderr", new_stderr);
976 ofstream errorfile(stream.str().c_str());
977 if (errorfile.is_open())
979 errorfile << _script;
983 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
984 Py_DECREF(new_stderr);
985 throw Exception("Error during execution");
988 _pyfunc=PyDict_GetItemString(_context,_fname.c_str());
989 DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
993 PyObject* new_stderr = newPyStdOut(_errorDetails);
994 PySys_SetObject((char*)"stderr", new_stderr);
996 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
997 Py_DECREF(new_stderr);
998 throw Exception("Error during execution");
1000 DEBTRACE( "---------------End PyFuncNode::load function---------------" );
1004 void PyFuncNode::execute()
1006 if(_mode==PythonNode::REMOTE_NAME)
1012 void PyFuncNode::executeRemote()
1014 DEBTRACE( "++++++++++++++ PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1016 throw Exception("DistributedPythonNode badly loaded");
1018 if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
1021 commonRemoteLoadPart2(this,dummy);
1022 _pynode->executeAnotherPieceOfCode(getScript().c_str());
1025 Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);;
1029 //===========================================================================
1030 // Get inputs in input ports, build a Python tuple and pickle it
1031 //===========================================================================
1032 PyObject *args(PyTuple_New(getNumberOfInputPorts()));
1034 for(std::list<InputPort *>::iterator iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++,pos++)
1036 InputPyPort *p=(InputPyPort *)*iter2;
1039 PyTuple_SetItem(args,pos,ob);
1042 PyObject_Print(args,stderr,Py_PRINT_RAW);
1045 PyObject *serializationInput=PyObject_CallObject(_pyfuncSer,args);
1047 //The pickled string may contain NULL characters so use PyString_AsStringAndSize
1048 char *serializationInputC(0);
1050 if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
1051 throw Exception("DistributedPythonNode problem in python pickle");
1053 serializationInputCorba->length(len);
1054 for(int i=0; i < len ; i++)
1055 serializationInputCorba[i]=serializationInputC[i];
1056 Py_DECREF(serializationInput);
1059 //===========================================================================
1060 // Execute in remote Python node
1061 //===========================================================================
1062 DEBTRACE( "-----------------starting remote python invocation-----------------" );
1063 Engines::pickledArgs_var resultCorba;
1066 resultCorba=_pynode->execute(getFname().c_str(),serializationInputCorba);
1068 catch( const SALOME::SALOME_Exception& ex )
1070 std::string msg="Exception on remote python invocation";
1072 msg += ex.details.text.in();
1074 throw Exception(msg);
1076 DEBTRACE( "-----------------end of remote python invocation-----------------" );
1077 //===========================================================================
1078 // Get results, unpickle and put them in output ports
1079 //===========================================================================
1080 char *resultCorbaC=new char[resultCorba->length()+1];
1081 resultCorbaC[resultCorba->length()]='\0';
1082 for(int i=0;i<resultCorba->length();i++)
1083 resultCorbaC[i]=resultCorba[i];
1088 PyObject *resultPython(PyBytes_FromStringAndSize(resultCorbaC,resultCorba->length()));
1089 delete [] resultCorbaC;
1090 PyObject *args(PyTuple_New(1)),*ob(0);
1091 PyTuple_SetItem(args,0,resultPython);
1092 PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
1095 DEBTRACE( "-----------------PythonNode::outputs-----------------" );
1097 if(finalResult == Py_None)
1099 else if(PyTuple_Check(finalResult))
1100 nres=PyTuple_Size(finalResult);
1102 if(getNumberOfOutputPorts() != nres)
1104 std::string msg="Number of output arguments : Mismatch between definition and execution";
1105 Py_DECREF(finalResult);
1107 throw Exception(msg);
1113 for(std::list<OutputPort *>::iterator iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++, pos++)
1115 OutputPyPort *p=(OutputPyPort *)*iter;
1116 DEBTRACE( "port name: " << p->getName() );
1117 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1118 DEBTRACE( "port pos : " << pos );
1119 if(PyTuple_Check(finalResult))
1120 ob=PyTuple_GetItem(finalResult,pos) ;
1123 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1126 Py_DECREF(finalResult);
1128 catch(ConversionException& ex)
1130 Py_DECREF(finalResult);
1131 _errorDetails=ex.what();
1136 DEBTRACE( "++++++++++++++ ENDOF PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1139 void PyFuncNode::executeLocal()
1141 DEBTRACE( "++++++++++++++ PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1145 if(!_pyfunc)throw Exception("PyFuncNode badly loaded");
1148 DEBTRACE( "---------------PyFuncNode::inputs---------------" );
1149 PyObject* args = PyTuple_New(getNumberOfInputPorts()) ;
1150 list<InputPort *>::iterator iter2;
1151 for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
1153 InputPyPort *p=(InputPyPort *)*iter2;
1154 DEBTRACE( "port name: " << p->getName() );
1155 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1158 PyObject_Print(ob,stderr,Py_PRINT_RAW);
1161 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1163 PyTuple_SetItem(args,pos,ob);
1164 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1167 DEBTRACE( "---------------End PyFuncNode::inputs---------------" );
1169 DEBTRACE( "----------------PyFuncNode::calculation---------------" );
1171 PyObject_Print(_pyfunc,stderr,Py_PRINT_RAW);
1173 PyObject_Print(args,stderr,Py_PRINT_RAW);
1176 DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1177 PyObject* result = PyObject_CallObject( _pyfunc , args ) ;
1178 DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1185 PyObject* new_stderr = newPyStdOut(_errorDetails);
1186 PySys_SetObject((char*)"stderr", new_stderr);
1187 std::ostringstream stream;
1188 stream << "/tmp/PythonNode_";
1190 ofstream errorfile(stream.str().c_str());
1191 if (errorfile.is_open())
1193 errorfile << _script;
1197 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1198 Py_DECREF(new_stderr);
1199 throw Exception("Error during execution");
1201 DEBTRACE( "----------------End PyFuncNode::calculation---------------" );
1203 DEBTRACE( "-----------------PyFuncNode::outputs-----------------" );
1205 if(result == Py_None)
1207 else if(PyTuple_Check(result))
1208 nres=PyTuple_Size(result);
1210 if(getNumberOfOutputPorts() != nres)
1212 std::string msg="Number of output arguments : Mismatch between definition and execution";
1215 throw Exception(msg);
1220 PyObject_Print(result,stderr,Py_PRINT_RAW);
1223 list<OutputPort *>::iterator iter;
1226 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
1228 OutputPyPort *p=(OutputPyPort *)*iter;
1229 DEBTRACE( "port name: " << p->getName() );
1230 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1231 DEBTRACE( "port pos : " << pos );
1232 if(PyTuple_Check(result))ob=PyTuple_GetItem(result,pos) ;
1234 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1236 PyObject_Print(ob,stderr,Py_PRINT_RAW);
1243 catch(ConversionException& ex)
1246 _errorDetails=ex.what();
1249 DEBTRACE( "-----------------End PyFuncNode::outputs-----------------" );
1252 DEBTRACE( "++++++++++++++ End PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1255 Node *PyFuncNode::simpleClone(ComposedNode *father, bool editionOnly) const
1257 return new PyFuncNode(*this,father);
1260 void PyFuncNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
1262 if(!CORBA::is_nil(_pynode))
1263 _pynode->UnRegister();
1264 _pynode=objContainer->createPyNode(getName().c_str(),getScript().c_str());
1267 Engines::PyNodeBase_var PyFuncNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
1269 Engines::PyNode_var ret(objContainer->getDefaultPyNode(getName().c_str()));
1270 if(!CORBA::is_nil(ret))
1274 return Engines::PyNodeBase::_narrow(ret);
1277 void PyFuncNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
1279 if(!CORBA::is_nil(_pynode))
1281 Engines::PyNode_var tmpp(Engines::PyNode::_narrow(remoteInterp));
1282 if(_pynode->_is_equivalent(tmpp))
1285 if(!CORBA::is_nil(_pynode))
1286 _pynode->UnRegister();
1287 _pynode=Engines::PyNode::_narrow(remoteInterp);
1290 Engines::PyNodeBase_var PyFuncNode::getRemoteInterpreterHandle()
1292 return Engines::PyNodeBase::_narrow(_pynode);
1295 //! Create a new node of same type with a given name
1296 PyFuncNode* PyFuncNode::cloneNode(const std::string& name)
1298 PyFuncNode* n=new PyFuncNode(name);
1299 n->setScript(_script);
1300 n->setFname(_fname);
1301 list<InputPort *>::iterator iter;
1302 for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
1304 InputPyPort *p=(InputPyPort *)*iter;
1305 n->edAddInputPort(p->getName(),p->edGetType());
1307 list<OutputPort *>::iterator iter2;
1308 for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
1310 OutputPyPort *p=(OutputPyPort *)*iter2;
1311 n->edAddOutputPort(p->getName(),p->edGetType());
1316 std::string PyFuncNode::getContainerLog()
1318 return PythonEntry::GetContainerLog(_mode,_container,this);
1321 void PyFuncNode::shutdown(int level)
1323 DEBTRACE("PyFuncNode::shutdown " << level);
1324 if(_mode=="local")return;
1327 if(!CORBA::is_nil(_pynode)) _pynode->UnRegister();
1328 _pynode=Engines::PyNode::_nil();
1329 _container->shutdown(level);