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