Version: 8.3.0
DistributedPythonNode.cxx
Go to the documentation of this file.
1 // Copyright (C) 2006-2016 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 "DistributedPythonNode.hxx"
21 #include "RuntimeSALOME.hxx"
22 #include "SalomeContainer.hxx"
23 #include "PythonNode.hxx"
24 #include "SalomeHPContainer.hxx"
25 #include "SalomeContainerTmpForHP.hxx"
26 #include "AutoGIL.hxx"
27 
28 #include "PythonPorts.hxx"
29 #include "YacsTrace.hxx"
30 #include "PyStdout.hxx"
31 
32 using namespace YACS::ENGINE;
33 using namespace std;
34 
35 const char DistributedPythonNode::KIND[]="DistPython";
36 const char DistributedPythonNode::IMPL_NAME[]="Python";
37 const char DistributedPythonNode::SALOME_CONTAINER_METHOD_IDL[]="createPyNode";
38 
39 Node *DistributedPythonNode::simpleClone(ComposedNode *father, bool editionOnly) const
40 {
41  return new DistributedPythonNode(*this,father);
42 }
43 
44 DistributedPythonNode::DistributedPythonNode(const std::string& name):ServerNode(name),_context(0),_pyfuncSer(0),_pyfuncUnser(0)
45 {
46  initMySelf();
47 }
48 
49 DistributedPythonNode::DistributedPythonNode(const DistributedPythonNode& other, ComposedNode *father):ServerNode(other,father),_context(0),_pyfuncSer(0),_pyfuncUnser(0)
50 {
51  initMySelf();
52 }
53 
54 DistributedPythonNode::~DistributedPythonNode()
55 {
56  AutoGIL agil;
57  Py_DECREF(_context);
58 }
59 
60 void DistributedPythonNode::load()
61 {
62  bool isContAlreadyStarted(false);
63  if(_container)
64  isContAlreadyStarted=_container->isAlreadyStarted(this);
65  ServerNode::load();
66  {
67  AutoGIL agil;
68  if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
69  {
70  stringstream msg;
71  msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
72  _errorDetails=msg.str();
73  throw Exception(msg.str());
74  }
75  const char picklizeScript[]="import cPickle\ndef pickleForDistPyth2009(*args,**kws):\n return cPickle.dumps((args,kws),-1)\n\ndef unPickleForDistPyth2009(st):\n args=cPickle.loads(st)\n return args\n";
76  PyObject *res=PyRun_String(picklizeScript,Py_file_input,_context,_context);
77  if(res == NULL)
78  {
79  _errorDetails="";
80  PyObject* new_stderr = newPyStdOut(_errorDetails);
81  PySys_SetObject((char*)"stderr", new_stderr);
82  PyErr_Print();
83  PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
84  Py_DECREF(new_stderr);
85  throw Exception("Error during execution");
86  return;
87  }
88  Py_DECREF(res);
89  _pyfuncSer=PyDict_GetItemString(_context,"pickleForDistPyth2009");
90  _pyfuncUnser=PyDict_GetItemString(_context,"unPickleForDistPyth2009");
91  if(_pyfuncSer == NULL)
92  {
93  _errorDetails="";
94  PyObject* new_stderr = newPyStdOut(_errorDetails);
95  PySys_SetObject((char*)"stderr", new_stderr);
96  PyErr_Print();
97  PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
98  Py_DECREF(new_stderr);
99  throw Exception("Error during execution");
100  }
101  if(_pyfuncUnser == NULL)
102  {
103  _errorDetails="";
104  PyObject* new_stderr = newPyStdOut(_errorDetails);
105  PySys_SetObject((char*)"stderr", new_stderr);
106  PyErr_Print();
107  PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
108  Py_DECREF(new_stderr);
109  throw Exception("Error during execution");
110  }
111 
112  Engines::Container_var objContainer=Engines::Container::_nil();
113  if(!_container)
114  throw Exception("No container specified !");
115  SalomeContainer *containerCast0(dynamic_cast<SalomeContainer *>(_container));
116  SalomeHPContainer *containerCast1(dynamic_cast<SalomeHPContainer *>(_container));
117  if(containerCast0)
118  objContainer=containerCast0->getContainerPtr(this);
119  else if(containerCast1)
120  {
121  YACS::BASES::AutoCppPtr<SalomeContainerTmpForHP> tmpCont(SalomeContainerTmpForHP::BuildFrom(containerCast1,this));
122  objContainer=tmpCont->getContainerPtr(this);
123  }
124  else
125  throw Exception("Unrecognized type of container ! Salome one is expected !");
126  if(CORBA::is_nil(objContainer))
127  throw Exception("Container corba pointer is NULL !");
128 
129  try
130  {
131  if(containerCast0 || !isContAlreadyStarted)
132  {
133  _pynode = objContainer->createPyNode(getName().c_str(),getScript().c_str());
134  }
135  else
136  {
137  Engines::PyNode_var dftPyScript(objContainer->getDefaultPyNode(getName().c_str()));
138  if(CORBA::is_nil(dftPyScript))
139  _pynode = objContainer->createPyNode(getName().c_str(),getScript().c_str());
140  else
141  _pynode = dftPyScript;
142  }
143  }
144  catch( const SALOME::SALOME_Exception& ex )
145  {
146  std::string msg="Exception on remote python node creation ";
147  msg += '\n';
148  msg += ex.details.text.in();
149  _errorDetails=msg;
150  throw Exception(msg);
151  }
152 
153  if(CORBA::is_nil(_pynode))
154  throw Exception("In DistributedPythonNode the ref in NULL ! ");
155 
156 
157  DEBTRACE( "---------------End PyfuncSerNode::load function---------------" );
158  }
159 }
160 
161 void DistributedPythonNode::execute()
162 {
163  YACSTRACE(1,"+++++++++++++++++ DistributedPythonNode::execute: " << getName() << " " << getFname() << " +++++++++++++++++" );
165  PyObject* ob;
166  if(!_pyfuncSer)
167  throw Exception("DistributedPythonNode badly loaded");
168  Engines::pickledArgs *serializationInputCorba(0);
169  PyObject *args(0);
170  {
171  AutoGIL agil;
172 
173  DEBTRACE( "---------------DistributedPythonNode::inputs---------------" );
174  args = PyTuple_New(getNumberOfInputPorts()) ;
175  int pos=0;
176  for(list<InputPort *>::iterator iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++,pos++)
177  {
178  InputPyPort *p=(InputPyPort *)*iter2;
179  ob=p->getPyObj();
180  Py_INCREF(ob);
181  PyTuple_SetItem(args,pos,ob);
182  }
183  PyObject *serializationInput=PyObject_CallObject(_pyfuncSer,args);
184  std::string serializationInputC=PyString_AsString(serializationInput);
185  serializationInputCorba=new Engines::pickledArgs;
186  int len=serializationInputC.length();
187  serializationInputCorba->length(serializationInputC.length());
188  for(int i=0;i<serializationInputC.length();i++)
189  (*serializationInputCorba)[i]=serializationInputC[i];
190  Py_DECREF(serializationInput);
191  }
192  //serializationInputCorba[serializationInputC.length()]='\0';
193  DEBTRACE( "-----------------DistributedPythonNode starting remote python invocation-----------------" );
194  Engines::pickledArgs *resultCorba;
195  try
196  {
197  resultCorba=_pynode->execute(getFname().c_str(),*serializationInputCorba);
198  }
199  catch(...)
200  {
201  std::string msg="Exception on remote python invocation";
202  _errorDetails=msg;
203  throw Exception(msg);
204  }
205  DEBTRACE( "-----------------DistributedPythonNode end of remote python invocation-----------------" );
206  //
207  delete serializationInputCorba;
208  char *resultCorbaC=new char[resultCorba->length()+1];
209  resultCorbaC[resultCorba->length()]='\0';
210  for(int i=0;i<resultCorba->length();i++)
211  resultCorbaC[i]=(*resultCorba)[i];
212  delete resultCorba;
213  {
214  AutoGIL agil;
215  args = PyTuple_New(1);
216  PyObject* resultPython=PyString_FromString(resultCorbaC);
217  delete [] resultCorbaC;
218  PyTuple_SetItem(args,0,resultPython);
219  PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
220  DEBTRACE( "-----------------DistributedPythonNode::outputs-----------------" );
221  int nres=1;
222  if(finalResult == Py_None)
223  nres=0;
224  else if(PyTuple_Check(finalResult))
225  nres=PyTuple_Size(finalResult);
226 
227  if(getNumberOfOutputPorts() != nres)
228  {
229  std::string msg="Number of output arguments : Mismatch between definition and execution";
230  Py_DECREF(finalResult);
231  _errorDetails=msg;
232  throw Exception(msg);
233  }
234  try
235  {
236  int pos(0);
237  for(list<OutputPort *>::iterator iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++, pos++)
238  {
239  OutputPyPort *p=(OutputPyPort *)*iter;
240  DEBTRACE( "port name: " << p->getName() );
241  DEBTRACE( "port kind: " << p->edGetType()->kind() );
242  DEBTRACE( "port pos : " << pos );
243  if(PyTuple_Check(finalResult))ob=PyTuple_GetItem(finalResult,pos) ;
244  else ob=finalResult;
245  DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
246  p->put(ob);
247  }
248  }
249  catch(ConversionException& ex)
250  {
251  Py_DECREF(finalResult);
252  _errorDetails=ex.what();
253  throw;
254  }
255  }
256  DEBTRACE( "++++++++++++++ End DistributedPythonNode::execute: " << getName() << " ++++++++++++++++++++" );
257 }
258 
259 std::string DistributedPythonNode::getEffectiveKindOfServer() const
260 {
261  return "Salome";
262 }
263 
264 std::string DistributedPythonNode::getKind() const
265 {
267  return PythonNode::KIND;
268 }
269 
270 ServerNode *DistributedPythonNode::createNode(const std::string& name) const
271 {
272  ServerNode *ret=new DistributedPythonNode(name);
273  ret->setContainer(_container);
274  return ret;
275 }
276 
277 void DistributedPythonNode::initMySelf()
278 {
279  _implementation = DistributedPythonNode::IMPL_NAME;
280  AutoGIL agil;
281  _context=PyDict_New();
282 }
283 
284 void DistributedPythonNode::dealException(CORBA::Exception *exc, const char *method, const char *ref)
285 {
286  if( exc )
287  {
288  DEBTRACE( "An exception was thrown!" );
289  DEBTRACE( "The raised exception is of Type:" << exc->_name() );
290 
291  CORBA::SystemException* sysexc;
292  sysexc=CORBA::SystemException::_downcast(exc);
293  if(sysexc != NULL)
294  {
295  // It's a SystemException
296  DEBTRACE( "minor code: " << sysexc->minor() );
297  DEBTRACE( "completion code: " << sysexc->completed() );
298  std::string text="Execution problem: ";
299  std::string excname=sysexc->_name();
300  if(excname == "BAD_OPERATION")
301  {
302  text=text+"bad operation detected";
303  }
304  else if(excname == "MARSHAL" && sysexc->minor() == omni::MARSHAL_PassEndOfMessage)
305  {
306  text=text+"probably an error in arguments of service '" + method + "' from component '" +ref+ "'";
307  }
308  else if(excname == "COMM_FAILURE" && sysexc->minor() == omni::COMM_FAILURE_UnMarshalResults)
309  {
310  text=text+"probably an error in output arguments of service '" + method + "' from component '" +ref+ "'";
311  }
312  else if(excname == "COMM_FAILURE" && sysexc->minor() == omni::COMM_FAILURE_UnMarshalArguments)
313  {
314  text=text+"probably an error in input arguments of service '" + method + "' from component '" +ref+ "'";
315  }
316  else if(excname == "COMM_FAILURE" && sysexc->minor() == omni::COMM_FAILURE_WaitingForReply)
317  {
318  text=text+"probably an error in input arguments of service '" + method + "' from component '" +ref+ "'";
319  }
320  else
321  {
322  DEBTRACE(sysexc->NP_minorString() );
323  text=text+"System Exception "+ excname;
324  }
325  _errorDetails=text;
326  throw Exception(text);
327  }
328 
329  // Not a System Exception
330  CORBA::UnknownUserException* userexc;
331  userexc=CORBA::UnknownUserException::_downcast(exc);
332  if(userexc != NULL)
333  {
334  CORBA::Any anyExcept = userexc->exception();
335 
336  const SALOME::SALOME_Exception* salexc;
337  if(anyExcept >>= salexc)
338  {
339  DEBTRACE("SALOME_Exception: "<< salexc->details.sourceFile);
340  DEBTRACE("SALOME_Exception: "<<salexc->details.lineNumber);
341  _errorDetails=salexc->details.text;
342  throw Exception("Execution problem: Salome Exception occurred" + getErrorDetails() );
343  }
344  std::string msg="Execution problem: User Exception occurred";
345  _errorDetails=msg;
346  throw Exception(msg);
347  }
348  std::string msg="Execution problem";
349  _errorDetails=msg;
350  throw Exception(msg);
351  }
352 }