interface DataServerManager;
- interface DataScopeServer
+ interface DataScopeServerBase
{
void ping();
string getScopeName();
boolean existVar(in string varName) raises (SALOME::SALOME_Exception);
BasicDataServer retrieveVar(in string varName) raises (SALOME::SALOME_Exception);
void deleteVar(in string varName) raises (SALOME::SALOME_Exception);
+ void shutdownIfNotHostedByDSM();
+ };
+
+ interface DataScopeServer : DataScopeServerBase
+ {
PickelizedPyObjRdOnlyServer createRdOnlyVar(in string varName, in ByteVec constValue) raises (SALOME::SALOME_Exception);
PickelizedPyObjRdExtServer createRdExtVar(in string varName, in ByteVec constValue) raises (SALOME::SALOME_Exception);
//PickelizedPyObjRdWrServer createRdWrVar(in string typeName, in string varName) raises (SALOME::SALOME_Exception);
- void shutdownIfNotHostedByDSM();
+ };
+
+ interface Transaction
+ {
+ };
+
+ typedef sequence<Transaction> ListOfTransaction;
+
+ interface DataScopeServerTransaction : DataScopeServerBase
+ {
+ Transaction createRdOnlyVarTransac(in string varName, in ByteVec constValue) raises (SALOME::SALOME_Exception);
+ void atomicApply(in ListOfTransaction transactions) raises (SALOME::SALOME_Exception);
};
interface DataServerManager
StringVec listAliveAndKickingScopes() raises (SALOME::SALOME_Exception);
DataScopeServer getDefaultScope() raises (SALOME::SALOME_Exception);
boolean isAliveAndKicking(in string scopeName) raises (SALOME::SALOME_Exception);
+ //
DataScopeServer createDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
- DataScopeServer retriveDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
DataScopeServer giveADataScopeCalled(in string scopeName, out boolean isCreated);
+ //
+ DataScopeServerTransaction createDataScopeTransaction(in string scopeName) raises (SALOME::SALOME_Exception);
+ DataScopeServerTransaction giveADataScopeTransactionCalled(in string scopeName, out boolean isCreated);
+ //
+ DataScopeServerBase retriveDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
void removeDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
void cleanScopesInNS();
void shutdownScopes() raises (SALOME::SALOME_Exception);
};
-
- interface Transaction
- {
- };
-
- typedef sequence<Transaction> ListOfTransaction;
-
- interface TransactionFactory
- {
- Transaction createRdOnlyVar(in string varName, in string scopeName, in ByteVec constValue) raises (SALOME::SALOME_Exception);
- void atomicApply(in ListOfTransaction transactions) raises (SALOME::SALOME_Exception);
- };
};
SALOMESDS_PickelizedPyObjRdOnlyServer.cxx
SALOMESDS_PickelizedPyObjRdExtServer.cxx
SALOMESDS_PickelizedPyObjRdWrServer.cxx
- SALOMESDS_TransactionFactory.cxx
SALOMESDS_Transaction.cxx
)
#include "SALOMESDS_PickelizedPyObjRdOnlyServer.hxx"
#include "SALOMESDS_PickelizedPyObjRdExtServer.hxx"
#include "SALOMESDS_PickelizedPyObjRdWrServer.hxx"
+#include "SALOMESDS_Transaction.hxx"
#include "SALOME_NamingService.hxx"
#include "SALOMESDS_Exception.hxx"
using namespace SALOMESDS;
-std::size_t DataScopeServer::COUNTER=0;
+std::size_t DataScopeServerBase::COUNTER=0;
-DataScopeServer::DataScopeServer(CORBA::ORB_ptr orb, const std::string& scopeName):_globals(0),_locals(0),_pickler(0),_orb(CORBA::ORB::_duplicate(orb)),_name(scopeName)
+DataScopeServerBase::DataScopeServerBase(CORBA::ORB_ptr orb, const std::string& scopeName):_globals(0),_locals(0),_pickler(0),_orb(CORBA::ORB::_duplicate(orb)),_name(scopeName)
{
}
-DataScopeServer::DataScopeServer(const DataScopeServer& other):_globals(0),_locals(0),_pickler(0),_name(other._name),_vars(other._vars)
+DataScopeServerBase::DataScopeServerBase(const DataScopeServerBase& other):_globals(0),_locals(0),_pickler(0),_name(other._name),_vars(other._vars)
{
}
-DataScopeServer::~DataScopeServer()
+DataScopeServerBase::~DataScopeServerBase()
{
// _globals is borrowed ref -> do nothing
Py_XDECREF(_locals);
/*!
* Called remotely -> to protect against throw
*/
-void DataScopeServer::ping()
+void DataScopeServerBase::ping()
{
}
/*!
* Called remotely -> to protect against throw
*/
-char *DataScopeServer::getScopeName()
+char *DataScopeServerBase::getScopeName()
{
return CORBA::string_dup(_name.c_str());
}
/*!
* Called remotely -> to protect against throw
*/
-SALOME::StringVec *DataScopeServer::listVars()
+SALOME::StringVec *DataScopeServerBase::listVars()
{
SALOME::StringVec *ret(new SALOME::StringVec);
std::size_t sz(_vars.size());
return ret;
}
-CORBA::Boolean DataScopeServer::existVar(const char *varName)
+CORBA::Boolean DataScopeServerBase::existVar(const char *varName)
{
std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it(_vars.begin());
for(;it!=_vars.end();it++)
return false;
}
-SALOME::BasicDataServer_ptr DataScopeServer::retrieveVar(const char *varName)
+SALOME::BasicDataServer_ptr DataScopeServerBase::retrieveVar(const char *varName)
{
std::string varNameCpp(varName);
std::vector<std::string> allNames(getAllVarNames());
std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varNameCpp));
if(it==allNames.end())
{
- std::ostringstream oss; oss << "DataScopeServer::retrieveVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
+ std::ostringstream oss; oss << "DataScopeServerBase::retrieveVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
throw Exception(oss.str());
}
return SALOME::BasicDataServer::_duplicate((*it0).first);
}
-void DataScopeServer::deleteVar(const char *varName)
+void DataScopeServerBase::deleteVar(const char *varName)
{
std::string varNameCpp(varName);
std::vector<std::string> allNames(getAllVarNames());
std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varNameCpp));
if(it==allNames.end())
{
- std::ostringstream oss; oss << "DataScopeServer::deleteVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
+ std::ostringstream oss; oss << "DataScopeServerBase::deleteVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
throw Exception(oss.str());
}
_vars.erase(it0);
}
-SALOME::PickelizedPyObjRdOnlyServer_ptr DataScopeServer::createRdOnlyVar(const char *varName, const SALOME::ByteVec& constValue)
-{
- std::string varNameCpp(varName);
- checkNotAlreadyExistingVar(varNameCpp);
- PickelizedPyObjRdOnlyServer *tmp(new PickelizedPyObjRdOnlyServer(this,varNameCpp,constValue));
- CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
- std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
- _vars.push_back(p);
- return SALOME::PickelizedPyObjRdOnlyServer::_narrow(ret);
-}
-
-SALOME::PickelizedPyObjRdExtServer_ptr DataScopeServer::createRdExtVar(const char *varName, const SALOME::ByteVec& constValue)
-{
- std::string varNameCpp(varName);
- checkNotAlreadyExistingVar(varNameCpp);
- PickelizedPyObjRdExtServer *tmp(new PickelizedPyObjRdExtServer(this,varNameCpp,constValue));
- CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
- std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
- _vars.push_back(p);
- return SALOME::PickelizedPyObjRdExtServer::_narrow(ret);
-}
-
-/*!
- * Called remotely -> to protect against throw
- */
-SALOME::PickelizedPyObjRdWrServer_ptr DataScopeServer::createRdWrVar(const char *typeName, const char *varName)
-{
- std::string varNameCpp(varName),typeNameCpp(typeName);
- checkNotAlreadyExistingVar(varNameCpp);
- PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,typeNameCpp,varNameCpp));
- CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
- std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
- _vars.push_back(p);
- return SALOME::PickelizedPyObjRdWrServer::_narrow(ret);
-}
-
-void DataScopeServer::shutdownIfNotHostedByDSM()
+void DataScopeServerBase::shutdownIfNotHostedByDSM()
{
SALOME_NamingService ns(_orb);
CORBA::Object_var obj(ns.Resolve(DataServerManager::NAME_IN_NS));
}
}
-void DataScopeServer::initializePython(int argc, char *argv[])
+void DataScopeServerBase::initializePython(int argc, char *argv[])
{
Py_Initialize();
PySys_SetArgv(argc,argv);
_pickler=PyImport_ImportModuleLevel(const_cast<char *>("cPickle"),_globals,_locals,tmp,-1);
}
-void DataScopeServer::registerToSalomePiDict() const
+void DataScopeServerBase::registerToSalomePiDict() const
{
PyObject *mod(PyImport_ImportModule("addToKillList"));
if(!mod)
{ Py_XDECREF(mod); return ; }
PyObject *args(PyTuple_New(2));
PyTuple_SetItem(args,0,PyInt_FromLong(getpid()));
- PyTuple_SetItem(args,1,PyString_FromString("SALOME_DataScopeServer"));
+ PyTuple_SetItem(args,1,PyString_FromString("SALOME_DataScopeServerBase"));
PyObject *res(PyObject_CallObject(meth,args));
Py_XDECREF(args);
Py_XDECREF(res);
/*!
* \a ptr has been activated by the POA \a poa.
*/
-void DataScopeServer::setPOAAndRegister(PortableServer::POA_var poa, SALOME::DataScopeServer_ptr ptr)
+void DataScopeServerBase::setPOAAndRegister(PortableServer::POA_var poa, SALOME::DataScopeServerBase_ptr ptr)
{
_poa=poa;
std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
ns.Register(ptr,fullScopeName.c_str());
}
-std::string DataScopeServer::BuildTmpVarNameFrom(const std::string& varName)
+std::string DataScopeServerBase::BuildTmpVarNameFrom(const std::string& varName)
{
std::ostringstream oss;
oss << varName << "@" << COUNTER++;
return oss.str();
}
-std::vector< std::string > DataScopeServer::getAllVarNames() const
+std::vector< std::string > DataScopeServerBase::getAllVarNames() const
{
std::size_t sz(_vars.size());
std::vector<std::string> ret(sz);
return ret;
}
-CORBA::Object_var DataScopeServer::activateWithDedicatedPOA(BasicDataServer *ds)
+CORBA::Object_var DataScopeServerBase::activateWithDedicatedPOA(BasicDataServer *ds)
{
PortableServer::ObjectId_var id(_poa->activate_object(ds));
CORBA::Object_var ret(_poa->id_to_reference(id));
return ret;
}
-void DataScopeServer::checkNotAlreadyExistingVar(const std::string& varName)
+void DataScopeServerBase::checkNotAlreadyExistingVar(const std::string& varName)
{
std::vector<std::string> allNames(getAllVarNames());
std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
if(it!=allNames.end())
{
- std::ostringstream oss; oss << "DataScopeServer::checkNotAlreadyExistingVar : name \"" << varName << "\" already exists !";
+ std::ostringstream oss; oss << "DataScopeServerBase::checkNotAlreadyExistingVar : name \"" << varName << "\" already exists !";
throw Exception(oss.str());
}
}
+
+///////
+
+DataScopeServer::DataScopeServer(CORBA::ORB_ptr orb, const std::string& scopeName):DataScopeServerBase(orb,scopeName)
+{
+}
+
+DataScopeServer::DataScopeServer(const DataScopeServer& other):DataScopeServerBase(other)
+{
+}
+
+SALOME::PickelizedPyObjRdOnlyServer_ptr DataScopeServer::createRdOnlyVar(const char *varName, const SALOME::ByteVec& constValue)
+{
+ std::string varNameCpp(varName);
+ checkNotAlreadyExistingVar(varNameCpp);
+ PickelizedPyObjRdOnlyServer *tmp(new PickelizedPyObjRdOnlyServer(this,varNameCpp,constValue));
+ CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ return SALOME::PickelizedPyObjRdOnlyServer::_narrow(ret);
+}
+
+SALOME::PickelizedPyObjRdExtServer_ptr DataScopeServer::createRdExtVar(const char *varName, const SALOME::ByteVec& constValue)
+{
+ std::string varNameCpp(varName);
+ checkNotAlreadyExistingVar(varNameCpp);
+ PickelizedPyObjRdExtServer *tmp(new PickelizedPyObjRdExtServer(this,varNameCpp,constValue));
+ CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ return SALOME::PickelizedPyObjRdExtServer::_narrow(ret);
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+SALOME::PickelizedPyObjRdWrServer_ptr DataScopeServer::createRdWrVar(const char *typeName, const char *varName)
+{
+ std::string varNameCpp(varName),typeNameCpp(typeName);
+ checkNotAlreadyExistingVar(varNameCpp);
+ PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,typeNameCpp,varNameCpp));
+ CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ return SALOME::PickelizedPyObjRdWrServer::_narrow(ret);
+}
+
+DataScopeServer::~DataScopeServer()
+{
+}
+
+////////
+
+DataScopeServerTransaction::DataScopeServerTransaction(CORBA::ORB_ptr orb, const std::string& scopeName):DataScopeServerBase(orb,scopeName)
+{
+}
+
+DataScopeServerTransaction::DataScopeServerTransaction(const DataScopeServerTransaction& other):DataScopeServerBase(other)
+{
+}
+
+SALOME::Transaction_ptr DataScopeServerTransaction::createRdOnlyVarTransac(const char *varName, const SALOME::ByteVec& constValue)
+{
+ TransactionRdOnlyVarCreate *ret(new TransactionRdOnlyVarCreate(varName,constValue));
+ PortableServer::ObjectId_var id(_poa->activate_object(ret));
+ CORBA::Object_var obj(_poa->id_to_reference(id));
+ return SALOME::Transaction::_narrow(obj);
+}
+
+void DataScopeServerTransaction::atomicApply(const SALOME::ListOfTransaction& transactions)
+{
+ std::size_t sz(transactions.length());
+ if(sz==0)
+ return ;
+ std::vector< AutoServantPtr<Transaction> > transactionsCpp(sz);
+ for(std::size_t i=0;i<sz;i++)
+ {
+ PortableServer::ServantBase *eltBase(0);
+ Transaction *elt(0);
+ try
+ {
+ eltBase=_poa->reference_to_servant(transactions[i]);
+ elt=dynamic_cast<Transaction *>(eltBase);
+ }
+ catch(...)
+ {
+ std::ostringstream oss; oss << "DataScopeServerTransaction::atomicApply : the elt #" << i << " is invalid !";
+ throw Exception(oss.str());
+ }
+ if(!elt)
+ {
+ std::ostringstream oss; oss << "DataScopeServerTransaction::atomicApply : the elt #" << i << " is null ?";
+ throw Exception(oss.str());
+ }
+ elt->_remove_ref();
+ transactionsCpp[i]=elt;
+ transactionsCpp[i].setHolder(this);
+ }
+ for(std::size_t i=0;i<sz;i++)
+ transactionsCpp[i]->prepareRollBackInCaseOfFailure();
+}
+
+DataScopeServerTransaction::~DataScopeServerTransaction()
+{
+}
+
namespace SALOMESDS
{
- class SALOMESDS_EXPORT DataScopeServer : public virtual POA_SALOME::DataScopeServer
+ class SALOMESDS_EXPORT DataScopeServerBase : public virtual POA_SALOME::DataScopeServerBase, public POAHolder
{
public:
- DataScopeServer(CORBA::ORB_ptr orb, const std::string& scopeName);
- DataScopeServer(const DataScopeServer& other);
+ DataScopeServerBase(CORBA::ORB_ptr orb, const std::string& scopeName);
+ DataScopeServerBase(const DataScopeServerBase& other);
void ping();
char *getScopeName();
SALOME::StringVec *listVars();
SALOME::PickelizedPyObjRdExtServer_ptr createRdExtVar(const char *varName, const SALOME::ByteVec& constValue);
SALOME::PickelizedPyObjRdWrServer_ptr createRdWrVar(const char *typeName, const char *varName);
void shutdownIfNotHostedByDSM();
- ~DataScopeServer();
+ ~DataScopeServerBase();
public:
void initializePython(int argc, char *argv[]);
void registerToSalomePiDict() const;
- void setPOAAndRegister(PortableServer::POA_var poa, SALOME::DataScopeServer_ptr ptr);
+ void setPOAAndRegister(PortableServer::POA_var poa, SALOME::DataScopeServerBase_ptr ptr);
PyObject *getGlobals() const { return _globals; }
PyObject *getLocals() const { return _locals; }
PyObject *getPickler() const { return _pickler; }
- PortableServer::POA_var getPOA() { return _poa; }
+ PortableServer::POA_var getPOA() const { return _poa; }
CORBA::ORB_var getORB() { return _orb; }
static std::string BuildTmpVarNameFrom(const std::string& varName);
- private:
+ protected:
std::vector< std::string> getAllVarNames() const;
CORBA::Object_var activateWithDedicatedPOA(BasicDataServer *ds);
void checkNotAlreadyExistingVar(const std::string& varName);
- private:
+ protected:
PyObject *_globals;
PyObject *_locals;
PyObject *_pickler;
std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > > _vars;
static std::size_t COUNTER;
};
+
+ class SALOMESDS_EXPORT DataScopeServer : public DataScopeServerBase, public virtual POA_SALOME::DataScopeServer
+ {
+ public:
+ DataScopeServer(CORBA::ORB_ptr orb, const std::string& scopeName);
+ DataScopeServer(const DataScopeServer& other);
+ SALOME::PickelizedPyObjRdOnlyServer_ptr createRdOnlyVar(const char *varName, const SALOME::ByteVec& constValue);
+ SALOME::PickelizedPyObjRdExtServer_ptr createRdExtVar(const char *varName, const SALOME::ByteVec& constValue);
+ SALOME::PickelizedPyObjRdWrServer_ptr createRdWrVar(const char *typeName, const char *varName);
+ ~DataScopeServer();
+ };
+
+ class SALOMESDS_EXPORT DataScopeServerTransaction : public DataScopeServerBase, public virtual POA_SALOME::DataScopeServerTransaction
+ {
+ public:
+ DataScopeServerTransaction(CORBA::ORB_ptr orb, const std::string& scopeName);
+ DataScopeServerTransaction(const DataScopeServerTransaction& other);
+ SALOME::Transaction_ptr createRdOnlyVarTransac(const char *varName, const SALOME::ByteVec& constValue);
+ void atomicApply(const SALOME::ListOfTransaction& transactions);
+ ~DataScopeServerTransaction();
+ };
+
+ /*SALOME::Transaction_ptr createRdOnlyVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue);
+ SALOME::Transaction_ptr createRdExtVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue);
+ SALOME::Transaction_ptr createRdWrVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue);
+ SALOME::Transaction_ptr addKeyValueInVarErrorIfAlreadyExisting(const char *varName, const char *scopeName, const SALOME::ByteVec& key, const SALOME::ByteVec& value);
+ SALOME::Transaction_ptr addKeyValueInVarHard(const char *varName, const char *scopeName, const SALOME::ByteVec& key, const SALOME::ByteVec& value);
+ SALOME::Transaction_ptr removeKeyInVarErrorIfNotAlreadyExisting(const char *varName, const char *scopeName, const SALOME::ByteVec& key);
+ SALOME::ByteVec *waitForKeyInVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constKey);
+ SALOME::ByteVec *waitForKeyInVarAndKillIt(const char *varName, const char *scopeName, const SALOME::ByteVec& constKey, SALOME::Transaction_out transaction);*/
}
#endif
SALOME::DataScopeServer_ptr DataServerManager::getDefaultScope()
{
- return retriveDataScope(DFT_SCOPE_NAME_IN_NS);
+ SALOME::DataScopeServerBase_var ret(retriveDataScope(DFT_SCOPE_NAME_IN_NS));
+ if(CORBA::is_nil(ret))
+ return SALOME::DataScopeServer::_narrow(ret);
+ SALOME::DataScopeServer_ptr ret2(SALOME::DataScopeServer::_narrow(ret));
+ if(CORBA::is_nil(ret2))
+ throw Exception("DataServerManager::getDefaultScope : exists but has not expected sub type !");
+ return ret2;
}
CORBA::Boolean DataServerManager::isAliveAndKicking(const char *scopeName)
{
- SALOME::DataScopeServer_var scopePtr(getScopePtrGivenName(scopeName));
+ SALOME::DataScopeServerBase_var scopePtr(getScopePtrGivenName(scopeName));
return IsAliveAndKicking(scopePtr);
}
-SALOME::DataScopeServer_ptr DataServerManager::createDataScope(const char *scopeName)
+template<class T>
+typename T::PtrType CreateDataScope(const std::string& scopeName, const std::vector<std::string>& scopes, SALOME_NamingService& ns)
{
- std::string scopeNameCpp(scopeName);
- std::vector<std::string> scopes(listOfScopesCpp());
- if(std::find(scopes.begin(),scopes.end(),scopeNameCpp)!=scopes.end())
+ int isTransactionInt(T::IsTransaction);
+ if(std::find(scopes.begin(),scopes.end(),scopeName)!=scopes.end())
{
std::ostringstream oss; oss << "DataServerManager::createDataScope : scope name \"" << scopeName << "\" already exists !";
throw Exception(oss.str());
}
//
- SALOME_NamingService ns(_orb);
- std::string fullScopeName(CreateAbsNameInNSFromScopeName(scopeName));
- std::ostringstream oss; oss << "SALOME_DataScopeServer" << " " << scopeName << " ";
+ std::string fullScopeName(DataServerManager::CreateAbsNameInNSFromScopeName(scopeName));
+ std::ostringstream oss; oss << "SALOME_DataScopeServer" << " " << scopeName << " " << isTransactionInt;
SALOME_ContainerManager::AddOmninamesParams(oss,&ns);
std::string command(oss.str());
SALOME_ContainerManager::MakeTheCommandToBeLaunchedASync(command);
int status(SALOME_ContainerManager::SystemThreadSafe(command.c_str()));
int count(SALOME_ContainerManager::GetTimeOutToLoaunchServer());
- SALOME::DataScopeServer_var ret(SALOME::DataScopeServer::_nil());
+ typename T::VarType ret(T::nil());
while (CORBA::is_nil(ret) && count)
{
SALOME_ContainerManager::SleepInSecond(1);
count--;
CORBA::Object_var obj(ns.Resolve(fullScopeName.c_str()));
- ret=SALOME::DataScopeServer::_narrow(obj);
+ ret=T::narrow(obj);
}
- return SALOME::DataScopeServer::_duplicate(ret);
+ return T::duplicate(ret);
}
-SALOME::DataScopeServer_ptr DataServerManager::giveADataScopeCalled(const char *scopeName, CORBA::Boolean& isCreated)
+template<class T>
+typename T::PtrType GiveADataScopeCalled(const std::string& scopeName, const std::vector<std::string>& scopes, SALOME_NamingService& ns, CORBA::Boolean& isCreated)
{
- std::string scopeNameCpp(scopeName);
- std::vector<std::string> scopes(listOfScopesCpp());
- if(std::find(scopes.begin(),scopes.end(),scopeNameCpp)==scopes.end())
+ if(std::find(scopes.begin(),scopes.end(),scopeName)==scopes.end())
{
isCreated=true;
- return createDataScope(scopeName);
+ return CreateDataScope<T>(scopeName,scopes,ns);
}
else
{
- if(isAliveAndKicking(scopeName))
+ SALOME::DataScopeServerBase_var ret(SALOMESDS::DataServerManager::GetScopePtrGivenName(scopeName,scopes,ns));
+ if(SALOMESDS::DataServerManager::IsAliveAndKicking(ret))
{
isCreated=false;
- return retriveDataScope(scopeName);
+ typename T::PtrType ret2(T::narrow(ret));
+ if(CORBA::is_nil(ret))
+ return ret2;
+ if(CORBA::is_nil(ret2))
+ {
+ std::ostringstream oss; oss << "DataServerManager::giveADataScopeCalled : scope \"" << scopeName << "\" exists but with invalid type !";
+ throw Exception(oss.str());
+ }
+ return ret2;
}
else
{
- SALOME_NamingService ns(_orb);
- std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(scopeNameCpp));
+ std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(scopeName));
ns.Destroy_Name(fullScopeName.c_str());
isCreated=true;
- return createDataScope(scopeName);
+ return CreateDataScope<T>(scopeName,scopes,ns);
}
}
}
-SALOME::DataScopeServer_ptr DataServerManager::retriveDataScope(const char *scopeName)
+class NormalFunctor
+{
+public:
+ typedef SALOME::DataScopeServer_ptr PtrType;
+ typedef SALOME::DataScopeServer_var VarType;
+ typedef SALOME::DataScopeServer TheType;
+ static const bool IsTransaction=false;
+ static PtrType nil() { return SALOME::DataScopeServer::_nil(); }
+ static VarType narrow(CORBA::Object_ptr obj) { return SALOME::DataScopeServer::_narrow(obj); }
+ static PtrType duplicate(PtrType obj) { return SALOME::DataScopeServer::_duplicate(obj); }
+};
+
+class TransactionFunctor
+{
+public:
+ typedef SALOME::DataScopeServerTransaction_ptr PtrType;
+ typedef SALOME::DataScopeServerTransaction_var VarType;
+ typedef SALOME::DataScopeServerTransaction TheType;
+ static const bool IsTransaction=true;
+ static PtrType nil() { return SALOME::DataScopeServerTransaction::_nil(); }
+ static VarType narrow(CORBA::Object_ptr obj) { return SALOME::DataScopeServerTransaction::_narrow(obj); }
+ static PtrType duplicate(PtrType obj) { return SALOME::DataScopeServerTransaction::_duplicate(obj); }
+};
+
+SALOME::DataScopeServer_ptr DataServerManager::createDataScope(const char *scopeName)
+{
+ SALOME_NamingService ns(_orb);
+ return CreateDataScope<NormalFunctor>(scopeName,listOfScopesCpp(),ns);
+}
+
+SALOME::DataScopeServer_ptr DataServerManager::giveADataScopeCalled(const char *scopeName, CORBA::Boolean& isCreated)
{
- SALOME::DataScopeServer_var ret(getScopePtrGivenName(scopeName));
- return SALOME::DataScopeServer::_duplicate(ret);
+ SALOME_NamingService ns(_orb);
+ return GiveADataScopeCalled<NormalFunctor>(scopeName,listOfScopesCpp(),ns,isCreated);
+}
+
+SALOME::DataScopeServerTransaction_ptr DataServerManager::createDataScopeTransaction(const char *scopeName)
+{
+ SALOME_NamingService ns(_orb);
+ return CreateDataScope<TransactionFunctor>(scopeName,listOfScopesCpp(),ns);
+}
+
+SALOME::DataScopeServerTransaction_ptr DataServerManager::giveADataScopeTransactionCalled(const char *scopeName, CORBA::Boolean& isCreated)
+{
+ SALOME_NamingService ns(_orb);
+ return GiveADataScopeCalled<TransactionFunctor>(scopeName,listOfScopesCpp(),ns,isCreated);
+}
+
+SALOME::DataScopeServerBase_ptr DataServerManager::retriveDataScope(const char *scopeName)
+{
+ SALOME::DataScopeServerBase_var ret(getScopePtrGivenName(scopeName));
+ return SALOME::DataScopeServerBase::_duplicate(ret);
}
void DataServerManager::removeDataScope(const char *scopeName)
{
- SALOME::DataScopeServer_var scs(getScopePtrGivenName(scopeName));
+ SALOME::DataScopeServerBase_var scs(getScopePtrGivenName(scopeName));
scs->shutdownIfNotHostedByDSM();
}
return oss.str();
}
-CORBA::Boolean DataServerManager::IsAliveAndKicking(SALOME::DataScopeServer_ptr scopePtr)
+CORBA::Boolean DataServerManager::IsAliveAndKicking(SALOME::DataScopeServerBase_ptr scopePtr)
{
CORBA::Boolean ret(true);
try
return ret;
}
-SALOME::DataScopeServer_var DataServerManager::getScopePtrGivenName(const std::string& scopeName)
+SALOME::DataScopeServerBase_var DataServerManager::GetScopePtrGivenName(const std::string& scopeName, const std::vector<std::string>& scopes, SALOME_NamingService& ns)
{
- std::vector<std::string> scopes(listOfScopesCpp());
std::size_t sz(scopes.size());
if(std::find(scopes.begin(),scopes.end(),scopeName)==scopes.end())
{
std::ostringstream oss; oss << "DataServerManager::getScopePtrGivenName : scope name \"" << scopeName << "\" does not exist !";
throw Exception(oss.str());
}
- SALOME_NamingService ns(_orb);
std::string fullScopeName(CreateAbsNameInNSFromScopeName(scopeName));
CORBA::Object_var obj(ns.Resolve(fullScopeName.c_str()));
- SALOME::DataScopeServer_var ret(SALOME::DataScopeServer::_narrow(obj));
+ SALOME::DataScopeServerBase_var ret(SALOME::DataScopeServerBase::_narrow(obj));
return ret;
}
+
+SALOME::DataScopeServerBase_var DataServerManager::getScopePtrGivenName(const std::string& scopeName)
+{
+ SALOME_NamingService ns(_orb);
+ return GetScopePtrGivenName(scopeName,listOfScopesCpp(),ns);
+}
#include <string>
+class SALOME_NamingService;
+
namespace SALOMESDS
{
class DataScopeServer;
-
+
class SALOMESDS_EXPORT DataServerManager : public virtual POA_SALOME::DataServerManager
{
public:
SALOME::StringVec *listAliveAndKickingScopes();
SALOME::DataScopeServer_ptr getDefaultScope();
CORBA::Boolean isAliveAndKicking(const char *scopeName);
+ SALOME::DataScopeServerBase_ptr retriveDataScope(const char *scopeName);
+ //
SALOME::DataScopeServer_ptr createDataScope(const char *scopeName);
- SALOME::DataScopeServer_ptr retriveDataScope(const char *scopeName);
SALOME::DataScopeServer_ptr giveADataScopeCalled(const char *scopeName, CORBA::Boolean& isCreated);
+ //
+ SALOME::DataScopeServerTransaction_ptr createDataScopeTransaction(const char *scopeName);
+ SALOME::DataScopeServerTransaction_ptr giveADataScopeTransactionCalled(const char *scopeName, CORBA::Boolean& isCreated);
+ //
void removeDataScope(const char *scopeName);
void cleanScopesInNS();
void shutdownScopes();
public:
CORBA::ORB_var getORB() { return _orb; }
static std::string CreateAbsNameInNSFromScopeName(const std::string& scopeName);
- static CORBA::Boolean IsAliveAndKicking(SALOME::DataScopeServer_ptr scopePtr);
+ static CORBA::Boolean IsAliveAndKicking(SALOME::DataScopeServerBase_ptr scopePtr);
+ static SALOME::DataScopeServerBase_var GetScopePtrGivenName(const std::string& scopeName, const std::vector<std::string>& scopes, SALOME_NamingService& ns);
public:
static const char NAME_IN_NS[];
static const char DFT_SCOPE_NAME_IN_NS[];
private:
std::vector<std::string> listOfScopesCpp();
- SALOME::DataScopeServer_var getScopePtrGivenName(const std::string& scopeName);
+ SALOME::DataScopeServerBase_var getScopePtrGivenName(const std::string& scopeName);
private:
CORBA::ORB_var _orb;
//! single thread poa
// Author : Anthony GEAY (EDF R&D)
#include "SALOMESDS_Transaction.hxx"
-#include "SALOMESDS_TransactionFactory.hxx"
#include "SALOMESDS_DataServerManager.hxx"
#include "SALOMESDS_Exception.hxx"
using namespace SALOMESDS;
-void Transaction::checkAliveAndKicking()
-{
- SALOME::DataScopeServer_var dsc(_tf->getDSM()->retriveDataScope(_scope_name.c_str()));
- if(!DataServerManager::IsAliveAndKicking(dsc))
- throw Exception("Transaction::checkAliveAndKicking : not alive !");
-}
-
void Transaction::FromByteSeqToVB(const SALOME::ByteVec& bsToBeConv, std::vector<unsigned char>& ret)
{
std::size_t sz(bsToBeConv.length());
buf[i]=bsToBeConv[i];
}
-TransactionVarCreate::TransactionVarCreate(TransactionFactory *tf, const std::string& varName, const std::string& scopeName, const SALOME::ByteVec& constValue):Transaction(tf,varName,scopeName)
+TransactionVarCreate::TransactionVarCreate(const std::string& varName, const SALOME::ByteVec& constValue):Transaction(varName)
{
FromByteSeqToVB(constValue,_data);
}
void TransactionVarCreate::prepareRollBackInCaseOfFailure()
{//nothing it is not a bug
}
-
-void TransactionVarCreate::checkAliveAndKicking()
-{
- SALOME::DataScopeServer_var dsc(_tf->getDSM()->retriveDataScope(_scope_name.c_str()));
- if(!DataServerManager::IsAliveAndKicking(dsc))
- throw Exception("TransactionVarCreate::checkAliveAndKicking : not alive !");
- if(dsc->existVar(_var_name.c_str()))
- {
- std::ostringstream oss; oss << "TransactionVarCreate::checkAliveAndKicking : var \"" << _var_name << "\" already exists in scope named \"" << _scope_name << "\" !";
- throw Exception(oss.str());
- }
-}
namespace SALOMESDS
{
- class TransactionFactory;
-
class SALOMESDS_EXPORT Transaction : public virtual POA_SALOME::Transaction
{
public:
- Transaction(TransactionFactory *tf, const std::string& varName, const std::string& scopeName):_tf(tf),_var_name(varName),_scope_name(scopeName) { }
- std::string getScopeName() const { return _scope_name; }
+ Transaction(const std::string& varName):_var_name(varName) { }
std::string getVarName() const { return _var_name; }
- virtual void checkAliveAndKicking();
virtual void prepareRollBackInCaseOfFailure() = 0;
public:
static void FromByteSeqToVB(const SALOME::ByteVec& bsToBeConv, std::vector<unsigned char>& ret);
protected:
- TransactionFactory *_tf;
std::string _var_name;
- std::string _scope_name;
};
class TransactionVarCreate : public Transaction
{
public:
- TransactionVarCreate(TransactionFactory *tf, const std::string& varName, const std::string& scopeName, const SALOME::ByteVec& constValue);
- void checkAliveAndKicking();
+ TransactionVarCreate(const std::string& varName, const SALOME::ByteVec& constValue);
void prepareRollBackInCaseOfFailure();
protected:
std::vector<unsigned char> _data;
class TransactionRdOnlyVarCreate : public TransactionVarCreate
{
public:
- TransactionRdOnlyVarCreate(TransactionFactory *tf, const std::string& varName, const std::string& scopeName, const SALOME::ByteVec& constValue):TransactionVarCreate(tf,varName,scopeName,constValue) { }
+ TransactionRdOnlyVarCreate(const std::string& varName, const SALOME::ByteVec& constValue):TransactionVarCreate(varName,constValue) { }
};
}
+++ /dev/null
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-// Author : Anthony GEAY (EDF R&D)
-
-#include "SALOMESDS_TransactionFactory.hxx"
-#include "SALOMESDS_DataServerManager.hxx"
-#include "SALOMESDS_AutoRefCountPtr.hxx"
-#include "SALOMESDS_Transaction.hxx"
-#include "SALOME_NamingService.hxx"
-#include "SALOMESDS_Exception.hxx"
-
-#include <sstream>
-
-using namespace SALOMESDS;
-
-const char TransactionFactory::NAME_IN_NS[]="/TransactionFactory";
-
-TransactionFactory::TransactionFactory(DataServerManager *dsm):_dsm(dsm)
-{
- if(!_dsm)
- throw Exception("TransactionFactory : null pointer !");
- CORBA::ORB_var orb(_dsm->getORB());
- CORBA::Object_var obj0(orb->resolve_initial_references("RootPOA"));
- _poa=PortableServer::POA::_narrow(obj0);
- //
- PortableServer::ObjectId_var id(_poa->activate_object(this));
- CORBA::Object_var obj(_poa->id_to_reference(id));
- SALOME::TransactionFactory_var obj2(SALOME::TransactionFactory::_narrow(obj));
- // publish Data server manager in NS
- SALOME_NamingService ns(orb);
- ns.Register(obj2,NAME_IN_NS);
-}
-
-SALOME::Transaction_ptr TransactionFactory::createRdOnlyVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue)
-{
- TransactionRdOnlyVarCreate *ret(new TransactionRdOnlyVarCreate(this,varName,scopeName,constValue));
- ret->checkAliveAndKicking();
- PortableServer::ObjectId_var id(_poa->activate_object(ret));
- CORBA::Object_var obj(_poa->id_to_reference(id));
- return SALOME::Transaction::_narrow(obj);
-}
-
-void TransactionFactory::atomicApply(const SALOME::ListOfTransaction& transactions)
-{
- std::size_t sz(transactions.length());
- if(sz==0)
- return ;
- std::vector< AutoServantPtr<Transaction> > transactionsCpp(sz);
- for(std::size_t i=0;i<sz;i++)
- {
- PortableServer::ServantBase *eltBase(0);
- Transaction *elt(0);
- try
- {
- eltBase=_poa->reference_to_servant(transactions[i]);
- elt=dynamic_cast<Transaction *>(eltBase);
- }
- catch(...)
- {
- std::ostringstream oss; oss << "TransactionFactory::atomicApply : the elt #" << i << " is invalid !";
- throw Exception(oss.str());
- }
- if(!elt)
- {
- std::ostringstream oss; oss << "TransactionFactory::atomicApply : the elt #" << i << " is null ?";
- throw Exception(oss.str());
- }
- elt->_remove_ref();
- transactionsCpp[i]=elt;
- transactionsCpp[i].setHolder(this);
- }
- std::string scopeName(transactionsCpp[0]->getScopeName());
- for(std::size_t i=0;i<sz;i++)
- if(transactionsCpp[i]->getScopeName()!=scopeName)
- throw Exception("TransactionFactory::atomicApply : all transactions must refer the same scope !");
- for(std::size_t i=0;i<sz;i++)
- transactionsCpp[i]->checkAliveAndKicking();
-}
+++ /dev/null
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-// Author : Anthony GEAY (EDF R&D)
-
-#ifndef __SALOMESDS_TRANSACTIONFACTORY_HXX__
-#define __SALOMESDS_TRANSACTIONFACTORY_HXX__
-
-#include "SALOMEconfig.h"
-#include CORBA_SERVER_HEADER(SALOME_SDS)
-#include "SALOMESDS_Defines.hxx"
-#include "SALOMESDS_AutoRefCountPtr.hxx"
-
-#include <string>
-#include <vector>
-
-namespace SALOMESDS
-{
- class DataServerManager;
-
- class SALOMESDS_EXPORT TransactionFactory : public virtual POA_SALOME::TransactionFactory, POAHolder
- {
- public:
- TransactionFactory(DataServerManager *dsm);
- DataServerManager *getDSM() const { return _dsm; }
- PortableServer::POA_var getPOA() const { return _poa; }
- public:
- SALOME::Transaction_ptr createRdOnlyVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue);
- SALOME::Transaction_ptr createRdExtVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue);
- SALOME::Transaction_ptr createRdWrVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constValue);
- SALOME::Transaction_ptr addKeyValueInVarErrorIfAlreadyExisting(const char *varName, const char *scopeName, const SALOME::ByteVec& key, const SALOME::ByteVec& value);
- SALOME::Transaction_ptr addKeyValueInVarHard(const char *varName, const char *scopeName, const SALOME::ByteVec& key, const SALOME::ByteVec& value);
- SALOME::Transaction_ptr removeKeyInVarErrorIfNotAlreadyExisting(const char *varName, const char *scopeName, const SALOME::ByteVec& key);
- SALOME::ByteVec *waitForKeyInVar(const char *varName, const char *scopeName, const SALOME::ByteVec& constKey);
- SALOME::ByteVec *waitForKeyInVarAndKillIt(const char *varName, const char *scopeName, const SALOME::ByteVec& constKey, SALOME::Transaction_out transaction);
- void atomicApply(const SALOME::ListOfTransaction& transactions);
- public:
- static const char NAME_IN_NS[];
- private:
- DataServerManager *_dsm;
- //! multi thread poa
- PortableServer::POA_var _poa;
- };
-}
-
-#endif
if(argc<=1)
throw SALOMESDS::Exception("In the main of SALOME_DataScopeServer.cxx !");
scopeName=argv[1];
+ std::istringstream isTransacSS(argv[2]);
+ int isTransac(0);
+ isTransacSS >> isTransac;
CORBA::ORB_var orb(CORBA::ORB_init(argc,argv));
CORBA::Object_var obj(orb->resolve_initial_references("RootPOA"));
PortableServer::POA_var poa(PortableServer::POA::_narrow(obj));
PortableServer::POAManager_var mgr(poa->the_POAManager());
mgr->activate();
- SALOMESDS::DataScopeServer *server(new SALOMESDS::DataScopeServer(orb,scopeName));
+ SALOMESDS::DataScopeServerBase *server(0);
+ if(!isTransac)
+ server=new SALOMESDS::DataScopeServer(orb,scopeName);
+ else
+ server=new SALOMESDS::DataScopeServerTransaction(orb,scopeName);
//
CORBA::PolicyList policies;
policies.length(1);
server->registerToSalomePiDict();
PortableServer::ObjectId_var id(poa2->activate_object(server));
obj=poa2->id_to_reference(id);
- SALOME::DataScopeServer_var serverPtr(SALOME::DataScopeServer::_narrow(obj));
+ SALOME::DataScopeServerBase_var serverPtr(SALOME::DataScopeServerBase::_narrow(obj));
server->setPOAAndRegister(poa2,serverPtr);
//
orb->run();
