]> SALOME platform Git repositories - modules/yacs.git/blob - src/runtime/PythonNode.cxx
Salome HOME
7f004fc9ef80476f9c556954cd46e3d596a62667
[modules/yacs.git] / src / runtime / PythonNode.cxx
1 // Copyright (C) 2006-2019  CEA/DEN, EDF R&D
2 //
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.
7 //
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.
12 //
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
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
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"
30
31 #include "PyStdout.hxx"
32 #include <iostream>
33 #include <sstream>
34 #include <fstream>
35
36 #ifdef WIN32
37 #include <process.h>
38 #define getpid _getpid
39 #endif
40
41 #if PY_VERSION_HEX < 0x02050000 
42 typedef int Py_ssize_t;
43 #endif
44
45 //#define _DEVDEBUG_
46 #include "YacsTrace.hxx"
47
48 using namespace YACS::ENGINE;
49 using namespace std;
50
51 const char PythonEntry::SCRIPT_FOR_SIMPLE_SERIALIZATION[]="import pickle\n"
52     "def pickleForVarSimplePyth2009(val):\n"
53     "  return pickle.dumps(val,-1)\n"
54     "\n";
55
56 const char PythonNode::IMPL_NAME[]="Python";
57 const char PythonNode::KIND[]="Python";
58
59 const char PythonNode::SCRIPT_FOR_SERIALIZATION[]="import pickle\n"
60     "def pickleForDistPyth2009(kws):\n"
61     "  return pickle.dumps(((),kws),-1)\n"
62     "\n"
63     "def unPickleForDistPyth2009(st):\n"
64     "  args=pickle.loads(st)\n"
65     "  return args\n";
66
67 const char PythonNode::REMOTE_NAME[]="remote";
68
69 const char PythonNode::DPL_INFO_NAME[]="my_dpl_localization";
70
71 const char PyFuncNode::SCRIPT_FOR_SERIALIZATION[]="import pickle\n"
72     "def pickleForDistPyth2009(*args,**kws):\n"
73     "  return pickle.dumps((args,kws),-1)\n"
74     "\n"
75     "def unPickleForDistPyth2009(st):\n"
76     "  args=pickle.loads(st)\n"
77     "  return args\n";
78
79
80 PythonEntry::PythonEntry():_context(0),_pyfuncSer(0),_pyfuncUnser(0),_pyfuncSimpleSer(0)
81 {
82 }
83
84 PythonEntry::~PythonEntry()
85 {
86   AutoGIL agil;
87   DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
88   // not Py_XDECREF of _pyfuncUnser because it is returned by PyDict_GetItem -> borrowed
89   // not Py_XDECREF of _pyfuncSer because it is returned by PyDict_GetItem -> borrowed
90   Py_XDECREF(_context);
91 }
92
93 void PythonEntry::commonRemoteLoadPart1(InlineNode *reqNode)
94 {
95   DEBTRACE( "---------------PythonEntry::CommonRemoteLoad function---------------" );
96   Container *container(reqNode->getContainer());
97   bool isContAlreadyStarted(false);
98   if(container)
99     {
100       isContAlreadyStarted=container->isAlreadyStarted(reqNode);
101       if(!isContAlreadyStarted)
102         {
103           try
104           {
105               container->start(reqNode);
106           }
107           catch(Exception& e)
108           {
109               reqNode->setErrorDetails(e.what());
110               throw e;
111           }
112         }
113     }
114   else
115     {
116       std::string what("PythonEntry::CommonRemoteLoad : a load operation requested on \"");
117       what+=reqNode->getName(); what+="\" with no container specified.";
118       reqNode->setErrorDetails(what);
119       throw Exception(what);
120     }
121 }
122
123 Engines::Container_var GetContainerObj(InlineNode *reqNode, bool& isStandardCont)
124 {
125   isStandardCont = false;
126   Container *container(reqNode->getContainer());
127   Engines::Container_var objContainer(Engines::Container::_nil());
128   if(!container)
129     throw YACS::Exception("No container specified !");
130   SalomeContainer *containerCast0(dynamic_cast<SalomeContainer *>(container));
131   SalomeHPContainerBase *containerCast1(dynamic_cast<SalomeHPContainerBase *>(container));
132   if(containerCast0)
133     {
134       isStandardCont = true;
135       objContainer=containerCast0->getContainerPtr(reqNode);
136     }
137   else if(containerCast1)
138     {
139       objContainer=containerCast1->getContainerPtr(reqNode);
140     }
141   else
142     throw YACS::Exception("Unrecognized type of container ! Salome one is expected for PythonNode/PyFuncNode !");
143   if(CORBA::is_nil(objContainer))
144     throw YACS::Exception("Container corba pointer is NULL for PythonNode !");
145   return objContainer;
146 }
147
148 Engines::Container_var PythonEntry::commonRemoteLoadPart2(InlineNode *reqNode, bool& isInitializeRequested)
149 {
150   bool isStandardCont(true);
151   Engines::Container_var objContainer(GetContainerObj(reqNode,isStandardCont));
152   isInitializeRequested=false;
153   try
154   {
155       if(isStandardCont)
156         {
157           createRemoteAdaptedPyInterpretor(objContainer);
158         }
159       else
160         {
161           Engines::PyNodeBase_var dftPyScript(retrieveDftRemotePyInterpretorIfAny(objContainer));
162           if(CORBA::is_nil(dftPyScript))
163             {
164               isInitializeRequested=true;
165               createRemoteAdaptedPyInterpretor(objContainer);
166             }
167           else
168             assignRemotePyInterpretor(dftPyScript);
169         }
170   }
171   catch( const SALOME::SALOME_Exception& ex )
172   {
173       std::string msg="Exception on remote python node creation ";
174       msg += '\n';
175       msg += ex.details.text.in();
176       reqNode->setErrorDetails(msg);
177       throw Exception(msg);
178   }
179   Engines::PyNodeBase_var pynode(getRemoteInterpreterHandle());
180   if(CORBA::is_nil(pynode))
181     throw Exception("In PythonNode the ref in NULL ! ");
182   return objContainer;
183 }
184
185 void PythonEntry::commonRemoteLoadPart3(InlineNode *reqNode, Engines::Container_ptr objContainer, bool isInitializeRequested)
186 {
187   Container *container(reqNode->getContainer());
188   Engines::PyNodeBase_var pynode(getRemoteInterpreterHandle());
189   ///
190   {
191     AutoGIL agil;
192     const char *picklizeScript(getSerializationScript());
193     PyObject *res=PyRun_String(picklizeScript,Py_file_input,_context,_context);
194     PyObject *res2(PyRun_String(SCRIPT_FOR_SIMPLE_SERIALIZATION,Py_file_input,_context,_context));
195     if(res == NULL || res2==NULL)
196       {
197         std::string errorDetails;
198         PyObject* new_stderr = newPyStdOut(errorDetails);
199         reqNode->setErrorDetails(errorDetails);
200         PySys_SetObject((char*)"stderr", new_stderr);
201         PyErr_Print();
202         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
203         Py_DECREF(new_stderr);
204         throw Exception("Error during load");
205       }
206     Py_DECREF(res); Py_DECREF(res2);
207     _pyfuncSer=PyDict_GetItemString(_context,"pickleForDistPyth2009");
208     _pyfuncUnser=PyDict_GetItemString(_context,"unPickleForDistPyth2009");
209     _pyfuncSimpleSer=PyDict_GetItemString(_context,"pickleForVarSimplePyth2009");
210     if(_pyfuncSer == NULL)
211       {
212         std::string errorDetails;
213         PyObject *new_stderr(newPyStdOut(errorDetails));
214         reqNode->setErrorDetails(errorDetails);
215         PySys_SetObject((char*)"stderr", new_stderr);
216         PyErr_Print();
217         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
218         Py_DECREF(new_stderr);
219         throw Exception("Error during load");
220       }
221     if(_pyfuncUnser == NULL)
222       {
223         std::string errorDetails;
224         PyObject *new_stderr(newPyStdOut(errorDetails));
225         reqNode->setErrorDetails(errorDetails);
226         PySys_SetObject((char*)"stderr", new_stderr);
227         PyErr_Print();
228         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
229         Py_DECREF(new_stderr);
230         throw Exception("Error during load");
231       }
232     if(_pyfuncSimpleSer == NULL)
233       {
234         std::string errorDetails;
235         PyObject *new_stderr(newPyStdOut(errorDetails));
236         reqNode->setErrorDetails(errorDetails);
237         PySys_SetObject((char*)"stderr", new_stderr);
238         PyErr_Print();
239         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
240         Py_DECREF(new_stderr);
241         throw Exception("Error during load");
242       }
243   }
244   if(isInitializeRequested)
245     {//This one is called only once at initialization in the container if an init-script is specified.
246       try
247       {
248           std::string zeInitScriptKey(container->getProperty(HomogeneousPoolContainer::INITIALIZE_SCRIPT_KEY));
249           if(!zeInitScriptKey.empty())
250             pynode->executeAnotherPieceOfCode(zeInitScriptKey.c_str());
251       }
252       catch( const SALOME::SALOME_Exception& ex )
253       {
254           std::string msg="Exception on PythonNode::loadRemote python invocation of initializisation py script !";
255           msg += '\n';
256           msg += ex.details.text.in();
257           reqNode->setErrorDetails(msg);
258           throw Exception(msg);
259       }
260       DEBTRACE( "---------------End PyNode::loadRemote function---------------" );
261     }
262 }
263
264 std::string PythonEntry::GetContainerLog(const std::string& mode, Container *container, const Task *askingTask)
265 {
266   if(mode=="local")
267     return "";
268
269   std::string msg;
270   try
271   {
272       SalomeContainer *containerCast(dynamic_cast<SalomeContainer *>(container));
273       SalomeHPContainer *objContainer2(dynamic_cast<SalomeHPContainer *>(container));
274       if(containerCast)
275         {
276           Engines::Container_var objContainer(containerCast->getContainerPtr(askingTask));
277           CORBA::String_var logname = objContainer->logfilename();
278           DEBTRACE(logname);
279           msg=logname;
280           std::string::size_type pos = msg.find(":");
281           msg=msg.substr(pos+1);
282         }
283       else if(objContainer2)
284         {
285           msg="Remote PythonNode is on HP Container : no log because no info of the location by definition of HP Container !";
286         }
287       else
288         {
289           msg="Not implemented yet for container log for that type of container !";
290         }
291   }
292   catch(...)
293   {
294       msg = "Container no longer reachable";
295   }
296   return msg;
297 }
298
299 void PythonEntry::commonRemoteLoad(InlineNode *reqNode)
300 {
301   commonRemoteLoadPart1(reqNode);
302   bool isInitializeRequested;
303   Engines::Container_var objContainer(commonRemoteLoadPart2(reqNode,isInitializeRequested));
304   commonRemoteLoadPart3(reqNode,objContainer,isInitializeRequested);
305 }
306
307 PythonNode::PythonNode(const PythonNode& other, ComposedNode *father):InlineNode(other,father),_autoSqueeze(other._autoSqueeze)
308 {
309   _implementation=IMPL_NAME;
310   {
311     AutoGIL agil;
312     _context=PyDict_New();
313     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
314       {
315         stringstream msg;
316         msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
317         _errorDetails=msg.str();
318         throw Exception(msg.str());
319       }
320   }
321 }
322
323 PythonNode::PythonNode(const std::string& name):InlineNode(name)
324 {
325   _implementation=IMPL_NAME;
326   {
327     AutoGIL agil;
328     _context=PyDict_New();
329     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
330       {
331         stringstream msg;
332         msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
333         _errorDetails=msg.str();
334         throw Exception(msg.str());
335       }
336   }
337 }
338
339 PythonNode::~PythonNode()
340 {
341   if(!CORBA::is_nil(_pynode))
342     {
343       _pynode->UnRegister();
344     }
345 }
346
347 void PythonNode::checkBasicConsistency() const throw(YACS::Exception)
348 {
349   DEBTRACE("checkBasicConsistency");
350   InlineNode::checkBasicConsistency();
351   {
352     AutoGIL agil;
353     PyObject* res;
354     res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
355     if(res == NULL)
356       {
357         std::string error="";
358         PyObject* new_stderr = newPyStdOut(error);
359         PySys_SetObject((char*)"stderr", new_stderr);
360         PyErr_Print();
361         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
362         Py_DECREF(new_stderr);
363         throw Exception(error);
364       }
365     else
366       Py_XDECREF(res);
367   }
368 }
369
370 void PythonNode::load()
371 {
372   DEBTRACE( "---------------PyNode::load function---------------" );
373   if(_mode==PythonNode::REMOTE_NAME)
374     loadRemote();
375   else
376     loadLocal();
377 }
378
379 void PythonNode::loadLocal()
380 {
381   DEBTRACE( "---------------PyNode::loadLocal function---------------" );
382   // do nothing
383 }
384
385 void PythonNode::loadRemote()
386 {
387   commonRemoteLoad(this);
388 }
389
390 void PythonNode::execute()
391 {
392   if(_mode==PythonNode::REMOTE_NAME)
393     executeRemote();
394   else
395     executeLocal();
396 }
397
398 void PythonNode::executeRemote()
399 {
400   DEBTRACE( "++++++++++++++ PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
401   if(!_pyfuncSer)
402     throw Exception("DistributedPythonNode badly loaded");
403   //
404   if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
405     {
406       bool dummy;
407       commonRemoteLoadPart2(this,dummy);
408       _pynode->assignNewCompiledCode(getScript().c_str());
409     }
410   //
411   Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);
412   {
413       AutoGIL agil;
414       PyObject *args(0),*ob(0);
415       //===========================================================================
416       // Get inputs in input ports, build a Python dict and pickle it
417       //===========================================================================
418       args = PyDict_New();
419       std::list<InputPort *>::iterator iter2;
420       int pos(0);
421       for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); ++iter2)
422         {
423           InputPyPort *p=(InputPyPort *)*iter2;
424           ob=p->getPyObj();
425           PyDict_SetItemString(args,p->getName().c_str(),ob);
426           pos++;
427         }
428 #ifdef _DEVDEBUG_
429       PyObject_Print(args,stderr,Py_PRINT_RAW);
430       std::cerr << endl;
431 #endif
432       PyObject *serializationInput(PyObject_CallFunctionObjArgs(_pyfuncSer,args,NULL));
433       Py_DECREF(args);
434       //The pickled string may contain NULL characters so use PyString_AsStringAndSize
435       char *serializationInputC(0);
436       Py_ssize_t len;
437       if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
438         throw Exception("DistributedPythonNode problem in python pickle");
439       serializationInputCorba->length(len);
440       for(int i=0; i < len ; i++)
441         serializationInputCorba[i]=serializationInputC[i];
442       Py_DECREF(serializationInput);
443   }
444
445   //get the list of output argument names
446   std::list<OutputPort *>::iterator iter;
447   Engines::listofstring myseq;
448   myseq.length(getNumberOfOutputPorts());
449   int pos=0;
450   for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
451     {
452       OutputPyPort *p=(OutputPyPort *)*iter;
453       myseq[pos]=p->getName().c_str();
454       DEBTRACE( "port name: " << p->getName() );
455       DEBTRACE( "port kind: " << p->edGetType()->kind() );
456       DEBTRACE( "port pos : " << pos );
457       pos++;
458     }
459   //===========================================================================
460   // Execute in remote Python node
461   //===========================================================================
462   DEBTRACE( "-----------------starting remote python invocation-----------------" );
463   Engines::pickledArgs *resultCorba(nullptr);
464   try
465     {
466       //pass outargsname and dict serialized
467       resultCorba=_pynode->execute(myseq,serializationInputCorba);
468     }
469   catch( const SALOME::SALOME_Exception& ex )
470     {
471       std::string msg="Exception on remote python invocation";
472       msg += '\n';
473       msg += ex.details.text.in();
474       _errorDetails=msg;
475       throw Exception(msg);
476     }
477   if(!CORBA::is_nil(_pynode))
478     {
479       _pynode->UnRegister();
480     }
481   _pynode = Engines::PyScriptNode::_nil();
482   //
483   bool dummy;
484   Engines::Container_var cont(GetContainerObj(this,dummy));
485   cont->removePyScriptNode(getName().c_str());
486   DEBTRACE( "-----------------end of remote python invocation-----------------" );
487   //===========================================================================
488   // Get results, unpickle and put them in output ports
489   //===========================================================================
490   auto length(resultCorba->length());
491   char *resultCorbaC=new char[length+1];
492   for(int i=0;i<length;i++)
493     resultCorbaC[i]=(*resultCorba)[i];
494   resultCorbaC[length]='\0';
495   delete resultCorba; resultCorba=nullptr;
496   {
497       AutoGIL agil;
498       PyObject *args(0),*ob(0);
499       PyObject* resultPython=PyMemoryView_FromMemory(resultCorbaC,length,PyBUF_READ);
500       args = PyTuple_New(1);
501       PyTuple_SetItem(args,0,resultPython);
502       PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
503       delete [] resultCorbaC;
504       Py_DECREF(args);
505
506       if (finalResult == NULL)
507         {
508           std::stringstream msg;
509           msg << "Conversion with pickle of output ports failed !";
510           msg << " : " << __FILE__ << ":" << __LINE__;
511           _errorDetails=msg.str();
512           throw YACS::ENGINE::ConversionException(msg.str());
513         }
514
515       DEBTRACE( "-----------------PythonNode::outputs-----------------" );
516       int nres=1;
517       if(finalResult == Py_None)
518         nres=0;
519       else if(PyTuple_Check(finalResult))
520         nres=PyTuple_Size(finalResult);
521
522       if(getNumberOfOutputPorts() != nres)
523         {
524           std::string msg="Number of output arguments : Mismatch between definition and execution";
525           Py_DECREF(finalResult);
526           _errorDetails=msg;
527           throw Exception(msg);
528         }
529
530       pos=0;
531       try
532       {
533           for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
534             {
535               OutputPyPort *p=(OutputPyPort *)*iter;
536               DEBTRACE( "port name: " << p->getName() );
537               DEBTRACE( "port kind: " << p->edGetType()->kind() );
538               DEBTRACE( "port pos : " << pos );
539               if(PyTuple_Check(finalResult))
540                 ob=PyTuple_GetItem(finalResult,pos) ;
541               else
542                 ob=finalResult;
543               DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
544               p->put(ob);
545               pos++;
546             }
547           Py_DECREF(finalResult);
548       }
549       catch(ConversionException& ex)
550       {
551           Py_DECREF(finalResult);
552           _errorDetails=ex.what();
553           throw;
554       }
555       if(_autoSqueeze)
556         squeezeMemoryRemote();
557   }
558   DEBTRACE( "++++++++++++++ ENDOF PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
559 }
560
561 void PythonNode::executeLocal()
562 {
563   DEBTRACE( "++++++++++++++ PyNode::executeLocal: " << getName() << " ++++++++++++++++++++" );
564   {
565     AutoGIL agil;
566
567     DEBTRACE( "---------------PyNode::inputs---------------" );
568     list<InputPort *>::iterator iter2;
569     for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
570       {
571         InputPyPort *p=(InputPyPort *)*iter2;
572         DEBTRACE( "port name: " << p->getName() );
573         DEBTRACE( "port kind: " << p->edGetType()->kind() );
574         PyObject* ob=p->getPyObj();
575         DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
576 #ifdef _DEVDEBUG_
577         PyObject_Print(ob,stderr,Py_PRINT_RAW);
578         cerr << endl;
579 #endif
580         int ier=PyDict_SetItemString(_context,p->getName().c_str(),ob);
581         DEBTRACE( "after PyDict_SetItemString:ob refcnt: " << ob->ob_refcnt );
582       }
583
584     DEBTRACE( "---------------End PyNode::inputs---------------" );
585
586     //calculation
587     DEBTRACE( "----------------PyNode::calculation---------------" );
588     DEBTRACE(  _script );
589     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
590
591     std::ostringstream stream;
592     stream << "/tmp/PythonNode_";
593     stream << getpid();
594
595     PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
596     if(code == NULL)
597       {
598         _errorDetails=""; 
599         PyObject* new_stderr = newPyStdOut(_errorDetails);
600         PySys_SetObject((char*)"stderr", new_stderr);
601         PyErr_Print();
602         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
603         Py_DECREF(new_stderr);
604         throw Exception("Error during execution");
605       }
606     PyObject *res = PyEval_EvalCode(  code, _context, _context);
607
608     Py_DECREF(code);
609     Py_XDECREF(res);
610     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
611     fflush(stdout);
612     fflush(stderr);
613     if(PyErr_Occurred ())
614       {
615         _errorDetails="";
616         PyObject* new_stderr = newPyStdOut(_errorDetails);
617         PySys_SetObject((char*)"stderr", new_stderr);
618         ofstream errorfile(stream.str().c_str());
619         if (errorfile.is_open())
620           {
621             errorfile << _script;
622             errorfile.close();
623           }
624         PyErr_Print();
625         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
626         Py_DECREF(new_stderr);
627         throw Exception("Error during execution");
628       }
629
630     DEBTRACE( "-----------------PyNode::outputs-----------------" );
631     list<OutputPort *>::iterator iter;
632     try
633     {
634         for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
635           {
636             OutputPyPort *p=(OutputPyPort *)*iter;
637             DEBTRACE( "port name: " << p->getName() );
638             DEBTRACE( "port kind: " << p->edGetType()->kind() );
639             PyObject *ob=PyDict_GetItemString(_context,p->getName().c_str());
640             if(ob==NULL)
641               {
642                 std::string msg="Error during execution: there is no variable ";
643                 msg=msg+p->getName()+" in node context";
644                 _errorDetails=msg;
645                 throw Exception(msg);
646               }
647             DEBTRACE( "PyNode::outputs::ob refcnt: " << ob->ob_refcnt );
648 #ifdef _DEVDEBUG_
649             PyObject_Print(ob,stderr,Py_PRINT_RAW);
650             cerr << endl;
651 #endif
652             p->put(ob);
653           }
654     }
655     catch(ConversionException& ex)
656     {
657         _errorDetails=ex.what();
658         throw;
659     }
660     if(_autoSqueeze)
661       squeezeMemory();
662     DEBTRACE( "-----------------End PyNode::outputs-----------------" );
663   }
664   DEBTRACE( "++++++++++++++ End PyNode::execute: " << getName() << " ++++++++++++++++++++" );
665 }
666
667 void PythonNode::squeezeMemorySafe()
668 {
669   AutoGIL agil;
670   if(_mode==PythonNode::REMOTE_NAME)
671     this->squeezeMemoryRemote();
672   else
673     this->squeezeMemory();
674 }
675   
676 void PythonNode::squeezeMemory()
677 {
678   for(auto p : _setOfInputPort)
679     {
680       PyDict_DelItemString(_context,p->getName().c_str());
681       InputPyPort *p2(static_cast<InputPyPort *>(p));
682       if(p2->canSafelySqueezeMemory())
683         p2->put(Py_None);
684     }
685   for(auto p : _setOfOutputPort)
686     {
687       PyDict_DelItemString(_context,p->getName().c_str());
688       OutputPyPort *p2(static_cast<OutputPyPort *>(p));
689       p2->putWithoutForward(Py_None);
690     }
691 }
692
693 void PythonNode::squeezeMemoryRemote()
694 {
695   for(auto p : _setOfInputPort)
696     {
697       InputPyPort *p2(static_cast<InputPyPort *>(p));
698       if(p2->canSafelySqueezeMemory())
699         p2->put(Py_None);
700     }
701   for(auto p : _setOfOutputPort)
702     {
703       OutputPyPort *p2(static_cast<OutputPyPort *>(p));
704       p2->putWithoutForward(Py_None);
705     }
706 }
707
708 std::string PythonNode::getContainerLog()
709 {
710   return PythonEntry::GetContainerLog(_mode,_container,this);
711 }
712
713 void PythonNode::shutdown(int level)
714 {
715   DEBTRACE("PythonNode::shutdown " << level);
716   if(_mode=="local")return;
717   if(_container)
718     {
719       if(!CORBA::is_nil(_pynode)) _pynode->UnRegister();
720       _pynode=Engines::PyScriptNode::_nil();
721       _container->shutdown(level);
722     }
723 }
724
725 Node *PythonNode::simpleClone(ComposedNode *father, bool editionOnly) const
726 {
727   return new PythonNode(*this,father);
728 }
729
730 void PythonNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
731 {
732   if(!CORBA::is_nil(_pynode))
733     _pynode->UnRegister();
734   _pynode=objContainer->createPyScriptNode(getName().c_str(),getScript().c_str());
735   _pynode->Register();
736 }
737
738 Engines::PyNodeBase_var PythonNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
739 {
740   Engines::PyScriptNode_var ret(objContainer->getDefaultPyScriptNode(getName().c_str()));
741   if(!CORBA::is_nil(ret))
742     {
743       ret->Register();
744     }
745   return Engines::PyNodeBase::_narrow(ret);
746 }
747
748 void PythonNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
749 {
750   if(!CORBA::is_nil(_pynode))
751     {
752       Engines::PyScriptNode_var tmpp(Engines::PyScriptNode::_narrow(remoteInterp));
753       if(_pynode->_is_equivalent(tmpp))
754         {
755           _pynode->UnRegister();
756           return ;
757         }
758     }
759   if(!CORBA::is_nil(_pynode))
760     _pynode->UnRegister();
761   _pynode=Engines::PyScriptNode::_narrow(remoteInterp);
762 }
763
764 Engines::PyNodeBase_var PythonNode::getRemoteInterpreterHandle()
765 {
766   return Engines::PyNodeBase::_narrow(_pynode);
767 }
768
769 //! Create a new node of same type with a given name
770 PythonNode* PythonNode::cloneNode(const std::string& name)
771 {
772   PythonNode* n=new PythonNode(name);
773   n->setScript(_script);
774   list<InputPort *>::iterator iter;
775   for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
776     {
777       InputPyPort *p=(InputPyPort *)*iter;
778       DEBTRACE( "port name: " << p->getName() );
779       DEBTRACE( "port kind: " << p->edGetType()->kind() );
780       n->edAddInputPort(p->getName(),p->edGetType());
781     }
782   list<OutputPort *>::iterator iter2;
783   for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
784     {
785       OutputPyPort *p=(OutputPyPort *)*iter2;
786       DEBTRACE( "port name: " << p->getName() );
787       DEBTRACE( "port kind: " << p->edGetType()->kind() );
788       n->edAddOutputPort(p->getName(),p->edGetType());
789     }
790   return n;
791 }
792
793 void PythonNode::applyDPLScope(ComposedNode *gfn)
794 {
795   std::vector< std::pair<std::string,int> > ret(getDPLScopeInfo(gfn));
796   if(ret.empty())
797     return ;
798   //
799   PyObject *ob(0);
800   {
801     AutoGIL agil;
802     std::size_t sz(ret.size());
803     ob=PyList_New(sz);
804     for(std::size_t i=0;i<sz;i++)
805       {
806         const std::pair<std::string,int>& p(ret[i]);
807         PyObject *elt(PyTuple_New(2));
808         PyTuple_SetItem(elt,0,PyUnicode_FromString(p.first.c_str()));
809         PyTuple_SetItem(elt,1,PyLong_FromLong(p.second));
810         PyList_SetItem(ob,i,elt);
811       }
812   }
813   if(_mode==REMOTE_NAME)
814     {
815       Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);
816       {
817         AutoGIL agil;
818         PyObject *serializationInput(PyObject_CallFunctionObjArgs(_pyfuncSimpleSer,ob,NULL));
819         Py_XDECREF(ob);
820         char *serializationInputC(0);
821         Py_ssize_t len;
822         if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
823           throw Exception("DistributedPythonNode problem in python pickle");
824         serializationInputCorba->length(len);
825         for(int i=0; i < len ; i++)
826           serializationInputCorba[i]=serializationInputC[i];
827         Py_XDECREF(serializationInput);
828       }
829       _pynode->defineNewCustomVar(DPL_INFO_NAME,serializationInputCorba);
830     }
831   else
832     {
833       AutoGIL agil;
834       PyDict_SetItemString(_context,DPL_INFO_NAME,ob);
835       Py_XDECREF(ob);
836     }
837 }
838
839 PyFuncNode::PyFuncNode(const PyFuncNode& other, ComposedNode *father):InlineFuncNode(other,father),_pyfunc(0)
840 {
841   _implementation = PythonNode::IMPL_NAME;
842   {
843     AutoGIL agil;
844     _context=PyDict_New();
845     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
846     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
847       {
848         stringstream msg;
849         msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
850         _errorDetails=msg.str();
851         throw Exception(msg.str());
852       }
853   }
854 }
855
856 PyFuncNode::PyFuncNode(const std::string& name): InlineFuncNode(name),_pyfunc(0)
857 {
858
859   _implementation = PythonNode::IMPL_NAME;
860   DEBTRACE( "PyFuncNode::PyFuncNode " << name );
861   {
862     AutoGIL agil;
863     _context=PyDict_New();
864     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
865     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
866       {
867         stringstream msg;
868         msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
869         _errorDetails=msg.str();
870         throw Exception(msg.str());
871       }
872   }
873 }
874
875 PyFuncNode::~PyFuncNode()
876 {
877   if(!CORBA::is_nil(_pynode))
878     {
879       _pynode->UnRegister();
880     }
881 }
882
883 void PyFuncNode::init(bool start)
884 {
885   initCommonPartWithoutStateManagement(start);
886   if(_state == YACS::DISABLED)
887     {
888       exDisabledState(); // to refresh propagation of DISABLED state
889       return ;
890     }
891   if(start) //complete initialization
892     setState(YACS::READY);
893   else if(_state > YACS::LOADED)// WARNING FuncNode has internal vars (CEA usecase) ! Partial initialization (inside a loop). Exclusivity of funcNode.
894     setState(YACS::TORECONNECT);
895 }
896
897 void PyFuncNode::checkBasicConsistency() const throw(YACS::Exception)
898 {
899   DEBTRACE("checkBasicConsistency");
900   InlineFuncNode::checkBasicConsistency();
901   {
902     AutoGIL agil;
903     PyObject* res;
904     res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
905     if(res == NULL)
906       {
907         std::string error="";
908         PyObject* new_stderr = newPyStdOut(error);
909         PySys_SetObject((char*)"stderr", new_stderr);
910         PyErr_Print();
911         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
912         Py_DECREF(new_stderr);
913         throw Exception(error);
914       }
915     else
916       Py_XDECREF(res);
917   }
918 }
919
920 void PyFuncNode::load()
921 {
922   DEBTRACE( "---------------PyfuncNode::load function---------------" );
923   if(_mode==PythonNode::REMOTE_NAME)
924     loadRemote();
925   else
926     loadLocal();
927 }
928
929 void PyFuncNode::loadRemote()
930 {
931   commonRemoteLoad(this);
932 }
933
934 void PyFuncNode::loadLocal()
935 {
936   DEBTRACE( "---------------PyFuncNode::load function " << getName() << " ---------------" );
937   DEBTRACE(  _script );
938
939 #ifdef _DEVDEBUG_
940   list<OutputPort *>::iterator iter;
941   for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
942     {
943       OutputPyPort *p=(OutputPyPort *)*iter;
944       DEBTRACE( "port name: " << p->getName() );
945       DEBTRACE( "port kind: " << p->edGetType()->kind() );
946     }
947 #endif
948
949   {
950     AutoGIL agil;
951     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
952
953     std::ostringstream stream;
954     stream << "/tmp/PythonNode_";
955     stream << getpid();
956
957     PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
958     if(code == NULL)
959       {
960         _errorDetails="";
961         PyObject* new_stderr = newPyStdOut(_errorDetails);
962         PySys_SetObject((char*)"stderr", new_stderr);
963         PyErr_Print();
964         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
965         Py_DECREF(new_stderr);
966         throw Exception("Error during execution");
967       }
968     PyObject *res = PyEval_EvalCode( code, _context, _context);
969     Py_DECREF(code);
970     Py_XDECREF(res);
971
972     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
973     if(PyErr_Occurred ())
974       {
975         _errorDetails="";
976         PyObject* new_stderr = newPyStdOut(_errorDetails);
977         PySys_SetObject((char*)"stderr", new_stderr);
978         ofstream errorfile(stream.str().c_str());
979         if (errorfile.is_open())
980           {
981             errorfile << _script;
982             errorfile.close();
983           }
984         PyErr_Print();
985         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
986         Py_DECREF(new_stderr);
987         throw Exception("Error during execution");
988         return;
989       }
990     _pyfunc=PyDict_GetItemString(_context,_fname.c_str());
991     DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
992     if(_pyfunc == NULL)
993       {
994         _errorDetails="";
995         PyObject* new_stderr = newPyStdOut(_errorDetails);
996         PySys_SetObject((char*)"stderr", new_stderr);
997         PyErr_Print();
998         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
999         Py_DECREF(new_stderr);
1000         throw Exception("Error during execution");
1001       }
1002     DEBTRACE( "---------------End PyFuncNode::load function---------------" );
1003   }
1004 }
1005
1006 void PyFuncNode::execute()
1007 {
1008   if(_mode==PythonNode::REMOTE_NAME)
1009     executeRemote();
1010   else
1011     executeLocal();
1012 }
1013
1014 void PyFuncNode::executeRemote()
1015 {
1016   DEBTRACE( "++++++++++++++ PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1017   if(!_pyfuncSer)
1018     throw Exception("DistributedPythonNode badly loaded");
1019   //
1020   if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
1021     {
1022       bool dummy;
1023       commonRemoteLoadPart2(this,dummy);
1024       _pynode->executeAnotherPieceOfCode(getScript().c_str());
1025     }
1026   //
1027   Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);;
1028   {
1029       AutoGIL agil;
1030       PyObject *ob(0);
1031       //===========================================================================
1032       // Get inputs in input ports, build a Python tuple and pickle it
1033       //===========================================================================
1034       PyObject *args(PyTuple_New(getNumberOfInputPorts()));
1035       int pos(0);
1036       for(std::list<InputPort *>::iterator iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++,pos++)
1037         {
1038           InputPyPort *p=(InputPyPort *)*iter2;
1039           ob=p->getPyObj();
1040           Py_INCREF(ob);
1041           PyTuple_SetItem(args,pos,ob);
1042         }
1043 #ifdef _DEVDEBUG_
1044       PyObject_Print(args,stderr,Py_PRINT_RAW);
1045       std::cerr << endl;
1046 #endif
1047       PyObject *serializationInput=PyObject_CallObject(_pyfuncSer,args);
1048       Py_DECREF(args);
1049       //The pickled string may contain NULL characters so use PyString_AsStringAndSize
1050       char *serializationInputC(0);
1051       Py_ssize_t len;
1052       if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
1053         throw Exception("DistributedPythonNode problem in python pickle");
1054
1055       serializationInputCorba->length(len);
1056       for(int i=0; i < len ; i++)
1057         serializationInputCorba[i]=serializationInputC[i];
1058       Py_DECREF(serializationInput);
1059   }
1060
1061   //===========================================================================
1062   // Execute in remote Python node
1063   //===========================================================================
1064   DEBTRACE( "-----------------starting remote python invocation-----------------" );
1065   Engines::pickledArgs_var resultCorba;
1066   try
1067     {
1068       resultCorba=_pynode->execute(getFname().c_str(),serializationInputCorba);
1069     }
1070   catch( const SALOME::SALOME_Exception& ex )
1071     {
1072       std::string msg="Exception on remote python invocation";
1073       msg += '\n';
1074       msg += ex.details.text.in();
1075       _errorDetails=msg;
1076       throw Exception(msg);
1077     }
1078   DEBTRACE( "-----------------end of remote python invocation-----------------" );
1079   //===========================================================================
1080   // Get results, unpickle and put them in output ports
1081   //===========================================================================
1082   char *resultCorbaC=new char[resultCorba->length()+1];
1083   resultCorbaC[resultCorba->length()]='\0';
1084   for(int i=0;i<resultCorba->length();i++)
1085     resultCorbaC[i]=resultCorba[i];
1086
1087   {
1088       AutoGIL agil;
1089
1090       PyObject *resultPython(PyBytes_FromStringAndSize(resultCorbaC,resultCorba->length()));
1091       delete [] resultCorbaC;
1092       PyObject *args(PyTuple_New(1)),*ob(0);
1093       PyTuple_SetItem(args,0,resultPython);
1094       PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
1095       Py_DECREF(args);
1096
1097       DEBTRACE( "-----------------PythonNode::outputs-----------------" );
1098       int nres=1;
1099       if(finalResult == Py_None)
1100         nres=0;
1101       else if(PyTuple_Check(finalResult))
1102         nres=PyTuple_Size(finalResult);
1103
1104       if(getNumberOfOutputPorts() != nres)
1105         {
1106           std::string msg="Number of output arguments : Mismatch between definition and execution";
1107           Py_DECREF(finalResult);
1108           _errorDetails=msg;
1109           throw Exception(msg);
1110         }
1111
1112       try
1113       {
1114           int pos(0);
1115           for(std::list<OutputPort *>::iterator iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++, pos++)
1116             {
1117               OutputPyPort *p=(OutputPyPort *)*iter;
1118               DEBTRACE( "port name: " << p->getName() );
1119               DEBTRACE( "port kind: " << p->edGetType()->kind() );
1120               DEBTRACE( "port pos : " << pos );
1121               if(PyTuple_Check(finalResult))
1122                 ob=PyTuple_GetItem(finalResult,pos) ;
1123               else
1124                 ob=finalResult;
1125               DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1126               p->put(ob);
1127             }
1128           Py_DECREF(finalResult);
1129       }
1130       catch(ConversionException& ex)
1131       {
1132           Py_DECREF(finalResult);
1133           _errorDetails=ex.what();
1134           throw;
1135       }
1136   }
1137
1138   DEBTRACE( "++++++++++++++ ENDOF PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1139 }
1140
1141 void PyFuncNode::executeLocal()
1142 {
1143   DEBTRACE( "++++++++++++++ PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1144
1145   int pos=0;
1146   PyObject* ob;
1147   if(!_pyfunc)throw Exception("PyFuncNode badly loaded");
1148   {
1149       AutoGIL agil;
1150       DEBTRACE( "---------------PyFuncNode::inputs---------------" );
1151       PyObject* args = PyTuple_New(getNumberOfInputPorts()) ;
1152       list<InputPort *>::iterator iter2;
1153       for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
1154         {
1155           InputPyPort *p=(InputPyPort *)*iter2;
1156           DEBTRACE( "port name: " << p->getName() );
1157           DEBTRACE( "port kind: " << p->edGetType()->kind() );
1158           ob=p->getPyObj();
1159 #ifdef _DEVDEBUG_
1160           PyObject_Print(ob,stderr,Py_PRINT_RAW);
1161           cerr << endl;
1162 #endif
1163           DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1164           Py_INCREF(ob);
1165           PyTuple_SetItem(args,pos,ob);
1166           DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1167           pos++;
1168         }
1169       DEBTRACE( "---------------End PyFuncNode::inputs---------------" );
1170
1171       DEBTRACE( "----------------PyFuncNode::calculation---------------" );
1172 #ifdef _DEVDEBUG_
1173       PyObject_Print(_pyfunc,stderr,Py_PRINT_RAW);
1174       cerr << endl;
1175       PyObject_Print(args,stderr,Py_PRINT_RAW);
1176       cerr << endl;
1177 #endif
1178       DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1179       PyObject* result = PyObject_CallObject( _pyfunc , args ) ;
1180       DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1181       Py_DECREF(args);
1182       fflush(stdout);
1183       fflush(stderr);
1184       if(result == NULL)
1185         {
1186           _errorDetails="";
1187           PyObject* new_stderr = newPyStdOut(_errorDetails);
1188           PySys_SetObject((char*)"stderr", new_stderr);
1189           std::ostringstream stream;
1190           stream << "/tmp/PythonNode_";
1191           stream << getpid();
1192           ofstream errorfile(stream.str().c_str());
1193           if (errorfile.is_open())
1194             {
1195               errorfile << _script;
1196               errorfile.close();
1197             }
1198           PyErr_Print();
1199           PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1200           Py_DECREF(new_stderr);
1201           throw Exception("Error during execution");
1202         }
1203       DEBTRACE( "----------------End PyFuncNode::calculation---------------" );
1204
1205       DEBTRACE( "-----------------PyFuncNode::outputs-----------------" );
1206       int nres=1;
1207       if(result == Py_None)
1208         nres=0;
1209       else if(PyTuple_Check(result))
1210         nres=PyTuple_Size(result);
1211
1212       if(getNumberOfOutputPorts() != nres)
1213         {
1214           std::string msg="Number of output arguments : Mismatch between definition and execution";
1215           Py_DECREF(result);
1216           _errorDetails=msg;
1217           throw Exception(msg);
1218         }
1219
1220       pos=0;
1221 #ifdef _DEVDEBUG_
1222       PyObject_Print(result,stderr,Py_PRINT_RAW);
1223       cerr << endl;
1224 #endif
1225       list<OutputPort *>::iterator iter;
1226       try
1227       {
1228           for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
1229             {
1230               OutputPyPort *p=(OutputPyPort *)*iter;
1231               DEBTRACE( "port name: " << p->getName() );
1232               DEBTRACE( "port kind: " << p->edGetType()->kind() );
1233               DEBTRACE( "port pos : " << pos );
1234               if(PyTuple_Check(result))ob=PyTuple_GetItem(result,pos) ;
1235               else ob=result;
1236               DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1237 #ifdef _DEVDEBUG_
1238               PyObject_Print(ob,stderr,Py_PRINT_RAW);
1239               cerr << endl;
1240 #endif
1241               p->put(ob);
1242               pos++;
1243             }
1244       }
1245       catch(ConversionException& ex)
1246       {
1247           Py_DECREF(result);
1248           _errorDetails=ex.what();
1249           throw;
1250       }
1251       DEBTRACE( "-----------------End PyFuncNode::outputs-----------------" );
1252       Py_DECREF(result);
1253   }
1254   DEBTRACE( "++++++++++++++ End PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1255 }
1256
1257 Node *PyFuncNode::simpleClone(ComposedNode *father, bool editionOnly) const
1258 {
1259   return new PyFuncNode(*this,father);
1260 }
1261
1262 void PyFuncNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
1263 {
1264   if(!CORBA::is_nil(_pynode))
1265     _pynode->UnRegister();
1266   _pynode=objContainer->createPyNode(getName().c_str(),getScript().c_str());
1267 }
1268
1269 Engines::PyNodeBase_var PyFuncNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
1270 {
1271   Engines::PyNode_var ret(objContainer->getDefaultPyNode(getName().c_str()));
1272   if(!CORBA::is_nil(ret))
1273     {
1274       ret->Register();
1275     }
1276   return Engines::PyNodeBase::_narrow(ret);
1277 }
1278
1279 void PyFuncNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
1280 {
1281   if(!CORBA::is_nil(_pynode))
1282     {
1283       Engines::PyNode_var tmpp(Engines::PyNode::_narrow(remoteInterp));
1284       if(_pynode->_is_equivalent(tmpp))
1285         return ;
1286     }
1287   if(!CORBA::is_nil(_pynode))
1288     _pynode->UnRegister();
1289   _pynode=Engines::PyNode::_narrow(remoteInterp);
1290 }
1291
1292 Engines::PyNodeBase_var PyFuncNode::getRemoteInterpreterHandle()
1293 {
1294   return Engines::PyNodeBase::_narrow(_pynode);
1295 }
1296
1297 //! Create a new node of same type with a given name
1298 PyFuncNode* PyFuncNode::cloneNode(const std::string& name)
1299 {
1300   PyFuncNode* n=new PyFuncNode(name);
1301   n->setScript(_script);
1302   n->setFname(_fname);
1303   list<InputPort *>::iterator iter;
1304   for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
1305     {
1306       InputPyPort *p=(InputPyPort *)*iter;
1307       n->edAddInputPort(p->getName(),p->edGetType());
1308     }
1309   list<OutputPort *>::iterator iter2;
1310   for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
1311     {
1312       OutputPyPort *p=(OutputPyPort *)*iter2;
1313       n->edAddOutputPort(p->getName(),p->edGetType());
1314     }
1315   return n;
1316 }
1317
1318 std::string PyFuncNode::getContainerLog()
1319 {
1320   return PythonEntry::GetContainerLog(_mode,_container,this);
1321 }
1322
1323 void PyFuncNode::shutdown(int level)
1324 {
1325   DEBTRACE("PyFuncNode::shutdown " << level);
1326   if(_mode=="local")return;
1327   if(_container)
1328     {
1329       if(!CORBA::is_nil(_pynode)) _pynode->UnRegister();
1330       _pynode=Engines::PyNode::_nil();
1331       _container->shutdown(level);
1332     }
1333 }
1334