]> SALOME platform Git repositories - modules/kernel.git/blob - src/SALOMESDS/SALOMESDS_DataScopeServer.cxx
Salome HOME
[EDF17719] : Comparison between 2 objects is now a user defined function called ...
[modules/kernel.git] / src / SALOMESDS / SALOMESDS_DataScopeServer.cxx
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
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 // Author : Anthony GEAY (EDF R&D)
20
21 #include "SALOMESDS_DataScopeServer.hxx"
22 #include "SALOMESDS_DataServerManager.hxx"
23 #include "SALOMESDS_PickelizedPyObjRdOnlyServer.hxx"
24 #include "SALOMESDS_PickelizedPyObjRdExtServer.hxx"
25 #include "SALOMESDS_PickelizedPyObjRdWrServer.hxx"
26 #include "SALOMESDS_PickelizedPyObjRdExtInitServer.hxx"
27 #include "SALOMESDS_TrustTransaction.hxx"
28 #include "SALOMESDS_KeyWaiter.hxx"
29 #include "SALOMESDS_Transaction.hxx"
30 #include "SALOME_NamingService.hxx"
31 #include "SALOMESDS_Exception.hxx"
32
33 #include <sstream>
34 #include <iterator>
35 #include <algorithm>
36
37 // agy : awful, to be factorized with ContainerManager.
38 #ifndef WIN32
39 #include <unistd.h>
40 #else
41 #include <process.h>
42 #define getpid _getpid
43 #endif
44
45 using namespace SALOMESDS;
46
47 std::size_t DataScopeServerBase::COUNTER=0;
48
49 #if PY_VERSION_HEX < 0x03050000
50 static char*
51 Py_EncodeLocale(const wchar_t *arg, size_t *size)
52 {
53         return _Py_wchar2char(arg, size);
54 }
55 static wchar_t*
56 Py_DecodeLocale(const char *arg, size_t *size)
57 {
58         return _Py_char2wchar(arg, size);
59 }
60 #endif
61
62 void DataScopeKiller::shutdown()
63 {
64   Py_Finalize();
65   _orb->shutdown(0);
66 }
67
68 RequestSwitcher::RequestSwitcher(CORBA::ORB_ptr orb, DataScopeServerTransaction *ds):RequestSwitcherBase(orb),_ds(ds)
69 {
70 }
71
72 SALOME::StringVec *RequestSwitcher::listVars()
73 {
74   return _ds->listVars();
75 }
76
77 SALOME::ByteVec *RequestSwitcher::fetchSerializedContent(const char *varName)
78 {
79   return _ds->fetchSerializedContent(varName);
80 }
81
82 void RequestSwitcher::fetchAndGetAccessOfVar(const char *varName, CORBA::String_out access, SALOME::ByteVec_out data)
83 {
84   return _ds->fetchAndGetAccessOfVar(varName,access,data);
85 }
86
87 DataScopeServerBase::DataScopeServerBase(CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName):_globals(0),_locals(0),_pickler(0),_orb(CORBA::ORB::_duplicate(orb)),_name(scopeName),_killer(killer)
88 {
89 }
90
91 DataScopeServerBase::DataScopeServerBase(const DataScopeServerBase& other):omniServant(other),ServantBase(other),_globals(0),_locals(0),_pickler(0),_name(other._name),_vars(other._vars),_killer(other._killer)
92 {
93 }
94
95 DataScopeServerBase::~DataScopeServerBase()
96 {
97   // _globals is borrowed ref -> do nothing
98   Py_XDECREF(_locals);
99   Py_XDECREF(_pickler);
100   for(std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it=_vars.begin();it!=_vars.end();it++)
101     {
102        BasicDataServer *obj((*it).second);
103        if(obj)
104          {
105            obj->decrRef();
106          }
107     }
108 }
109
110 /*!
111  * Called remotely -> to protect against throw
112  */
113 void DataScopeServerBase::ping()
114 {
115 }
116
117 /*!
118  * Called remotely -> to protect against throw
119  */
120 char *DataScopeServerBase::getScopeName()
121 {
122   return CORBA::string_dup(_name.c_str());
123 }
124
125 /*!
126  * Called remotely -> to protect against throw
127  */
128 SALOME::StringVec *DataScopeServerBase::listVars()
129 {
130   SALOME::StringVec *ret(new SALOME::StringVec);
131   std::size_t sz(_vars.size());
132   ret->length(sz);
133   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(_vars.begin());
134   for(std::size_t i=0;i<sz;it++,i++)
135     {
136       BasicDataServer *obj((*it).second);
137       std::string name(obj->getVarNameCpp());
138       (*ret)[i]=CORBA::string_dup(name.c_str());
139     }
140   return ret;
141 }
142
143 CORBA::Boolean DataScopeServerBase::existVar(const char *varName)
144 {
145   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it(_vars.begin());
146   for(;it!=_vars.end();it++)
147     if((*it).second->getVarNameCpp()==varName)
148       return true;
149   return false;
150 }
151
152 SALOME::BasicDataServer_ptr DataScopeServerBase::retrieveVarInternal(const char *varName)
153 {
154   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it0(retrieveVarInternal3(varName));
155   return SALOME::BasicDataServer::_duplicate((*it0).first);
156 }
157
158 BasicDataServer *DataScopeServerBase::retrieveVarInternal2(const std::string& varName)
159 {
160   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it0(retrieveVarInternal3(varName));
161   return (*it0).second;
162 }
163
164 void DataScopeServerBase::deleteVar(const char *varName)
165 {
166   std::string varNameCpp(varName);
167   std::vector<std::string> allNames(getAllVarNames());
168   std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varNameCpp));
169   if(it==allNames.end())
170     {
171       std::ostringstream oss; oss << "DataScopeServerBase::deleteVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
172       std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
173       throw Exception(oss.str());
174     }
175   std::size_t pos(std::distance(allNames.begin(),it));
176   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it0(_vars.begin());
177   for(std::size_t ii=0;ii<pos;ii++,it0++);
178   (*it0).second->decrRef();
179   _vars.erase(it0);
180 }
181
182 CORBA::Boolean DataScopeServerBase::shutdownIfNotHostedByDSM(SALOME::DataScopeKiller_out killer)
183 {
184   SALOME_NamingService ns(_orb);
185   CORBA::Object_var obj(ns.Resolve(DataServerManager::NAME_IN_NS));
186   SALOME::DataServerManager_var dsm(SALOME::DataServerManager::_narrow(obj));
187   if(CORBA::is_nil(dsm))
188     throw Exception("Unable to reach in the NS the unique DataServerManager instance of the Session !");
189   // destroy ref in the naming service
190   std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
191   ns.Destroy_Name(fullScopeName.c_str());
192   // establish if dsm and this shared the same POA. If yes dsm and this are collocated !
193   PortableServer::ServantBase *ret(0);
194   try
195     {
196       ret=_poa->reference_to_servant(dsm);
197     }
198   catch(...) { ret=0; }
199   //
200   if(!ret)
201     {
202       enforcedRelease();
203       killer=SALOME::DataScopeKiller::_duplicate(_killer);
204       return true;
205     }
206   else
207     {
208       ret->_remove_ref();
209       enforcedRelease();
210       killer=SALOME::DataScopeKiller::_duplicate(_killer);
211       return false;
212     }
213 }
214
215 SALOME::ByteVec *DataScopeServerBase::fetchSerializedContent(const char *varName)
216 {
217   BasicDataServer *var(retrieveVarInternal2(varName));
218   PickelizedPyObjServer *varc(dynamic_cast<PickelizedPyObjServer *>(var));
219   if(!varc)
220     {
221       std::ostringstream oss; oss << "DataScopeServerBase::fetchSerializedContent : var \"" << varName << "\" exists but it is not serialized !";
222       throw Exception(oss.str());
223     }
224   return varc->fetchSerializedContent();
225 }
226
227 SALOME::SeqOfByteVec *DataScopeServerBase::getAllKeysOfVarWithTypeDict(const char *varName)
228 {
229   BasicDataServer *var(retrieveVarInternal2(varName));
230   PickelizedPyObjServer *varc(dynamic_cast<PickelizedPyObjServer *>(var));
231   if(!varc)
232     {
233       std::ostringstream oss; oss << "DataScopeServerBase::getAllKeysOfVarWithTypeDict : var \"" << varName << "\" exists but it is not serialized !";
234       throw Exception(oss.str());
235     }
236   if(!varc->isDict())
237     {
238       std::ostringstream oss; oss << "DataScopeServerBase::getAllKeysOfVarWithTypeDict : var \"" << varName << "\" exists but it is not a PyDict !";
239       throw Exception(oss.str());
240     }
241   PyObject *keys(PyDict_Keys(varc->getPyObj()));
242   if(!PyList_Check(keys))
243     {
244       std::ostringstream oss; oss << "DataScopeServerBase::getAllKeysOfVarWithTypeDict : var \"" << varName << "\" has keys but not of type list !";
245       throw Exception(oss.str());
246     }
247   Py_ssize_t sz(PyList_Size(keys));
248   SALOME::SeqOfByteVec *ret(new SALOME::SeqOfByteVec);
249   ret->length(sz);
250   for(Py_ssize_t i=0;i<sz;i++)
251     {
252       PyObject *item(PyList_GetItem(keys,i));
253       Py_XINCREF(item);
254       std::string pickel(varc->pickelize(item));//item consumed
255       PickelizedPyObjServer::FromCppToByteSeq(pickel,(*ret)[i]);
256     }
257   Py_XDECREF(keys);
258   return ret;
259 }
260
261 void DataScopeServerBase::takeANap(CORBA::Double napDurationInSec)
262 {
263   if(napDurationInSec<0.)
264     throw Exception("DataScopeServerBase::takeANap : negative value !");
265 #ifndef WIN32
266   struct timespec req,rem;
267   long nbSec((long)napDurationInSec);
268   double remainTime(napDurationInSec-(double)nbSec);
269   req.tv_sec=nbSec;
270   req.tv_nsec=(long)(remainTime*1000000.);
271   int ret(nanosleep(&req,&rem));
272   if(ret!=0)
273     throw Exception("DataScopeServerBase::takeANap : nap not finished as expected !");
274 #else
275   throw Exception("DataScopeServerBase::takeANap : not implemented for Windows !");
276 #endif
277 }
278
279 void DataScopeServerBase::initializePython(int argc, char *argv[])
280 {
281   Py_Initialize();
282   PyEval_InitThreads();
283   wchar_t **changed_argv = new wchar_t*[argc]; // Setting arguments
284   for (int i = 0; i < argc; i++)
285     changed_argv[i] = Py_DecodeLocale(argv[i], NULL);
286   PySys_SetArgv(argc, changed_argv);
287   PyObject *mainmod(PyImport_AddModule("__main__"));
288   _globals=PyModule_GetDict(mainmod);
289   if(PyDict_GetItemString(_globals, "__builtins__") == NULL)
290     {
291       PyObject *bimod(PyImport_ImportModule("__builtin__"));
292       if (bimod == NULL || PyDict_SetItemString(_globals, "__builtins__", bimod) != 0)
293         Py_FatalError("can't add __builtins__ to __main__");
294       Py_XDECREF(bimod);
295     }
296   _locals=PyDict_New();
297   PyObject *tmp(PyList_New(0));
298   _pickler=PyImport_ImportModuleLevel(const_cast<char *>("pickle"),_globals,_locals,tmp,0);
299 }
300
301 void DataScopeServerBase::registerToSalomePiDict() const
302 {
303   PyObject *mod(PyImport_ImportModule("addToKillList"));//new value
304   if(!mod)
305     return;
306   PyObject *meth(PyObject_GetAttrString(mod,"addToKillList"));//new value
307   if(!meth)
308     { Py_XDECREF(mod); return ; }
309   PyObject *args(PyTuple_New(2));
310   PyTuple_SetItem(args,0,PyLong_FromLong(getpid()));
311   PyTuple_SetItem(args,1,PyUnicode_FromString("SALOME_DataScopeServerBase"));
312   PyObject *res(PyObject_CallObject(meth,args));
313   Py_XDECREF(args);
314   Py_XDECREF(res);
315   Py_XDECREF(meth);
316   Py_XDECREF(mod);
317 }
318
319 void DataScopeServerBase::setPOA(PortableServer::POA_var poa)
320 {
321   _poa=poa;
322 }
323
324 void DataScopeServerBase::registerInNS(SALOME::DataScopeServerBase_ptr ptr)
325 {
326   std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
327   SALOME_NamingService ns(_orb);
328   ns.Register(ptr,fullScopeName.c_str());
329 }
330
331 std::string DataScopeServerBase::BuildTmpVarNameFrom(const std::string& varName)
332 {
333   std::ostringstream oss;
334   oss << varName << "@" << COUNTER++;
335   return oss.str();
336 }
337
338 std::vector< std::string > DataScopeServerBase::getAllVarNames() const
339 {
340   std::size_t sz(_vars.size());
341   std::vector<std::string> ret(sz);
342   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it(_vars.begin());
343   for(std::size_t i=0;i<sz;it++,i++)
344     ret[i]=(*it).second->getVarNameCpp();
345   return ret;
346 }
347
348 bool DataScopeServerBase::isExistingVar(const std::string& varName) const
349 {
350   std::vector<std::string> allNames(getAllVarNames());
351   std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
352   return it!=allNames.end();
353 }
354
355 void DataScopeServerBase::checkNotAlreadyExistingVar(const std::string& varName) const
356 {
357   if(isExistingVar(varName))
358     {
359       std::ostringstream oss; oss << "DataScopeServerBase::checkNotAlreadyExistingVar : name \"" << varName << "\" already exists !";
360       throw Exception(oss.str());
361     }
362 }
363
364 void DataScopeServerBase::checkExistingVar(const std::string& varName) const
365 {
366   std::vector<std::string> allNames(getAllVarNames());
367   std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
368   if(it==allNames.end())
369     {
370       std::ostringstream oss; oss << "DataScopeServerBase::checkExistingVar : name \"" << varName << "\" does not exist !";
371       throw Exception(oss.str());
372     }
373 }
374
375 PickelizedPyObjServer *DataScopeServerBase::checkVarExistingAndDict(const std::string& varName)
376 {
377   checkExistingVar(varName);
378   BasicDataServer *var(retrieveVarInternal2(varName.c_str()));
379   PickelizedPyObjServer *ret(dynamic_cast<PickelizedPyObjServer *>(var));
380   if(!ret)
381     {
382       std::ostringstream oss; oss << "TransactionAddKeyValueHard::prepareRollBackInCaseOfFailure : var \"" << varName << "\"exists but it is not serialized !";
383       throw Exception(oss.str());
384     }
385   if(!ret->isDict())
386     {
387       std::ostringstream oss; oss << "TransactionAddKeyValueHard::prepareRollBackInCaseOfFailure : var \"" << varName << "\"exists but it is not a Dict !";
388       throw Exception(oss.str());
389     }
390   return ret;
391 }
392
393 void DataScopeServerBase::moveStatusOfVarFromRdWrToRdOnly(const std::string& varName)
394 {
395   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(retrieveVarInternal4(varName));
396   std::pair< SALOME::BasicDataServer_var, BasicDataServer * >& p(*it);
397   PickelizedPyObjRdWrServer *varc(dynamic_cast<PickelizedPyObjRdWrServer *>(p.second));
398   if(!varc)
399     throw Exception("DataScopeServerBase::moveStatusOfVarFromRdWrToRdOnly : var is not a RdWr !");
400   PyObject *pyobj(varc->getPyObj()); Py_XINCREF(pyobj);
401   PickelizedPyObjRdOnlyServer *newVar(new PickelizedPyObjRdOnlyServer(this,varName,pyobj));
402   CORBA::Object_var obj(newVar->activate());
403   SALOME::BasicDataServer_var obj2(SALOME::BasicDataServer::_narrow(obj));
404   p.first=obj2; p.second=newVar;
405   varc->decrRef();
406 }
407
408 void DataScopeServerBase::moveStatusOfVarFromRdOnlyToRdWr(const std::string& varName)
409 {
410   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(retrieveVarInternal4(varName));
411   std::pair< SALOME::BasicDataServer_var, BasicDataServer * >& p(*it);
412   PickelizedPyObjRdOnlyServer *varc(dynamic_cast<PickelizedPyObjRdOnlyServer *>(p.second));
413   if(!varc)
414     throw Exception("DataScopeServerBase::moveStatusOfVarFromRdOnlyToRdWr : var is not a RdWr !");
415   PyObject *pyobj(varc->getPyObj()); Py_XINCREF(pyobj);
416   PickelizedPyObjRdWrServer *newVar(new PickelizedPyObjRdWrServer(this,varName,pyobj));
417   CORBA::Object_var obj(newVar->activate());
418   SALOME::BasicDataServer_var obj2(SALOME::BasicDataServer::_narrow(obj));
419   p.first=obj2; p.second=newVar;
420   varc->decrRef();
421 }
422
423 void DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExtInit(const std::string& varName)
424 {
425   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(retrieveVarInternal4(varName));
426   std::pair< SALOME::BasicDataServer_var, BasicDataServer * >& p(*it);
427   PickelizedPyObjRdExtServer *varc0(dynamic_cast<PickelizedPyObjRdExtServer *>(p.second));
428   PickelizedPyObjRdExtInitServer *varc1(dynamic_cast<PickelizedPyObjRdExtInitServer *>(p.second));
429   if(!varc0 && !varc1)
430     throw Exception("DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExtInit : var is neither RdExt nor RdExtInit !");
431   if(varc0)
432     {
433       PickelizedPyObjRdExtInitServer *newVar(varc0->buildInitInstanceFrom(varName));
434       newVar->incrNbClients();
435       CORBA::Object_var obj(newVar->activate());
436       SALOME::BasicDataServer_var obj2(SALOME::BasicDataServer::_narrow(obj));
437       p.first=obj2; p.second=newVar;
438       varc0->decrRef();
439     }
440   else
441     varc1->incrNbClients();
442 }
443
444 void DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExt(const std::string& varName)
445 {
446   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(retrieveVarInternal4(varName));
447   std::pair< SALOME::BasicDataServer_var, BasicDataServer * >& p(*it);
448   PickelizedPyObjRdExtInitServer *varc0(dynamic_cast<PickelizedPyObjRdExtInitServer *>(p.second));
449   PickelizedPyObjRdExtServer *varc1(dynamic_cast<PickelizedPyObjRdExtServer *>(p.second));
450   if(!varc0 && !varc1)
451     throw Exception("DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExt : var is not a RdExtInit !");
452   if(varc0)
453     {
454       if(varc0->decrNbClients())
455         {
456           PickelizedPyObjRdExtServer *newVar(varc0->buildStdInstanceFrom(varName));
457           CORBA::Object_var obj(newVar->activate());
458           SALOME::BasicDataServer_var obj2(SALOME::BasicDataServer::_narrow(obj));
459           p.first=obj2; p.second=newVar;
460           varc0->decrRef();
461         }
462     }
463 }
464
465 std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator DataScopeServerBase::retrieveVarInternal3(const std::string& varName) const
466 {
467   std::vector<std::string> allNames(getAllVarNames());
468   std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
469   if(it==allNames.end())
470     {
471       std::ostringstream oss; oss << "DataScopeServerBase::retrieveVarInternal3 : name \"" << varName << "\" does not exists ! Possibilities are :";
472       std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
473       throw Exception(oss.str());
474     }
475   std::size_t pos(std::distance(allNames.begin(),it));
476   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it0(_vars.begin());
477   for(std::size_t i=0;i<pos;i++,it0++);
478   return it0;
479 }
480
481 std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator DataScopeServerBase::retrieveVarInternal4(const std::string& varName)
482 {
483   std::vector<std::string> allNames(getAllVarNames());
484   std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
485   if(it==allNames.end())
486     {
487       std::ostringstream oss; oss << "DataScopeServerBase::retrieveVarInternal4 : name \"" << varName << "\" does not exists ! Possibilities are :";
488       std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
489       throw Exception(oss.str());
490     }
491   std::size_t pos(std::distance(allNames.begin(),it));
492   std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it0(_vars.begin());
493   for(std::size_t i=0;i<pos;i++,it0++);
494   return it0;
495 }
496
497 ///////
498
499 DataScopeServer::DataScopeServer(CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName):DataScopeServerBase(orb,killer,scopeName)
500 {
501 }
502
503 DataScopeServer::DataScopeServer(const DataScopeServer& other):omniServant(other),ServantBase(other),DataScopeServerBase(other)
504 {
505 }
506
507 SALOME::PickelizedPyObjRdOnlyServer_ptr DataScopeServer::createRdOnlyVar(const char *varName, const SALOME::ByteVec& constValue)
508 {
509   std::string varNameCpp(varName);
510   checkNotAlreadyExistingVar(varNameCpp);
511   PickelizedPyObjRdOnlyServer *tmp(new PickelizedPyObjRdOnlyServer(this,varNameCpp,constValue));
512   CORBA::Object_var ret(tmp->activate());
513   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
514   _vars.push_back(p);
515   return SALOME::PickelizedPyObjRdOnlyServer::_narrow(ret);
516 }
517
518 SALOME::PickelizedPyObjRdExtServer_ptr DataScopeServer::createRdExtVar(const char *varName, const SALOME::ByteVec& constValue)
519 {
520   std::string varNameCpp(varName);
521   checkNotAlreadyExistingVar(varNameCpp);
522   PickelizedPyObjRdExtServer *tmp(new PickelizedPyObjRdExtServer(this,varNameCpp,constValue));
523   CORBA::Object_var ret(tmp->activate());
524   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
525   _vars.push_back(p);
526   return SALOME::PickelizedPyObjRdExtServer::_narrow(ret);
527 }
528
529 SALOME::PickelizedPyObjRdWrServer_ptr DataScopeServer::createRdWrVar(const char *typeName, const char *varName)
530 {
531   std::string varNameCpp(varName),typeNameCpp(typeName);
532   checkNotAlreadyExistingVar(varNameCpp);
533   PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,typeNameCpp,varNameCpp));
534   CORBA::Object_var ret(tmp->activate());
535   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
536   _vars.push_back(p);
537   return SALOME::PickelizedPyObjRdWrServer::_narrow(ret);
538 }
539
540 DataScopeServer::~DataScopeServer()
541 {
542 }
543
544 ////////
545
546 DataScopeServerTransaction::DataScopeServerTransaction(CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName):DataScopeServerBase(orb,killer,scopeName)
547 {
548   CORBA::Object_var obj(_orb->resolve_initial_references("RootPOA"));
549   PortableServer::POA_var poa(PortableServer::POA::_narrow(obj));
550   //
551   PortableServer::POAManager_var mgr(poa->the_POAManager());
552   CORBA::PolicyList policies;
553   policies.length(1);
554   PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::ORB_CTRL_MODEL));
555   policies[0]=PortableServer::ThreadPolicy::_duplicate(threadPol);
556   PortableServer::POA_var poa2(poa->create_POA("POAForWaiters",mgr,policies));
557   threadPol->destroy();
558   //
559   _poa_for_key_waiter=poa2;
560 }
561
562 DataScopeServerTransaction::DataScopeServerTransaction(const DataScopeServerTransaction& other):omniServant(other),ServantBase(other),DataScopeServerBase(other),_poa_for_key_waiter(other.getPOA4KeyWaiter())
563 {
564 }
565
566 char *DataScopeServerTransaction::getAccessOfVar(const char *varName)
567 {
568   std::string varNameCpp(varName);
569   checkExistingVar(varNameCpp);
570   BasicDataServer *var(retrieveVarInternal2(varName));
571   if(!var)
572     throw Exception("DataScopeServerTransaction::getAccessOfVar : variable is NULL !");
573   PickelizedPyObjServer *varc(dynamic_cast<PickelizedPyObjServer *>(var));
574   if(!varc)
575     throw Exception("DataScopeServerTransaction::getAccessOfVar : variable is not of type PickelizedPyObjServer !");
576   std::string ret(varc->getAccessStr());
577   return CORBA::string_dup(ret.c_str());
578 }
579
580 /*!
581  * This method is here to retrieve atomically accessStr and picklization.
582  */
583 void DataScopeServerTransaction::fetchAndGetAccessOfVar(const char *varName, CORBA::String_out access, SALOME::ByteVec_out data)
584 {
585   access=getAccessOfVar(varName);
586   data=fetchSerializedContent(varName);
587 }
588
589 void DataScopeServerTransaction::createRdOnlyVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
590 {
591   checkNotAlreadyExistingVar(varName);
592   PickelizedPyObjRdOnlyServer *tmp(new PickelizedPyObjRdOnlyServer(this,varName,constValue));
593   CORBA::Object_var ret(tmp->activate());
594   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
595   _vars.push_back(p);
596 }
597
598 void DataScopeServerTransaction::createRdExtVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
599 {
600   checkNotAlreadyExistingVar(varName);
601   PickelizedPyObjRdExtServer *tmp(new PickelizedPyObjRdExtServer(this,varName,constValue));
602   CORBA::Object_var ret(tmp->activate());
603   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
604   _vars.push_back(p);
605 }
606
607 void DataScopeServerTransaction::createRdExtVarFreeStyleInternal(const std::string& varName, const SALOME::ByteVec& constValue, std::string&& compareFuncContent, SALOME::AutoPyRef&& compareFunc)
608 {
609   if(!isExistingVar(varName))
610     {
611       PickelizedPyObjRdExtFreeStyleServer *tmp(new PickelizedPyObjRdExtFreeStyleServer(this,varName,constValue,std::move(compareFuncContent),std::move(compareFunc)));
612       CORBA::Object_var ret(tmp->activate());
613       std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
614       _vars.push_back(p);
615     }
616   else
617     {
618       BasicDataServer *ds(retrieveVarInternal2(varName));
619       if(!ds)
620         {
621           std::ostringstream oss;
622           oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : internal error 1 for varname \"" << varName << "\"!";
623           throw Exception(oss.str());
624         }
625       Sha1Keeper *ds2(dynamic_cast<Sha1Keeper *>(ds));
626       if(!ds2)
627         {
628           std::ostringstream oss;
629           oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : varname \"" << varName << "\" already exists with a non Sha1Keeper type !";
630           throw Exception(oss.str());
631         }
632       PickelizedPyObjServer *ds3(dynamic_cast<PickelizedPyObjServer *>(ds));
633       if(!ds3)
634         {
635           std::ostringstream oss;
636           oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : varname \"" << varName << "\" already exists with a non PickelizedPyObjServer type !";
637           throw Exception(oss.str());
638         }
639       std::vector<unsigned char> constValueAsCpp;
640       Transaction::FromByteSeqToVB(constValue,constValueAsCpp);
641       SALOME::AutoPyRef newObj(PickelizedPyObjServer::GetPyObjFromPickled(constValueAsCpp,this));
642       if(newObj.isNull())
643         {
644           std::ostringstream oss;
645           oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : varname \"" << varName << "\" already exists but input pickelized object is not loadable !";
646           throw Exception(oss.str());
647         }
648       ds2->checkSame(varName,compareFuncContent,ds3->getPyObj(),newObj);
649     }
650 }
651
652 void DataScopeServerTransaction::createRdExtInitVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
653 {
654   checkNotAlreadyExistingVar(varName);
655   PickelizedPyObjRdExtInitServer *tmp(new PickelizedPyObjRdExtInitServer(this,varName,constValue));
656   CORBA::Object_var ret(tmp->activate());
657   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
658   _vars.push_back(p);
659 }
660
661 void DataScopeServerTransaction::createRdWrVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
662 {
663   checkNotAlreadyExistingVar(varName);
664   PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,varName,constValue));
665   CORBA::Object_var ret(tmp->activate());
666   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
667   _vars.push_back(p);
668 }
669
670 SALOME::Transaction_ptr DataScopeServerTransaction::createRdOnlyVarTransac(const char *varName, const SALOME::ByteVec& constValue)
671 {
672   checkNotAlreadyExistingVar(varName);
673   TransactionRdOnlyVarCreate *ret(new TransactionRdOnlyVarCreate(this,varName,constValue));
674   CORBA::Object_var obj(ret->activate());
675   return SALOME::Transaction::_narrow(obj);
676 }
677
678 SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtVarTransac(const char *varName, const SALOME::ByteVec& constValue)
679 {
680   checkNotAlreadyExistingVar(varName);
681   TransactionRdExtVarCreate *ret(new TransactionRdExtVarCreate(this,varName,constValue));
682   CORBA::Object_var obj(ret->activate());
683   return SALOME::Transaction::_narrow(obj);
684 }
685
686 SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtVarFreeStyleTransac(const char *varName, const SALOME::ByteVec& constValue, const char *compareFuncContent)
687 {// no check on varName done here. Will be done on perform
688   TransactionRdExtVarFreeStyleCreate *ret(new TransactionRdExtVarFreeStyleCreate(this,varName,constValue,compareFuncContent));
689   CORBA::Object_var obj(ret->activate());
690   return SALOME::Transaction::_narrow(obj);
691 }
692
693 SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtInitVarTransac(const char *varName, const SALOME::ByteVec& constValue)
694 {
695   checkNotAlreadyExistingVar(varName);
696   TransactionRdExtInitVarCreate *ret(new TransactionRdExtInitVarCreate(this,varName,constValue));
697   CORBA::Object_var obj(ret->activate());
698   return SALOME::Transaction::_narrow(obj);
699 }
700
701 SALOME::Transaction_ptr DataScopeServerTransaction::createRdWrVarTransac(const char *varName, const SALOME::ByteVec& constValue)
702 {
703   checkNotAlreadyExistingVar(varName);
704   TransactionRdWrVarCreate *ret(new TransactionRdWrVarCreate(this,varName,constValue));
705   CORBA::Object_var obj(ret->activate());
706   return SALOME::Transaction::_narrow(obj);
707 }
708
709 void DataScopeServerTransaction::addWaitKey(KeyWaiter *kw)
710 {
711   if(!kw)
712     throw Exception("DataScopeServerTransaction::addWaitKey : NULL input object !");
713   _waiting_keys.push_back(kw);
714 }
715
716 void DataScopeServerTransaction::pingKey(PyObject *keyObj)
717 {
718   std::size_t ii(0);
719   // this part does nothing except to be sure that in notify key all will be OK.
720   PyObject *args(PyTuple_New(1));
721   PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
722   for(std::list< KeyWaiter *>::iterator it=_waiting_keys.begin();it!=_waiting_keys.end();it++,ii++)
723     {
724       PyObject *waitKey((*it)->getKeyPyObj());
725       PyObject *meth(PyObject_GetAttrString(waitKey,"__eq__"));
726       if(!meth)
727       {
728           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
729           throw Exception(oss.str());
730       }
731       PyObject *res(PyObject_CallObject(meth,args));
732       Py_XDECREF(meth);
733       if(res==NULL)
734         {
735           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " error during cmp(k,wk[i]) !";
736           throw Exception(oss.str());
737         }
738       PyBool_Check(res);
739       if(PyErr_Occurred())
740         {
741           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " error during interpretation of cmp(k,wk[i]) !";
742           throw Exception(oss.str());
743         }
744       Py_XDECREF(res);
745     }
746   Py_XDECREF(args);
747 }
748
749 void DataScopeServerTransaction::notifyKey(const std::string& varName, PyObject *keyObj, PyObject *valueObj)
750 {
751   std::size_t ii(0);
752   PyObject *args(PyTuple_New(1));
753   PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
754   std::list< KeyWaiter *> newList,listOfEltToWakeUp;
755   for(std::list< KeyWaiter *>::iterator it=_waiting_keys.begin();it!=_waiting_keys.end();it++,ii++)
756     {
757       if((*it)->getVarName()!=varName)
758         {
759           newList.push_back(*it);
760           continue;
761         }
762       PyObject *waitKey((*it)->getKeyPyObj());
763       PyObject *meth(PyObject_GetAttrString(waitKey,"__eq__"));
764       if(!meth)
765       {
766           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
767           throw Exception(oss.str());
768       }
769       PyObject *res(PyObject_CallObject(meth,args));
770       Py_XDECREF(meth);
771       if(!PyBool_Check(res))
772       {
773           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
774           throw Exception(oss.str());
775       }
776       if(PyErr_Occurred())
777         {
778           std::ostringstream oss; oss << "DataScopeServerTransaction::notifyKey : MAIN INTERNAL ERROR ! for object id #" << ii << " error during interpretation of cmp(k,wk[i]) !";
779           throw Exception(oss.str());
780         }
781       if(res==Py_True)
782         listOfEltToWakeUp.push_back(*it);
783       else
784         newList.push_back(*it);
785       Py_XDECREF(res);
786     }
787   Py_XDECREF(args);
788   for(std::list< KeyWaiter *>::iterator it=listOfEltToWakeUp.begin();it!=listOfEltToWakeUp.end();it++)
789     (*it)->valueJustCome(valueObj);
790   for(std::list< KeyWaiter *>::iterator it=listOfEltToWakeUp.begin();it!=listOfEltToWakeUp.end();it++)
791     (*it)->go();
792   _waiting_keys=newList;
793 }
794
795 SALOME::Transaction_ptr DataScopeServerTransaction::addKeyValueInVarHard(const char *varName, const SALOME::ByteVec& key, const SALOME::ByteVec& value)
796 {
797   checkVarExistingAndDict(varName);
798   TransactionAddKeyValueHard *ret(new TransactionAddKeyValueHard(this,varName,key,value));
799   CORBA::Object_var obj(ret->activate());
800   return SALOME::Transaction::_narrow(obj);
801 }
802
803 SALOME::Transaction_ptr DataScopeServerTransaction::addKeyValueInVarErrorIfAlreadyExisting(const char *varName, const SALOME::ByteVec& key, const SALOME::ByteVec& value)
804 {
805   checkVarExistingAndDict(varName);
806   TransactionAddKeyValueErrorIfAlreadyExisting *ret(new TransactionAddKeyValueErrorIfAlreadyExisting(this,varName,key,value));
807   CORBA::Object_var obj(ret->activate());
808   return SALOME::Transaction::_narrow(obj);
809 }
810
811 SALOME::TransactionMultiKeyAddSession_ptr DataScopeServerTransaction::addMultiKeyValueSession(const char *varName)
812 {
813   checkVarExistingAndDict(varName);
814   TransactionMultiKeyAddSession *ret(new TransactionMultiKeyAddSession(this,varName));
815   CORBA::Object_var obj(ret->activate());
816   return SALOME::TransactionMultiKeyAddSession::_narrow(obj);
817 }
818
819 SALOME::Transaction_ptr DataScopeServerTransaction::removeKeyInVarErrorIfNotAlreadyExisting(const char *varName, const SALOME::ByteVec& key)
820 {
821   checkVarExistingAndDict(varName);
822   TransactionRemoveKeyInVarErrorIfNotAlreadyExisting *ret(new TransactionRemoveKeyInVarErrorIfNotAlreadyExisting(this,varName,key));
823   CORBA::Object_var obj(ret->activate());
824   return SALOME::Transaction::_narrow(obj);
825 }
826
827 SALOME::TransactionRdWrAccess_ptr DataScopeServerTransaction::createWorkingVarTransac(const char *varName, const SALOME::ByteVec& constValue)
828 {
829   std::string varNameCpp(varName);
830   checkNotAlreadyExistingVar(varName);
831   PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,varNameCpp,constValue));
832   CORBA::Object_var obj(tmp->activate());
833   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(obj),tmp);
834   _vars.push_back(p);
835   //
836   TransactionMorphRdWrIntoRdOnly *ret(new TransactionMorphRdWrIntoRdOnly(this,varName));
837   CORBA::Object_var obj2(ret->activate());
838   return SALOME::TransactionRdWrAccess::_narrow(obj2);
839 }
840
841 SALOME::Transaction_ptr DataScopeServerTransaction::killVarTransac(const char *varName)
842 {
843   std::string varNameCpp(varName);
844   checkExistingVar(varNameCpp);
845   //
846   TransactionKillVar *ret(new TransactionKillVar(this,varName));
847   CORBA::Object_var obj2(ret->activate());
848   return SALOME::Transaction::_narrow(obj2);
849 }
850
851 SALOME::KeyWaiter_ptr DataScopeServerTransaction::waitForKeyInVar(const char *varName, const SALOME::ByteVec& keyVal)
852 {
853   PickelizedPyObjServer *pickelObj(checkVarExistingAndDict(varName));
854   KeyWaiter *ret(new KeyWaiter(pickelObj,keyVal));
855   CORBA::Object_var obj(ret->activate());//KeyWaiter instance activated inside a multithread POA contrary to all of objects in SALOMESDS in single thread !
856   return SALOME::KeyWaiter::_narrow(obj);
857 }
858
859 SALOME::KeyWaiter_ptr DataScopeServerTransaction::waitForKeyInVarAndKillIt(const char *varName, const SALOME::ByteVec& keyVal, SALOME::Transaction_out transac)
860 {
861   PickelizedPyObjServer *pickelObj(checkVarExistingAndDict(varName));
862   KeyWaiter *ret0(new KeyWaiter(pickelObj,keyVal));
863   CORBA::Object_var obj(ret0->activate());//KeyWaiter instance activated inside a multithread POA contrary to all of objects in SALOMESDS in single thread !
864   //
865   TransactionRemoveKeyInVarErrorIfNotAlreadyExisting *ret1(new TransactionRemoveKeyInVarErrorIfNotAlreadyExisting(this,varName,keyVal));
866   CORBA::Object_var obj2(ret1->activate());
867   transac=SALOME::Transaction::_narrow(obj2);
868   //
869   return SALOME::KeyWaiter::_narrow(obj);
870 }
871
872 SALOME::ByteVec *DataScopeServerTransaction::waitForMonoThrRev(SALOME::KeyWaiter_ptr kw)
873 {
874   PortableServer::ServantBase *ret(0);
875   try
876     {
877       ret=_poa_for_key_waiter->reference_to_servant(kw);// Warning ref cnt of ret has been incremented !
878     }
879   catch(...) { ret=0; }
880   KeyWaiter *retc(dynamic_cast<KeyWaiter *>(ret));
881   if(!retc)
882     throw Exception("DataScopeServerTransaction::invokeMonoThr : internal error 1 !");
883   retc->_remove_ref();// restore the counter after _poa_for_key_waiter->reference_to_servant(kw)
884   SALOME::ByteVec *zeRet(retc->waitForMonoThr());
885   retc->enforcedRelease();
886   return zeRet;
887 }
888
889 SALOME::ByteVec *DataScopeServerTransaction::waitForAndKill(SALOME::KeyWaiter_ptr kw)
890 {
891   PortableServer::ServantBase *ret(0);
892   try
893     {
894       ret=_poa_for_key_waiter->reference_to_servant(kw);// Warning ref cnt of ret has been incremented !
895     }
896   catch(...) { ret=0; }
897   KeyWaiter *retc(dynamic_cast<KeyWaiter *>(ret));
898   if(!retc)
899     throw Exception("DataScopeServerTransaction::invokeMonoThr : internal error 1 !");
900   retc->_remove_ref();// restore the counter after _poa_for_key_waiter->reference_to_servant(kw)
901   SALOME::ByteVec *zeRet(retc->waitForAndKill());
902   retc->enforcedRelease();
903   return zeRet;
904 }
905
906 void DataScopeServerTransaction::atomicApply(const SALOME::ListOfTransaction& transactions)
907 {
908   std::size_t sz(transactions.length());
909   if(sz==0)
910     return ;
911   std::vector< AutoServantPtr<Transaction> > transactionsCpp(sz);
912   for(std::size_t i=0;i<sz;i++)
913     {
914       PortableServer::ServantBase *eltBase(0);
915       Transaction *elt(0);
916       try
917         {
918           eltBase=_poa->reference_to_servant(transactions[i]);
919           elt=dynamic_cast<Transaction *>(eltBase);
920         }
921       catch(...)
922         {
923           std::ostringstream oss; oss << "DataScopeServerTransaction::atomicApply : the elt #" << i << " is invalid !";
924           throw Exception(oss.str());
925         }
926       if(!elt)
927         {
928           std::ostringstream oss; oss << "DataScopeServerTransaction::atomicApply : the elt #" << i << " is null ?";
929           throw Exception(oss.str());
930         }
931       elt->_remove_ref();
932       transactionsCpp[i]=elt;
933     }
934   {// important do not merge loops ! 
935     std::vector<TrustTransaction> transactions2(sz);
936     bool mustRollback(true);
937     for(std::size_t i=0;i<sz;i++)
938       transactions2[i].setTransaction(transactionsCpp[i],&mustRollback);
939     for(std::size_t i=0;i<sz;i++)
940       transactions2[i].operate();
941     mustRollback=false;
942   }
943   for(std::size_t i=0;i<sz;i++)
944     transactionsCpp[i]->notify();
945 }
946
947 DataScopeServerTransaction::~DataScopeServerTransaction()
948 {
949 }
950
951 SALOME::RequestSwitcher_ptr DataScopeServerTransaction::getRequestSwitcher()
952 {
953   if(_rs.isNull())
954     {
955       _rs=new RequestSwitcher(_orb,this);
956     }
957   CORBA::Object_var obj(_rs->activate());
958   return SALOME::RequestSwitcher::_narrow(obj);
959 }