src/runtime/PythonNode.cxx

   1 // Copyright (C) 2006-2022  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 "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::GetDestroyStatus( PyObject *ob )
 332 {
 333   if(!_pyClsBigObject)
 334     return false;
 335   if( PyObject_IsInstance( ob, _pyClsBigObject) == 1 )
 336   {
 337     AutoPyRef unlinkOnDestructor = PyObject_GetAttrString(ob,"getDestroyStatus");
 338     AutoPyRef tmp = PyObject_CallFunctionObjArgs(unlinkOnDestructor,nullptr);
 339     if( PyBool_Check(tmp.get()) )
 340     {
 341       return tmp.get() == Py_True;
 342     }
 343     return false;
 344   }
 345   return false;
 346 }
 347
 348 void PythonEntry::IfProxyDoSomething( PyObject *ob, const char *meth )
 349 {
 350   if(!_pyClsBigObject)
 351     return ;
 352   if( PyObject_IsInstance( ob, _pyClsBigObject) == 1 )
 353   {
 354     AutoPyRef unlinkOnDestructor = PyObject_GetAttrString(ob,meth);
 355     AutoPyRef tmp = PyObject_CallFunctionObjArgs(unlinkOnDestructor,nullptr);
 356   }
 357 }
 358
 359 void PythonEntry::DoNotTouchFileIfProxy( PyObject *ob )
 360 {
 361   IfProxyDoSomething(ob,"doNotTouchFile");
 362 }
 363
 364 void PythonEntry::UnlinkOnDestructorIfProxy( PyObject *ob )
 365 {
 366   IfProxyDoSomething(ob,"unlinkOnDestructor");
 367 }
 368
 369 PythonNode::PythonNode(const PythonNode& other, ComposedNode *father):InlineNode(other,father),_autoSqueeze(other._autoSqueeze)
 370 {
 371   _pynode = Engines::PyScriptNode::_nil();
 372   _implementation=IMPL_NAME;
 373   {
 374     AutoGIL agil;
 375     _context=PyDict_New();
 376     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
 377       {
 378         stringstream msg;
 379         msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
 380         _errorDetails=msg.str();
 381         throw Exception(msg.str());
 382       }
 383   }
 384 }
 385
 386 PythonNode::PythonNode(const std::string& name):InlineNode(name)
 387 {
 388   _pynode = Engines::PyScriptNode::_nil();
 389   _implementation=IMPL_NAME;
 390   {
 391     AutoGIL agil;
 392     _context=PyDict_New();
 393     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
 394       {
 395         stringstream msg;
 396         msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
 397         _errorDetails=msg.str();
 398         throw Exception(msg.str());
 399       }
 400   }
 401 }
 402
 403 PythonNode::~PythonNode()
 404 {
 405   freeKernelPynode();
 406 }
 407
 408 void PythonNode::checkBasicConsistency() const
 409 {
 410   DEBTRACE("checkBasicConsistency");
 411   InlineNode::checkBasicConsistency();
 412   {
 413     AutoGIL agil;
 414     PyObject* res;
 415     res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
 416     if(res == NULL)
 417       {
 418         std::string error="";
 419         PyObject* new_stderr = newPyStdOut(error);
 420         PySys_SetObject((char*)"stderr", new_stderr);
 421         PyErr_Print();
 422         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
 423         Py_DECREF(new_stderr);
 424         throw Exception(error);
 425       }
 426     else
 427       Py_XDECREF(res);
 428   }
 429 }
 430
 431 void PythonNode::load()
 432 {
 433   DEBTRACE( "---------------PyNode::load function---------------" );
 434   if(_mode==PythonNode::REMOTE_NAME)
 435     loadRemote();
 436   else
 437     loadLocal();
 438 }
 439
 440 void PythonNode::loadLocal()
 441 {
 442   DEBTRACE( "---------------PyNode::loadLocal function---------------" );
 443   // do nothing
 444 }
 445
 446 void PythonNode::loadRemote()
 447 {
 448   commonRemoteLoad(this);
 449 }
 450
 451 void PythonNode::execute()
 452 {
 453   if(_mode==PythonNode::REMOTE_NAME)
 454     executeRemote();
 455   else
 456     executeLocal();
 457 }
 458
 459 void PythonNode::executeRemote()
 460 {
 461   DEBTRACE( "++++++++++++++ PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
 462   if(!_pyfuncSer)
 463     throw Exception("PythonNode badly loaded");
 464   //
 465   if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
 466     {
 467       bool dummy;
 468       loadPythonAdapter(this,dummy);
 469       _pynode->assignNewCompiledCode(getScript().c_str());
 470     }
 471   // not managed by unique_ptr here because destructed by the order of client.
 472   SenderByteImpl *serializationInputCorba = nullptr;
 473   AutoPyRef serializationInput;
 474   {
 475 #if PY_VERSION_HEX < 0x03070000
 476       std::unique_lock<std::mutex> lock(data_mutex);
 477 #endif
 478       AutoGIL agil;
 479       PyObject *args(0),*ob(0);
 480       //===========================================================================
 481       // Get inputs in input ports, build a Python dict and pickle it
 482       //===========================================================================
 483       args = PyDict_New();
 484       std::list<InputPort *>::iterator iter2;
 485       int pos(0);
 486       for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); ++iter2)
 487         {
 488           InputPyPort *p=(InputPyPort *)*iter2;
 489           ob=p->getPyObj();
 490           PyDict_SetItemString(args,p->getName().c_str(),ob);
 491           pos++;
 492         }
 493 #ifdef _DEVDEBUG_
 494       PyObject_Print(args,stderr,Py_PRINT_RAW);
 495       std::cerr << endl;
 496 #endif
 497       serializationInput.set(PyObject_CallFunctionObjArgs(_pyfuncSer,args,nullptr));
 498       Py_DECREF(args);
 499       //The pickled string may contain NULL characters so use PyString_AsStringAndSize
 500       char *serializationInputC(nullptr);
 501       Py_ssize_t len;
 502       if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
 503         throw Exception("DistributedPythonNode problem in python pickle");
 504       // no copy here. The C byte array of Python is taken  as this into CORBA sequence to avoid copy
 505       serializationInputCorba = new SenderByteImpl(serializationInputC,len);
 506   }
 507
 508   //get the list of output argument names
 509   std::list<OutputPort *>::iterator iter;
 510   Engines::listofstring myseq;
 511   myseq.length(getNumberOfOutputPorts());
 512   int pos=0;
 513   for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
 514     {
 515       OutputPyPort *p=(OutputPyPort *)*iter;
 516       myseq[pos]=p->getName().c_str();
 517       DEBTRACE( "port name: " << p->getName() );
 518       DEBTRACE( "port kind: " << p->edGetType()->kind() );
 519       DEBTRACE( "port pos : " << pos );
 520       pos++;
 521     }
 522   //===========================================================================
 523   // Execute in remote Python node
 524   //===========================================================================
 525   DEBTRACE( "-----------------starting remote python invocation-----------------" );
 526   std::unique_ptr<SALOME::SenderByteSeq> resultCorba;
 527   try
 528     {
 529       //pass outargsname and dict serialized
 530       SALOME::SenderByte_var serializationInputRef = serializationInputCorba->_this();
 531       _pynode->executeFirst(serializationInputRef);
 532       //serializationInput and serializationInputCorba are no more needed for server. Release it.
 533       serializationInput.set(nullptr);
 534       resultCorba.reset( _pynode->executeSecond(myseq) );
 535       if( ! this->isUsingPythonCache() )
 536         _pynode->removeAllVarsInContext();
 537     }
 538   catch( const SALOME::SALOME_Exception& ex )
 539     {
 540       std::ostringstream msg; msg << "Exception on remote python invocation" << std::endl << ex.details.text.in() << std::endl;
 541       msg << "PyScriptNode CORBA ref : ";
 542       {
 543         CORBA::ORB_ptr orb(getSALOMERuntime()->getOrb());
 544         if(!CORBA::is_nil(orb))
 545         {
 546           CORBA::String_var IOR(orb->object_to_string(_pynode));
 547           msg << IOR;
 548         }
 549       }
 550       msg << std::endl;
 551       _errorDetails=msg.str();
 552       throw Exception(msg.str());
 553     }
 554   catch(CORBA::COMM_FAILURE& ex)
 555     {
 556       std::ostringstream msg;
 557       msg << "Exception on remote python invocation." << std::endl ;
 558       msg << "Caught system exception COMM_FAILURE -- unable to contact the "
 559           << "object." << std::endl;
 560       _errorDetails=msg.str();
 561       throw Exception(msg.str());
 562     }
 563   catch(CORBA::SystemException& ex)
 564     {
 565       std::ostringstream msg;
 566       msg << "Exception on remote python invocation." << std::endl ;
 567       msg << "Caught a CORBA::SystemException." ;
 568       CORBA::Any tmp;
 569       tmp <<= ex;
 570       CORBA::TypeCode_var tc = tmp.type();
 571       const char *p = tc->name();
 572       if ( *p != '\0' )
 573         msg <<p;
 574       else
 575         msg  << tc->id();
 576       msg << std::endl;
 577       _errorDetails=msg.str();
 578       throw Exception(msg.str());
 579     }
 580   catch(CORBA::Exception& ex)
 581     {
 582       std::ostringstream msg;
 583       msg << "Exception on remote python invocation." << std::endl ;
 584       msg << "Caught CORBA::Exception. " ;
 585       CORBA::Any tmp;
 586       tmp <<= ex;
 587       CORBA::TypeCode_var tc = tmp.type();
 588       const char *p = tc->name();
 589       if ( *p != '\0' )
 590         msg <<p;
 591       else
 592         msg  << tc->id();
 593       msg << std::endl;
 594       _errorDetails=msg.str();
 595       throw Exception(msg.str());
 596     }
 597   catch(omniORB::fatalException& fe)
 598     {
 599       std::ostringstream msg;
 600       msg << "Exception on remote python invocation." << std::endl ;
 601       msg << "Caught omniORB::fatalException:" << std::endl;
 602       msg << "  file: " << fe.file() << std::endl;
 603       msg << "  line: " << fe.line() << std::endl;
 604       msg << "  mesg: " << fe.errmsg() << std::endl;
 605       _errorDetails=msg.str();
 606       throw Exception(msg.str());
 607     }
 608   DEBTRACE( "-----------------end of remote python invocation-----------------" );
 609   //===========================================================================
 610   // Get results, unpickle and put them in output ports
 611   //===========================================================================
 612   {
 613 #if PY_VERSION_HEX < 0x03070000
 614       std::unique_lock<std::mutex> lock(data_mutex);
 615 #endif
 616       AutoGIL agil;
 617       DEBTRACE( "-----------------PythonNode::outputs-----------------" );
 618       int nres( resultCorba->length() );
 619
 620       if(getNumberOfOutputPorts() != nres)
 621         {
 622           std::string msg="Number of output arguments : Mismatch between definition and execution";
 623           _errorDetails=msg;
 624           throw Exception(msg);
 625         }
 626       pos=0;
 627       try
 628       {
 629           for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
 630             {
 631               OutputPyPort *p=(OutputPyPort *)*iter;
 632               DEBTRACE( "port name: " << p->getName() );
 633               DEBTRACE( "port kind: " << p->edGetType()->kind() );
 634               DEBTRACE( "port pos : " << pos );
 635               SALOME::SenderByte_var elt = (*resultCorba)[pos];
 636               SeqByteReceiver recv(elt);
 637               unsigned long length = 0;
 638               char *resultCorbaC = recv.data(length);
 639               {
 640                 AutoPyRef resultPython=PyMemoryView_FromMemory(resultCorbaC,length,PyBUF_READ);
 641                 AutoPyRef args = PyTuple_New(1);
 642                 PyTuple_SetItem(args,0,resultPython.retn());
 643                 AutoPyRef ob = PyObject_CallObject(_pyfuncUnser,args);
 644                 if (!ob)
 645                 {
 646                   std::stringstream msg;
 647                   msg << "Conversion with pickle of output ports failed !";
 648                   msg << " : " << __FILE__ << ":" << __LINE__;
 649                   _errorDetails=msg.str();
 650                   throw YACS::ENGINE::ConversionException(msg.str());
 651                 }
 652                 UnlinkOnDestructorIfProxy(ob);
 653                 p->put( ob );
 654               }
 655               pos++;
 656             }
 657       }
 658       catch(ConversionException& ex)
 659       {
 660           _errorDetails=ex.what();
 661           throw;
 662       }
 663       if(_autoSqueeze)
 664         squeezeMemoryRemote();
 665   }
 666   //
 667   if(!isUsingPythonCache())
 668   {
 669     freeKernelPynode();
 670     bool dummy;
 671     Engines::Container_var cont(GetContainerObj(this,dummy));
 672     cont->removePyScriptNode(getName().c_str());
 673   }
 674   DEBTRACE( "++++++++++++++ ENDOF PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
 675 }
 676
 677 void PythonNode::executeLocal()
 678 {
 679   DEBTRACE( "++++++++++++++ PyNode::executeLocal: " << getName() << " ++++++++++++++++++++" );
 680   {
 681     AutoGIL agil;
 682
 683     DEBTRACE( "---------------PyNode::inputs---------------" );
 684     list<InputPort *>::iterator iter2;
 685     for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
 686       {
 687         InputPyPort *p=(InputPyPort *)*iter2;
 688         DEBTRACE( "port name: " << p->getName() );
 689         DEBTRACE( "port kind: " << p->edGetType()->kind() );
 690         PyObject* ob=p->getPyObj();
 691         DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
 692 #ifdef _DEVDEBUG_
 693         PyObject_Print(ob,stderr,Py_PRINT_RAW);
 694         cerr << endl;
 695 #endif
 696         int ier=PyDict_SetItemString(_context,p->getName().c_str(),ob);
 697         DEBTRACE( "after PyDict_SetItemString:ob refcnt: " << ob->ob_refcnt );
 698       }
 699
 700     DEBTRACE( "---------------End PyNode::inputs---------------" );
 701
 702     //calculation
 703     DEBTRACE( "----------------PyNode::calculation---------------" );
 704     DEBTRACE(  _script );
 705     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
 706
 707     std::ostringstream stream;
 708     stream << "/tmp/PythonNode_";
 709     stream << getpid();
 710
 711     PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
 712     if(code == NULL)
 713       {
 714         _errorDetails="";
 715         PyObject* new_stderr = newPyStdOut(_errorDetails);
 716         PySys_SetObject((char*)"stderr", new_stderr);
 717         PyErr_Print();
 718         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
 719         Py_DECREF(new_stderr);
 720         throw Exception("Error during execution");
 721       }
 722     PyObject *res = PyEval_EvalCode(  code, _context, _context);
 723
 724     Py_DECREF(code);
 725     Py_XDECREF(res);
 726     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
 727     fflush(stdout);
 728     fflush(stderr);
 729     if(PyErr_Occurred ())
 730       {
 731         _errorDetails="";
 732         PyObject* new_stderr = newPyStdOut(_errorDetails);
 733         PySys_SetObject((char*)"stderr", new_stderr);
 734         ofstream errorfile(stream.str().c_str());
 735         if (errorfile.is_open())
 736           {
 737             errorfile << _script;
 738             errorfile.close();
 739           }
 740         PyErr_Print();
 741         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
 742         Py_DECREF(new_stderr);
 743         throw Exception("Error during execution");
 744       }
 745
 746     DEBTRACE( "-----------------PyNode::outputs-----------------" );
 747     list<OutputPort *>::iterator iter;
 748     try
 749     {
 750         for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
 751           {
 752             OutputPyPort *p=(OutputPyPort *)*iter;
 753             DEBTRACE( "port name: " << p->getName() );
 754             DEBTRACE( "port kind: " << p->edGetType()->kind() );
 755             PyObject *ob=PyDict_GetItemString(_context,p->getName().c_str());
 756             if(ob==NULL)
 757               {
 758                 std::string msg="Error during execution: there is no variable ";
 759                 msg=msg+p->getName()+" in node context";
 760                 _errorDetails=msg;
 761                 throw Exception(msg);
 762               }
 763             DEBTRACE( "PyNode::outputs::ob refcnt: " << ob->ob_refcnt );
 764 #ifdef _DEVDEBUG_
 765             PyObject_Print(ob,stderr,Py_PRINT_RAW);
 766             cerr << endl;
 767 #endif
 768             p->put(ob);
 769           }
 770     }
 771     catch(ConversionException& ex)
 772     {
 773         _errorDetails=ex.what();
 774         throw;
 775     }
 776     if(_autoSqueeze)
 777       squeezeMemory();
 778     DEBTRACE( "-----------------End PyNode::outputs-----------------" );
 779   }
 780   DEBTRACE( "++++++++++++++ End PyNode::execute: " << getName() << " ++++++++++++++++++++" );
 781 }
 782
 783 void PythonNode::squeezeMemorySafe()
 784 {
 785   AutoGIL agil;
 786   if(_mode==PythonNode::REMOTE_NAME)
 787     this->squeezeMemoryRemote();
 788   else
 789     this->squeezeMemory();
 790 }
 791
 792 void PythonNode::squeezeMemory()
 793 {
 794   for(auto p : _setOfInputPort)
 795     {
 796       PyDict_DelItemString(_context,p->getName().c_str());
 797       InputPyPort *p2(static_cast<InputPyPort *>(p));
 798       if(p2->canSafelySqueezeMemory())
 799         p2->put(Py_None);
 800     }
 801   for(auto p : _setOfOutputPort)
 802     {
 803       PyDict_DelItemString(_context,p->getName().c_str());
 804       OutputPyPort *p2(static_cast<OutputPyPort *>(p));
 805       p2->putWithoutForward(Py_None);
 806     }
 807 }
 808
 809 void PythonNode::squeezeMemoryRemote()
 810 {
 811   for(auto p : _setOfInputPort)
 812     {
 813       InputPyPort *p2(static_cast<InputPyPort *>(p));
 814       if(p2->canSafelySqueezeMemory())
 815         p2->put(Py_None);
 816     }
 817   for(auto p : _setOfOutputPort)
 818     {
 819       OutputPyPort *p2(static_cast<OutputPyPort *>(p));
 820       p2->putWithoutForward(Py_None);
 821     }
 822 }
 823
 824 std::string PythonNode::getContainerLog()
 825 {
 826   return PythonEntry::GetContainerLog(_mode,_container,this);
 827 }
 828
 829 void PythonNode::shutdown(int level)
 830 {
 831   DEBTRACE("PythonNode::shutdown " << level);
 832   if(_mode=="local")return;
 833   if(_container)
 834     {
 835       freeKernelPynode();
 836       _container->shutdown(level);
 837     }
 838 }
 839
 840 void PythonNode::imposeResource(const std::string& resource_name,
 841                                 const std::string& container_name)
 842 {
 843   if(!resource_name.empty() && !container_name.empty())
 844   {
 845     _imposedResource = resource_name;
 846     _imposedContainer = container_name;
 847   }
 848 }
 849
 850 bool PythonNode::canAcceptImposedResource()
 851 {
 852   return _container != nullptr && _container->canAcceptImposedResource();
 853 }
 854
 855 bool PythonNode::hasImposedResource()const
 856 {
 857   return PythonEntry::hasImposedResource();
 858 }
 859
 860 std::string PythonNode::pythonEntryName()const
 861 {
 862   if(isUsingPythonCache())
 863     return "DEFAULT_NAME_FOR_UNIQUE_PYTHON_NODE_ENTRY";
 864   else
 865     return getName();
 866 }
 867
 868 bool PythonNode::isUsingPythonCache()const
 869 {
 870   bool found = false;
 871   if(_container)
 872     found = _container->isUsingPythonCache();
 873   return found;
 874 }
 875
 876 void PythonNode::freeKernelPynode()
 877 {
 878   if(!CORBA::is_nil(_pynode))
 879   {
 880     try
 881     {
 882       _pynode->UnRegister();
 883     }
 884     catch(...)
 885     {
 886       DEBTRACE("Trouble when pynode->UnRegister!")
 887     }
 888     _pynode = Engines::PyScriptNode::_nil();
 889   }
 890 }
 891
 892 Node *PythonNode::simpleClone(ComposedNode *father, bool editionOnly) const
 893 {
 894   return new PythonNode(*this,father);
 895 }
 896
 897 void PythonNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
 898 {
 899   freeKernelPynode();
 900   _pynode=objContainer->createPyScriptNode(pythonEntryName().c_str(),getScript().c_str());
 901   _pynode->Register();
 902 }
 903
 904 Engines::PyNodeBase_var PythonNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
 905 {
 906   Engines::PyScriptNode_var ret(objContainer->getDefaultPyScriptNode(pythonEntryName().c_str()));
 907   if(!CORBA::is_nil(ret))
 908     {
 909       ret->Register();
 910     }
 911   return Engines::PyNodeBase::_narrow(ret);
 912 }
 913
 914 void PythonNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
 915 {
 916   if(CORBA::is_nil(_pynode))
 917     _pynode=Engines::PyScriptNode::_narrow(remoteInterp);
 918   else
 919   {
 920     Engines::PyScriptNode_var tmpp(Engines::PyScriptNode::_narrow(remoteInterp));
 921     if(!_pynode->_is_equivalent(tmpp))
 922     {
 923       freeKernelPynode();
 924       _pynode=Engines::PyScriptNode::_narrow(remoteInterp);
 925     }
 926   }
 927   _pynode->assignNewCompiledCode(getScript().c_str());
 928 }
 929
 930 Engines::PyNodeBase_var PythonNode::getRemoteInterpreterHandle()
 931 {
 932   return Engines::PyNodeBase::_narrow(_pynode);
 933 }
 934
 935 //! Create a new node of same type with a given name
 936 PythonNode* PythonNode::cloneNode(const std::string& name)
 937 {
 938   PythonNode* n=new PythonNode(name);
 939   n->setScript(_script);
 940   list<InputPort *>::iterator iter;
 941   for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
 942     {
 943       InputPyPort *p=(InputPyPort *)*iter;
 944       DEBTRACE( "port name: " << p->getName() );
 945       DEBTRACE( "port kind: " << p->edGetType()->kind() );
 946       n->edAddInputPort(p->getName(),p->edGetType());
 947     }
 948   list<OutputPort *>::iterator iter2;
 949   for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
 950     {
 951       OutputPyPort *p=(OutputPyPort *)*iter2;
 952       DEBTRACE( "port name: " << p->getName() );
 953       DEBTRACE( "port kind: " << p->edGetType()->kind() );
 954       n->edAddOutputPort(p->getName(),p->edGetType());
 955     }
 956   return n;
 957 }
 958
 959 void PythonNode::applyDPLScope(ComposedNode *gfn)
 960 {
 961   std::vector< std::pair<std::string,int> > ret(getDPLScopeInfo(gfn));
 962   if(ret.empty())
 963     return ;
 964   //
 965   PyObject *ob(0);
 966   {
 967     AutoGIL agil;
 968     std::size_t sz(ret.size());
 969     ob=PyList_New(sz);
 970     for(std::size_t i=0;i<sz;i++)
 971       {
 972         const std::pair<std::string,int>& p(ret[i]);
 973         PyObject *elt(PyTuple_New(2));
 974         PyTuple_SetItem(elt,0,PyUnicode_FromString(p.first.c_str()));
 975         PyTuple_SetItem(elt,1,PyLong_FromLong(p.second));
 976         PyList_SetItem(ob,i,elt);
 977       }
 978   }
 979   if(_mode==REMOTE_NAME)
 980     {
 981       Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);
 982       {
 983         AutoGIL agil;
 984         PyObject *serializationInput(PyObject_CallFunctionObjArgs(_pyfuncSimpleSer,ob,NULL));
 985         Py_XDECREF(ob);
 986         char *serializationInputC(0);
 987         Py_ssize_t len;
 988         if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
 989           throw Exception("DistributedPythonNode problem in python pickle");
 990         serializationInputCorba->length(len);
 991         for(int i=0; i < len ; i++)
 992           serializationInputCorba[i]=serializationInputC[i];
 993         Py_XDECREF(serializationInput);
 994       }
 995       _pynode->defineNewCustomVar(DPL_INFO_NAME,serializationInputCorba);
 996     }
 997   else
 998     {
 999       AutoGIL agil;
1000       PyDict_SetItemString(_context,DPL_INFO_NAME,ob);
1001       Py_XDECREF(ob);
1002     }
1003 }
1004
1005 PyFuncNode::PyFuncNode(const PyFuncNode& other, ComposedNode *father):InlineFuncNode(other,father),_pyfunc(0)
1006 {
1007   _implementation = PythonNode::IMPL_NAME;
1008   {
1009     AutoGIL agil;
1010     _context=PyDict_New();
1011     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1012     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
1013       {
1014         stringstream msg;
1015         msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
1016         _errorDetails=msg.str();
1017         throw Exception(msg.str());
1018       }
1019   }
1020 }
1021
1022 PyFuncNode::PyFuncNode(const std::string& name): InlineFuncNode(name),_pyfunc(0)
1023 {
1024
1025   _implementation = PythonNode::IMPL_NAME;
1026   DEBTRACE( "PyFuncNode::PyFuncNode " << name );
1027   {
1028     AutoGIL agil;
1029     _context=PyDict_New();
1030     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1031     if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
1032       {
1033         stringstream msg;
1034         msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
1035         _errorDetails=msg.str();
1036         throw Exception(msg.str());
1037       }
1038   }
1039 }
1040
1041 PyFuncNode::~PyFuncNode()
1042 {
1043   if(!CORBA::is_nil(_pynode))
1044     {
1045       _pynode->UnRegister();
1046     }
1047 }
1048
1049 void PyFuncNode::init(bool start)
1050 {
1051   initCommonPartWithoutStateManagement(start);
1052   if(_state == YACS::DISABLED)
1053     {
1054       exDisabledState(); // to refresh propagation of DISABLED state
1055       return ;
1056     }
1057   if(start) //complete initialization
1058     setState(YACS::READY);
1059   else if(_state > YACS::LOADED)// WARNING FuncNode has internal vars (CEA usecase) ! Partial initialization (inside a loop). Exclusivity of funcNode.
1060     setState(YACS::TORECONNECT);
1061 }
1062
1063 void PyFuncNode::checkBasicConsistency() const
1064 {
1065   DEBTRACE("checkBasicConsistency");
1066   InlineFuncNode::checkBasicConsistency();
1067   {
1068     AutoGIL agil;
1069     PyObject* res;
1070     res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
1071     if(res == NULL)
1072       {
1073         std::string error="";
1074         PyObject* new_stderr = newPyStdOut(error);
1075         PySys_SetObject((char*)"stderr", new_stderr);
1076         PyErr_Print();
1077         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1078         Py_DECREF(new_stderr);
1079         throw Exception(error);
1080       }
1081     else
1082       Py_XDECREF(res);
1083   }
1084 }
1085
1086 void PyFuncNode::load()
1087 {
1088   DEBTRACE( "---------------PyfuncNode::load function---------------" );
1089   if(_mode==PythonNode::REMOTE_NAME)
1090     loadRemote();
1091   else
1092     loadLocal();
1093 }
1094
1095 void PyFuncNode::loadRemote()
1096 {
1097   commonRemoteLoad(this);
1098 }
1099
1100 void PyFuncNode::loadLocal()
1101 {
1102   DEBTRACE( "---------------PyFuncNode::load function " << getName() << " ---------------" );
1103   DEBTRACE(  _script );
1104
1105 #ifdef _DEVDEBUG_
1106   list<OutputPort *>::iterator iter;
1107   for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
1108     {
1109       OutputPyPort *p=(OutputPyPort *)*iter;
1110       DEBTRACE( "port name: " << p->getName() );
1111       DEBTRACE( "port kind: " << p->edGetType()->kind() );
1112     }
1113 #endif
1114
1115   {
1116     AutoGIL agil;
1117     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1118
1119     std::ostringstream stream;
1120     stream << "/tmp/PythonNode_";
1121     stream << getpid();
1122
1123     PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
1124     if(code == NULL)
1125       {
1126         _errorDetails="";
1127         PyObject* new_stderr = newPyStdOut(_errorDetails);
1128         PySys_SetObject((char*)"stderr", new_stderr);
1129         PyErr_Print();
1130         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1131         Py_DECREF(new_stderr);
1132         throw Exception("Error during execution");
1133       }
1134     PyObject *res = PyEval_EvalCode( code, _context, _context);
1135     Py_DECREF(code);
1136     Py_XDECREF(res);
1137
1138     DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1139     if(PyErr_Occurred ())
1140       {
1141         _errorDetails="";
1142         PyObject* new_stderr = newPyStdOut(_errorDetails);
1143         PySys_SetObject((char*)"stderr", new_stderr);
1144         ofstream errorfile(stream.str().c_str());
1145         if (errorfile.is_open())
1146           {
1147             errorfile << _script;
1148             errorfile.close();
1149           }
1150         PyErr_Print();
1151         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1152         Py_DECREF(new_stderr);
1153         throw Exception("Error during execution");
1154         return;
1155       }
1156     _pyfunc=PyDict_GetItemString(_context,_fname.c_str());
1157     DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1158     if(_pyfunc == NULL)
1159       {
1160         _errorDetails="";
1161         PyObject* new_stderr = newPyStdOut(_errorDetails);
1162         PySys_SetObject((char*)"stderr", new_stderr);
1163         PyErr_Print();
1164         PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1165         Py_DECREF(new_stderr);
1166         throw Exception("Error during execution");
1167       }
1168     DEBTRACE( "---------------End PyFuncNode::load function---------------" );
1169   }
1170 }
1171
1172 void PyFuncNode::execute()
1173 {
1174   if(_mode==PythonNode::REMOTE_NAME)
1175     executeRemote();
1176   else
1177     executeLocal();
1178 }
1179
1180 void PyFuncNode::executeRemote()
1181 {
1182   DEBTRACE( "++++++++++++++ PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1183   if(!_pyfuncSer)
1184     throw Exception("DistributedPythonNode badly loaded");
1185   //
1186   if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
1187     {
1188       bool dummy;
1189       loadPythonAdapter(this,dummy);
1190       _pynode->executeAnotherPieceOfCode(getScript().c_str());
1191     }
1192   //
1193   Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);;
1194   {
1195 #if PY_VERSION_HEX < 0x03070000
1196       std::unique_lock<std::mutex> lock(data_mutex);
1197 #endif
1198       AutoGIL agil;
1199       PyObject *ob(0);
1200       //===========================================================================
1201       // Get inputs in input ports, build a Python tuple and pickle it
1202       //===========================================================================
1203       PyObject *args(PyTuple_New(getNumberOfInputPorts()));
1204       int pos(0);
1205       for(std::list<InputPort *>::iterator iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++,pos++)
1206         {
1207           InputPyPort *p=(InputPyPort *)*iter2;
1208           ob=p->getPyObj();
1209           Py_INCREF(ob);
1210           PyTuple_SetItem(args,pos,ob);
1211         }
1212 #ifdef _DEVDEBUG_
1213       PyObject_Print(args,stderr,Py_PRINT_RAW);
1214       std::cerr << endl;
1215 #endif
1216       PyObject *serializationInput=PyObject_CallObject(_pyfuncSer,args);
1217       Py_DECREF(args);
1218       //The pickled string may contain NULL characters so use PyString_AsStringAndSize
1219       char *serializationInputC(0);
1220       Py_ssize_t len;
1221       if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
1222         throw Exception("DistributedPythonNode problem in python pickle");
1223
1224       serializationInputCorba->length(len);
1225       for(int i=0; i < len ; i++)
1226         serializationInputCorba[i]=serializationInputC[i];
1227       Py_DECREF(serializationInput);
1228   }
1229
1230   //===========================================================================
1231   // Execute in remote Python node
1232   //===========================================================================
1233   DEBTRACE( "-----------------starting remote python invocation-----------------" );
1234   Engines::pickledArgs_var resultCorba;
1235   try
1236     {
1237       resultCorba=_pynode->execute(getFname().c_str(),serializationInputCorba);
1238     }
1239   catch( const SALOME::SALOME_Exception& ex )
1240     {
1241       std::string msg="Exception on remote python invocation";
1242       msg += '\n';
1243       msg += ex.details.text.in();
1244       _errorDetails=msg;
1245       throw Exception(msg);
1246     }
1247   catch(CORBA::COMM_FAILURE& ex)
1248     {
1249       std::ostringstream msg;
1250       msg << "Exception on remote python invocation." << std::endl ;
1251       msg << "Caught system exception COMM_FAILURE -- unable to contact the "
1252           << "object." << std::endl;
1253       _errorDetails=msg.str();
1254       throw Exception(msg.str());
1255     }
1256   catch(CORBA::SystemException& ex)
1257     {
1258       std::ostringstream msg;
1259       msg << "Exception on remote python invocation." << std::endl ;
1260       msg << "Caught a CORBA::SystemException." ;
1261       CORBA::Any tmp;
1262       tmp <<= ex;
1263       CORBA::TypeCode_var tc = tmp.type();
1264       const char *p = tc->name();
1265       if ( *p != '\0' )
1266         msg <<p;
1267       else
1268         msg  << tc->id();
1269       msg << std::endl;
1270       _errorDetails=msg.str();
1271       throw Exception(msg.str());
1272     }
1273   catch(CORBA::Exception& ex)
1274     {
1275       std::ostringstream msg;
1276       msg << "Exception on remote python invocation." << std::endl ;
1277       msg << "Caught CORBA::Exception. " ;
1278       CORBA::Any tmp;
1279       tmp <<= ex;
1280       CORBA::TypeCode_var tc = tmp.type();
1281       const char *p = tc->name();
1282       if ( *p != '\0' )
1283         msg <<p;
1284       else
1285         msg  << tc->id();
1286       msg << std::endl;
1287       _errorDetails=msg.str();
1288       throw Exception(msg.str());
1289     }
1290   catch(omniORB::fatalException& fe)
1291     {
1292       std::ostringstream msg;
1293       msg << "Exception on remote python invocation." << std::endl ;
1294       msg << "Caught omniORB::fatalException:" << std::endl;
1295       msg << "  file: " << fe.file() << std::endl;
1296       msg << "  line: " << fe.line() << std::endl;
1297       msg << "  mesg: " << fe.errmsg() << std::endl;
1298       _errorDetails=msg.str();
1299       throw Exception(msg.str());
1300     }
1301   DEBTRACE( "-----------------end of remote python invocation-----------------" );
1302   //===========================================================================
1303   // Get results, unpickle and put them in output ports
1304   //===========================================================================
1305   char *resultCorbaC=new char[resultCorba->length()+1];
1306   resultCorbaC[resultCorba->length()]='\0';
1307   for(int i=0;i<resultCorba->length();i++)
1308     resultCorbaC[i]=resultCorba[i];
1309
1310   {
1311 #if PY_VERSION_HEX < 0x03070000
1312       std::unique_lock<std::mutex> lock(data_mutex);
1313 #endif
1314       AutoGIL agil;
1315
1316       PyObject *resultPython(PyBytes_FromStringAndSize(resultCorbaC,resultCorba->length()));
1317       delete [] resultCorbaC;
1318       PyObject *args(PyTuple_New(1)),*ob(0);
1319       PyTuple_SetItem(args,0,resultPython);
1320       PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
1321       Py_DECREF(args);
1322
1323       DEBTRACE( "-----------------PythonNode::outputs-----------------" );
1324       int nres=1;
1325       if(finalResult == Py_None)
1326         nres=0;
1327       else if(PyTuple_Check(finalResult))
1328         nres=PyTuple_Size(finalResult);
1329
1330       if(getNumberOfOutputPorts() != nres)
1331         {
1332           std::string msg="Number of output arguments : Mismatch between definition and execution";
1333           Py_DECREF(finalResult);
1334           _errorDetails=msg;
1335           throw Exception(msg);
1336         }
1337
1338       try
1339       {
1340           int pos(0);
1341           for(std::list<OutputPort *>::iterator iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++, pos++)
1342             {
1343               OutputPyPort *p=(OutputPyPort *)*iter;
1344               DEBTRACE( "port name: " << p->getName() );
1345               DEBTRACE( "port kind: " << p->edGetType()->kind() );
1346               DEBTRACE( "port pos : " << pos );
1347               if(PyTuple_Check(finalResult))
1348                 ob=PyTuple_GetItem(finalResult,pos) ;
1349               else
1350                 ob=finalResult;
1351               DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1352               p->put(ob);
1353             }
1354           Py_DECREF(finalResult);
1355       }
1356       catch(ConversionException& ex)
1357       {
1358           Py_DECREF(finalResult);
1359           _errorDetails=ex.what();
1360           throw;
1361       }
1362   }
1363
1364   DEBTRACE( "++++++++++++++ ENDOF PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1365 }
1366
1367 void PyFuncNode::executeLocal()
1368 {
1369   DEBTRACE( "++++++++++++++ PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1370
1371   int pos=0;
1372   PyObject* ob;
1373   if(!_pyfunc)throw Exception("PyFuncNode badly loaded");
1374   {
1375       AutoGIL agil;
1376       DEBTRACE( "---------------PyFuncNode::inputs---------------" );
1377       PyObject* args = PyTuple_New(getNumberOfInputPorts()) ;
1378       list<InputPort *>::iterator iter2;
1379       for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
1380         {
1381           InputPyPort *p=(InputPyPort *)*iter2;
1382           DEBTRACE( "port name: " << p->getName() );
1383           DEBTRACE( "port kind: " << p->edGetType()->kind() );
1384           ob=p->getPyObj();
1385 #ifdef _DEVDEBUG_
1386           PyObject_Print(ob,stderr,Py_PRINT_RAW);
1387           cerr << endl;
1388 #endif
1389           DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1390           Py_INCREF(ob);
1391           PyTuple_SetItem(args,pos,ob);
1392           DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1393           pos++;
1394         }
1395       DEBTRACE( "---------------End PyFuncNode::inputs---------------" );
1396
1397       DEBTRACE( "----------------PyFuncNode::calculation---------------" );
1398 #ifdef _DEVDEBUG_
1399       PyObject_Print(_pyfunc,stderr,Py_PRINT_RAW);
1400       cerr << endl;
1401       PyObject_Print(args,stderr,Py_PRINT_RAW);
1402       cerr << endl;
1403 #endif
1404       DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1405       PyObject* result = PyObject_CallObject( _pyfunc , args ) ;
1406       DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1407       Py_DECREF(args);
1408       fflush(stdout);
1409       fflush(stderr);
1410       if(result == NULL)
1411         {
1412           _errorDetails="";
1413           PyObject* new_stderr = newPyStdOut(_errorDetails);
1414           PySys_SetObject((char*)"stderr", new_stderr);
1415           std::ostringstream stream;
1416           stream << "/tmp/PythonNode_";
1417           stream << getpid();
1418           ofstream errorfile(stream.str().c_str());
1419           if (errorfile.is_open())
1420             {
1421               errorfile << _script;
1422               errorfile.close();
1423             }
1424           PyErr_Print();
1425           PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1426           Py_DECREF(new_stderr);
1427           throw Exception("Error during execution");
1428         }
1429       DEBTRACE( "----------------End PyFuncNode::calculation---------------" );
1430
1431       DEBTRACE( "-----------------PyFuncNode::outputs-----------------" );
1432       int nres=1;
1433       if(result == Py_None)
1434         nres=0;
1435       else if(PyTuple_Check(result))
1436         nres=PyTuple_Size(result);
1437
1438       if(getNumberOfOutputPorts() != nres)
1439         {
1440           std::string msg="Number of output arguments : Mismatch between definition and execution";
1441           Py_DECREF(result);
1442           _errorDetails=msg;
1443           throw Exception(msg);
1444         }
1445
1446       pos=0;
1447 #ifdef _DEVDEBUG_
1448       PyObject_Print(result,stderr,Py_PRINT_RAW);
1449       cerr << endl;
1450 #endif
1451       list<OutputPort *>::iterator iter;
1452       try
1453       {
1454           for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
1455             {
1456               OutputPyPort *p=(OutputPyPort *)*iter;
1457               DEBTRACE( "port name: " << p->getName() );
1458               DEBTRACE( "port kind: " << p->edGetType()->kind() );
1459               DEBTRACE( "port pos : " << pos );
1460               if(PyTuple_Check(result))ob=PyTuple_GetItem(result,pos) ;
1461               else ob=result;
1462               DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1463 #ifdef _DEVDEBUG_
1464               PyObject_Print(ob,stderr,Py_PRINT_RAW);
1465               cerr << endl;
1466 #endif
1467               p->put(ob);
1468               pos++;
1469             }
1470       }
1471       catch(ConversionException& ex)
1472       {
1473           Py_DECREF(result);
1474           _errorDetails=ex.what();
1475           throw;
1476       }
1477       DEBTRACE( "-----------------End PyFuncNode::outputs-----------------" );
1478       Py_DECREF(result);
1479   }
1480   DEBTRACE( "++++++++++++++ End PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1481 }
1482
1483 Node *PyFuncNode::simpleClone(ComposedNode *father, bool editionOnly) const
1484 {
1485   return new PyFuncNode(*this,father);
1486 }
1487
1488 void PyFuncNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
1489 {
1490   if(!CORBA::is_nil(_pynode))
1491     _pynode->UnRegister();
1492   _pynode=objContainer->createPyNode(getName().c_str(),getScript().c_str());
1493 }
1494
1495 Engines::PyNodeBase_var PyFuncNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
1496 {
1497   Engines::PyNode_var ret(objContainer->getDefaultPyNode(getName().c_str()));
1498   if(!CORBA::is_nil(ret))
1499     {
1500       ret->Register();
1501     }
1502   return Engines::PyNodeBase::_narrow(ret);
1503 }
1504
1505 void PyFuncNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
1506 {
1507   if(!CORBA::is_nil(_pynode))
1508     {
1509       Engines::PyNode_var tmpp(Engines::PyNode::_narrow(remoteInterp));
1510       if(_pynode->_is_equivalent(tmpp))
1511         return ;
1512     }
1513   if(!CORBA::is_nil(_pynode))
1514     _pynode->UnRegister();
1515   _pynode=Engines::PyNode::_narrow(remoteInterp);
1516 }
1517
1518 Engines::PyNodeBase_var PyFuncNode::getRemoteInterpreterHandle()
1519 {
1520   return Engines::PyNodeBase::_narrow(_pynode);
1521 }
1522
1523 //! Create a new node of same type with a given name
1524 PyFuncNode* PyFuncNode::cloneNode(const std::string& name)
1525 {
1526   PyFuncNode* n=new PyFuncNode(name);
1527   n->setScript(_script);
1528   n->setFname(_fname);
1529   list<InputPort *>::iterator iter;
1530   for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
1531     {
1532       InputPyPort *p=(InputPyPort *)*iter;
1533       n->edAddInputPort(p->getName(),p->edGetType());
1534     }
1535   list<OutputPort *>::iterator iter2;
1536   for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
1537     {
1538       OutputPyPort *p=(OutputPyPort *)*iter2;
1539       n->edAddOutputPort(p->getName(),p->edGetType());
1540     }
1541   return n;
1542 }
1543
1544 std::string PyFuncNode::getContainerLog()
1545 {
1546   return PythonEntry::GetContainerLog(_mode,_container,this);
1547 }
1548
1549 void PyFuncNode::shutdown(int level)
1550 {
1551   DEBTRACE("PyFuncNode::shutdown " << level);
1552   if(_mode=="local")return;
1553   if(_container)
1554     {
1555       if(!CORBA::is_nil(_pynode)) _pynode->UnRegister();
1556       _pynode=Engines::PyNode::_nil();
1557       _container->shutdown(level);
1558     }
1559 }
1560
1561 void PyFuncNode::imposeResource(const std::string& resource_name,
1562                                 const std::string& container_name)
1563 {
1564   if(!resource_name.empty() && !container_name.empty())
1565   {
1566     _imposedResource = resource_name;
1567     _imposedContainer = container_name;
1568   }
1569 }
1570
1571 bool PyFuncNode::canAcceptImposedResource()
1572 {
1573   return _container != nullptr && _container->canAcceptImposedResource();
1574 }
1575
1576 bool PyFuncNode::hasImposedResource()const
1577 {
1578   return PythonEntry::hasImposedResource();
1579 }
1580