src/runtime/PythonNode.cxx

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