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