-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include "SALOMESDS_PickelizedPyObjRdOnlyServer.hxx"
#include "SALOMESDS_PickelizedPyObjRdExtServer.hxx"
#include "SALOMESDS_PickelizedPyObjRdWrServer.hxx"
+#include "SALOMESDS_PickelizedPyObjRdExtInitServer.hxx"
+#include "SALOMESDS_TrustTransaction.hxx"
#include "SALOMESDS_KeyWaiter.hxx"
#include "SALOMESDS_Transaction.hxx"
-#include "SALOME_NamingService.hxx"
+#include "SALOME_NamingService_Abstract.hxx"
#include "SALOMESDS_Exception.hxx"
#include <sstream>
void DataScopeKiller::shutdown()
{
- Py_Finalize();
_orb->shutdown(0);
}
-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)
+RequestSwitcher::RequestSwitcher(CORBA::ORB_ptr orb, DataScopeServerTransaction *ds):RequestSwitcherBase(orb),_ds(ds)
{
}
-DataScopeServerBase::DataScopeServerBase(const DataScopeServerBase& other):_globals(0),_locals(0),_pickler(0),_name(other._name),_vars(other._vars),_killer(other._killer)
+SALOME::StringVec *RequestSwitcher::listVars()
+{
+ return _ds->listVars();
+}
+
+SALOME::ByteVec *RequestSwitcher::fetchSerializedContent(const char *varName)
+{
+ return _ds->fetchSerializedContent(varName);
+}
+
+void RequestSwitcher::fetchAndGetAccessOfVar(const char *varName, CORBA::String_out access, SALOME::ByteVec_out data)
+{
+ return _ds->fetchAndGetAccessOfVar(varName,access,data);
+}
+
+DataScopeServerBase::DataScopeServerBase(const SALOME_CPythonHelper *pyHelper, CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName, SALOME_NamingService_Container_Abstract *ns):_ns(ns),_pyHelper(pyHelper),_orb(CORBA::ORB::_duplicate(orb)),_name(scopeName),_killer(killer)
+{
+}
+
+DataScopeServerBase::DataScopeServerBase(const DataScopeServerBase& other):omniServant(other),ServantBase(other),_ns(other._ns->clone()),_pyHelper(other._pyHelper),_name(other._name),_vars(other._vars),_killer(other._killer)
{
}
DataScopeServerBase::~DataScopeServerBase()
{
- // _globals is borrowed ref -> do nothing
- Py_XDECREF(_locals);
- Py_XDECREF(_pickler);
for(std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it=_vars.begin();it!=_vars.end();it++)
{
BasicDataServer *obj((*it).second);
obj->decrRef();
}
}
+ delete _ns;
}
/*!
{
SALOME::StringVec *ret(new SALOME::StringVec);
std::size_t sz(_vars.size());
- ret->length(sz);
+ ret->length((CORBA::ULong)sz); //!< TODO: size_t to CORBA::ULong
std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(_vars.begin());
for(std::size_t i=0;i<sz;it++,i++)
{
BasicDataServer *obj((*it).second);
std::string name(obj->getVarNameCpp());
- (*ret)[i]=CORBA::string_dup(name.c_str());
+ (*ret)[(CORBA::ULong)i]=CORBA::string_dup(name.c_str()); //!< TODO: size_t to CORBA::ULong
}
return ret;
}
CORBA::Boolean DataScopeServerBase::shutdownIfNotHostedByDSM(SALOME::DataScopeKiller_out killer)
{
- SALOME_NamingService ns(_orb);
- CORBA::Object_var obj(ns.Resolve(DataServerManager::NAME_IN_NS));
+ CORBA::Object_var obj(_ns->Resolve(DataServerManager::NAME_IN_NS));
SALOME::DataServerManager_var dsm(SALOME::DataServerManager::_narrow(obj));
if(CORBA::is_nil(dsm))
throw Exception("Unable to reach in the NS the unique DataServerManager instance of the Session !");
// destroy ref in the naming service
std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
- ns.Destroy_Name(fullScopeName.c_str());
+ _ns->Destroy_Name(fullScopeName.c_str());
// establish if dsm and this shared the same POA. If yes dsm and this are collocated !
PortableServer::ServantBase *ret(0);
try
}
Py_ssize_t sz(PyList_Size(keys));
SALOME::SeqOfByteVec *ret(new SALOME::SeqOfByteVec);
- ret->length(sz);
+ ret->length((CORBA::ULong)sz); //!< TODO: convert Py_ssize_t in CORBA::ULong
for(Py_ssize_t i=0;i<sz;i++)
{
PyObject *item(PyList_GetItem(keys,i));
Py_XINCREF(item);
std::string pickel(varc->pickelize(item));//item consumed
- PickelizedPyObjServer::FromCppToByteSeq(pickel,(*ret)[i]);
+ PickelizedPyObjServer::FromCppToByteSeq(pickel,(*ret)[(CORBA::ULong)i]); //!< TODO: convert Py_ssize_t in CORBA::ULong
}
Py_XDECREF(keys);
return ret;
}
-void DataScopeServerBase::initializePython(int argc, char *argv[])
+SALOME::ByteVec *DataScopeServerBase::getValueOfVarWithTypeDict(const char *varName, const SALOME::ByteVec& constKey)
{
- Py_Initialize();
- PyEval_InitThreads();
- PySys_SetArgv(argc,argv);
- PyObject *mainmod(PyImport_AddModule("__main__"));
- _globals=PyModule_GetDict(mainmod);
- if(PyDict_GetItemString(_globals, "__builtins__") == NULL)
+ BasicDataServer *var(retrieveVarInternal2(varName));
+ PickelizedPyObjServer *varc(dynamic_cast<PickelizedPyObjServer *>(var));
+ if(!varc)
{
- PyObject *bimod(PyImport_ImportModule("__builtin__"));
- if (bimod == NULL || PyDict_SetItemString(_globals, "__builtins__", bimod) != 0)
- Py_FatalError("can't add __builtins__ to __main__");
- Py_XDECREF(bimod);
+ std::ostringstream oss; oss << "DataScopeServerBase::getValueOfVarWithTypeDict : var \"" << varName << "\" exists but it is not serialized !";
+ throw Exception(oss.str());
}
- _locals=PyDict_New();
- PyObject *tmp(PyList_New(0));
- _pickler=PyImport_ImportModuleLevel(const_cast<char *>("cPickle"),_globals,_locals,tmp,-1);
+ if(!varc->isDict())
+ {
+ std::ostringstream oss; oss << "DataScopeServerBase::getValueOfVarWithTypeDict : var \"" << varName << "\" exists but it is not a PyDict !";
+ throw Exception(oss.str());
+ }
+ //
+ std::string keyCpp;
+ PickelizedPyObjServer::FromByteSeqToCpp(constKey,keyCpp);
+ SALOME::AutoPyRef key(PickelizedPyObjServer::GetPyObjFromPickled(keyCpp,this));
+ PyObject *value(PyDict_GetItem(varc->getPyObj(),key.get()));//borrowed
+ if(!value)
+ {
+ std::ostringstream oss; oss << "DataScopeServerBase::getValueOfVarWithTypeDict : var \"" << varName << "\" seems to not have key specified !";
+ throw Exception(oss.str());
+ }
+ Py_XINCREF(value);
+ std::string ret(PickelizedPyObjServer::Pickelize(value,this));//value is consumed
+ return PickelizedPyObjServer::FromCppToByteSeq(ret);
+}
+
+void DataScopeServerBase::takeANap(CORBA::Double napDurationInSec)
+{
+ if(napDurationInSec<0.)
+ throw Exception("DataScopeServerBase::takeANap : negative value !");
+#ifndef WIN32
+ struct timespec req,rem;
+ long nbSec((long)napDurationInSec);
+ double remainTime(napDurationInSec-(double)nbSec);
+ req.tv_sec=nbSec;
+ req.tv_nsec=(long)(remainTime*1000000.);
+ int ret(nanosleep(&req,&rem));
+ if(ret!=0)
+ throw Exception("DataScopeServerBase::takeANap : nap not finished as expected !");
+#else
+ throw Exception("DataScopeServerBase::takeANap : not implemented for Windows !");
+#endif
}
void DataScopeServerBase::registerToSalomePiDict() const
{
- PyObject *mod(PyImport_ImportModule("addToKillList"));
- if(!mod)
- return;
- PyObject *meth(PyObject_GetAttrString(mod,"addToKillList"));
- if(!meth)
- { Py_XDECREF(mod); return ; }
- PyObject *args(PyTuple_New(2));
- PyTuple_SetItem(args,0,PyInt_FromLong(getpid()));
- PyTuple_SetItem(args,1,PyString_FromString("SALOME_DataScopeServerBase"));
- PyObject *res(PyObject_CallObject(meth,args));
- Py_XDECREF(args);
- Py_XDECREF(res);
- Py_XDECREF(mod);
+ _pyHelper->registerToSalomePiDict("SALOME_DataScopeServerBase",getpid());
}
void DataScopeServerBase::setPOA(PortableServer::POA_var poa)
void DataScopeServerBase::registerInNS(SALOME::DataScopeServerBase_ptr ptr)
{
std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
- SALOME_NamingService ns(_orb);
- ns.Register(ptr,fullScopeName.c_str());
+ _ns->Register(ptr,fullScopeName.c_str());
}
std::string DataScopeServerBase::BuildTmpVarNameFrom(const std::string& varName)
return ret;
}
-void DataScopeServerBase::checkNotAlreadyExistingVar(const std::string& varName) const
+bool DataScopeServerBase::isExistingVar(const std::string& varName) const
{
std::vector<std::string> allNames(getAllVarNames());
std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
- if(it!=allNames.end())
+ return it!=allNames.end();
+}
+
+void DataScopeServerBase::checkNotAlreadyExistingVar(const std::string& varName) const
+{
+ if(isExistingVar(varName))
{
std::ostringstream oss; oss << "DataScopeServerBase::checkNotAlreadyExistingVar : name \"" << varName << "\" already exists !";
throw Exception(oss.str());
varc->decrRef();
}
+void DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExtInit(const std::string& varName)
+{
+ std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(retrieveVarInternal4(varName));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * >& p(*it);
+ PickelizedPyObjRdExtServer *varc0(dynamic_cast<PickelizedPyObjRdExtServer *>(p.second));
+ PickelizedPyObjRdExtInitServer *varc1(dynamic_cast<PickelizedPyObjRdExtInitServer *>(p.second));
+ if(!varc0 && !varc1)
+ throw Exception("DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExtInit : var is neither RdExt nor RdExtInit !");
+ if(varc0)
+ {
+ PickelizedPyObjRdExtInitServer *newVar(varc0->buildInitInstanceFrom(varName));
+ newVar->incrNbClients();
+ CORBA::Object_var obj(newVar->activate());
+ SALOME::BasicDataServer_var obj2(SALOME::BasicDataServer::_narrow(obj));
+ p.first=obj2; p.second=newVar;
+ varc0->decrRef();
+ }
+ else
+ varc1->incrNbClients();
+}
+
+void DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExt(const std::string& varName)
+{
+ std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(retrieveVarInternal4(varName));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * >& p(*it);
+ PickelizedPyObjRdExtInitServer *varc0(dynamic_cast<PickelizedPyObjRdExtInitServer *>(p.second));
+ PickelizedPyObjRdExtServer *varc1(dynamic_cast<PickelizedPyObjRdExtServer *>(p.second));
+ if(!varc0 && !varc1)
+ throw Exception("DataScopeServerBase::moveStatusOfVarFromRdExtOrRdExtInitToRdExt : var is not a RdExtInit !");
+ if(varc0)
+ {
+ if(varc0->decrNbClients())
+ {
+ PickelizedPyObjRdExtServer *newVar(varc0->buildStdInstanceFrom(varName));
+ CORBA::Object_var obj(newVar->activate());
+ SALOME::BasicDataServer_var obj2(SALOME::BasicDataServer::_narrow(obj));
+ p.first=obj2; p.second=newVar;
+ varc0->decrRef();
+ }
+ }
+}
+
std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator DataScopeServerBase::retrieveVarInternal3(const std::string& varName) const
{
std::vector<std::string> allNames(getAllVarNames());
///////
-DataScopeServer::DataScopeServer(CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName):DataScopeServerBase(orb,killer,scopeName)
+DataScopeServer::DataScopeServer(const SALOME_CPythonHelper *pyHelper, CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName, SALOME_NamingService_Container_Abstract *ns):DataScopeServerBase(pyHelper,orb,killer,scopeName,ns)
{
}
-DataScopeServer::DataScopeServer(const DataScopeServer& other):DataScopeServerBase(other)
+DataScopeServer::DataScopeServer(const DataScopeServer& other):omniServant(other),ServantBase(other),DataScopeServerBase(other)
{
}
////////
-DataScopeServerTransaction::DataScopeServerTransaction(CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName):DataScopeServerBase(orb,killer,scopeName)
+DataScopeServerTransaction::DataScopeServerTransaction(const SALOME_CPythonHelper *pyHelper, CORBA::ORB_ptr orb, SALOME::DataScopeKiller_var killer, const std::string& scopeName, SALOME_NamingService_Container_Abstract *ns):DataScopeServerBase(pyHelper,orb,killer,scopeName,ns)
{
CORBA::Object_var obj(_orb->resolve_initial_references("RootPOA"));
PortableServer::POA_var poa(PortableServer::POA::_narrow(obj));
_poa_for_key_waiter=poa2;
}
-DataScopeServerTransaction::DataScopeServerTransaction(const DataScopeServerTransaction& other):DataScopeServerBase(other),_poa_for_key_waiter(other.getPOA4KeyWaiter())
+DataScopeServerTransaction::DataScopeServerTransaction(const DataScopeServerTransaction& other):omniServant(other),ServantBase(other),DataScopeServerBase(other),_poa_for_key_waiter(other.getPOA4KeyWaiter())
{
}
return CORBA::string_dup(ret.c_str());
}
+/*!
+ * This method is here to retrieve atomically accessStr and picklization.
+ */
+void DataScopeServerTransaction::fetchAndGetAccessOfVar(const char *varName, CORBA::String_out access, SALOME::ByteVec_out data)
+{
+ access=getAccessOfVar(varName);
+ data=fetchSerializedContent(varName);
+}
+
void DataScopeServerTransaction::createRdOnlyVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
{
checkNotAlreadyExistingVar(varName);
_vars.push_back(p);
}
+void DataScopeServerTransaction::createRdExtVarFreeStyleInternal(const std::string& varName, const SALOME::ByteVec& constValue, std::string&& compareFuncContent, SALOME::AutoPyRef&& compareFunc)
+{
+ if(!isExistingVar(varName))
+ {
+ PickelizedPyObjRdExtFreeStyleServer *tmp(new PickelizedPyObjRdExtFreeStyleServer(this,varName,constValue,std::move(compareFuncContent),std::move(compareFunc)));
+ CORBA::Object_var ret(tmp->activate());
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ }
+ else
+ {
+ BasicDataServer *ds(retrieveVarInternal2(varName));
+ if(!ds)
+ {
+ std::ostringstream oss;
+ oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : internal error 1 for varname \"" << varName << "\"!";
+ throw Exception(oss.str());
+ }
+ Sha1Keeper *ds2(dynamic_cast<Sha1Keeper *>(ds));
+ if(!ds2)
+ {
+ std::ostringstream oss;
+ oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : varname \"" << varName << "\" already exists with a non Sha1Keeper type !";
+ throw Exception(oss.str());
+ }
+ PickelizedPyObjServer *ds3(dynamic_cast<PickelizedPyObjServer *>(ds));
+ if(!ds3)
+ {
+ std::ostringstream oss;
+ oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : varname \"" << varName << "\" already exists with a non PickelizedPyObjServer type !";
+ throw Exception(oss.str());
+ }
+ std::vector<unsigned char> constValueAsCpp;
+ Transaction::FromByteSeqToVB(constValue,constValueAsCpp);
+ SALOME::AutoPyRef newObj(PickelizedPyObjServer::GetPyObjFromPickled(constValueAsCpp,this));
+ if(newObj.isNull())
+ {
+ std::ostringstream oss;
+ oss << "DataScopeServerTransaction::createRdExtVarFreeStyleInternal : varname \"" << varName << "\" already exists but input pickelized object is not loadable !";
+ throw Exception(oss.str());
+ }
+ ds2->checkSame(varName,compareFuncContent,ds3->getPyObj(),newObj);
+ }
+}
+
+void DataScopeServerTransaction::createRdExtInitVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
+{
+ checkNotAlreadyExistingVar(varName);
+ PickelizedPyObjRdExtInitServer *tmp(new PickelizedPyObjRdExtInitServer(this,varName,constValue));
+ CORBA::Object_var ret(tmp->activate());
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+}
+
void DataScopeServerTransaction::createRdWrVarInternal(const std::string& varName, const SALOME::ByteVec& constValue)
{
checkNotAlreadyExistingVar(varName);
return SALOME::Transaction::_narrow(obj);
}
+SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtVarFreeStyleTransac(const char *varName, const SALOME::ByteVec& constValue, const char *compareFuncContent)
+{// no check on varName done here. Will be done on perform
+ TransactionRdExtVarFreeStyleCreate *ret(new TransactionRdExtVarFreeStyleCreate(this,varName,constValue,compareFuncContent));
+ CORBA::Object_var obj(ret->activate());
+ return SALOME::Transaction::_narrow(obj);
+}
+
+SALOME::Transaction_ptr DataScopeServerTransaction::createRdExtInitVarTransac(const char *varName, const SALOME::ByteVec& constValue)
+{
+ checkNotAlreadyExistingVar(varName);
+ TransactionRdExtInitVarCreate *ret(new TransactionRdExtInitVarCreate(this,varName,constValue));
+ CORBA::Object_var obj(ret->activate());
+ return SALOME::Transaction::_narrow(obj);
+}
+
SALOME::Transaction_ptr DataScopeServerTransaction::createRdWrVarTransac(const char *varName, const SALOME::ByteVec& constValue)
{
checkNotAlreadyExistingVar(varName);
void DataScopeServerTransaction::pingKey(PyObject *keyObj)
{
- PyObject *cmpObj(getPyCmpFunc());
- if(!keyObj)
- throw Exception("ataScopeServerTransaction::pingKey : Key Object is NULL !");
- PyObject *args(PyTuple_New(2));
- PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
std::size_t ii(0);
// this part does nothing except to be sure that in notify key all will be OK.
+ PyObject *args(PyTuple_New(1));
+ PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
for(std::list< KeyWaiter *>::iterator it=_waiting_keys.begin();it!=_waiting_keys.end();it++,ii++)
{
PyObject *waitKey((*it)->getKeyPyObj());
- PyTuple_SetItem(args,1,waitKey); Py_XINCREF(waitKey);
- PyObject *res(PyObject_CallObject(cmpObj,args));
+ PyObject *meth(PyObject_GetAttrString(waitKey,"__eq__"));
+ if(!meth)
+ {
+ std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
+ throw Exception(oss.str());
+ }
+ PyObject *res(PyObject_CallObject(meth,args));
+ Py_XDECREF(meth);
if(res==NULL)
{
std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " error during cmp(k,wk[i]) !";
throw Exception(oss.str());
}
- PyInt_AsLong(res);
+ PyBool_Check(res);
if(PyErr_Occurred())
{
std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " error during interpretation of cmp(k,wk[i]) !";
}
Py_XDECREF(res);
}
+ Py_XDECREF(args);
}
void DataScopeServerTransaction::notifyKey(const std::string& varName, PyObject *keyObj, PyObject *valueObj)
{
- PyObject *cmpObj(getPyCmpFunc());
- if(!keyObj)
- throw Exception("DataScopeServerTransaction::notifyKey : MAIN INTERNAL ERROR ! Key Object is NULL !");
- PyObject *args(PyTuple_New(2));
- PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
std::size_t ii(0);
+ PyObject *args(PyTuple_New(1));
+ PyTuple_SetItem(args,0,keyObj); Py_XINCREF(keyObj);
std::list< KeyWaiter *> newList,listOfEltToWakeUp;
for(std::list< KeyWaiter *>::iterator it=_waiting_keys.begin();it!=_waiting_keys.end();it++,ii++)
{
continue;
}
PyObject *waitKey((*it)->getKeyPyObj());
- PyTuple_SetItem(args,1,waitKey); Py_XINCREF(waitKey);
- PyObject *res(PyObject_CallObject(cmpObj,args));
- if(res==NULL)
- {
- std::ostringstream oss; oss << "DataScopeServerTransaction::notifyKey : MAIN INTERNAL ERROR ! for object id #" << ii << " error during cmp(k,wk[i]) !";
- throw Exception(oss.str());
- }
- long resCpp(PyInt_AsLong(res));
+ PyObject *meth(PyObject_GetAttrString(waitKey,"__eq__"));
+ if(!meth)
+ {
+ std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
+ throw Exception(oss.str());
+ }
+ PyObject *res(PyObject_CallObject(meth,args));
+ Py_XDECREF(meth);
+ if(!PyBool_Check(res))
+ {
+ std::ostringstream oss; oss << "DataScopeServerTransaction::pingKey : for object id #" << ii << " no __eq__ in pyobj !";
+ throw Exception(oss.str());
+ }
if(PyErr_Occurred())
{
std::ostringstream oss; oss << "DataScopeServerTransaction::notifyKey : MAIN INTERNAL ERROR ! for object id #" << ii << " error during interpretation of cmp(k,wk[i]) !";
throw Exception(oss.str());
}
- Py_XDECREF(res);
- if(resCpp==0)
+ if(res==Py_True)
listOfEltToWakeUp.push_back(*it);
else
newList.push_back(*it);
+ Py_XDECREF(res);
}
+ Py_XDECREF(args);
for(std::list< KeyWaiter *>::iterator it=listOfEltToWakeUp.begin();it!=listOfEltToWakeUp.end();it++)
(*it)->valueJustCome(valueObj);
for(std::list< KeyWaiter *>::iterator it=listOfEltToWakeUp.begin();it!=listOfEltToWakeUp.end();it++)
TransactionAddKeyValueErrorIfAlreadyExisting *ret(new TransactionAddKeyValueErrorIfAlreadyExisting(this,varName,key,value));
CORBA::Object_var obj(ret->activate());
return SALOME::Transaction::_narrow(obj);
-};
-
-class TrustTransaction
-{
-public:
- TrustTransaction():_must_rollback(0),_ptr(0) { }
- void setTransaction(Transaction *t, bool *mustRollback) { if(!t || !mustRollback) throw Exception("TrustTransaction Error #1"); _ptr=t; _must_rollback=mustRollback; _ptr->prepareRollBackInCaseOfFailure(); }
- void operate() { _ptr->perform(); }
- ~TrustTransaction() { if(!_ptr) return ; if(*_must_rollback) _ptr->rollBack(); }
-private:
- bool *_must_rollback;
- Transaction *_ptr;
-};
+}
-void DataScopeServerTransaction::addKeyValueInVarErrorIfAlreadyExistingNow(const char *varName, const SALOME::ByteVec& key, const SALOME::ByteVec& value)
+SALOME::TransactionMultiKeyAddSession_ptr DataScopeServerTransaction::addMultiKeyValueSession(const char *varName)
{
checkVarExistingAndDict(varName);
- TransactionAddKeyValueErrorIfAlreadyExisting ret(this,varName,key,value);
- {
- bool mustRollback(true);
- TrustTransaction t;
- t.setTransaction(&ret,&mustRollback);
- t.operate();
- mustRollback=false;
- }
+ TransactionMultiKeyAddSession *ret(new TransactionMultiKeyAddSession(this,varName));
+ CORBA::Object_var obj(ret->activate());
+ return SALOME::TransactionMultiKeyAddSession::_narrow(obj);
}
SALOME::Transaction_ptr DataScopeServerTransaction::removeKeyInVarErrorIfNotAlreadyExisting(const char *varName, const SALOME::ByteVec& key)
return SALOME::TransactionRdWrAccess::_narrow(obj2);
}
+SALOME::Transaction_ptr DataScopeServerTransaction::killVarTransac(const char *varName)
+{
+ std::string varNameCpp(varName);
+ checkExistingVar(varNameCpp);
+ //
+ TransactionKillVar *ret(new TransactionKillVar(this,varName));
+ CORBA::Object_var obj2(ret->activate());
+ return SALOME::Transaction::_narrow(obj2);
+}
+
SALOME::KeyWaiter_ptr DataScopeServerTransaction::waitForKeyInVar(const char *varName, const SALOME::ByteVec& keyVal)
{
PickelizedPyObjServer *pickelObj(checkVarExistingAndDict(varName));
PortableServer::ServantBase *ret(0);
try
{
- ret=_poa_for_key_waiter->reference_to_servant(kw);
+ ret=_poa_for_key_waiter->reference_to_servant(kw);// Warning ref cnt of ret has been incremented !
+ }
+ catch(...) { ret=0; }
+ KeyWaiter *retc(dynamic_cast<KeyWaiter *>(ret));
+ if(!retc)
+ throw Exception("DataScopeServerTransaction::invokeMonoThr : internal error 1 !");
+ retc->_remove_ref();// restore the counter after _poa_for_key_waiter->reference_to_servant(kw)
+ SALOME::ByteVec *zeRet(retc->waitForMonoThr());
+ retc->enforcedRelease();
+ return zeRet;
+}
+
+SALOME::ByteVec *DataScopeServerTransaction::waitForAndKill(SALOME::KeyWaiter_ptr kw)
+{
+ PortableServer::ServantBase *ret(0);
+ try
+ {
+ ret=_poa_for_key_waiter->reference_to_servant(kw);// Warning ref cnt of ret has been incremented !
}
catch(...) { ret=0; }
KeyWaiter *retc(dynamic_cast<KeyWaiter *>(ret));
if(!retc)
throw Exception("DataScopeServerTransaction::invokeMonoThr : internal error 1 !");
- retc->_remove_ref();
- retc->waitForMonoThr();
+ retc->_remove_ref();// restore the counter after _poa_for_key_waiter->reference_to_servant(kw)
+ SALOME::ByteVec *zeRet(retc->waitForAndKill());
+ retc->enforcedRelease();
+ return zeRet;
}
void DataScopeServerTransaction::atomicApply(const SALOME::ListOfTransaction& transactions)
Transaction *elt(0);
try
{
- eltBase=_poa->reference_to_servant(transactions[i]);
+ eltBase=_poa->reference_to_servant(transactions[(CORBA::ULong)i]); //!< TODO: size_t to CORBA::ULong
elt=dynamic_cast<Transaction *>(eltBase);
}
catch(...)
transactionsCpp[i]->notify();
}
-/*!
- * Returns borrowed reference.
- */
-PyObject *DataScopeServerTransaction::getPyCmpFunc()
+DataScopeServerTransaction::~DataScopeServerTransaction()
{
- PyObject *builtins(PyDict_GetItemString(_globals,"__builtins__"));//borrowed
- if(builtins==NULL)
- throw Exception("Fail to find reference to builtins !");
- PyObject *builtins2(PyModule_GetDict(builtins));//borrowed
- if(builtins2==NULL)
- throw Exception("Fail to invoke __dict__ on builtins !");
- PyObject *cmpObj(PyDict_GetItemString(builtins2,"cmp"));
- if(cmpObj==NULL)
- throw Exception("Fail to find cmp in __builtins__ !");
- return cmpObj;
}
-DataScopeServerTransaction::~DataScopeServerTransaction()
+SALOME::RequestSwitcher_ptr DataScopeServerTransaction::getRequestSwitcher()
{
+ if(_rs.isNull())
+ {
+ _rs=new RequestSwitcher(_orb,this);
+ }
+ CORBA::Object_var obj(_rs->activate());
+ return SALOME::RequestSwitcher::_narrow(obj);
}
-