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::vector<unsigned char>&& sha1)
 608 {
 609   if(!isExistingVar(varName))
 610     {
 611       PickelizedPyObjRdExtFreeStyleServer *tmp(new PickelizedPyObjRdExtFreeStyleServer(this,varName,constValue,std::move(sha1)));
 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 RdExtFreeStyle type !";
 630           throw Exception(oss.str());
 631         }
 632       ds2->checkSha1(varName,sha1);
 633     }
 634 }
 635
 636 void DataScopeServerTransaction::createRdExtInitVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
 637 {
 638   checkNotAlreadyExistingVar(varName);
 639   PickelizedPyObjRdExtInitServer *tmp(new PickelizedPyObjRdExtInitServer(this,varName,constValue));
 640   CORBA::Object_var ret(tmp->activate());
 641   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
 642   _vars.push_back(p);
 643 }
 644
 645 void DataScopeServerTransaction::createRdWrVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
 646 {
 647   checkNotAlreadyExistingVar(varName);
 648   PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,varName,constValue));
 649   CORBA::Object_var ret(tmp->activate());
 650   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
 651   _vars.push_back(p);
 652 }
 653
 654 SALOME::Transaction_ptr DataScopeServerTransaction::createRdOnlyVarTransac(const char *varName, const SALOME::ByteVec& constValue)
 655 {
 656   checkNotAlreadyExistingVar(varName);
 657   TransactionRdOnlyVarCreate *ret(new TransactionRdOnlyVarCreate(this,varName,constValue));
 658   CORBA::Object_var obj(ret->activate());
 659   return SALOME::Transaction::_narrow(obj);
 660 }
 661
 662 SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtVarTransac(const char *varName, const SALOME::ByteVec& constValue)
 663 {
 664   checkNotAlreadyExistingVar(varName);
 665   TransactionRdExtVarCreate *ret(new TransactionRdExtVarCreate(this,varName,constValue));
 666   CORBA::Object_var obj(ret->activate());
 667   return SALOME::Transaction::_narrow(obj);
 668 }
 669
 670 SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtVarFreeStyleTransac(const char *varName, const SALOME::ByteVec& constValue, const SALOME::ByteVec& sha1)
 671 {// no check on varName done here. Will be done on perform
 672   TransactionRdExtVarFreeStyleCreate *ret(new TransactionRdExtVarFreeStyleCreate(this,varName,constValue,sha1));
 673   CORBA::Object_var obj(ret->activate());
 674   return SALOME::Transaction::_narrow(obj);
 675 }
 676
 677 SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtInitVarTransac(const char *varName, const SALOME::ByteVec& constValue)
 678 {
 679   checkNotAlreadyExistingVar(varName);
 680   TransactionRdExtInitVarCreate *ret(new TransactionRdExtInitVarCreate(this,varName,constValue));
 681   CORBA::Object_var obj(ret->activate());
 682   return SALOME::Transaction::_narrow(obj);
 683 }
 684
 685 SALOME::Transaction_ptr DataScopeServerTransaction::createRdWrVarTransac(const char *varName, const SALOME::ByteVec& constValue)
 686 {
 687   checkNotAlreadyExistingVar(varName);
 688   TransactionRdWrVarCreate *ret(new TransactionRdWrVarCreate(this,varName,constValue));
 689   CORBA::Object_var obj(ret->activate());
 690   return SALOME::Transaction::_narrow(obj);
 691 }
 692
 693 void DataScopeServerTransaction::addWaitKey(KeyWaiter *kw)
 694 {
 695   if(!kw)
 696     throw Exception("DataScopeServerTransaction::addWaitKey : NULL input object !");
 697   _waiting_keys.push_back(kw);
 698 }
 699
 700 void DataScopeServerTransaction::pingKey(PyObject *keyObj)
 701 {
 702   std::size_t ii(0);
 703   // this part does nothing except to be sure that in notify key all will be OK.
 704   PyObject *args(PyTuple_New(1));
 705   PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
 706   for(std::list< KeyWaiter *>::iterator it=_waiting_keys.begin();it!=_waiting_keys.end();it++,ii++)
 707     {
 708       PyObject *waitKey((*it)->getKeyPyObj());
 709       PyObject *meth(PyObject_GetAttrString(keyObj,"__eq__"));
 710       if(!meth)
 711       {
 712           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
 713           throw Exception(oss.str());
 714       }
 715       PyObject *res(PyObject_CallObject(meth,args));
 716       Py_XDECREF(meth);
 717       if(res==NULL)
 718         {
 719           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " error during cmp(k,wk[i]) !";
 720           throw Exception(oss.str());
 721         }
 722       PyBool_Check(res);
 723       if(PyErr_Occurred())
 724         {
 725           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " error during interpretation of cmp(k,wk[i]) !";
 726           throw Exception(oss.str());
 727         }
 728       Py_XDECREF(res);
 729     }
 730   Py_XDECREF(args);
 731 }
 732
 733 void DataScopeServerTransaction::notifyKey(const std::string& varName, PyObject *keyObj, PyObject *valueObj)
 734 {
 735   std::size_t ii(0);
 736   PyObject *args(PyTuple_New(1));
 737   PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
 738   std::list< KeyWaiter *> newList,listOfEltToWakeUp;
 739   for(std::list< KeyWaiter *>::iterator it=_waiting_keys.begin();it!=_waiting_keys.end();it++,ii++)
 740     {
 741       if((*it)->getVarName()!=varName)
 742         {
 743           newList.push_back(*it);
 744           continue;
 745         }
 746       PyObject *waitKey((*it)->getKeyPyObj());
 747       PyObject *meth(PyObject_GetAttrString(keyObj,"__eq__"));
 748       if(!meth)
 749       {
 750           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
 751           throw Exception(oss.str());
 752       }
 753       PyObject *res(PyObject_CallObject(meth,args));
 754       Py_XDECREF(meth);
 755       if(!PyBool_Check(res))
 756       {
 757           std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
 758           throw Exception(oss.str());
 759       }
 760       if(PyErr_Occurred())
 761         {
 762           std::ostringstream oss; oss << "DataScopeServerTransaction::notifyKey : MAIN INTERNAL ERROR ! for object id #" << ii << " error during interpretation of cmp(k,wk[i]) !";
 763           throw Exception(oss.str());
 764         }
 765       if(res==Py_True)
 766         listOfEltToWakeUp.push_back(*it);
 767       else
 768         newList.push_back(*it);
 769       Py_XDECREF(res);
 770     }
 771   Py_XDECREF(args);
 772   for(std::list< KeyWaiter *>::iterator it=listOfEltToWakeUp.begin();it!=listOfEltToWakeUp.end();it++)
 773     (*it)->valueJustCome(valueObj);
 774   for(std::list< KeyWaiter *>::iterator it=listOfEltToWakeUp.begin();it!=listOfEltToWakeUp.end();it++)
 775     (*it)->go();
 776   _waiting_keys=newList;
 777 }
 778
 779 SALOME::Transaction_ptr DataScopeServerTransaction::addKeyValueInVarHard(const char *varName, const SALOME::ByteVec& key, const SALOME::ByteVec& value)
 780 {
 781   checkVarExistingAndDict(varName);
 782   TransactionAddKeyValueHard *ret(new TransactionAddKeyValueHard(this,varName,key,value));
 783   CORBA::Object_var obj(ret->activate());
 784   return SALOME::Transaction::_narrow(obj);
 785 }
 786
 787 SALOME::Transaction_ptr DataScopeServerTransaction::addKeyValueInVarErrorIfAlreadyExisting(const char *varName, const SALOME::ByteVec& key, const SALOME::ByteVec& value)
 788 {
 789   checkVarExistingAndDict(varName);
 790   TransactionAddKeyValueErrorIfAlreadyExisting *ret(new TransactionAddKeyValueErrorIfAlreadyExisting(this,varName,key,value));
 791   CORBA::Object_var obj(ret->activate());
 792   return SALOME::Transaction::_narrow(obj);
 793 }
 794
 795 SALOME::TransactionMultiKeyAddSession_ptr DataScopeServerTransaction::addMultiKeyValueSession(const char *varName)
 796 {
 797   checkVarExistingAndDict(varName);
 798   TransactionMultiKeyAddSession *ret(new TransactionMultiKeyAddSession(this,varName));
 799   CORBA::Object_var obj(ret->activate());
 800   return SALOME::TransactionMultiKeyAddSession::_narrow(obj);
 801 }
 802
 803 SALOME::Transaction_ptr DataScopeServerTransaction::removeKeyInVarErrorIfNotAlreadyExisting(const char *varName, const SALOME::ByteVec& key)
 804 {
 805   checkVarExistingAndDict(varName);
 806   TransactionRemoveKeyInVarErrorIfNotAlreadyExisting *ret(new TransactionRemoveKeyInVarErrorIfNotAlreadyExisting(this,varName,key));
 807   CORBA::Object_var obj(ret->activate());
 808   return SALOME::Transaction::_narrow(obj);
 809 }
 810
 811 SALOME::TransactionRdWrAccess_ptr DataScopeServerTransaction::createWorkingVarTransac(const char *varName, const SALOME::ByteVec& constValue)
 812 {
 813   std::string varNameCpp(varName);
 814   checkNotAlreadyExistingVar(varName);
 815   PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,varNameCpp,constValue));
 816   CORBA::Object_var obj(tmp->activate());
 817   std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(obj),tmp);
 818   _vars.push_back(p);
 819   //
 820   TransactionMorphRdWrIntoRdOnly *ret(new TransactionMorphRdWrIntoRdOnly(this,varName));
 821   CORBA::Object_var obj2(ret->activate());
 822   return SALOME::TransactionRdWrAccess::_narrow(obj2);
 823 }
 824
 825 SALOME::Transaction_ptr DataScopeServerTransaction::killVarTransac(const char *varName)
 826 {
 827   std::string varNameCpp(varName);
 828   checkExistingVar(varNameCpp);
 829   //
 830   TransactionKillVar *ret(new TransactionKillVar(this,varName));
 831   CORBA::Object_var obj2(ret->activate());
 832   return SALOME::Transaction::_narrow(obj2);
 833 }
 834
 835 SALOME::KeyWaiter_ptr DataScopeServerTransaction::waitForKeyInVar(const char *varName, const SALOME::ByteVec& keyVal)
 836 {
 837   PickelizedPyObjServer *pickelObj(checkVarExistingAndDict(varName));
 838   KeyWaiter *ret(new KeyWaiter(pickelObj,keyVal));
 839   CORBA::Object_var obj(ret->activate());//KeyWaiter instance activated inside a multithread POA contrary to all of objects in SALOMESDS in single thread !
 840   return SALOME::KeyWaiter::_narrow(obj);
 841 }
 842
 843 SALOME::KeyWaiter_ptr DataScopeServerTransaction::waitForKeyInVarAndKillIt(const char *varName, const SALOME::ByteVec& keyVal, SALOME::Transaction_out transac)
 844 {
 845   PickelizedPyObjServer *pickelObj(checkVarExistingAndDict(varName));
 846   KeyWaiter *ret0(new KeyWaiter(pickelObj,keyVal));
 847   CORBA::Object_var obj(ret0->activate());//KeyWaiter instance activated inside a multithread POA contrary to all of objects in SALOMESDS in single thread !
 848   //
 849   TransactionRemoveKeyInVarErrorIfNotAlreadyExisting *ret1(new TransactionRemoveKeyInVarErrorIfNotAlreadyExisting(this,varName,keyVal));
 850   CORBA::Object_var obj2(ret1->activate());
 851   transac=SALOME::Transaction::_narrow(obj2);
 852   //
 853   return SALOME::KeyWaiter::_narrow(obj);
 854 }
 855
 856 SALOME::ByteVec *DataScopeServerTransaction::waitForMonoThrRev(SALOME::KeyWaiter_ptr kw)
 857 {
 858   PortableServer::ServantBase *ret(0);
 859   try
 860     {
 861       ret=_poa_for_key_waiter->reference_to_servant(kw);// Warning ref cnt of ret has been incremented !
 862     }
 863   catch(...) { ret=0; }
 864   KeyWaiter *retc(dynamic_cast<KeyWaiter *>(ret));
 865   if(!retc)
 866     throw Exception("DataScopeServerTransaction::invokeMonoThr : internal error 1 !");
 867   retc->_remove_ref();// restore the counter after _poa_for_key_waiter->reference_to_servant(kw)
 868   SALOME::ByteVec *zeRet(retc->waitForMonoThr());
 869   retc->enforcedRelease();
 870   return zeRet;
 871 }
 872
 873 SALOME::ByteVec *DataScopeServerTransaction::waitForAndKill(SALOME::KeyWaiter_ptr kw)
 874 {
 875   PortableServer::ServantBase *ret(0);
 876   try
 877     {
 878       ret=_poa_for_key_waiter->reference_to_servant(kw);// Warning ref cnt of ret has been incremented !
 879     }
 880   catch(...) { ret=0; }
 881   KeyWaiter *retc(dynamic_cast<KeyWaiter *>(ret));
 882   if(!retc)
 883     throw Exception("DataScopeServerTransaction::invokeMonoThr : internal error 1 !");
 884   retc->_remove_ref();// restore the counter after _poa_for_key_waiter->reference_to_servant(kw)
 885   SALOME::ByteVec *zeRet(retc->waitForAndKill());
 886   retc->enforcedRelease();
 887   return zeRet;
 888 }
 889
 890 void DataScopeServerTransaction::atomicApply(const SALOME::ListOfTransaction& transactions)
 891 {
 892   std::size_t sz(transactions.length());
 893   if(sz==0)
 894     return ;
 895   std::vector< AutoServantPtr<Transaction> > transactionsCpp(sz);
 896   for(std::size_t i=0;i<sz;i++)
 897     {
 898       PortableServer::ServantBase *eltBase(0);
 899       Transaction *elt(0);
 900       try
 901         {
 902           eltBase=_poa->reference_to_servant(transactions[i]);
 903           elt=dynamic_cast<Transaction *>(eltBase);
 904         }
 905       catch(...)
 906         {
 907           std::ostringstream oss; oss << "DataScopeServerTransaction::atomicApply : the elt #" << i << " is invalid !";
 908           throw Exception(oss.str());
 909         }
 910       if(!elt)
 911         {
 912           std::ostringstream oss; oss << "DataScopeServerTransaction::atomicApply : the elt #" << i << " is null ?";
 913           throw Exception(oss.str());
 914         }
 915       elt->_remove_ref();
 916       transactionsCpp[i]=elt;
 917     }
 918   {// important do not merge loops !
 919     std::vector<TrustTransaction> transactions2(sz);
 920     bool mustRollback(true);
 921     for(std::size_t i=0;i<sz;i++)
 922       transactions2[i].setTransaction(transactionsCpp[i],&mustRollback);
 923     for(std::size_t i=0;i<sz;i++)
 924       transactions2[i].operate();
 925     mustRollback=false;
 926   }
 927   for(std::size_t i=0;i<sz;i++)
 928     transactionsCpp[i]->notify();
 929 }
 930
 931 DataScopeServerTransaction::~DataScopeServerTransaction()
 932 {
 933 }
 934
 935 SALOME::RequestSwitcher_ptr DataScopeServerTransaction::getRequestSwitcher()
 936 {
 937   if(_rs.isNull())
 938     {
 939       _rs=new RequestSwitcher(_orb,this);
 940     }
 941   CORBA::Object_var obj(_rs->activate());
 942   return SALOME::RequestSwitcher::_narrow(obj);
 943 }