diff options
135 files changed, 8323 insertions, 10447 deletions
diff --git a/cpp/config/Make.rules b/cpp/config/Make.rules index c70786deebb..a3c935023ef 100644 --- a/cpp/config/Make.rules +++ b/cpp/config/Make.rules @@ -62,10 +62,11 @@ static_excludes = test/Ice/library test/Ice/plugin # cpp11_components = $(coreandstub_components) \ glacier2router Glacier2CryptPermissionsVerifier \ - icebox iceboxadmin icebridge \ + icebox icebridge \ IceDB \ IceXML \ icegridnode icegridregistry icegridadmin icegriddb \ + IceStormService icestormadmin icestormdb \ cpp11_projects = test/Common \ test/IceUtil/% \ @@ -80,7 +81,7 @@ cpp11_projects = test/Common \ test/IceGrid/% \ test/IceBridge/simple -cpp11_excludes = test/Ice/gc +cpp11_excludes = test/Ice/gc # # If building on a Linux multilib platform, we restrict what we build for diff --git a/cpp/src/IceGrid/Activator.cpp b/cpp/src/IceGrid/Activator.cpp index 23369aac08f..a403433d398 100644 --- a/cpp/src/IceGrid/Activator.cpp +++ b/cpp/src/IceGrid/Activator.cpp @@ -44,33 +44,12 @@ using namespace IceGrid; namespace IceGrid { -class TerminationListenerThread : public IceUtil::Thread -{ -public: - - TerminationListenerThread(Activator& activator) : - IceUtil::Thread("IceGrid termination listener thread"), - _activator(activator) - { - } - - virtual - void run() - { - _activator.runTerminationListener(); - } - -private: - - Activator& _activator; -}; - #ifndef _WIN32 // // Helper function for async-signal safe error reporting // void -reportChildError(int err, int fd, const char* cannot, const char* name, const TraceLevelsPtr& traceLevels) +reportChildError(int err, int fd, const char* cannot, const char* name, const shared_ptr<TraceLevels>& traceLevels) { // // Send any errors to the parent process, using the write @@ -301,19 +280,19 @@ extern "C" void CALLBACK activatorWaitCallback(PVOID data, BOOLEAN) } #endif -Activator::Activator(const TraceLevelsPtr& traceLevels) : +Activator::Activator(const shared_ptr<TraceLevels>& traceLevels) : _traceLevels(traceLevels), _deactivating(false) { #ifdef _WIN32 _hIntr = CreateEvent( - ICE_NULLPTR, // Security attributes + nullptr, // Security attributes TRUE, // Manual reset FALSE, // Initial state is nonsignaled - ICE_NULLPTR // Unnamed + nullptr // Unnamed ); - if(_hIntr == ICE_NULLPTR) + if(_hIntr == nullptr) { throw SyscallException(__FILE__, __LINE__, getSystemErrno()); @@ -335,10 +314,8 @@ Activator::Activator(const TraceLevelsPtr& traceLevels) : Activator::~Activator() { - assert(!_thread); - #ifdef _WIN32 - if(_hIntr != ICE_NULLPTR) + if(_hIntr != nullptr) { CloseHandle(_hIntr); } @@ -358,9 +335,9 @@ Activator::activate(const string& name, #endif const Ice::StringSeq& options, const Ice::StringSeq& envs, - const ServerIPtr& server) + const shared_ptr<ServerI>& server) { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); if(_deactivating) { @@ -390,7 +367,7 @@ Activator::activate(const string& name, // IceGrid doesn't support to use string converters, so don't need to use // any string converter in wstringToString conversions. // - if(SearchPathW(ICE_NULLPTR, stringToWstring(path).c_str(), ext.c_str(), _MAX_PATH, absbuf, &fPart) == 0) + if(SearchPathW(nullptr, stringToWstring(path).c_str(), ext.c_str(), _MAX_PATH, absbuf, &fPart) == 0) { if(_traceLevels->activator > 0) { @@ -417,7 +394,7 @@ Activator::activate(const string& name, if(!pwd.empty()) { wchar_t absbuf[_MAX_PATH]; - if(_wfullpath(absbuf, stringToWstring(pwd).c_str(), _MAX_PATH) == ICE_NULLPTR) + if(_wfullpath(absbuf, stringToWstring(pwd).c_str(), _MAX_PATH) == nullptr) { if(_traceLevels->activator > 0) { @@ -506,7 +483,7 @@ Activator::activate(const string& name, // any string converter in stringToWstring conversions. // wstring wpwd = stringToWstring(pwd); - const wchar_t* dir = !wpwd.empty() ? wpwd.c_str() : ICE_NULLPTR; + const wchar_t* dir = !wpwd.empty() ? wpwd.c_str() : nullptr; // // Make a copy of the command line. @@ -519,7 +496,7 @@ Activator::activate(const string& name, // Since Windows is case insensitive wrt environment variables we convert the keys to // uppercase to ensure matches are found. // - const wchar_t* env = ICE_NULLPTR; + const wchar_t* env = nullptr; wstring envbuf; if(!envs.empty()) { @@ -583,10 +560,10 @@ Activator::activate(const string& name, PROCESS_INFORMATION pi; ZeroMemory(&pi, sizeof(pi)); BOOL b = CreateProcessW( - ICE_NULLPTR, // Executable + nullptr, // Executable cmdbuf, // Command line - ICE_NULLPTR, // Process attributes - ICE_NULLPTR, // Thread attributes + nullptr, // Process attributes + nullptr, // Thread attributes FALSE, // Do NOT inherit handles CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT, // Process creation flags (LPVOID)env, // Process environment @@ -809,7 +786,7 @@ Activator::activate(const string& name, int maxFd = static_cast<int>(sysconf(_SC_OPEN_MAX)); if(maxFd <= 0) { - maxFd = INT_MAX; + maxFd = numeric_limits<int>::max(); } for(int fd = 3; fd < maxFd; ++fd) @@ -884,7 +861,7 @@ Activator::activate(const string& name, } // - // If an error occured before the exec() we do some cleanup and throw. + // If an error occurred before the exec() we do some cleanup and throw. // if(!message.empty()) { @@ -930,42 +907,8 @@ Activator::activate(const string& name, #endif } -namespace -{ - -class ShutdownCallback : public IceUtil::Shared -{ -public: - - ShutdownCallback(const ActivatorPtr& activator, const string& name, const TraceLevelsPtr& traceLevels) : - _activator(activator), _name(name), _traceLevels(traceLevels) - { - - } - - virtual void - exception(const Ice::Exception& ex) - { - Ice::Warning out(_traceLevels->logger); - out << "exception occurred while deactivating `" << _name << "' using process proxy:\n" << ex; - - // - // Send a SIGTERM to the process. - // - _activator->sendSignal(_name, SIGTERM); - } - -private: - - const ActivatorPtr _activator; - const string _name; - const TraceLevelsPtr _traceLevels; -}; - -} - void -Activator::deactivate(const string& name, const Ice::ProcessPrx& process) +Activator::deactivate(const string& name, const shared_ptr<Ice::ProcessPrx>& process) { #ifdef _WIN32 Ice::Int pid = getServerPid(name); @@ -988,8 +931,24 @@ Activator::deactivate(const string& name, const Ice::ProcessPrx& process) Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat); out << "deactivating `" << name << "' using process proxy"; } - process->begin_shutdown(Ice::newCallback_Process_shutdown(new ShutdownCallback(this, name, _traceLevels), - &ShutdownCallback::exception)); + + process->shutdownAsync(nullptr, [self = shared_from_this(), name] (exception_ptr ex) + { + try + { + rethrow_exception(ex); + } + catch (const std::exception& e) + { + Ice::Warning out(self->_traceLevels->logger); + out << "exception occurred while deactivating `" << name << "' using process proxy:\n" << e; + } + + // + // Send a SIGTERM to the process. + // + self->sendSignal(name, SIGTERM); + }); return; } @@ -1051,7 +1010,7 @@ Activator::sendSignal(const string& name, int signal) else if(signal == SIGKILL) { HANDLE hnd = OpenProcess(PROCESS_TERMINATE, FALSE, pid); - if(hnd == ICE_NULLPTR) + if(hnd == nullptr) { throw SyscallException(__FILE__, __LINE__, getSystemErrno()); } @@ -1085,18 +1044,18 @@ Activator::sendSignal(const string& name, int signal) #endif } -Ice::Int +int Activator::getServerPid(const string& name) { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); - map<string, Process>::const_iterator p = _processes.find(name); + auto p = _processes.find(name); if(p == _processes.end()) { return 0; } - return static_cast<Ice::Int>(p->second.pid); + return static_cast<int>(p->second.pid); } void @@ -1105,24 +1064,20 @@ Activator::start() // // Create and start the termination listener thread. // - _thread = new TerminationListenerThread(*this); - _thread->start(); + _thread = thread([this] { runTerminationListener(); }); } void Activator::waitForShutdown() { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); - while(!_deactivating) - { - wait(); - } + unique_lock lock(_mutex); + _condVar.wait(lock, [this] { return _deactivating; }); } void Activator::shutdown() { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); if(_deactivating) { return; @@ -1136,7 +1091,7 @@ Activator::shutdown() // _deactivating = true; setInterrupt(); - notifyAll(); + _condVar.notify_all(); } void @@ -1144,7 +1099,7 @@ Activator::destroy() { map<string, Process> processes; { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); assert(_deactivating); processes = _processes; } @@ -1152,7 +1107,7 @@ Activator::destroy() // // Stop all active processes. // - for(map<string, Process>::iterator p = processes.begin(); p != processes.end(); ++p) + for(const auto& [name, proc] : processes) { // // Stop the server. The listener thread should detect the @@ -1161,7 +1116,7 @@ Activator::destroy() // try { - p->second.server->stop_async(0, Ice::emptyCurrent); + proc.server->stopAsync(nullptr, nullptr, Ice::emptyCurrent); } catch(const ServerStopException&) { @@ -1176,7 +1131,7 @@ Activator::destroy() catch(const Ice::LocalException& ex) { Ice::Warning out(_traceLevels->logger); - out << "unexpected exception raised by server `" << p->first << "' stop:\n" << ex; + out << "unexpected exception raised by server `" << name << "' stop:\n" << ex; } } @@ -1185,18 +1140,14 @@ Activator::destroy() // when there's no more processes and when _deactivating is set to // true. // - if(_thread) - { - _thread->getThreadControl().join(); - _thread = 0; - } + _thread.join(); assert(_processes.empty()); } bool Activator::isActive() { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); return !_deactivating; } @@ -1245,7 +1196,7 @@ Activator::terminationListener() vector<Process> terminated; bool deactivated = false; { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); for(vector<Process*>::const_iterator q = _terminated.begin(); q != _terminated.end(); ++q) { for(map<string, Process>::iterator p = _processes.begin(); p != _processes.end(); ++p) @@ -1307,7 +1258,7 @@ Activator::terminationListener() FD_SET(_fdIntrRead, &fdSet); { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); for(map<string, Process>::iterator p = _processes.begin(); p != _processes.end(); ++p) { @@ -1344,7 +1295,7 @@ Activator::terminationListener() vector<Process> terminated; bool deactivated = false; { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); if(FD_ISSET(_fdIntrRead, &fdSet)) { @@ -1461,8 +1412,7 @@ Activator::clearInterrupt() ResetEvent(_hIntr); #else char c; - while(read(_fdIntrRead, &c, 1) == 1) - ; + while(read(_fdIntrRead, &c, 1) == 1); #endif } @@ -1534,7 +1484,7 @@ Activator::waitPid(pid_t processPid) void Activator::processTerminated(Activator::Process* process) { - IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this); + lock_guard lock(_mutex); setInterrupt(); _terminated.push_back(process); } diff --git a/cpp/src/IceGrid/Activator.h b/cpp/src/IceGrid/Activator.h index f2eb0ff5a56..809dc1d7441 100644 --- a/cpp/src/IceGrid/Activator.h +++ b/cpp/src/IceGrid/Activator.h @@ -5,7 +5,6 @@ #ifndef ICE_GRID_ACTIVATOR_H #define ICE_GRID_ACTIVATOR_H -#include <IceUtil/Thread.h> #include <IceGrid/Internal.h> #ifndef _WIN32 @@ -16,14 +15,11 @@ namespace IceGrid { class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - class ServerI; -typedef IceUtil::Handle<ServerI> ServerIPtr; std::string signalToString(int); -class Activator : public IceUtil::Monitor< IceUtil::Mutex>, public IceUtil::Shared +class Activator final : public std::enable_shared_from_this<Activator> { public: @@ -39,27 +35,27 @@ public: int pipeFd; std::string msg; #endif - ServerIPtr server; + std::shared_ptr<ServerI> server; }; - Activator(const TraceLevelsPtr&); - virtual ~Activator(); + Activator(const std::shared_ptr<TraceLevels>&); + ~Activator(); - virtual int activate(const std::string&, const std::string&, const std::string&, + int activate(const std::string&, const std::string&, const std::string&, #ifndef _WIN32 - uid_t, gid_t, + uid_t, gid_t, #endif - const Ice::StringSeq&, const Ice::StringSeq&, const ServerIPtr&); - virtual void deactivate(const std::string&, const Ice::ProcessPrx&); - virtual void kill(const std::string&); - virtual void sendSignal(const std::string&, const std::string&); + const Ice::StringSeq&, const Ice::StringSeq&, const std::shared_ptr<ServerI>&); + void deactivate(const std::string&, const std::shared_ptr<Ice::ProcessPrx>&); + void kill(const std::string&); + void sendSignal(const std::string&, const std::string&); - virtual Ice::Int getServerPid(const std::string&); + int getServerPid(const std::string&); - virtual void start(); - virtual void waitForShutdown(); - virtual void shutdown(); - virtual void destroy(); + void start(); + void waitForShutdown(); + void shutdown(); + void destroy(); bool isActive(); @@ -80,7 +76,7 @@ private: int waitPid(pid_t); #endif - TraceLevelsPtr _traceLevels; + std::shared_ptr<TraceLevels> _traceLevels; std::map<std::string, Process> _processes; bool _deactivating; @@ -92,9 +88,10 @@ private: int _fdIntrWrite; #endif - IceUtil::ThreadPtr _thread; + std::mutex _mutex; + std::condition_variable _condVar; + std::thread _thread; }; -typedef IceUtil::Handle<Activator> ActivatorPtr; } diff --git a/cpp/src/IceGrid/AdapterCache.cpp b/cpp/src/IceGrid/AdapterCache.cpp index 941a653b5f3..e6fd6523609 100644 --- a/cpp/src/IceGrid/AdapterCache.cpp +++ b/cpp/src/IceGrid/AdapterCache.cpp @@ -11,6 +11,7 @@ #include <IceGrid/ServerCache.h> #include <IceGrid/NodeCache.h> #include <IceGrid/SessionI.h> +#include <IceGrid/Internal.h> #include <functional> @@ -20,52 +21,11 @@ using namespace IceGrid; namespace IceGrid { -struct ReplicaLoadComp : binary_function<ServerAdapterEntryPtr&, ServerAdapterEntryPtr&, bool> -{ - bool operator()(const pair<float, ServerAdapterEntryPtr>& lhs, const pair<float, ServerAdapterEntryPtr>& rhs) - { - return lhs.first < rhs.first; - } -}; - -struct ReplicaPriorityComp : binary_function<ServerAdapterEntryPtr&, ServerAdapterEntryPtr&, bool> -{ - bool operator()(const ServerAdapterEntryPtr& lhs, const ServerAdapterEntryPtr& rhs) - { - return lhs->getPriority() < rhs->getPriority(); - } -}; - -struct TransformToReplicaLoad : - public unary_function<const ServerAdapterEntryPtr&, pair<float, ServerAdapterEntryPtr> > +class ReplicaGroupSyncCallback final : public SynchronizationCallback { public: - TransformToReplicaLoad(LoadSample loadSample) : _loadSample(loadSample) { } - - pair<float, ServerAdapterEntryPtr> - operator()(const ServerAdapterEntryPtr& value) - { - return make_pair(value->getLeastLoadedNodeLoad(_loadSample), value); - } - - LoadSample _loadSample; -}; - -struct TransformToReplica : public unary_function<const pair<string, ServerAdapterEntryPtr>&, ServerAdapterEntryPtr> -{ - ServerAdapterEntryPtr - operator()(const pair<float, ServerAdapterEntryPtr>& value) - { - return value.second; - } -}; - -class ReplicaGroupSyncCallback : public SynchronizationCallback, public IceUtil::Mutex -{ -public: - - ReplicaGroupSyncCallback(const SynchronizationCallbackPtr& callback, int count, int nReplicas) : + ReplicaGroupSyncCallback(const shared_ptr<SynchronizationCallback>& callback, int count, int nReplicas) : _callback(callback), _responseCalled(false), _synchronizeCount(count), @@ -77,20 +37,20 @@ public: bool response() { - Lock sync(*this); + lock_guard lock(_mutex); _responseCalled = true; if(_synchronizedCount >= _nReplicas) { - _callback = 0; + _callback = nullptr; return false; } else if(_synchronizeCount == 0) { - if(_synchronizedCount == 0 && _exception.get()) + if(_synchronizedCount == 0 && _exception) { - _exception->ice_throw(); + rethrow_exception(_exception); } - _callback = 0; + _callback = nullptr; return false; } return true; @@ -99,9 +59,9 @@ public: void synchronized() { - SynchronizationCallbackPtr callback; + shared_ptr<SynchronizationCallback> callback; { - Lock sync(*this); + lock_guard lock(_mutex); ++_synchronizedCount; --_synchronizeCount; @@ -116,7 +76,7 @@ public: } callback = _callback; - _callback = 0; + _callback = nullptr; } if(callback) @@ -126,14 +86,14 @@ public: } void - synchronized(const Ice::Exception& ex) + synchronized(exception_ptr ex) { - SynchronizationCallbackPtr callback; + shared_ptr<SynchronizationCallback> callback; { - Lock sync(*this); - if(!_exception.get()) + lock_guard lock(_mutex); + if(!_exception) { - _exception.reset(ex.ice_clone()); + _exception = ex; } --_synchronizeCount; @@ -159,19 +119,20 @@ public: private: - SynchronizationCallbackPtr _callback; + shared_ptr<SynchronizationCallback> _callback; bool _responseCalled; int _synchronizeCount; int _synchronizedCount; int _nReplicas; - IceInternal::UniquePtr<Ice::Exception> _exception; + exception_ptr _exception; + + mutex _mutex; }; -typedef IceUtil::Handle<ReplicaGroupSyncCallback> ReplicaGroupSyncCallbackPtr; } void -GetAdapterInfoResult::add(const ServerAdapterEntryPtr& adapter) +GetAdapterInfoResult::add(const ServerAdapterEntry* adapter) { AdapterInfo info; info.id = adapter->getId(); @@ -179,15 +140,15 @@ GetAdapterInfoResult::add(const ServerAdapterEntryPtr& adapter) _adapters.push_back(info); try { - _results.push_back(adapter->getProxy("", true)->begin_getDirectProxy()); + _results.push_back(adapter->getProxy("", true)->getDirectProxyAsync()); } catch(const SynchronizationException&) { - _results.push_back(0); + _results.push_back(nullopt); } catch(const Ice::Exception&) { - _results.push_back(0); + _results.push_back(nullopt); } } @@ -195,13 +156,13 @@ AdapterInfoSeq GetAdapterInfoResult::get() { vector<AdapterInfo>::iterator q = _adapters.begin(); - for(vector<Ice::AsyncResultPtr>::const_iterator p = _results.begin(); p != _results.end(); ++p, ++q) + for(auto p = _results.begin(); p != _results.end(); ++p, ++q) { try { if(*p) { - q->proxy = AdapterPrx::uncheckedCast((*p)->getProxy())->end_getDirectProxy(*p); + q->proxy = Ice::uncheckedCast<AdapterPrx>((*p)->get()); } } catch(const Ice::Exception&) @@ -211,14 +172,14 @@ GetAdapterInfoResult::get() return _adapters; } -AdapterCache::AdapterCache(const Ice::CommunicatorPtr& communicator) : _communicator(communicator) +AdapterCache::AdapterCache(const shared_ptr<Ice::Communicator>& communicator) : _communicator(communicator) { } void -AdapterCache::addServerAdapter(const AdapterDescriptor& desc, const ServerEntryPtr& server, const string& app) +AdapterCache::addServerAdapter(const AdapterDescriptor& desc, const shared_ptr<ServerEntry>& server, const string& app) { - Lock sync(*this); + lock_guard lock(_mutex); if(getImpl(desc.id)) { Ice::Error out(_communicator->getLogger()); @@ -226,23 +187,29 @@ AdapterCache::addServerAdapter(const AdapterDescriptor& desc, const ServerEntryP return; } - istringstream is(desc.priority); int priority = 0; - is >> priority; + try + { + priority = stoi(desc.priority); + } + catch(const std::exception&) + { + } - ServerAdapterEntryPtr entry = new ServerAdapterEntry(*this, desc.id, app, desc.replicaGroupId, priority, server); + auto entry = make_shared<ServerAdapterEntry>(*this, desc.id, app, desc.replicaGroupId, priority, server); addImpl(desc.id, entry); if(!desc.replicaGroupId.empty()) { - ReplicaGroupEntryPtr repEntry = ReplicaGroupEntryPtr::dynamicCast(getImpl(desc.replicaGroupId)); + auto repEntry = dynamic_pointer_cast<ReplicaGroupEntry>(getImpl(desc.replicaGroupId)); if(!repEntry) { // // Add an un-assigned replica group, the replica group will in theory be added // shortly after when its application is loaded. // - repEntry = new ReplicaGroupEntry(*this, desc.replicaGroupId, "", new RandomLoadBalancingPolicy("0"), ""); + repEntry = make_shared<ReplicaGroupEntry>(*this, desc.replicaGroupId, "", + make_shared<RandomLoadBalancingPolicy>("0"), ""); addImpl(desc.replicaGroupId, repEntry); } repEntry->addReplica(desc.id, entry); @@ -252,8 +219,8 @@ AdapterCache::addServerAdapter(const AdapterDescriptor& desc, const ServerEntryP void AdapterCache::addReplicaGroup(const ReplicaGroupDescriptor& desc, const string& app) { - Lock sync(*this); - ReplicaGroupEntryPtr repEntry = ReplicaGroupEntryPtr::dynamicCast(getImpl(desc.id)); + lock_guard lock(_mutex); + auto repEntry = dynamic_pointer_cast<ReplicaGroupEntry>(getImpl(desc.id)); if(repEntry) { // @@ -271,14 +238,15 @@ AdapterCache::addReplicaGroup(const ReplicaGroupDescriptor& desc, const string& } return; } - addImpl(desc.id, new ReplicaGroupEntry(*this, desc.id, app, desc.loadBalancing, desc.filter)); + addImpl(desc.id, make_shared<ReplicaGroupEntry>(*this, desc.id, app, desc.loadBalancing, desc.filter)); } -AdapterEntryPtr +shared_ptr<AdapterEntry> AdapterCache::get(const string& id) const { - Lock sync(*this); - AdapterEntryPtr entry = getImpl(id); + lock_guard lock(_mutex); + + auto entry = getImpl(id); if(!entry) { throw AdapterNotExistException(id); @@ -289,9 +257,9 @@ AdapterCache::get(const string& id) const void AdapterCache::removeServerAdapter(const string& id) { - Lock sync(*this); + lock_guard lock(_mutex); - ServerAdapterEntryPtr entry = ServerAdapterEntryPtr::dynamicCast(getImpl(id)); + auto entry = dynamic_pointer_cast<ServerAdapterEntry>(getImpl(id)); if(!entry) { Ice::Error out(_communicator->getLogger()); @@ -303,7 +271,7 @@ AdapterCache::removeServerAdapter(const string& id) string replicaGroupId = entry->getReplicaGroupId(); if(!replicaGroupId.empty()) { - ReplicaGroupEntryPtr repEntry = ReplicaGroupEntryPtr::dynamicCast(getImpl(replicaGroupId)); + auto repEntry = dynamic_pointer_cast<ReplicaGroupEntry>(getImpl(replicaGroupId)); if(!repEntry) { Ice::Error out(_communicator->getLogger()); @@ -325,8 +293,9 @@ AdapterCache::removeServerAdapter(const string& id) void AdapterCache::removeReplicaGroup(const string& id) { - Lock sync(*this); - ReplicaGroupEntryPtr entry = ReplicaGroupEntryPtr::dynamicCast(getImpl(id)); + lock_guard lock(_mutex); + + auto entry = dynamic_pointer_cast<ReplicaGroupEntry>(getImpl(id)); if(!entry) { Ice::Error out(_communicator->getLogger()); @@ -336,8 +305,8 @@ AdapterCache::removeReplicaGroup(const string& id) removeImpl(id); } -AdapterEntryPtr -AdapterCache::addImpl(const string& id, const AdapterEntryPtr& entry) +shared_ptr<AdapterEntry> +AdapterCache::addImpl(const string& id, const shared_ptr<AdapterEntry>& entry) { if(_traceLevels && _traceLevels->adapter > 0) { @@ -388,7 +357,7 @@ ServerAdapterEntry::ServerAdapterEntry(AdapterCache& cache, const string& application, const string& replicaGroupId, int priority, - const ServerEntryPtr& server) : + const shared_ptr<ServerEntry>& server) : AdapterEntry(cache, id, application), _replicaGroupId(replicaGroupId), _priority(priority), @@ -397,7 +366,7 @@ ServerAdapterEntry::ServerAdapterEntry(AdapterCache& cache, } bool -ServerAdapterEntry::addSyncCallback(const SynchronizationCallbackPtr& callback, const set<string>&) +ServerAdapterEntry::addSyncCallback(const shared_ptr<SynchronizationCallback>& callback, const set<string>&) { try { @@ -448,23 +417,18 @@ ServerAdapterEntry::getLeastLoadedNodeLoad(LoadSample loadSample) const AdapterInfoSeq ServerAdapterEntry::getAdapterInfoNoEndpoints() const { - AdapterInfo info; - info.id = _id; - info.replicaGroupId = _replicaGroupId; - AdapterInfoSeq infos; - infos.push_back(info); - return infos; + return { { _id, nullptr, _replicaGroupId } }; } -GetAdapterInfoResultPtr +shared_ptr<GetAdapterInfoResult> ServerAdapterEntry::getAdapterInfoAsync() const { - GetAdapterInfoResultPtr result = new GetAdapterInfoResult(); - result->add(const_cast<ServerAdapterEntry*>(this)); + auto result = make_shared<GetAdapterInfoResult>(); + result->add(this); return result; } -AdapterPrx +shared_ptr<AdapterPrx> ServerAdapterEntry::getProxy(const string& replicaGroupId, bool upToDate) const { if(replicaGroupId.empty()) @@ -484,9 +448,10 @@ ServerAdapterEntry::getProxy(const string& replicaGroupId, bool upToDate) const void ServerAdapterEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters) const { - LocatorAdapterInfo info; - info.id = _id; - info.proxy = _server->getAdapter(info.activationTimeout, info.deactivationTimeout, _id, true); + chrono::seconds activationTimeout, deactivationTimeout; + auto proxy = _server->getAdapter(activationTimeout, deactivationTimeout, _id, true); + + LocatorAdapterInfo info = { _id, move(proxy), activationTimeout, deactivationTimeout }; adapters.push_back(info); } @@ -518,7 +483,7 @@ ServerAdapterEntry::getNodeName() const ReplicaGroupEntry::ReplicaGroupEntry(AdapterCache& cache, const string& id, const string& application, - const LoadBalancingPolicyPtr& policy, + const shared_ptr<LoadBalancingPolicy>& policy, const string& filter) : AdapterEntry(cache, id, application), _lastReplica(0), @@ -528,26 +493,27 @@ ReplicaGroupEntry::ReplicaGroupEntry(AdapterCache& cache, } bool -ReplicaGroupEntry::addSyncCallback(const SynchronizationCallbackPtr& callback, const set<string>& excludes) +ReplicaGroupEntry::addSyncCallback(const shared_ptr<SynchronizationCallback>& callback, const set<string>& excludes) { - vector<ServerAdapterEntryPtr> replicas; + vector<shared_ptr<ServerAdapterEntry>> replicas; int nReplicas; - int roundRobin = false; + bool roundRobin = false; { - Lock sync(*this); + lock_guard lock(_mutex); + nReplicas = _loadBalancingNReplicas > 0 ? _loadBalancingNReplicas : static_cast<int>(_replicas.size()); - roundRobin = RoundRobinLoadBalancingPolicyPtr::dynamicCast(_loadBalancing); + roundRobin = dynamic_pointer_cast<RoundRobinLoadBalancingPolicy>(_loadBalancing) != nullptr; if(!roundRobin) { replicas = _replicas; } else { - for(vector<ServerAdapterEntryPtr>::const_iterator p = _replicas.begin(); p != _replicas.end(); ++p) + for(const auto& replica : _replicas) { - if(excludes.find((*p)->getId()) == excludes.end()) + if(excludes.find(replica->getId()) == excludes.end()) { - replicas.push_back(*p); + replicas.push_back(replica); } } } @@ -558,39 +524,37 @@ ReplicaGroupEntry::addSyncCallback(const SynchronizationCallbackPtr& callback, c } } - ReplicaGroupSyncCallbackPtr cb = new ReplicaGroupSyncCallback(callback, - static_cast<int>(replicas.size()), - nReplicas); + auto cb = make_shared<ReplicaGroupSyncCallback>(callback, static_cast<int>(replicas.size()), nReplicas); set<string> emptyExcludes; - for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { try { - if(!(*p)->addSyncCallback(cb, emptyExcludes)) + if(!replica->addSyncCallback(cb, emptyExcludes)) { cb->synchronized(); } } - catch(const Ice::Exception& ex) + catch(const std::exception&) { - cb->synchronized(ex); + cb->synchronized(current_exception()); } } return cb->response(); } void -ReplicaGroupEntry::addReplica(const string& /*replicaId*/, const ServerAdapterEntryPtr& adapter) +ReplicaGroupEntry::addReplica(const string& /*replicaId*/, const shared_ptr<ServerAdapterEntry>& adapter) { - Lock sync(*this); + lock_guard lock(_mutex); _replicas.push_back(adapter); } bool ReplicaGroupEntry::removeReplica(const string& replicaId) { - Lock sync(*this); - for(vector<ServerAdapterEntryPtr>::iterator p = _replicas.begin(); p != _replicas.end(); ++p) + lock_guard lock(_mutex); + for(auto p = _replicas.cbegin(); p != _replicas.cend(); ++p) { if(replicaId == (*p)->getId()) { @@ -606,37 +570,44 @@ ReplicaGroupEntry::removeReplica(const string& replicaId) } void -ReplicaGroupEntry::update(const string& application, const LoadBalancingPolicyPtr& policy, const string& filter) +ReplicaGroupEntry::update(const string& application, const shared_ptr<LoadBalancingPolicy>& policy, const string& filter) { - Lock sync(*this); + lock_guard lock(_mutex); + assert(policy); _application = application; _loadBalancing = policy; _filter = filter; - istringstream is(_loadBalancing->nReplicas); int nReplicas = 0; - is >> nReplicas; + try + { + nReplicas = stoi(_loadBalancing->nReplicas); + } + catch(const std::exception&) + { + } + _loadBalancingNReplicas = nReplicas < 0 ? 1 : nReplicas; - AdaptiveLoadBalancingPolicyPtr alb = AdaptiveLoadBalancingPolicyPtr::dynamicCast(_loadBalancing); + auto alb = dynamic_pointer_cast<AdaptiveLoadBalancingPolicy>(_loadBalancing); if(alb) { if(alb->loadSample == "1") { - _loadSample = LoadSample1; + _loadSample = LoadSample::LoadSample1; } else if(alb->loadSample == "5") { - _loadSample = LoadSample5; + _loadSample = LoadSample::LoadSample5; } else if(alb->loadSample == "15") { - _loadSample = LoadSample15; + _loadSample = LoadSample::LoadSample15; } else { - _loadSample = LoadSample1; + _loadSample = LoadSample::LoadSample1; } } } @@ -645,11 +616,11 @@ void ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& nReplicas, bool& replicaGroup, bool& roundRobin, string& filter, const set<string>& excludes) { - vector<ServerAdapterEntryPtr> replicas; + vector<shared_ptr<ServerAdapterEntry>> replicas; bool adaptive = false; - LoadSample loadSample = LoadSample1; + LoadSample loadSample = LoadSample::LoadSample1; { - Lock sync(*this); + unique_lock lock(_mutex); replicaGroup = true; roundRobin = false; filter = _filter; @@ -661,13 +632,10 @@ ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& n } replicas.reserve(_replicas.size()); - if(RoundRobinLoadBalancingPolicyPtr::dynamicCast(_loadBalancing)) + if(dynamic_pointer_cast<RoundRobinLoadBalancingPolicy>(_loadBalancing)) { // Serialize round-robin requests - while(_requestInProgress) - { - wait(); - } + _condVar.wait(lock, [this] { return !_requestInProgress; } ); _requestInProgress = true; for(size_t i = 0; i < _replicas.size(); ++i) { @@ -676,19 +644,23 @@ ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& n _lastReplica = (_lastReplica + 1) % static_cast<int>(_replicas.size()); roundRobin = true; } - else if(AdaptiveLoadBalancingPolicyPtr::dynamicCast(_loadBalancing)) + else if(dynamic_pointer_cast<AdaptiveLoadBalancingPolicy>(_loadBalancing)) { replicas = _replicas; IceUtilInternal::shuffle(replicas.begin(), replicas.end()); loadSample = _loadSample; adaptive = true; } - else if(OrderedLoadBalancingPolicyPtr::dynamicCast(_loadBalancing)) + else if(dynamic_pointer_cast<OrderedLoadBalancingPolicy>(_loadBalancing)) { replicas = _replicas; - sort(replicas.begin(), replicas.end(), ReplicaPriorityComp()); + sort(replicas.begin(), replicas.end(), + [](const auto& lhs, const auto& rhs) + { + return lhs->getPriority() < rhs->getPriority(); + }); } - else if(RandomLoadBalancingPolicyPtr::dynamicCast(_loadBalancing)) + else if(dynamic_pointer_cast<RandomLoadBalancingPolicy>(_loadBalancing)) { replicas = _replicas; IceUtilInternal::shuffle(replicas.begin(), replicas.end()); @@ -703,16 +675,20 @@ ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& n { // // This must be done outside the synchronization block since - // the trasnform() might call and lock each server adapter + // the transform() might call and lock each server adapter // entry. We also can't sort directly as the load of each // server adapter is not stable so we first take a snapshot of // each adapter and sort the snapshot. // - vector<pair<float, ServerAdapterEntryPtr> > rl; - transform(replicas.begin(), replicas.end(), back_inserter(rl), TransformToReplicaLoad(loadSample)); - sort(rl.begin(), rl.end(), ReplicaLoadComp()); + vector<pair<float, shared_ptr<ServerAdapterEntry>>> rl; + transform(replicas.begin(), replicas.end(), back_inserter(rl), + [loadSample](const auto& value) -> pair<float, shared_ptr<ServerAdapterEntry>> + { + return { value -> getLeastLoadedNodeLoad(loadSample), value }; + }); + sort(rl.begin(), rl.end(), [](const auto& lhs, const auto& rhs) { return lhs.first < rhs.first; }); replicas.clear(); - transform(rl.begin(), rl.end(), back_inserter(replicas), TransformToReplica()); + transform(rl.begin(), rl.end(), back_inserter(replicas), [](const auto& value) { return value.second; }); } // @@ -722,13 +698,13 @@ ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& n // set<string> emptyExcludes; bool firstUnreachable = true; - for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - if(!roundRobin || excludes.find((*p)->getId()) == excludes.end()) + if(!roundRobin || excludes.find(replica->getId()) == excludes.end()) { try { - (*p)->getLocatorAdapterInfo(adapters); + replica->getLocatorAdapterInfo(adapters); firstUnreachable = false; } catch(const SynchronizationException&) @@ -745,24 +721,24 @@ ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& n } } } - catch(...) + catch(const std::exception&) { if(roundRobin) { - Lock sync(*this); + lock_guard lock(_mutex); assert(_requestInProgress); _requestInProgress = false; - notify(); + _condVar.notify_one(); } throw; } if(roundRobin) { - Lock sync(*this); + lock_guard lock(_mutex); assert(_requestInProgress); _requestInProgress = false; - notify(); + _condVar.notify_one(); if(unreachable > 0) { _lastReplica = (_lastReplica + unreachable) % static_cast<int>(_replicas.size()); @@ -778,9 +754,9 @@ ReplicaGroupEntry::getLocatorAdapterInfo(LocatorAdapterInfoSeq& adapters, int& n float ReplicaGroupEntry::getLeastLoadedNodeLoad(LoadSample loadSample) const { - vector<ServerAdapterEntryPtr> replicas; + vector<shared_ptr<ServerAdapterEntry>> replicas; { - Lock sync(*this); + lock_guard lock(_mutex); replicas = _replicas; } @@ -795,9 +771,17 @@ ReplicaGroupEntry::getLeastLoadedNodeLoad(LoadSample loadSample) const else { IceUtilInternal::shuffle(replicas.begin(), replicas.end()); - vector<pair<float, ServerAdapterEntryPtr> > rl; - transform(replicas.begin(), replicas.end(), back_inserter(rl), TransformToReplicaLoad(loadSample)); - return min_element(rl.begin(), rl.end(), ReplicaLoadComp())->first; + vector<pair<float, shared_ptr<ServerAdapterEntry>>> rl; + transform(replicas.begin(), replicas.end(), back_inserter(rl), + [loadSample] (const auto& value) -> pair<float, shared_ptr<ServerAdapterEntry>> + { + return { value->getLeastLoadedNodeLoad(loadSample), value }; + }); + return min_element(rl.begin(), rl.end(), + [](const auto& lhs, const auto& rhs) + { + return lhs.first < rhs.first; + })->first; } } @@ -808,34 +792,34 @@ ReplicaGroupEntry::getAdapterInfoNoEndpoints() const // This method is called with the database locked so we're sure // that no new adapters will be added or removed concurrently. // - vector<ServerAdapterEntryPtr> replicas; + vector<shared_ptr<ServerAdapterEntry>> replicas; { - Lock sync(*this); + lock_guard lock(_mutex); replicas = _replicas; } AdapterInfoSeq infos; - for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - AdapterInfoSeq infs = (*p)->getAdapterInfoNoEndpoints(); + AdapterInfoSeq infs = replica->getAdapterInfoNoEndpoints(); assert(infs.size() == 1); infos.push_back(infs[0]); } return infos; } -GetAdapterInfoResultPtr +shared_ptr<GetAdapterInfoResult> ReplicaGroupEntry::getAdapterInfoAsync() const { - GetAdapterInfoResultPtr result = new GetAdapterInfoResult(); - vector<ServerAdapterEntryPtr> replicas; + auto result = make_shared<GetAdapterInfoResult>(); + vector<shared_ptr<ServerAdapterEntry>> replicas; { - Lock sync(*this); + lock_guard lock(_mutex); replicas = _replicas; } - for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - result->add(*p); + result->add(replica.get()); } return result; } @@ -843,16 +827,16 @@ ReplicaGroupEntry::getAdapterInfoAsync() const bool ReplicaGroupEntry::hasAdaptersFromOtherApplications() const { - vector<ServerAdapterEntryPtr> replicas; + vector<shared_ptr<ServerAdapterEntry>> replicas; { - Lock sync(*this); + lock_guard lock(_mutex); replicas = _replicas; } AdapterInfoSeq infos; - for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - if((*p)->getApplication() != _application) + if(replica->getApplication() != _application) { return true; } diff --git a/cpp/src/IceGrid/AdapterCache.h b/cpp/src/IceGrid/AdapterCache.h index bbe0bfeb794..3247315ef56 100644 --- a/cpp/src/IceGrid/AdapterCache.h +++ b/cpp/src/IceGrid/AdapterCache.h @@ -5,69 +5,60 @@ #ifndef ICE_GRID_ADAPTERCACHE_H #define ICE_GRID_ADAPTERCACHE_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Shared.h> #include <IceGrid/Cache.h> #include <IceGrid/Registry.h> #include <IceGrid/Internal.h> +#include <optional> #include <set> namespace IceGrid { class AdapterCache; - -class SynchronizationCallback; -typedef IceUtil::Handle<SynchronizationCallback> SynchronizationCallbackPtr; - -class ServerEntry; -typedef IceUtil::Handle<ServerEntry> ServerEntryPtr; -typedef std::vector<ServerEntryPtr> ServerEntrySeq; - class AdapterEntry; -typedef IceUtil::Handle<AdapterEntry> AdapterEntryPtr; - class ServerAdapterEntry; -typedef IceUtil::Handle<ServerAdapterEntry> ServerAdapterEntryPtr; +class ServerEntry; +class SynchronizationCallback; + +using ServerEntrySeq = std::vector<std::shared_ptr<ServerEntry>>; struct LocatorAdapterInfo { std::string id; - AdapterPrx proxy; - int activationTimeout; - int deactivationTimeout; + std::shared_ptr<AdapterPrx> proxy; + std::chrono::seconds activationTimeout; + std::chrono::seconds deactivationTimeout; }; -typedef std::vector<LocatorAdapterInfo> LocatorAdapterInfoSeq; +using LocatorAdapterInfoSeq = std::vector<LocatorAdapterInfo>; -class GetAdapterInfoResult : public IceUtil::Shared +class GetAdapterInfoResult { public: - void add(const ServerAdapterEntryPtr&); + void add(const ServerAdapterEntry*); AdapterInfoSeq get(); private: AdapterInfoSeq _adapters; - std::vector<Ice::AsyncResultPtr> _results; + std::vector<std::optional<std::future<std::shared_ptr<Ice::ObjectPrx>>>> _results; }; -typedef IceUtil::Handle<GetAdapterInfoResult> GetAdapterInfoResultPtr; -class AdapterEntry : public virtual IceUtil::Shared +class AdapterEntry { public: AdapterEntry(AdapterCache&, const std::string&, const std::string&); - virtual bool addSyncCallback(const SynchronizationCallbackPtr&, const std::set<std::string>&) = 0; + virtual bool addSyncCallback(const std::shared_ptr<SynchronizationCallback>&, const std::set<std::string>&) = 0; virtual void getLocatorAdapterInfo(LocatorAdapterInfoSeq&, int&, bool&, bool&, std::string&, const std::set<std::string>&) = 0; virtual float getLeastLoadedNodeLoad(LoadSample) const = 0; virtual AdapterInfoSeq getAdapterInfoNoEndpoints() const = 0; - virtual GetAdapterInfoResultPtr getAdapterInfoAsync() const = 0; - virtual AdapterPrx getProxy(const std::string&, bool) const = 0; + virtual std::shared_ptr<GetAdapterInfoResult> getAdapterInfoAsync() const = 0; + virtual std::shared_ptr<AdapterPrx> getProxy(const std::string&, bool) const = 0; virtual bool canRemove(); @@ -80,24 +71,23 @@ protected: const std::string _id; std::string _application; }; -typedef IceUtil::Handle<AdapterEntry> AdapterEntryPtr; -class ServerAdapterEntry : public AdapterEntry +class ServerAdapterEntry final : public AdapterEntry { public: ServerAdapterEntry(AdapterCache&, const std::string&, const std::string&, const std::string&, int, - const ServerEntryPtr&); + const std::shared_ptr<ServerEntry>&); - virtual bool addSyncCallback(const SynchronizationCallbackPtr&, const std::set<std::string>&); + bool addSyncCallback(const std::shared_ptr<SynchronizationCallback>&, const std::set<std::string>&) override; - virtual void getLocatorAdapterInfo(LocatorAdapterInfoSeq&, int&, bool&, bool&, std::string&, - const std::set<std::string>&); + void getLocatorAdapterInfo(LocatorAdapterInfoSeq&, int&, bool&, bool&, std::string&, + const std::set<std::string>&) override; - virtual float getLeastLoadedNodeLoad(LoadSample) const; - virtual AdapterInfoSeq getAdapterInfoNoEndpoints() const; - virtual GetAdapterInfoResultPtr getAdapterInfoAsync() const; - virtual AdapterPrx getProxy(const std::string&, bool) const; + float getLeastLoadedNodeLoad(LoadSample) const override; + AdapterInfoSeq getAdapterInfoNoEndpoints() const override; + std::shared_ptr<GetAdapterInfoResult> getAdapterInfoAsync() const override; + std::shared_ptr<AdapterPrx> getProxy(const std::string&, bool) const override; void getLocatorAdapterInfo(LocatorAdapterInfoSeq&) const; const std::string& getReplicaGroupId() const { return _replicaGroupId; } @@ -110,68 +100,69 @@ private: const std::string _replicaGroupId; const int _priority; - const ServerEntryPtr _server; + const std::shared_ptr<ServerEntry> _server; }; -typedef IceUtil::Handle<ServerAdapterEntry> ServerAdapterEntryPtr; -class ReplicaGroupEntry : public AdapterEntry, public IceUtil::Monitor<IceUtil::Mutex> +class ReplicaGroupEntry final : public AdapterEntry { public: - ReplicaGroupEntry(AdapterCache&, const std::string&, const std::string&, const LoadBalancingPolicyPtr&, + ReplicaGroupEntry(AdapterCache&, const std::string&, const std::string&, const std::shared_ptr<LoadBalancingPolicy>&, const std::string&); - virtual bool addSyncCallback(const SynchronizationCallbackPtr&, const std::set<std::string>&); + virtual bool addSyncCallback(const std::shared_ptr<SynchronizationCallback>&, const std::set<std::string>&); virtual void getLocatorAdapterInfo(LocatorAdapterInfoSeq&, int&, bool&, bool&, std::string&, const std::set<std::string>&); virtual float getLeastLoadedNodeLoad(LoadSample) const; virtual AdapterInfoSeq getAdapterInfoNoEndpoints() const; - virtual GetAdapterInfoResultPtr getAdapterInfoAsync() const; - virtual AdapterPrx getProxy(const std::string&, bool) const { return 0; } + virtual std::shared_ptr<GetAdapterInfoResult> getAdapterInfoAsync() const; + virtual std::shared_ptr<AdapterPrx> getProxy(const std::string&, bool) const { return nullptr; } - void addReplica(const std::string&, const ServerAdapterEntryPtr&); + void addReplica(const std::string&, const std::shared_ptr<ServerAdapterEntry>&); bool removeReplica(const std::string&); - void update(const std::string&, const LoadBalancingPolicyPtr&, const std::string&); + void update(const std::string&, const std::shared_ptr<LoadBalancingPolicy>&, const std::string&); bool hasAdaptersFromOtherApplications() const; const std::string& getFilter() const { return _filter; } private: - LoadBalancingPolicyPtr _loadBalancing; + std::shared_ptr<LoadBalancingPolicy> _loadBalancing; int _loadBalancingNReplicas; LoadSample _loadSample; std::string _filter; - std::vector<ServerAdapterEntryPtr> _replicas; + std::vector<std::shared_ptr<ServerAdapterEntry>> _replicas; int _lastReplica; bool _requestInProgress; + + mutable std::mutex _mutex; + std::condition_variable _condVar; }; -typedef IceUtil::Handle<ReplicaGroupEntry> ReplicaGroupEntryPtr; class AdapterCache : public CacheByString<AdapterEntry> { public: - AdapterCache(const Ice::CommunicatorPtr&); + AdapterCache(const std::shared_ptr<Ice::Communicator>&); - void addServerAdapter(const AdapterDescriptor&, const ServerEntryPtr&, const std::string&); + void addServerAdapter(const AdapterDescriptor&, const std::shared_ptr<ServerEntry>&, const std::string&); void addReplicaGroup(const ReplicaGroupDescriptor&, const std::string&); - AdapterEntryPtr get(const std::string&) const; + std::shared_ptr<AdapterEntry> get(const std::string&) const; void removeServerAdapter(const std::string&); void removeReplicaGroup(const std::string&); protected: - virtual AdapterEntryPtr addImpl(const std::string&, const AdapterEntryPtr&); + virtual std::shared_ptr<AdapterEntry> addImpl(const std::string&, const std::shared_ptr<AdapterEntry>&); virtual void removeImpl(const std::string&); private: - const Ice::CommunicatorPtr _communicator; + const std::shared_ptr<Ice::Communicator> _communicator; }; }; diff --git a/cpp/src/IceGrid/AdminCallbackRouter.cpp b/cpp/src/IceGrid/AdminCallbackRouter.cpp index 3d58311845c..d1a394cf8a3 100644 --- a/cpp/src/IceGrid/AdminCallbackRouter.cpp +++ b/cpp/src/IceGrid/AdminCallbackRouter.cpp @@ -4,42 +4,26 @@ #include <IceGrid/AdminCallbackRouter.h> -using namespace Ice; using namespace std; +using namespace IceGrid; void -IceGrid::AdminCallbackRouter::invokeResponse(bool ok, - const std::pair<const Byte*, const Byte*>& outParams, - const AMD_Object_ice_invokePtr& amdCB) +AdminCallbackRouter::addMapping(const string& category, const shared_ptr<Ice::Connection>& con) { - amdCB->ice_response(ok, outParams); -} - -void -IceGrid::AdminCallbackRouter::invokeException(const Ice::Exception&, const AMD_Object_ice_invokePtr& amdCB) -{ - // Callback object is unreachable. - amdCB->ice_exception(ObjectNotExistException(__FILE__, __LINE__)); -} - -void -IceGrid::AdminCallbackRouter::addMapping(const string& category, const ConnectionPtr& con) -{ - IceUtil::Mutex::Lock sync(_mutex); + lock_guard lock(_mutex); #ifdef NDEBUG - _categoryToConnection.insert(map<string, ConnectionPtr>::value_type(category, con)); + _categoryToConnection.insert({ category, con }); #else - bool inserted = - _categoryToConnection.insert(map<string, ConnectionPtr>::value_type(category, con)).second; + bool inserted = _categoryToConnection.insert({ category, con }).second; assert(inserted == true); #endif } void -IceGrid::AdminCallbackRouter::removeMapping(const string& category) +AdminCallbackRouter::removeMapping(const string& category) { - IceUtil::Mutex::Lock sync(_mutex); + lock_guard lock(_mutex); #ifndef NDEBUG size_t one = @@ -50,30 +34,34 @@ IceGrid::AdminCallbackRouter::removeMapping(const string& category) } void -IceGrid::AdminCallbackRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, - const pair<const Byte*, const Byte*>& inParams, - const Current& current) +AdminCallbackRouter::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) { - ConnectionPtr con; + shared_ptr<Ice::Connection> con; { - IceUtil::Mutex::Lock sync(_mutex); - map<string, ConnectionPtr>::iterator p = _categoryToConnection.find(current.id.category); + lock_guard lock(_mutex); + auto p = _categoryToConnection.find(current.id.category); if(p == _categoryToConnection.end()) { - throw ObjectNotExistException(__FILE__, __LINE__); + throw Ice::ObjectNotExistException(__FILE__, __LINE__); } con = p->second; } - ObjectPrx target = con->createProxy(current.id)->ice_facet(current.facet); + auto target = con->createProxy(current.id)->ice_facet(current.facet); // // Call with AMI // - target->begin_ice_invoke(current.operation, current.mode, inParams, current.ctx, - newCallback_Object_ice_invoke(this, - &AdminCallbackRouter::invokeResponse, - &AdminCallbackRouter::invokeException), - cb); + target->ice_invokeAsync(current.operation, current.mode, inParams, + move(response), + [exception = move(exception)] (exception_ptr) + { + exception(make_exception_ptr(Ice::ObjectNotExistException(__FILE__, __LINE__))); + }, + nullptr, + current.ctx); } diff --git a/cpp/src/IceGrid/AdminCallbackRouter.h b/cpp/src/IceGrid/AdminCallbackRouter.h index 67800fe1f97..7e8184408c7 100644 --- a/cpp/src/IceGrid/AdminCallbackRouter.h +++ b/cpp/src/IceGrid/AdminCallbackRouter.h @@ -21,25 +21,20 @@ class AdminCallbackRouter : public Ice::BlobjectArrayAsync { public: - void addMapping(const std::string&, const Ice::ConnectionPtr&); + void addMapping(const std::string&, const std::shared_ptr<Ice::Connection>&); void removeMapping(const std::string&); - virtual void invokeResponse(bool, - const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, - const Ice::AMD_Object_ice_invokePtr&); - - virtual void invokeException(const Ice::Exception&, const Ice::AMD_Object_ice_invokePtr&); - - virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, - const std::pair<const Ice::Byte*, const Ice::Byte*>&, - const Ice::Current&); + void ice_invokeAsync(std::pair<const Ice::Byte*, const Ice::Byte*>, + std::function<void(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current& current) override; private: - IceUtil::Mutex _mutex; - std::map<std::string, Ice::ConnectionPtr> _categoryToConnection; + std::mutex _mutex; + std::map<std::string, std::shared_ptr<Ice::Connection>> _categoryToConnection; }; -typedef IceUtil::Handle<AdminCallbackRouter> AdminCallbackRouterPtr; } + #endif diff --git a/cpp/src/IceGrid/AdminI.cpp b/cpp/src/IceGrid/AdminI.cpp index 3c27f0a119f..b8637fce89b 100644 --- a/cpp/src/IceGrid/AdminI.cpp +++ b/cpp/src/IceGrid/AdminI.cpp @@ -16,23 +16,25 @@ #include <IceGrid/DescriptorHelper.h> #include <IceGrid/AdminSessionI.h> #include <IceGrid/NodeSessionI.h> +#include <IceGrid/Internal.h> using namespace std; +using namespace std::chrono; using namespace Ice; using namespace IceGrid; -namespace IceGrid +namespace { class ServerProxyWrapper { public: - ServerProxyWrapper(const DatabasePtr& database, const string& id) : _id(id) + ServerProxyWrapper(const shared_ptr<Database>& database, const string& id) : _id(id) { try { - _proxy = database->getServer(_id)->getProxy(_activationTimeout, _deactivationTimeout, _node, false, 5); + _proxy = database->getServer(_id)->getProxy(_activationTimeout, _deactivationTimeout, _node, false, 5s); } catch(const SynchronizationException&) { @@ -40,39 +42,65 @@ public: } } - ServerProxyWrapper(const ServerProxyWrapper& wrapper) : - _id(wrapper._id), - _proxy(wrapper._proxy), - _activationTimeout(wrapper._activationTimeout), - _deactivationTimeout(wrapper._deactivationTimeout), - _node(wrapper._node) + ServerProxyWrapper(const ServerProxyWrapper& wrapper) = default; + + template<typename Func, typename... Args> + auto invoke(Func&& f, Args&&... args) { + try + { + return std::invoke(forward<Func>(f), _proxy, forward<Args>(args)..., ::Ice::noExplicitContext); + } + catch (const Ice::Exception&) + { + handleException(current_exception()); + throw; // keep compiler happy + } + } + + template<typename Func> + auto invokeAsync(Func&& f, function<void()> response, function<void(exception_ptr)> exception) + { + auto exceptionWrapper = [this, exception = move(exception)](exception_ptr ex) + { + try + { + handleException(ex); + } + catch(const std::exception&) + { + exception(current_exception()); + } + }; + return std::invoke(forward<Func>(f), _proxy, move(response), move(exceptionWrapper), nullptr, Ice::noExplicitContext); } void useActivationTimeout() { - _proxy = ServerPrx::uncheckedCast(_proxy->ice_invocationTimeout(_activationTimeout * 1000)); + auto timeout = secondsToInt(_activationTimeout) * 1000; + _proxy = _proxy->ice_invocationTimeout(timeout); } void useDeactivationTimeout() { - _proxy = ServerPrx::uncheckedCast(_proxy->ice_invocationTimeout(_deactivationTimeout * 1000)); + auto timeout = secondsToInt(_deactivationTimeout) * 1000; + _proxy = _proxy->ice_invocationTimeout(timeout); } - IceProxy::IceGrid::Server* + ServerPrx* operator->() const { return _proxy.get(); } void - handleException(const Ice::Exception& ex) const + handleException(exception_ptr ex) const { try { - ex.ice_throw(); + rethrow_exception(ex); } catch(const Ice::UserException&) { @@ -84,24 +112,23 @@ public: } catch(const Ice::LocalException& e) { - ostringstream os; - os << e; - throw NodeUnreachableException(_node, os.str()); + throw NodeUnreachableException(_node, e.what()); } } private: string _id; - ServerPrx _proxy; - int _activationTimeout; - int _deactivationTimeout; + shared_ptr<ServerPrx> _proxy; + chrono::seconds _activationTimeout; + chrono::seconds _deactivationTimeout; string _node; }; } -AdminI::AdminI(const DatabasePtr& database, const RegistryIPtr& registry, const AdminSessionIPtr& session) : +AdminI::AdminI(const shared_ptr<Database>& database, const shared_ptr<RegistryI>& registry, + const shared_ptr<AdminSessionI>& session) : _database(database), _registry(registry), _traceLevels(_database->getTraceLevels()), @@ -109,17 +136,13 @@ AdminI::AdminI(const DatabasePtr& database, const RegistryIPtr& registry, const { } -AdminI::~AdminI() -{ -} - void -AdminI::addApplication(const ApplicationDescriptor& descriptor, const Current&) +AdminI::addApplication(ApplicationDescriptor descriptor, const Current&) { checkIsReadOnly(); ApplicationInfo info; - info.createTime = info.updateTime = IceUtil::Time::now().toMilliSeconds(); + info.createTime = info.updateTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count(); info.createUser = info.updateUser = _session->getId(); info.descriptor = descriptor; info.revision = 1; @@ -129,19 +152,19 @@ AdminI::addApplication(const ApplicationDescriptor& descriptor, const Current&) } void -AdminI::syncApplication(const ApplicationDescriptor& descriptor, const Current&) +AdminI::syncApplication(ApplicationDescriptor descriptor, const Current&) { checkIsReadOnly(); _database->syncApplicationDescriptor(descriptor, false, _session.get()); } void -AdminI::updateApplication(const ApplicationUpdateDescriptor& descriptor, const Current&) +AdminI::updateApplication(ApplicationUpdateDescriptor descriptor, const Current&) { checkIsReadOnly(); ApplicationUpdateInfo update; - update.updateTime = IceUtil::Time::now().toMilliSeconds(); + update.updateTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count(); update.updateUser = _session->getId(); update.descriptor = descriptor; update.revision = -1; // The database will set it. @@ -149,19 +172,19 @@ AdminI::updateApplication(const ApplicationUpdateDescriptor& descriptor, const C } void -AdminI::syncApplicationWithoutRestart(const ApplicationDescriptor& descriptor, const Current&) +AdminI::syncApplicationWithoutRestart(ApplicationDescriptor descriptor, const Current&) { checkIsReadOnly(); _database->syncApplicationDescriptor(descriptor, true, _session.get()); } void -AdminI::updateApplicationWithoutRestart(const ApplicationUpdateDescriptor& descriptor, const Current&) +AdminI::updateApplicationWithoutRestart(ApplicationUpdateDescriptor descriptor, const Current&) { checkIsReadOnly(); ApplicationUpdateInfo update; - update.updateTime = IceUtil::Time::now().toMilliSeconds(); + update.updateTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count(); update.updateUser = _session->getId(); update.descriptor = descriptor; update.revision = -1; // The database will set it. @@ -169,29 +192,29 @@ AdminI::updateApplicationWithoutRestart(const ApplicationUpdateDescriptor& descr } void -AdminI::removeApplication(const string& name, const Current&) +AdminI::removeApplication(string name, const Current&) { checkIsReadOnly(); - _database->removeApplication(name, _session.get()); + _database->removeApplication(move(name), _session.get()); } void -AdminI::instantiateServer(const string& app, const string& node, const ServerInstanceDescriptor& desc, const Current&) +AdminI::instantiateServer(string app, string node, ServerInstanceDescriptor desc, const Current&) { checkIsReadOnly(); - _database->instantiateServer(app, node, desc, _session.get()); + _database->instantiateServer(move(app), move(node), move(desc), _session.get()); } ApplicationInfo -AdminI::getApplicationInfo(const string& name, const Current&) const +AdminI::getApplicationInfo(string name, const Current&) const { - return _database->getApplicationInfo(name); + return _database->getApplicationInfo(move(name)); } ApplicationDescriptor AdminI::getDefaultApplicationDescriptor(const Current& current) const { - Ice::PropertiesPtr properties = current.adapter->getCommunicator()->getProperties(); + auto properties = current.adapter->getCommunicator()->getProperties(); string path = properties->getProperty("IceGrid.Registry.DefaultTemplates"); if(path.empty()) { @@ -243,39 +266,23 @@ AdminI::getAllApplicationNames(const Current&) const } ServerInfo -AdminI::getServerInfo(const string& id, const Current&) const +AdminI::getServerInfo(string id, const Current&) const { - return _database->getServer(id)->getInfo(true); + return _database->getServer(move(id))->getInfo(true); } ServerState -AdminI::getServerState(const string& id, const Current&) const +AdminI::getServerState(string id, const Current&) const { - ServerProxyWrapper proxy(_database, id); - try - { - return proxy->getState(); - } - catch(const Ice::Exception& ex) - { - proxy.handleException(ex); - return Inactive; - } + ServerProxyWrapper proxy(_database, move(id)); + return proxy.invoke(&ServerPrx::getState); } -Ice::Int -AdminI::getServerPid(const string& id, const Current&) const +int +AdminI::getServerPid(string id, const Current&) const { - ServerProxyWrapper proxy(_database, id); - try - { - return proxy->getPid(); - } - catch(const Ice::Exception& ex) - { - proxy.handleException(ex); - return 0; - } + ServerProxyWrapper proxy(_database, move(id)); + return proxy.invoke(&ServerPrx::getPid); } string @@ -284,115 +291,25 @@ AdminI::getServerAdminCategory(const Current&) const return _registry->getServerAdminCategory(); } -ObjectPrx -AdminI::getServerAdmin(const string& id, const Current& current) const +shared_ptr<ObjectPrx> +AdminI::getServerAdmin(string id, const Current& current) const { ServerProxyWrapper proxy(_database, id); // Ensure that the server exists and loaded on the node. - Ice::Identity adminId; - adminId.name = id; - adminId.category = _registry->getServerAdminCategory(); - return current.adapter->createProxy(adminId); -} - -namespace -{ - -class StartCB : public virtual IceUtil::Shared -{ -public: - - StartCB(const ServerProxyWrapper& proxy, const AMD_Admin_startServerPtr& amdCB) : _proxy(proxy), _amdCB(amdCB) - { - } - - virtual void - response() - { - _amdCB->ice_response(); - } - - virtual void - exception(const Ice::Exception& ex) - { - try - { - _proxy.handleException(ex); - assert(false); - } - catch(const Ice::Exception& e) - { - _amdCB->ice_exception(e); - } - } - -private: - - const ServerProxyWrapper _proxy; - const AMD_Admin_startServerPtr _amdCB; -}; - + return current.adapter->createProxy({ id, _registry->getServerAdminCategory() }); } void -AdminI::startServer_async(const AMD_Admin_startServerPtr& amdCB, const string& id, const Current&) +AdminI::startServerAsync(string id, function<void()> response, function<void(exception_ptr)> exception, const Current&) { - ServerProxyWrapper proxy(_database, id); + ServerProxyWrapper proxy(_database, move(id)); proxy.useActivationTimeout(); - // - // Since the server might take a while to be activated, we use AMI. - // - proxy->begin_start(newCallback_Server_start(new StartCB(proxy, amdCB), - &StartCB::response, - &StartCB::exception)); -} - -namespace -{ - -class StopCB : public virtual IceUtil::Shared -{ -public: - - StopCB(const ServerProxyWrapper& proxy, const AMD_Admin_stopServerPtr& amdCB) : _proxy(proxy), _amdCB(amdCB) - { - } - - virtual void - response() - { - _amdCB->ice_response(); - } - - virtual void - exception(const Ice::Exception& ex) - { - try - { - _proxy.handleException(ex); - assert(false); - } - catch(const Ice::TimeoutException&) - { - _amdCB->ice_response(); - } - catch(const Ice::Exception& e) - { - _amdCB->ice_exception(e); - } - } - -private: - - const ServerProxyWrapper _proxy; - const AMD_Admin_stopServerPtr _amdCB; -}; - + proxy.invokeAsync([](const auto& prx, auto... args) { prx->startAsync(args...); }, move(response), move(exception)); } void -AdminI::stopServer_async(const AMD_Admin_stopServerPtr& amdCB, const string& id, const Current&) +AdminI::stopServerAsync(string id, function<void()> response, function<void(exception_ptr)> exception, const Current&) { ServerProxyWrapper proxy(_database, id); proxy.useDeactivationTimeout(); @@ -400,23 +317,29 @@ AdminI::stopServer_async(const AMD_Admin_stopServerPtr& amdCB, const string& id, // // Since the server might take a while to be deactivated, we use AMI. // - proxy->begin_stop(newCallback_Server_stop(new StopCB(proxy, amdCB), - &StopCB::response, - &StopCB::exception)); + proxy.invokeAsync([](const auto& prx, auto... args) { prx->stopAsync(args...); }, + response, + [response, exception = move(exception)](exception_ptr ex) { + try + { + rethrow_exception(ex); + } + catch(const Ice::TimeoutException&) + { + response(); + } + catch(const Ice::Exception&) + { + exception(current_exception()); + } + }); } void -AdminI::sendSignal(const string& id, const string& signal, const Current&) +AdminI::sendSignal(string id, string signal, const Current&) { - ServerProxyWrapper proxy(_database, id); - try - { - proxy->sendSignal(signal); - } - catch(const Ice::Exception& ex) - { - proxy.handleException(ex); - } + ServerProxyWrapper proxy(_database, move(id)); + proxy.invoke(&ServerPrx::sendSignal, move(signal)); } StringSeq @@ -426,42 +349,27 @@ AdminI::getAllServerIds(const Current&) const } void -AdminI::enableServer(const string& id, bool enable, const Ice::Current&) +AdminI::enableServer(string id, bool enable, const Ice::Current&) { - ServerProxyWrapper proxy(_database, id); - try - { - proxy->setEnabled(enable); - } - catch(const Ice::Exception& ex) - { - proxy.handleException(ex); - } + ServerProxyWrapper proxy(_database, move(id)); + proxy.invoke(&ServerPrx::setEnabled, move(enable)); } bool -AdminI::isServerEnabled(const ::std::string& id, const Ice::Current&) const +AdminI::isServerEnabled(string id, const Ice::Current&) const { - ServerProxyWrapper proxy(_database, id); - try - { - return proxy->isEnabled(); - } - catch(const Ice::Exception& ex) - { - proxy.handleException(ex); - return true; // Keeps the compiler happy. - } + ServerProxyWrapper proxy(_database, move(id)); + return proxy.invoke(&ServerPrx::isEnabled); } AdapterInfoSeq -AdminI::getAdapterInfo(const string& id, const Current&) const +AdminI::getAdapterInfo(string id, const Current&) const { return _database->getAdapterInfo(id); } void -AdminI::removeAdapter(const string& adapterId, const Ice::Current&) +AdminI::removeAdapter(string adapterId, const Ice::Current&) { checkIsReadOnly(); _database->removeAdapter(adapterId); @@ -474,7 +382,7 @@ AdminI::getAllAdapterIds(const Current&) const } void -AdminI::addObject(const Ice::ObjectPrx& proxy, const ::Ice::Current& current) +AdminI::addObject(shared_ptr<Ice::ObjectPrx> proxy, const ::Ice::Current& current) { checkIsReadOnly(); @@ -497,7 +405,7 @@ AdminI::addObject(const Ice::ObjectPrx& proxy, const ::Ice::Current& current) } void -AdminI::updateObject(const Ice::ObjectPrx& proxy, const ::Ice::Current&) +AdminI::updateObject(shared_ptr<Ice::ObjectPrx> proxy, const ::Ice::Current&) { checkIsReadOnly(); @@ -517,7 +425,7 @@ AdminI::updateObject(const Ice::ObjectPrx& proxy, const ::Ice::Current&) } void -AdminI::addObjectWithType(const Ice::ObjectPrx& proxy, const string& type, const ::Ice::Current&) +AdminI::addObjectWithType(shared_ptr<Ice::ObjectPrx> proxy, string type, const ::Ice::Current&) { checkIsReadOnly(); @@ -541,7 +449,7 @@ AdminI::addObjectWithType(const Ice::ObjectPrx& proxy, const string& type, const } void -AdminI::removeObject(const Ice::Identity& id, const Ice::Current&) +AdminI::removeObject(Ice::Identity id, const Ice::Current&) { checkIsReadOnly(); if(id.category == _database->getInstanceName()) @@ -554,45 +462,42 @@ AdminI::removeObject(const Ice::Identity& id, const Ice::Current&) } ObjectInfo -AdminI::getObjectInfo(const Ice::Identity& id, const Ice::Current&) const +AdminI::getObjectInfo(Ice::Identity id, const Ice::Current&) const { - return _database->getObjectInfo(id); + return _database->getObjectInfo(move(id)); } ObjectInfoSeq -AdminI::getObjectInfosByType(const string& type, const Ice::Current&) const +AdminI::getObjectInfosByType(string type, const Ice::Current&) const { - return _database->getObjectInfosByType(type); + return _database->getObjectInfosByType(move(type)); } ObjectInfoSeq -AdminI::getAllObjectInfos(const string& expression, const Ice::Current&) const +AdminI::getAllObjectInfos(string expression, const Ice::Current&) const { - return _database->getAllObjectInfos(expression); + return _database->getAllObjectInfos(move(expression)); } NodeInfo -AdminI::getNodeInfo(const string& name, const Ice::Current&) const +AdminI::getNodeInfo(string name, const Ice::Current&) const { return toNodeInfo(_database->getNode(name)->getInfo()); } -ObjectPrx -AdminI::getNodeAdmin(const string& name, const Current& current) const +shared_ptr<ObjectPrx> +AdminI::getNodeAdmin(string name, const Current& current) const { // // Check if the node exists // _database->getNode(name); - Ice::Identity adminId; - adminId.name = name; - adminId.category = _registry->getNodeAdminCategory(); - return current.adapter->createProxy(adminId); + return current.adapter->createProxy({ name, _registry->getNodeAdminCategory() }); } bool -AdminI::pingNode(const string& name, const Current&) const +AdminI::pingNode(string name, const Current&) const { try { @@ -614,7 +519,7 @@ AdminI::pingNode(const string& name, const Current&) const } LoadInfo -AdminI::getNodeLoad(const string& name, const Current&) const +AdminI::getNodeLoad(string name, const Current&) const { try { @@ -633,7 +538,7 @@ AdminI::getNodeLoad(const string& name, const Current&) const } int -AdminI::getNodeProcessorSocketCount(const string& name, const Current&) const +AdminI::getNodeProcessorSocketCount(string name, const Current&) const { try { @@ -658,7 +563,7 @@ AdminI::getNodeProcessorSocketCount(const string& name, const Current&) const } void -AdminI::shutdownNode(const string& name, const Current&) +AdminI::shutdownNode(string name, const Current&) { try { @@ -677,7 +582,7 @@ AdminI::shutdownNode(const string& name, const Current&) } string -AdminI::getNodeHostname(const string& name, const Current&) const +AdminI::getNodeHostname(string name, const Current&) const { try { @@ -702,7 +607,7 @@ AdminI::getAllNodeNames(const Current&) const } RegistryInfo -AdminI::getRegistryInfo(const string& name, const Ice::Current&) const +AdminI::getRegistryInfo(string name, const Ice::Current&) const { if(name == _registry->getName()) { @@ -714,8 +619,8 @@ AdminI::getRegistryInfo(const string& name, const Ice::Current&) const } } -ObjectPrx -AdminI::getRegistryAdmin(const string& name, const Current& current) const +shared_ptr<ObjectPrx> +AdminI::getRegistryAdmin(string name, const Current& current) const { if(name != _registry->getName()) { @@ -725,14 +630,11 @@ AdminI::getRegistryAdmin(const string& name, const Current& current) const _database->getReplica(name); } - Identity adminId; - adminId.name = name; - adminId.category = _registry->getReplicaAdminCategory(); - return current.adapter->createProxy(adminId); + return current.adapter->createProxy({ name, _registry->getReplicaAdminCategory() }); } bool -AdminI::pingRegistry(const string& name, const Current&) const +AdminI::pingRegistry(string name, const Current&) const { if(name == _registry->getName()) { @@ -755,7 +657,7 @@ AdminI::pingRegistry(const string& name, const Current&) const } void -AdminI::shutdownRegistry(const string& name, const Current&) +AdminI::shutdownRegistry(string name, const Current&) { if(name == _registry->getName()) { diff --git a/cpp/src/IceGrid/AdminI.h b/cpp/src/IceGrid/AdminI.h index ac294ae0445..e6b065c149c 100644 --- a/cpp/src/IceGrid/AdminI.h +++ b/cpp/src/IceGrid/AdminI.h @@ -10,89 +10,83 @@ namespace IceGrid { +class AdminSessionI; class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - class RegistryI; -typedef IceUtil::Handle<RegistryI> RegistryIPtr; - -class AdminSessionI; -typedef IceUtil::Handle<AdminSessionI> AdminSessionIPtr; +class TraceLevels; -class AdminI : public Admin, public IceUtil::Mutex +class AdminI final : public Admin { public: - AdminI(const DatabasePtr&, const RegistryIPtr&, const AdminSessionIPtr&); - virtual ~AdminI(); - - virtual void addApplication(const ApplicationDescriptor&, const Ice::Current&); - virtual void syncApplication(const ApplicationDescriptor&, const Ice::Current&); - virtual void updateApplication(const ApplicationUpdateDescriptor&, const Ice::Current&); - virtual void syncApplicationWithoutRestart(const ApplicationDescriptor&, const Ice::Current&); - virtual void updateApplicationWithoutRestart(const ApplicationUpdateDescriptor&, const Ice::Current&); - virtual void removeApplication(const std::string&, const Ice::Current&); - virtual void instantiateServer(const std::string&, const std::string&, const ServerInstanceDescriptor&, - const Ice::Current&); - virtual ApplicationInfo getApplicationInfo(const ::std::string&, const Ice::Current&) const; - virtual ApplicationDescriptor getDefaultApplicationDescriptor(const Ice::Current&) const; - virtual Ice::StringSeq getAllApplicationNames(const Ice::Current&) const; - - virtual ServerInfo getServerInfo(const ::std::string&, const Ice::Current&) const; - virtual ServerState getServerState(const ::std::string&, const Ice::Current&) const; - virtual Ice::Int getServerPid(const ::std::string&, const Ice::Current&) const; - virtual std::string getServerAdminCategory(const Ice::Current&) const; - virtual Ice::ObjectPrx getServerAdmin(const std::string&, const Ice::Current&) const; - virtual void startServer_async(const AMD_Admin_startServerPtr&, const ::std::string&, const Ice::Current&); - virtual void stopServer_async(const AMD_Admin_stopServerPtr&, const ::std::string&, const Ice::Current&); - virtual void sendSignal(const ::std::string&, const ::std::string&, const Ice::Current&); - virtual Ice::StringSeq getAllServerIds(const Ice::Current&) const; - virtual void enableServer(const ::std::string&, bool, const Ice::Current&); - virtual bool isServerEnabled(const ::std::string&, const Ice::Current&) const; - - virtual AdapterInfoSeq getAdapterInfo(const ::std::string&, const ::Ice::Current&) const; - virtual void removeAdapter(const std::string&, const Ice::Current&); - virtual Ice::StringSeq getAllAdapterIds(const ::Ice::Current&) const; - - virtual void addObject(const ::Ice::ObjectPrx&, const ::Ice::Current&); - virtual void updateObject(const ::Ice::ObjectPrx&, const ::Ice::Current&); - virtual void addObjectWithType(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Current&); - virtual void removeObject(const ::Ice::Identity&, const ::Ice::Current&); - virtual ObjectInfo getObjectInfo(const Ice::Identity&, const ::Ice::Current&) const; - virtual ObjectInfoSeq getObjectInfosByType(const std::string&, const ::Ice::Current&) const; - virtual ObjectInfoSeq getAllObjectInfos(const std::string&, const ::Ice::Current&) const; - - virtual NodeInfo getNodeInfo(const std::string&, const Ice::Current&) const; - virtual Ice::ObjectPrx getNodeAdmin(const std::string&, const Ice::Current&) const; - virtual bool pingNode(const std::string&, const Ice::Current&) const; - virtual LoadInfo getNodeLoad(const std::string&, const Ice::Current&) const; - virtual int getNodeProcessorSocketCount(const std::string&, const Ice::Current&) const; - virtual void shutdownNode(const std::string&, const Ice::Current&); - virtual std::string getNodeHostname(const std::string&, const Ice::Current&) const; - virtual Ice::StringSeq getAllNodeNames(const ::Ice::Current&) const; - - virtual RegistryInfo getRegistryInfo(const std::string&, const Ice::Current&) const; - virtual Ice::ObjectPrx getRegistryAdmin(const std::string&, const Ice::Current&) const; - virtual bool pingRegistry(const std::string&, const Ice::Current&) const; - virtual void shutdownRegistry(const std::string&, const Ice::Current&); - virtual Ice::StringSeq getAllRegistryNames(const ::Ice::Current&) const; - - virtual void shutdown(const Ice::Current&); + AdminI(const std::shared_ptr<Database>&, const std::shared_ptr<RegistryI>&, const std::shared_ptr<AdminSessionI>&); + + void addApplication(ApplicationDescriptor, const Ice::Current&) override; + void syncApplication(ApplicationDescriptor, const Ice::Current&) override; + void updateApplication(ApplicationUpdateDescriptor, const Ice::Current&) override; + void syncApplicationWithoutRestart(ApplicationDescriptor, const Ice::Current&) override; + void updateApplicationWithoutRestart(ApplicationUpdateDescriptor, const Ice::Current&) override; + void removeApplication(std::string, const Ice::Current&) override; + void instantiateServer(std::string, std::string, ServerInstanceDescriptor, const Ice::Current&) override; + ApplicationInfo getApplicationInfo(std::string, const Ice::Current&) const override; + ApplicationDescriptor getDefaultApplicationDescriptor(const Ice::Current&) const override; + Ice::StringSeq getAllApplicationNames(const Ice::Current&) const override; + + ServerInfo getServerInfo(std::string, const Ice::Current&) const override; + ServerState getServerState(std::string, const Ice::Current&) const override; + Ice::Int getServerPid(std::string, const Ice::Current&) const override; + std::string getServerAdminCategory(const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> getServerAdmin(std::string, const Ice::Current&) const override; + void startServerAsync(std::string, std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + void stopServerAsync(std::string, std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + void sendSignal(std::string, std::string, const Ice::Current&) override; + Ice::StringSeq getAllServerIds(const Ice::Current&) const override; + void enableServer(std::string, bool, const Ice::Current&) override; + bool isServerEnabled(std::string, const Ice::Current&) const override; + + AdapterInfoSeq getAdapterInfo(std::string, const ::Ice::Current&) const override; + void removeAdapter(std::string, const Ice::Current&) override; + Ice::StringSeq getAllAdapterIds(const ::Ice::Current&) const override; + + void addObject(std::shared_ptr<Ice::ObjectPrx>, const ::Ice::Current&) override; + void updateObject(std::shared_ptr<Ice::ObjectPrx>, const ::Ice::Current&) override; + void addObjectWithType(std::shared_ptr<Ice::ObjectPrx>, std::string, const ::Ice::Current&) override; + void removeObject(Ice::Identity, const ::Ice::Current&) override; + ObjectInfo getObjectInfo(Ice::Identity, const ::Ice::Current&) const override; + ObjectInfoSeq getObjectInfosByType(std::string, const ::Ice::Current&) const override; + ObjectInfoSeq getAllObjectInfos(std::string, const ::Ice::Current&) const override; + + NodeInfo getNodeInfo(std::string, const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> getNodeAdmin(std::string, const Ice::Current&) const override; + bool pingNode(std::string, const Ice::Current&) const override; + LoadInfo getNodeLoad(std::string, const Ice::Current&) const override; + int getNodeProcessorSocketCount(std::string, const Ice::Current&) const override; + void shutdownNode(std::string, const Ice::Current&) override; + std::string getNodeHostname(std::string, const Ice::Current&) const override; + Ice::StringSeq getAllNodeNames(const ::Ice::Current&) const override; + + RegistryInfo getRegistryInfo(std::string, const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> getRegistryAdmin(std::string, const Ice::Current&) const override; + bool pingRegistry(std::string, const Ice::Current&) const override; + void shutdownRegistry(std::string, const Ice::Current&) override; + Ice::StringSeq getAllRegistryNames(const ::Ice::Current&) const override; + + void shutdown(const Ice::Current&) override; private: void checkIsReadOnly() const; - const DatabasePtr _database; - const RegistryIPtr _registry; - const TraceLevelsPtr _traceLevels; - const AdminSessionIPtr _session; + const std::shared_ptr<Database> _database; + const std::shared_ptr<RegistryI> _registry; + const std::shared_ptr<TraceLevels> _traceLevels; + const std::shared_ptr<AdminSessionI> _session; + + std::mutex _mutex; }; -typedef IceUtil::Handle<AdminI> AdminIPtr; } diff --git a/cpp/src/IceGrid/AdminRouter.cpp b/cpp/src/IceGrid/AdminRouter.cpp index 27c0fa9c0ae..b4ce2128540 100644 --- a/cpp/src/IceGrid/AdminRouter.cpp +++ b/cpp/src/IceGrid/AdminRouter.cpp @@ -4,89 +4,73 @@ #include <IceGrid/AdminRouter.h> -using namespace Ice; using namespace std; +using namespace IceGrid; -namespace -{ - -class CallbackI : public IceUtil::Shared -{ -public: - - CallbackI(const AMD_Object_ice_invokePtr& cb, const Ice::ObjectPrx& target, const string& operation, - const IceGrid::TraceLevelsPtr& traceLevels) : - _cb(cb), - _target(target), - _operation(operation), - _traceLevels(traceLevels) - { - } - - void response(bool ok, const pair<const Byte*, const Byte*>& outParams) - { - if(_traceLevels->admin > 0) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->adminCat); - - out << "operation `" << _operation << "' routed to `" << Ice::identityToString(_target->ice_getIdentity()) - << " -f " << _target->ice_getFacet() << "' is returning "; - if(ok) - { - out << "successfully"; - } - else - { - out << "a user exception"; - } - } - _cb->ice_response(ok, outParams); - } - - void exception(const Ice::Exception& ex) - { - if(_traceLevels->admin > 0) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->adminCat); - out << "operation `" << _operation << "' routed to `" << Ice::identityToString(_target->ice_getIdentity()) - << " -f " << _target->ice_getFacet() << "' failed with " << ex; - } - // Admin object is unreachable - _cb->ice_exception(ObjectNotExistException(__FILE__, __LINE__)); - } - -private: - AMD_Object_ice_invokePtr _cb; - Ice::ObjectPrx _target; - string _operation; - const IceGrid::TraceLevelsPtr _traceLevels; -}; - -} - -IceGrid::AdminRouter::AdminRouter(const TraceLevelsPtr& traceLevels) : +IceGrid::AdminRouter::AdminRouter(const shared_ptr<TraceLevels>& traceLevels) : _traceLevels(traceLevels) { } void -IceGrid::AdminRouter::invokeOnTarget(const Ice::ObjectPrx& target, - const AMD_Object_ice_invokePtr& cb, - const pair<const Byte*, const Byte*>& inParams, - const Current& current) +IceGrid::AdminRouter::invokeOnTarget(const shared_ptr<Ice::ObjectPrx>& target, + const pair<const Ice::Byte*, const Ice::Byte*>& inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)>&& response, + function<void(exception_ptr)>&& exception, + const Ice::Current& current) { - assert(target != 0); - - // - // Call with AMI - // - Callback_Object_ice_invokePtr amiCb = newCallback_Object_ice_invoke( - new CallbackI(cb, target, current.operation, _traceLevels), &CallbackI::response, &CallbackI::exception); + assert(target); if(_traceLevels->admin > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->adminCat); out << "routing operation `" << current.operation << "' to `" << target->ice_toString() << "'"; } - target->begin_ice_invoke(current.operation, current.mode, inParams, current.ctx, amiCb); + + target->ice_invokeAsync(current.operation, current.mode, inParams, + [response, operation = current.operation, traceLevels = _traceLevels, target] + (bool ok, auto bytes) + { + if(traceLevels->admin > 0) + { + Ice::Trace out(traceLevels->logger, traceLevels->adminCat); + + out << "operation `" << operation << "' routed to `" + << Ice::identityToString(target->ice_getIdentity()) + << " -f " << target->ice_getFacet() << "' is returning "; + + if(ok) + { + out << "successfully"; + } + else + { + out << "a user exception"; + } + } + + response(move(ok), move(bytes)); + }, + [exception, operation = current.operation, traceLevels = _traceLevels, target] + (exception_ptr exptr) + { + if(traceLevels->admin > 0) + { + Ice::Trace out(traceLevels->logger, traceLevels->adminCat); + try + { + rethrow_exception(exptr); + } + catch(const std::exception& ex) + { + out << "operation `" << operation << "' routed to `" + << Ice::identityToString(target->ice_getIdentity()) + << " -f " << target->ice_getFacet() << "' failed with " << ex; + } + } + + exception(exptr); + }, + nullptr, + current.ctx); } diff --git a/cpp/src/IceGrid/AdminRouter.h b/cpp/src/IceGrid/AdminRouter.h index fcb988e1f06..e261d2e088f 100644 --- a/cpp/src/IceGrid/AdminRouter.h +++ b/cpp/src/IceGrid/AdminRouter.h @@ -18,14 +18,15 @@ class AdminRouter : public Ice::BlobjectArrayAsync { protected: - AdminRouter(const TraceLevelsPtr&); + AdminRouter(const std::shared_ptr<TraceLevels>&); - void invokeOnTarget(const Ice::ObjectPrx&, - const Ice::AMD_Object_ice_invokePtr&, + void invokeOnTarget(const std::shared_ptr<Ice::ObjectPrx>&, const std::pair<const Ice::Byte*, const Ice::Byte*>&, + std::function<void(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&)>&&, + std::function<void(std::exception_ptr)>&&, const Ice::Current&); - const TraceLevelsPtr _traceLevels; + const std::shared_ptr<TraceLevels> _traceLevels; }; } diff --git a/cpp/src/IceGrid/AdminSessionI.cpp b/cpp/src/IceGrid/AdminSessionI.cpp index 947298e7842..4120f274f28 100644 --- a/cpp/src/IceGrid/AdminSessionI.cpp +++ b/cpp/src/IceGrid/AdminSessionI.cpp @@ -8,6 +8,7 @@ #include <IceGrid/AdminSessionI.h> #include <IceGrid/AdminI.h> #include <IceGrid/Database.h> +#include <IceGrid/Internal.h> #include <IceSSL/Plugin.h> @@ -19,67 +20,45 @@ namespace class SubscriberForwarderI : public Ice::BlobjectArrayAsync { - class CallbackI: public IceUtil::Shared - { - public: - - virtual void - exception(const Ice::Exception& ex, const Ice::AMD_Object_ice_invokePtr& amdCB) - { - try - { - ex.ice_throw(); - } - catch(const Ice::Exception&) - { - // Throw ObjectNotExistException, the subscriber is unreachable - amdCB->ice_exception(Ice::ObjectNotExistException(__FILE__, __LINE__)); - } - } - - virtual void - response(bool ok, - const pair<const Ice::Byte*, const Ice::Byte*>& outP, - const Ice::AMD_Object_ice_invokePtr& amdCB) - { - amdCB->ice_response(ok, outP); - } - }; - public: - SubscriberForwarderI(const Ice::ObjectPrx& proxy) : - _proxy(proxy), - _callback(newCallback_Object_ice_invoke(new CallbackI(), &CallbackI::response, &CallbackI::exception)) + SubscriberForwarderI(const std::shared_ptr<Ice::ObjectPrx>& proxy) : + _proxy(proxy) { } - virtual void - ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB, - const pair<const Ice::Byte*, const Ice::Byte*>& inParams, - const Ice::Current& current) + void + ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, const Ice::Current& current) override { - _proxy->begin_ice_invoke(current.operation, current.mode, inParams, current.ctx, _callback, amdCB); + _proxy->ice_invokeAsync(current.operation, current.mode, inParams, + move(response), + [exception = move(exception)] (exception_ptr) + { + // Throw ObjectNotExistException, the subscriber is unreachable + exception(make_exception_ptr(Ice::ObjectNotExistException(__FILE__, __LINE__))); + }, + nullptr, current.ctx); } private: - const Ice::ObjectPrx _proxy; - const Ice::Callback_Object_ice_invokePtr _callback; + const shared_ptr<Ice::ObjectPrx> _proxy; }; } -FileIteratorI::FileIteratorI(const AdminSessionIPtr& session, - const FileReaderPrx& reader, +FileIteratorI::FileIteratorI(const shared_ptr<AdminSessionI>& session, + const shared_ptr<FileReaderPrx>& reader, const string& filename, - Ice::Long offset, - int messageSizeMax) : + long long offset, + int messageMaxSize) : _session(session), _reader(reader), _filename(filename), _offset(offset), - _messageSizeMax(messageSizeMax - 256) // Room for the header + _messageMaxSize(messageMaxSize - 256) // Room for the header { } @@ -88,13 +67,11 @@ FileIteratorI::read(int size, Ice::StringSeq& lines, const Ice::Current&) { try { - return _reader->read(_filename, _offset, size > _messageSizeMax ? _messageSizeMax : size, _offset, lines); + return _reader->read(_filename, _offset, size > _messageMaxSize ? _messageMaxSize : size, _offset, lines); } - catch(const Ice::LocalException& ex) + catch(const std::exception& ex) { - ostringstream os; - os << ex; - throw FileNotAvailableException(os.str()); + throw FileNotAvailableException(ex.what()); } } @@ -104,7 +81,8 @@ FileIteratorI::destroy(const Ice::Current& current) _session->removeFileIterator(current.id, current); } -AdminSessionI::AdminSessionI(const string& id, const DatabasePtr& db, int timeout, const RegistryIPtr& registry) : +AdminSessionI::AdminSessionI(const string& id, const shared_ptr<Database>& db, chrono::seconds timeout, + const shared_ptr<RegistryI>& registry) : BaseSessionI(id, "admin", db), _timeout(timeout), _replicaName(registry->getName()), @@ -112,12 +90,9 @@ AdminSessionI::AdminSessionI(const string& id, const DatabasePtr& db, int timeou { } -AdminSessionI::~AdminSessionI() -{ -} - -Ice::ObjectPrx -AdminSessionI::_register(const SessionServantManagerPtr& servantManager, const Ice::ConnectionPtr& con) +shared_ptr<Ice::ObjectPrx> +AdminSessionI::_register(const shared_ptr<SessionServantManager>& servantManager, + const shared_ptr<Ice::Connection>& con) { // // This is supposed to be called after creation only, no need to synchronize. @@ -137,117 +112,123 @@ AdminSessionI::_register(const SessionServantManagerPtr& servantManager, const I _adminCallbackTemplate = _registry->createAdminCallbackProxy(templateId); } - Ice::ObjectPrx session = _servantManager->addSession(this, con, category); + auto self = static_pointer_cast<AdminSessionI>(shared_from_this()); + + auto session = _servantManager->addSession(self, con, category); - _admin = AdminPrx::uncheckedCast(_servantManager->add(new AdminI(_database, _registry, this), this)); + _admin = Ice::uncheckedCast<AdminPrx>(_servantManager->add(make_shared<AdminI>(_database, _registry, self), self)); return session; } -AdminPrx +shared_ptr<AdminPrx> AdminSessionI::getAdmin(const Ice::Current&) const { return _admin; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> AdminSessionI::getAdminCallbackTemplate(const Ice::Current&) const { return _adminCallbackTemplate; } void -AdminSessionI::setObservers(const RegistryObserverPrx& registryObserver, - const NodeObserverPrx& nodeObserver, - const ApplicationObserverPrx& appObserver, - const AdapterObserverPrx& adapterObserver, - const ObjectObserverPrx& objectObserver, +AdminSessionI::setObservers(shared_ptr<RegistryObserverPrx> registryObserver, + shared_ptr<NodeObserverPrx> nodeObserver, + shared_ptr<ApplicationObserverPrx> appObserver, + shared_ptr<AdapterObserverPrx> adapterObserver, + shared_ptr<ObjectObserverPrx> objectObserver, const Ice::Current& current) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__, current.id, "", ""); } - const int t = _timeout * 1000; - const Ice::LocatorPrx l = _registry->getLocator(); + const auto t = secondsToInt(_timeout); + assert(t != 0); + const auto l = _registry->getLocator(); if(registryObserver) { - setupObserverSubscription(RegistryObserverTopicName, + setupObserverSubscription(TopicName::RegistryObserver, addForwarder(registryObserver->ice_timeout(t)->ice_locator(l))); } else { - setupObserverSubscription(RegistryObserverTopicName, Ice::ObjectPrx()); + setupObserverSubscription(TopicName::RegistryObserver, nullptr); } if(nodeObserver) { - setupObserverSubscription(NodeObserverTopicName, + setupObserverSubscription(TopicName::NodeObserver, addForwarder(nodeObserver->ice_timeout(t)->ice_locator(l))); } else { - setupObserverSubscription(NodeObserverTopicName, Ice::ObjectPrx()); + setupObserverSubscription(TopicName::NodeObserver, nullptr); } if(appObserver) { - setupObserverSubscription(ApplicationObserverTopicName, + setupObserverSubscription(TopicName::ApplicationObserver, addForwarder(appObserver->ice_timeout(t)->ice_locator(l))); } else { - setupObserverSubscription(ApplicationObserverTopicName, Ice::ObjectPrx()); + setupObserverSubscription(TopicName::ApplicationObserver, nullptr); } if(adapterObserver) { - setupObserverSubscription(AdapterObserverTopicName, + setupObserverSubscription(TopicName::AdapterObserver, addForwarder(adapterObserver->ice_timeout(t)->ice_locator(l))); } else { - setupObserverSubscription(AdapterObserverTopicName, Ice::ObjectPrx()); + setupObserverSubscription(TopicName::AdapterObserver, nullptr); } if(objectObserver) { - setupObserverSubscription(ObjectObserverTopicName, + setupObserverSubscription(TopicName::ObjectObserver, addForwarder(objectObserver->ice_timeout(t)->ice_locator(l))); } else { - setupObserverSubscription(ObjectObserverTopicName, Ice::ObjectPrx()); + setupObserverSubscription(TopicName::ObjectObserver, nullptr); } } void -AdminSessionI::setObserversByIdentity(const Ice::Identity& registryObserver, - const Ice::Identity& nodeObserver, - const Ice::Identity& appObserver, - const Ice::Identity& adapterObserver, - const Ice::Identity& objectObserver, +AdminSessionI::setObserversByIdentity(Ice::Identity registryObserver, + Ice::Identity nodeObserver, + Ice::Identity appObserver, + Ice::Identity adapterObserver, + Ice::Identity objectObserver, const Ice::Current& current) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__, current.id, "", ""); } - setupObserverSubscription(RegistryObserverTopicName, addForwarder(registryObserver, current), true); - setupObserverSubscription(NodeObserverTopicName, addForwarder(nodeObserver, current), true); - setupObserverSubscription(ApplicationObserverTopicName, addForwarder(appObserver, current), true); - setupObserverSubscription(AdapterObserverTopicName, addForwarder(adapterObserver, current), true); - setupObserverSubscription(ObjectObserverTopicName, addForwarder(objectObserver, current), true); + setupObserverSubscription(TopicName::RegistryObserver, addForwarder(registryObserver, current), true); + setupObserverSubscription(TopicName::NodeObserver, addForwarder(nodeObserver, current), true); + setupObserverSubscription(TopicName::ApplicationObserver, addForwarder(appObserver, current), true); + setupObserverSubscription(TopicName::AdapterObserver, addForwarder(adapterObserver, current), true); + setupObserverSubscription(TopicName::ObjectObserver, addForwarder(objectObserver, current), true); } int AdminSessionI::startUpdate(const Ice::Current& current) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__, current.id, "", ""); @@ -260,7 +241,8 @@ AdminSessionI::startUpdate(const Ice::Current& current) void AdminSessionI::finishUpdate(const Ice::Current& current) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__, current.id, "", ""); @@ -275,12 +257,12 @@ AdminSessionI::getReplicaName(const Ice::Current&) const return _replicaName; } -FileIteratorPrx -AdminSessionI::openServerLog(const string& id, const string& path, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openServerLog(string id, string path, int nLines, const Ice::Current& current) { try { - return addFileIterator(_database->getServer(id)->getProxy(false, 5), "#" + path, nLines, current); + return addFileIterator(_database->getServer(move(id))->getProxy(false, 5s), "#" + move(path), nLines, current); } catch(const SynchronizationException&) { @@ -288,12 +270,12 @@ AdminSessionI::openServerLog(const string& id, const string& path, int nLines, c } } -FileIteratorPrx -AdminSessionI::openServerStdOut(const string& id, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openServerStdOut(string id, int nLines, const Ice::Current& current) { try { - return addFileIterator(_database->getServer(id)->getProxy(false, 5), "stdout", nLines, current); + return addFileIterator(_database->getServer(move(id))->getProxy(false, 5s), "stdout", nLines, current); } catch(const SynchronizationException&) { @@ -301,12 +283,12 @@ AdminSessionI::openServerStdOut(const string& id, int nLines, const Ice::Current } } -FileIteratorPrx -AdminSessionI::openServerStdErr(const string& id, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openServerStdErr(string id, int nLines, const Ice::Current& current) { try { - return addFileIterator(_database->getServer(id)->getProxy(false, 5), "stderr", nLines, current); + return addFileIterator(_database->getServer(move(id))->getProxy(false, 5s), "stderr", nLines, current); } catch(const SynchronizationException&) { @@ -314,44 +296,44 @@ AdminSessionI::openServerStdErr(const string& id, int nLines, const Ice::Current } } -FileIteratorPrx -AdminSessionI::openNodeStdOut(const string& name, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openNodeStdOut(string name, int nLines, const Ice::Current& current) { - return addFileIterator(_database->getNode(name)->getProxy(), "stdout", nLines, current); + return addFileIterator(_database->getNode(move(name))->getProxy(), "stdout", nLines, current); } -FileIteratorPrx -AdminSessionI::openNodeStdErr(const string& name, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openNodeStdErr(string name, int nLines, const Ice::Current& current) { - return addFileIterator(_database->getNode(name)->getProxy(), "stderr", nLines, current); + return addFileIterator(_database->getNode(move(name))->getProxy(), "stderr", nLines, current); } -FileIteratorPrx -AdminSessionI::openRegistryStdOut(const string& name, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openRegistryStdOut(string name, int nLines, const Ice::Current& current) { - FileReaderPrx reader; + shared_ptr<FileReaderPrx> reader; if(name == _replicaName) { reader = _database->getReplicaCache().getInternalRegistry(); } else { - reader = _database->getReplica(name)->getProxy(); + reader = _database->getReplica(move(name))->getProxy(); } return addFileIterator(reader, "stdout", nLines, current); } -FileIteratorPrx -AdminSessionI::openRegistryStdErr(const string& name, int nLines, const Ice::Current& current) +shared_ptr<FileIteratorPrx> +AdminSessionI::openRegistryStdErr(string name, int nLines, const Ice::Current& current) { - FileReaderPrx reader; + shared_ptr<FileReaderPrx> reader; if(name == _replicaName) { reader = _database->getReplicaCache().getInternalRegistry(); } else { - reader = _database->getReplica(name)->getProxy(); + reader = _database->getReplica(move(name))->getProxy(); } return addFileIterator(reader, "stderr", nLines, current); } @@ -363,7 +345,7 @@ AdminSessionI::destroy(const Ice::Current&) } void -AdminSessionI::setupObserverSubscription(TopicName name, const Ice::ObjectPrx& observer, bool forwarder) +AdminSessionI::setupObserverSubscription(TopicName name, const shared_ptr<Ice::ObjectPrx>& observer, bool forwarder) { if(_observers.find(name) != _observers.end() && _observers[name].first != observer) { @@ -390,27 +372,28 @@ AdminSessionI::setupObserverSubscription(TopicName name, const Ice::ObjectPrx& o } } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> AdminSessionI::addForwarder(const Ice::Identity& id, const Ice::Current& current) { if(id.name.empty()) { - return Ice::ObjectPrx(); + return nullptr; } return addForwarder(current.con->createProxy(id)->ice_encodingVersion(current.encoding)); } -Ice::ObjectPrx -AdminSessionI::addForwarder(const Ice::ObjectPrx& prx) +shared_ptr<Ice::ObjectPrx> +AdminSessionI::addForwarder(const shared_ptr<Ice::ObjectPrx>& prx) { - return _registry->getRegistryAdapter()->addWithUUID(new SubscriberForwarderI(prx)); + return _registry->getRegistryAdapter()->addWithUUID(make_shared<SubscriberForwarderI>(prx)); } -FileIteratorPrx -AdminSessionI::addFileIterator(const FileReaderPrx& reader, const string& filename, int nLines, +shared_ptr<FileIteratorPrx> +AdminSessionI::addFileIterator(const shared_ptr<FileReaderPrx>& reader, const string& filename, int nLines, const Ice::Current& current) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__, current.id, "", ""); @@ -420,29 +403,29 @@ AdminSessionI::addFileIterator(const FileReaderPrx& reader, const string& filena // Always call getOffsetFromEnd even if nLines < 0. This allows to // throw right away if the file doesn't exit. // - Ice::Long offset; + long long offset; try { offset = reader->getOffsetFromEnd(filename, nLines); } - catch(const Ice::LocalException& ex) + catch(const std::exception& ex) { - ostringstream os; - os << ex; - throw FileNotAvailableException(os.str()); + throw FileNotAvailableException(ex.what()); } - Ice::PropertiesPtr properties = reader->ice_getCommunicator()->getProperties(); - int messageSizeMax = properties->getPropertyAsIntWithDefault("Ice.MessageSizeMax", 1024) * 1024; + auto properties = reader->ice_getCommunicator()->getProperties(); + int messageMaxSize = properties->getPropertyAsIntWithDefault("Ice.MessageMaxSize", 1024) * 1024; - Ice::ObjectPrx obj = _servantManager->add(new FileIteratorI(this, reader, filename, offset, messageSizeMax), this); - return FileIteratorPrx::uncheckedCast(obj); + auto self = static_pointer_cast<AdminSessionI>(shared_from_this()); + auto obj = _servantManager->add(make_shared<FileIteratorI>(self, reader, filename, offset, messageMaxSize), self); + return Ice::uncheckedCast<FileIteratorPrx>(obj); } void AdminSessionI::removeFileIterator(const Ice::Identity& id, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); + _servantManager->remove(id); } @@ -451,7 +434,7 @@ AdminSessionI::destroyImpl(bool shutdown) { BaseSessionI::destroyImpl(shutdown); - _servantManager->removeSession(this); + _servantManager->removeSession(shared_from_this()); try { @@ -466,18 +449,18 @@ AdminSessionI::destroyImpl(bool shutdown) // // Unsubscribe from the topics. // - setupObserverSubscription(RegistryObserverTopicName, 0); - setupObserverSubscription(NodeObserverTopicName, 0); - setupObserverSubscription(ApplicationObserverTopicName, 0); - setupObserverSubscription(AdapterObserverTopicName, 0); - setupObserverSubscription(ObjectObserverTopicName, 0); + setupObserverSubscription(TopicName::RegistryObserver, nullptr); + setupObserverSubscription(TopicName::NodeObserver, nullptr); + setupObserverSubscription(TopicName::ApplicationObserver, nullptr); + setupObserverSubscription(TopicName::AdapterObserver, nullptr); + setupObserverSubscription(TopicName::ObjectObserver, nullptr); } } -AdminSessionFactory::AdminSessionFactory(const SessionServantManagerPtr& servantManager, - const DatabasePtr& database, - const ReapThreadPtr& reaper, - const RegistryIPtr& registry) : +AdminSessionFactory::AdminSessionFactory(const shared_ptr<SessionServantManager>& servantManager, + const shared_ptr<Database>& database, + const shared_ptr<ReapThread>& reaper, + const shared_ptr<RegistryI>& registry) : _servantManager(servantManager), _database(database), _timeout(registry->getSessionTimeout(Ice::emptyCurrent)), @@ -487,35 +470,29 @@ AdminSessionFactory::AdminSessionFactory(const SessionServantManagerPtr& servant { if(_servantManager) // Not set if Glacier2 session manager adapter not enabled { - Ice::PropertiesPtr props = database->getCommunicator()->getProperties(); + auto props = database->getCommunicator()->getProperties(); const_cast<bool&>(_filters) = props->getPropertyAsIntWithDefault("IceGrid.Registry.AdminSessionFilters", 0) > 0; } } -Glacier2::SessionPrx -AdminSessionFactory::createGlacier2Session(const string& sessionId, const Glacier2::SessionControlPrx& ctl) +shared_ptr<Glacier2::SessionPrx> +AdminSessionFactory::createGlacier2Session(const string& sessionId, const shared_ptr<Glacier2::SessionControlPrx>& ctl) { assert(_servantManager); - AdminSessionIPtr session = createSessionServant(sessionId); - Ice::ObjectPrx proxy = session->_register(_servantManager, 0); + auto session = createSessionServant(sessionId); + auto proxy = session->_register(_servantManager, nullptr); - int timeout = 0; + chrono::seconds timeout = 0s; if(ctl) { try { if(_filters) { - Ice::IdentitySeq ids; - Ice::Identity queryId; - queryId.category = _database->getInstanceName(); - queryId.name = "Query"; - ids.push_back(queryId); - - _servantManager->setSessionControl(session, ctl, ids); + _servantManager->setSessionControl(session, ctl, { {"Query", _database->getInstanceName() } }); } - timeout = ctl->getSessionTimeout(); + timeout = chrono::seconds(ctl->getSessionTimeout()); } catch(const Ice::LocalException& e) { @@ -528,39 +505,40 @@ AdminSessionFactory::createGlacier2Session(const string& sessionId, const Glacie } } - _reaper->add(new SessionReapable<AdminSessionI>(_database->getTraceLevels()->logger, session), timeout); - return Glacier2::SessionPrx::uncheckedCast(proxy); + _reaper->add(make_shared<SessionReapable<AdminSessionI>>(_database->getTraceLevels()->logger, session), timeout); + return Ice::uncheckedCast<Glacier2::SessionPrx>(proxy); } -AdminSessionIPtr +shared_ptr<AdminSessionI> AdminSessionFactory::createSessionServant(const string& id) { - return new AdminSessionI(id, _database, _timeout, _registry); + return make_shared<AdminSessionI>(id, _database, _timeout, _registry); } -const TraceLevelsPtr& +const shared_ptr<TraceLevels>& AdminSessionFactory::getTraceLevels() const { return _database->getTraceLevels(); } -AdminSessionManagerI::AdminSessionManagerI(const AdminSessionFactoryPtr& factory) : _factory(factory) +AdminSessionManagerI::AdminSessionManagerI(const shared_ptr<AdminSessionFactory>& factory) : _factory(factory) { } -Glacier2::SessionPrx -AdminSessionManagerI::create(const string& userId, const Glacier2::SessionControlPrx& ctl, const Ice::Current&) +shared_ptr<Glacier2::SessionPrx> +AdminSessionManagerI::create(string userId, shared_ptr<Glacier2::SessionControlPrx> ctl, + const Ice::Current&) { - return _factory->createGlacier2Session(userId, ctl); + return _factory->createGlacier2Session(move(userId), move(ctl)); } -AdminSSLSessionManagerI::AdminSSLSessionManagerI(const AdminSessionFactoryPtr& factory) : _factory(factory) +AdminSSLSessionManagerI::AdminSSLSessionManagerI(const shared_ptr<AdminSessionFactory>& factory) : _factory(factory) { } -Glacier2::SessionPrx -AdminSSLSessionManagerI::create(const Glacier2::SSLInfo& info, - const Glacier2::SessionControlPrx& ctl, +shared_ptr<Glacier2::SessionPrx> +AdminSSLSessionManagerI::create(Glacier2::SSLInfo info, + shared_ptr<Glacier2::SessionControlPrx> ctl, const Ice::Current&) { string userDN; @@ -568,7 +546,7 @@ AdminSSLSessionManagerI::create(const Glacier2::SSLInfo& info, { try { - IceSSL::CertificatePtr cert = IceSSL::Certificate::decode(info.certs[0]); + auto cert = IceSSL::Certificate::decode(info.certs[0]); userDN = cert->getSubjectDN(); } catch(const Ice::Exception& ex) @@ -580,5 +558,5 @@ AdminSSLSessionManagerI::create(const Glacier2::SSLInfo& info, } } - return _factory->createGlacier2Session(userDN, ctl); + return _factory->createGlacier2Session(move(userDN), move(ctl)); } diff --git a/cpp/src/IceGrid/AdminSessionI.h b/cpp/src/IceGrid/AdminSessionI.h index ee1d9c909d8..8ed7ab9e5b8 100644 --- a/cpp/src/IceGrid/AdminSessionI.h +++ b/cpp/src/IceGrid/AdminSessionI.h @@ -14,132 +14,135 @@ namespace IceGrid { class RegistryI; -typedef IceUtil::Handle<RegistryI> RegistryIPtr; - class FileIteratorI; -typedef IceUtil::Handle<FileIteratorI> FileIteratorIPtr; class AdminSessionI : public BaseSessionI, public AdminSession { public: - AdminSessionI(const std::string&, const DatabasePtr&, int, const RegistryIPtr&); - virtual ~AdminSessionI(); + AdminSessionI(const std::string&, const std::shared_ptr<Database>&, + std::chrono::seconds, const std::shared_ptr<RegistryI>&); - Ice::ObjectPrx _register(const SessionServantManagerPtr&, const Ice::ConnectionPtr&); + std::shared_ptr<Ice::ObjectPrx> _register(const std::shared_ptr<SessionServantManager>&, + const std::shared_ptr<Ice::Connection>&); - virtual void keepAlive(const Ice::Current& current) { BaseSessionI::keepAlive(current); } + void keepAlive(const Ice::Current& current) override { BaseSessionI::keepAlive(current); } - virtual AdminPrx getAdmin(const Ice::Current&) const; - virtual Ice::ObjectPrx getAdminCallbackTemplate(const Ice::Current&) const; + std::shared_ptr<AdminPrx> getAdmin(const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> getAdminCallbackTemplate(const Ice::Current&) const override; - virtual void setObservers(const RegistryObserverPrx&, const NodeObserverPrx&, const ApplicationObserverPrx&, - const AdapterObserverPrx&, const ObjectObserverPrx&, const Ice::Current&); + void setObservers(std::shared_ptr<RegistryObserverPrx>, std::shared_ptr<NodeObserverPrx>, + std::shared_ptr<ApplicationObserverPrx>, std::shared_ptr<AdapterObserverPrx>, + std::shared_ptr<ObjectObserverPrx>, const Ice::Current&) override; - virtual void setObserversByIdentity(const Ice::Identity&, const Ice::Identity&, const Ice::Identity&, - const Ice::Identity&, const Ice::Identity&, const Ice::Current&); + void setObserversByIdentity(Ice::Identity, Ice::Identity, Ice::Identity, Ice::Identity, Ice::Identity, + const Ice::Current&) override; - virtual int startUpdate(const Ice::Current&); - virtual void finishUpdate(const Ice::Current&); + int startUpdate(const Ice::Current&) override; + void finishUpdate(const Ice::Current&) override; - virtual std::string getReplicaName(const Ice::Current&) const; + std::string getReplicaName(const Ice::Current&) const override; - virtual FileIteratorPrx openServerLog(const std::string&, const std::string&, int, const Ice::Current&); - virtual FileIteratorPrx openServerStdOut(const std::string&, int, const Ice::Current&); - virtual FileIteratorPrx openServerStdErr(const std::string&, int, const Ice::Current&); + std::shared_ptr<FileIteratorPrx> openServerLog(std::string, std::string, int, const Ice::Current&) override; + std::shared_ptr<FileIteratorPrx> openServerStdOut(std::string, int, const Ice::Current&) override; + std::shared_ptr<FileIteratorPrx> openServerStdErr(std::string, int, const Ice::Current&) override; - virtual FileIteratorPrx openNodeStdOut(const std::string&, int, const Ice::Current&); - virtual FileIteratorPrx openNodeStdErr(const std::string&, int, const Ice::Current&); + std::shared_ptr<FileIteratorPrx> openNodeStdOut(std::string, int, const Ice::Current&) override; + std::shared_ptr<FileIteratorPrx> openNodeStdErr(std::string, int, const Ice::Current&) override; - virtual FileIteratorPrx openRegistryStdOut(const std::string&, int, const Ice::Current&); - virtual FileIteratorPrx openRegistryStdErr(const std::string&, int, const Ice::Current&); + std::shared_ptr<FileIteratorPrx> openRegistryStdOut(std::string, int, const Ice::Current&) override; + std::shared_ptr<FileIteratorPrx> openRegistryStdErr(std::string, int, const Ice::Current&) override; - virtual void destroy(const Ice::Current&); + void destroy(const Ice::Current&) override; void removeFileIterator(const Ice::Identity&, const Ice::Current&); private: - void setupObserverSubscription(TopicName, const Ice::ObjectPrx&, bool = false); - Ice::ObjectPrx addForwarder(const Ice::Identity&, const Ice::Current&); - Ice::ObjectPrx addForwarder(const Ice::ObjectPrx&); - FileIteratorPrx addFileIterator(const FileReaderPrx&, const std::string&, int, const Ice::Current&); + void setupObserverSubscription(TopicName, const std::shared_ptr<Ice::ObjectPrx>&, bool = false); + std::shared_ptr<Ice::ObjectPrx> addForwarder(const Ice::Identity&, const Ice::Current&); + std::shared_ptr<Ice::ObjectPrx> addForwarder(const std::shared_ptr<Ice::ObjectPrx>&); + std::shared_ptr<FileIteratorPrx> addFileIterator(const std::shared_ptr<FileReaderPrx>&, const std::string&, int, + const Ice::Current&); - virtual void destroyImpl(bool); + void destroyImpl(bool) override; - const int _timeout; + const std::chrono::seconds _timeout; const std::string _replicaName; - AdminPrx _admin; - std::map<TopicName, std::pair<Ice::ObjectPrx, bool> > _observers; - RegistryIPtr _registry; - Ice::ObjectPrx _adminCallbackTemplate; + std::shared_ptr<AdminPrx> _admin; + std::map<TopicName, std::pair<std::shared_ptr<Ice::ObjectPrx>, bool>> _observers; + std::shared_ptr<RegistryI> _registry; + std::shared_ptr<Ice::ObjectPrx> _adminCallbackTemplate; }; -typedef IceUtil::Handle<AdminSessionI> AdminSessionIPtr; -class AdminSessionFactory : public virtual IceUtil::Shared +class AdminSessionFactory { public: - AdminSessionFactory(const SessionServantManagerPtr&, const DatabasePtr&, const ReapThreadPtr&, const RegistryIPtr&); + AdminSessionFactory(const std::shared_ptr<SessionServantManager>&, const std::shared_ptr<Database>&, + const std::shared_ptr<ReapThread>&, const std::shared_ptr<RegistryI>&); - Glacier2::SessionPrx createGlacier2Session(const std::string&, const Glacier2::SessionControlPrx&); - AdminSessionIPtr createSessionServant(const std::string&); + std::shared_ptr<Glacier2::SessionPrx> createGlacier2Session(const std::string&, + const std::shared_ptr<Glacier2::SessionControlPrx>&); + std::shared_ptr<AdminSessionI> createSessionServant(const std::string&); - const TraceLevelsPtr& getTraceLevels() const; + const std::shared_ptr<TraceLevels>& getTraceLevels() const; private: - const SessionServantManagerPtr _servantManager; - const DatabasePtr _database; - const int _timeout; - const ReapThreadPtr _reaper; - const RegistryIPtr _registry; + const std::shared_ptr<SessionServantManager> _servantManager; + const std::shared_ptr<Database> _database; + const std::chrono::seconds _timeout; + const std::shared_ptr<ReapThread> _reaper; + const std::shared_ptr<RegistryI> _registry; const bool _filters; }; -typedef IceUtil::Handle<AdminSessionFactory> AdminSessionFactoryPtr; -class AdminSessionManagerI : public virtual Glacier2::SessionManager +class AdminSessionManagerI : public Glacier2::SessionManager { public: - AdminSessionManagerI(const AdminSessionFactoryPtr&); + AdminSessionManagerI(const std::shared_ptr<AdminSessionFactory>&); - virtual Glacier2::SessionPrx create(const std::string&, const Glacier2::SessionControlPrx&, const Ice::Current&); + std::shared_ptr<Glacier2::SessionPrx> create(std::string, std::shared_ptr<Glacier2::SessionControlPrx>, + const Ice::Current&) override; private: - const AdminSessionFactoryPtr _factory; + const std::shared_ptr<AdminSessionFactory> _factory; }; -class AdminSSLSessionManagerI : public virtual Glacier2::SSLSessionManager +class AdminSSLSessionManagerI : public Glacier2::SSLSessionManager { public: - AdminSSLSessionManagerI(const AdminSessionFactoryPtr&); - virtual Glacier2::SessionPrx create(const Glacier2::SSLInfo&, const Glacier2::SessionControlPrx&, - const Ice::Current&); + AdminSSLSessionManagerI(const std::shared_ptr<AdminSessionFactory>&); + + std::shared_ptr<Glacier2::SessionPrx> create(Glacier2::SSLInfo, std::shared_ptr<Glacier2::SessionControlPrx>, + const Ice::Current&) override; private: - const AdminSessionFactoryPtr _factory; + const std::shared_ptr<AdminSessionFactory> _factory; }; class FileIteratorI : public FileIterator { public: - FileIteratorI(const AdminSessionIPtr&, const FileReaderPrx&, const std::string&, Ice::Long, int); + FileIteratorI(const std::shared_ptr<AdminSessionI>&, const std::shared_ptr<FileReaderPrx>&, const std::string&, + long long, int); virtual bool read(int, Ice::StringSeq&, const Ice::Current&); virtual void destroy(const Ice::Current&); private: - const AdminSessionIPtr _session; - const FileReaderPrx _reader; + const std::shared_ptr<AdminSessionI> _session; + const std::shared_ptr<FileReaderPrx> _reader; const std::string _filename; - Ice::Long _offset; - const int _messageSizeMax; + long long _offset; + const int _messageMaxSize; }; }; diff --git a/cpp/src/IceGrid/Allocatable.cpp b/cpp/src/IceGrid/Allocatable.cpp index 35c1ad5b823..10889a1a871 100644 --- a/cpp/src/IceGrid/Allocatable.cpp +++ b/cpp/src/IceGrid/Allocatable.cpp @@ -8,26 +8,22 @@ using namespace std; using namespace IceGrid; -AllocationRequest::~AllocationRequest() -{ -} - bool AllocationRequest::pending() { - Lock sync(*this); + lock_guard lock(_mutex); assert(_state == Initial); if(_timeout == 0) { _state = Canceled; - canceled(AllocationTimeoutException()); + canceled(make_exception_ptr(AllocationTimeoutException())); return false; } - else if(!_session->addAllocationRequest(this)) + else if(!_session->addAllocationRequest(shared_from_this())) { _state = Canceled; - canceled(AllocationException("session destroyed")); + canceled(make_exception_ptr(AllocationException("session destroyed"))); return false; } @@ -35,7 +31,7 @@ AllocationRequest::pending() { try { - _session->getTimer()->schedule(this, IceUtil::Time::milliSeconds(_timeout)); + _session->getTimer()->schedule(shared_from_this(), IceUtil::Time::milliSeconds(_timeout)); } catch(const IceUtil::Exception&) { @@ -47,9 +43,9 @@ AllocationRequest::pending() } bool -AllocationRequest::allocate(const AllocatablePtr& /*allocatable*/, const SessionIPtr& session) +AllocationRequest::allocate(const shared_ptr<Allocatable>&, const shared_ptr<SessionI>& session) { - Lock sync(*this); + lock_guard lock(_mutex); switch(_state) { case Initial: @@ -59,9 +55,9 @@ AllocationRequest::allocate(const AllocatablePtr& /*allocatable*/, const Session case Pending: if(_timeout > 0) { - _session->getTimer()->cancel(this); + _session->getTimer()->cancel(shared_from_this()); } - _session->removeAllocationRequest(this); + _session->removeAllocationRequest(shared_from_this()); break; case Allocated: assert(false); @@ -74,7 +70,7 @@ AllocationRequest::allocate(const AllocatablePtr& /*allocatable*/, const Session if(_session == session) { _state = Canceled; - canceled(AllocationException("already allocated by the session")); + canceled(make_exception_ptr(AllocationException("already allocated by the session"))); return false; } else @@ -85,9 +81,9 @@ AllocationRequest::allocate(const AllocatablePtr& /*allocatable*/, const Session } void -AllocationRequest::cancel(const Ice::UserException& ex) +AllocationRequest::cancel(exception_ptr ex) { - Lock sync(*this); + lock_guard lock(_mutex); switch(_state) { case Initial: @@ -98,9 +94,9 @@ AllocationRequest::cancel(const Ice::UserException& ex) case Pending: if(_timeout > 0) { - _session->getTimer()->cancel(this); + _session->getTimer()->cancel(shared_from_this()); } - _session->removeAllocationRequest(this); + _session->removeAllocationRequest(shared_from_this()); break; } @@ -111,7 +107,7 @@ AllocationRequest::cancel(const Ice::UserException& ex) void AllocationRequest::runTimerTask() // TimerTask::runTimerTask() method implementation { - Lock sync(*this); + lock_guard lock(_mutex); switch(_state) { case Initial: @@ -120,18 +116,18 @@ AllocationRequest::runTimerTask() // TimerTask::runTimerTask() method implementa case Allocated: return; case Pending: - _session->removeAllocationRequest(this); + _session->removeAllocationRequest(shared_from_this()); break; } _state = Canceled; - canceled(AllocationTimeoutException()); + canceled(make_exception_ptr(AllocationTimeoutException())); } bool AllocationRequest::isCanceled() const { - Lock sync(*this); + lock_guard lock(_mutex); return _state == Canceled; } @@ -141,37 +137,22 @@ AllocationRequest::operator<(const AllocationRequest& r) const return this < &r; } -AllocationRequest::AllocationRequest(const SessionIPtr& session) : +AllocationRequest::AllocationRequest(const shared_ptr<SessionI>& session) : _session(session), _timeout(_session->getAllocationTimeout()), // The session timeout can be updated so we need to cache it here. _state(Initial) { } -Allocatable::Allocatable(bool allocatable, const AllocatablePtr& parent) : +Allocatable::Allocatable(bool allocatable, const shared_ptr<Allocatable>& parent) : _allocatable(allocatable || (parent && parent->isAllocatable())), + _parent((parent && parent->isAllocatable()) ? parent : nullptr), _count(0), _releasing(false) { - // - // COMPILERFIX: the constructor initializaton: - // - // _parent((parent && parent->isAllocatable()) ? parent : AllocatablePtr()) - // - // doesn't work on HP-UX (aCC: HP ANSI C++ B3910B A.03.56). It - // results in a SEGFAULT at runtime. - // - if(parent && parent->isAllocatable()) - { - const_cast<AllocatablePtr&>(_parent) = parent; - } assert(!_parent || _parent->isAllocatable()); // Parent is only set if it's allocatable. } -Allocatable::~Allocatable() -{ -} - void Allocatable::checkAllocatable() { @@ -182,7 +163,7 @@ Allocatable::checkAllocatable() } bool -Allocatable::allocate(const AllocationRequestPtr& request, bool fromRelease) +Allocatable::allocate(const shared_ptr<AllocationRequest>& request, bool fromRelease) { try { @@ -195,7 +176,7 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool fromRelease) } bool -Allocatable::tryAllocate(const AllocationRequestPtr& request, bool fromRelease) +Allocatable::tryAllocate(const shared_ptr<AllocationRequest>& request, bool fromRelease) { try { @@ -208,18 +189,15 @@ Allocatable::tryAllocate(const AllocationRequestPtr& request, bool fromRelease) } void -Allocatable::release(const SessionIPtr& session, bool fromRelease) +Allocatable::release(const shared_ptr<SessionI>& session, bool fromRelease) { bool isReleased = false; bool hasRequests = false; { - Lock sync(*this); + unique_lock lock(_mutex); if(!fromRelease) { - while(_releasing) - { - wait(); - } + _condVar.wait(lock, [this] { return !_releasing; }); assert(!_releasing); } @@ -260,17 +238,17 @@ Allocatable::release(const SessionIPtr& session, bool fromRelease) { while(true) { - AllocationRequestPtr request; - AllocatablePtr allocatable; + shared_ptr<AllocationRequest> request; + shared_ptr<Allocatable> allocatable; { - Lock sync(*this); + lock_guard lock(_mutex); allocatable = dequeueAllocationAttempt(request); if(!allocatable) { assert(_requests.empty()); assert(_count == 0); _releasing = false; - notifyAll(); + _condVar.notify_all(); return; } } @@ -287,7 +265,7 @@ Allocatable::release(const SessionIPtr& session, bool fromRelease) while(true) { { - Lock sync(*this); + lock_guard lock(_mutex); assert(_count); allocatable = 0; @@ -297,7 +275,7 @@ Allocatable::release(const SessionIPtr& session, bool fromRelease) // Check if there's other requests from the session // waiting to allocate this allocatable. // - list<pair<AllocatablePtr, AllocationRequestPtr> >::iterator p = _requests.begin(); + auto p = _requests.begin(); while(p != _requests.end()) { if(p->second && p->second->getSession() == _session) @@ -312,7 +290,7 @@ Allocatable::release(const SessionIPtr& session, bool fromRelease) if(!allocatable) { _releasing = false; - notifyAll(); + _condVar.notify_all(); return; // We're done, the allocatable was released (but is allocated again)! } } @@ -322,16 +300,16 @@ Allocatable::release(const SessionIPtr& session, bool fromRelease) assert(allocatable && request); allocatable->allocate(request, true); } - catch(const Ice::UserException& ex) + catch(const Ice::UserException&) { - request->cancel(ex); + request->cancel(current_exception()); } } } } - catch(const Ice::UserException& ex) + catch(const Ice::UserException&) { - request->cancel(ex); + request->cancel(current_exception()); } } } @@ -342,10 +320,10 @@ Allocatable::release(const SessionIPtr& session, bool fromRelease) } } -SessionIPtr +shared_ptr<SessionI> Allocatable::getSession() const { - Lock sync(*this); + lock_guard lock(_mutex); return _session; } @@ -356,8 +334,8 @@ Allocatable::operator<(const Allocatable& r) const } void -Allocatable::queueAllocationAttempt(const AllocatablePtr& allocatable, - const AllocationRequestPtr& request, +Allocatable::queueAllocationAttempt(const shared_ptr<Allocatable>& allocatable, + const shared_ptr<AllocationRequest>& request, bool tryAllocate) { assert(!_parent); @@ -365,17 +343,17 @@ Allocatable::queueAllocationAttempt(const AllocatablePtr& allocatable, { if(request->pending()) { - _requests.push_back(make_pair(allocatable, request)); + _requests.push_back({ allocatable, request }); } } else { - _requests.push_back(make_pair(allocatable, AllocationRequestPtr())); + _requests.push_back({ allocatable, nullptr }); } } void -Allocatable::queueAllocationAttemptFromChild(const AllocatablePtr& allocatable) +Allocatable::queueAllocationAttemptFromChild(const shared_ptr<Allocatable>& allocatable) { if(_parent) { @@ -383,19 +361,19 @@ Allocatable::queueAllocationAttemptFromChild(const AllocatablePtr& allocatable) return; } - Lock sync(*this); - _requests.push_back(make_pair(allocatable, AllocationRequestPtr())); + lock_guard lock(_mutex); + _requests.push_back({ allocatable, nullptr }); } -AllocatablePtr -Allocatable::dequeueAllocationAttempt(AllocationRequestPtr& request) +shared_ptr<Allocatable> +Allocatable::dequeueAllocationAttempt(shared_ptr<AllocationRequest>& request) { if(_requests.empty()) { - return 0; + return nullptr; } - pair<AllocatablePtr, AllocationRequestPtr> alloc = _requests.front(); + auto alloc = _requests.front(); _requests.pop_front(); if(alloc.second) { @@ -405,9 +383,9 @@ Allocatable::dequeueAllocationAttempt(AllocationRequestPtr& request) } bool -Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, bool fromRelease) +Allocatable::allocate(const shared_ptr<AllocationRequest>& request, bool tryAllocate, bool fromRelease) { - if(_parent && !_parent->allocateFromChild(request, this, tryAllocate, fromRelease)) + if(_parent && !_parent->allocateFromChild(request, shared_from_this(), tryAllocate, fromRelease)) { return false; } @@ -416,12 +394,12 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, boo int allocationCount = 0; try { - Lock sync(*this); + lock_guard lock(_mutex); checkAllocatable(); if(!_session && (fromRelease || !_releasing)) { - if(request->allocate(this, _session)) + if(request->allocate(shared_from_this(), _session)) { try { @@ -429,12 +407,12 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, boo } catch(const SessionDestroyedException&) { - request->canceled(AllocationException("session destroyed")); + request->canceled(make_exception_ptr(AllocationException("session destroyed"))); throw; } assert(_count == 0); _session = request->getSession(); - request->allocated(this, request->getSession()); + request->allocated(shared_from_this(), request->getSession()); ++_count; allocationCount = _count; } @@ -443,11 +421,11 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, boo { if(!tryAllocate) { - if(request->allocate(this, _session)) + if(request->allocate(shared_from_this(), _session)) { assert(_count > 0); ++_count; - request->allocated(this, _session); + request->allocated(shared_from_this(), _session); allocationCount = _count; } } @@ -458,7 +436,7 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, boo } else { - queueAllocationAttempt(this, request, tryAllocate); + queueAllocationAttempt(shared_from_this(), request, tryAllocate); } } catch(...) @@ -478,7 +456,7 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, boo { if(queueWithParent) { - _parent->queueAllocationAttemptFromChild(this); + _parent->queueAllocationAttemptFromChild(shared_from_this()); } _parent->release(request->getSession(), fromRelease); } @@ -486,8 +464,8 @@ Allocatable::allocate(const AllocationRequestPtr& request, bool tryAllocate, boo } bool -Allocatable::allocateFromChild(const AllocationRequestPtr& request, - const AllocatablePtr& child, +Allocatable::allocateFromChild(const shared_ptr<AllocationRequest>& request, + const shared_ptr<Allocatable>& child, bool tryAllocate, bool fromRelease) { @@ -498,7 +476,7 @@ Allocatable::allocateFromChild(const AllocationRequestPtr& request, int allocationCount = 0; { - Lock sync(*this); + lock_guard lock(_mutex); if((!_session || _session == request->getSession()) && (fromRelease || !_releasing)) { if(!_session) diff --git a/cpp/src/IceGrid/Allocatable.h b/cpp/src/IceGrid/Allocatable.h index 94f7fd2a183..bedf6dabce8 100644 --- a/cpp/src/IceGrid/Allocatable.h +++ b/cpp/src/IceGrid/Allocatable.h @@ -5,10 +5,6 @@ #ifndef ICE_GRID_ALLOCATABLE_H #define ICE_GRID_ALLOCATABLE_H -#include <IceUtil/Handle.h> -#include <IceUtil/Mutex.h> -#include <IceUtil/Shared.h> -#include <IceUtil/Time.h> #include <IceUtil/Timer.h> #include <IceGrid/Session.h> @@ -19,35 +15,33 @@ namespace IceGrid { -class SessionI; -typedef IceUtil::Handle<SessionI> SessionIPtr; - class Allocatable; -typedef IceUtil::Handle<Allocatable> AllocatablePtr; +class SessionI; -class AllocationRequest : public IceUtil::Mutex, public IceUtil::TimerTask +class AllocationRequest : public IceUtil::TimerTask, public std::enable_shared_from_this<AllocationRequest> { public: - virtual ~AllocationRequest(); + virtual ~AllocationRequest() = default; - virtual void allocated(const AllocatablePtr&, const SessionIPtr&) = 0; - virtual void canceled(const Ice::UserException&) = 0; + virtual void allocated(const std::shared_ptr<Allocatable>&, const std::shared_ptr<SessionI>&) = 0; + virtual void canceled(std::exception_ptr) = 0; bool pending(); - bool allocate(const AllocatablePtr&, const SessionIPtr&); - void cancel(const Ice::UserException&); - void runTimerTask(); // Implementation of IceUtil::TimerTask::runTimerTask() + bool allocate(const std::shared_ptr<Allocatable>&, const std::shared_ptr<SessionI>&); + void cancel(std::exception_ptr); + + void runTimerTask() override; int getTimeout() const { return _timeout; } - const SessionIPtr& getSession() const { return _session; } + const std::shared_ptr<SessionI>& getSession() const { return _session; } bool isCanceled() const; bool operator<(const AllocationRequest&) const; protected: - AllocationRequest(const SessionIPtr&); + AllocationRequest(const std::shared_ptr<SessionI>&); private: @@ -59,53 +53,57 @@ private: Allocated }; - const SessionIPtr _session; + const std::shared_ptr<SessionI> _session; const int _timeout; State _state; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<AllocationRequest> AllocationRequestPtr; -class Allocatable : public virtual IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex> +class Allocatable: public virtual std::enable_shared_from_this<Allocatable> { public: - Allocatable(bool, const AllocatablePtr&); - virtual ~Allocatable(); + Allocatable(bool, const std::shared_ptr<Allocatable>&); + virtual ~Allocatable() = default; virtual void checkAllocatable(); - virtual bool allocate(const AllocationRequestPtr&, bool = false); - virtual bool tryAllocate(const AllocationRequestPtr&, bool = false); - virtual void release(const SessionIPtr&, bool = false); + virtual bool allocate(const std::shared_ptr<AllocationRequest>&, bool = false); + virtual bool tryAllocate(const std::shared_ptr<AllocationRequest>&, bool = false); + virtual void release(const std::shared_ptr<SessionI>&, bool = false); bool isAllocatable() const { return _allocatable; } - SessionIPtr getSession() const; + std::shared_ptr<SessionI> getSession() const; virtual bool isEnabled() const = 0; - virtual void allocated(const SessionIPtr&) = 0; - virtual void released(const SessionIPtr&) = 0; + virtual void allocated(const std::shared_ptr<SessionI>&) = 0; + virtual void released(const std::shared_ptr<SessionI>&) = 0; virtual bool canTryAllocate() { return false; } - virtual void allocatedNoSync(const SessionIPtr&) { ; } - virtual void releasedNoSync(const SessionIPtr&) { ; } + virtual void allocatedNoSync(const std::shared_ptr<SessionI>&) {} + virtual void releasedNoSync(const std::shared_ptr<SessionI>&) {} bool operator<(const Allocatable&) const; protected: - bool allocate(const AllocationRequestPtr&, bool, bool); - void queueAllocationAttemptFromChild(const AllocatablePtr&); - bool allocateFromChild(const AllocationRequestPtr&, const AllocatablePtr&, bool, bool); + bool allocate(const std::shared_ptr<AllocationRequest>&, bool, bool); + void queueAllocationAttemptFromChild(const std::shared_ptr<Allocatable>&); + bool allocateFromChild(const std::shared_ptr<AllocationRequest>&, const std::shared_ptr<Allocatable>&, bool, bool); - void queueAllocationAttempt(const AllocatablePtr&, const AllocationRequestPtr&, bool); - AllocatablePtr dequeueAllocationAttempt(AllocationRequestPtr&); + void queueAllocationAttempt(const std::shared_ptr<Allocatable>&, const std::shared_ptr<AllocationRequest>&, bool); + std::shared_ptr<Allocatable> dequeueAllocationAttempt(std::shared_ptr<AllocationRequest>&); bool _allocatable; - const AllocatablePtr _parent; + const std::shared_ptr<Allocatable> _parent; - std::list<std::pair<AllocatablePtr, AllocationRequestPtr> > _requests; - SessionIPtr _session; + std::list<std::pair<std::shared_ptr<Allocatable>, std::shared_ptr<AllocationRequest>>> _requests; + std::shared_ptr<SessionI> _session; int _count; bool _releasing; + + mutable std::mutex _mutex; + std::condition_variable _condVar; }; }; diff --git a/cpp/src/IceGrid/AllocatableObjectCache.cpp b/cpp/src/IceGrid/AllocatableObjectCache.cpp index 0f77b299ea1..54004e47f7d 100644 --- a/cpp/src/IceGrid/AllocatableObjectCache.cpp +++ b/cpp/src/IceGrid/AllocatableObjectCache.cpp @@ -13,32 +13,24 @@ using namespace std; using namespace IceGrid; -namespace IceGrid +namespace { -struct AllocatableObjectEntryCI : binary_function<AllocatableObjectEntryPtr&, AllocatableObjectEntryPtr&, bool> +bool compareAllocatableObjectEntry(const shared_ptr<AllocatableObjectEntry>& lhs, + const shared_ptr<AllocatableObjectEntry>& rhs) { - - bool - operator()(const AllocatableObjectEntryPtr& lhs, const AllocatableObjectEntryPtr& rhs) - { - return ::Ice::proxyIdentityLess(lhs->getProxy(), rhs->getProxy()); - } -}; + return Ice::proxyIdentityLess(lhs->getProxy(), rhs->getProxy()); +} }; -AllocatableObjectCache::TypeEntry::TypeEntry() -{ -} - void -AllocatableObjectCache::TypeEntry::add(const AllocatableObjectEntryPtr& obj) +AllocatableObjectCache::TypeEntry::add(const shared_ptr<AllocatableObjectEntry>& obj) { // // No mutex protection here, this is called with the cache locked. // - _objects.insert(lower_bound(_objects.begin(), _objects.end(), obj, AllocatableObjectEntryCI()), obj); + _objects.insert(lower_bound(_objects.begin(), _objects.end(), obj, compareAllocatableObjectEntry), obj); if(!_requests.empty()) { canTryAllocate(obj, false); @@ -46,28 +38,28 @@ AllocatableObjectCache::TypeEntry::add(const AllocatableObjectEntryPtr& obj) } bool -AllocatableObjectCache::TypeEntry::remove(const AllocatableObjectEntryPtr& obj) +AllocatableObjectCache::TypeEntry::remove(const shared_ptr<AllocatableObjectEntry>& obj) { // // No mutex protection here, this is called with the cache locked. // - vector<AllocatableObjectEntryPtr>::iterator q; - q = lower_bound(_objects.begin(), _objects.end(), obj, AllocatableObjectEntryCI()); + vector<shared_ptr<AllocatableObjectEntry>>::iterator q; + q = lower_bound(_objects.begin(), _objects.end(), obj, compareAllocatableObjectEntry); assert(q->get() == obj.get()); _objects.erase(q); if(!_requests.empty() && _objects.empty()) { - for(list<ObjectAllocationRequestPtr>::const_iterator p = _requests.begin(); p != _requests.end(); ++p) + for(const auto& req : _requests) { - (*p)->cancel(AllocationException("no allocatable objects with type `" + obj->getType() + "' registered")); + req->cancel(make_exception_ptr(AllocationException("no allocatable objects with type `" + obj->getType() + "' registered"))); } } return _objects.empty(); } void -AllocatableObjectCache::TypeEntry::addAllocationRequest(const ObjectAllocationRequestPtr& request) +AllocatableObjectCache::TypeEntry::addAllocationRequest(const shared_ptr<ObjectAllocationRequest>& request) { // // No mutex protection here, this is called with the cache locked. @@ -79,15 +71,15 @@ AllocatableObjectCache::TypeEntry::addAllocationRequest(const ObjectAllocationRe } bool -AllocatableObjectCache::TypeEntry::canTryAllocate(const AllocatableObjectEntryPtr& entry, bool fromRelease) +AllocatableObjectCache::TypeEntry::canTryAllocate(const shared_ptr<AllocatableObjectEntry>& entry, bool fromRelease) { // // No mutex protection here, this is called with the cache locked. // - list<ObjectAllocationRequestPtr>::iterator p = _requests.begin(); + auto p = _requests.begin(); while(p != _requests.end()) { - AllocationRequestPtr request = *p; + auto request = *p; try { if(request->isCanceled()) // If the request has been canceled, we just remove it. @@ -116,17 +108,18 @@ AllocatableObjectCache::TypeEntry::canTryAllocate(const AllocatableObjectEntryPt return false; } -AllocatableObjectCache::AllocatableObjectCache(const Ice::CommunicatorPtr& communicator) : +AllocatableObjectCache::AllocatableObjectCache(const shared_ptr<Ice::Communicator>& communicator) : _communicator(communicator) { } void -AllocatableObjectCache::add(const ObjectInfo& info, const ServerEntryPtr& parent) +AllocatableObjectCache::add(const ObjectInfo& info, const shared_ptr<ServerEntry>& parent) { - const Ice::Identity& id = info.proxy->ice_getIdentity(); + auto id = info.proxy->ice_getIdentity(); + + lock_guard lock(_mutex); - Lock sync(*this); if(getImpl(id)) { Ice::Error out(_communicator->getLogger()); @@ -134,7 +127,7 @@ AllocatableObjectCache::add(const ObjectInfo& info, const ServerEntryPtr& parent return; } - AllocatableObjectEntryPtr entry = new AllocatableObjectEntry(*this, info, parent); + auto entry = make_shared<AllocatableObjectEntry>(*this, info, parent); addImpl(id, entry); map<string, TypeEntry>::iterator p = _types.find(entry->getType()); @@ -151,11 +144,12 @@ AllocatableObjectCache::add(const ObjectInfo& info, const ServerEntryPtr& parent } } -AllocatableObjectEntryPtr +shared_ptr<AllocatableObjectEntry> AllocatableObjectCache::get(const Ice::Identity& id) const { - Lock sync(*this); - AllocatableObjectEntryPtr entry = getImpl(id); + lock_guard lock(_mutex); + + auto entry = getImpl(id); if(!entry) { throw ObjectNotRegisteredException(id); @@ -166,9 +160,10 @@ AllocatableObjectCache::get(const Ice::Identity& id) const void AllocatableObjectCache::remove(const Ice::Identity& id) { - AllocatableObjectEntryPtr entry; + shared_ptr<AllocatableObjectEntry> entry; { - Lock sync(*this); + lock_guard lock(_mutex); + entry = getImpl(id); if(!entry) { @@ -177,7 +172,7 @@ AllocatableObjectCache::remove(const Ice::Identity& id) } removeImpl(id); - map<string, TypeEntry>::iterator p = _types.find(entry->getType()); + auto p = _types.find(entry->getType()); assert(p != _types.end()); if(p->second.remove(entry)) { @@ -201,26 +196,27 @@ AllocatableObjectCache::remove(const Ice::Identity& id) } void -AllocatableObjectCache::allocateByType(const string& type, const ObjectAllocationRequestPtr& request) +AllocatableObjectCache::allocateByType(const string& type, const shared_ptr<ObjectAllocationRequest>& request) { - Lock sync(*this); - map<string, TypeEntry>::iterator p = _types.find(type); + lock_guard lock(_mutex); + + auto p = _types.find(type); if(p == _types.end()) { throw AllocationException("no allocatable objects with type `" + type + "' registered"); } - vector<AllocatableObjectEntryPtr> objects = p->second.getObjects(); + vector<shared_ptr<AllocatableObjectEntry>> objects = p->second.getObjects(); IceUtilInternal::shuffle(objects.begin(), objects.end()); // TODO: OPTIMIZE int allocatable = 0; try { - for(vector<AllocatableObjectEntryPtr>::const_iterator q = objects.begin(); q != objects.end(); ++q) + for(const auto& obj : objects) { - if((*q)->isEnabled()) + if(obj->isEnabled()) { ++allocatable; - if((*q)->tryAllocate(request)) + if(obj->tryAllocate(request)) { return; } @@ -239,13 +235,13 @@ AllocatableObjectCache::allocateByType(const string& type, const ObjectAllocatio } bool -AllocatableObjectCache::canTryAllocate(const AllocatableObjectEntryPtr& entry) +AllocatableObjectCache::canTryAllocate(const shared_ptr<AllocatableObjectEntry>& entry) { // // Notify the type entry that an object was released. // - Lock sync(*this); - map<string, TypeEntry>::iterator p = _types.find(entry->getType()); + lock_guard lock(_mutex); + auto p = _types.find(entry->getType()); if(p == _types.end()) { return false; @@ -255,7 +251,7 @@ AllocatableObjectCache::canTryAllocate(const AllocatableObjectEntryPtr& entry) AllocatableObjectEntry::AllocatableObjectEntry(AllocatableObjectCache& cache, const ObjectInfo& info, - const ServerEntryPtr& parent) : + const shared_ptr<ServerEntry>& parent) : Allocatable(true, parent), _cache(cache), _info(info), @@ -265,7 +261,7 @@ AllocatableObjectEntry::AllocatableObjectEntry(AllocatableObjectCache& cache, assert(_server); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> AllocatableObjectEntry::getProxy() const { return _info.proxy; @@ -290,15 +286,15 @@ AllocatableObjectEntry::isEnabled() const } void -AllocatableObjectEntry::allocated(const SessionIPtr& session) +AllocatableObjectEntry::allocated(const shared_ptr<SessionI>& session) { // // Add the object allocation to the session. The object will be // released once the session is destroyed. // - session->addAllocation(this); + session->addAllocation(shared_from_this()); - TraceLevelsPtr traceLevels = _cache.getTraceLevels(); + auto traceLevels = _cache.getTraceLevels(); if(traceLevels && traceLevels->object > 1) { Ice::Trace out(traceLevels->logger, traceLevels->objectCat); @@ -306,7 +302,7 @@ AllocatableObjectEntry::allocated(const SessionIPtr& session) << ")"; } - Glacier2::IdentitySetPrx identities = session->getGlacier2IdentitySet(); + auto identities = session->getGlacier2IdentitySet(); if(identities) { try @@ -328,16 +324,16 @@ AllocatableObjectEntry::allocated(const SessionIPtr& session) } void -AllocatableObjectEntry::released(const SessionIPtr& session) +AllocatableObjectEntry::released(const shared_ptr<SessionI>& session) { // // Remove the object allocation from the session. // - session->removeAllocation(this); + session->removeAllocation(shared_from_this()); - TraceLevelsPtr traceLevels = _cache.getTraceLevels(); + auto traceLevels = _cache.getTraceLevels(); - Glacier2::IdentitySetPrx identities = session->getGlacier2IdentitySet(); + auto identities = session->getGlacier2IdentitySet(); if(identities) { try @@ -368,9 +364,9 @@ AllocatableObjectEntry::released(const SessionIPtr& session) void AllocatableObjectEntry::destroy() { - SessionIPtr session; + shared_ptr<SessionI> session; { - Lock sync(*this); + lock_guard lock(_mutex); _destroyed = true; session = _session; } @@ -400,5 +396,5 @@ AllocatableObjectEntry::checkAllocatable() bool AllocatableObjectEntry::canTryAllocate() { - return _cache.canTryAllocate(this); + return _cache.canTryAllocate(static_pointer_cast<AllocatableObjectEntry>(shared_from_this())); } diff --git a/cpp/src/IceGrid/AllocatableObjectCache.h b/cpp/src/IceGrid/AllocatableObjectCache.h index 19f60f2ba11..bdae1d6037a 100644 --- a/cpp/src/IceGrid/AllocatableObjectCache.h +++ b/cpp/src/IceGrid/AllocatableObjectCache.h @@ -5,7 +5,6 @@ #ifndef ICE_GRID_ALLOCATABLEOBJECTCACHE_H #define ICE_GRID_ALLOCATABLEOBJECTCACHE_H -#include <IceUtil/Mutex.h> #include <Ice/CommunicatorF.h> #include <IceGrid/Cache.h> #include <IceGrid/Admin.h> @@ -14,77 +13,73 @@ namespace IceGrid { -class ServerEntry; -typedef IceUtil::Handle<ServerEntry> ServerEntryPtr; - class AllocatableObjectCache; +class ServerEntry; class AllocatableObjectEntry : public Allocatable { public: - AllocatableObjectEntry(AllocatableObjectCache&, const ObjectInfo&, const ServerEntryPtr&); - Ice::ObjectPrx getProxy() const; + AllocatableObjectEntry(AllocatableObjectCache&, const ObjectInfo&, const std::shared_ptr<ServerEntry>&); + std::shared_ptr<Ice::ObjectPrx> getProxy() const; std::string getType() const; bool canRemove(); - virtual bool isEnabled() const; - virtual void allocated(const SessionIPtr&); - virtual void released(const SessionIPtr&); - virtual bool canTryAllocate(); + bool isEnabled() const override; + void allocated(const std::shared_ptr<SessionI>&) override; + void released(const std::shared_ptr<SessionI>&) override; + bool canTryAllocate() override; void destroy(); - virtual void checkAllocatable(); + void checkAllocatable() override; private: AllocatableObjectCache& _cache; const ObjectInfo _info; - ServerEntryPtr _server; + std::shared_ptr<ServerEntry> _server; bool _destroyed; }; -typedef IceUtil::Handle<AllocatableObjectEntry> AllocatableObjectEntryPtr; class ObjectAllocationRequest : public AllocationRequest { public: - ObjectAllocationRequest(const SessionIPtr& session) : AllocationRequest(session) { } + ObjectAllocationRequest(const std::shared_ptr<SessionI>& session) : AllocationRequest(session) + { + } - virtual void response(const Ice::ObjectPrx&) = 0; - virtual void exception(const Ice::UserException&) = 0; + virtual void response(const std::shared_ptr<Ice::ObjectPrx>&) = 0; + virtual void exception(std::exception_ptr) = 0; private: - virtual void allocated(const AllocatablePtr& allocatable, const SessionIPtr& /*session*/) + void allocated(const std::shared_ptr<Allocatable>& allocatable, const std::shared_ptr<SessionI>&) override { - response(AllocatableObjectEntryPtr::dynamicCast(allocatable)->getProxy()); + response(std::dynamic_pointer_cast<AllocatableObjectEntry>(allocatable)->getProxy()); } - virtual void canceled(const Ice::UserException& ex) + void canceled(std::exception_ptr ex) override { exception(ex); } }; -typedef IceUtil::Handle<ObjectAllocationRequest> ObjectAllocationRequestPtr; - -class AdapterCache; class AllocatableObjectCache : public Cache<Ice::Identity, AllocatableObjectEntry> { public: - AllocatableObjectCache(const Ice::CommunicatorPtr&); + AllocatableObjectCache(const std::shared_ptr<Ice::Communicator>&); - void add(const ObjectInfo&, const ServerEntryPtr&); - AllocatableObjectEntryPtr get(const Ice::Identity&) const; + void add(const ObjectInfo&, const std::shared_ptr<ServerEntry>&); + std::shared_ptr<AllocatableObjectEntry> get(const Ice::Identity&) const; void remove(const Ice::Identity&); - void allocateByType(const std::string&, const ObjectAllocationRequestPtr&); - bool canTryAllocate(const AllocatableObjectEntryPtr&); + void allocateByType(const std::string&, const std::shared_ptr<ObjectAllocationRequest>&); + bool canTryAllocate(const std::shared_ptr<AllocatableObjectEntry>&); - const Ice::CommunicatorPtr& getCommunicator() const { return _communicator; } + const std::shared_ptr<Ice::Communicator>& getCommunicator() const { return _communicator; } private: @@ -92,23 +87,21 @@ private: { public: - TypeEntry(); - - void add(const AllocatableObjectEntryPtr&); - bool remove(const AllocatableObjectEntryPtr&); + void add(const std::shared_ptr<AllocatableObjectEntry>&); + bool remove(const std::shared_ptr<AllocatableObjectEntry>&); - void addAllocationRequest(const ObjectAllocationRequestPtr&); - bool canTryAllocate(const AllocatableObjectEntryPtr&, bool); + void addAllocationRequest(const std::shared_ptr<ObjectAllocationRequest>&); + bool canTryAllocate(const std::shared_ptr<AllocatableObjectEntry>&, bool); - const std::vector<AllocatableObjectEntryPtr>& getObjects() const { return _objects; } + const std::vector<std::shared_ptr<AllocatableObjectEntry>>& getObjects() const { return _objects; } private: - std::vector<AllocatableObjectEntryPtr> _objects; - std::list<ObjectAllocationRequestPtr> _requests; + std::vector<std::shared_ptr<AllocatableObjectEntry>> _objects; + std::list<std::shared_ptr<ObjectAllocationRequest>> _requests; }; - const Ice::CommunicatorPtr _communicator; + const std::shared_ptr<Ice::Communicator> _communicator; std::map<std::string, TypeEntry> _types; std::map<std::string, std::vector<Ice::Identity> > _allocatablesByType; }; diff --git a/cpp/src/IceGrid/Cache.h b/cpp/src/IceGrid/Cache.h index 9e32c561d41..e1ec7f5682f 100644 --- a/cpp/src/IceGrid/Cache.h +++ b/cpp/src/IceGrid/Cache.h @@ -5,29 +5,26 @@ #ifndef ICE_GRID_CACHE_H #define ICE_GRID_CACHE_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Shared.h> #include <IceGrid/Util.h> #include <IceGrid/TraceLevels.h> +#include <mutex> + namespace IceGrid { -class SynchronizationCallback : public virtual IceUtil::Shared +class SynchronizationCallback { public: - virtual void synchronized() = 0; - - virtual void synchronized(const Ice::Exception&) = 0; + virtual void synchronized(std::exception_ptr) = 0; }; -typedef IceUtil::Handle<SynchronizationCallback> SynchronizationCallbackPtr; template<typename Key, typename Value> -class Cache : public IceUtil::Monitor<IceUtil::Mutex> +class Cache { - typedef IceUtil::Handle<Value> ValuePtr; - typedef std::map<Key, ValuePtr> ValueMap; + using ValueType = std::shared_ptr<Value>; + using ValueMap = std::map<Key, ValueType>; public: @@ -35,39 +32,36 @@ public: { } - virtual - ~Cache() - { - } + virtual ~Cache() = default; bool has(const Key& key) const { - Lock sync(*this); - return getImpl(key); + std::lock_guard<std::mutex> lock(_mutex); + return getImpl(key) != nullptr; } void remove(const Key& key) { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); removeImpl(key); } void - setTraceLevels(const TraceLevelsPtr& traceLevels) + setTraceLevels(const std::shared_ptr<TraceLevels>& traceLevels) { _traceLevels = traceLevels; } - const TraceLevelsPtr& getTraceLevels() const { return _traceLevels; } + const std::shared_ptr<TraceLevels>& getTraceLevels() const { return _traceLevels; } protected: - virtual ValuePtr + virtual ValueType getImpl(const Key& key) const { - typename ValueMap::iterator p = const_cast<ValueMap&>(_entries).end(); + auto p = const_cast<ValueMap&>(_entries).end(); if(_entriesHint != p) { if(_entriesHint->first == key) @@ -88,22 +82,21 @@ protected: } else { - return 0; + return nullptr; } } - virtual ValuePtr - addImpl(const Key& key, const ValuePtr& entry) + virtual ValueType + addImpl(const Key& key, const ValueType& entry) { - typename ValueMap::value_type v(key, entry); - _entriesHint = _entries.insert(_entriesHint, v); + _entriesHint = _entries.insert(_entriesHint, { key, entry }); return entry; } virtual void removeImpl(const Key& key) { - typename ValueMap::iterator p = _entries.end(); + auto p = _entries.end(); if(_entriesHint != _entries.end()) { if(_entriesHint->first == key) @@ -129,23 +122,24 @@ protected: } } - TraceLevelsPtr _traceLevels; + std::shared_ptr<TraceLevels> _traceLevels; ValueMap _entries; typename ValueMap::iterator _entriesHint; + + mutable std::mutex _mutex; + std::condition_variable _condVar; }; template<typename T> class CacheByString : public Cache<std::string, T> { - typedef IceUtil::Handle<T> TPtr; - public: - virtual std::vector<std::string> + std::vector<std::string> getAll(const std::string& expr) { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - return getMatchingKeys<std::map<std::string,TPtr> >(Cache<std::string, T>::_entries, expr); + std::lock_guard<std::mutex> lock(Cache<std::string, T>::_mutex); + return getMatchingKeys<std::map<std::string, std::shared_ptr<T>>>(Cache<std::string, T>::_entries, expr); } }; diff --git a/cpp/src/IceGrid/Client.cpp b/cpp/src/IceGrid/Client.cpp index 627cb87e95d..555e0ee7e4a 100644 --- a/cpp/src/IceGrid/Client.cpp +++ b/cpp/src/IceGrid/Client.cpp @@ -4,12 +4,9 @@ #include <IceUtil/Options.h> #include <IceUtil/CtrlCHandler.h> -#include <IceUtil/Thread.h> #include <IceUtil/StringUtil.h> #include <Ice/ConsoleUtil.h> #include <Ice/UUID.h> -#include <IceUtil/Mutex.h> -#include <IceUtil/MutexPtrLock.h> #include <Ice/Ice.h> #include <IceGrid/Parser.h> #include <IceGrid/FileParserI.h> @@ -37,90 +34,46 @@ class Client; namespace { -IceUtil::Mutex* _staticMutex = 0; -Ice::CommunicatorPtr communicator; -IceGrid::ParserPtr parser; +mutex staticMutex; +shared_ptr<Ice::Communicator> communicator; +shared_ptr<IceGrid::Parser> parser; -class Init -{ -public: - - Init() - { - _staticMutex = new IceUtil::Mutex; - } - - ~Init() - { - delete _staticMutex; - _staticMutex = 0; - } }; -Init init; - -} - -class ReuseConnectionRouter : public Ice::Router +class ReuseConnectionRouter final : public Ice::Router { public: - ReuseConnectionRouter(const Ice::ObjectPrx& proxy) : _clientProxy(proxy) + ReuseConnectionRouter(shared_ptr<Ice::ObjectPrx> proxy) : _clientProxy(move(proxy)) { } - virtual Ice::ObjectPrx - getClientProxy(IceUtil::Optional<bool>& hasRoutingTable, const Ice::Current&) const + shared_ptr<Ice::ObjectPrx> + getClientProxy(IceUtil::Optional<bool>& hasRoutingTable, const Ice::Current&) const override { hasRoutingTable = false; return _clientProxy; } - virtual Ice::ObjectPrx - getServerProxy(const Ice::Current&) const - { - return 0; - } - - virtual void - addProxy(const Ice::ObjectPrx&, const Ice::Current&) + shared_ptr<Ice::ObjectPrx> + getServerProxy(const Ice::Current&) const override { + return nullptr; } - virtual Ice::ObjectProxySeq - addProxies(const Ice::ObjectProxySeq&, const Ice::Current&) + Ice::ObjectProxySeq + addProxies(Ice::ObjectProxySeq, const Ice::Current&) override { return Ice::ObjectProxySeq(); } private: - const Ice::ObjectPrx _clientProxy; + const shared_ptr<Ice::ObjectPrx> _clientProxy; }; int run(const Ice::StringSeq&); -// -// Callback for CtrlCHandler -// -static void -interruptCallback(int /*signal*/) -{ - IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_staticMutex); - if(parser) // If there's an interactive parser, notify the parser. - { - parser->interrupt(); - } - else - { - // - // Otherwise, destroy the communicator. - // - assert(communicator); - communicator->destroy(); - } -} - int #ifdef _WIN32 wmain(int argc, wchar_t* argv[]) @@ -138,16 +91,31 @@ main(int argc, char* argv[]) try { - Ice::CtrlCHandler ctrlCHandler; - Ice::PropertiesPtr defaultProps = Ice::createProperties(); - defaultProps->setProperty("IceGridAdmin.Server.Endpoints", "tcp -h localhost"); + IceUtil::CtrlCHandler ctrlCHandler; + auto defaultProps = Ice::createProperties(); + defaultProps->setProperty("IceGridAdmin.Server.Endpoints", "tcp -h 127.0.0.1"); + defaultProps->setProperty("IceGridAdmin.Server.ServerName", "127.0.0.1"); Ice::InitializationData id; id.properties = createProperties(args, defaultProps); id.properties->setProperty("Ice.Warn.Endpoints", "0"); Ice::CommunicatorHolder ich(id); communicator = ich.communicator(); - ctrlCHandler.setCallback(interruptCallback); + ctrlCHandler.setCallback([](int) { + lock_guard lg(staticMutex); + if(parser) // If there's an interactive parser, notify the parser. + { + parser->interrupt(); + } + else + { + // + // Otherwise, destroy the communicator. + // + assert(communicator); + communicator->destroy(); + } + }); try { @@ -224,7 +192,7 @@ getPassword(const string& prompt) } extern "C" ICE_LOCATOR_DISCOVERY_API Ice::Plugin* -createIceLocatorDiscovery(const Ice::CommunicatorPtr&, const string&, const Ice::StringSeq&); +createIceLocatorDiscovery(const shared_ptr<Ice::Communicator>&, const string&, const Ice::StringSeq&); int run(const Ice::StringSeq& args) @@ -275,9 +243,9 @@ run(const Ice::StringSeq& args) if(opts.isSet("server")) { - Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("IceGridAdmin.Server"); + auto adapter = communicator->createObjectAdapter("IceGridAdmin.Server"); adapter->activate(); - Ice::ObjectPrx proxy = adapter->add(new FileParserI, Ice::stringToIdentity("FileParser")); + auto proxy = adapter->add(make_shared<IceGrid::FileParserI>(), Ice::stringToIdentity("FileParser")); consoleOut << proxy << endl; communicator->waitForShutdown(); @@ -286,10 +254,9 @@ run(const Ice::StringSeq& args) if(opts.isSet("e")) { - vector<string> optargs = opts.argVec("e"); - for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) + for(const auto& arg : opts.argVec("e")) { - commands += *i + ";"; + commands += arg + ";"; } } debug = opts.isSet("debug"); @@ -334,15 +301,15 @@ run(const Ice::StringSeq& args) } } - Ice::PropertiesPtr properties = communicator->getProperties(); + auto properties = communicator->getProperties(); string replica = properties->getProperty("IceGridAdmin.Replica"); if(!opts.optArg("replica").empty()) { replica = opts.optArg("replica"); } - Glacier2::RouterPrx router; - IceGrid::AdminSessionPrx session; + shared_ptr<Glacier2::RouterPrx> router; + shared_ptr<IceGrid::AdminSessionPrx> session; int status = 0; try { @@ -356,7 +323,7 @@ run(const Ice::StringSeq& args) os << "Ice/LocatorFinder" << (ssl ? " -s" : ""); os << ":tcp -h \"" << host << "\" -p " << (port == 0 ? 4061 : port) << " -t " << timeout; os << ":ssl -h \"" << host << "\" -p " << (port == 0 ? 4062 : port) << " -t " << timeout; - Ice::LocatorFinderPrx finder = Ice::LocatorFinderPrx::uncheckedCast(communicator->stringToProxy(os.str())); + auto finder = Ice::uncheckedCast<Ice::LocatorFinderPrx>(communicator->stringToProxy(os.str())); try { communicator->setDefaultLocator(finder->getLocator()); @@ -381,18 +348,19 @@ run(const Ice::StringSeq& args) // to lookup for locator proxies. We destroy the plugin, once we have selected a // locator. // - Ice::PluginPtr pluginObj = createIceLocatorDiscovery(communicator, "IceGridAdmin.Discovery", Ice::StringSeq()); - IceLocatorDiscovery::PluginPtr plugin = IceLocatorDiscovery::PluginPtr::dynamicCast(pluginObj); + shared_ptr<Ice::Plugin> pluginObj(createIceLocatorDiscovery(communicator, "IceGridAdmin.Discovery", + Ice::StringSeq())); + auto plugin = dynamic_pointer_cast<IceLocatorDiscovery::Plugin>(pluginObj); plugin->initialize(); - vector<Ice::LocatorPrx> locators = plugin->getLocators(instanceName, IceUtil::Time::milliSeconds(300)); + auto locators = plugin->getLocators(instanceName, IceUtil::Time::milliSeconds(300)); if(locators.size() > 1) { consoleOut << "found " << locators.size() << " Ice locators:" << endl; unsigned int num = 0; - for(vector<Ice::LocatorPrx>::const_iterator p = locators.begin(); p != locators.end(); ++p) + for(const auto& locator : locators) { - consoleOut << ++num << ": proxy = `" << *p << "'" << endl; + consoleOut << ++num << ": proxy = `" << locator << "'" << endl; } num = 0; @@ -440,7 +408,7 @@ run(const Ice::StringSeq& args) try { // Use SSL if available. - router = Glacier2::RouterPrx::checkedCast(communicator->getDefaultRouter()->ice_preferSecure(true)); + router = Ice::checkedCast<Glacier2::RouterPrx>(communicator->getDefaultRouter()->ice_preferSecure(true)); if(!router) { consoleErr << args[0] << ": configured router is not a Glacier2 router" << endl; @@ -455,7 +423,7 @@ run(const Ice::StringSeq& args) if(ssl) { - session = IceGrid::AdminSessionPrx::uncheckedCast(router->createSessionFromSecureConnection()); + session = Ice::uncheckedCast<IceGrid::AdminSessionPrx>(router->createSessionFromSecureConnection()); if(!session) { consoleErr << args[0] @@ -488,7 +456,7 @@ run(const Ice::StringSeq& args) #endif } - session = IceGrid::AdminSessionPrx::uncheckedCast(router->createSession(id, password)); + session = Ice::uncheckedCast<IceGrid::AdminSessionPrx>(router->createSession(id, password)); fill(password.begin(), password.end(), '\0'); // Zero the password string. if(!session) @@ -528,11 +496,11 @@ run(const Ice::StringSeq& args) // no need to go further. Otherwise, we get the proxy of local registry // proxy. // - IceGrid::LocatorPrx locator; - IceGrid::RegistryPrx localRegistry; + shared_ptr<IceGrid::LocatorPrx> locator; + shared_ptr<IceGrid::RegistryPrx> localRegistry; try { - locator = IceGrid::LocatorPrx::checkedCast(communicator->getDefaultLocator()); + locator = Ice::checkedCast<IceGrid::LocatorPrx>(communicator->getDefaultLocator()); if(!locator) { consoleErr << args[0] << ": configured locator is not an IceGrid locator" << endl; @@ -546,7 +514,7 @@ run(const Ice::StringSeq& args) return 1; } - IceGrid::RegistryPrx registry; + shared_ptr<IceGrid::RegistryPrx> registry; if(localRegistry->ice_getIdentity() == registryId) { registry = localRegistry; @@ -559,7 +527,7 @@ run(const Ice::StringSeq& args) try { - registry = IceGrid::RegistryPrx::checkedCast(locator->findObjectById(registryId)); + registry = Ice::checkedCast<IceGrid::RegistryPrx>(locator->findObjectById(registryId)); if(!registry) { consoleErr << args[0] << ": could not contact an IceGrid registry" << endl; @@ -603,9 +571,9 @@ run(const Ice::StringSeq& args) // if(registry->ice_getIdentity() == localRegistry->ice_getIdentity()) { - Ice::ObjectAdapterPtr colloc = communicator->createObjectAdapter(""); // colloc-only adapter - communicator->setDefaultRouter(Ice::RouterPrx::uncheckedCast( - colloc->addWithUUID(new ReuseConnectionRouter(locator)))); + auto colloc = communicator->createObjectAdapter(""); // colloc-only adapter + communicator->setDefaultRouter(Ice::uncheckedCast<Ice::RouterPrx>( + colloc->addWithUUID(make_shared<ReuseConnectionRouter>(locator)))); registry = registry->ice_router(communicator->getDefaultRouter()); } @@ -663,12 +631,12 @@ run(const Ice::StringSeq& args) if(acmTimeout > 0) { - session->ice_getConnection()->setACM(acmTimeout, IceUtil::None, Ice::ICE_ENUM(ACMHeartbeat, HeartbeatAlways)); + session->ice_getConnection()->setACM(acmTimeout, IceUtil::None, Ice::ACMHeartbeat::HeartbeatAlways); } { - IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_staticMutex); - parser = IceGrid::Parser::createParser(communicator, session, session->getAdmin(), commands.empty()); + lock_guard lock(staticMutex); + parser = make_shared<IceGrid::Parser>(communicator, session, session->getAdmin(), commands.empty()); } if(!commands.empty()) // Commands were given diff --git a/cpp/src/IceGrid/Database.cpp b/cpp/src/IceGrid/Database.cpp index 4abfe9e436d..697e7fd8e70 100644 --- a/cpp/src/IceGrid/Database.cpp +++ b/cpp/src/IceGrid/Database.cpp @@ -4,7 +4,6 @@ #include <IceUtil/StringUtil.h> #include <IceUtil/Random.h> -#include <IceUtil/Functional.h> #include <Ice/LoggerUtil.h> #include <Ice/Communicator.h> #include <Ice/ObjectAdapter.h> @@ -25,11 +24,11 @@ using namespace std; using namespace IceGrid; -typedef IceDB::ReadWriteCursor<string, ApplicationInfo, IceDB::IceContext, Ice::OutputStream> ApplicationMapRWCursor; -typedef IceDB::ReadOnlyCursor<string, AdapterInfo, IceDB::IceContext, Ice::OutputStream> AdapterMapROCursor; -typedef IceDB::Cursor<string, string, IceDB::IceContext, Ice::OutputStream> AdaptersByGroupMapCursor; -typedef IceDB::ReadOnlyCursor<string, Ice::Identity, IceDB::IceContext, Ice::OutputStream> ObjectsByTypeMapROCursor; -typedef IceDB::ReadOnlyCursor<Ice::Identity, ObjectInfo, IceDB::IceContext, Ice::OutputStream> ObjectsMapROCursor; +using ApplicationMapRWCursor = IceDB::ReadWriteCursor<string, ApplicationInfo, IceDB::IceContext, Ice::OutputStream>; +using AdapterMapROCursor = IceDB::ReadOnlyCursor<string, AdapterInfo, IceDB::IceContext, Ice::OutputStream>; +using AdaptersByGroupMapCursor = IceDB::Cursor<string, string, IceDB::IceContext, Ice::OutputStream>; +using ObjectsByTypeMapROCursor = IceDB::ReadOnlyCursor<string, Ice::Identity, IceDB::IceContext, Ice::OutputStream>; +using ObjectsMapROCursor = IceDB::ReadOnlyCursor<Ice::Identity, ObjectInfo, IceDB::IceContext, Ice::OutputStream>; namespace { @@ -43,14 +42,6 @@ const string internalObjectsDbName = "internal-objects"; const string internalObjectsByTypeDbName = "internal-objectsByType"; const string serialsDbName = "serials"; -struct ObjectLoadCI : binary_function<pair<Ice::ObjectPrx, float>&, pair<Ice::ObjectPrx, float>&, bool> -{ - bool operator()(const pair<Ice::ObjectPrx, float>& lhs, const pair<Ice::ObjectPrx, float>& rhs) - { - return lhs.second < rhs.second; - } -}; - template<typename K, typename V, typename C, typename H> vector<V> toVector(const IceDB::ReadOnlyTxn& txn, const IceDB::Dbi<K, V, C, H>& m) { @@ -82,7 +73,7 @@ toMap(const IceDB::Txn& txn, const IceDB::Dbi<K, V, C, H>& d) } void -logError(const Ice::CommunicatorPtr& com, const IceDB::LMDBException& ex) +logError(const shared_ptr<Ice::Communicator>& com, const IceDB::LMDBException& ex) { Ice::Error error(com->getLogger()); error << "LMDB error: " << ex; @@ -91,8 +82,8 @@ logError(const Ice::CommunicatorPtr& com, const IceDB::LMDBException& ex) void filterAdapterInfos(const string& filter, const string& replicaGroupId, - const RegistryPluginFacadeIPtr& pluginFacade, - const Ice::ConnectionPtr& con, + const shared_ptr<RegistryPluginFacadeI>& pluginFacade, + const shared_ptr<Ice::Connection>& con, const Ice::Context& ctx, AdapterInfoSeq& infos) { @@ -101,7 +92,7 @@ filterAdapterInfos(const string& filter, return; } - vector<ReplicaGroupFilterPtr> filters = pluginFacade->getReplicaGroupFilters(filter); + auto filters = pluginFacade->getReplicaGroupFilters(filter); if(filters.empty()) { return; @@ -109,25 +100,25 @@ filterAdapterInfos(const string& filter, Ice::StringSeq adapterIds; adapterIds.reserve(infos.size()); - for(vector<AdapterInfo>::const_iterator p = infos.begin(); p != infos.end(); ++p) + for(const auto& info : infos) { - adapterIds.push_back(p->id); + adapterIds.push_back(info.id); } - for(vector<ReplicaGroupFilterPtr>::const_iterator q = filters.begin(); q != filters.end(); ++q) + for(const auto& f : filters) { - adapterIds = (*q)->filter(replicaGroupId, adapterIds, con, ctx); + adapterIds = f->filter(replicaGroupId, adapterIds, con, ctx); } vector<AdapterInfo> filteredAdpts; filteredAdpts.reserve(infos.size()); - for(Ice::StringSeq::const_iterator q = adapterIds.begin(); q != adapterIds.end(); ++q) + for(const auto& id : adapterIds) { - for(vector<AdapterInfo>::const_iterator r = infos.begin(); r != infos.end(); ++r) + for(const auto& info : infos) { - if(*q == r->id) + if(id == info.id) { - filteredAdpts.push_back(*r); + filteredAdpts.push_back(info); break; } } @@ -187,10 +178,25 @@ findByType(const IceDB::ReadOnlyTxn& txn, } -Database::Database(const Ice::ObjectAdapterPtr& registryAdapter, - const IceStorm::TopicManagerPrx& topicManager, +shared_ptr<Database> +Database::create(const shared_ptr<Ice::ObjectAdapter>& registryAdapter, + const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, + const string& instanceName, + const shared_ptr<TraceLevels>& traceLevels, + const RegistryInfo& info, + bool readonly) +{ + shared_ptr<Database> db(new Database(registryAdapter, topicManager, instanceName, traceLevels, info, readonly)); + + db->_pluginFacade->setDatabase(db); + + return db; +} + +Database::Database(const shared_ptr<Ice::ObjectAdapter>& registryAdapter, + const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, const string& instanceName, - const TraceLevelsPtr& traceLevels, + const shared_ptr<TraceLevels>& traceLevels, const RegistryInfo& info, bool readonly) : _communicator(registryAdapter->getCommunicator()), @@ -209,8 +215,8 @@ Database::Database(const Ice::ObjectAdapterPtr& registryAdapter, _dbLock(_communicator->getProperties()->getProperty("IceGrid.Registry.LMDB.Path") + "/icedb.lock"), _env(_communicator->getProperties()->getProperty("IceGrid.Registry.LMDB.Path"), 8, IceDB::getMapSize(_communicator->getProperties()->getPropertyAsInt("IceGrid.Registry.LMDB.MapSize"))), - _pluginFacade(RegistryPluginFacadeIPtr::dynamicCast(getRegistryPluginFacade())), - _lock(0) + _pluginFacade(dynamic_pointer_cast<RegistryPluginFacadeI>(getRegistryPluginFacade())), + _lock(nullptr) { IceDB::ReadWriteTxn txn(_env); @@ -257,13 +263,13 @@ Database::Database(const Ice::ObjectAdapterPtr& registryAdapter, _objectCache.setTraceLevels(_traceLevels); _allocatableObjectCache.setTraceLevels(_traceLevels); - _nodeObserverTopic = new NodeObserverTopic(_topicManager, _internalAdapter); - _registryObserverTopic = new RegistryObserverTopic(_topicManager); + _nodeObserverTopic = NodeObserverTopic::create(_topicManager, _internalAdapter); + _registryObserverTopic = make_shared<RegistryObserverTopic>(_topicManager); _serverCache.setNodeObserverTopic(_nodeObserverTopic); // Set all serials to 1 if they have not yet been set. - Ice::Long serial; + long long serial; if(!_serials.get(txn, applicationsDbName, serial)) { _serials.put(txn, applicationsDbName, 1); @@ -277,18 +283,16 @@ Database::Database(const Ice::ObjectAdapterPtr& registryAdapter, _serials.put(txn, objectsDbName, 1); } - _applicationObserverTopic = - new ApplicationObserverTopic(_topicManager, toMap(txn, _applications), getSerial(txn, applicationsDbName)); - _adapterObserverTopic = - new AdapterObserverTopic(_topicManager, toMap(txn, _adapters), getSerial(txn, adaptersDbName)); - _objectObserverTopic = - new ObjectObserverTopic(_topicManager, toMap(txn, _objects), getSerial(txn, objectsDbName)); + _applicationObserverTopic = make_shared<ApplicationObserverTopic>(_topicManager, toMap(txn, _applications), + getSerial(txn, applicationsDbName)); + _adapterObserverTopic = make_shared<AdapterObserverTopic>(_topicManager, toMap(txn, _adapters), + getSerial(txn, adaptersDbName)); + _objectObserverTopic = make_shared<ObjectObserverTopic>(_topicManager, toMap(txn, _objects), + getSerial(txn, objectsDbName)); txn.commit(); _registryObserverTopic->registryUp(info); - - _pluginFacade->setDatabase(this); } std::string @@ -300,7 +304,7 @@ Database::getInstanceName() const void Database::destroy() { - _pluginFacade->setDatabase(0); + _pluginFacade->setDatabase(nullptr); _registryObserverTopic->destroy(); _nodeObserverTopic->destroy(); @@ -309,31 +313,31 @@ Database::destroy() _objectObserverTopic->destroy(); } -ObserverTopicPtr +shared_ptr<ObserverTopic> Database::getObserverTopic(TopicName name) const { switch(name) { - case RegistryObserverTopicName: + case TopicName::RegistryObserver: return _registryObserverTopic; - case NodeObserverTopicName: + case TopicName::NodeObserver: return _nodeObserverTopic; - case ApplicationObserverTopicName: + case TopicName::ApplicationObserver: return _applicationObserverTopic; - case AdapterObserverTopicName: + case TopicName::AdapterObserver: return _adapterObserverTopic; - case ObjectObserverTopicName: + case TopicName::ObjectObserver: return _objectObserverTopic; default: break; } - return 0; + return nullptr; } void Database::checkSessionLock(AdminSessionI* session) { - if(_lock != 0 && session != _lock) + if(_lock != nullptr && session != _lock) { throw AccessDeniedException(_lockUserId); // Lock held by another session. } @@ -342,13 +346,13 @@ Database::checkSessionLock(AdminSessionI* session) int Database::lock(AdminSessionI* session, const string& userId) { - Lock sync(*this); + lock_guard lock(_mutex); - if(_lock != 0 && session != _lock) + if(_lock != nullptr && session != _lock) { throw AccessDeniedException(_lockUserId); // Lock held by another session. } - assert(_lock == 0 || _lock == session); + assert(_lock == nullptr || _lock == session); _lock = session; _lockUserId = userId; @@ -359,23 +363,24 @@ Database::lock(AdminSessionI* session, const string& userId) void Database::unlock(AdminSessionI* session) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_lock != session) { throw AccessDeniedException(); } - _lock = 0; + _lock = nullptr; _lockUserId.clear(); } void -Database::syncApplications(const ApplicationInfoSeq& newApplications, Ice::Long dbSerial) +Database::syncApplications(const ApplicationInfoSeq& newApplications, long long dbSerial) { assert(dbSerial != 0); int serial = 0; { - Lock sync(*this); + lock_guard lock(_mutex); map<string, ApplicationInfo> oldApplications; try @@ -433,7 +438,10 @@ Database::syncApplications(const ApplicationInfoSeq& newApplications, Ice::Long } } - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync)); + for(const auto& entry : entries) + { + entry->sync(); + } if(_traceLevels->application > 0) { @@ -447,21 +455,21 @@ Database::syncApplications(const ApplicationInfoSeq& newApplications, Ice::Long } void -Database::syncAdapters(const AdapterInfoSeq& adapters, Ice::Long dbSerial) +Database::syncAdapters(const AdapterInfoSeq& adapters, long long dbSerial) { assert(dbSerial != 0); int serial = 0; { - Lock sync(*this); + lock_guard lock(_mutex); try { IceDB::ReadWriteTxn txn(_env); _adapters.clear(txn); _adaptersByGroupId.clear(txn); - for(AdapterInfoSeq::const_iterator r = adapters.begin(); r != adapters.end(); ++r) + for(const auto& adapter : adapters) { - addAdapter(txn, *r); + addAdapter(txn, adapter); } dbSerial = updateSerial(txn, adaptersDbName, dbSerial); @@ -489,21 +497,21 @@ Database::syncAdapters(const AdapterInfoSeq& adapters, Ice::Long dbSerial) } void -Database::syncObjects(const ObjectInfoSeq& objects, Ice::Long dbSerial) +Database::syncObjects(const ObjectInfoSeq& objects, long long dbSerial) { assert(dbSerial != 0); int serial = 0; { - Lock sync(*this); + lock_guard lock(_mutex); try { IceDB::ReadWriteTxn txn(_env); _objects.clear(txn); _objectsByType.clear(txn); - for(ObjectInfoSeq::const_iterator q = objects.begin(); q != objects.end(); ++q) + for(const auto& obj : objects) { - addObject(txn, *q, false); + addObject(txn, obj, false); } dbSerial = updateSerial(txn, objectsDbName, dbSerial); @@ -527,7 +535,7 @@ Database::syncObjects(const ObjectInfoSeq& objects, Ice::Long dbSerial) } ApplicationInfoSeq -Database::getApplications(Ice::Long& serial) +Database::getApplications(long long& serial) { try { @@ -544,7 +552,7 @@ Database::getApplications(Ice::Long& serial) } AdapterInfoSeq -Database::getAdapters(Ice::Long& serial) +Database::getAdapters(long long& serial) { try { @@ -561,7 +569,7 @@ Database::getAdapters(Ice::Long& serial) } ObjectInfoSeq -Database::getObjects(Ice::Long& serial) +Database::getObjects(long long& serial) { try { @@ -585,7 +593,7 @@ Database::getSerials() const } void -Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ice::Long dbSerial) +Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, long long dbSerial) { assert(dbSerial != 0 || _master); @@ -593,10 +601,10 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ic ServerEntrySeq entries; try { - Lock sync(*this); + unique_lock lock(_mutex); checkSessionLock(session); - waitForUpdate(info.descriptor.name); + waitForUpdate(lock, info.descriptor.name); IceDB::ReadWriteTxn txn(_env); @@ -614,7 +622,11 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ic load(helper, entries, info.uuid, info.revision); startUpdating(info.descriptor.name, info.uuid, info.revision); - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync)); + for(const auto& entry : entries) + { + entry->sync(); + } + serial = _applicationObserverTopic->applicationAdded(dbSerial, info); } catch(const IceDB::KeyTooLongException& ex) @@ -634,7 +646,8 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ic // for the nodes to start the servers. // { - Lock sync(*this); + lock_guard lock(_mutex); + vector<UpdateInfo>::iterator p = find(_updating.begin(), _updating.end(), info.descriptor.name); assert(p != _updating.end()); p->markUpdated(); @@ -660,7 +673,7 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ic { try { - Lock sync(*this); + lock_guard lock(_mutex); entries.clear(); unload(ApplicationHelper(_communicator, info.descriptor), entries); @@ -668,7 +681,11 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ic dbSerial = removeApplication(info.descriptor.name, txn); txn.commit(); - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync)); + for(const auto& entry : entries) + { + entry->sync(); + } + serial = _applicationObserverTopic->applicationRemoved(dbSerial, info.descriptor.name); } catch(const DeploymentException& ex) @@ -682,7 +699,10 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session, Ic } _applicationObserverTopic->waitForSyncedSubscribers(serial); - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::waitForSyncNoThrow)); + for(const auto& entry : entries) + { + entry->waitForSyncNoThrow(); + } finishUpdating(info.descriptor.name); throw; } @@ -704,14 +724,14 @@ Database::updateApplication(const ApplicationUpdateInfo& updt, bool noRestart, A ApplicationInfo oldApp; ApplicationUpdateInfo update = updt; - IceInternal::UniquePtr<ApplicationHelper> previous; - IceInternal::UniquePtr<ApplicationHelper> helper; + unique_ptr<ApplicationHelper> previous; + unique_ptr<ApplicationHelper> helper; try { - Lock sync(*this); + unique_lock lock(_mutex); checkSessionLock(session); - waitForUpdate(update.descriptor.name); + waitForUpdate(lock, update.descriptor.name); IceDB::ReadOnlyTxn txn(_env); @@ -725,8 +745,8 @@ Database::updateApplication(const ApplicationUpdateInfo& updt, bool noRestart, A update.revision = oldApp.revision + 1; } - previous.reset(new ApplicationHelper(_communicator, oldApp.descriptor)); - helper.reset(new ApplicationHelper(_communicator, previous->update(update.descriptor), true)); + previous = make_unique<ApplicationHelper>(_communicator, oldApp.descriptor); + helper = make_unique<ApplicationHelper>(_communicator, previous->update(update.descriptor), true); startUpdating(update.descriptor.name, oldApp.uuid, oldApp.revision + 1); } @@ -736,7 +756,7 @@ Database::updateApplication(const ApplicationUpdateInfo& updt, bool noRestart, A throw; } - finishApplicationUpdate(update, oldApp, *previous, *helper, session, noRestart, dbSerial); + finishApplicationUpdate(update, oldApp, *previous.get(), *helper.get(), session, noRestart, dbSerial); } void @@ -746,14 +766,14 @@ Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, bool n ApplicationUpdateInfo update; ApplicationInfo oldApp; - IceInternal::UniquePtr<ApplicationHelper> previous; - IceInternal::UniquePtr<ApplicationHelper> helper; + unique_ptr<ApplicationHelper> previous; + unique_ptr<ApplicationHelper> helper; try { - Lock sync(*this); + unique_lock lock(_mutex); checkSessionLock(session); - waitForUpdate(newDesc.name); + waitForUpdate(lock, newDesc.name); IceDB::ReadOnlyTxn txn(_env); @@ -762,8 +782,8 @@ Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, bool n throw ApplicationNotExistException(newDesc.name); } - previous.reset(new ApplicationHelper(_communicator, oldApp.descriptor)); - helper.reset(new ApplicationHelper(_communicator, newDesc, true)); + previous = make_unique<ApplicationHelper>(_communicator, oldApp.descriptor); + helper = make_unique<ApplicationHelper>(_communicator, newDesc, true); update.updateTime = IceUtil::Time::now().toMilliSeconds(); update.updateUser = _lockUserId; @@ -778,7 +798,7 @@ Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, bool n throw; } - finishApplicationUpdate(update, oldApp, *previous, *helper, session, noRestart); + finishApplicationUpdate(update, oldApp, *previous.get(), *helper.get(), session, noRestart); } void @@ -791,15 +811,15 @@ Database::instantiateServer(const string& application, ApplicationUpdateInfo update; ApplicationInfo oldApp; - IceInternal::UniquePtr<ApplicationHelper> previous; - IceInternal::UniquePtr<ApplicationHelper> helper; + unique_ptr<ApplicationHelper> previous; + unique_ptr<ApplicationHelper> helper; try { - Lock sync(*this); + unique_lock lock(_mutex); checkSessionLock(session); - waitForUpdate(application); + waitForUpdate(lock, application); IceDB::ReadOnlyTxn txn(_env); @@ -808,8 +828,8 @@ Database::instantiateServer(const string& application, throw ApplicationNotExistException(application); } - previous.reset(new ApplicationHelper(_communicator, oldApp.descriptor)); - helper.reset(new ApplicationHelper(_communicator, previous->instantiateServer(node, instance), true)); + previous = make_unique<ApplicationHelper>(_communicator, oldApp.descriptor); + helper = make_unique<ApplicationHelper>(_communicator, previous->instantiateServer(node, instance), true); update.updateTime = IceUtil::Time::now().toMilliSeconds(); update.updateUser = _lockUserId; @@ -824,7 +844,7 @@ Database::instantiateServer(const string& application, throw; } - finishApplicationUpdate(update, oldApp, *previous, *helper, session, true); + finishApplicationUpdate(update, oldApp, *previous.get(), *helper.get(), session, true); } void @@ -836,10 +856,10 @@ Database::removeApplication(const string& name, AdminSessionI* session, Ice::Lon int serial = 0; // Initialize to prevent warning. try { - Lock sync(*this); + unique_lock lock(_mutex); checkSessionLock(session); - waitForUpdate(name); + waitForUpdate(lock, name); ApplicationInfo appInfo; @@ -871,7 +891,11 @@ Database::removeApplication(const string& name, AdminSessionI* session, Ice::Lon startUpdating(name, appInfo.uuid, appInfo.revision); - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync)); + for(const auto& entry : entries) + { + entry->sync(); + } + serial = _applicationObserverTopic->applicationRemoved(dbSerial, name); } catch(const IceDB::LMDBException& ex) @@ -884,7 +908,10 @@ Database::removeApplication(const string& name, AdminSessionI* session, Ice::Lon if(_master) { - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::waitForSyncNoThrow)); + for(const auto& entry : entries) + { + entry->waitForSyncNoThrow(); + } } if(_traceLevels->application > 0) @@ -917,20 +944,20 @@ Database::getAllApplications(const string& expression) } void -Database::waitForApplicationUpdate(const AMD_NodeSession_waitForApplicationUpdatePtr& cb, - const string& uuid, - int revision) +Database::waitForApplicationUpdate(const string& uuid, + int revision, + function<void()> response, function<void(exception_ptr)> exception) { - Lock sync(*this); + lock_guard lock(_mutex); vector<UpdateInfo>::iterator p = find(_updating.begin(), _updating.end(), make_pair(uuid, revision)); if(p != _updating.end() && !p->updated) { - p->cbs.push_back(cb); + p->cbs.push_back({ response, exception }); } else { - cb->ice_response(); + response(); } } @@ -940,7 +967,7 @@ Database::getNodeCache() return _nodeCache; } -NodeEntryPtr +shared_ptr<NodeEntry> Database::getNode(const string& name, bool create) const { return _nodeCache.get(name, create); @@ -952,7 +979,7 @@ Database::getReplicaCache() return _replicaCache; } -ReplicaEntryPtr +shared_ptr<ReplicaEntry> Database::getReplica(const string& name) const { return _replicaCache.get(name); @@ -964,7 +991,7 @@ Database::getServerCache() return _serverCache; } -ServerEntryPtr +shared_ptr<ServerEntry> Database::getServer(const string& id) const { return _serverCache.get(id); @@ -976,21 +1003,21 @@ Database::getAllocatableObjectCache() return _allocatableObjectCache; } -AllocatableObjectEntryPtr +shared_ptr<AllocatableObjectEntry> Database::getAllocatableObject(const Ice::Identity& id) const { return _allocatableObjectCache.get(id); } void -Database::setAdapterDirectProxy(const string& adapterId, const string& replicaGroupId, const Ice::ObjectPrx& proxy, - Ice::Long dbSerial) +Database::setAdapterDirectProxy(const string& adapterId, const string& replicaGroupId, + const shared_ptr<Ice::ObjectPrx>& proxy, long long dbSerial) { assert(dbSerial != 0 || _master); int serial = 0; // Initialize to prevent warning. { - Lock sync(*this); + lock_guard lock(_mutex); if(_adapterCache.has(adapterId)) { throw AdapterExistsException(adapterId); @@ -1003,10 +1030,7 @@ Database::setAdapterDirectProxy(const string& adapterId, const string& replicaGr "can be member of this replica group"); } - AdapterInfo info; - info.id = adapterId; - info.proxy = proxy; - info.replicaGroupId = replicaGroupId; + AdapterInfo info = { adapterId, proxy, replicaGroupId }; bool updated = false; try @@ -1077,8 +1101,9 @@ Database::setAdapterDirectProxy(const string& adapterId, const string& replicaGr _adapterObserverTopic->waitForSyncedSubscribers(serial); } -Ice::ObjectPrx -Database::getAdapterDirectProxy(const string& id, const Ice::EncodingVersion& encoding, const Ice::ConnectionPtr& con, +shared_ptr<Ice::ObjectPrx> +Database::getAdapterDirectProxy(const string& id, const Ice::EncodingVersion& encoding, + const shared_ptr<Ice::Connection>& con, const Ice::Context& ctx) { IceDB::ReadOnlyTxn txn(_env); @@ -1119,10 +1144,10 @@ Database::removeAdapter(const string& adapterId) int serial = 0; // Initialize to prevent warning. { - Lock sync(*this); + lock_guard lock(_mutex); if(_adapterCache.has(adapterId)) { - AdapterEntryPtr adpt = _adapterCache.get(adapterId); + auto adpt = _adapterCache.get(adapterId); throw DeploymentException("removing adapter `" + adapterId + "' is not allowed:\n" + "the adapter was added with the application descriptor `" + adpt->getApplication() + "'"); @@ -1188,16 +1213,16 @@ Database::removeAdapter(const string& adapterId) _adapterObserverTopic->waitForSyncedSubscribers(serial); } -AdapterPrx +shared_ptr<AdapterPrx> Database::getAdapterProxy(const string& adapterId, const string& replicaGroupId, bool upToDate) { - Lock sync(*this); // Make sure this isn't call during an update. + lock_guard lock(_mutex); // Make sure this isn't call during an update. return _adapterCache.get(adapterId)->getProxy(replicaGroupId, upToDate); } void Database::getLocatorAdapterInfo(const string& id, - const Ice::ConnectionPtr& connection, + const shared_ptr<Ice::Connection>& connection, const Ice::Context& context, LocatorAdapterInfoSeq& adpts, int& count, @@ -1207,13 +1232,13 @@ Database::getLocatorAdapterInfo(const string& id, { string filter; { - Lock sync(*this); // Make sure this isn't call during an update. + lock_guard lock(_mutex); // Make sure this isn't called during an update. _adapterCache.get(id)->getLocatorAdapterInfo(adpts, count, replicaGroup, roundRobin, filter, excludes); } if(_pluginFacade->hasReplicaGroupFilters() && !adpts.empty()) { - vector<ReplicaGroupFilterPtr> filters = _pluginFacade->getReplicaGroupFilters(filter); + auto filters = _pluginFacade->getReplicaGroupFilters(filter); if(!filters.empty()) { Ice::StringSeq adapterIds; @@ -1222,9 +1247,9 @@ Database::getLocatorAdapterInfo(const string& id, adapterIds.push_back(q->id); } - for(vector<ReplicaGroupFilterPtr>::const_iterator q = filters.begin(); q != filters.end(); ++q) + for(const auto& f : filters) { - adapterIds = (*q)->filter(id, adapterIds, connection, context); + adapterIds = f->filter(id, adapterIds, connection, context); } LocatorAdapterInfoSeq filteredAdpts; @@ -1247,10 +1272,10 @@ Database::getLocatorAdapterInfo(const string& id, bool Database::addAdapterSyncCallback(const string& id, - const SynchronizationCallbackPtr& callback, + const shared_ptr<SynchronizationCallback>& callback, const std::set<std::string>& excludes) { - Lock sync(*this); // Make sure this isn't call during an update. + lock_guard lock(_mutex); // Make sure this isn't call during an update. return _adapterCache.get(id)->addSyncCallback(callback, excludes); } @@ -1262,10 +1287,10 @@ Database::getAdapterInfo(const string& id) // server, if that's the case we get the adapter proxy from the // server. // - GetAdapterInfoResultPtr result; + shared_ptr<GetAdapterInfoResult> result; try { - Lock sync(*this); // Make sure this isn't call during an update. + lock_guard lock(_mutex); // Make sure this isn't call during an update. result = _adapterCache.get(id)->getAdapterInfoAsync(); } catch(const AdapterNotExistException&) @@ -1304,7 +1329,7 @@ Database::getAdapterInfo(const string& id) } AdapterInfoSeq -Database::getFilteredAdapterInfo(const string& id, const Ice::ConnectionPtr& con, const Ice::Context& ctx) +Database::getFilteredAdapterInfo(const string& id, const shared_ptr<Ice::Connection>& con, const Ice::Context& ctx) { // // First we check if the given adapter id is associated to a @@ -1314,13 +1339,13 @@ Database::getFilteredAdapterInfo(const string& id, const Ice::ConnectionPtr& con try { AdapterInfoSeq infos; - ReplicaGroupEntryPtr replicaGroup; + shared_ptr<ReplicaGroupEntry> replicaGroup; { - Lock sync(*this); // Make sure this isn't call during an update. + lock_guard lock(_mutex); // Make sure this isn't call during an update. - AdapterEntryPtr entry = _adapterCache.get(id); + auto entry = _adapterCache.get(id); infos = entry->getAdapterInfoNoEndpoints(); - replicaGroup = ReplicaGroupEntryPtr::dynamicCast(entry); + replicaGroup = dynamic_pointer_cast<ReplicaGroupEntry>(entry); } if(replicaGroup) { @@ -1365,8 +1390,8 @@ Database::getAdapterServer(const string& id) const { try { - Lock sync(*this); // Make sure this isn't call during an update. - ServerAdapterEntryPtr adapter = ServerAdapterEntryPtr::dynamicCast(_adapterCache.get(id)); + lock_guard lock(_mutex); // Make sure this isn't call during an update. + auto adapter = dynamic_pointer_cast<ServerAdapterEntry>(_adapterCache.get(id)); if(adapter) { return adapter->getServerId(); @@ -1383,7 +1408,7 @@ Database::getAdapterApplication(const string& id) const { try { - Lock sync(*this); // Make sure this isn't call during an update. + lock_guard lock(_mutex); // Make sure this isn't call during an update. return _adapterCache.get(id)->getApplication(); } catch(const AdapterNotExistException&) @@ -1397,8 +1422,8 @@ Database::getAdapterNode(const string& id) const { try { - Lock sync(*this); // Make sure this isn't call during an update. - ServerAdapterEntryPtr adapter = ServerAdapterEntryPtr::dynamicCast(_adapterCache.get(id)); + lock_guard lock(_mutex); // Make sure this isn't call during an update. + auto adapter = dynamic_pointer_cast<ServerAdapterEntry>(_adapterCache.get(id)); if(adapter) { return adapter->getNodeName(); @@ -1413,7 +1438,7 @@ Database::getAdapterNode(const string& id) const Ice::StringSeq Database::getAllAdapters(const string& expression) { - Lock sync(*this); + lock_guard lock(_mutex); vector<string> result; vector<string> ids = _adapterCache.getAll(expression); result.swap(ids); @@ -1456,7 +1481,7 @@ Database::addObject(const ObjectInfo& info) int serial = 0; { - Lock sync(*this); + lock_guard lock(_mutex); const Ice::Identity id = info.proxy->ice_getIdentity(); if(_objectCache.has(id)) @@ -1464,7 +1489,7 @@ Database::addObject(const ObjectInfo& info) throw ObjectExistsException(id); } - Ice::Long dbSerial = 0; + long long dbSerial = 0; try { IceDB::ReadWriteTxn txn(_env); @@ -1496,13 +1521,13 @@ Database::addObject(const ObjectInfo& info) } void -Database::addOrUpdateObject(const ObjectInfo& info, Ice::Long dbSerial) +Database::addOrUpdateObject(const ObjectInfo& info, long long dbSerial) { assert(dbSerial != 0 || _master); int serial = 0; // Initialize to prevent warning. { - Lock sync(*this); + lock_guard lock(_mutex); const Ice::Identity id = info.proxy->ice_getIdentity(); if(_objectCache.has(id)) @@ -1552,13 +1577,13 @@ Database::addOrUpdateObject(const ObjectInfo& info, Ice::Long dbSerial) } void -Database::removeObject(const Ice::Identity& id, Ice::Long dbSerial) +Database::removeObject(const Ice::Identity& id, long long dbSerial) { assert(dbSerial != 0 || _master); int serial = 0; // Initialize to prevent warning. { - Lock sync(*this); + lock_guard lock(_mutex); if(_objectCache.has(id)) { throw DeploymentException("removing object `" + _communicator->identityToString(id) + "' is not allowed:\n" @@ -1598,13 +1623,13 @@ Database::removeObject(const Ice::Identity& id, Ice::Long dbSerial) } void -Database::updateObject(const Ice::ObjectPrx& proxy) +Database::updateObject(const shared_ptr<Ice::ObjectPrx>& proxy) { assert(_master); int serial = 0; { - Lock sync(*this); + lock_guard lock(_mutex); const Ice::Identity id = proxy->ice_getIdentity(); if(_objectCache.has(id)) @@ -1649,19 +1674,19 @@ Database::updateObject(const Ice::ObjectPrx& proxy) int Database::addOrUpdateRegistryWellKnownObjects(const ObjectInfoSeq& objects) { - Lock sync(*this); + lock_guard lock(_mutex); try { IceDB::ReadWriteTxn txn(_env); - for(ObjectInfoSeq::const_iterator p = objects.begin(); p != objects.end(); ++p) + for(const auto& obj : objects) { - Ice::Identity id = p->proxy->ice_getIdentity(); + Ice::Identity id = obj.proxy->ice_getIdentity(); ObjectInfo info; if(_objects.get(txn, id, info)) { _objectsByType.del(txn, info.type, id); } - addObject(txn, *p, false); + addObject(txn, obj, false); } txn.commit(); } @@ -1677,13 +1702,13 @@ Database::addOrUpdateRegistryWellKnownObjects(const ObjectInfoSeq& objects) int Database::removeRegistryWellKnownObjects(const ObjectInfoSeq& objects) { - Lock sync(*this); + lock_guard lock(_mutex); try { IceDB::ReadWriteTxn txn(_env); - for(ObjectInfoSeq::const_iterator p = objects.begin(); p != objects.end(); ++p) + for(const auto& obj : objects) { - Ice::Identity id = p->proxy->ice_getIdentity(); + Ice::Identity id = obj.proxy->ice_getIdentity(); ObjectInfo info; if(_objects.get(txn, id, info)) { @@ -1701,7 +1726,7 @@ Database::removeRegistryWellKnownObjects(const ObjectInfoSeq& objects) return _objectObserverTopic->wellKnownObjectsRemoved(objects); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> Database::getObjectProxy(const Ice::Identity& id) { try @@ -1724,8 +1749,8 @@ Database::getObjectProxy(const Ice::Identity& id) return info.proxy; } -Ice::ObjectPrx -Database::getObjectByType(const string& type, const Ice::ConnectionPtr& con, const Ice::Context& ctx) +shared_ptr<Ice::ObjectPrx> +Database::getObjectByType(const string& type, const shared_ptr<Ice::Connection>& con, const Ice::Context& ctx) { Ice::ObjectProxySeq objs = getObjectsByType(type, con, ctx); if(objs.empty()) @@ -1735,9 +1760,9 @@ Database::getObjectByType(const string& type, const Ice::ConnectionPtr& con, con return objs[IceUtilInternal::random(static_cast<int>(objs.size()))]; } -Ice::ObjectPrx -Database::getObjectByTypeOnLeastLoadedNode(const string& type, LoadSample sample, const Ice::ConnectionPtr& con, - const Ice::Context& ctx) +shared_ptr<Ice::ObjectPrx> +Database::getObjectByTypeOnLeastLoadedNode(const string& type, LoadSample sample, + const shared_ptr<Ice::Connection>& con, const Ice::Context& ctx) { Ice::ObjectProxySeq objs = getObjectsByType(type, con, ctx); if(objs.empty()) @@ -1746,55 +1771,59 @@ Database::getObjectByTypeOnLeastLoadedNode(const string& type, LoadSample sample } IceUtilInternal::shuffle(objs.begin(), objs.end()); - vector<pair<Ice::ObjectPrx, float> > objectsWithLoad; + vector<pair<shared_ptr<Ice::ObjectPrx>, float>> objectsWithLoad; objectsWithLoad.reserve(objs.size()); - for(Ice::ObjectProxySeq::const_iterator p = objs.begin(); p != objs.end(); ++p) + for(const auto& obj : objs) { float load = 1.0f; - if(!(*p)->ice_getAdapterId().empty()) + if(!obj->ice_getAdapterId().empty()) { try { - load = _adapterCache.get((*p)->ice_getAdapterId())->getLeastLoadedNodeLoad(sample); + load = _adapterCache.get(obj->ice_getAdapterId())->getLeastLoadedNodeLoad(sample); } catch(const AdapterNotExistException&) { } } - objectsWithLoad.push_back(make_pair(*p, load)); + objectsWithLoad.push_back(make_pair(obj, load)); } - return min_element(objectsWithLoad.begin(), objectsWithLoad.end(), ObjectLoadCI())->first; + return min_element(objectsWithLoad.begin(), objectsWithLoad.end(), [](const auto& lhs, const auto& rhs) + { + return lhs.second < rhs.second; + })->first; } Ice::ObjectProxySeq -Database::getObjectsByType(const string& type, const Ice::ConnectionPtr& con, const Ice::Context& ctx) +Database::getObjectsByType(const string& type, const shared_ptr<Ice::Connection>& con, const Ice::Context& ctx) { Ice::ObjectProxySeq proxies; - vector<ObjectEntryPtr> objects = _objectCache.getObjectsByType(type); - for(vector<ObjectEntryPtr>::const_iterator q = objects.begin(); q != objects.end(); ++q) + auto objects = _objectCache.getObjectsByType(type); + + for(const auto& obj : objects) { - if(_nodeObserverTopic->isServerEnabled((*q)->getServer())) // Only return proxies from enabled servers. + if(_nodeObserverTopic->isServerEnabled(obj->getServer())) // Only return proxies from enabled servers. { - proxies.push_back((*q)->getProxy()); + proxies.push_back(obj->getProxy()); } } IceDB::ReadOnlyTxn txn(_env); vector<ObjectInfo> infos = findByType(txn, _objects, _objectsByType, type); - for(unsigned int i = 0; i < infos.size(); ++i) + for(const auto& info : infos) { - proxies.push_back(infos[i].proxy); + proxies.push_back(info.proxy); } if(con && !proxies.empty() && _pluginFacade->hasTypeFilters()) { - vector<TypeFilterPtr> filters = _pluginFacade->getTypeFilters(type); + auto filters = _pluginFacade->getTypeFilters(type); if(!filters.empty()) { - for(vector<TypeFilterPtr>::const_iterator p = filters.begin(); p != filters.end(); ++p) + for(const auto& filter: filters) { - proxies = (*p)->filter(type, proxies, con, ctx); + proxies = filter->filter(type, proxies, con, ctx); } } } @@ -1806,8 +1835,7 @@ Database::getObjectInfo(const Ice::Identity& id) { try { - ObjectEntryPtr object = _objectCache.get(id); - return object->getObjectInfo(); + return _objectCache.get(id)->getObjectInfo(); } catch(const ObjectNotRegisteredException&) { @@ -1859,7 +1887,7 @@ Database::getObjectInfosByType(const string& type) void Database::addInternalObject(const ObjectInfo& info, bool replace) { - Lock sync(*this); + lock_guard lock(_mutex); const Ice::Identity id = info.proxy->ice_getIdentity(); try @@ -1889,7 +1917,7 @@ Database::addInternalObject(const ObjectInfo& info, bool replace) void Database::removeInternalObject(const Ice::Identity& id) { - Lock sync(*this); + lock_guard lock(_mutex); try { @@ -1934,7 +1962,11 @@ Database::checkForAddition(const ApplicationHelper& app, const IceDB::ReadWriteT app.getIds(serverIds, adapterIds, objectIds); - for_each(serverIds.begin(), serverIds.end(), objFunc(*this, &Database::checkServerForAddition)); + for(const auto& serverId : serverIds) + { + checkServerForAddition(serverId); + } + if(!adapterIds.empty()) { for(set<string>::const_iterator p = adapterIds.begin(); p != adapterIds.end(); ++p) @@ -1953,7 +1985,10 @@ Database::checkForAddition(const ApplicationHelper& app, const IceDB::ReadWriteT set<string> repGrps; set<string> adptRepGrps; app.getReplicaGroups(repGrps, adptRepGrps); - for_each(adptRepGrps.begin(), adptRepGrps.end(), objFunc(*this, &Database::checkReplicaGroupExists)); + for(const auto& repGrp : adptRepGrps) + { + checkReplicaGroupExists(repGrp); + } } void @@ -1970,15 +2005,18 @@ Database::checkForUpdate(const ApplicationHelper& origApp, Ice::StringSeq addedSvrs; set_difference(newSvrs.begin(), newSvrs.end(), oldSvrs.begin(), oldSvrs.end(), back_inserter(addedSvrs)); - for_each(addedSvrs.begin(), addedSvrs.end(), objFunc(*this, &Database::checkServerForAddition)); + for(const auto& svr : addedSvrs) + { + checkServerForAddition(svr); + } Ice::StringSeq addedAdpts; set_difference(newAdpts.begin(), newAdpts.end(), oldAdpts.begin(), oldAdpts.end(), back_inserter(addedAdpts)); if(!addedAdpts.empty()) { - for(Ice::StringSeq::const_iterator p = addedAdpts.begin(); p != addedAdpts.end(); ++p) + for(const auto& adpt : addedAdpts) { - checkAdapterForAddition(*p, txn); + checkAdapterForAddition(adpt, txn); } } @@ -1986,9 +2024,9 @@ Database::checkForUpdate(const ApplicationHelper& origApp, set_difference(newObjs.begin(), newObjs.end(), oldObjs.begin(), oldObjs.end(), back_inserter(addedObjs)); if(!addedObjs.empty()) { - for(vector<Ice::Identity>::const_iterator p = addedObjs.begin(); p != addedObjs.end(); ++p) + for(const auto& obj : addedObjs) { - checkObjectForAddition(*p, txn); + checkObjectForAddition(obj, txn); } } @@ -1999,12 +2037,18 @@ Database::checkForUpdate(const ApplicationHelper& origApp, set<string> rmRepGrps; set_difference(oldRepGrps.begin(), oldRepGrps.end(), newRepGrps.begin(),newRepGrps.end(), set_inserter(rmRepGrps)); - for_each(rmRepGrps.begin(), rmRepGrps.end(), objFunc(*this, &Database::checkReplicaGroupForRemove)); + for(const auto& repGrp : rmRepGrps) + { + checkReplicaGroupForRemove(repGrp); + } set<string> addedAdptRepGrps; set_difference(newAdptRepGrps.begin(),newAdptRepGrps.end(), oldAdptRepGrps.begin(), oldAdptRepGrps.end(), set_inserter(addedAdptRepGrps)); - for_each(addedAdptRepGrps.begin(), addedAdptRepGrps.end(), objFunc(*this, &Database::checkReplicaGroupExists)); + for(const auto& repGrp : addedAdptRepGrps) + { + checkReplicaGroupExists(repGrp); + } vector<string> invalidAdptRepGrps; set_intersection(rmRepGrps.begin(), rmRepGrps.end(), newAdptRepGrps.begin(), newAdptRepGrps.end(), @@ -2021,7 +2065,11 @@ Database::checkForRemove(const ApplicationHelper& app) set<string> replicaGroups; set<string> adapterReplicaGroups; app.getReplicaGroups(replicaGroups, adapterReplicaGroups); - for_each(replicaGroups.begin(), replicaGroups.end(), objFunc(*this, &Database::checkReplicaGroupForRemove)); + + for(const auto& replicaGroup : replicaGroups) + { + checkReplicaGroupForRemove(replicaGroup); + } } void @@ -2088,10 +2136,10 @@ Database::checkObjectForAddition(const Ice::Identity& objectId, void Database::checkReplicaGroupExists(const string& replicaGroup) { - ReplicaGroupEntryPtr entry; + shared_ptr<ReplicaGroupEntry> entry; try { - entry = ReplicaGroupEntryPtr::dynamicCast(_adapterCache.get(replicaGroup)); + entry = dynamic_pointer_cast<ReplicaGroupEntry>(_adapterCache.get(replicaGroup)); } catch(const AdapterNotExistException&) { @@ -2106,10 +2154,10 @@ Database::checkReplicaGroupExists(const string& replicaGroup) void Database::checkReplicaGroupForRemove(const string& replicaGroup) { - ReplicaGroupEntryPtr entry; + shared_ptr<ReplicaGroupEntry> entry; try { - entry = ReplicaGroupEntryPtr::dynamicCast(_adapterCache.get(replicaGroup)); + entry = dynamic_pointer_cast<ReplicaGroupEntry>(_adapterCache.get(replicaGroup)); } catch(const AdapterNotExistException&) { @@ -2137,53 +2185,50 @@ Database::load(const ApplicationHelper& app, ServerEntrySeq& entries, const stri { const NodeDescriptorDict& nodes = app.getInstance().nodes; const string application = app.getInstance().name; - for(NodeDescriptorDict::const_iterator n = nodes.begin(); n != nodes.end(); ++n) + for(const auto& node : nodes) { - _nodeCache.get(n->first, true)->addDescriptor(application, n->second); + _nodeCache.get(node.first, true)->addDescriptor(application, node.second); } const ReplicaGroupDescriptorSeq& adpts = app.getInstance().replicaGroups; - for(ReplicaGroupDescriptorSeq::const_iterator r = adpts.begin(); r != adpts.end(); ++r) + for(const auto& adpt : adpts) { - assert(!r->id.empty()); - _adapterCache.addReplicaGroup(*r, application); - for(ObjectDescriptorSeq::const_iterator o = r->objects.begin(); o != r->objects.end(); ++o) + assert(!adpt.id.empty()); + _adapterCache.addReplicaGroup(adpt, application); + for(const auto& obj : adpt.objects) { - _objectCache.add(toObjectInfo(_communicator, *o, r->id), application, ""); + _objectCache.add(toObjectInfo(_communicator, obj, adpt.id), application, ""); } } - map<string, ServerInfo> servers = app.getServerInfos(uuid, revision); - for(map<string, ServerInfo>::const_iterator p = servers.begin(); p != servers.end(); ++p) + for(const auto& server : app.getServerInfos(uuid, revision)) { - entries.push_back(_serverCache.add(p->second)); + entries.push_back(_serverCache.add(server.second)); } } void Database::unload(const ApplicationHelper& app, ServerEntrySeq& entries) { - map<string, ServerInfo> servers = app.getServerInfos("", 0); - for(map<string, ServerInfo>::const_iterator p = servers.begin(); p != servers.end(); ++p) + for(const auto& server : app.getServerInfos("", 0)) { - entries.push_back(_serverCache.remove(p->first, false)); + entries.push_back(_serverCache.remove(server.first, false)); } - const ReplicaGroupDescriptorSeq& adpts = app.getInstance().replicaGroups; - for(ReplicaGroupDescriptorSeq::const_iterator r = adpts.begin(); r != adpts.end(); ++r) + for(const auto& adpt : app.getInstance().replicaGroups) { - for(ObjectDescriptorSeq::const_iterator o = r->objects.begin(); o != r->objects.end(); ++o) + for(ObjectDescriptorSeq::const_iterator o = adpt.objects.begin(); o != adpt.objects.end(); ++o) { _objectCache.remove(o->id); } - _adapterCache.removeReplicaGroup(r->id); + _adapterCache.removeReplicaGroup(adpt.id); } const NodeDescriptorDict& nodes = app.getInstance().nodes; const string application = app.getInstance().name; - for(NodeDescriptorDict::const_iterator n = nodes.begin(); n != nodes.end(); ++n) + for(const auto& node : nodes) { - _nodeCache.get(n->first)->removeDescriptor(application); + _nodeCache.get(node.first)->removeDescriptor(application); } } @@ -2200,8 +2245,8 @@ Database::reload(const ApplicationHelper& oldApp, // // Remove destroyed servers. // - map<string, ServerInfo> oldServers = oldApp.getServerInfos(uuid, revision); - map<string, ServerInfo> newServers = newApp.getServerInfos(uuid, revision); + auto oldServers = oldApp.getServerInfos(uuid, revision); + auto newServers = newApp.getServerInfos(uuid, revision); vector<pair<bool, ServerInfo> > load; for(map<string, ServerInfo>::const_iterator p = newServers.begin(); p != newServers.end(); ++p) { @@ -2217,7 +2262,7 @@ Database::reload(const ApplicationHelper& oldApp, } else { - ServerEntryPtr server = _serverCache.get(p->first); + auto server = _serverCache.get(p->first); server->update(q->second, noRestart); // Just update the server revision on the node. entries.push_back(server); } @@ -2281,7 +2326,7 @@ Database::reload(const ApplicationHelper& oldApp, { try { - ReplicaGroupEntryPtr entry = ReplicaGroupEntryPtr::dynamicCast(_adapterCache.get(r->id)); + auto entry = dynamic_pointer_cast<ReplicaGroupEntry>(_adapterCache.get(r->id)); assert(entry); entry->update(application, r->loadBalancing, r->filter); } @@ -2312,16 +2357,16 @@ Database::reload(const ApplicationHelper& oldApp, } } -Ice::Long -Database::saveApplication(const ApplicationInfo& info, const IceDB::ReadWriteTxn& txn, Ice::Long dbSerial) +long long +Database::saveApplication(const ApplicationInfo& info, const IceDB::ReadWriteTxn& txn, long long dbSerial) { assert(dbSerial != 0 || _master); _applications.put(txn, info.descriptor.name, info); return updateSerial(txn, applicationsDbName, dbSerial); } -Ice::Long -Database::removeApplication(const string& name, const IceDB::ReadWriteTxn& txn, Ice::Long dbSerial) +long long +Database::removeApplication(const string& name, const IceDB::ReadWriteTxn& txn, long long dbSerial) { assert(dbSerial != 0 || _master); _applications.del(txn, name); @@ -2343,21 +2388,21 @@ Database::checkUpdate(const ApplicationHelper& oldApp, map<string, ServerInfo>::const_iterator p; vector<string> servers; vector<string> reasons; - vector<CheckUpdateResultPtr> results; + vector<shared_ptr<CheckUpdateResult>> results; set<string> unreachableNodes; if(noRestart) { for(p = oldServers.begin(); p != oldServers.end(); ++p) { - map<string, ServerInfo>::const_iterator q = newServers.find(p->first); + auto q = newServers.find(p->first); if(q == newServers.end()) { try { - ServerInfo info = p->second; + auto info = p->second; info.descriptor = 0; // Clear the descriptor to indicate removal. - CheckUpdateResultPtr result = _serverCache.get(p->first)->checkUpdate(info, true); + auto result = _serverCache.get(p->first)->checkUpdate(info, true); if(result) { results.push_back(result); @@ -2378,7 +2423,7 @@ Database::checkUpdate(const ApplicationHelper& oldApp, for(p = newServers.begin(); p != newServers.end(); ++p) { - map<string, ServerInfo>::const_iterator q = oldServers.find(p->first); + auto q = oldServers.find(p->first); if(q != oldServers.end() && isServerUpdated(p->second, q->second)) { if(noRestart && @@ -2400,7 +2445,7 @@ Database::checkUpdate(const ApplicationHelper& oldApp, // try { - CheckUpdateResultPtr result = _serverCache.get(p->first)->checkUpdate(p->second, noRestart); + auto result = _serverCache.get(p->first)->checkUpdate(p->second, noRestart); if(result) { results.push_back(result); @@ -2419,11 +2464,11 @@ Database::checkUpdate(const ApplicationHelper& oldApp, } } - for(vector<CheckUpdateResultPtr>::const_iterator q = results.begin(); q != results.end(); ++q) + for(const auto& result : results) { try { - (*q)->getResult(); + result->getResult(); } catch(const NodeUnreachableException& ex) { @@ -2431,7 +2476,7 @@ Database::checkUpdate(const ApplicationHelper& oldApp, } catch(const DeploymentException& ex) { - servers.push_back((*q)->getServer()); + servers.push_back(result->getServer()); reasons.push_back(ex.reason); } } @@ -2446,15 +2491,9 @@ Database::checkUpdate(const ApplicationHelper& oldApp, out << "check for application `" << application << "' update failed:"; if(!unreachableNodes.empty()) { -#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES) - Ice::StringSeq nodes; - for(set<string>::const_iterator r = unreachableNodes.begin(); r != unreachableNodes.end(); ++r) - { - nodes.push_back(*r); - } -#else + Ice::StringSeq nodes(unreachableNodes.begin(), unreachableNodes.end()); -#endif + if(nodes.size() == 1) { out << "\nthe node `" << nodes[0] << "' is down"; @@ -2488,15 +2527,7 @@ Database::checkUpdate(const ApplicationHelper& oldApp, } if(!unreachableNodes.empty()) { -#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES) - Ice::StringSeq nodes; - for(set<string>::const_iterator r = unreachableNodes.begin(); r != unreachableNodes.end(); ++r) - { - nodes.push_back(*r); - } -#else Ice::StringSeq nodes(unreachableNodes.begin(), unreachableNodes.end()); -#endif if(nodes.size() == 1) { os << "\nthe node `" << nodes[0] << "' is down"; @@ -2541,14 +2572,17 @@ Database::finishApplicationUpdate(const ApplicationUpdateInfo& update, checkUpdate(previousAppHelper, appHelper, oldApp.uuid, oldApp.revision, noRestart); } - Lock sync(*this); + lock_guard lock(_mutex); IceDB::ReadWriteTxn txn(_env); checkForUpdate(previousAppHelper, appHelper, txn); reload(previousAppHelper, appHelper, entries, oldApp.uuid, oldApp.revision + 1, noRestart); - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync)); + for(const auto& entry : entries) + { + entry->sync(); + } ApplicationInfo info = oldApp; info.updateTime = update.updateTime; @@ -2579,8 +2613,8 @@ Database::finishApplicationUpdate(const ApplicationUpdateInfo& update, // for the nodes to start servers. // { - Lock sync(*this); - vector<UpdateInfo>::iterator p = find(_updating.begin(), _updating.end(), update.descriptor.name); + lock_guard lock(_mutex); + auto p = find(_updating.begin(), _updating.end(), update.descriptor.name); assert(p != _updating.end()); p->markUpdated(); } @@ -2605,7 +2639,7 @@ Database::finishApplicationUpdate(const ApplicationUpdateInfo& update, { ApplicationUpdateInfo newUpdate; { - Lock sync(*this); + lock_guard lock(_mutex); entries.clear(); ApplicationHelper previous(_communicator, newDesc); ApplicationHelper helper(_communicator, oldApp.descriptor); @@ -2635,12 +2669,20 @@ Database::finishApplicationUpdate(const ApplicationUpdateInfo& update, assert(p != _updating.end()); p->unmarkUpdated(); - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync)); + for(const auto& entry : entries) + { + entry->sync(); + } serial = _applicationObserverTopic->applicationUpdated(dbSerial, newUpdate); } _applicationObserverTopic->waitForSyncedSubscribers(serial); // Wait for subscriber to be updated. - for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::waitForSyncNoThrow)); + + for(const auto& entry : entries) + { + entry->waitForSyncNoThrow(); + } + finishUpdating(newDesc.name); throw; } @@ -2655,12 +2697,9 @@ Database::finishApplicationUpdate(const ApplicationUpdateInfo& update, } void -Database::waitForUpdate(const string& name) +Database::waitForUpdate(unique_lock<mutex>& lock, const string& name) { - while(find(_updating.begin(), _updating.end(), name) != _updating.end()) - { - wait(); - } + _condVar.wait(lock, [this, &name] { return find(_updating.begin(), _updating.end(), name) == _updating.end(); }); } void @@ -2674,25 +2713,25 @@ Database::startUpdating(const string& name, const string& uuid, int revision) void Database::finishUpdating(const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); vector<UpdateInfo>::iterator p = find(_updating.begin(), _updating.end(), name); assert(p != _updating.end()); p->markUpdated(); _updating.erase(p); - notifyAll(); + _condVar.notify_all(); } -Ice::Long +long long Database::getSerial(const IceDB::Txn& txn, const string& dbName) { - Ice::Long serial = 1; + long long serial = 1; _serials.get(txn, dbName, serial); return serial; } -Ice::Long -Database::updateSerial(const IceDB::ReadWriteTxn& txn, const string& dbName, Ice::Long serial) +long long +Database::updateSerial(const IceDB::ReadWriteTxn& txn, const string& dbName, long long serial) { if(serial == -1) // The master we are talking to doesn't support serials (old IceGrid versions) { diff --git a/cpp/src/IceGrid/Database.h b/cpp/src/IceGrid/Database.h index 877f1d25a6f..f1e032be3c3 100644 --- a/cpp/src/IceGrid/Database.h +++ b/cpp/src/IceGrid/Database.h @@ -5,8 +5,6 @@ #ifndef ICE_GRID_DATABASE_H #define ICE_GRID_DATABASE_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Shared.h> #include <IceUtil/FileUtil.h> #include <Ice/CommunicatorF.h> #include <IceGrid/Admin.h> @@ -25,126 +23,117 @@ namespace IceGrid { -class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - +class AdminSessionI; +class ApplicationHelper; class NodeSessionI; -typedef IceUtil::Handle<NodeSessionI> NodeSessionIPtr; - class ReplicaSessionI; -typedef IceUtil::Handle<ReplicaSessionI> ReplicaSessionIPtr; - -class AdminSessionI; - class ServerEntry; -typedef IceUtil::Handle<ServerEntry> ServerEntryPtr; - -class ApplicationHelper; - -typedef IceDB::Dbi<std::string, IceGrid::ApplicationInfo, IceDB::IceContext, Ice::OutputStream> - StringApplicationInfoMap; - -typedef IceDB::Dbi<Ice::Identity, IceGrid::ObjectInfo, IceDB::IceContext, Ice::OutputStream> IdentityObjectInfoMap; -typedef IceDB::Dbi<std::string, Ice::Identity, IceDB::IceContext, Ice::OutputStream> StringIdentityMap; - -typedef IceDB::Dbi<std::string, IceGrid::AdapterInfo, IceDB::IceContext, Ice::OutputStream> StringAdapterInfoMap; -typedef IceDB::Dbi<std::string, std::string, IceDB::IceContext, Ice::OutputStream> StringStringMap; - -typedef IceDB::Dbi<std::string, Ice::Long, IceDB::IceContext, Ice::OutputStream> StringLongMap; +class TraceLevels; -class Database : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex> +using StringApplicationInfoMap = IceDB::Dbi<std::string, + IceGrid::ApplicationInfo, + IceDB::IceContext, Ice::OutputStream>; +using IdentityObjectInfoMap = IceDB::Dbi<Ice::Identity, + IceGrid::ObjectInfo, + IceDB::IceContext, + Ice::OutputStream>; +using StringIdentityMap = IceDB::Dbi<std::string, Ice::Identity, IceDB::IceContext, Ice::OutputStream>; +using StringAdapterInfoMap = IceDB::Dbi<std::string, IceGrid::AdapterInfo, IceDB::IceContext, Ice::OutputStream>; +using StringStringMap = IceDB::Dbi<std::string, std::string, IceDB::IceContext, Ice::OutputStream>; +using StringLongMap = IceDB::Dbi<std::string, Ice::Long, IceDB::IceContext, Ice::OutputStream>; + +class Database final { public: -#ifdef __SUNPRO_CC - using IceUtil::Monitor<IceUtil::Mutex>::lock; - using IceUtil::Monitor<IceUtil::Mutex>::unlock; -#endif - - Database(const Ice::ObjectAdapterPtr&, const IceStorm::TopicManagerPrx&, const std::string&, const TraceLevelsPtr&, - const RegistryInfo&, bool); + static std::shared_ptr<Database> + create(const std::shared_ptr<Ice::ObjectAdapter>&, const std::shared_ptr<IceStorm::TopicManagerPrx>&, + const std::string&, const std::shared_ptr<TraceLevels>&, const RegistryInfo&, bool); std::string getInstanceName() const; bool isReadOnly() const { return _readonly; } - const TraceLevelsPtr& getTraceLevels() const { return _traceLevels; } - const Ice::CommunicatorPtr& getCommunicator() const { return _communicator; } - const Ice::ObjectAdapterPtr& getInternalAdapter() { return _internalAdapter; } + const std::shared_ptr<TraceLevels>& getTraceLevels() const { return _traceLevels; } + const std::shared_ptr<Ice::Communicator>& getCommunicator() const { return _communicator; } + const std::shared_ptr<Ice::ObjectAdapter>& getInternalAdapter() { return _internalAdapter; } void destroy(); - ObserverTopicPtr getObserverTopic(TopicName) const; + std::shared_ptr<ObserverTopic> getObserverTopic(TopicName) const; int lock(AdminSessionI*, const std::string&); void unlock(AdminSessionI*); - void syncApplications(const ApplicationInfoSeq&, Ice::Long); - void syncAdapters(const AdapterInfoSeq&, Ice::Long); - void syncObjects(const ObjectInfoSeq&, Ice::Long); + void syncApplications(const ApplicationInfoSeq&, long long); + void syncAdapters(const AdapterInfoSeq&, long long); + void syncObjects(const ObjectInfoSeq&, long long); - ApplicationInfoSeq getApplications(Ice::Long&); - AdapterInfoSeq getAdapters(Ice::Long&); - ObjectInfoSeq getObjects(Ice::Long&); + ApplicationInfoSeq getApplications(long long&); + AdapterInfoSeq getAdapters(long long&); + ObjectInfoSeq getObjects(long long&); StringLongDict getSerials() const; - void addApplication(const ApplicationInfo&, AdminSessionI*, Ice::Long = 0); - void updateApplication(const ApplicationUpdateInfo&, bool, AdminSessionI*, Ice::Long = 0); + void addApplication(const ApplicationInfo&, AdminSessionI*, long long = 0); + void updateApplication(const ApplicationUpdateInfo&, bool, AdminSessionI*, long long = 0); void syncApplicationDescriptor(const ApplicationDescriptor&, bool, AdminSessionI*); void instantiateServer(const std::string&, const std::string&, const ServerInstanceDescriptor&, AdminSessionI*); - void removeApplication(const std::string&, AdminSessionI*, Ice::Long = 0); + void removeApplication(const std::string&, AdminSessionI*, long long = 0); ApplicationInfo getApplicationInfo(const std::string&); Ice::StringSeq getAllApplications(const std::string& = std::string()); - void waitForApplicationUpdate(const AMD_NodeSession_waitForApplicationUpdatePtr&, const std::string&, int); + void waitForApplicationUpdate(const std::string&, int, std::function<void()>, + std::function<void(std::exception_ptr)>); NodeCache& getNodeCache(); - NodeEntryPtr getNode(const std::string&, bool = false) const; + std::shared_ptr<NodeEntry> getNode(const std::string&, bool = false) const; ReplicaCache& getReplicaCache(); - ReplicaEntryPtr getReplica(const std::string&) const; + std::shared_ptr<ReplicaEntry> getReplica(const std::string&) const; ServerCache& getServerCache(); - ServerEntryPtr getServer(const std::string&) const; + std::shared_ptr<ServerEntry> getServer(const std::string&) const; AllocatableObjectCache& getAllocatableObjectCache(); - AllocatableObjectEntryPtr getAllocatableObject(const Ice::Identity&) const; + std::shared_ptr<AllocatableObjectEntry> getAllocatableObject(const Ice::Identity&) const; - void setAdapterDirectProxy(const std::string&, const std::string&, const Ice::ObjectPrx&, Ice::Long = 0); - Ice::ObjectPrx getAdapterDirectProxy(const std::string&, const Ice::EncodingVersion&, const Ice::ConnectionPtr&, - const Ice::Context&); + void setAdapterDirectProxy(const std::string&, const std::string&, const std::shared_ptr<Ice::ObjectPrx>&, + long long = 0); + std::shared_ptr<Ice::ObjectPrx> getAdapterDirectProxy(const std::string&, const Ice::EncodingVersion&, + const std::shared_ptr<Ice::Connection>&, + const Ice::Context&); void removeAdapter(const std::string&); - AdapterPrx getAdapterProxy(const std::string&, const std::string&, bool); - void getLocatorAdapterInfo(const std::string&, const Ice::ConnectionPtr&, const Ice::Context&, + std::shared_ptr<AdapterPrx> getAdapterProxy(const std::string&, const std::string&, bool); + void getLocatorAdapterInfo(const std::string&, const std::shared_ptr<Ice::Connection>&, const Ice::Context&, LocatorAdapterInfoSeq&, int&, bool&, bool&, const std::set<std::string>& = std::set<std::string>()); - bool addAdapterSyncCallback(const std::string&, const SynchronizationCallbackPtr&, + bool addAdapterSyncCallback(const std::string&, const std::shared_ptr<SynchronizationCallback>&, const std::set<std::string>& = std::set<std::string>()); - std::vector<std::pair<std::string, AdapterPrx> > getAdapters(const std::string&, int&, bool&); + std::vector<std::pair<std::string, std::shared_ptr<AdapterPrx>>> getAdapters(const std::string&, int&, bool&); AdapterInfoSeq getAdapterInfo(const std::string&); - AdapterInfoSeq getFilteredAdapterInfo(const std::string&, const Ice::ConnectionPtr&, const Ice::Context&); + AdapterInfoSeq getFilteredAdapterInfo(const std::string&, const std::shared_ptr<Ice::Connection>&, const Ice::Context&); std::string getAdapterServer(const std::string&) const; std::string getAdapterApplication(const std::string&) const; std::string getAdapterNode(const std::string&) const; Ice::StringSeq getAllAdapters(const std::string& = std::string()); void addObject(const ObjectInfo&); - void addOrUpdateObject(const ObjectInfo&, Ice::Long = 0); - void removeObject(const Ice::Identity&, Ice::Long = 0); - void updateObject(const Ice::ObjectPrx&); + void addOrUpdateObject(const ObjectInfo&, long long = 0); + void removeObject(const Ice::Identity&, long long = 0); + void updateObject(const std::shared_ptr<Ice::ObjectPrx>&); int addOrUpdateRegistryWellKnownObjects(const ObjectInfoSeq&); int removeRegistryWellKnownObjects(const ObjectInfoSeq&); - Ice::ObjectPrx getObjectProxy(const Ice::Identity&); - Ice::ObjectPrx getObjectByType(const std::string&, - const Ice::ConnectionPtr& = Ice::ConnectionPtr(), - const Ice::Context& = Ice::Context()); - Ice::ObjectPrx getObjectByTypeOnLeastLoadedNode(const std::string&, LoadSample, - const Ice::ConnectionPtr& = Ice::ConnectionPtr(), + std::shared_ptr<Ice::ObjectPrx> getObjectProxy(const Ice::Identity&); + std::shared_ptr<Ice::ObjectPrx> getObjectByType(const std::string&, + const std::shared_ptr<Ice::Connection>& = nullptr, const Ice::Context& = Ice::Context()); + std::shared_ptr<Ice::ObjectPrx> getObjectByTypeOnLeastLoadedNode(const std::string&, LoadSample, + const std::shared_ptr<Ice::Connection>& = nullptr, + const Ice::Context& = Ice::Context()); Ice::ObjectProxySeq getObjectsByType(const std::string&, - const Ice::ConnectionPtr& = Ice::ConnectionPtr(), + const std::shared_ptr<Ice::Connection>& = nullptr, const Ice::Context& = Ice::Context()); ObjectInfo getObjectInfo(const Ice::Identity&); ObjectInfoSeq getObjectInfosByType(const std::string&); @@ -156,6 +145,9 @@ public: private: + Database(const std::shared_ptr<Ice::ObjectAdapter>&, const std::shared_ptr<IceStorm::TopicManagerPrx>&, + const std::string&, const std::shared_ptr<TraceLevels>&, const RegistryInfo&, bool); + void checkForAddition(const ApplicationHelper&, const IceDB::ReadWriteTxn&); void checkForUpdate(const ApplicationHelper&, const ApplicationHelper&, const IceDB::ReadWriteTxn&); void checkForRemove(const ApplicationHelper&); @@ -172,20 +164,20 @@ private: void checkUpdate(const ApplicationHelper&, const ApplicationHelper&, const std::string&, int, bool); - Ice::Long saveApplication(const ApplicationInfo&, const IceDB::ReadWriteTxn&, Ice::Long = 0); - Ice::Long removeApplication(const std::string&, const IceDB::ReadWriteTxn&, Ice::Long = 0); + long long saveApplication(const ApplicationInfo&, const IceDB::ReadWriteTxn&, long long = 0); + long long removeApplication(const std::string&, const IceDB::ReadWriteTxn&, long long = 0); void finishApplicationUpdate(const ApplicationUpdateInfo&, const ApplicationInfo&, const ApplicationHelper&, - const ApplicationHelper&, AdminSessionI*, bool, Ice::Long = 0); + const ApplicationHelper&, AdminSessionI*, bool, long long = 0); void checkSessionLock(AdminSessionI*); - void waitForUpdate(const std::string&); + void waitForUpdate(std::unique_lock<std::mutex>&, const std::string&); void startUpdating(const std::string&, const std::string&, int); void finishUpdating(const std::string&); - Ice::Long getSerial(const IceDB::Txn&, const std::string&); - Ice::Long updateSerial(const IceDB::ReadWriteTxn&, const std::string&, Ice::Long = 0); + long long getSerial(const IceDB::Txn&, const std::string&); + long long updateSerial(const IceDB::ReadWriteTxn&, const std::string&, long long = 0); void addAdapter(const IceDB::ReadWriteTxn&, const AdapterInfo&); void deleteAdapter(const IceDB::ReadWriteTxn&, const AdapterInfo&); @@ -201,11 +193,11 @@ private: static const std::string _adapterDbName; static const std::string _replicaGroupDbName; - const Ice::CommunicatorPtr _communicator; - const Ice::ObjectAdapterPtr _internalAdapter; - const IceStorm::TopicManagerPrx _topicManager; + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<Ice::ObjectAdapter> _internalAdapter; + const std::shared_ptr<IceStorm::TopicManagerPrx> _topicManager; const std::string _instanceName; - const TraceLevelsPtr _traceLevels; + const std::shared_ptr<TraceLevels> _traceLevels; const bool _master; const bool _readonly; @@ -216,11 +208,11 @@ private: AllocatableObjectCache _allocatableObjectCache; ServerCache _serverCache; - RegistryObserverTopicPtr _registryObserverTopic; - NodeObserverTopicPtr _nodeObserverTopic; - ApplicationObserverTopicPtr _applicationObserverTopic; - AdapterObserverTopicPtr _adapterObserverTopic; - ObjectObserverTopicPtr _objectObserverTopic; + std::shared_ptr<RegistryObserverTopic> _registryObserverTopic; + std::shared_ptr<NodeObserverTopic> _nodeObserverTopic; + std::shared_ptr<ApplicationObserverTopic> _applicationObserverTopic; + std::shared_ptr<AdapterObserverTopic> _adapterObserverTopic; + std::shared_ptr<ObjectObserverTopic> _objectObserverTopic; IceUtilInternal::FileLock _dbLock; IceDB::Env _env; @@ -238,7 +230,7 @@ private: StringLongMap _serials; - RegistryPluginFacadeIPtr _pluginFacade; + std::shared_ptr<RegistryPluginFacadeI> _pluginFacade; AdminSessionI* _lock; std::string _lockUserId; @@ -248,7 +240,7 @@ private: std::string name; std::string uuid; int revision; - std::vector<AMD_NodeSession_waitForApplicationUpdatePtr> cbs; + std::vector<std::pair<std::function<void()>, std::function<void(std::exception_ptr)>>> cbs; bool updated; UpdateInfo(const std::string& n, const std::string& u, int r) : @@ -268,10 +260,9 @@ private: void markUpdated() { updated = true; - std::vector<AMD_NodeSession_waitForApplicationUpdatePtr>::const_iterator q; - for(q = cbs.begin(); q != cbs.end(); ++q) + for(const auto& cb: cbs) { - (*q)->ice_response(); + cb.first(); } cbs.clear(); } @@ -282,9 +273,11 @@ private: } }; std::vector<UpdateInfo> _updating; -}; -typedef IceUtil::Handle<Database> DatabasePtr; + mutable std::mutex _mutex; + std::condition_variable _condVar; }; +} + #endif diff --git a/cpp/src/IceGrid/DescriptorBuilder.cpp b/cpp/src/IceGrid/DescriptorBuilder.cpp index 472af859692..f96619368c0 100644 --- a/cpp/src/IceGrid/DescriptorBuilder.cpp +++ b/cpp/src/IceGrid/DescriptorBuilder.cpp @@ -13,7 +13,7 @@ using namespace std; using namespace IceGrid; XmlAttributesHelper::XmlAttributesHelper(const IceXML::Attributes& attrs, - const Ice::LoggerPtr& logger, + const shared_ptr<Ice::Logger>& logger, const string& filename, int line) : _attributes(attrs), @@ -215,7 +215,7 @@ PropertySetDescriptorBuilder::finish() return true; } -ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(const Ice::CommunicatorPtr& communicator, +ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator, const XmlAttributesHelper& attrs, const map<string, string>& overrides) : _communicator(communicator), @@ -225,7 +225,7 @@ ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(const Ice::Communicat _descriptor.variables = overrides; } -ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(const Ice::CommunicatorPtr& communicator, +ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator, const ApplicationDescriptor& app, const XmlAttributesHelper& attrs, const map<string, string>& overrides) : @@ -264,7 +264,7 @@ ApplicationDescriptorBuilder::finishReplicaGroup() { if(!_descriptor.replicaGroups.back().loadBalancing) { - _descriptor.replicaGroups.back().loadBalancing = new RandomLoadBalancingPolicy(); + _descriptor.replicaGroups.back().loadBalancing = make_shared<RandomLoadBalancingPolicy>(); _descriptor.replicaGroups.back().loadBalancing->nReplicas = "0"; } } @@ -272,23 +272,23 @@ ApplicationDescriptorBuilder::finishReplicaGroup() void ApplicationDescriptorBuilder::setLoadBalancing(const XmlAttributesHelper& attrs) { - LoadBalancingPolicyPtr policy; + shared_ptr<LoadBalancingPolicy> policy; string type = attrs("type"); if(type == "random") { - policy = new RandomLoadBalancingPolicy(); + policy = make_shared<RandomLoadBalancingPolicy>(); } else if(type == "ordered") { - policy = new OrderedLoadBalancingPolicy(); + policy = make_shared<OrderedLoadBalancingPolicy>(); } else if(type == "round-robin") { - policy = new RoundRobinLoadBalancingPolicy(); + policy = make_shared<RoundRobinLoadBalancingPolicy>(); } else if(type == "adaptive") { - AdaptiveLoadBalancingPolicyPtr alb = new AdaptiveLoadBalancingPolicy(); + auto alb = make_shared<AdaptiveLoadBalancingPolicy>(); alb->loadSample = attrs("load-sample", "1"); policy = alb; } @@ -498,7 +498,7 @@ NodeDescriptorBuilder::addServerInstance(const ServerInstanceDescriptor& desc) } void -NodeDescriptorBuilder::addServer(const ServerDescriptorPtr& server) +NodeDescriptorBuilder::addServer(const shared_ptr<ServerDescriptor>& server) { _descriptor.servers.push_back(server); } @@ -544,7 +544,7 @@ TemplateDescriptorBuilder::addParameter(const XmlAttributesHelper& attrs) } void -TemplateDescriptorBuilder::setDescriptor(const CommunicatorDescriptorPtr& desc) +TemplateDescriptorBuilder::setDescriptor(const shared_ptr<CommunicatorDescriptor>& desc) { _descriptor.descriptor = desc; } @@ -579,13 +579,13 @@ TemplateDescriptorBuilder::createService(const XmlAttributesHelper& attrs) return new ServiceDescriptorBuilder(_application.getCommunicator(), attrs); } -CommunicatorDescriptorBuilder::CommunicatorDescriptorBuilder(const Ice::CommunicatorPtr& communicator) : +CommunicatorDescriptorBuilder::CommunicatorDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator) : _communicator(communicator) { } void -CommunicatorDescriptorBuilder::init(const CommunicatorDescriptorPtr& desc, const XmlAttributesHelper&) +CommunicatorDescriptorBuilder::init(const shared_ptr<CommunicatorDescriptor>& desc, const XmlAttributesHelper&) { _descriptor = desc; } @@ -644,7 +644,7 @@ CommunicatorDescriptorBuilder::addAdapter(const XmlAttributesHelper& attrs) else { string fqn = "${server}"; - if(ServiceDescriptorPtr::dynamicCast(_descriptor)) + if(dynamic_pointer_cast<ServiceDescriptor>(_descriptor)) { fqn += ".${service}"; } @@ -702,64 +702,6 @@ CommunicatorDescriptorBuilder::addAllocatable(const XmlAttributesHelper& attrs) } void -CommunicatorDescriptorBuilder::addDbEnv(const XmlAttributesHelper& attrs) -{ - DbEnvDescriptor desc; - desc.name = attrs("name"); - - DbEnvDescriptorSeq::iterator p; - for(p = _descriptor->dbEnvs.begin(); p != _descriptor->dbEnvs.end(); ++p) - { - // - // We are re-opening the dbenv element to define more properties. - // - if(p->name == desc.name) - { - break; - } - } - - if(p != _descriptor->dbEnvs.end()) - { - // - // Remove the previously defined dbenv, we'll add it back again when - // the dbenv element end tag is reached. - // - desc = *p; - _descriptor->dbEnvs.erase(p); - } - - if(desc.dbHome.empty()) - { - desc.dbHome = attrs("home", ""); - } - - _descriptor->dbEnvs.push_back(desc); -} - -void -CommunicatorDescriptorBuilder::addDbEnvProperty(const XmlAttributesHelper& attrs) -{ - if(!_descriptor->dbEnvs.back().dbHome.empty()) - { - throw invalid_argument("can't add property to the database environment:\n" - "properties are only allowed if the database\n" - "environment home directory is managed by the node"); - } - - PropertyDescriptor prop; - prop.name = attrs("name"); - prop.value = attrs("value", ""); - _descriptor->dbEnvs.back().properties.push_back(prop); -} - -void -CommunicatorDescriptorBuilder::setDbEnvDescription(const string& value) -{ - _descriptor->dbEnvs.back().description = value; -} - -void CommunicatorDescriptorBuilder::addLog(const XmlAttributesHelper& attrs) { if(attrs.contains("property")) @@ -802,20 +744,20 @@ ServiceInstanceDescriptorBuilder::addPropertySet(const PropertySetDescriptor& de p.properties.insert(p.properties.end(), desc.properties.begin(), desc.properties.end()); } -ServerDescriptorBuilder::ServerDescriptorBuilder(const Ice::CommunicatorPtr& communicator, +ServerDescriptorBuilder::ServerDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator, const XmlAttributesHelper& attrs) : CommunicatorDescriptorBuilder(communicator) { - init(new ServerDescriptor(), attrs); + init(make_shared<ServerDescriptor>(), attrs); } -ServerDescriptorBuilder::ServerDescriptorBuilder(const Ice::CommunicatorPtr& communicator) : +ServerDescriptorBuilder::ServerDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator) : CommunicatorDescriptorBuilder(communicator) { } void -ServerDescriptorBuilder::init(const ServerDescriptorPtr& desc, const XmlAttributesHelper& attrs) +ServerDescriptorBuilder::init(const shared_ptr<ServerDescriptor>& desc, const XmlAttributesHelper& attrs) { CommunicatorDescriptorBuilder::init(desc, attrs); _descriptor = desc; @@ -855,7 +797,7 @@ ServerDescriptorBuilder::addEnv(const string& v) } void -ServerDescriptorBuilder::addService(const ServiceDescriptorPtr& /*desc*/) +ServerDescriptorBuilder::addService(const shared_ptr<ServiceDescriptor>& /*desc*/) { assert(false); } @@ -866,15 +808,15 @@ ServerDescriptorBuilder::addServiceInstance(const ServiceInstanceDescriptor& /*d assert(false); } -IceBoxDescriptorBuilder::IceBoxDescriptorBuilder(const Ice::CommunicatorPtr& communicator, +IceBoxDescriptorBuilder::IceBoxDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator, const XmlAttributesHelper& attrs) : ServerDescriptorBuilder(communicator) { - init(new IceBoxDescriptor(), attrs); + init(make_shared<IceBoxDescriptor>(), attrs); } void -IceBoxDescriptorBuilder::init(const IceBoxDescriptorPtr& desc, const XmlAttributesHelper& attrs) +IceBoxDescriptorBuilder::init(const shared_ptr<IceBoxDescriptor>& desc, const XmlAttributesHelper& attrs) { ServerDescriptorBuilder::init(desc, attrs); _descriptor = desc; @@ -899,19 +841,13 @@ IceBoxDescriptorBuilder::addAdapter(const XmlAttributesHelper& /*attrs*/) } void -IceBoxDescriptorBuilder::addDbEnv(const XmlAttributesHelper& /*attrs*/) -{ - throw invalid_argument("<dbenv> element can't be a child of an <icebox> element"); -} - -void IceBoxDescriptorBuilder::addServiceInstance(const ServiceInstanceDescriptor& desc) { _descriptor->services.push_back(desc); } void -IceBoxDescriptorBuilder::addService(const ServiceDescriptorPtr& desc) +IceBoxDescriptorBuilder::addService(const shared_ptr<ServiceDescriptor>& desc) { ServiceInstanceDescriptor instance; assert(desc); @@ -919,15 +855,15 @@ IceBoxDescriptorBuilder::addService(const ServiceDescriptorPtr& desc) _descriptor->services.push_back(instance); } -ServiceDescriptorBuilder::ServiceDescriptorBuilder(const Ice::CommunicatorPtr& communicator, +ServiceDescriptorBuilder::ServiceDescriptorBuilder(const shared_ptr<Ice::Communicator>& communicator, const XmlAttributesHelper& attrs) : CommunicatorDescriptorBuilder(communicator) { - init(new ServiceDescriptor(), attrs); + init(make_shared<ServiceDescriptor>(), attrs); } void -ServiceDescriptorBuilder::init(const ServiceDescriptorPtr& desc, const XmlAttributesHelper& attrs) +ServiceDescriptorBuilder::init(const shared_ptr<ServiceDescriptor>& desc, const XmlAttributesHelper& attrs) { CommunicatorDescriptorBuilder::init(desc, attrs); _descriptor = desc; diff --git a/cpp/src/IceGrid/DescriptorBuilder.h b/cpp/src/IceGrid/DescriptorBuilder.h index f58cf8e7a0e..02e9c397da3 100644 --- a/cpp/src/IceGrid/DescriptorBuilder.h +++ b/cpp/src/IceGrid/DescriptorBuilder.h @@ -10,13 +10,6 @@ #include <IceGrid/Descriptor.h> #include <set> -#ifdef __SUNPRO_CC -// -// We hide some init functions on purpose in classes below -// -# pragma error_messages(off,hidef) -#endif - namespace IceGrid { @@ -24,7 +17,7 @@ class XmlAttributesHelper { public: - XmlAttributesHelper(const IceXML::Attributes&, const Ice::LoggerPtr&, const std::string&, int); + XmlAttributesHelper(const IceXML::Attributes&, const std::shared_ptr<Ice::Logger>&, const std::string&, int); void checkUnknownAttributes(); bool contains(const std::string&) const; @@ -39,7 +32,7 @@ public: private: const IceXML::Attributes& _attributes; - const Ice::LoggerPtr _logger; + const std::shared_ptr<Ice::Logger> _logger; const std::string _filename; const int _line; @@ -52,7 +45,7 @@ class DescriptorBuilder { public: - virtual ~DescriptorBuilder() { } + virtual ~DescriptorBuilder() = default; virtual void addVariable(const XmlAttributesHelper&); }; @@ -89,10 +82,10 @@ class ApplicationDescriptorBuilder : public DescriptorBuilder { public: - ApplicationDescriptorBuilder(const Ice::CommunicatorPtr&, const XmlAttributesHelper&, - const std::map<std::string, std::string>&); - ApplicationDescriptorBuilder(const Ice::CommunicatorPtr&, const ApplicationDescriptor&, const XmlAttributesHelper&, + ApplicationDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&, const XmlAttributesHelper&, const std::map<std::string, std::string>&); + ApplicationDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&, const ApplicationDescriptor&, + const XmlAttributesHelper&, const std::map<std::string, std::string>&); const ApplicationDescriptor& getDescriptor() const; @@ -117,11 +110,11 @@ public: bool isOverride(const std::string&); - const Ice::CommunicatorPtr& getCommunicator() const { return _communicator; } + const std::shared_ptr<Ice::Communicator>& getCommunicator() const { return _communicator; } private: - Ice::CommunicatorPtr _communicator; + std::shared_ptr<Ice::Communicator> _communicator; ApplicationDescriptor _descriptor; std::map<std::string, std::string> _overrides; }; @@ -157,7 +150,7 @@ public: virtual PropertySetDescriptorBuilder* createPropertySet(const XmlAttributesHelper&) const; void addVariable(const XmlAttributesHelper&); - void addServer(const ServerDescriptorPtr&); + void addServer(const std::shared_ptr<ServerDescriptor>&); void addServerInstance(const ServerInstanceDescriptor&); void addPropertySet(const std::string&, const PropertySetDescriptor&); void setDescription(const std::string&); @@ -185,7 +178,7 @@ public: virtual ServiceDescriptorBuilder* createService(const XmlAttributesHelper&); void addParameter(const XmlAttributesHelper&); - void setDescriptor(const CommunicatorDescriptorPtr&); + void setDescriptor(const std::shared_ptr<CommunicatorDescriptor>&); const std::string& getId() const { return _id; } const TemplateDescriptor& getDescriptor() const { return _descriptor; } @@ -202,9 +195,9 @@ class CommunicatorDescriptorBuilder : public DescriptorBuilder { public: - CommunicatorDescriptorBuilder(const Ice::CommunicatorPtr&); + CommunicatorDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&); - void init(const CommunicatorDescriptorPtr&, const XmlAttributesHelper&); + void init(const std::shared_ptr<CommunicatorDescriptor>&, const XmlAttributesHelper&); virtual void finish(); virtual void setDescription(const std::string&); @@ -214,9 +207,6 @@ public: virtual void setAdapterDescription(const std::string&); virtual void addObject(const XmlAttributesHelper&); virtual void addAllocatable(const XmlAttributesHelper&); - virtual void addDbEnv(const XmlAttributesHelper&); - virtual void addDbEnvProperty(const XmlAttributesHelper&); - virtual void setDbEnvDescription(const std::string&); virtual void addLog(const XmlAttributesHelper&); virtual PropertySetDescriptorBuilder* createPropertySet() const; @@ -226,11 +216,11 @@ protected: void addProperty(PropertyDescriptorSeq&, const std::string&, const std::string&); PropertyDescriptorSeq _hiddenProperties; - Ice::CommunicatorPtr _communicator; + std::shared_ptr<Ice::Communicator> _communicator; private: - CommunicatorDescriptorPtr _descriptor; + std::shared_ptr<CommunicatorDescriptor> _descriptor; }; class ServiceInstanceDescriptorBuilder : public DescriptorBuilder @@ -252,65 +242,60 @@ class ServerDescriptorBuilder : public CommunicatorDescriptorBuilder { public: - ServerDescriptorBuilder(const Ice::CommunicatorPtr&, const XmlAttributesHelper&); - ServerDescriptorBuilder(const Ice::CommunicatorPtr&); + ServerDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&, const XmlAttributesHelper&); + ServerDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&); - void init(const ServerDescriptorPtr&, const XmlAttributesHelper&); + void init(const std::shared_ptr<ServerDescriptor>&, const XmlAttributesHelper&); virtual ServiceDescriptorBuilder* createService(const XmlAttributesHelper&); virtual ServiceInstanceDescriptorBuilder* createServiceInstance(const XmlAttributesHelper&); virtual void addOption(const std::string&); virtual void addEnv(const std::string&); - virtual void addService(const ServiceDescriptorPtr&); + virtual void addService(const std::shared_ptr<ServiceDescriptor>&); virtual void addServiceInstance(const ServiceInstanceDescriptor&); - const ServerDescriptorPtr& getDescriptor() const { return _descriptor; } + const std::shared_ptr<ServerDescriptor>& getDescriptor() const { return _descriptor; } private: - ServerDescriptorPtr _descriptor; + std::shared_ptr<ServerDescriptor> _descriptor; }; class IceBoxDescriptorBuilder : public ServerDescriptorBuilder { public: - IceBoxDescriptorBuilder(const Ice::CommunicatorPtr&, const XmlAttributesHelper&); + IceBoxDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&, const XmlAttributesHelper&); - void init(const IceBoxDescriptorPtr&, const XmlAttributesHelper&); + void init(const std::shared_ptr<IceBoxDescriptor>&, const XmlAttributesHelper&); virtual ServiceDescriptorBuilder* createService(const XmlAttributesHelper&); virtual ServiceInstanceDescriptorBuilder* createServiceInstance(const XmlAttributesHelper&); virtual void addAdapter(const XmlAttributesHelper&); - virtual void addDbEnv(const XmlAttributesHelper&); virtual void addServiceInstance(const ServiceInstanceDescriptor&); - virtual void addService(const ServiceDescriptorPtr&); + virtual void addService(const std::shared_ptr<ServiceDescriptor>&); private: - IceBoxDescriptorPtr _descriptor; + std::shared_ptr<IceBoxDescriptor> _descriptor; }; class ServiceDescriptorBuilder : public CommunicatorDescriptorBuilder { public: - ServiceDescriptorBuilder(const Ice::CommunicatorPtr&, const XmlAttributesHelper&); - void init(const ServiceDescriptorPtr&, const XmlAttributesHelper&); + ServiceDescriptorBuilder(const std::shared_ptr<Ice::Communicator>&, const XmlAttributesHelper&); + void init(const std::shared_ptr<ServiceDescriptor>&, const XmlAttributesHelper&); - const ServiceDescriptorPtr& getDescriptor() const { return _descriptor; } + const std::shared_ptr<ServiceDescriptor>& getDescriptor() const { return _descriptor; } private: - ServiceDescriptorPtr _descriptor; + std::shared_ptr<ServiceDescriptor> _descriptor; }; } -#ifdef __SUNPRO_CC -# pragma error_messages(default,hidef) -#endif - #endif diff --git a/cpp/src/IceGrid/DescriptorHelper.cpp b/cpp/src/IceGrid/DescriptorHelper.cpp index 58ec1da1ec9..39cbcdebdef 100644 --- a/cpp/src/IceGrid/DescriptorHelper.cpp +++ b/cpp/src/IceGrid/DescriptorHelper.cpp @@ -13,42 +13,23 @@ using namespace IceUtil; using namespace IceUtilInternal; using namespace IceGrid; -#ifdef __SUNPRO_CC -// -// Disable warning about unassigned function objects -// -# pragma error_messages(off,unassigned) -#endif - -namespace IceGrid +namespace { -struct GetReplicaGroupId : unary_function<const ReplicaGroupDescriptor&, const string&> +const string& getReplicaGroupId(const ReplicaGroupDescriptor& desc) { - const string& - operator()(const ReplicaGroupDescriptor& desc) - { - return desc.id; - } -}; + return desc.id; +} -struct GetAdapterId : unary_function<const AdapterDescriptor&, const string&> +const string& getAdapterId(const AdapterDescriptor& desc) { - const string& - operator()(const AdapterDescriptor& desc) - { - return desc.id; - } -}; + return desc.id; +} -struct GetObjectId : unary_function<const ObjectDescriptor&, const Ice::Identity&> +const Ice::Identity& getObjectId(const ObjectDescriptor& desc) { - const Ice::Identity& - operator()(const ObjectDescriptor& desc) - { - return desc.id; - } -}; + return desc.id; +} template <typename GetKeyFunc, typename Seq, typename EqFunc> bool isSeqEqual(const Seq& lseq, const Seq& rseq, GetKeyFunc func, EqFunc eq = equal_to<typename Seq::value_type>()) @@ -76,162 +57,146 @@ isSeqEqual(const Seq& lseq, const Seq& rseq, GetKeyFunc func, EqFunc eq = equal_ return true; } -struct TemplateDescriptorEqual : std::binary_function<TemplateDescriptor&, TemplateDescriptor&, bool> +bool templateDescriptorEqual(const TemplateDescriptor& lhs, const TemplateDescriptor& rhs) { - bool - operator()(const TemplateDescriptor& lhs, const TemplateDescriptor& rhs) + if(lhs.parameters != rhs.parameters) { - if(lhs.parameters != rhs.parameters) - { - return false; - } + return false; + } - if(lhs.parameterDefaults != rhs.parameterDefaults) - { - return false; - } + if(lhs.parameterDefaults != rhs.parameterDefaults) + { + return false; + } + { + auto slhs = dynamic_pointer_cast<IceBoxDescriptor>(lhs.descriptor); + auto srhs = dynamic_pointer_cast<IceBoxDescriptor>(rhs.descriptor); + if(slhs && srhs) { - IceBoxDescriptorPtr slhs = IceBoxDescriptorPtr::dynamicCast(lhs.descriptor); - IceBoxDescriptorPtr srhs = IceBoxDescriptorPtr::dynamicCast(rhs.descriptor); - if(slhs && srhs) - { - return IceBoxHelper(slhs) == IceBoxHelper(srhs); - } + return IceBoxHelper(slhs) == IceBoxHelper(srhs); } + } + { + auto slhs = dynamic_pointer_cast<ServerDescriptor>(lhs.descriptor); + auto srhs = dynamic_pointer_cast<ServerDescriptor>(rhs.descriptor); + if(slhs && srhs) { - ServerDescriptorPtr slhs = ServerDescriptorPtr::dynamicCast(lhs.descriptor); - ServerDescriptorPtr srhs = ServerDescriptorPtr::dynamicCast(rhs.descriptor); - if(slhs && srhs) - { - return ServerHelper(slhs) == ServerHelper(srhs); - } + return ServerHelper(slhs) == ServerHelper(srhs); } + } + { + auto slhs = dynamic_pointer_cast<ServiceDescriptor>(lhs.descriptor); + auto srhs = dynamic_pointer_cast<ServiceDescriptor>(rhs.descriptor); + if(slhs && srhs) { - ServiceDescriptorPtr slhs = ServiceDescriptorPtr::dynamicCast(lhs.descriptor); - ServiceDescriptorPtr srhs = ServiceDescriptorPtr::dynamicCast(rhs.descriptor); - if(slhs && srhs) - { - return ServiceHelper(slhs) == ServiceHelper(srhs); - } + return ServiceHelper(slhs) == ServiceHelper(srhs); } - - return false; } -}; -struct ObjectDescriptorEq : std::binary_function<const ObjectDescriptor&, const ObjectDescriptor&, bool> + return false; +} + +bool objectDescriptorEqual(const ObjectDescriptor& lhs, const ObjectDescriptor& rhs) { - bool - operator()(const ObjectDescriptor& lhs, const ObjectDescriptor& rhs) + if(lhs.id != rhs.id) { - if(lhs.id != rhs.id) - { - return false; - } - if(lhs.type != rhs.type) - { - return false; - } - if(lhs.proxyOptions != rhs.proxyOptions) - { - return false; - } - return true; + return false; + } + if(lhs.type != rhs.type) + { + return false; + } + if(lhs.proxyOptions != rhs.proxyOptions) + { + return false; } -}; + return true; +} -struct AdapterEq : std::binary_function<const AdapterDescriptor&, const AdapterDescriptor&, bool> +bool adapterEqual(const AdapterDescriptor& lhs, const AdapterDescriptor& rhs) { - bool - operator()(const AdapterDescriptor& lhs, const AdapterDescriptor& rhs) + if(lhs.id != rhs.id) { - if(lhs.id != rhs.id) - { - return false; - } - if(lhs.name != rhs.name) - { - return false; - } - if(lhs.description != rhs.description) - { - return false; - } - if(lhs.replicaGroupId != rhs.replicaGroupId) - { - return false; - } - if(lhs.priority != rhs.priority) - { - return false; - } - if(lhs.registerProcess != rhs.registerProcess) - { - return false; - } - if(lhs.serverLifetime != rhs.serverLifetime) - { - return false; - } - if(!isSeqEqual(lhs.objects, rhs.objects, GetObjectId(), ObjectDescriptorEq())) - { - return false; - } - if(!isSeqEqual(lhs.allocatables, rhs.allocatables, GetObjectId(), ObjectDescriptorEq())) - { - return false; - } - return true; + return false; + } + if(lhs.name != rhs.name) + { + return false; + } + if(lhs.description != rhs.description) + { + return false; + } + if(lhs.replicaGroupId != rhs.replicaGroupId) + { + return false; } -}; + if(lhs.priority != rhs.priority) + { + return false; + } + if(lhs.registerProcess != rhs.registerProcess) + { + return false; + } + if(lhs.serverLifetime != rhs.serverLifetime) + { + return false; + } + if(!isSeqEqual(lhs.objects, rhs.objects, getObjectId, objectDescriptorEqual)) + { + return false; + } + if(!isSeqEqual(lhs.allocatables, rhs.allocatables, getObjectId, objectDescriptorEqual)) + { + return false; + } + return true; +} -struct ReplicaGroupEq : std::binary_function<const ReplicaGroupDescriptor&, const ReplicaGroupDescriptor&, bool> +bool replicaGroupEqual(const ReplicaGroupDescriptor& lhs, const ReplicaGroupDescriptor& rhs) { - bool - operator()(const ReplicaGroupDescriptor& lhs, const ReplicaGroupDescriptor& rhs) + if(lhs.id != rhs.id) { - if(lhs.id != rhs.id) - { - return false; - } - if(lhs.proxyOptions != rhs.proxyOptions) - { - return false; - } - if(lhs.filter != rhs.filter) + return false; + } + if(lhs.proxyOptions != rhs.proxyOptions) + { + return false; + } + if(lhs.filter != rhs.filter) + { + return false; + } + if(!isSeqEqual(lhs.objects, rhs.objects, getObjectId, objectDescriptorEqual)) + { + return false; + } + if(lhs.loadBalancing && rhs.loadBalancing) + { + if(lhs.loadBalancing->ice_id() != rhs.loadBalancing->ice_id()) { return false; } - if(!isSeqEqual(lhs.objects, rhs.objects, GetObjectId(), ObjectDescriptorEq())) + if(lhs.loadBalancing->nReplicas != rhs.loadBalancing->nReplicas) { return false; } - if(lhs.loadBalancing && rhs.loadBalancing) - { - if(lhs.loadBalancing->ice_id() != rhs.loadBalancing->ice_id()) - { - return false; - } - if(lhs.loadBalancing->nReplicas != rhs.loadBalancing->nReplicas) - { - return false; - } - AdaptiveLoadBalancingPolicyPtr alhs = AdaptiveLoadBalancingPolicyPtr::dynamicCast(lhs.loadBalancing); - AdaptiveLoadBalancingPolicyPtr arhs = AdaptiveLoadBalancingPolicyPtr::dynamicCast(rhs.loadBalancing); - if(alhs && arhs && alhs->loadSample != arhs->loadSample) - { - return false; - } - } - else if(lhs.loadBalancing || rhs.loadBalancing) + auto alhs = dynamic_pointer_cast<AdaptiveLoadBalancingPolicy>(lhs.loadBalancing); + auto arhs = dynamic_pointer_cast<AdaptiveLoadBalancingPolicy>(rhs.loadBalancing); + if(alhs && arhs && alhs->loadSample != arhs->loadSample) { return false; } - - return true; } -}; + else if(lhs.loadBalancing || rhs.loadBalancing) + { + return false; + } + + return true; +} template <typename GetKeyFunc, typename Seq> Seq getSeqUpdatedElts(const Seq& lseq, const Seq& rseq, GetKeyFunc func) @@ -383,7 +348,7 @@ validateProxyOptions(const Resolver& resolver, const string& proxyOptions) } -Resolver::Resolver(const ApplicationDescriptor& app, const Ice::CommunicatorPtr& communicator, bool enableWarning) : +Resolver::Resolver(const ApplicationDescriptor& app, const shared_ptr<Ice::Communicator>& communicator, bool enableWarning) : _application(&app), _communicator(communicator), _escape(false), @@ -508,7 +473,7 @@ Resolver::Resolver(const Resolver& resolve, } } -Resolver::Resolver(const InternalNodeInfoPtr& info, const Ice::CommunicatorPtr& com) : +Resolver::Resolver(const shared_ptr<InternalNodeInfo>& info, const shared_ptr<Ice::Communicator>& com) : _application(0), _communicator(com), _escape(true), @@ -1049,7 +1014,7 @@ Resolver::checkDeprecated(const string& name) const } } -CommunicatorHelper::CommunicatorHelper(const CommunicatorDescriptorPtr& desc, bool ignoreProps) : +CommunicatorHelper::CommunicatorHelper(const shared_ptr<CommunicatorDescriptor>& desc, bool ignoreProps) : _desc(desc), _ignoreProps(ignoreProps) { } @@ -1067,7 +1032,7 @@ CommunicatorHelper::operator==(const CommunicatorHelper& helper) const return false; } - if(!isSeqEqual(_desc->adapters, helper._desc->adapters, GetAdapterId(), AdapterEq())) + if(!isSeqEqual(_desc->adapters, helper._desc->adapters, getAdapterId, adapterEqual)) { return false; } @@ -1080,12 +1045,6 @@ CommunicatorHelper::operator==(const CommunicatorHelper& helper) const } } - if(set<DbEnvDescriptor>(_desc->dbEnvs.begin(), _desc->dbEnvs.end()) != - set<DbEnvDescriptor>(helper._desc->dbEnvs.begin(), helper._desc->dbEnvs.end())) - { - return false; - } - if(_desc->logs != helper._desc->logs) { return false; @@ -1143,7 +1102,7 @@ CommunicatorHelper::getReplicaGroups(set<string>& replicaGroups) const } void -CommunicatorHelper::instantiateImpl(const CommunicatorDescriptorPtr& instance, const Resolver& resolve) const +CommunicatorHelper::instantiateImpl(const shared_ptr<CommunicatorDescriptor>& instance, const Resolver& resolve) const { instance->description = resolve(_desc->description, "description"); instance->propertySet = resolve(_desc->propertySet); @@ -1200,16 +1159,6 @@ CommunicatorHelper::instantiateImpl(const CommunicatorDescriptorPtr& instance, c } } - for(DbEnvDescriptorSeq::const_iterator s = _desc->dbEnvs.begin(); s != _desc->dbEnvs.end(); ++s) - { - DbEnvDescriptor dbEnv; - dbEnv.name = resolve(s->name, "database environment name", false); - dbEnv.description = resolve(s->description, "database environment description"); - dbEnv.dbHome = resolve(s->dbHome, "database environment home directory"); - dbEnv.properties = resolve(s->properties, "database environment property"); - instance->dbEnvs.push_back(dbEnv); - } - for(Ice::StringSeq::const_iterator l = _desc->logs.begin(); l != _desc->logs.end(); ++l) { instance->logs.push_back(resolve(*l, "log path", false)); @@ -1217,7 +1166,7 @@ CommunicatorHelper::instantiateImpl(const CommunicatorDescriptorPtr& instance, c } void -CommunicatorHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) const +CommunicatorHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out) const { if(!_desc->description.empty()) { @@ -1228,12 +1177,6 @@ CommunicatorHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) } set<string> hiddenProperties; { - for(DbEnvDescriptorSeq::const_iterator p = _desc->dbEnvs.begin(); p != _desc->dbEnvs.end(); ++p) - { - printDbEnv(out, *p); - } - } - { for(AdapterDescriptorSeq::const_iterator p = _desc->adapters.begin(); p != _desc->adapters.end(); ++p) { hiddenProperties.insert(p->name + ".Endpoints"); @@ -1269,36 +1212,7 @@ CommunicatorHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) } void -CommunicatorHelper::printDbEnv(Output& out, const DbEnvDescriptor& dbEnv) const -{ - out << nl << "database environment `" << dbEnv.name << "'"; - if(!dbEnv.dbHome.empty() || !dbEnv.properties.empty() || !dbEnv.description.empty()) - { - out << sb; - if(!dbEnv.dbHome.empty()) - { - out << nl << "home = `" << dbEnv.dbHome << "'"; - } - if(!dbEnv.description.empty()) - { - out << nl << "description = `" << dbEnv.description << "'"; - } - if(!dbEnv.properties.empty()) - { - out << nl << "properties"; - out << sb; - for(PropertyDescriptorSeq::const_iterator p = dbEnv.properties.begin(); p != dbEnv.properties.end(); ++p) - { - out << nl << p->name << " = `" << p->value << "'"; - } - out << eb; - } - out << eb; - } -} - -void -CommunicatorHelper::printObjectAdapter(const Ice::CommunicatorPtr& communicator, +CommunicatorHelper::printObjectAdapter(const shared_ptr<Ice::Communicator>& communicator, Output& out, const AdapterDescriptor& adapter) const { @@ -1372,7 +1286,7 @@ CommunicatorHelper::getProperty(const string& name) const return IceGrid::getProperty(_desc->propertySet.properties, name); } -ServiceHelper::ServiceHelper(const ServiceDescriptorPtr& descriptor, bool ignoreProps) : +ServiceHelper::ServiceHelper(const shared_ptr<ServiceDescriptor>& descriptor, bool ignoreProps) : CommunicatorHelper(descriptor, ignoreProps), _desc(descriptor) { @@ -1400,29 +1314,23 @@ ServiceHelper::operator==(const CommunicatorHelper& h) const return true; } -bool -ServiceHelper::operator!=(const CommunicatorHelper& helper) const -{ - return !operator==(helper); -} - -ServiceDescriptorPtr +shared_ptr<ServiceDescriptor> ServiceHelper::getDescriptor() const { return _desc; } -ServiceDescriptorPtr +shared_ptr<ServiceDescriptor> ServiceHelper::instantiate(const Resolver& resolver, const PropertyDescriptorSeq& props, const PropertySetDescriptorDict& serviceProps) const { - ServiceDescriptorPtr service = new ServiceDescriptor(); + auto service = make_shared<ServiceDescriptor>(); instantiateImpl(service, resolver, props, serviceProps); return service; } void -ServiceHelper::instantiateImpl(const ServiceDescriptorPtr& instance, +ServiceHelper::instantiateImpl(const shared_ptr<ServiceDescriptor>& instance, const Resolver& resolve, const PropertyDescriptorSeq& props, const PropertySetDescriptorDict& serviceProps) const @@ -1441,7 +1349,7 @@ ServiceHelper::instantiateImpl(const ServiceDescriptorPtr& instance, } void -ServiceHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) const +ServiceHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out) const { out << "service `" + _desc->name + "'"; out << sb; @@ -1450,7 +1358,7 @@ ServiceHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) cons out << eb; } -ServerHelper::ServerHelper(const ServerDescriptorPtr& descriptor, bool ignoreProps) : +ServerHelper::ServerHelper(const shared_ptr<ServerDescriptor>& descriptor, bool ignoreProps) : CommunicatorHelper(descriptor, ignoreProps), _desc(descriptor) { @@ -1525,19 +1433,13 @@ ServerHelper::operator==(const CommunicatorHelper& h) const return true; } -bool -ServerHelper::operator!=(const CommunicatorHelper& helper) const -{ - return !operator==(helper); -} - -ServerDescriptorPtr +shared_ptr<ServerDescriptor> ServerHelper::getDescriptor() const { return _desc; } -ServerDescriptorPtr +shared_ptr<ServerDescriptor> ServerHelper::instantiate(const Resolver& resolver, const PropertyDescriptorSeq& props, const PropertySetDescriptorDict& serviceProps) const @@ -1547,19 +1449,19 @@ ServerHelper::instantiate(const Resolver& resolver, resolver.exception("service property sets are only allowed in IceBox server instances"); } - ServerDescriptorPtr server = new ServerDescriptor(); + auto server = make_shared<ServerDescriptor>(); instantiateImpl(server, resolver, props); return server; } void -ServerHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) const +ServerHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out) const { print(communicator, out, ServerInfo()); } void -ServerHelper::print(const Ice::CommunicatorPtr& communicator, Output& out, const ServerInfo& info) const +ServerHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out, const ServerInfo& info) const { out << "server `" + _desc->id + "'"; out << sb; @@ -1568,7 +1470,7 @@ ServerHelper::print(const Ice::CommunicatorPtr& communicator, Output& out, const } void -ServerHelper::printImpl(const Ice::CommunicatorPtr& communicator, Output& out, const ServerInfo& info) const +ServerHelper::printImpl(const shared_ptr<Ice::Communicator>& communicator, Output& out, const ServerInfo& info) const { if(!info.application.empty()) { @@ -1620,7 +1522,7 @@ ServerHelper::printImpl(const Ice::CommunicatorPtr& communicator, Output& out, c } void -ServerHelper::instantiateImpl(const ServerDescriptorPtr& instance, +ServerHelper::instantiateImpl(const shared_ptr<ServerDescriptor>& instance, const Resolver& resolve, const PropertyDescriptorSeq& props) const { @@ -1648,7 +1550,7 @@ ServerHelper::instantiateImpl(const ServerDescriptorPtr& instance, instance->propertySet.properties.insert(instance->propertySet.properties.end(), props.begin(), props.end()); } -IceBoxHelper::IceBoxHelper(const IceBoxDescriptorPtr& descriptor, bool ignoreProps) : +IceBoxHelper::IceBoxHelper(const shared_ptr<IceBoxDescriptor>& descriptor, bool ignoreProps) : ServerHelper(descriptor, ignoreProps), _desc(descriptor) { @@ -1675,18 +1577,12 @@ IceBoxHelper::operator==(const CommunicatorHelper& h) const return true; } -bool -IceBoxHelper::operator!=(const CommunicatorHelper& helper) const -{ - return !operator==(helper); -} - -ServerDescriptorPtr +shared_ptr<ServerDescriptor> IceBoxHelper::instantiate(const Resolver& resolver, const PropertyDescriptorSeq& props, const PropertySetDescriptorDict& serviceProps) const { - IceBoxDescriptorPtr iceBox = new IceBoxDescriptor(); + auto iceBox = make_shared<IceBoxDescriptor>(); instantiateImpl(iceBox, resolver, props, serviceProps); return iceBox; } @@ -1712,13 +1608,13 @@ IceBoxHelper::getReplicaGroups(set<string>& replicaGroups) const } void -IceBoxHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) const +IceBoxHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out) const { print(communicator, out, ServerInfo()); } void -IceBoxHelper::print(const Ice::CommunicatorPtr& communicator, Output& out, const ServerInfo& info) const +IceBoxHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out, const ServerInfo& info) const { out << "icebox `" + _desc->id + "'"; out << sb; @@ -1738,7 +1634,7 @@ IceBoxHelper::print(const Ice::CommunicatorPtr& communicator, Output& out, const } void -IceBoxHelper::instantiateImpl(const IceBoxDescriptorPtr& instance, +IceBoxHelper::instantiateImpl(const shared_ptr<IceBoxDescriptor>& instance, const Resolver& resolver, const PropertyDescriptorSeq& props, const PropertySetDescriptorDict& serviceProps) const @@ -1864,7 +1760,7 @@ ServiceInstanceHelper::instantiate(const Resolver& resolve, const PropertySetDes { assert(!_def._cpp_template.empty()); TemplateDescriptor tmpl = resolve.getServiceTemplate(_def._cpp_template); - def = ServiceHelper(ServiceDescriptorPtr::dynamicCast(tmpl.descriptor)); + def = ServiceHelper(dynamic_pointer_cast<ServiceDescriptor>(tmpl.descriptor)); parameterValues = instantiateParams(resolve, _def._cpp_template, _def.parameterValues, @@ -1911,7 +1807,7 @@ ServiceInstanceHelper::getReplicaGroups(set<string>& replicaGroups) const } void -ServiceInstanceHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) const +ServiceInstanceHelper::print(const shared_ptr<Ice::Communicator>& communicator, Output& out) const { if(_service.getDescriptor()) { @@ -1942,7 +1838,7 @@ ServerInstanceHelper::ServerInstanceHelper(const ServerInstanceDescriptor& desc, init(0, resolve, instantiate); } -ServerInstanceHelper::ServerInstanceHelper(const ServerDescriptorPtr& definition, +ServerInstanceHelper::ServerInstanceHelper(const shared_ptr<ServerDescriptor>& definition, const Resolver& resolve, bool instantiate) : _def(ServerInstanceDescriptor()) @@ -1951,12 +1847,12 @@ ServerInstanceHelper::ServerInstanceHelper(const ServerDescriptorPtr& definition } void -ServerInstanceHelper::init(const ServerDescriptorPtr& definition, const Resolver& resolve, bool instantiate) +ServerInstanceHelper::init(const shared_ptr<ServerDescriptor>& definition, const Resolver& resolve, bool instantiate) { // // Get the server definition if it's not provided. // - ServerDescriptorPtr def = definition; + auto def = definition; std::map<std::string, std::string> parameterValues; if(!def) { @@ -1969,7 +1865,7 @@ ServerInstanceHelper::init(const ServerDescriptorPtr& definition, const Resolver // Get the server definition and the template property sets. // TemplateDescriptor tmpl = resolve.getServerTemplate(_def._cpp_template); - def = ServerDescriptorPtr::dynamicCast(tmpl.descriptor); + def = dynamic_pointer_cast<ServerDescriptor>(tmpl.descriptor); parameterValues = instantiateParams(resolve, _def._cpp_template, _def.parameterValues, @@ -2025,8 +1921,8 @@ ServerInstanceHelper::init(const ServerDescriptorPtr& definition, const Resolver // // Instantiate the server definition. // - ServerDescriptorPtr inst = _serverDefinition->instantiate(svrResolve, _instance.propertySet.properties, - _instance.servicePropertySets); + shared_ptr<ServerDescriptor> inst = _serverDefinition->instantiate(svrResolve, _instance.propertySet.properties, + _instance.servicePropertySets); _serverInstance = createHelper(inst); } @@ -2072,14 +1968,14 @@ ServerInstanceHelper::getInstance() const return _instance; } -ServerDescriptorPtr +shared_ptr<ServerDescriptor> ServerInstanceHelper::getServerDefinition() const { assert(_def._cpp_template.empty()); return _serverDefinition->getDescriptor(); } -ServerDescriptorPtr +shared_ptr<ServerDescriptor> ServerInstanceHelper::getServerInstance() const { assert(_serverInstance); @@ -2214,12 +2110,12 @@ NodeHelper::diff(const NodeHelper& helper) const update.name = _name; if(_def.loadFactor != helper._def.loadFactor) { - update.loadFactor = new BoxedString(_def.loadFactor); + update.loadFactor = make_shared<BoxedString>(_def.loadFactor); } if(_def.description != helper._def.description) { - update.description = new BoxedString(_def.description); + update.description = make_shared<BoxedString>(_def.description); } update.variables = getDictUpdatedElts(helper._def.variables, _def.variables); @@ -2570,7 +2466,7 @@ NodeHelper::printDiff(Output& out, const NodeHelper& helper) const out << eb; } -ApplicationHelper::ApplicationHelper(const Ice::CommunicatorPtr& communicator, +ApplicationHelper::ApplicationHelper(const shared_ptr<Ice::Communicator>& communicator, const ApplicationDescriptor& appDesc, bool enableWarning, bool instantiate) : @@ -2609,7 +2505,7 @@ ApplicationHelper::ApplicationHelper(const Ice::CommunicatorPtr& communicator, { resolve.exception("replica group load balancing is not set"); } - desc.loadBalancing = LoadBalancingPolicyPtr::dynamicCast(r->loadBalancing->ice_clone()); + desc.loadBalancing = dynamic_pointer_cast<LoadBalancingPolicy>(r->loadBalancing->ice_clone()); desc.loadBalancing->nReplicas = resolve.asInt(r->loadBalancing->nReplicas, "replica group number of replicas"); if(desc.loadBalancing->nReplicas.empty()) @@ -2620,7 +2516,7 @@ ApplicationHelper::ApplicationHelper(const Ice::CommunicatorPtr& communicator, { resolve.exception("invalid replica group load balancing number of replicas value: inferior to 0"); } - AdaptiveLoadBalancingPolicyPtr al = AdaptiveLoadBalancingPolicyPtr::dynamicCast(desc.loadBalancing); + auto al = dynamic_pointer_cast<AdaptiveLoadBalancingPolicy>(desc.loadBalancing); if(al) { al->loadSample = resolve(al->loadSample, "replica group load sample"); @@ -2717,7 +2613,7 @@ ApplicationHelper::diff(const ApplicationHelper& helper) const updt.name = _def.name; if(_def.description != helper._def.description) { - updt.description = new BoxedString(_def.description); + updt.description = make_shared<BoxedString>(_def.description); } updt.variables = getDictUpdatedElts(helper._def.variables, _def.variables); @@ -2726,15 +2622,12 @@ ApplicationHelper::diff(const ApplicationHelper& helper) const updt.propertySets = getDictUpdatedElts(helper._def.propertySets, _def.propertySets); updt.removePropertySets = getDictRemovedElts(helper._def.propertySets, _def.propertySets); - GetReplicaGroupId rk; - ReplicaGroupEq req; - updt.replicaGroups = getSeqUpdatedEltsWithEq(helper._def.replicaGroups, _def.replicaGroups, rk, req); - updt.removeReplicaGroups = getSeqRemovedElts(helper._def.replicaGroups, _def.replicaGroups, rk); + updt.replicaGroups = getSeqUpdatedEltsWithEq(helper._def.replicaGroups, _def.replicaGroups, getReplicaGroupId, replicaGroupEqual); + updt.removeReplicaGroups = getSeqRemovedElts(helper._def.replicaGroups, _def.replicaGroups, getReplicaGroupId); - TemplateDescriptorEqual eq; - updt.serverTemplates = getDictUpdatedEltsWithEq(helper._def.serverTemplates, _def.serverTemplates, eq); + updt.serverTemplates = getDictUpdatedEltsWithEq(helper._def.serverTemplates, _def.serverTemplates, templateDescriptorEqual); updt.removeServerTemplates = getDictRemovedElts(helper._def.serverTemplates, _def.serverTemplates); - updt.serviceTemplates = getDictUpdatedEltsWithEq(helper._def.serviceTemplates, _def.serviceTemplates, eq); + updt.serviceTemplates = getDictUpdatedEltsWithEq(helper._def.serviceTemplates, _def.serviceTemplates, templateDescriptorEqual); updt.removeServiceTemplates = getDictRemovedElts(helper._def.serviceTemplates, _def.serviceTemplates); NodeHelperDict updated = getDictUpdatedElts(helper._nodes, _nodes); @@ -2749,8 +2642,8 @@ ApplicationHelper::diff(const ApplicationHelper& helper) const nodeUpdate.variables = node.variables; nodeUpdate.servers = node.servers; nodeUpdate.serverInstances = node.serverInstances; - nodeUpdate.loadFactor = new BoxedString(node.loadFactor); - nodeUpdate.description = new BoxedString(node.description); + nodeUpdate.loadFactor = make_shared<BoxedString>(node.loadFactor); + nodeUpdate.description = make_shared<BoxedString>(node.description); updt.nodes.push_back(nodeUpdate); } else @@ -2767,11 +2660,10 @@ ApplicationDescriptor ApplicationHelper::update(const ApplicationUpdateDescriptor& updt) const { ApplicationDescriptor def; - GetReplicaGroupId rg; def.name = _def.name; def.description = updt.description ? updt.description->value : _def.description; - def.replicaGroups = updateSeqElts(_def.replicaGroups, updt.replicaGroups, updt.removeReplicaGroups, rg); + def.replicaGroups = updateSeqElts(_def.replicaGroups, updt.replicaGroups, updt.removeReplicaGroups, getReplicaGroupId); def.variables = updateDictElts(_def.variables, updt.variables, updt.removeVariables); def.propertySets = updateDictElts(_def.propertySets, updt.propertySets, updt.removePropertySets); def.serverTemplates = updateDictElts(_def.serverTemplates, updt.serverTemplates, updt.removeServerTemplates); @@ -2980,15 +2872,15 @@ ApplicationHelper::print(Output& out, const ApplicationInfo& info) const { out << "default (return all endpoints)"; } - else if(RandomLoadBalancingPolicyPtr::dynamicCast(p->loadBalancing)) + else if(dynamic_pointer_cast<RandomLoadBalancingPolicy>(p->loadBalancing)) { out << "random"; } - else if(RoundRobinLoadBalancingPolicyPtr::dynamicCast(p->loadBalancing)) + else if(dynamic_pointer_cast<RoundRobinLoadBalancingPolicy>(p->loadBalancing)) { out << "round-robin"; } - else if(AdaptiveLoadBalancingPolicyPtr::dynamicCast(p->loadBalancing)) + else if(dynamic_pointer_cast<AdaptiveLoadBalancingPolicy>(p->loadBalancing)) { out << "adaptive" ; } @@ -3065,11 +2957,9 @@ ApplicationHelper::printDiff(Output& out, const ApplicationHelper& helper) const } } { - GetReplicaGroupId rk; - ReplicaGroupEq req; ReplicaGroupDescriptorSeq updated = - getSeqUpdatedEltsWithEq(helper._def.replicaGroups, _def.replicaGroups, rk, req); - Ice::StringSeq removed = getSeqRemovedElts(helper._def.replicaGroups, _def.replicaGroups, rk); + getSeqUpdatedEltsWithEq(helper._def.replicaGroups, _def.replicaGroups, getReplicaGroupId, replicaGroupEqual); + Ice::StringSeq removed = getSeqRemovedElts(helper._def.replicaGroups, _def.replicaGroups, getReplicaGroupId); if(!updated.empty() || !removed.empty()) { out << nl << "replica groups"; @@ -3105,9 +2995,8 @@ ApplicationHelper::printDiff(Output& out, const ApplicationHelper& helper) const } { - TemplateDescriptorEqual eq; TemplateDescriptorDict updated; - updated = getDictUpdatedEltsWithEq(helper._def.serverTemplates, _def.serverTemplates, eq); + updated = getDictUpdatedEltsWithEq(helper._def.serverTemplates, _def.serverTemplates, templateDescriptorEqual); Ice::StringSeq removed = getDictRemovedElts(helper._def.serverTemplates, _def.serverTemplates); if(!updated.empty() || !removed.empty()) { @@ -3135,9 +3024,8 @@ ApplicationHelper::printDiff(Output& out, const ApplicationHelper& helper) const } } { - TemplateDescriptorEqual eq; TemplateDescriptorDict updated; - updated = getDictUpdatedEltsWithEq(helper._def.serviceTemplates, _def.serviceTemplates, eq); + updated = getDictUpdatedEltsWithEq(helper._def.serviceTemplates, _def.serviceTemplates, templateDescriptorEqual); Ice::StringSeq removed = getDictRemovedElts(helper._def.serviceTemplates, _def.serviceTemplates); if(!updated.empty() || !removed.empty()) { @@ -3198,10 +3086,10 @@ ApplicationHelper::printDiff(Output& out, const ApplicationHelper& helper) const } bool -IceGrid::descriptorEqual(const ServerDescriptorPtr& lhs, const ServerDescriptorPtr& rhs, bool ignoreProps) +IceGrid::descriptorEqual(const shared_ptr<ServerDescriptor>& lhs, const shared_ptr<ServerDescriptor>& rhs, bool ignoreProps) { - IceBoxDescriptorPtr lhsIceBox = IceBoxDescriptorPtr::dynamicCast(lhs); - IceBoxDescriptorPtr rhsIceBox = IceBoxDescriptorPtr::dynamicCast(rhs); + auto lhsIceBox = dynamic_pointer_cast<IceBoxDescriptor>(lhs); + auto rhsIceBox = dynamic_pointer_cast<IceBoxDescriptor>(rhs); if(lhsIceBox && rhsIceBox) { return IceBoxHelper(lhsIceBox, ignoreProps) == IceBoxHelper(rhsIceBox, ignoreProps); @@ -3216,17 +3104,17 @@ IceGrid::descriptorEqual(const ServerDescriptorPtr& lhs, const ServerDescriptorP } } -ServerHelperPtr -IceGrid::createHelper(const ServerDescriptorPtr& desc) +shared_ptr<ServerHelper> +IceGrid::createHelper(const shared_ptr<ServerDescriptor>& desc) { - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(desc); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(desc); if(iceBox) { - return new IceBoxHelper(iceBox); + return make_shared<IceBoxHelper>(iceBox); } else { - return new ServerHelper(desc); + return make_shared<ServerHelper>(desc); } } diff --git a/cpp/src/IceGrid/DescriptorHelper.h b/cpp/src/IceGrid/DescriptorHelper.h index 4fa15ef3a5c..c0a40139719 100644 --- a/cpp/src/IceGrid/DescriptorHelper.h +++ b/cpp/src/IceGrid/DescriptorHelper.h @@ -19,9 +19,9 @@ class Resolver { public: - Resolver(const ApplicationDescriptor&, const Ice::CommunicatorPtr&, bool); + Resolver(const ApplicationDescriptor&, const std::shared_ptr<Ice::Communicator>&, bool); Resolver(const Resolver&, const std::map<std::string, std::string>&, bool); - Resolver(const InternalNodeInfoPtr&, const Ice::CommunicatorPtr&); + Resolver(const std::shared_ptr<InternalNodeInfo>&, const std::shared_ptr<Ice::Communicator>&); std::string operator()(const std::string&, const std::string& = std::string(), bool = true) const; Ice::StringSeq operator()(const Ice::StringSeq&, const std::string&) const; @@ -51,7 +51,7 @@ public: TemplateDescriptor getServiceTemplate(const std::string&) const; bool hasReplicaGroup(const std::string&) const; - Ice::CommunicatorPtr getCommunicator() const { return _communicator; } + std::shared_ptr<Ice::Communicator> getCommunicator() const { return _communicator; } bool warningEnabled() const { return _enableWarning; } private: @@ -65,7 +65,7 @@ private: void checkDeprecated(const std::string&) const; const ApplicationDescriptor* _application; - const Ice::CommunicatorPtr _communicator; + const std::shared_ptr<Ice::Communicator> _communicator; const bool _escape; const bool _enableWarning; std::string _context; @@ -82,90 +82,86 @@ class CommunicatorHelper { public: - CommunicatorHelper(const CommunicatorDescriptorPtr&, bool = false); CommunicatorHelper() : _ignoreProps(false) { } - virtual ~CommunicatorHelper() { } + CommunicatorHelper(const std::shared_ptr<CommunicatorDescriptor>&, bool = false); virtual bool operator==(const CommunicatorHelper&) const; - virtual bool operator!=(const CommunicatorHelper&) const; + bool operator!=(const CommunicatorHelper&) const; virtual void getIds(std::multiset<std::string>&, std::multiset<Ice::Identity>&) const; virtual void getReplicaGroups(std::set<std::string>&) const; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&) const; protected: - void printDbEnv(IceUtilInternal::Output&, const DbEnvDescriptor&) const; - void printObjectAdapter(const Ice::CommunicatorPtr&, IceUtilInternal::Output&, const AdapterDescriptor&) const; + void printObjectAdapter(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&, const AdapterDescriptor&) const; void printPropertySet(IceUtilInternal::Output&, const PropertySetDescriptor&) const; virtual std::string getProperty(const std::string&) const; - void instantiateImpl(const CommunicatorDescriptorPtr&, const Resolver&) const; + void instantiateImpl(const std::shared_ptr<CommunicatorDescriptor>&, const Resolver&) const; private: - CommunicatorDescriptorPtr _desc; + std::shared_ptr<CommunicatorDescriptor> _desc; bool _ignoreProps; }; -class ServiceHelper : public CommunicatorHelper +class ServiceHelper final : public CommunicatorHelper { public: - ServiceHelper(const ServiceDescriptorPtr&, bool = false); - ServiceHelper() { } + ServiceHelper() = default; + ServiceHelper(const std::shared_ptr<ServiceDescriptor>&, bool = false); - virtual bool operator==(const CommunicatorHelper&) const; - virtual bool operator!=(const CommunicatorHelper&) const; + bool operator==(const CommunicatorHelper&) const override; - ServiceDescriptorPtr getDescriptor() const; - ServiceDescriptorPtr instantiate(const Resolver&, const PropertyDescriptorSeq&, - const PropertySetDescriptorDict&) const; + std::shared_ptr<ServiceDescriptor> getDescriptor() const; + std::shared_ptr<ServiceDescriptor> instantiate(const Resolver&, const PropertyDescriptorSeq&, + const PropertySetDescriptorDict&) const; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&) const; protected: using CommunicatorHelper::instantiateImpl; - void instantiateImpl(const ServiceDescriptorPtr&, const Resolver&, const PropertyDescriptorSeq&, + void instantiateImpl(const std::shared_ptr<ServiceDescriptor>&, const Resolver&, const PropertyDescriptorSeq&, const PropertySetDescriptorDict&) const; private: - ServiceDescriptorPtr _desc; + std::shared_ptr<ServiceDescriptor> _desc; }; -class ServerHelper : public CommunicatorHelper, public IceUtil::SimpleShared +class ServerHelper : public CommunicatorHelper { public: - ServerHelper(const ServerDescriptorPtr&, bool = false); - ServerHelper() { } + ServerHelper() = default; + ServerHelper(const std::shared_ptr<ServerDescriptor>&, bool = false); + virtual ~ServerHelper() = default; - virtual bool operator==(const CommunicatorHelper&) const; - virtual bool operator!=(const CommunicatorHelper&) const; + bool operator==(const CommunicatorHelper&) const override; - ServerDescriptorPtr getDescriptor() const; - virtual ServerDescriptorPtr instantiate(const Resolver&, const PropertyDescriptorSeq&, - const PropertySetDescriptorDict&) const; + std::shared_ptr<ServerDescriptor> getDescriptor() const; + virtual std::shared_ptr<ServerDescriptor> instantiate(const Resolver&, const PropertyDescriptorSeq&, + const PropertySetDescriptorDict&) const; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&) const; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&, const ServerInfo&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&, const ServerInfo&) const; protected: using CommunicatorHelper::instantiateImpl; - void printImpl(const Ice::CommunicatorPtr&, IceUtilInternal::Output&, const ServerInfo&) const; - void instantiateImpl(const ServerDescriptorPtr&, const Resolver&, const PropertyDescriptorSeq&) const; + void printImpl(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&, const ServerInfo&) const; + void instantiateImpl(const std::shared_ptr<ServerDescriptor>&, const Resolver&, const PropertyDescriptorSeq&) const; private: - ServerDescriptorPtr _desc; + std::shared_ptr<ServerDescriptor> _desc; }; -typedef IceUtil::Handle<ServerHelper> ServerHelperPtr; class InstanceHelper { @@ -178,7 +174,7 @@ protected: const std::map<std::string, std::string>&) const; }; -class ServiceInstanceHelper : public InstanceHelper +class ServiceInstanceHelper final : public InstanceHelper { public: @@ -191,7 +187,7 @@ public: void getIds(std::multiset<std::string>&, std::multiset<Ice::Identity>&) const; void getReplicaGroups(std::set<std::string>&) const; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&) const; private: @@ -199,47 +195,42 @@ private: mutable ServiceHelper _service; }; -class IceBoxHelper : public ServerHelper +class IceBoxHelper final : public ServerHelper { public: - IceBoxHelper(const IceBoxDescriptorPtr&, bool = false); - IceBoxHelper() { } + IceBoxHelper() = default; + IceBoxHelper(const std::shared_ptr<IceBoxDescriptor>&, bool = false); - virtual bool operator==(const CommunicatorHelper&) const; - virtual bool operator!=(const CommunicatorHelper&) const; + bool operator==(const CommunicatorHelper&) const override; - virtual ServerDescriptorPtr instantiate(const Resolver&, const PropertyDescriptorSeq&, - const PropertySetDescriptorDict&) const; + std::shared_ptr<ServerDescriptor> instantiate(const Resolver&, const PropertyDescriptorSeq&, + const PropertySetDescriptorDict&) const override; - virtual void getIds(std::multiset<std::string>&, std::multiset<Ice::Identity>&) const; - virtual void getReplicaGroups(std::set<std::string>&) const; + void getIds(std::multiset<std::string>&, std::multiset<Ice::Identity>&) const override; + void getReplicaGroups(std::set<std::string>&) const override; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&) const; - void print(const Ice::CommunicatorPtr&, IceUtilInternal::Output&, const ServerInfo&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&) const; + void print(const std::shared_ptr<Ice::Communicator>&, IceUtilInternal::Output&, const ServerInfo&) const; protected: -#ifdef __SUNPRO_CC - using ServerHelper::instantiateImpl; -#endif - - void instantiateImpl(const IceBoxDescriptorPtr&, const Resolver&, const PropertyDescriptorSeq&, + void instantiateImpl(const std::shared_ptr<IceBoxDescriptor>&, const Resolver&, const PropertyDescriptorSeq&, const PropertySetDescriptorDict&) const; private: - IceBoxDescriptorPtr _desc; + std::shared_ptr<IceBoxDescriptor> _desc; std::vector<ServiceInstanceHelper> _services; }; -class ServerInstanceHelper : public InstanceHelper +class ServerInstanceHelper final : public InstanceHelper { public: ServerInstanceHelper(const ServerInstanceDescriptor&, const Resolver&, bool); - ServerInstanceHelper(const ServerDescriptorPtr&, const Resolver&, bool); + ServerInstanceHelper(const std::shared_ptr<ServerDescriptor>&, const Resolver&, bool); bool operator==(const ServerInstanceHelper&) const; bool operator!=(const ServerInstanceHelper&) const; @@ -248,33 +239,32 @@ public: ServerInstanceDescriptor getDefinition() const; ServerInstanceDescriptor getInstance() const; - ServerDescriptorPtr getServerDefinition() const; - ServerDescriptorPtr getServerInstance() const; + std::shared_ptr<ServerDescriptor> getServerDefinition() const; + std::shared_ptr<ServerDescriptor> getServerInstance() const; void getIds(std::multiset<std::string>&, std::multiset<Ice::Identity>&) const; void getReplicaGroups(std::set<std::string>&) const; private: - void init(const ServerDescriptorPtr&, const Resolver&, bool); + void init(const std::shared_ptr<ServerDescriptor>&, const Resolver&, bool); ServerInstanceDescriptor _def; std::string _id; ServerInstanceDescriptor _instance; - ServerHelperPtr _serverDefinition; - ServerHelperPtr _serverInstance; + std::shared_ptr<ServerHelper> _serverDefinition; + std::shared_ptr<ServerHelper> _serverInstance; }; -class NodeHelper +class NodeHelper final { public: NodeHelper(const std::string&, const NodeDescriptor&, const Resolver&, bool); - virtual ~NodeHelper() { } - virtual bool operator==(const NodeHelper&) const; - virtual bool operator!=(const NodeHelper&) const; + bool operator==(const NodeHelper&) const; + bool operator!=(const NodeHelper&) const; NodeUpdateDescriptor diff(const NodeHelper&) const; NodeDescriptor update(const NodeUpdateDescriptor&, const Resolver&) const; @@ -303,11 +293,11 @@ private: ServerInstanceHelperDict _servers; }; -class ApplicationHelper +class ApplicationHelper final { public: - ApplicationHelper(const Ice::CommunicatorPtr&, const ApplicationDescriptor&, bool = false, bool = true); + ApplicationHelper(const std::shared_ptr<Ice::Communicator>&, const ApplicationDescriptor&, bool = false, bool = true); ApplicationUpdateDescriptor diff(const ApplicationHelper&) const; ApplicationDescriptor update(const ApplicationUpdateDescriptor&) const; @@ -324,16 +314,16 @@ public: private: - Ice::CommunicatorPtr _communicator; + std::shared_ptr<Ice::Communicator> _communicator; ApplicationDescriptor _def; ApplicationDescriptor _instance; - typedef std::map<std::string, NodeHelper> NodeHelperDict; + using NodeHelperDict = std::map<std::string, NodeHelper>; NodeHelperDict _nodes; }; -bool descriptorEqual(const ServerDescriptorPtr&, const ServerDescriptorPtr&, bool = false); -ServerHelperPtr createHelper(const ServerDescriptorPtr&); +bool descriptorEqual(const std::shared_ptr<ServerDescriptor>&, const std::shared_ptr<ServerDescriptor>&, bool = false); +std::shared_ptr<ServerHelper> createHelper(const std::shared_ptr<ServerDescriptor>&); bool isServerUpdated(const ServerInfo&, const ServerInfo&, bool = false); } diff --git a/cpp/src/IceGrid/DescriptorParser.cpp b/cpp/src/IceGrid/DescriptorParser.cpp index b86f8cbb775..26cd9c24104 100644 --- a/cpp/src/IceGrid/DescriptorParser.cpp +++ b/cpp/src/IceGrid/DescriptorParser.cpp @@ -16,22 +16,22 @@ using namespace std; using namespace Ice; using namespace IceGrid; -namespace IceGrid +namespace { -class DescriptorHandler : public IceXML::Handler +class DescriptorHandler final : public IceXML::Handler { public: - DescriptorHandler(const string&, const Ice::CommunicatorPtr&); + DescriptorHandler(const string&, const shared_ptr<Ice::Communicator>&); - void setAdmin(const IceGrid::AdminPrx&); + void setAdmin(const shared_ptr<IceGrid::AdminPrx>&); void setVariables(const map<string, string>&, const vector<string>&); - virtual void startElement(const string&, const IceXML::Attributes&, int, int); - virtual void endElement(const string&, int, int); - virtual void characters(const string&, int, int); - virtual void error(const string&, int, int); + void startElement(const string&, const IceXML::Attributes&, int, int) override; + void endElement(const string&, int, int) override; + void characters(const string&, int, int) override; + void error(const string&, int, int) override; const ApplicationDescriptor& getApplicationDescriptor() const; @@ -43,8 +43,8 @@ private: void error(const string&) const; bool isTargetDeployable(const string&) const; - const Ice::CommunicatorPtr _communicator; - IceGrid::AdminPrx _admin; + const shared_ptr<Ice::Communicator> _communicator; + shared_ptr<IceGrid::AdminPrx> _admin; string _filename; map<string, string> _overrides; vector<string> _targets; @@ -55,38 +55,34 @@ private: int _line; int _column; - IceInternal::UniquePtr<ApplicationDescriptorBuilder> _currentApplication; - IceInternal::UniquePtr<NodeDescriptorBuilder> _currentNode; - IceInternal::UniquePtr<TemplateDescriptorBuilder> _currentTemplate; - IceInternal::UniquePtr<ServerInstanceDescriptorBuilder> _currentServerInstance; - IceInternal::UniquePtr<ServiceInstanceDescriptorBuilder> _currentServiceInstance; - IceInternal::UniquePtr<ServerDescriptorBuilder> _currentServer; - IceInternal::UniquePtr<ServiceDescriptorBuilder> _currentService; + unique_ptr<ApplicationDescriptorBuilder> _currentApplication; + unique_ptr<NodeDescriptorBuilder> _currentNode; + unique_ptr<TemplateDescriptorBuilder> _currentTemplate; + unique_ptr<ServerInstanceDescriptorBuilder> _currentServerInstance; + unique_ptr<ServiceInstanceDescriptorBuilder> _currentServiceInstance; + unique_ptr<ServerDescriptorBuilder> _currentServer; + unique_ptr<ServiceDescriptorBuilder> _currentService; CommunicatorDescriptorBuilder* _currentCommunicator; - IceInternal::UniquePtr<PropertySetDescriptorBuilder> _currentPropertySet; + unique_ptr<PropertySetDescriptorBuilder> _currentPropertySet; bool _isTopLevel; bool _inAdapter; bool _inReplicaGroup; - bool _inDbEnv; }; -} - -DescriptorHandler::DescriptorHandler(const string& filename, const Ice::CommunicatorPtr& communicator) : +DescriptorHandler::DescriptorHandler(const string& filename, const shared_ptr<Ice::Communicator>& communicator) : _communicator(communicator), _filename(filename), _isCurrentTargetDeployable(true), - _currentCommunicator(0), + _currentCommunicator(nullptr), _isTopLevel(true), _inAdapter(false), - _inReplicaGroup(false), - _inDbEnv(false) + _inReplicaGroup(false) { } void -DescriptorHandler::setAdmin(const AdminPrx& admin) +DescriptorHandler::setAdmin(const shared_ptr<AdminPrx>& admin) { _admin = admin; } @@ -405,15 +401,6 @@ DescriptorHandler::startElement(const string& name, const IceXML::Attributes& at } _currentCommunicator->addAllocatable(attributes); } - else if(name == "dbenv") - { - if(!_currentCommunicator) - { - error("the <dbenv> element can only be a child of a <server> or <service> element"); - } - _currentCommunicator->addDbEnv(attributes); - _inDbEnv = true; - } else if(name == "log") { if(!_currentCommunicator) @@ -422,14 +409,6 @@ DescriptorHandler::startElement(const string& name, const IceXML::Attributes& at } _currentCommunicator->addLog(attributes); } - else if(name == "dbproperty") - { - if(!_inDbEnv) - { - error("the <dbproperty> element can only be a child of a <dbenv> element"); - } - _currentCommunicator->addDbEnvProperty(attributes); - } else if(name == "description" || name == "option" || name == "env") { // @@ -488,7 +467,7 @@ DescriptorHandler::endElement(const string& name, int line, int column) else if(name == "node") { _currentApplication->addNode(_currentNode->getName(), _currentNode->getDescriptor()); - _currentNode.reset(0); + _currentNode.reset(nullptr); } else if(name == "server" || name == "icebox") { @@ -503,14 +482,14 @@ DescriptorHandler::endElement(const string& name, int line, int column) _currentNode->addServer(_currentServer->getDescriptor()); } _currentServer->finish(); - _currentServer.reset(0); - _currentCommunicator = 0; + _currentServer.reset(nullptr); + _currentCommunicator = nullptr; } else if(name == "server-template") { assert(_currentApplication.get()); _currentApplication->addServerTemplate(_currentTemplate->getId(), _currentTemplate->getDescriptor()); - _currentTemplate.reset(0); + _currentTemplate.reset(nullptr); } else if(name == "service") { @@ -524,26 +503,26 @@ DescriptorHandler::endElement(const string& name, int line, int column) _currentTemplate->setDescriptor(_currentService->getDescriptor()); } _currentService->finish(); - _currentService.reset(0); + _currentService.reset(nullptr); _currentCommunicator = _currentServer.get(); } else if(name == "service-template") { assert(_currentTemplate.get()); _currentApplication->addServiceTemplate(_currentTemplate->getId(), _currentTemplate->getDescriptor()); - _currentTemplate.reset(0); + _currentTemplate.reset(nullptr); } else if(name == "server-instance") { assert(_currentNode.get() && _currentServerInstance.get()); _currentNode->addServerInstance(_currentServerInstance->getDescriptor()); - _currentServerInstance.reset(0); + _currentServerInstance.reset(nullptr); } else if(name == "service-instance") { assert(_currentServer.get() && _currentServiceInstance.get()); _currentServer->addServiceInstance(_currentServiceInstance->getDescriptor()); - _currentServiceInstance.reset(0); + _currentServiceInstance.reset(nullptr); } else if(name == "properties") { @@ -577,7 +556,7 @@ DescriptorHandler::endElement(const string& name, int line, int column) { assert(false); } - _currentPropertySet.reset(0); + _currentPropertySet.reset(nullptr); } } else if(name == "description") @@ -590,11 +569,6 @@ DescriptorHandler::endElement(const string& name, int line, int column) { _currentApplication->setReplicaGroupDescription(elementValue()); } - else if(_inDbEnv) - { - assert(_currentCommunicator); - _currentCommunicator->setDbEnvDescription(elementValue()); - } else if(_currentCommunicator) { _currentCommunicator->setDescription(elementValue()); @@ -637,10 +611,6 @@ DescriptorHandler::endElement(const string& name, int line, int column) _currentApplication->finishReplicaGroup(); _inReplicaGroup = false; } - else if(name == "dbenv") - { - _inDbEnv = false; - } } catch(const exception& ex) { @@ -811,12 +781,14 @@ DescriptorHandler::isTargetDeployable(const string& target) const return false; } +} + ApplicationDescriptor DescriptorParser::parseDescriptor(const string& descriptor, const Ice::StringSeq& targets, const map<string, string>& variables, - const Ice::CommunicatorPtr& communicator, - const IceGrid::AdminPrx& admin) + const shared_ptr<Ice::Communicator>& communicator, + const shared_ptr<IceGrid::AdminPrx>& admin) { string filename = simplify(descriptor); DescriptorHandler handler(filename, communicator); @@ -827,7 +799,7 @@ DescriptorParser::parseDescriptor(const string& descriptor, } ApplicationDescriptor -DescriptorParser::parseDescriptor(const string& descriptor, const Ice::CommunicatorPtr& communicator) +DescriptorParser::parseDescriptor(const string& descriptor, const shared_ptr<Ice::Communicator>& communicator) { string filename = simplify(descriptor); DescriptorHandler handler(filename, communicator); diff --git a/cpp/src/IceGrid/DescriptorParser.h b/cpp/src/IceGrid/DescriptorParser.h index 2e8f3e2b5f6..eda03f32d53 100644 --- a/cpp/src/IceGrid/DescriptorParser.h +++ b/cpp/src/IceGrid/DescriptorParser.h @@ -8,19 +8,18 @@ namespace IceGrid { -class DescriptorParser +namespace DescriptorParser { -public: - static ApplicationDescriptor parseDescriptor(const std::string&, - const Ice::StringSeq&, - const std::map<std::string, std::string>&, - const Ice::CommunicatorPtr&, - const IceGrid::AdminPrx&); +ApplicationDescriptor parseDescriptor(const std::string&, + const Ice::StringSeq&, + const std::map<std::string, std::string>&, + const std::shared_ptr<Ice::Communicator>&, + const std::shared_ptr<IceGrid::AdminPrx>&); - static ApplicationDescriptor parseDescriptor(const std::string&, const Ice::CommunicatorPtr&); +ApplicationDescriptor parseDescriptor(const std::string&, const std::shared_ptr<Ice::Communicator>&); -}; +} } diff --git a/cpp/src/IceGrid/FileCache.cpp b/cpp/src/IceGrid/FileCache.cpp index 565e7896e62..ba06b25d61d 100644 --- a/cpp/src/IceGrid/FileCache.cpp +++ b/cpp/src/IceGrid/FileCache.cpp @@ -16,12 +16,12 @@ using namespace std; using namespace IceGrid; -FileCache::FileCache(const Ice::CommunicatorPtr& com) : - _messageSizeMax(com->getProperties()->getPropertyAsIntWithDefault("Ice.MessageSizeMax", 1024) * 1024 - 256) +FileCache::FileCache(const shared_ptr<Ice::Communicator>& com) : + _messageMaxSize(com->getProperties()->getPropertyAsIntWithDefault("Ice.MessageMaxSize", 1024) * 1024 - 256) { } -Ice::Long +long long FileCache::getOffsetFromEnd(const string& file, int originalCount) { ifstream is(IceUtilInternal::streamFilename(file).c_str()); // file is a UTF-8 string @@ -108,7 +108,7 @@ FileCache::getOffsetFromEnd(const string& file, int originalCount) if(is.bad()) { - throw FileNotAvailableException("unrecoverable error occured while reading file `" + file + "'"); + throw FileNotAvailableException("unrecoverable error occurred while reading file `" + file + "'"); } if(lines.empty()) @@ -122,13 +122,13 @@ FileCache::getOffsetFromEnd(const string& file, int originalCount) } bool -FileCache::read(const string& file, Ice::Long offset, int size, Ice::Long& newOffset, Ice::StringSeq& lines) +FileCache::read(const string& file, long long offset, int size, long long& newOffset, Ice::StringSeq& lines) { assert(size > 0); - if(size > _messageSizeMax) + if(size > _messageMaxSize) { - size = _messageSizeMax; + size = _messageMaxSize; } if(size <= 5) @@ -205,7 +205,7 @@ FileCache::read(const string& file, Ice::Long offset, int size, Ice::Long& newOf if(is.bad()) { - throw FileNotAvailableException("unrecoverable error occured while reading file `" + file + "'"); + throw FileNotAvailableException("unrecoverable error occurred while reading file `" + file + "'"); } return is.eof(); diff --git a/cpp/src/IceGrid/FileCache.h b/cpp/src/IceGrid/FileCache.h index 12751665402..3a40feac689 100644 --- a/cpp/src/IceGrid/FileCache.h +++ b/cpp/src/IceGrid/FileCache.h @@ -5,27 +5,25 @@ #ifndef ICE_GRID_FILE_CACHE_H #define ICE_GRID_FILE_CACHE_H -#include <IceUtil/Shared.h> #include <Ice/BuiltinSequences.h> #include <Ice/CommunicatorF.h> namespace IceGrid { -class FileCache : public IceUtil::Shared +class FileCache { public: - FileCache(const Ice::CommunicatorPtr&); + FileCache(const std::shared_ptr<Ice::Communicator>&); - Ice::Long getOffsetFromEnd(const std::string&, int); - bool read(const std::string&, Ice::Long, int, Ice::Long&, Ice::StringSeq&); + long long getOffsetFromEnd(const std::string&, int); + bool read(const std::string&, long long , int, long long &, Ice::StringSeq&); private: - const int _messageSizeMax; + const int _messageMaxSize; }; -typedef IceUtil::Handle<FileCache> FileCachePtr; }; diff --git a/cpp/src/IceGrid/FileParserI.cpp b/cpp/src/IceGrid/FileParserI.cpp index fefe366a693..b382c561d9f 100644 --- a/cpp/src/IceGrid/FileParserI.cpp +++ b/cpp/src/IceGrid/FileParserI.cpp @@ -11,12 +11,12 @@ using namespace std; using namespace IceGrid; ApplicationDescriptor -FileParserI::parse(const string& file, const AdminPrx& admin, const Ice::Current& current) +FileParserI::parse(string file, shared_ptr<AdminPrx> admin, const Ice::Current& current) { try { - return DescriptorParser::parseDescriptor(file, Ice::StringSeq(), map<string, string>(), - current.adapter->getCommunicator(), admin); + return DescriptorParser::parseDescriptor(move(file), Ice::StringSeq(), map<string, string>(), + current.adapter->getCommunicator(), move(admin)); } catch(const IceXML::ParserException& e) { diff --git a/cpp/src/IceGrid/FileParserI.h b/cpp/src/IceGrid/FileParserI.h index 1762db9eb09..36178f52e15 100644 --- a/cpp/src/IceGrid/FileParserI.h +++ b/cpp/src/IceGrid/FileParserI.h @@ -7,12 +7,17 @@ #include <IceGrid/FileParser.h> -class FileParserI : public IceGrid::FileParser +namespace IceGrid +{ + +class FileParserI : public FileParser { public: - IceGrid::ApplicationDescriptor - parse(const std::string& file, const IceGrid::AdminPrx& admin, const Ice::Current&); + ApplicationDescriptor + parse(std::string file, std::shared_ptr<AdminPrx> admin, const Ice::Current&) override; }; +} + #endif diff --git a/cpp/src/IceGrid/FileUserAccountMapperI.cpp b/cpp/src/IceGrid/FileUserAccountMapperI.cpp index a9a1ef6dd77..c2189f435e2 100644 --- a/cpp/src/IceGrid/FileUserAccountMapperI.cpp +++ b/cpp/src/IceGrid/FileUserAccountMapperI.cpp @@ -68,9 +68,9 @@ FileUserAccountMapperI::FileUserAccountMapperI(const string& filename) } string -FileUserAccountMapperI::getUserAccount(const string& user, const Ice::Current&) +FileUserAccountMapperI::getUserAccount(string user, const Ice::Current&) { - map<string, string>::const_iterator p = _accounts.find(user); + map<string, string>::const_iterator p = _accounts.find(move(user)); if(p == _accounts.end()) { throw UserAccountNotFoundException(); diff --git a/cpp/src/IceGrid/FileUserAccountMapperI.h b/cpp/src/IceGrid/FileUserAccountMapperI.h index 4630654082e..915455c6d8e 100644 --- a/cpp/src/IceGrid/FileUserAccountMapperI.h +++ b/cpp/src/IceGrid/FileUserAccountMapperI.h @@ -16,7 +16,7 @@ public: FileUserAccountMapperI(const std::string&); - virtual std::string getUserAccount(const std::string&, const Ice::Current&); + std::string getUserAccount(std::string, const Ice::Current&) override; private: diff --git a/cpp/src/IceGrid/Grammar.cpp b/cpp/src/IceGrid/Grammar.cpp index 2e3a629ac00..13023be904c 100644 --- a/cpp/src/IceGrid/Grammar.cpp +++ b/cpp/src/IceGrid/Grammar.cpp @@ -58,8 +58,6 @@ /* Using locations. */ #define YYLSP_NEEDED 0 - - /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE @@ -148,13 +146,9 @@ #define ICE_GRID_ENABLE 295 #define ICE_GRID_DISABLE 296 - - - /* Copy the first part of user declarations. */ #line 1 "src/IceGrid/Grammar.y" - // // Copyright (c) ZeroC, Inc. All rights reserved. // @@ -198,8 +192,6 @@ yyerror(const char* s) parser->invalidCommand(s); } - - /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 1 @@ -225,11 +217,8 @@ typedef int YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 #endif - - /* Copy the second part of user declarations. */ - /* Line 216 of yacc.c. */ #line 235 "src/IceGrid/Grammar.cpp" @@ -386,7 +375,6 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - #if (! defined yyoverflow \ && (! defined __cplusplus \ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) @@ -1356,7 +1344,6 @@ static const yytype_uint8 yystos[] = #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab - /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ @@ -1382,11 +1369,9 @@ do \ } \ while (YYID (0)) - #define YYTERROR 1 #define YYERRCODE 256 - /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ @@ -1412,7 +1397,6 @@ while (YYID (0)) while (YYID (0)) #endif - /* YY_LOCATION_PRINT -- Print the location on the stream. This macro was not mandated originally: define only if we know we won't break user code: when these are the locations we know. */ @@ -1428,7 +1412,6 @@ while (YYID (0)) # endif #endif - /* YYLEX -- calling `yylex' with the right arguments. */ #ifdef YYLEX_PARAM @@ -1462,7 +1445,6 @@ do { \ } \ } while (YYID (0)) - /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ @@ -1495,7 +1477,6 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep) } } - /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ @@ -1549,7 +1530,6 @@ do { \ yy_stack_print ((Bottom), (Top)); \ } while (YYID (0)) - /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ @@ -1597,7 +1577,6 @@ int yydebug; # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ - /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 @@ -1614,8 +1593,6 @@ int yydebug; # define YYMAXDEPTH 10000 #endif - - #if YYERROR_VERBOSE # ifndef yystrlen @@ -1876,9 +1853,26 @@ int yyparse (); #endif /* ! YYPARSE_PARAM */ + default: + break; + } +} +/* Prevent warnings from -Wmissing-prototypes. */ - +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ /*----------. | yyparse. | @@ -1947,8 +1941,6 @@ int yynerrs; YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvsp; - - #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) YYSIZE_T yystacksize = YYINITDEPTH; @@ -1957,7 +1949,6 @@ int yynerrs; action routines. */ YYSTYPE yyval; - /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; @@ -2126,7 +2117,6 @@ yybackup: goto yynewstate; - /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ @@ -2136,7 +2126,6 @@ yydefault: goto yyerrlab; goto yyreduce; - /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ @@ -2154,7 +2143,6 @@ yyreduce: GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; - YY_REDUCE_PRINT (yyn); switch (yyn) { @@ -3309,7 +3297,6 @@ yyreduce: ;} break; - /* Line 1267 of yacc.c. */ #line 3315 "src/IceGrid/Grammar.cpp" default: break; @@ -3337,7 +3324,6 @@ yyreduce: goto yynewstate; - /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ @@ -3383,8 +3369,6 @@ yyerrlab: #endif } - - if (yyerrstatus == 3) { /* If just tried and failed to reuse look-ahead token after an @@ -3408,7 +3392,6 @@ yyerrlab: token. */ goto yyerrlab1; - /*---------------------------------------------------. | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ @@ -3428,7 +3411,6 @@ yyerrorlab: yystate = *yyssp; goto yyerrlab1; - /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ @@ -3453,7 +3435,6 @@ yyerrlab1: if (yyssp == yyss) YYABORT; - yydestruct ("Error: popping", yystos[yystate], yyvsp); YYPOPSTACK (1); @@ -3466,14 +3447,12 @@ yyerrlab1: *++yyvsp = yylval; - /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; - /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ @@ -3523,6 +3502,3 @@ yyreturn: /* Make sure YYID is used. */ return YYID (yyresult); } - - - diff --git a/cpp/src/IceGrid/Grammar.h b/cpp/src/IceGrid/Grammar.h index fb0c3c72213..9b8655708e2 100644 --- a/cpp/src/IceGrid/Grammar.h +++ b/cpp/src/IceGrid/Grammar.h @@ -121,15 +121,9 @@ #define ICE_GRID_ENABLE 295 #define ICE_GRID_DISABLE 296 - - - #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef int YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif - - - diff --git a/cpp/src/IceGrid/IceGridNode.cpp b/cpp/src/IceGrid/IceGridNode.cpp index 7d404da3fe5..22efdc6c601 100644 --- a/cpp/src/IceGrid/IceGridNode.cpp +++ b/cpp/src/IceGrid/IceGridNode.cpp @@ -31,68 +31,61 @@ using namespace Ice; using namespace IceInternal; using namespace IceGrid; -// Work-around for anonymous namspace bug in xlclang++ -#ifdef __ibmxl__ -namespace IceGridNodeNamespace -#else namespace -#endif { -class ProcessI : public Process +class ProcessI final : public Process { public: - ProcessI(const ActivatorPtr&, const ProcessPtr&); + ProcessI(const shared_ptr<Activator>&, const shared_ptr<Process>&); - virtual void shutdown(const Current&); - virtual void writeMessage(const std::string&, Int, const Current&); + void shutdown(const Current&) override; + void writeMessage(std::string, int, const Current&) override; private: - ActivatorPtr _activator; - ProcessPtr _origProcess; + shared_ptr<Activator> _activator; + shared_ptr<Process> _origProcess; }; -class NodeService : public Service +class NodeService final : public Service { public: - NodeService(); - ~NodeService(); - - virtual bool shutdown(); + bool shutdown() override; protected: - virtual bool start(int, char*[], int&); + bool start(int, char*[], int&) override; bool startImpl(int, char*[], int&); - virtual void waitForShutdown(); - virtual bool stop(); - virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int); + void waitForShutdown() override; + bool stop() override; + shared_ptr<Communicator> initializeCommunicator(int&, char*[], const InitializationData&, int) override; private: void usage(const std::string&); - ActivatorPtr _activator; + shared_ptr<Activator> _activator; IceUtil::TimerPtr _timer; - RegistryIPtr _registry; - NodeIPtr _node; - IceInternal::UniquePtr<NodeSessionManager> _sessions; - Ice::ObjectAdapterPtr _adapter; + shared_ptr<RegistryI> _registry; + shared_ptr<NodeI> _node; + unique_ptr<NodeSessionManager> _sessions; + shared_ptr<ObjectAdapter> _adapter; }; -class CollocatedRegistry : public RegistryI +class CollocatedRegistry final : public RegistryI { public: - CollocatedRegistry(const CommunicatorPtr&, const ActivatorPtr&, bool, bool, const std::string&, const std::string&); - virtual void shutdown(); + CollocatedRegistry(const shared_ptr<Communicator>&, const shared_ptr<Activator>&, bool, bool, const std::string&, + const std::string&); + void shutdown() override; private: - ActivatorPtr _activator; + shared_ptr<Activator> _activator; }; #ifdef _WIN32 @@ -114,17 +107,13 @@ setNoIndexingAttribute(const string& path) } -#ifdef __ibmxl__ -using namespace IceGridNodeNamespace; -#endif - -CollocatedRegistry::CollocatedRegistry(const CommunicatorPtr& com, - const ActivatorPtr& activator, +CollocatedRegistry::CollocatedRegistry(const shared_ptr<Communicator>& com, + const shared_ptr<Activator>& activator, bool nowarn, bool readonly, const string& initFromReplica, const string& nodeName) : - RegistryI(com, new TraceLevels(com, "IceGrid.Registry"), nowarn, readonly, initFromReplica, nodeName), + RegistryI(com, make_shared<TraceLevels>(com, "IceGrid.Registry"), nowarn, readonly, initFromReplica, nodeName), _activator(activator) { } @@ -135,7 +124,7 @@ CollocatedRegistry::shutdown() _activator->shutdown(); } -ProcessI::ProcessI(const ActivatorPtr& activator, const ProcessPtr& origProcess) : +ProcessI::ProcessI(const shared_ptr<Activator>& activator, const shared_ptr<Process>& origProcess) : _activator(activator), _origProcess(origProcess) { @@ -148,17 +137,9 @@ ProcessI::shutdown(const Current&) } void -ProcessI::writeMessage(const string& message, Int fd, const Current& current) -{ - _origProcess->writeMessage(message, fd, current); -} - -NodeService::NodeService() -{ -} - -NodeService::~NodeService() +ProcessI::writeMessage(string message, int fd, const Current& current) { + _origProcess->writeMessage(move(message), move(fd), current); } bool @@ -265,7 +246,7 @@ NodeService::startImpl(int argc, char* argv[], int& status) } } - PropertiesPtr properties = communicator()->getProperties(); + auto properties = communicator()->getProperties(); string name = properties->getProperty("IceGrid.Node.Name"); if(name.empty()) @@ -300,15 +281,15 @@ NodeService::startImpl(int argc, char* argv[], int& status) // // Create the activator. // - TraceLevelsPtr traceLevels = new TraceLevels(communicator(), "IceGrid.Node"); - _activator = new Activator(traceLevels); + auto traceLevels = make_shared<TraceLevels>(communicator(), "IceGrid.Node"); + _activator = make_shared<Activator>(traceLevels); // // Collocate the IceGrid registry if we need to. // if(properties->getPropertyAsInt("IceGrid.Node.CollocateRegistry") > 0) { - _registry = new CollocatedRegistry(communicator(), _activator, nowarn, readonly, initFromReplica, name); + _registry = make_shared<CollocatedRegistry>(communicator(), _activator, nowarn, readonly, initFromReplica, name); if(!_registry->start()) { return false; @@ -405,12 +386,12 @@ NodeService::startImpl(int argc, char* argv[], int& status) // string mapperProperty = "IceGrid.Node.UserAccountMapper"; string mapperPropertyValue = properties->getProperty(mapperProperty); - UserAccountMapperPrx mapper; + shared_ptr<UserAccountMapperPrx> mapper; if(!mapperPropertyValue.empty()) { try { - mapper = UserAccountMapperPrx::uncheckedCast(communicator()->propertyToProxy(mapperProperty)); + mapper = uncheckedCast<UserAccountMapperPrx>(communicator()->propertyToProxy(mapperProperty)); } catch(const std::exception& ex) { @@ -426,8 +407,8 @@ NodeService::startImpl(int argc, char* argv[], int& status) { try { - Ice::ObjectPrx object = _adapter->addWithUUID(new FileUserAccountMapperI(userAccountFileProperty)); - mapper = UserAccountMapperPrx::uncheckedCast(object); + auto object = _adapter->addWithUUID(make_shared<FileUserAccountMapperI>(userAccountFileProperty)); + mapper = uncheckedCast<UserAccountMapperPrx>(object); } catch(const exception& ex) { @@ -440,7 +421,7 @@ NodeService::startImpl(int argc, char* argv[], int& status) // // Create a new timer to handle server activation/deactivation timeouts. // - _timer = new IceUtil::Timer(); + _timer = new IceUtil::Timer; // // The IceGrid instance name. @@ -459,7 +440,7 @@ NodeService::startImpl(int argc, char* argv[], int& status) instanceName = "IceGrid"; } - _sessions.reset(new NodeSessionManager(communicator(), instanceName)); + _sessions = make_unique<NodeSessionManager>(communicator(), instanceName); // // Create the server factory. The server factory creates persistent objects @@ -467,18 +448,19 @@ NodeService::startImpl(int argc, char* argv[], int& status) // evictors and object factories necessary to store these objects. // Identity id = stringToIdentity(instanceName + "/Node-" + name); - NodePrx nodeProxy = NodePrx::uncheckedCast(_adapter->createProxy(id)); - _node = new NodeI(_adapter, *_sessions, _activator, _timer, traceLevels, nodeProxy, name, mapper, instanceName); + auto nodeProxy = uncheckedCast<NodePrx>(_adapter->createProxy(id)); + _node = make_shared<NodeI>(_adapter, *_sessions, _activator, _timer, traceLevels, nodeProxy, name, mapper, + instanceName); _adapter->add(_node, nodeProxy->ice_getIdentity()); - _adapter->addDefaultServant(new NodeServerAdminRouter(_node), _node->getServerAdminCategory()); + _adapter->addDefaultServant(make_shared<NodeServerAdminRouter>(_node), _node->getServerAdminCategory()); // // Keep the old default servant for backward compatibility with IceGrid registries 3.5 that // still forward requests to this category. This can be removed when we decide to break // backward compatibility with 3.5 registries. // - _adapter->addDefaultServant(new NodeServerAdminRouter(_node), instanceName + "-NodeRouter"); + _adapter->addDefaultServant(make_shared<NodeServerAdminRouter>(_node), instanceName + "-NodeRouter"); // // Start the platform info thread if needed. @@ -514,13 +496,9 @@ NodeService::startImpl(int argc, char* argv[], int& status) if(!_registry && properties->getPropertyAsInt("Ice.Admin.Enabled") > 0) { // Replace Admin facet - ProcessPtr origProcess = ProcessPtr::dynamicCast(communicator()->removeAdminFacet("Process")); - communicator()->addAdminFacet(new ProcessI(_activator, origProcess), "Process"); - - Identity adminId; - adminId.name = "NodeAdmin-" + name; - adminId.category = instanceName; - communicator()->createAdmin(_adapter, adminId); + auto origProcess = dynamic_pointer_cast<Process>(communicator()->removeAdminFacet("Process")); + communicator()->addAdminFacet(make_shared<ProcessI>(_activator, origProcess), "Process"); + communicator()->createAdmin(_adapter, { "NodeAdmin-" + name, instanceName }); } // @@ -561,11 +539,9 @@ NodeService::startImpl(int argc, char* argv[], int& status) { try { - Ice::Identity regId; - regId.category = instanceName; - regId.name = "Registry"; + Ice::Identity regId = { "Registry", instanceName }; - RegistryPrx registry = RegistryPrx::checkedCast(communicator()->getDefaultLocator()->findObjectById(regId)); + auto registry = checkedCast<RegistryPrx>(communicator()->getDefaultLocator()->findObjectById(regId)); if(!registry) { throw runtime_error("invalid registry"); @@ -573,7 +549,7 @@ NodeService::startImpl(int argc, char* argv[], int& status) registry = registry->ice_preferSecure(true); // Use SSL if available. - IceGrid::AdminSessionPrx session; + shared_ptr<AdminSessionPrx> session; if(communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.AuthenticateUsingSSL")) { session = registry->createAdminSessionFromSecureConnection(); @@ -600,9 +576,9 @@ NodeService::startImpl(int argc, char* argv[], int& status) } assert(session); - AdminPrx admin = session->getAdmin(); + auto admin = session->getAdmin(); map<string, string> vars; - ApplicationDescriptor app = DescriptorParser::parseDescriptor(desc, targets, vars, communicator(), admin); + auto app = DescriptorParser::parseDescriptor(desc, targets, vars, communicator(), admin); try { @@ -681,7 +657,7 @@ NodeService::stop() { assert(false); } - _timer = 0; + _timer = nullptr; } // @@ -692,7 +668,7 @@ NodeService::stop() try { _adapter->deactivate(); - _adapter = 0; + _adapter = nullptr; } catch(const std::exception& ex) { @@ -737,7 +713,7 @@ NodeService::stop() if(_node) { _node->shutdown(); - _node = 0; + _node = nullptr; } // @@ -746,13 +722,13 @@ NodeService::stop() if(_registry) { _registry->stop(); - _registry = 0; + _registry = nullptr; } return true; } -CommunicatorPtr +shared_ptr<Communicator> NodeService::initializeCommunicator(int& argc, char* argv[], const InitializationData& initializationData, int version) @@ -768,20 +744,20 @@ NodeService::initializeCommunicator(int& argc, char* argv[], vTypes.push_back(""); vTypes.push_back("Admin"); - for(vector<string>::const_iterator p = vTypes.begin(); p != vTypes.end(); ++p) + for(const auto& type : vTypes) { - string verifier = "IceGrid.Registry." + *p + "PermissionsVerifier"; + string verifier = "IceGrid.Registry." + type + "PermissionsVerifier"; if(initData.properties->getProperty(verifier).empty()) { - string cryptPasswords = initData.properties->getProperty("IceGrid.Registry." + *p + "CryptPasswords"); + string cryptPasswords = initData.properties->getProperty("IceGrid.Registry." + type + "CryptPasswords"); if(!cryptPasswords.empty()) { initData.properties->setProperty("Ice.Plugin.Glacier2CryptPermissionsVerifier", "Glacier2CryptPermissionsVerifier:createCryptPermissionsVerifier"); - initData.properties->setProperty("Glacier2CryptPermissionsVerifier.IceGrid.Registry." + *p + + initData.properties->setProperty("Glacier2CryptPermissionsVerifier.IceGrid.Registry." + type + "PermissionsVerifier", cryptPasswords); } } diff --git a/cpp/src/IceGrid/IceGridRegistry.cpp b/cpp/src/IceGrid/IceGridRegistry.cpp index 34cea54dc50..04f6c7f2f33 100644 --- a/cpp/src/IceGrid/IceGridRegistry.cpp +++ b/cpp/src/IceGrid/IceGridRegistry.cpp @@ -22,35 +22,24 @@ class RegistryService : public Service { public: - RegistryService(); - ~RegistryService(); - - virtual bool shutdown(); + bool shutdown() override; protected: - virtual bool start(int, char*[], int&); - virtual void waitForShutdown(); - virtual bool stop(); - virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int); + bool start(int, char*[], int&) override; + void waitForShutdown() override; + bool stop() override; + shared_ptr<Communicator> initializeCommunicator(int&, char*[], const InitializationData&, int) override; private: void usage(const std::string&); - RegistryIPtr _registry; + shared_ptr<RegistryI> _registry; }; } // End of namespace IceGrid -RegistryService::RegistryService() -{ -} - -RegistryService::~RegistryService() -{ -} - bool RegistryService::shutdown() { @@ -111,7 +100,7 @@ RegistryService::start(int argc, char* argv[], int& status) return false; } - Ice::PropertiesPtr properties = communicator()->getProperties(); + auto properties = communicator()->getProperties(); // // Warn the user that setting Ice.ThreadPool.Server isn't useful. @@ -123,9 +112,9 @@ RegistryService::start(int argc, char* argv[], int& status) out << "you should set individual adapter thread pools instead."; } - TraceLevelsPtr traceLevels = new TraceLevels(communicator(), "IceGrid.Registry"); + auto traceLevels = make_shared<TraceLevels>(communicator(), "IceGrid.Registry"); - _registry = new RegistryI(communicator(), traceLevels, nowarn, readonly, initFromReplica, ""); + _registry = make_shared<RegistryI>(communicator(), traceLevels, nowarn, readonly, initFromReplica, ""); if(!_registry->start()) { return false; @@ -153,7 +142,7 @@ RegistryService::stop() return true; } -CommunicatorPtr +shared_ptr<Communicator> RegistryService::initializeCommunicator(int& argc, char* argv[], const InitializationData& initializationData, int version) diff --git a/cpp/src/IceGrid/Internal.ice b/cpp/src/IceGrid/Internal.ice index dabf62015e4..d273e2879ef 100644 --- a/cpp/src/IceGrid/Internal.ice +++ b/cpp/src/IceGrid/Internal.ice @@ -9,7 +9,6 @@ #include <Ice/Identity.ice> #include <Ice/BuiltinSequences.ice> #include <Ice/ProcessF.ice> -#include <Ice/Properties.ice> #include <Glacier2/Session.ice> #include <IceGrid/Admin.ice> @@ -22,6 +21,8 @@ local exception SynchronizationException { } +// This class is no longer used. We keep it only for interop with IceGrid 3.7. +// class InternalDbEnvDescriptor { /** The name of the database environment. */ @@ -111,7 +112,7 @@ class InternalServerDescriptor /** The indirect object adapters. */ InternalAdapterDescriptorSeq adapters; - /** The database environments. */ + // Not used, always empty. Kept only for interop with IceGrid 3.7. InternalDbEnvDescriptorSeq dbEnvs; /** The configuration files of the server. */ @@ -514,11 +515,11 @@ exception ReplicaActiveException enum TopicName { - RegistryObserverTopicName, - NodeObserverTopicName, - ApplicationObserverTopicName, - AdapterObserverTopicName, - ObjectObserverTopicName + RegistryObserver, + NodeObserver, + ApplicationObserver, + AdapterObserver, + ObjectObserver } interface DatabaseObserver extends ApplicationObserver, ObjectObserver, AdapterObserver diff --git a/cpp/src/IceGrid/InternalRegistryI.cpp b/cpp/src/IceGrid/InternalRegistryI.cpp index 379743d6cf6..a1db6e6e49e 100644 --- a/cpp/src/IceGrid/InternalRegistryI.cpp +++ b/cpp/src/IceGrid/InternalRegistryI.cpp @@ -21,47 +21,43 @@ using namespace std; using namespace IceGrid; -InternalRegistryI::InternalRegistryI(const RegistryIPtr& registry, - const DatabasePtr& database, - const ReapThreadPtr& reaper, - const WellKnownObjectsManagerPtr& wellKnownObjects, +InternalRegistryI::InternalRegistryI(const shared_ptr<RegistryI>& registry, + const shared_ptr<Database>& database, + const shared_ptr<ReapThread>& reaper, + const shared_ptr<WellKnownObjectsManager>& wellKnownObjects, ReplicaSessionManager& session) : _registry(registry), _database(database), _reaper(reaper), _wellKnownObjects(wellKnownObjects), - _fileCache(new FileCache(database->getCommunicator())), + _fileCache(make_shared<FileCache>(database->getCommunicator())), _session(session) { - Ice::PropertiesPtr properties = database->getCommunicator()->getProperties(); - _nodeSessionTimeout = properties->getPropertyAsIntWithDefault("IceGrid.Registry.NodeSessionTimeout", 30); - _replicaSessionTimeout = properties->getPropertyAsIntWithDefault("IceGrid.Registry.ReplicaSessionTimeout", 30); + auto properties = database->getCommunicator()->getProperties(); + _nodeSessionTimeout = + chrono::seconds(properties->getPropertyAsIntWithDefault("IceGrid.Registry.NodeSessionTimeout", 30)); + _replicaSessionTimeout = + chrono::seconds(properties->getPropertyAsIntWithDefault("IceGrid.Registry.ReplicaSessionTimeout", 30)); _requireNodeCertCN = properties->getPropertyAsIntWithDefault("IceGrid.Registry.RequireNodeCertCN", 0); _requireReplicaCertCN = properties->getPropertyAsIntWithDefault("IceGrid.Registry.RequireReplicaCertCN", 0); } -InternalRegistryI::~InternalRegistryI() -{ -} - -NodeSessionPrx -InternalRegistryI::registerNode(const InternalNodeInfoPtr& info, - const NodePrx& node, - const LoadInfo& load, +shared_ptr<NodeSessionPrx> +InternalRegistryI::registerNode(shared_ptr<InternalNodeInfo> info, shared_ptr<NodePrx> node, LoadInfo load, const Ice::Current& current) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); - const Ice::LoggerPtr logger = traceLevels->logger; + const auto traceLevels = _database->getTraceLevels(); + const auto logger = traceLevels->logger; if(!info || !node) { - return 0; + return nullptr; } if(_requireNodeCertCN) { try { - IceSSL::ConnectionInfoPtr sslConnInfo = IceSSL::ConnectionInfoPtr::dynamicCast(current.con->getInfo()); + auto sslConnInfo = dynamic_pointer_cast<IceSSL::ConnectionInfo>(current.con->getInfo()); if(sslConnInfo) { if (sslConnInfo->certs.empty() || @@ -102,8 +98,8 @@ InternalRegistryI::registerNode(const InternalNodeInfoPtr& info, try { - NodeSessionIPtr session = new NodeSessionI(_database, node, info, _nodeSessionTimeout, load); - _reaper->add(new SessionReapable<NodeSessionI>(logger, session), _nodeSessionTimeout); + auto session = NodeSessionI::create(_database, node, info, _nodeSessionTimeout, load); + _reaper->add(make_shared<SessionReapable<NodeSessionI>>(logger, session), _nodeSessionTimeout); return session->getProxy(); } catch(const Ice::ObjectAdapterDeactivatedException&) @@ -112,23 +108,23 @@ InternalRegistryI::registerNode(const InternalNodeInfoPtr& info, } } -ReplicaSessionPrx -InternalRegistryI::registerReplica(const InternalReplicaInfoPtr& info, - const InternalRegistryPrx& prx, +shared_ptr<ReplicaSessionPrx> +InternalRegistryI::registerReplica(shared_ptr<InternalReplicaInfo> info, + shared_ptr<InternalRegistryPrx> prx, const Ice::Current& current) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); - const Ice::LoggerPtr logger = traceLevels->logger; + const auto traceLevels = _database->getTraceLevels(); + const auto logger = traceLevels->logger; if(!info || !prx) { - return 0; + return nullptr; } if(_requireReplicaCertCN) { try { - IceSSL::ConnectionInfoPtr sslConnInfo = IceSSL::ConnectionInfoPtr::dynamicCast(current.con->getInfo()); + auto sslConnInfo = dynamic_pointer_cast<IceSSL::ConnectionInfo>(current.con->getInfo()); if(sslConnInfo) { if (sslConnInfo->certs.empty() || @@ -169,8 +165,8 @@ InternalRegistryI::registerReplica(const InternalReplicaInfoPtr& info, try { - ReplicaSessionIPtr s = new ReplicaSessionI(_database, _wellKnownObjects, info, prx, _replicaSessionTimeout); - _reaper->add(new SessionReapable<ReplicaSessionI>(logger, s), _replicaSessionTimeout); + auto s = ReplicaSessionI::create(_database, _wellKnownObjects, info, prx, _replicaSessionTimeout); + _reaper->add(make_shared<SessionReapable<ReplicaSessionI>>(logger, s), _replicaSessionTimeout); return s->getProxy(); } catch(const Ice::ObjectAdapterDeactivatedException&) @@ -180,9 +176,9 @@ InternalRegistryI::registerReplica(const InternalReplicaInfoPtr& info, } void -InternalRegistryI::registerWithReplica(const InternalRegistryPrx& replica, const Ice::Current&) +InternalRegistryI::registerWithReplica(shared_ptr<InternalRegistryPrx> replica, const Ice::Current&) { - _session.create(replica); + _session.create(move(replica)); } NodePrxSeq @@ -192,7 +188,7 @@ InternalRegistryI::getNodes(const Ice::Current&) const Ice::ObjectProxySeq proxies = _database->getInternalObjectsByType(Node::ice_staticId()); for(Ice::ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) { - nodes.push_back(NodePrx::uncheckedCast(*p)); + nodes.push_back(Ice::uncheckedCast<NodePrx>(*p)); } return nodes; } @@ -204,25 +200,25 @@ InternalRegistryI::getReplicas(const Ice::Current&) const Ice::ObjectProxySeq proxies = _database->getObjectsByType(InternalRegistry::ice_staticId()); for(Ice::ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) { - replicas.push_back(InternalRegistryPrx::uncheckedCast(*p)); + replicas.push_back(Ice::uncheckedCast<InternalRegistryPrx>(*p)); } return replicas; } ApplicationInfoSeq -InternalRegistryI::getApplications(Ice::Long& serial, const Ice::Current&) const +InternalRegistryI::getApplications(long long& serial, const Ice::Current&) const { return _database->getApplications(serial); } AdapterInfoSeq -InternalRegistryI::getAdapters(Ice::Long& serial, const Ice::Current&) const +InternalRegistryI::getAdapters(long long& serial, const Ice::Current&) const { return _database->getAdapters(serial); } ObjectInfoSeq -InternalRegistryI::getObjects(Ice::Long& serial, const Ice::Current&) const +InternalRegistryI::getObjects(long long& serial, const Ice::Current&) const { return _database->getObjects(serial); } @@ -233,14 +229,14 @@ InternalRegistryI::shutdown(const Ice::Current& /*current*/) const _registry->shutdown(); } -Ice::Long -InternalRegistryI::getOffsetFromEnd(const string& filename, int count, const Ice::Current&) const +long long +InternalRegistryI::getOffsetFromEnd(string filename, int count, const Ice::Current&) const { return _fileCache->getOffsetFromEnd(getFilePath(filename), count); } bool -InternalRegistryI::read(const string& filename, Ice::Long pos, int size, Ice::Long& newPos, Ice::StringSeq& lines, +InternalRegistryI::read(string filename, long long pos, int size, long long& newPos, Ice::StringSeq& lines, const Ice::Current&) const { return _fileCache->read(getFilePath(filename), pos, size, newPos, lines); diff --git a/cpp/src/IceGrid/InternalRegistryI.h b/cpp/src/IceGrid/InternalRegistryI.h index 9333650f7ae..f90637f66c6 100644 --- a/cpp/src/IceGrid/InternalRegistryI.h +++ b/cpp/src/IceGrid/InternalRegistryI.h @@ -12,61 +12,52 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - class FileCache; -typedef IceUtil::Handle<FileCache> FileCachePtr; - -class WellKnownObjectsManager; -typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr; - class ReapThread; -typedef IceUtil::Handle<ReapThread> ReapThreadPtr; - class RegistryI; -typedef IceUtil::Handle<RegistryI> RegistryIPtr; - class ReplicaSessionManager; +class WellKnownObjectsManager; class InternalRegistryI : public InternalRegistry { public: - InternalRegistryI(const RegistryIPtr&, const DatabasePtr&, const ReapThreadPtr&, - const WellKnownObjectsManagerPtr&, ReplicaSessionManager&); - virtual ~InternalRegistryI(); + InternalRegistryI(const std::shared_ptr<RegistryI>&, const std::shared_ptr<Database>&, + const std::shared_ptr<ReapThread>&, const std::shared_ptr<WellKnownObjectsManager>&, + ReplicaSessionManager&); - virtual NodeSessionPrx registerNode(const InternalNodeInfoPtr&, const NodePrx&, const LoadInfo&, - const Ice::Current&); - virtual ReplicaSessionPrx registerReplica(const InternalReplicaInfoPtr&, const InternalRegistryPrx&, - const Ice::Current&); + std::shared_ptr<NodeSessionPrx> registerNode(std::shared_ptr<InternalNodeInfo>, std::shared_ptr<NodePrx>, LoadInfo, + const Ice::Current&) override; + std::shared_ptr<ReplicaSessionPrx> registerReplica(std::shared_ptr<InternalReplicaInfo>, + std::shared_ptr<InternalRegistryPrx>, + const Ice::Current&) override; - virtual void registerWithReplica(const InternalRegistryPrx&, const Ice::Current&); + void registerWithReplica(std::shared_ptr<InternalRegistryPrx>, const Ice::Current&) override; - virtual NodePrxSeq getNodes(const Ice::Current&) const; - virtual InternalRegistryPrxSeq getReplicas(const Ice::Current&) const; + NodePrxSeq getNodes(const Ice::Current&) const override; + InternalRegistryPrxSeq getReplicas(const Ice::Current&) const override; - virtual ApplicationInfoSeq getApplications(Ice::Long&, const Ice::Current&) const; - virtual AdapterInfoSeq getAdapters(Ice::Long&, const Ice::Current&) const; - virtual ObjectInfoSeq getObjects(Ice::Long&, const Ice::Current&) const; + ApplicationInfoSeq getApplications(long long&, const Ice::Current&) const override; + AdapterInfoSeq getAdapters(long long&, const Ice::Current&) const override; + ObjectInfoSeq getObjects(long long&, const Ice::Current&) const override; - virtual void shutdown(const Ice::Current&) const; + void shutdown(const Ice::Current&) const override; - virtual Ice::Long getOffsetFromEnd(const std::string&, int, const Ice::Current&) const; - virtual bool read(const std::string&, Ice::Long, int, Ice::Long&, Ice::StringSeq&, const Ice::Current&) const; + long long getOffsetFromEnd(std::string, int, const Ice::Current&) const override; + bool read(std::string, long long, int, long long&, Ice::StringSeq&, const Ice::Current&) const override; private: std::string getFilePath(const std::string&) const; - const RegistryIPtr _registry; - const DatabasePtr _database; - const ReapThreadPtr _reaper; - const WellKnownObjectsManagerPtr _wellKnownObjects; - const FileCachePtr _fileCache; + const std::shared_ptr<RegistryI> _registry; + const std::shared_ptr<Database> _database; + const std::shared_ptr<ReapThread> _reaper; + const std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects; + const std::shared_ptr<FileCache> _fileCache; ReplicaSessionManager& _session; - int _nodeSessionTimeout; - int _replicaSessionTimeout; + std::chrono::seconds _nodeSessionTimeout; + std::chrono::seconds _replicaSessionTimeout; bool _requireNodeCertCN; bool _requireReplicaCertCN; }; diff --git a/cpp/src/IceGrid/LocatorI.cpp b/cpp/src/IceGrid/LocatorI.cpp index ae21fa49175..e6da5a12384 100644 --- a/cpp/src/IceGrid/LocatorI.cpp +++ b/cpp/src/IceGrid/LocatorI.cpp @@ -8,153 +8,26 @@ #include <IceGrid/WellKnownObjectsManager.h> #include <IceGrid/SessionI.h> #include <IceGrid/Util.h> +#include <IceGrid/Internal.h> using namespace std; +using namespace std::chrono; using namespace IceGrid; -namespace IceGrid +namespace { -// -// Callback from asynchronous call to adapter->getDirectProxy() invoked in LocatorI::findAdapterById_async(). -// -class AdapterGetDirectProxyCallback : public virtual IceUtil::Shared -{ -public: - - AdapterGetDirectProxyCallback(const LocatorIPtr& locator, const LocatorAdapterInfo& adapter) : - _locator(locator), _adapter(adapter) - { - } - - virtual void response(const ::Ice::ObjectPrx& obj) - { - assert(obj); - _locator->getDirectProxyResponse(_adapter, obj); - } - - virtual void exception(const ::Ice::Exception& e) - { - _locator->getDirectProxyException(_adapter, e); - } - -private: - - const LocatorIPtr _locator; - const LocatorAdapterInfo _adapter; -}; - -class AdapterActivateCallback : public virtual IceUtil::Shared -{ -public: - - AdapterActivateCallback(const LocatorIPtr& locator, const LocatorAdapterInfo& adapter) : - _locator(locator), _adapter(adapter) - { - } - - virtual void response(const ::Ice::ObjectPrx& obj) - { - _locator->getDirectProxyResponse(_adapter, obj); - } - - virtual void exception(const ::Ice::Exception& ex) - { - _locator->getDirectProxyException(_adapter, ex); - } - -private: - - const LocatorIPtr _locator; - const LocatorAdapterInfo _adapter; -}; - -// -// Callback from asynchrnous call to LocatorI::findAdapterById_async() -// invoked in LocatorI::findObjectById_async(). -// -class AMD_Locator_findAdapterByIdI : public Ice::AMD_Locator_findAdapterById +class AdapterRequest final : public LocatorI::Request { public: - AMD_Locator_findAdapterByIdI(const Ice::AMD_Locator_findObjectByIdPtr& cb, const Ice::ObjectPrx& obj) : - _cb(cb), - _obj(obj) - { - } - - virtual void ice_response(const ::Ice::ObjectPrx& obj) - { - // - // If the adapter dummy direct proxy is not null, return a - // proxy containing the identity we were looking for and the - // endpoints of the adapter. - // - // If null, return the proxy registered with the object - // registry. - // - if(obj) - { - _cb->ice_response(obj->ice_identity(_obj->ice_getIdentity())); - } - else - { - _cb->ice_response(_obj); - } - } - - virtual void ice_exception(const ::Ice::Exception& ex) - { - try - { - ex.ice_throw(); - } - catch(const Ice::AdapterNotFoundException&) - { - // - // We couldn't find the adapter, we ignore and return the - // original proxy containing the adapter id. - // - _cb->ice_response(_obj); - return; - } - catch(const Ice::Exception& e) - { - // - // Rethrow unexpected exception. - // - _cb->ice_exception(e); - return; - } - - assert(false); - } - - virtual void ice_exception(const std::exception& ex) - { - _cb->ice_exception(ex); - } - - virtual void ice_exception() - { - _cb->ice_exception(); - } - -private: - - const Ice::AMD_Locator_findObjectByIdPtr _cb; - const Ice::ObjectPrx _obj; -}; - -class AdapterRequest : public LocatorI::Request -{ -public: - - AdapterRequest(const Ice::AMD_Locator_findAdapterByIdPtr& amdCB, - const LocatorIPtr& locator, + AdapterRequest(function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)> exception, + const shared_ptr<LocatorI>& locator, const Ice::EncodingVersion& encoding, const LocatorAdapterInfo& adapter) : - _amdCB(amdCB), + _response(move(response)), + _exception(move(exception)), _locator(locator), _encoding(encoding), _adapter(adapter), @@ -163,20 +36,20 @@ public: assert(_adapter.proxy); } - virtual void - execute() + void + execute() override { - _locator->getDirectProxy(_adapter, this); + _locator->getDirectProxy(_adapter, shared_from_this()); } - virtual void - activating(const string&) + void + activating(const string&) override { // Nothing to do. } - virtual void - response(const std::string& id, const Ice::ObjectPrx& proxy) + void + response(const std::string& id, const shared_ptr<Ice::ObjectPrx>& proxy) override { assert(proxy); @@ -185,49 +58,52 @@ public: // if(!IceInternal::isSupported(_encoding, proxy->ice_getEncodingVersion())) { - exception(id, Ice::UnsupportedEncodingException(__FILE__, - __LINE__, - "server doesn't support requested encoding", - _encoding, - proxy->ice_getEncodingVersion())); + exception(id, + make_exception_ptr(Ice::UnsupportedEncodingException(__FILE__, __LINE__, + "server doesn't support requested encoding", + _encoding, + proxy->ice_getEncodingVersion()))); return; } - _amdCB->ice_response(proxy->ice_identity(Ice::stringToIdentity("dummy"))); + _response(proxy->ice_identity(Ice::stringToIdentity("dummy"))); } - virtual void - exception(const std::string&, const Ice::Exception& ex) + void + exception(const std::string&, exception_ptr ex) override { if(_traceLevels->locator > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); out << "couldn't resolve adapter`" << _adapter.id << "' endpoints:\n" << toString(ex); } - _amdCB->ice_response(0); + _response(nullptr); } private: - const Ice::AMD_Locator_findAdapterByIdPtr _amdCB; - const LocatorIPtr _locator; + const function<void(const shared_ptr<Ice::ObjectPrx>&)> _response; + const function<void(exception_ptr)> _exception; + const shared_ptr<LocatorI> _locator; const Ice::EncodingVersion _encoding; const LocatorAdapterInfo _adapter; - const TraceLevelsPtr _traceLevels; + const shared_ptr<TraceLevels> _traceLevels; }; -class ReplicaGroupRequest : public LocatorI::Request, public IceUtil::Mutex +class ReplicaGroupRequest final : public LocatorI::Request { public: - ReplicaGroupRequest(const Ice::AMD_Locator_findAdapterByIdPtr& amdCB, - const LocatorIPtr& locator, + ReplicaGroupRequest(function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)> exception, + const shared_ptr<LocatorI>& locator, const string& id, const Ice::EncodingVersion& encoding, const LocatorAdapterInfoSeq& adapters, int count, - Ice::ObjectPrx firstProxy) : - _amdCB(amdCB), + shared_ptr<Ice::ObjectPrx> firstProxy) : + _response(move(response)), + _exception(move(exception)), _locator(locator), _id(id), _encoding(encoding), @@ -254,15 +130,15 @@ public: } } - virtual void - execute() + void + execute() override { // // Otherwise, request as many adapters as required. // LocatorAdapterInfoSeq adapters; { - Lock sync(*this); + lock_guard lock(_mutex); for(unsigned int i = static_cast<unsigned int>(_proxies.size()); i < _count; ++i) { if(_lastAdapter == _adapters.end()) @@ -286,17 +162,17 @@ public: } } - for(LocatorAdapterInfoSeq::const_iterator p = adapters.begin(); p != adapters.end(); ++p) + for(const auto& adapter : adapters) { - if(_locator->getDirectProxy(*p, this)) + if(_locator->getDirectProxy(adapter, shared_from_this())) { - activating(p->id); + activating(adapter.id); } } } - virtual void - activating(const string&) + void + activating(const string&) override { // // An adapter is being activated. Don't wait for the activation to complete. Instead, @@ -305,7 +181,7 @@ public: LocatorAdapterInfo adapter; do { - Lock sync(*this); + lock_guard lock(_mutex); if(_lastAdapter == _adapters.end()) { break; @@ -313,23 +189,23 @@ public: adapter = *_lastAdapter; ++_lastAdapter; } - while(_locator->getDirectProxy(adapter, this)); + while(_locator->getDirectProxy(adapter, shared_from_this())); } - virtual void - exception(const string& /*id*/, const Ice::Exception& ex) + void + exception(const string&, exception_ptr exptr) override { LocatorAdapterInfo adapter; { - Lock sync(*this); + lock_guard lock(_mutex); if(_proxies.size() == _count) // Nothing to do if we already sent the response. { return; } - if(!_exception.get()) + if(!_exptr) { - _exception.reset(ex.ice_clone()); + _exptr = exptr; } if(_lastAdapter == _adapters.end()) @@ -354,30 +230,31 @@ public: if(adapter.proxy) { - if(_locator->getDirectProxy(adapter, this)) + if(_locator->getDirectProxy(adapter, shared_from_this())) { activating(adapter.id); } } } - virtual void - response(const string& id, const Ice::ObjectPrx& proxy) + void + response(const string& id, const shared_ptr<Ice::ObjectPrx>& proxy) override { // // Ensure the server supports the request encoding. // if(!IceInternal::isSupported(_encoding, proxy->ice_getEncodingVersion())) { - exception(id, Ice::UnsupportedEncodingException(__FILE__, - __LINE__, - "server doesn't support requested encoding", - _encoding, - proxy->ice_getEncodingVersion())); + exception(id, + make_exception_ptr(Ice::UnsupportedEncodingException(__FILE__, + __LINE__, + "server doesn't support requested encoding", + _encoding, + proxy->ice_getEncodingVersion()))); return; } - Lock sync(*this); + lock_guard lock(_mutex); assert(proxy); if(_proxies.size() == _count) // Nothing to do if we already sent the response. { @@ -403,7 +280,7 @@ private: { if(_proxies.size() == 1) { - _amdCB->ice_response(_proxies.begin()->second); + _response(_proxies.begin()->second); } else if(_proxies.empty()) { @@ -411,58 +288,63 @@ private: // If there's no proxies, it's either because we couldn't contact the adapters or // because the replica group has no members. // - assert(_exception.get() || _adapters.empty()); + assert(_exptr || _adapters.empty()); if(_traceLevels->locator > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); out << "couldn't resolve replica group `" << _id << "' endpoints:\n"; - out << (_exception.get() ? toString(*_exception) : string("replica group is empty")); + out << (_exptr ? toString(_exptr) : string("replica group is empty")); } - _amdCB->ice_response(0); + _response(nullptr); } else if(_proxies.size() > 1) { Ice::EndpointSeq endpoints; endpoints.reserve(_proxies.size()); - for(LocatorAdapterInfoSeq::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + for(const auto& adapter : _adapters) { - map<string, Ice::ObjectPrx>::const_iterator q = _proxies.find(p->id); + auto q = _proxies.find(adapter.id); if(q != _proxies.end()) { - Ice::EndpointSeq edpts = q->second->ice_getEndpoints(); + auto edpts = q->second->ice_getEndpoints(); endpoints.insert(endpoints.end(), edpts.begin(), edpts.end()); + } } - Ice::ObjectPrx proxy = _locator->getCommunicator()->stringToProxy("dummy:default"); - _amdCB->ice_response(proxy->ice_endpoints(endpoints)); + auto proxy = _locator->getCommunicator()->stringToProxy("dummy:default"); + _response(proxy->ice_endpoints(endpoints)); } } - const Ice::AMD_Locator_findAdapterByIdPtr _amdCB; - const LocatorIPtr _locator; + const function<void(const shared_ptr<Ice::ObjectPrx>&)> _response; + const function<void(exception_ptr)> _exception; + const shared_ptr<LocatorI> _locator; const std::string _id; const Ice::EncodingVersion _encoding; LocatorAdapterInfoSeq _adapters; - const TraceLevelsPtr _traceLevels; + const shared_ptr<TraceLevels> _traceLevels; unsigned int _count; LocatorAdapterInfoSeq::const_iterator _lastAdapter; - std::map<std::string, Ice::ObjectPrx> _proxies; - IceInternal::UniquePtr<Ice::Exception> _exception; + std::map<std::string, shared_ptr<Ice::ObjectPrx>> _proxies; + exception_ptr _exptr; + std::mutex _mutex; }; -class RoundRobinRequest : public LocatorI::Request, SynchronizationCallback, public IceUtil::Mutex +class RoundRobinRequest final : public LocatorI::Request, SynchronizationCallback { public: - RoundRobinRequest(const Ice::AMD_Locator_findAdapterByIdPtr& amdCB, - const LocatorIPtr& locator, - const DatabasePtr database, + RoundRobinRequest(function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)> exception, + const shared_ptr<LocatorI>& locator, + const shared_ptr<Database> database, const string& id, const Ice::Current& current, const LocatorAdapterInfoSeq& adapters, int count) : - _amdCB(amdCB), + _response(move(response)), + _exception(move(exception)), _locator(locator), _database(database), _id(id), @@ -477,8 +359,8 @@ public: assert(_adapters.empty() || _count > 0); } - virtual void - execute() + void + execute() override { if(_adapters.empty()) { @@ -487,26 +369,26 @@ public: Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); out << "couldn't resolve replica group `" << _id << "' endpoints:\nreplica group is empty"; } - _amdCB->ice_response(0); + _response(nullptr); return; } LocatorAdapterInfo adapter = _adapters[0]; assert(adapter.proxy); - if(_locator->getDirectProxy(adapter, this)) + if(_locator->getDirectProxy(adapter, shared_from_this())) { activating(adapter.id); } } - virtual void - activating(const string& id) + void + activating(const string& id) override { LocatorAdapterInfo adapter; adapter.id = id; do { - Lock sync(*this); + lock_guard lock(_mutex); if(_adapters.empty() || _waitForActivation) { return; @@ -514,26 +396,27 @@ public: _activatingOrFailed.insert(adapter.id); adapter = nextAdapter(); } - while(adapter.proxy && _locator->getDirectProxy(adapter, this)); + while(adapter.proxy && _locator->getDirectProxy(adapter, shared_from_this())); } - virtual void - response(const std::string& id, const Ice::ObjectPrx& proxy) + void + response(const std::string& id, const shared_ptr<Ice::ObjectPrx>& proxy) override { // // Ensure the server supports the request encoding. // if(!IceInternal::isSupported(_encoding, proxy->ice_getEncodingVersion())) { - exception(id, Ice::UnsupportedEncodingException(__FILE__, - __LINE__, - "server doesn't support requested encoding", - _encoding, - proxy->ice_getEncodingVersion())); + exception(id, + make_exception_ptr(Ice::UnsupportedEncodingException(__FILE__, + __LINE__, + "server doesn't support requested encoding", + _encoding, + proxy->ice_getEncodingVersion()))); return; } - Lock sync(*this); + lock_guard lock(_mutex); assert(proxy); if(_adapters.empty() || id != _adapters[0].id) { @@ -542,30 +425,30 @@ public: if(_count > 1) { - Ice::ObjectPrx p = proxy->ice_identity(Ice::stringToIdentity("dummy")); - LocatorI::RequestPtr request = - new ReplicaGroupRequest(_amdCB, _locator, _id, _encoding, _adapters, _count, p); + auto p = proxy->ice_identity(Ice::stringToIdentity("dummy")); + shared_ptr<LocatorI::Request> request = + make_shared<ReplicaGroupRequest>(_response, _exception, _locator, _id, _encoding, _adapters, _count, p); request->execute(); } else { - _amdCB->ice_response(proxy->ice_identity(Ice::stringToIdentity("dummy"))); + _response(proxy->ice_identity(Ice::stringToIdentity("dummy"))); } _adapters.clear(); } - virtual void - exception(const std::string& id, const Ice::Exception& ex) + void + exception(const std::string& id, exception_ptr ex) override { LocatorAdapterInfo adapter; { - Lock sync(*this); + lock_guard<std::mutex> lock(_mutex); _failed.insert(id); _activatingOrFailed.insert(id); - if(!_exception.get()) + if(!_exptr) { - _exception.reset(ex.ice_clone()); + _exptr = ex; } if(_adapters.empty() || id != _adapters[0].id) @@ -576,34 +459,34 @@ public: adapter = nextAdapter(); } - if(adapter.proxy && _locator->getDirectProxy(adapter, this)) + if(adapter.proxy && _locator->getDirectProxy(adapter, shared_from_this())) { activating(adapter.id); } } void - synchronized() + synchronized() override { LocatorAdapterInfo adapter; { - Lock sync(*this); + lock_guard lock(_mutex); assert(_adapters.empty()); adapter = nextAdapter(); } - if(adapter.proxy && _locator->getDirectProxy(adapter, this)) + if(adapter.proxy && _locator->getDirectProxy(adapter, shared_from_this())) { activating(adapter.id); } } void - synchronized(const Ice::Exception& ex) + synchronized(exception_ptr ex) override { LocatorAdapterInfo adapter; { - Lock sync(*this); + lock_guard lock(_mutex); assert(_adapters.empty()); if(_activatingOrFailed.size() > _failed.size()) @@ -618,12 +501,12 @@ public: Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); out << "couldn't resolve replica group `" << _id << "' endpoints:\n" << toString(ex); } - _amdCB->ice_response(0); + _response(nullptr); return; } } - if(adapter.proxy && _locator->getDirectProxy(adapter, this)) + if(adapter.proxy && _locator->getDirectProxy(adapter, shared_from_this())) { activating(adapter.id); } @@ -667,13 +550,15 @@ private: { assert(_adapters.empty()); bool callback; + auto self = dynamic_pointer_cast<SynchronizationCallback>(shared_from_this()); + assert(self); if(!_waitForActivation) { - callback = _database->addAdapterSyncCallback(_id, this, _activatingOrFailed); + callback = _database->addAdapterSyncCallback(_id, move(self), _activatingOrFailed); } else { - callback = _database->addAdapterSyncCallback(_id, this, _failed); + callback = _database->addAdapterSyncCallback(_id, move(self), _failed); } if(callback) { @@ -688,11 +573,11 @@ private: { Ice::Current current; current.encoding = _encoding; - _locator->findAdapterById_async(_amdCB, _id, current); + _locator->findAdapterByIdAsync( _id, _response, _exception, current); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - _amdCB->ice_exception(ex); + _exception(current_exception()); } _adapters.clear(); return LocatorAdapterInfo(); @@ -708,108 +593,117 @@ private: { Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); out << "couldn't resolve replica group `" << _id << "' endpoints:\n"; - out << (_exception.get() ? toString(*_exception) : string("replica group is empty")); + out << (_exptr ? toString(_exptr) : string("replica group is empty")); } - _amdCB->ice_response(0); + _response(nullptr); return LocatorAdapterInfo(); } } catch(const AdapterNotExistException&) { assert(_adapters.empty()); - _amdCB->ice_exception(Ice::AdapterNotFoundException()); + _exception(make_exception_ptr(Ice::AdapterNotFoundException())); return LocatorAdapterInfo(); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { assert(_adapters.empty()); if(_traceLevels->locator > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); - out << "couldn't resolve replica group `" << _id << "' endpoints:\n" << toString(ex); + out << "couldn't resolve replica group `" << _id << "' endpoints:\n" << toString(current_exception()); } - _amdCB->ice_response(0); + _response(nullptr); return LocatorAdapterInfo(); } } - const Ice::AMD_Locator_findAdapterByIdPtr _amdCB; - const LocatorIPtr _locator; - const DatabasePtr _database; - const std::string _id; + const function<void(const shared_ptr<Ice::ObjectPrx>&)> _response; + const function<void(exception_ptr)> _exception; + const shared_ptr<LocatorI> _locator; + const shared_ptr<Database> _database; + const string _id; const Ice::EncodingVersion _encoding; - const Ice::ConnectionPtr _connection; + const shared_ptr<Ice::Connection> _connection; const Ice::Context _context; LocatorAdapterInfoSeq _adapters; - const TraceLevelsPtr _traceLevels; + const shared_ptr<TraceLevels> _traceLevels; int _count; bool _waitForActivation; set<string> _failed; set<string> _activatingOrFailed; - IceInternal::UniquePtr<Ice::Exception> _exception; + exception_ptr _exptr; + mutex _mutex; }; -class FindAdapterByIdCallback : public SynchronizationCallback +class FindAdapterByIdCallback final : public SynchronizationCallback { public: - FindAdapterByIdCallback(const LocatorIPtr& locator, - const Ice::AMD_Locator_findAdapterByIdPtr& cb, + FindAdapterByIdCallback(const shared_ptr<LocatorI>& locator, + function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)> exception, const string& id, - const Ice::Current& current) : _locator(locator), _cb(cb), _id(id), _current(current) + const Ice::Current& current) : + _locator(locator), + _response(move(response)), + _exception(move(exception)), + _id(id), + _current(current) { } - virtual void - synchronized() + void + synchronized() override { try { - _locator->findAdapterById_async(_cb, _id, _current); + _locator->findAdapterByIdAsync(_id, _response, _exception, _current); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - _cb->ice_exception(ex); + _exception(current_exception()); } } - virtual void - synchronized(const Ice::Exception& sex) + void + synchronized(exception_ptr exptr) override { try { - sex.ice_throw(); + rethrow_exception(exptr); } catch(const AdapterNotExistException&) { } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - const TraceLevelsPtr traceLevels = _locator->getTraceLevels(); + const shared_ptr<TraceLevels> traceLevels = _locator->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); - out << "couldn't resolve adapter `" << _id << "' endpoints:\n" << toString(ex); + out << "couldn't resolve adapter `" << _id << "' endpoints:\n" << toString(exptr); } } - _cb->ice_response(0); + _response(nullptr); } private: - const LocatorIPtr _locator; - const Ice::AMD_Locator_findAdapterByIdPtr _cb; + const shared_ptr<LocatorI> _locator; + const function<void(const shared_ptr<Ice::ObjectPrx>&)> _response; + const function<void(exception_ptr)> _exception; const string _id; const Ice::Current _current; }; }; -LocatorI::LocatorI(const Ice::CommunicatorPtr& communicator, - const DatabasePtr& database, - const WellKnownObjectsManagerPtr& wellKnownObjects, - const RegistryPrx& registry, - const QueryPrx& query) : +LocatorI::LocatorI(const shared_ptr<Ice::Communicator>& communicator, + const shared_ptr<Database>& database, + const shared_ptr<WellKnownObjectsManager>& wellKnownObjects, + const shared_ptr<RegistryPrx>& registry, + const shared_ptr<QueryPrx>& query) : _communicator(communicator), _database(database), _wellKnownObjects(wellKnownObjects), @@ -823,13 +717,14 @@ LocatorI::LocatorI(const Ice::CommunicatorPtr& communicator, // registry. // void -LocatorI::findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr& cb, - const Ice::Identity& id, - const Ice::Current&) const +LocatorI::findObjectByIdAsync(Ice::Identity id, + function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)>, + const Ice::Current&) const { try { - cb->ice_response(_database->getObjectProxy(id)); + response(_database->getObjectProxy(id)); } catch(const ObjectNotRegisteredException&) { @@ -842,11 +737,13 @@ LocatorI::findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr& cb, // registry. If found, we try to get its direct proxy. // void -LocatorI::findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr& cb, - const string& id, - const Ice::Current& current) const +LocatorI::findAdapterByIdAsync(string id, + function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) const { - LocatorIPtr self = const_cast<LocatorI*>(this); + auto self = const_pointer_cast<LocatorI>(shared_from_this()); + bool replicaGroup = false; try { @@ -868,26 +765,28 @@ LocatorI::findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr& cb, } catch(const SynchronizationException&) { - if(_database->addAdapterSyncCallback(id, new FindAdapterByIdCallback(self, cb, id, current))) + if(_database->addAdapterSyncCallback(id, make_shared<FindAdapterByIdCallback>(self, response, exception, id, current))) { return; } } } - RequestPtr request; + shared_ptr<Request> request; if(roundRobin) { - request = new RoundRobinRequest(cb, self, _database, id, current, adapters, count); + request = make_shared<RoundRobinRequest>(response, exception, self, _database, id, current, adapters, + count); } else if(replicaGroup) { - request = new ReplicaGroupRequest(cb, self, id, current.encoding, adapters, count, 0); + request = make_shared<ReplicaGroupRequest>(response, exception, self, id, current.encoding, adapters, count, + nullptr); } else { assert(adapters.size() == 1); - request = new AdapterRequest(cb, self, current.encoding, adapters[0]); + request = make_shared<AdapterRequest>(response, exception, self, current.encoding, adapters[0]); } request->execute(); return; @@ -895,95 +794,100 @@ LocatorI::findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr& cb, catch(const AdapterNotExistException&) { } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); + auto traceLevels = _database->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); if(replicaGroup) { - out << "couldn't resolve replica group `" << id << "' endpoints:\n" << toString(ex); + out << "couldn't resolve replica group `" << id << "' endpoints:\n" << toString(current_exception()); } else { - out << "couldn't resolve adapter `" << id << "' endpoints:\n" << toString(ex); + out << "couldn't resolve adapter `" << id << "' endpoints:\n" << toString(current_exception()); } } - cb->ice_response(0); + response(nullptr); return; } try { - cb->ice_response(_database->getAdapterDirectProxy(id, current.encoding, current.con, current.ctx)); + response(_database->getAdapterDirectProxy(id, current.encoding, current.con, current.ctx)); } catch(const AdapterNotExistException&) { - cb->ice_exception(Ice::AdapterNotFoundException()); + exception(make_exception_ptr(Ice::AdapterNotFoundException())); } } -Ice::LocatorRegistryPrx +shared_ptr<Ice::LocatorRegistryPrx> LocatorI::getRegistry(const Ice::Current&) const { return _wellKnownObjects->getLocatorRegistry(); } -RegistryPrx +shared_ptr<RegistryPrx> LocatorI::getLocalRegistry(const Ice::Current&) const { return _localRegistry; } -QueryPrx +shared_ptr<QueryPrx> LocatorI::getLocalQuery(const Ice::Current&) const { return _localQuery; } -const Ice::CommunicatorPtr& +const shared_ptr<Ice::Communicator>& LocatorI::getCommunicator() const { return _communicator; } -const TraceLevelsPtr& +const shared_ptr<TraceLevels>& LocatorI::getTraceLevels() const { return _database->getTraceLevels(); } bool -LocatorI::getDirectProxy(const LocatorAdapterInfo& adapter, const RequestPtr& request) +LocatorI::getDirectProxy(const LocatorAdapterInfo& adapter, const shared_ptr<Request>& request) { { - Lock sync(*this); - PendingRequestsMap::iterator p = _pendingRequests.find(adapter.id); + lock_guard lock(_mutex); + auto p = _pendingRequests.find(adapter.id); if(p != _pendingRequests.end()) { p->second.push_back(request); return _activating.find(adapter.id) != _activating.end(); } - PendingRequests requests; - requests.push_back(request); - _pendingRequests.insert(make_pair(adapter.id, requests)); + _pendingRequests.insert({ adapter.id, { request } }); } - adapter.proxy->begin_getDirectProxy(newCallback_Adapter_getDirectProxy( - new AdapterGetDirectProxyCallback(this, adapter), - &AdapterGetDirectProxyCallback::response, - &AdapterGetDirectProxyCallback::exception)); + + auto self = shared_from_this(); + adapter.proxy->getDirectProxyAsync([self, adapter] (auto obj) + { + assert(obj); + self->getDirectProxyResponse(adapter, move(obj)); + }, + [self, adapter] (exception_ptr ex) + { + self->getDirectProxyException(adapter, ex); + }); return false; } void -LocatorI::getDirectProxyResponse(const LocatorAdapterInfo& adapter, const Ice::ObjectPrx& proxy) +LocatorI::getDirectProxyResponse(const LocatorAdapterInfo& adapter, const shared_ptr<Ice::ObjectPrx>& proxy) { PendingRequests requests; { - Lock sync(*this); - PendingRequestsMap::iterator p = _pendingRequests.find(adapter.id); + lock_guard lock(_mutex); + auto p = _pendingRequests.find(adapter.id); assert(p != _pendingRequests.end()); requests.swap(p->second); _pendingRequests.erase(p); @@ -992,27 +896,27 @@ LocatorI::getDirectProxyResponse(const LocatorAdapterInfo& adapter, const Ice::O if(proxy) { - for(PendingRequests::iterator q = requests.begin(); q != requests.end(); ++q) + for(const auto& request : requests) { - (*q)->response(adapter.id, proxy); + request->response(adapter.id, proxy); } } else { - for(PendingRequests::iterator q = requests.begin(); q != requests.end(); ++q) + for(const auto& request : requests) { - (*q)->exception(adapter.id, AdapterNotActiveException()); + request->exception(adapter.id, make_exception_ptr(AdapterNotActiveException())); } } } void -LocatorI::getDirectProxyException(const LocatorAdapterInfo& adapter, const Ice::Exception& ex) +LocatorI::getDirectProxyException(const LocatorAdapterInfo& adapter, exception_ptr ex) { bool activate = false; try { - ex.ice_throw(); + rethrow_exception(ex); } catch(const AdapterNotActiveException& e) { @@ -1024,8 +928,8 @@ LocatorI::getDirectProxyException(const LocatorAdapterInfo& adapter, const Ice:: PendingRequests requests; { - Lock sync(*this); - PendingRequestsMap::iterator p = _pendingRequests.find(adapter.id); + lock_guard lock(_mutex); + auto p = _pendingRequests.find(adapter.id); assert(p != _pendingRequests.end()); if(activate) { @@ -1042,22 +946,28 @@ LocatorI::getDirectProxyException(const LocatorAdapterInfo& adapter, const Ice:: if(activate) { - for(PendingRequests::iterator q = requests.begin(); q != requests.end(); ++q) + for(const auto& request : requests) { - (*q)->activating(adapter.id); + request->activating(adapter.id); } - int timeout = adapter.activationTimeout + adapter.deactivationTimeout; - AdapterPrx::uncheckedCast(adapter.proxy->ice_invocationTimeout(timeout * 1000))->begin_activate( - newCallback_Adapter_activate(new AdapterActivateCallback(this, adapter), - &AdapterActivateCallback::response, - &AdapterActivateCallback::exception)); + int timeout = secondsToInt(adapter.activationTimeout + adapter.deactivationTimeout) * 1000; + auto self = shared_from_this(); + Ice::uncheckedCast<AdapterPrx>(adapter.proxy->ice_invocationTimeout(timeout))->activateAsync( + [self, adapter] (auto obj) + { + self->getDirectProxyResponse(adapter, move(obj)); + }, + [self, adapter] (auto e) + { + self->getDirectProxyException(adapter, e); + }); } else { - for(PendingRequests::iterator q = requests.begin(); q != requests.end(); ++q) + for(const auto& request : requests) { - (*q)->exception(adapter.id, ex); + request->exception(adapter.id, ex); } } } diff --git a/cpp/src/IceGrid/LocatorI.h b/cpp/src/IceGrid/LocatorI.h index 8eb5524fc04..6ef0b5f1c58 100644 --- a/cpp/src/IceGrid/LocatorI.h +++ b/cpp/src/IceGrid/LocatorI.h @@ -14,67 +14,65 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class WellKnownObjectsManager; -typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr; - class LocatorI; -typedef IceUtil::Handle<LocatorI> LocatorIPtr; - class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; +class WellKnownObjectsManager; struct LocatorAdapterInfo; typedef std::vector<LocatorAdapterInfo> LocatorAdapterInfoSeq; -class LocatorI : public Locator, public IceUtil::Mutex +class LocatorI : public Locator, public std::enable_shared_from_this<LocatorI> { public: - class Request : public virtual IceUtil::Shared + class Request : public std::enable_shared_from_this<Request> { public: - virtual void execute() = 0; virtual void activating(const std::string&) = 0; - virtual void response(const std::string&, const Ice::ObjectPrx&) = 0; - virtual void exception(const std::string&, const Ice::Exception&) = 0; + virtual void response(const std::string&, const std::shared_ptr<Ice::ObjectPrx>&) = 0; + virtual void exception(const std::string&, std::exception_ptr) = 0; }; - typedef IceUtil::Handle<Request> RequestPtr; - LocatorI(const Ice::CommunicatorPtr&, const DatabasePtr&, const WellKnownObjectsManagerPtr&, const RegistryPrx&, - const QueryPrx&); + LocatorI(const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<Database>&, + const std::shared_ptr<WellKnownObjectsManager>&, const std::shared_ptr<RegistryPrx>&, + const std::shared_ptr<QueryPrx>&); - virtual void findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr&, const Ice::Identity&, - const Ice::Current&) const; + void findObjectByIdAsync(Ice::Identity, + std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) const override; - virtual void findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr&, const ::std::string&, - const Ice::Current&) const; + void findAdapterByIdAsync(std::string, + std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) const override; - virtual Ice::LocatorRegistryPrx getRegistry(const Ice::Current&) const; - virtual RegistryPrx getLocalRegistry(const Ice::Current&) const; - virtual QueryPrx getLocalQuery(const Ice::Current&) const; + std::shared_ptr<Ice::LocatorRegistryPrx> getRegistry(const Ice::Current&) const override; + std::shared_ptr<RegistryPrx> getLocalRegistry(const Ice::Current&) const override; + std::shared_ptr<QueryPrx> getLocalQuery(const Ice::Current&) const override; - const Ice::CommunicatorPtr& getCommunicator() const; - const TraceLevelsPtr& getTraceLevels() const; + const std::shared_ptr<Ice::Communicator>& getCommunicator() const; + const std::shared_ptr<TraceLevels>& getTraceLevels() const; - bool getDirectProxy(const LocatorAdapterInfo&, const RequestPtr&); - void getDirectProxyResponse(const LocatorAdapterInfo&, const Ice::ObjectPrx&); - void getDirectProxyException(const LocatorAdapterInfo&, const Ice::Exception&); + bool getDirectProxy(const LocatorAdapterInfo&, const std::shared_ptr<Request>&); + void getDirectProxyResponse(const LocatorAdapterInfo&, const std::shared_ptr<Ice::ObjectPrx>&); + void getDirectProxyException(const LocatorAdapterInfo&, std::exception_ptr); protected: - const Ice::CommunicatorPtr _communicator; - const DatabasePtr _database; - const WellKnownObjectsManagerPtr _wellKnownObjects; - const RegistryPrx _localRegistry; - const QueryPrx _localQuery; + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<Database> _database; + const std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects; + const std::shared_ptr<RegistryPrx> _localRegistry; + const std::shared_ptr<QueryPrx> _localQuery; - typedef std::vector<RequestPtr> PendingRequests; - typedef std::map<std::string, PendingRequests> PendingRequestsMap; + using PendingRequests = std::vector<std::shared_ptr<Request>>; + using PendingRequestsMap = std::map<std::string, PendingRequests>; PendingRequestsMap _pendingRequests; std::set<std::string> _activating; + + std::mutex _mutex; }; } diff --git a/cpp/src/IceGrid/LocatorRegistryI.cpp b/cpp/src/IceGrid/LocatorRegistryI.cpp index 52e254e2ee0..e6a172f3f41 100644 --- a/cpp/src/IceGrid/LocatorRegistryI.cpp +++ b/cpp/src/IceGrid/LocatorRegistryI.cpp @@ -7,6 +7,7 @@ #include <IceGrid/ReplicaSessionManager.h> #include <IceGrid/Database.h> #include <IceGrid/Util.h> +#include <IceGrid/Internal.h> using namespace std; using namespace IceGrid; @@ -14,241 +15,175 @@ using namespace IceGrid; namespace IceGrid { -template<class AmdCB> -class SetDirectProxyCB : public LocatorRegistryI::AdapterSetDirectProxyCB +tuple<function<void()>, function<void(exception_ptr)>> +newSetDirectProxyCB(function<void()> responseCb, + function<void(exception_ptr)> exceptionCb, + const shared_ptr<TraceLevels>& traceLevels, const string& id, + const shared_ptr<Ice::ObjectPrx>& proxy) { -public: - - SetDirectProxyCB(const AmdCB& cb, - const TraceLevelsPtr& traceLevels, - const string& id, - const Ice::ObjectPrx& proxy) : - _cb(cb), _traceLevels(traceLevels), _id(id), _proxy(proxy) - { - } - - virtual void response() + auto response = [traceLevels, id, proxy, responseCb = move(responseCb)] () { - if(_traceLevels->locator > 1) + if(traceLevels->locator > 1) { - Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); - out << "registered adapter `" << _id << "' endpoints: `"; - out << (_proxy ? _proxy->ice_toString() : string("")) << "'"; + Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); + out << "registered adapter `" << id << "' endpoints: `"; + out << (proxy ? proxy->ice_toString() : string("")) << "'"; } - _cb->ice_response(); - } + responseCb(); + }; - virtual void exception(const ::Ice::Exception& ex) + auto exception = [traceLevels, id, exceptionCb = move(exceptionCb)](auto exptr) { - if(_traceLevels->locator > 1) + if(traceLevels->locator > 1) { - Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); - out << "failed to register adapter `" << _id << "' endpoints:\n" << ex; + try + { + rethrow_exception(exptr); + } + catch(const std::exception& ex) + { + Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); + out << "failed to register adapter `" << id << "' endpoints:\n" << ex; + } } try { - ex.ice_throw(); + rethrow_exception(exptr); } catch(const AdapterActiveException&) { - _cb->ice_exception(Ice::AdapterAlreadyActiveException()); + exceptionCb(make_exception_ptr(Ice::AdapterAlreadyActiveException())); return; } catch(const Ice::ObjectNotExistException&) { - _cb->ice_exception(Ice::AdapterNotFoundException()); // Expected if the adapter was destroyed. + exceptionCb(make_exception_ptr(Ice::AdapterNotFoundException())); // Expected if the adapter was destroyed). return; } catch(const Ice::Exception&) { - _cb->ice_exception(Ice::AdapterNotFoundException()); + exceptionCb(make_exception_ptr(Ice::AdapterNotFoundException())); return; } + }; - assert(false); - } - -private: - - const AmdCB _cb; - const TraceLevelsPtr _traceLevels; - const string _id; - const Ice::ObjectPrx _proxy; -}; - -template<class AmdCB> SetDirectProxyCB<AmdCB>* -newSetDirectProxyCB(const AmdCB& cb, const TraceLevelsPtr& traceLevels, const string& id, const Ice::ObjectPrx& p) -{ - return new SetDirectProxyCB<AmdCB>(cb, traceLevels, id, p); + return { move(response), move(exception) }; } -class ServerSetProcessCB : public virtual IceUtil::Shared +class SetAdapterDirectProxyCallback final : public SynchronizationCallback { public: - ServerSetProcessCB(const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr& cb, - const TraceLevelsPtr& traceLevels, - const string& id, - const Ice::ObjectPrx& proxy) : - _cb(cb), _traceLevels(traceLevels), _id(id), _proxy(proxy) - { - } - - virtual void ice_response() - { - if(_traceLevels->locator > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); - out << "registered server `" << _id << "' process proxy: `"; - out << (_proxy ? _proxy->ice_toString() : string("")) << "'"; - } - _cb->ice_response(); - } - - virtual void ice_exception(const ::Ice::Exception& ex) - { - if(_traceLevels->locator > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->locatorCat); - out << "failed to register server process proxy `" << _id << "':\n" << ex; - } - - try - { - ex.ice_throw(); - } - catch(const Ice::ObjectNotExistException&) - { - // Expected if the server was destroyed. - _cb->ice_exception(Ice::ServerNotFoundException()); - return; - } - catch(const Ice::LocalException&) - { - _cb->ice_exception(Ice::ServerNotFoundException()); - return; - } - - assert(false); - } - -private: - - const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr _cb; - const TraceLevelsPtr _traceLevels; - const string _id; - const Ice::ObjectPrx _proxy; -}; -typedef IceUtil::Handle<ServerSetProcessCB> ServerSetProcessCBPtr; - -class SetAdapterDirectProxyCallback : public SynchronizationCallback -{ -public: - - SetAdapterDirectProxyCallback(const LocatorRegistryIPtr& registry, - const LocatorRegistryI::AdapterSetDirectProxyCBPtr& amiCB, + SetAdapterDirectProxyCallback(const shared_ptr<LocatorRegistryI>& registry, + function<void()> response, + function<void(exception_ptr)> exception, const string& adapterId, const string& replicaGroupId, - const Ice::ObjectPrx& proxy) : - _registry(registry), _amiCB(amiCB), _adapterId(adapterId), _replicaGroupId(replicaGroupId), _proxy(proxy) + const shared_ptr<Ice::ObjectPrx>& proxy) : + _registry(registry), + _response(move(response)), + _exception(move(exception)), + _adapterId(adapterId), + _replicaGroupId(replicaGroupId), + _proxy(proxy) { } - virtual void - synchronized() + void + synchronized() override { try { - _registry->setAdapterDirectProxy(_amiCB, _adapterId, _replicaGroupId, _proxy); + _registry->setAdapterDirectProxy(_adapterId, _replicaGroupId, _proxy, _response, _exception); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - _amiCB->exception(ex); + _exception(current_exception()); } } - virtual void - synchronized(const Ice::Exception& ex) + void + synchronized(exception_ptr ex) override { - try - { - ex.ice_throw(); - } - catch(const Ice::Exception& e) - { - _amiCB->exception(e); - } + _exception(ex); } private: - const LocatorRegistryIPtr _registry; - const LocatorRegistryI::AdapterSetDirectProxyCBPtr _amiCB; + const shared_ptr<LocatorRegistryI> _registry; + const function<void()> _response; + const function<void(exception_ptr)> _exception; const string _adapterId; const string _replicaGroupId; - const Ice::ObjectPrx _proxy; + const shared_ptr<Ice::ObjectPrx> _proxy; }; -class SetServerProcessProxyCallback : public SynchronizationCallback +class SetServerProcessProxyCallback final : public SynchronizationCallback { public: - SetServerProcessProxyCallback(const LocatorRegistryIPtr& registry, - const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr& cb, + SetServerProcessProxyCallback(const shared_ptr<LocatorRegistryI>& registry, + const function<void()> response, + const function<void(exception_ptr)> exception, const string& id, - const Ice::ProcessPrx& proxy) : - _registry(registry), _cb(cb), _id(id), _proxy(proxy) + const shared_ptr<Ice::ProcessPrx>& proxy) : + _registry(registry), + _response(move(response)), + _exception(move(exception)), + _id(id), + _proxy(proxy) { } - virtual void - synchronized() + void + synchronized() override { try { - _registry->setServerProcessProxy_async(_cb, _id, _proxy, Ice::Current()); + _registry->setServerProcessProxyAsync(_id, _proxy, _response, _exception, Ice::Current()); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - _cb->ice_exception(ex); + _exception(current_exception()); } } - virtual void - synchronized(const Ice::Exception& sex) + void + synchronized(exception_ptr exptr) override { try { - sex.ice_throw(); + rethrow_exception(exptr); } catch(const ServerNotExistException&) { - _cb->ice_exception(Ice::ServerNotFoundException()); + _exception(make_exception_ptr(Ice::ServerNotFoundException())); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - const TraceLevelsPtr traceLevels = _registry->getTraceLevels(); + auto traceLevels = _registry->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); - out << "couldn't register server `" << _id << "' process proxy:\n" << toString(ex); + out << "couldn't register server `" << _id << "' process proxy:\n" << toString(current_exception()); } - _cb->ice_exception(Ice::ServerNotFoundException()); + _exception(make_exception_ptr(Ice::ServerNotFoundException())); } } private: - const LocatorRegistryIPtr _registry; - const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr _cb; + const shared_ptr<LocatorRegistryI> _registry; + const function<void()> _response; + const function<void(exception_ptr)> _exception; const string _id; - const Ice::ProcessPrx _proxy; + const shared_ptr<Ice::ProcessPrx> _proxy; }; }; -LocatorRegistryI::LocatorRegistryI(const DatabasePtr& database, +LocatorRegistryI::LocatorRegistryI(const shared_ptr<Database>& database, bool dynamicRegistration, bool master, ReplicaSessionManager& session) : @@ -260,36 +195,42 @@ LocatorRegistryI::LocatorRegistryI(const DatabasePtr& database, } void -LocatorRegistryI::setAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb, - const string& adapterId, - const Ice::ObjectPrx& proxy, +LocatorRegistryI::setAdapterDirectProxyAsync(string adapterId, shared_ptr<Ice::ObjectPrx> proxy, + function<void()> response, + function<void(exception_ptr)> exception, const Ice::Current&) { - setAdapterDirectProxy(newSetDirectProxyCB(cb, _database->getTraceLevels(), adapterId, proxy), - adapterId, + auto [responseCb, exceptionCb] = newSetDirectProxyCB(move(response), move(exception), _database->getTraceLevels(), + adapterId, proxy); + + setAdapterDirectProxy(adapterId, "", - proxy); + proxy, + move(responseCb), + move(exceptionCb)); } void -LocatorRegistryI::setReplicatedAdapterDirectProxy_async( - const Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr& cb, - const string& adapterId, - const string& replicaGroupId, - const Ice::ObjectPrx& proxy, - const Ice::Current&) +LocatorRegistryI::setReplicatedAdapterDirectProxyAsync(string adapterId, string replicaGroupId, + shared_ptr<Ice::ObjectPrx> proxy, + function<void()> response, + function<void(exception_ptr)> exception, + const Ice::Current&) { - setAdapterDirectProxy(newSetDirectProxyCB(cb, _database->getTraceLevels(), adapterId, proxy), - adapterId, + auto [responseCb, exceptionCb] = newSetDirectProxyCB(move(response), move(exception), _database->getTraceLevels(), + adapterId, proxy); + setAdapterDirectProxy(adapterId, replicaGroupId, - proxy); + proxy, + move(responseCb), + move(exceptionCb)); } void -LocatorRegistryI::setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr& cb, - const string& id, - const Ice::ProcessPrx& proxy, - const Ice::Current&) +LocatorRegistryI::setServerProcessProxyAsync(string id, shared_ptr<Ice::ProcessPrx> proxy, + function<void()> response, + function<void(exception_ptr)> exception, + const Ice::Current&) { try { @@ -301,7 +242,7 @@ LocatorRegistryI::setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_set // is needed for the session activation mode for cases where // the server is released during the server startup. // - ServerPrx server; + shared_ptr<ServerPrx> server; while(true) { try @@ -311,46 +252,86 @@ LocatorRegistryI::setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_set } catch(const SynchronizationException&) { - if(_database->getServer(id)->addSyncCallback(new SetServerProcessProxyCallback(this, cb, id, proxy))) + auto cb = make_shared<SetServerProcessProxyCallback>(shared_from_this(), response, + exception, id, proxy); + if(_database->getServer(id)->addSyncCallback(move(cb))) { return; } } } - server->begin_setProcess(proxy, IceGrid::newCallback_Server_setProcess( - new ServerSetProcessCB(cb, _database->getTraceLevels(), id, proxy), - &ServerSetProcessCB::ice_response, - &ServerSetProcessCB::ice_exception)); + server->setProcessAsync(proxy, + [id, proxy, response, traceLevels = _database->getTraceLevels()] + { + if(traceLevels->locator > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); + out << "registered server `" << id << "' process proxy: `"; + out << (proxy ? proxy->ice_toString() : string("")) << "'"; + } + response(); + }, + [id, exception, traceLevels = _database->getTraceLevels()] (exception_ptr exptr) + { + if(traceLevels->locator > 1) + { + try + { + rethrow_exception(exptr); + } + catch(const std::exception& ex) + { + Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); + out << "failed to register server process proxy `" << id << "':\n" << ex; + } + } + + try + { + rethrow_exception(exptr); + } + catch(const Ice::ObjectNotExistException&) + { + // Expected if the server was destroyed. + exception(make_exception_ptr(Ice::ServerNotFoundException())); + return; + } + catch(const Ice::LocalException&) + { + exception(make_exception_ptr(Ice::ServerNotFoundException())); + return; + } + }); } catch(const ServerNotExistException&) { - cb->ice_exception(Ice::ServerNotFoundException()); + exception(make_exception_ptr(Ice::ServerNotFoundException())); } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); + auto traceLevels = _database->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); - out << "couldn't register server `" << id << "' process proxy:\n" << toString(ex); + out << "couldn't register server `" << id << "' process proxy:\n" << toString(current_exception()); } - cb->ice_exception(Ice::ServerNotFoundException()); + exception(make_exception_ptr(Ice::ServerNotFoundException())); } } void -LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirectProxyCBPtr& amiCB, - const string& adapterId, - const string& replicaGroupId, - const Ice::ObjectPrx& proxy) +LocatorRegistryI::setAdapterDirectProxy(string adapterId, string replicaGroupId, + shared_ptr<Ice::ObjectPrx> proxy, + function<void()> response, + function<void(exception_ptr)> exception) { // // Ignore request with empty adapter id. // if(adapterId.empty()) { - amiCB->response(); + response(); return; } @@ -362,7 +343,7 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect // // Get the adapter from the registry and set its direct proxy. // - AdapterPrx adapter; + shared_ptr<AdapterPrx> adapter; while(true) { try @@ -376,17 +357,19 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect } catch(const SynchronizationException&) { - if(_database->addAdapterSyncCallback(adapterId, new SetAdapterDirectProxyCallback( - this, amiCB, adapterId, replicaGroupId, proxy))) + if(_database->addAdapterSyncCallback(adapterId, + make_shared<SetAdapterDirectProxyCallback>(shared_from_this(), + response, exception, + adapterId, + replicaGroupId, + proxy))) { return; } } } - adapter->begin_setDirectProxy(proxy, IceGrid::newCallback_Adapter_setDirectProxy(amiCB, - &LocatorRegistryI::AdapterSetDirectProxyCB::response, - &LocatorRegistryI::AdapterSetDirectProxyCB::exception)); + adapter->setDirectProxyAsync(proxy, response, exception); return; } catch(const AdapterNotExistException&) @@ -396,13 +379,13 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect throw Ice::AdapterNotFoundException(); } } - catch(const Ice::Exception& ex) + catch(const Ice::Exception&) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); + auto traceLevels = _database->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); - out << "couldn't register adapter `" << adapterId << "' endpoints:\n" << toString(ex); + out << "couldn't register adapter `" << adapterId << "' endpoints:\n" << toString(current_exception()); } throw Ice::AdapterNotFoundException(); } @@ -413,7 +396,7 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect try { _database->setAdapterDirectProxy(adapterId, replicaGroupId, proxy); - amiCB->response(); + response(); return; } catch(const AdapterExistsException&) @@ -422,7 +405,7 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect } catch(const DeploymentException& ex) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); + auto traceLevels = _database->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); @@ -433,10 +416,10 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect } else { - ReplicaSessionPrx session = _session.getSession(); + auto session = _session.getSession(); if(!session) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); + auto traceLevels = _database->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); @@ -449,7 +432,7 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect try { session->setAdapterDirectProxy(adapterId, replicaGroupId, proxy); - amiCB->response(); + response(); return; } catch(const AdapterExistsException&) @@ -460,13 +443,14 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect { throw Ice::AdapterNotFoundException(); // Dynamic registration not allowed on the master. } - catch(const Ice::LocalException& ex) + catch(const Ice::LocalException&) { - const TraceLevelsPtr traceLevels = _database->getTraceLevels(); + auto traceLevels = _database->getTraceLevels(); if(traceLevels->locator > 0) { Ice::Trace out(traceLevels->logger, traceLevels->locatorCat); - out << "couldn't register adapter `" << adapterId << "' endpoints with master:\n" << toString(ex); + out << "couldn't register adapter `" << adapterId << "' endpoints with master:\n" + << toString(current_exception()); } throw Ice::AdapterNotFoundException(); } @@ -476,7 +460,7 @@ LocatorRegistryI::setAdapterDirectProxy(const LocatorRegistryI::AdapterSetDirect throw Ice::AdapterNotFoundException(); } -const TraceLevelsPtr& +const shared_ptr<TraceLevels>& LocatorRegistryI::getTraceLevels() const { return _database->getTraceLevels(); diff --git a/cpp/src/IceGrid/LocatorRegistryI.h b/cpp/src/IceGrid/LocatorRegistryI.h index eb7253fe9f9..c9137ccf1e2 100644 --- a/cpp/src/IceGrid/LocatorRegistryI.h +++ b/cpp/src/IceGrid/LocatorRegistryI.h @@ -5,59 +5,50 @@ #ifndef ICE_GRID_LOCATOR_REGISTRY_I_H #define ICE_GRID_LOCATOR_REGISTRY_I_H -#include <IceGrid/Internal.h> #include <Ice/Locator.h> -#include <IceUtil/Shared.h> +#include <IceGrid/Internal.h> namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - class ReplicaSessionManager; +class TraceLevels; -class LocatorRegistryI : public Ice::LocatorRegistry +class LocatorRegistryI final : public Ice::LocatorRegistry, public std::enable_shared_from_this<LocatorRegistryI> { public: - class AdapterSetDirectProxyCB : public virtual IceUtil::Shared - { - public: - - virtual void response() = 0; - virtual void exception(const ::Ice::Exception&) = 0; - }; - typedef IceUtil::Handle<AdapterSetDirectProxyCB> AdapterSetDirectProxyCBPtr; - - LocatorRegistryI(const DatabasePtr&, bool, bool, ReplicaSessionManager&); + LocatorRegistryI(const std::shared_ptr<Database>&, bool, bool, ReplicaSessionManager&); - virtual void setAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setAdapterDirectProxyPtr&, - const std::string&, const Ice::ObjectPrx&, const Ice::Current&); + void setAdapterDirectProxyAsync(std::string, std::shared_ptr<Ice::ObjectPrx>, + std::function<void()>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) override; - virtual void setReplicatedAdapterDirectProxy_async( - const Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr&, const std::string&, const std::string&, - const Ice::ObjectPrx&, const Ice::Current&); + void setReplicatedAdapterDirectProxyAsync(std::string, std::string, std::shared_ptr<Ice::ObjectPrx>, + std::function<void()>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) override; - virtual void setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr&, - const ::std::string&, const ::Ice::ProcessPrx&, const ::Ice::Current&); + void setServerProcessProxyAsync(std::string, std::shared_ptr<Ice::ProcessPrx>, + std::function<void()>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) override; - void setAdapterDirectProxy(const AdapterSetDirectProxyCBPtr&, const std::string&, const std::string&, - const Ice::ObjectPrx&); + void setAdapterDirectProxy(std::string, std::string, std::shared_ptr<Ice::ObjectPrx>, + std::function<void()>, + std::function<void(std::exception_ptr)>); - const TraceLevelsPtr& getTraceLevels() const; + const std::shared_ptr<TraceLevels>& getTraceLevels() const; private: - const DatabasePtr _database; + const std::shared_ptr<Database> _database; const bool _dynamicRegistration; const bool _master; ReplicaSessionManager& _session; }; -typedef IceUtil::Handle<LocatorRegistryI> LocatorRegistryIPtr; } diff --git a/cpp/src/IceGrid/NodeAdminRouter.cpp b/cpp/src/IceGrid/NodeAdminRouter.cpp index f739f6e06b2..f6e1f9b5fbc 100644 --- a/cpp/src/IceGrid/NodeAdminRouter.cpp +++ b/cpp/src/IceGrid/NodeAdminRouter.cpp @@ -11,23 +11,24 @@ using namespace IceGrid; using namespace Ice; using namespace std; -IceGrid::NodeServerAdminRouter::NodeServerAdminRouter(const NodeIPtr& node) : +NodeServerAdminRouter::NodeServerAdminRouter(const shared_ptr<NodeI>& node) : AdminRouter(node->getTraceLevels()), _node(node) { } void -IceGrid::NodeServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, - const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams, - const Current& current) +NodeServerAdminRouter::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) { // // First, get the ServerI servant // Identity serverId = _node->createServerIdentity(current.id.name); - ServerIPtr server = ServerIPtr::dynamicCast(_node->getAdapter()->find(serverId)); - if(server == 0) + auto server = dynamic_pointer_cast<ServerI>(_node->getAdapter()->find(serverId)); + if(server == nullptr) { if(_traceLevels->admin > 0) { @@ -41,9 +42,9 @@ IceGrid::NodeServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& // // Then get a proxy to the Process facet of the real admin object // - ObjectPrx target = server->getProcess(); + auto target = server->getProcess(); - if(target == 0) + if(target == nullptr) { if(_traceLevels->admin > 0) { @@ -65,5 +66,5 @@ IceGrid::NodeServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& target = target->ice_facet(current.facet); } - invokeOnTarget(target, cb, inParams, current); + invokeOnTarget(target, inParams, move(response), move(exception), current); } diff --git a/cpp/src/IceGrid/NodeAdminRouter.h b/cpp/src/IceGrid/NodeAdminRouter.h index 795dfdbe12a..b32f0f6011c 100644 --- a/cpp/src/IceGrid/NodeAdminRouter.h +++ b/cpp/src/IceGrid/NodeAdminRouter.h @@ -14,19 +14,20 @@ namespace IceGrid // // Routes requests to a server's admin object through the Node // -class NodeServerAdminRouter : public AdminRouter +class NodeServerAdminRouter final : public AdminRouter { public: - NodeServerAdminRouter(const NodeIPtr&); + NodeServerAdminRouter(const std::shared_ptr<NodeI>&); - virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, - const std::pair<const Ice::Byte*, const Ice::Byte*>&, - const Ice::Current&); + void ice_invokeAsync(std::pair<const Ice::Byte*, const Ice::Byte*>, + std::function<void(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current& current) override; private: - NodeIPtr _node; + std::shared_ptr<NodeI> _node; }; } diff --git a/cpp/src/IceGrid/NodeCache.cpp b/cpp/src/IceGrid/NodeCache.cpp index b727edb4966..8d397255f72 100644 --- a/cpp/src/IceGrid/NodeCache.cpp +++ b/cpp/src/IceGrid/NodeCache.cpp @@ -2,7 +2,6 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <IceUtil/Functional.h> #include <Ice/Communicator.h> #include <Ice/Properties.h> #include <Ice/LoggerUtil.h> @@ -16,361 +15,122 @@ using namespace std; using namespace IceGrid; -namespace IceGrid +namespace { -struct ToInternalServerDescriptor : std::unary_function<CommunicatorDescriptorPtr&, void> +PropertyDescriptor +removeProperty(PropertyDescriptorSeq& properties, const string& name) { - ToInternalServerDescriptor(const InternalServerDescriptorPtr& descriptor, const InternalNodeInfoPtr& node, - int iceVersion) : - _desc(descriptor), - _node(node), - _iceVersion(iceVersion) + string value; + PropertyDescriptorSeq::iterator p = properties.begin(); + while(p != properties.end()) { - } - - void - operator()(const CommunicatorDescriptorPtr& desc) - { - // - // Figure out the configuration file name for the communicator - // (if it's a service, it's "config_<service name>", if it's - // the server, it's just "config"). - // - string filename = "config"; - ServiceDescriptorPtr svc = ServiceDescriptorPtr::dynamicCast(desc); - if(svc) - { - filename += "_" + svc->name; - _desc->services->push_back(svc->name); - } - - PropertyDescriptorSeq& props = _desc->properties[filename]; - PropertyDescriptorSeq communicatorProps = desc->propertySet.properties; - - // - // If this is a service communicator and the IceBox server has Admin - // enabled or Admin endpoints configured, we ignore the server-lifetime attributes - // of the service object adapters and assume it's set to false. - // - bool ignoreServerLifetime = false; - if(svc) - { - if(_iceVersion == 0 || _iceVersion >= 30300) - { - if(getPropertyAsInt(_desc->properties["config"], "Ice.Admin.Enabled") > 0 || - getProperty(_desc->properties["config"], "Ice.Admin.Endpoints") != "") - { - ignoreServerLifetime = true; - } - } - } - // - // Add the adapters and their configuration. - // - for(AdapterDescriptorSeq::const_iterator q = desc->adapters.begin(); q != desc->adapters.end(); ++q) - { - _desc->adapters.push_back(new InternalAdapterDescriptor(q->id, - ignoreServerLifetime ? false : q->serverLifetime)); - - props.push_back(createProperty("# Object adapter " + q->name)); - PropertyDescriptor prop = removeProperty(communicatorProps, q->name + ".Endpoints"); - prop.name = q->name + ".Endpoints"; - props.push_back(prop); - props.push_back(createProperty(q->name + ".AdapterId", q->id)); - if(!q->replicaGroupId.empty()) - { - props.push_back(createProperty(q->name + ".ReplicaGroupId", q->replicaGroupId)); - } - - // - // Ignore the register process attribute if the server is using Ice >= 3.3.0 - // - if(_iceVersion != 0 && _iceVersion < 30300) - { - if(q->registerProcess) - { - props.push_back(createProperty(q->name + ".RegisterProcess", "1")); - _desc->processRegistered = true; - } - } - } - - _desc->logs.insert(_desc->logs.end(), desc->logs.begin(), desc->logs.end()); - - const string dbsPath = _node->dataDir + "/servers/" + _desc->id + "/dbs/"; - for(DbEnvDescriptorSeq::const_iterator p = desc->dbEnvs.begin(); p != desc->dbEnvs.end(); ++p) - { - props.push_back(createProperty("# Database environment " + p->name)); - if(p->dbHome.empty()) - { - _desc->dbEnvs.push_back(new InternalDbEnvDescriptor(p->name, p->properties)); - props.push_back(createProperty("Freeze.DbEnv." + p->name + ".DbHome", dbsPath + p->name)); - } - else - { - props.push_back(createProperty("Freeze.DbEnv." + p->name + ".DbHome", p->dbHome)); - } - } - - // - // Copy the communicator descriptor properties. - // - if(!communicatorProps.empty()) - { - if(svc) - { - props.push_back(createProperty("# Service descriptor properties")); - } - else - { - props.push_back(createProperty("# Server descriptor properties")); - } - copy(communicatorProps.begin(), communicatorProps.end(), back_inserter(props)); - } - - // - // For Ice servers > 3.3.0 escape the properties. - // - if(_iceVersion == 0 || _iceVersion >= 30300) - { - for(PropertyDescriptorSeq::iterator p = props.begin(); p != props.end(); ++p) - { - if(p->name.find('#') != 0 || !p->value.empty()) - { - p->name = escapeProperty(p->name, true); - p->value = escapeProperty(p->value); - } - } - } - } - - PropertyDescriptor - removeProperty(PropertyDescriptorSeq& properties, const string& name) - { - string value; - PropertyDescriptorSeq::iterator p = properties.begin(); - while(p != properties.end()) - { - if(p->name == name) - { - value = p->value; - p = properties.erase(p); - } - else - { - ++p; - } - } - PropertyDescriptor desc; - desc.name = name; - desc.value = value; - return desc; - } - - InternalServerDescriptorPtr _desc; - InternalNodeInfoPtr _node; - int _iceVersion; -}; - -class LoadCB : public virtual IceUtil::Shared -{ -public: - - LoadCB(const TraceLevelsPtr& traceLevels, const ServerEntryPtr& server, const string& node, int timeout) : - _traceLevels(traceLevels), _server(server), _id(server->getId()), _node(node), _timeout(timeout) - { - } - - void - response(const ServerPrx& server, const AdapterPrxDict& adapters, int at, int dt) - { - if(_traceLevels && _traceLevels->server > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); - out << "loaded `" << _id << "' on node `" << _node << "'"; - } - - // - // Add the node session timeout on the proxies to ensure the - // timeout is large enough. - // - _server->loadCallback(server, adapters, at + _timeout, dt + _timeout); - } - - void - exception(const Ice::Exception& lex) - { - try - { - lex.ice_throw(); - } - catch(const DeploymentException& ex) - { - if(_traceLevels && _traceLevels->server > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); - out << "couldn't load `" << _id << "' on node `" << _node << "':\n" << ex.reason; - } - - ostringstream os; - os << "couldn't load `" << _id << "' on node `" << _node << "':\n" << ex.reason; - _server->exception(DeploymentException(os.str())); - } - catch(const Ice::Exception& ex) - { - if(_traceLevels && _traceLevels->server > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); - out << "couldn't load `" << _id << "' on node `" << _node << "':\n" << ex; - } - - ostringstream os; - os << ex; - _server->exception(NodeUnreachableException(_node, os.str())); - } - } - -private: - - const TraceLevelsPtr _traceLevels; - const ServerEntryPtr _server; - const string _id; - const string _node; - const int _timeout; -}; - -class DestroyCB : public virtual IceUtil::Shared -{ -public: - - DestroyCB(const TraceLevelsPtr& traceLevels, const ServerEntryPtr& server, const string& node) : - _traceLevels(traceLevels), _server(server), _id(server->getId()), _node(node) - { - } - - void - response() - { - if(_traceLevels && _traceLevels->server > 1) + if(p->name == name) { - Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); - out << "unloaded `" << _id << "' on node `" << _node << "'"; - } - _server->destroyCallback(); - } - - void - exception(const Ice::Exception& dex) - { - try - { - dex.ice_throw(); - } - catch(const DeploymentException& ex) - { - if(_traceLevels && _traceLevels->server > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); - out << "couldn't unload `" << _id << "' on node `" << _node << "':\n" << ex.reason; - } - - ostringstream os; - os << "couldn't unload `" << _id << "' on node `" << _node << "':\n" << ex.reason; - _server->exception(DeploymentException(os.str())); + value = p->value; + p = properties.erase(p); } - catch(const Ice::Exception& ex) + else { - if(_traceLevels && _traceLevels->server > 1) - { - Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); - out << "couldn't unload `" << _id << "' on node `" << _node << "':\n" << ex; - } - ostringstream os; - os << ex; - _server->exception(NodeUnreachableException(_node, os.str())); + ++p; } } - -private: - - const TraceLevelsPtr _traceLevels; - const ServerEntryPtr _server; - const string _id; - const string _node; -}; + return { name, value }; +} } -NodeCache::NodeCache(const Ice::CommunicatorPtr& communicator, ReplicaCache& replicaCache, const string& replicaName) : +NodeCache::NodeCache(const shared_ptr<Ice::Communicator>& communicator, + ReplicaCache& replicaCache, const string& replicaName) : _communicator(communicator), _replicaName(replicaName), _replicaCache(replicaCache) { } -NodeEntryPtr +shared_ptr<NodeEntry> NodeCache::get(const string& name, bool create) const { - Lock sync(*this); - NodeEntryPtr entry = getImpl(name); - if(!entry && create) + lock_guard lock(_mutex); + + auto cacheEntry = getImpl(name); + if(!cacheEntry && create) { NodeCache& self = const_cast<NodeCache&>(*this); - entry = new NodeEntry(self, name); - self.addImpl(name, entry); + cacheEntry = make_shared<NodeEntry>(self, name); + self.addImpl(name, cacheEntry); } - if(!entry) + if(!cacheEntry) { throw NodeNotExistException(name); } + + // Get a self removing shared_ptr to the cached NodeEntry which will remove + // itself from the this cache upon destruction + auto entry = cacheEntry->_selfRemovingPtr.lock(); + + if (!entry) + { + // Create self removing shared_ptr of cacheEntry. The cacheEntry maintains a ref count for the case where + // the self removing shared_ptr has no more references but its deleter has yet to run (weak_ptr has expired) + // and at the same time another thread calls NodeCache::get which refreshes the self removing ptr before + // the cached entry can be removed. + entry = shared_ptr<NodeEntry>(const_cast<NodeEntry*>(cacheEntry.get()), + [cache = const_cast<NodeCache*>(this), name](NodeEntry* e) + { + lock_guard cacheLock(cache->_mutex); + if(--e->_selfRemovingRefCount == 0) + { + cache->removeImpl(name); + } + }); + cacheEntry->_selfRemovingRefCount++; + cacheEntry->_selfRemovingPtr = entry; + } + return entry; } NodeEntry::NodeEntry(NodeCache& cache, const std::string& name) : _cache(cache), - _ref(0), _name(name), - _registering(false) -{ -} - -NodeEntry::~NodeEntry() + _registering(false), + _selfRemovingRefCount(0) { } void NodeEntry::addDescriptor(const string& application, const NodeDescriptor& descriptor) { - Lock sync(*this); + lock_guard lock(_mutex); _descriptors.insert(make_pair(application, descriptor)); } void NodeEntry::removeDescriptor(const string& application) { - Lock sync(*this); + lock_guard lock(_mutex); _descriptors.erase(application); } void -NodeEntry::addServer(const ServerEntryPtr& entry) +NodeEntry::addServer(const shared_ptr<ServerEntry>& entry) { - Lock sync(*this); + lock_guard lock(_mutex); _servers.insert(make_pair(entry->getId(), entry)); } void -NodeEntry::removeServer(const ServerEntryPtr& entry) +NodeEntry::removeServer(const shared_ptr<ServerEntry>& entry) { - Lock sync(*this); + lock_guard lock(_mutex); _servers.erase(entry->getId()); } void -NodeEntry::setSession(const NodeSessionIPtr& session) +NodeEntry::setSession(const shared_ptr<NodeSessionI>& session) { - Lock sync(*this); + unique_lock lock(_mutex); if(session) { @@ -380,12 +140,12 @@ NodeEntry::setSession(const NodeSessionIPtr& session) { // If the current session has just been destroyed, wait for the setSession(0) call. assert(session != _session); - wait(); + _condVar.wait(lock); } else { - NodeSessionIPtr s = _session; - sync.release(); + auto s = _session; + lock.unlock(); try { s->getNode()->ice_ping(); @@ -401,7 +161,7 @@ NodeEntry::setSession(const NodeSessionIPtr& session) { } } - sync.acquire(); + lock.lock(); } } @@ -410,7 +170,7 @@ NodeEntry::setSession(const NodeSessionIPtr& session) // so we won't need anymore to try to register it with this // registry. // - _proxy = 0; + _proxy = nullptr; } else { @@ -421,12 +181,12 @@ NodeEntry::setSession(const NodeSessionIPtr& session) } _session = session; - notifyAll(); + _condVar.notify_all(); if(_registering) { _registering = false; - notifyAll(); + _condVar.notify_all(); } if(session) @@ -447,28 +207,28 @@ NodeEntry::setSession(const NodeSessionIPtr& session) } } -NodePrx +shared_ptr<NodePrx> NodeEntry::getProxy() const { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); return _session->getNode(); } -InternalNodeInfoPtr +shared_ptr<InternalNodeInfo> NodeEntry::getInfo() const { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); return _session->getInfo(); } ServerEntrySeq NodeEntry::getServers() const { - Lock sync(*this); + lock_guard lock(_mutex); ServerEntrySeq entries; - for(map<string, ServerEntryPtr>::const_iterator p = _servers.begin(); p != _servers.end(); ++p) + for(map<string, shared_ptr<ServerEntry>>::const_iterator p = _servers.begin(); p != _servers.end(); ++p) { entries.push_back(p->second); } @@ -478,8 +238,8 @@ NodeEntry::getServers() const LoadInfo NodeEntry::getLoadInfoAndLoadFactor(const string& application, float& loadFactor) const { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); map<string, NodeDescriptor>::const_iterator p = _descriptors.find(application); if(p == _descriptors.end()) @@ -523,46 +283,45 @@ NodeEntry::getLoadInfoAndLoadFactor(const string& application, float& loadFactor return _session->getLoadInfo(); } -NodeSessionIPtr +shared_ptr<NodeSessionI> NodeEntry::getSession() const { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); return _session; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> NodeEntry::getAdminProxy() const { - Ice::ObjectPrx prx = getProxy(); + auto prx = getProxy(); assert(prx); - Ice::Identity adminId; - adminId.name = "NodeAdmin-" + _name ; - adminId.category = prx->ice_getIdentity().category; - return prx->ice_identity(adminId); + return prx->ice_identity({ "NodeAdmin-" + _name, prx->ice_getIdentity().category }); } bool NodeEntry::canRemove() { - Lock sync(*this); - return _servers.empty() && !_session && _descriptors.empty(); + lock_guard lock(_mutex); + + // The cache mutex must be locked to acesss _selfRemovingRefCount + return _servers.empty() && !_session && _descriptors.empty() && _selfRemovingRefCount == 0; } void -NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, const SessionIPtr& session, int timeout, - bool noRestart) +NodeEntry::loadServer(const shared_ptr<ServerEntry>& entry, const ServerInfo& server, + const shared_ptr<SessionI>& session, chrono::seconds timeout, bool noRestart) { try { - NodePrx node; - int sessionTimeout; - InternalServerDescriptorPtr desc; + shared_ptr<NodePrx> node; + chrono::seconds sessionTimeout; + shared_ptr<InternalServerDescriptor> desc; { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); node = _session->getNode(); - sessionTimeout = _session->getTimeout(Ice::emptyCurrent); + sessionTimeout = chrono::seconds(_session->getTimeout(Ice::emptyCurrent)); // // Check if we should use a specific timeout (the load @@ -570,9 +329,10 @@ NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, con // time to deactivate, up to "deactivation-timeout" // seconds). // - if(timeout > 0) + if(timeout > 0s) { - node = NodePrx::uncheckedCast(node->ice_invocationTimeout(timeout * 1000)); + auto timeoutInMilliseconds = secondsToInt(timeout) * 1000; + node = Ice::uncheckedCast<NodePrx>(node->ice_invocationTimeout(move(timeoutInMilliseconds))); } ServerInfo info = server; @@ -603,38 +363,79 @@ NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, con } } + auto response = [traceLevels = _cache.getTraceLevels(), entry, name = _name, sessionTimeout] + (shared_ptr<ServerPrx> serverPrx, AdapterPrxDict adapters, int at, int dt) + { + if(traceLevels && traceLevels->server > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->serverCat); + out << "loaded `" << entry->getId() << "' on node `" << name << "'"; + } + + // + // Add the node session timeout on the proxies to ensure the + // timeout is large enough. + // + entry->loadCallback(move(serverPrx), move(adapters), + chrono::seconds(at) + sessionTimeout, + chrono::seconds(dt) + sessionTimeout); + + }; + + auto exception = [traceLevels = _cache.getTraceLevels(), entry, name = _name](auto exptr) + { + try + { + rethrow_exception(exptr); + } + catch(const DeploymentException& ex) + { + if(traceLevels && traceLevels->server > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->serverCat); + out << "couldn't load `" << entry->getId() << "' on node `" << name << "':\n" << ex.reason; + } + + ostringstream os; + os << "couldn't load `" << entry->getId() << "' on node `" << name << "':\n" << ex.reason; + entry->exception(make_exception_ptr(DeploymentException(os.str()))); + } + catch(const Ice::Exception& ex) + { + if(traceLevels && traceLevels->server > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->serverCat); + out << "couldn't load `" << entry->getId() << "' on node `" << name << "':\n" << ex; + } + + entry->exception(make_exception_ptr(NodeUnreachableException(name, ex.what()))); + } + }; + if(noRestart) { - node->begin_loadServerWithoutRestart(desc, _cache.getReplicaName(), - newCallback_Node_loadServerWithoutRestart( - new LoadCB(_cache.getTraceLevels(), entry, _name, sessionTimeout), - &LoadCB::response, - &LoadCB::exception)); + node->loadServerWithoutRestartAsync(desc, _cache.getReplicaName(), move(response), move(exception)); } else { - node->begin_loadServer(desc, _cache.getReplicaName(), - newCallback_Node_loadServer( - new LoadCB(_cache.getTraceLevels(), entry, _name, sessionTimeout), - &LoadCB::response, - &LoadCB::exception)); + node->loadServerAsync(desc, _cache.getReplicaName(), move(response), move(exception)); } } - catch(const NodeUnreachableException& ex) + catch(const NodeUnreachableException&) { - entry->exception(ex); + entry->exception(current_exception()); } } void -NodeEntry::destroyServer(const ServerEntryPtr& entry, const ServerInfo& info, int timeout, bool noRestart) +NodeEntry::destroyServer(const shared_ptr<ServerEntry>& entry, const ServerInfo& info, chrono::seconds timeout, bool noRestart) { try { - NodePrx node; + shared_ptr<NodePrx> node; { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); node = _session->getNode(); // @@ -643,9 +444,10 @@ NodeEntry::destroyServer(const ServerEntryPtr& entry, const ServerInfo& info, in // time to deactivate, up to "deactivation-timeout" // seconds). // - if(timeout > 0) + if(timeout > 0s) { - node = NodePrx::uncheckedCast(node->ice_invocationTimeout(timeout * 1000)); + int timeoutInMilliseconds = secondsToInt(timeout) * 1000; + node = Ice::uncheckedCast<NodePrx>(node->ice_invocationTimeout(move(timeoutInMilliseconds))); } } @@ -655,35 +457,67 @@ NodeEntry::destroyServer(const ServerEntryPtr& entry, const ServerInfo& info, in out << "unloading `" << info.descriptor->id << "' on node `" << _name << "'"; } + auto response = [traceLevels = _cache.getTraceLevels(), entry, name = _name] + { + if(traceLevels && traceLevels->server > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->serverCat); + out << "unloaded `" << entry->getId() << "' on node `" << name << "'"; + } + entry->destroyCallback(); + }; + + auto exception = [traceLevels = _cache.getTraceLevels(), entry, name = _name](auto exptr) + { + try + { + rethrow_exception(exptr); + } + catch(const DeploymentException& ex) + { + if(traceLevels && traceLevels->server > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->serverCat); + out << "couldn't unload `" << entry->getId() << "' on node `" << name << "':\n" << ex.reason; + } + + ostringstream os; + os << "couldn't unload `" << entry->getId() << "' on node `" << name << "':\n" << ex.reason; + entry->exception(make_exception_ptr(DeploymentException(os.str()))); + } + catch(const Ice::Exception& ex) + { + if(traceLevels && traceLevels->server > 1) + { + Ice::Trace out(traceLevels->logger, traceLevels->serverCat); + out << "couldn't unload `" << entry->getId() << "' on node `" << name << "':\n" << ex; + } + entry->exception(make_exception_ptr(NodeUnreachableException(name, ex.what()))); + } + }; + if(noRestart) { - node->begin_destroyServerWithoutRestart(info.descriptor->id, info.uuid, info.revision, - _cache.getReplicaName(), - newCallback_Node_destroyServerWithoutRestart( - new DestroyCB(_cache.getTraceLevels(), entry, _name), - &DestroyCB::response, - &DestroyCB::exception)); + node->destroyServerWithoutRestartAsync(info.descriptor->id, info.uuid, info.revision, + _cache.getReplicaName(), move(response), move(exception)); } else { - node->begin_destroyServer(info.descriptor->id, info.uuid, info.revision, _cache.getReplicaName(), - newCallback_Node_destroyServer( - new DestroyCB(_cache.getTraceLevels(), entry, _name), - &DestroyCB::response, - &DestroyCB::exception)); + node->destroyServerAsync(info.descriptor->id, info.uuid, info.revision, _cache.getReplicaName(), + move(response), move(exception)); } } - catch(const NodeUnreachableException& ex) + catch(const NodeUnreachableException&) { - entry->exception(ex); + entry->exception(current_exception()); } } ServerInfo -NodeEntry::getServerInfo(const ServerInfo& server, const SessionIPtr& session) +NodeEntry::getServerInfo(const ServerInfo& server, const shared_ptr<SessionI>& session) { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); ServerInfo info = server; info.descriptor = getServerDescriptor(server, session); @@ -691,11 +525,11 @@ NodeEntry::getServerInfo(const ServerInfo& server, const SessionIPtr& session) return info; } -InternalServerDescriptorPtr -NodeEntry::getInternalServerDescriptor(const ServerInfo& server, const SessionIPtr& session) +shared_ptr<InternalServerDescriptor> +NodeEntry::getInternalServerDescriptor(const ServerInfo& server, const shared_ptr<SessionI>& session) { - Lock sync(*this); - checkSession(); + unique_lock lock(_mutex); + checkSession(lock); ServerInfo info = server; try @@ -715,54 +549,7 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& server, const SessionIP } void -NodeEntry::__incRef() -{ - Lock sync(*this); - assert(_ref >= 0); - ++_ref; -} - -void -NodeEntry::__decRef() -{ - // - // The node entry implements its own reference counting. If the - // reference count drops to 1, this means that only the cache - // holds a reference on the node entry. If that's the case, we - // check if the node entry can be removed or not and if it can be - // removed we remove it from the cache map. - // - - bool doRemove = false; - bool doDelete = false; - { - Lock sync(*this); // We use a recursive mutex so it's fine to - // create Ptr with the mutex locked. - assert(_ref > 0); - --_ref; - - if(_ref == 1) - { - doRemove = canRemove(); - } - else if(_ref == 0) - { - doDelete = true; - } - } - - if(doRemove) - { - _cache.remove(_name); - } - else if(doDelete) - { - delete this; - } -} - -void -NodeEntry::checkSession() const +NodeEntry::checkSession(unique_lock<mutex>& lock) const { if(_session) { @@ -796,22 +583,27 @@ NodeEntry::checkSession() const // hang in the while loop. // _registering = true; - NodeEntry* self = const_cast<NodeEntry*>(this); - _proxy->begin_registerWithReplica(_cache.getReplicaCache().getInternalRegistry(), - newCallback_Node_registerWithReplica(self, - &NodeEntry::finishedRegistration, - &NodeEntry::finishedRegistration)); - _proxy = 0; // Registration with the proxy is only attempted once. - } - while(_registering) - { - if(!timedWait(IceUtil::Time::seconds(10))) - { - break; // Consider the node down if it doesn't respond promptly. - } + // 'this' is only ever accessed though the self removing pointer, ensuring _selfRemovingPtr is always + // valid and its access is thread safe + auto self = _selfRemovingPtr.lock(); + assert(self); + _proxy->registerWithReplicaAsync(_cache.getReplicaCache().getInternalRegistry(), + [self] + { + self->finishedRegistration(); + }, + [self] (exception_ptr ex) + { + self->finishedRegistration(ex); + }); + _proxy = nullptr; // Registration with the proxy is only attempted once. + } + // Consider the node down if it doesn't respond promptly. + _condVar.wait_for(lock, 10s, [this] { return !_registering; }); + if(!_session || _session->isDestroyed()) { throw NodeUnreachableException(_name, "the node is not active"); @@ -819,9 +611,9 @@ NodeEntry::checkSession() const } void -NodeEntry::setProxy(const NodePrx& node) +NodeEntry::setProxy(const shared_ptr<NodePrx>& node) { - Lock sync(*this); + lock_guard lock(_mutex); // // If the node has already established a session with the @@ -838,7 +630,7 @@ NodeEntry::setProxy(const NodePrx& node) void NodeEntry::finishedRegistration() { - Lock sync(*this); + lock_guard lock(_mutex); if(_cache.getTraceLevels() && _cache.getTraceLevels()->node > 0) { Ice::Trace out(_cache.getTraceLevels()->logger, _cache.getTraceLevels()->nodeCat); @@ -855,29 +647,36 @@ NodeEntry::finishedRegistration() if(_registering) { _registering = false; - notifyAll(); + _condVar.notify_all(); } } void -NodeEntry::finishedRegistration(const Ice::Exception& ex) +NodeEntry::finishedRegistration(exception_ptr exptr) { - Lock sync(*this); + lock_guard lock(_mutex); if(_cache.getTraceLevels() && _cache.getTraceLevels()->node > 0) { - Ice::Trace out(_cache.getTraceLevels()->logger, _cache.getTraceLevels()->nodeCat); - out << "node `" << _name << "' session creation failed:\n" << ex; + try + { + rethrow_exception(exptr); + } + catch(const std::exception& ex) + { + Ice::Trace out(_cache.getTraceLevels()->logger, _cache.getTraceLevels()->nodeCat); + out << "node `" << _name << "' session creation failed:\n" << ex.what(); + } } if(_registering) { _registering = false; - notifyAll(); + _condVar.notify_all(); } } -ServerDescriptorPtr -NodeEntry::getServerDescriptor(const ServerInfo& server, const SessionIPtr& session) +shared_ptr<ServerDescriptor> +NodeEntry::getServerDescriptor(const ServerInfo& server, const shared_ptr<SessionI>& session) { assert(_session); @@ -891,7 +690,7 @@ NodeEntry::getServerDescriptor(const ServerInfo& server, const SessionIPtr& sess resolve.setReserved("session.id", session->getId()); } - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(server.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(server.descriptor); if(iceBox) { return IceBoxHelper(iceBox).instantiate(resolve, PropertyDescriptorSeq(), PropertySetDescriptorDict()); @@ -903,7 +702,7 @@ NodeEntry::getServerDescriptor(const ServerInfo& server, const SessionIPtr& sess } } -InternalServerDescriptorPtr +shared_ptr<InternalServerDescriptor> NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const { // @@ -911,7 +710,7 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const // assert(_session); - InternalServerDescriptorPtr server = new InternalServerDescriptor(); + shared_ptr<InternalServerDescriptor> server = make_shared<InternalServerDescriptor>(); server->id = info.descriptor->id; server->application = info.application; server->uuid = info.uuid; @@ -929,7 +728,6 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const // server->logs: assigned for each communicator (see below) // server->adapters: assigned for each communicator (see below) - // server->dbEnvs: assigned for each communicator (see below) // server->properties: assigned for each communicator (see below) // @@ -966,7 +764,8 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const } else { - props.push_back(createProperty("Ice.Admin.Endpoints", "tcp -h localhost")); + props.push_back(createProperty("Ice.Admin.Endpoints", "tcp -h 127.0.0.1")); + props.push_back(createProperty("Ice.Admin.ServerName", "127.0.0.1")); server->processRegistered = true; } } @@ -985,12 +784,12 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const // Add IceBox properties. // string servicesStr; - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(info.descriptor); if(iceBox) { - for(ServiceInstanceDescriptorSeq::const_iterator p = iceBox->services.begin(); p != iceBox->services.end();++p) + for(const auto& serviceInstance : iceBox->services) { - ServiceDescriptorPtr s = p->descriptor; + const auto& s = serviceInstance.descriptor; const string path = _session->getInfo()->dataDir + "/servers/" + server->id + "/config/config_" + s->name; // @@ -1012,38 +811,115 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const } props.push_back(createProperty("IceBox.LoadOrder", servicesStr)); + } - if(iceVersion != 0 && iceVersion < 30300) + // + // Now, for each communicator of the descriptor, add the necessary + // logs, adapters and properties to the internal server + // descriptor. + // + forEachCommunicator(info.descriptor, + [server, node = _session->getInfo(), iceVersion](const auto& desc) { - if(hasProperty(iceBox->propertySet.properties, "IceBox.ServiceManager.RegisterProcess")) + // + // Figure out the configuration file name for the communicator + // (if it's a service, it's "config_<service name>", if it's + // the server, it's just "config"). + // + string filename = "config"; + auto svc = dynamic_pointer_cast<ServiceDescriptor>(desc); + if(svc) { - if(getProperty(iceBox->propertySet.properties, "IceBox.ServiceManager.RegisterProcess") != "0") + filename += "_" + svc->name; + server->services->push_back(svc->name); + } + + PropertyDescriptorSeq& serverProps = server->properties[filename]; + PropertyDescriptorSeq communicatorProps = desc->propertySet.properties; + + // + // If this is a service communicator and the IceBox server has Admin + // enabled or Admin endpoints configured, we ignore the server-lifetime attributes + // of the service object adapters and assume it's set to false. + // + bool ignoreServerLifetime = false; + if(svc) + { + if(iceVersion == 0 || iceVersion >= 30300) { - server->processRegistered = true; + if(getPropertyAsInt(server->properties["config"], "Ice.Admin.Enabled") > 0 || + getProperty(server->properties["config"], "Ice.Admin.Endpoints") != "") + { + ignoreServerLifetime = true; + } } } - else + // + // Add the adapters and their configuration. + // + for(const auto& adapter : desc->adapters) { - props.push_back(createProperty("IceBox.ServiceManager.RegisterProcess", "1")); - server->processRegistered = true; + server->adapters.push_back(make_shared<InternalAdapterDescriptor>(adapter.id, + ignoreServerLifetime ? false : + adapter.serverLifetime)); + + serverProps.push_back(createProperty("# Object adapter " + adapter.name)); + + PropertyDescriptor prop = removeProperty(communicatorProps, adapter.name + ".Endpoints"); + prop.name = adapter.name + ".Endpoints"; + serverProps.push_back(prop); + serverProps.push_back(createProperty(adapter.name + ".AdapterId", adapter.id)); + + if(!adapter.replicaGroupId.empty()) + { + serverProps.push_back(createProperty(adapter.name + ".ReplicaGroupId", adapter.replicaGroupId)); + } + + // + // Ignore the register process attribute if the server is using Ice >= 3.3.0 + // + if(iceVersion != 0 && iceVersion < 30300) + { + if(adapter.registerProcess) + { + serverProps.push_back(createProperty(adapter.name + ".RegisterProcess", "1")); + server->processRegistered = true; + } + } } - if(!hasProperty(iceBox->propertySet.properties, "IceBox.ServiceManager.Endpoints")) + + server->logs.insert(server->logs.end(), desc->logs.begin(), desc->logs.end()); + + // + // Copy the communicator descriptor properties. + // + if(!communicatorProps.empty()) { - props.push_back(createProperty("IceBox.ServiceManager.Endpoints", "tcp -h 127.0.0.1")); + if(svc) + { + serverProps.push_back(createProperty("# Service descriptor properties")); + } + else + { + serverProps.push_back(createProperty("# Server descriptor properties")); + } + copy(communicatorProps.begin(), communicatorProps.end(), back_inserter(serverProps)); } - } - if(!hasProperty(info.descriptor->propertySet.properties, "IceBox.InstanceName") && - hasProperty(iceBox->propertySet.properties, "IceBox.ServiceManager.Endpoints")) - { - props.push_back(createProperty("IceBox.InstanceName", server->id)); - } - } - // - // Now, for each communicator of the descriptor, add the necessary - // logs, adapters, db envs and properties to the internal server - // descriptor. - // - forEachCommunicator(ToInternalServerDescriptor(server, _session->getInfo(), iceVersion))(info.descriptor); + // + // For Ice servers > 3.3.0 escape the properties. + // + if(iceVersion == 0 || iceVersion >= 30300) + { + for(PropertyDescriptorSeq::iterator p = serverProps.begin(); p != serverProps.end(); ++p) + { + if(p->name.find('#') != 0 || !p->value.empty()) + { + p->name = escapeProperty(p->name, true); + p->value = escapeProperty(p->value); + } + } + } + }); return server; } diff --git a/cpp/src/IceGrid/NodeCache.h b/cpp/src/IceGrid/NodeCache.h index 0230b7d05b2..639ff988ce1 100644 --- a/cpp/src/IceGrid/NodeCache.h +++ b/cpp/src/IceGrid/NodeCache.h @@ -5,8 +5,6 @@ #ifndef ICE_GRID_NODECACHE_H #define ICE_GRID_NODECACHE_H -#include <IceUtil/RecMutex.h> -#include <IceUtil/Shared.h> #include <IceGrid/Cache.h> #include <IceGrid/Internal.h> @@ -14,90 +12,94 @@ namespace IceGrid { class NodeCache; - -class SessionI; -typedef IceUtil::Handle<SessionI> SessionIPtr; - class NodeSessionI; -typedef IceUtil::Handle<NodeSessionI> NodeSessionIPtr; - +class ReplicaCache; class ServerEntry; -typedef IceUtil::Handle<ServerEntry> ServerEntryPtr; -typedef std::vector<ServerEntryPtr> ServerEntrySeq; +class SessionI; -class ReplicaCache; +using ServerEntrySeq = std::vector<std::shared_ptr<ServerEntry>>; -class NodeEntry : private IceUtil::Monitor<IceUtil::RecMutex> +class NodeEntry final { public: NodeEntry(NodeCache&, const std::string&); - virtual ~NodeEntry(); void addDescriptor(const std::string&, const NodeDescriptor&); void removeDescriptor(const std::string&); - void addServer(const ServerEntryPtr&); - void removeServer(const ServerEntryPtr&); - void setSession(const NodeSessionIPtr&); + void addServer(const std::shared_ptr<ServerEntry>&); + void removeServer(const std::shared_ptr<ServerEntry>&); + void setSession(const std::shared_ptr<NodeSessionI>&); - NodePrx getProxy() const; - InternalNodeInfoPtr getInfo() const; + std::shared_ptr<NodePrx> getProxy() const; + std::shared_ptr<InternalNodeInfo> getInfo() const; ServerEntrySeq getServers() const; LoadInfo getLoadInfoAndLoadFactor(const std::string&, float&) const; - NodeSessionIPtr getSession() const; + std::shared_ptr<NodeSessionI> getSession() const; - Ice::ObjectPrx getAdminProxy() const; + std::shared_ptr<Ice::ObjectPrx> getAdminProxy() const; bool canRemove(); - void loadServer(const ServerEntryPtr&, const ServerInfo&, const SessionIPtr&, int, bool); - void destroyServer(const ServerEntryPtr&, const ServerInfo&, int, bool); + void loadServer(const std::shared_ptr<ServerEntry>&, const ServerInfo&, const std::shared_ptr<SessionI>&, + std::chrono::seconds, bool); + void destroyServer(const std::shared_ptr<ServerEntry>&, const ServerInfo&, std::chrono::seconds, bool); - ServerInfo getServerInfo(const ServerInfo&, const SessionIPtr&); - InternalServerDescriptorPtr getInternalServerDescriptor(const ServerInfo&, const SessionIPtr&); + ServerInfo getServerInfo(const ServerInfo&, const std::shared_ptr<SessionI>&); + std::shared_ptr<InternalServerDescriptor> getInternalServerDescriptor(const ServerInfo&, const std::shared_ptr<SessionI>&); - void __incRef(); - void __decRef(); - - void checkSession() const; - void setProxy(const NodePrx&); + void checkSession(std::unique_lock<std::mutex>&) const; + void setProxy(const std::shared_ptr<NodePrx>&); void finishedRegistration(); - void finishedRegistration(const Ice::Exception&); + void finishedRegistration(std::exception_ptr); private: - ServerDescriptorPtr getServerDescriptor(const ServerInfo&, const SessionIPtr&); - InternalServerDescriptorPtr getInternalServerDescriptor(const ServerInfo&) const; + std::shared_ptr<NodeEntry> selfRemovingPtr() const; + + std::shared_ptr<ServerDescriptor> getServerDescriptor(const ServerInfo&, const std::shared_ptr<SessionI>&); + std::shared_ptr<InternalServerDescriptor> getInternalServerDescriptor(const ServerInfo&) const; NodeCache& _cache; - IceUtil::Mutex _refMutex; - int _ref; const std::string _name; - NodeSessionIPtr _session; - std::map<std::string, ServerEntryPtr> _servers; + std::shared_ptr<NodeSessionI> _session; + std::map<std::string, std::shared_ptr<ServerEntry>> _servers; std::map<std::string, NodeDescriptor> _descriptors; mutable bool _registering; - mutable NodePrx _proxy; + mutable std::shared_ptr<NodePrx> _proxy; + + mutable std::mutex _mutex; + mutable std::condition_variable _condVar; + + // A self removing shared_ptr of 'this' which removes itself from the NodeCache upon destruction + std::weak_ptr<NodeEntry> _selfRemovingPtr; + + // The number of self removing shared_ptr deleters left to run. + // Always accessed with the cache mutex locked + int _selfRemovingRefCount; + + friend NodeCache; }; -typedef IceUtil::Handle<NodeEntry> NodeEntryPtr; class NodeCache : public CacheByString<NodeEntry> { public: - NodeCache(const Ice::CommunicatorPtr&, ReplicaCache&, const std::string&); + using ValueType = NodeEntry*; + + NodeCache(const std::shared_ptr<Ice::Communicator>&, ReplicaCache&, const std::string&); - NodeEntryPtr get(const std::string&, bool = false) const; + std::shared_ptr<NodeEntry> get(const std::string&, bool = false) const; - const Ice::CommunicatorPtr& getCommunicator() const { return _communicator; } + const std::shared_ptr<Ice::Communicator>& getCommunicator() const { return _communicator; } const std::string& getReplicaName() const { return _replicaName; } ReplicaCache& getReplicaCache() const { return _replicaCache; } private: - const Ice::CommunicatorPtr _communicator; + const std::shared_ptr<Ice::Communicator> _communicator; const std::string _replicaName; ReplicaCache& _replicaCache; }; diff --git a/cpp/src/IceGrid/NodeI.cpp b/cpp/src/IceGrid/NodeI.cpp index d098d71e83f..09c45027550 100644 --- a/cpp/src/IceGrid/NodeI.cpp +++ b/cpp/src/IceGrid/NodeI.cpp @@ -16,121 +16,37 @@ using namespace std; using namespace IceGrid; -namespace +NodeI::Update::Update(UpdateFunction updateFunction, const shared_ptr<NodeI>& node, + const shared_ptr<NodeObserverPrx>& observer) : _func(move(updateFunction)), + _node(node), _observer(observer) { +} -class NodeUp : public NodeI::Update +bool +NodeI::Update::send() { -public: - - NodeUp(const NodeIPtr& node, const NodeObserverPrx& observer, NodeDynamicInfo info) : - NodeI::Update(node, observer), _info(info) + auto self = shared_from_this(); + try { - } + _func([self] { self->_node->dequeueUpdate(self->_observer, self, false); }, + [self](exception_ptr) { self->_node->dequeueUpdate(self->_observer, self, true); }); - virtual bool - send() - { - try - { - _observer->begin_nodeUp(_info, newCallback(static_cast<NodeI::Update*>(this), &NodeI::Update::completed)); - } - catch(const Ice::LocalException&) - { - return false; - } return true; } - -private: - - NodeDynamicInfo _info; -}; - -class UpdateServer : public NodeI::Update -{ -public: - - UpdateServer(const NodeIPtr& node, const NodeObserverPrx& observer, ServerDynamicInfo info) : - NodeI::Update(node, observer), _info(info) - { - } - - virtual bool - send() + catch(const std::exception&) { - try - { - _observer->begin_updateServer(_node->getName(Ice::emptyCurrent), - _info, - newCallback(static_cast<NodeI::Update*>(this), &NodeI::Update::completed)); - } - catch(const Ice::LocalException&) - { - return false; - } - return true; - } - -private: - - ServerDynamicInfo _info; -}; - -class UpdateAdapter : public NodeI::Update -{ -public: - - UpdateAdapter(const NodeIPtr& node, const NodeObserverPrx& observer, AdapterDynamicInfo info) : - NodeI::Update(node, observer), _info(info) - { - } - - virtual bool - send() - { - try - { - _observer->begin_updateAdapter(_node->getName(Ice::emptyCurrent), - _info, - newCallback(static_cast<NodeI::Update*>(this), &NodeI::Update::completed)); - } - catch(const Ice::LocalException&) - { - return false; - } - return true; + return false; } - -private: - - AdapterDynamicInfo _info; -}; - -} - -NodeI::Update::Update(const NodeIPtr& node, const NodeObserverPrx& observer) : _node(node), _observer(observer) -{ } -NodeI::Update::~Update() -{ -} - -void -NodeI::Update::finished(bool success) -{ - _node->dequeueUpdate(_observer, this, !success); -} - -NodeI::NodeI(const Ice::ObjectAdapterPtr& adapter, +NodeI::NodeI(const shared_ptr<Ice::ObjectAdapter>& adapter, NodeSessionManager& sessions, - const ActivatorPtr& activator, + const shared_ptr<Activator>& activator, const IceUtil::TimerPtr& timer, - const TraceLevelsPtr& traceLevels, - const NodePrx& proxy, + const shared_ptr<TraceLevels>& traceLevels, + const shared_ptr<NodePrx>& proxy, const string& name, - const UserAccountMapperPrx& mapper, + const shared_ptr<UserAccountMapperPrx>& mapper, const string& instanceName) : _communicator(adapter->getCommunicator()), _adapter(adapter), @@ -146,16 +62,16 @@ NodeI::NodeI(const Ice::ObjectAdapterPtr& adapter, _instanceName(instanceName), _userAccountMapper(mapper), _platform("IceGrid.Node", _communicator, _traceLevels), - _fileCache(new FileCache(_communicator)), + _fileCache(make_shared<FileCache>(_communicator)), _serial(1), _consistencyCheckDone(false) { - Ice::PropertiesPtr props = _communicator->getProperties(); + auto props = _communicator->getProperties(); const_cast<string&>(_dataDir) = _platform.getDataDir(); const_cast<string&>(_serversDir) = _dataDir + "/servers"; const_cast<string&>(_tmpDir) = _dataDir + "/tmp"; - const_cast<Ice::Int&>(_waitTime) = props->getPropertyAsIntWithDefault("IceGrid.Node.WaitTime", 60); + const_cast<int&>(_waitTime) = props->getPropertyAsIntWithDefault("IceGrid.Node.WaitTime", 60); const_cast<string&>(_outputDir) = props->getProperty("IceGrid.Node.Output"); const_cast<bool&>(_redirectErrToOut) = props->getPropertyAsInt("IceGrid.Node.RedirectErrToOut") > 0; const_cast<bool&>(_allowEndpointsOverride) = props->getPropertyAsInt("IceGrid.Node.AllowEndpointsOverride") > 0; @@ -174,156 +90,75 @@ NodeI::NodeI(const Ice::ObjectAdapterPtr& adapter, } } - Ice::PropertiesPtr p = Ice::createProperties(); + auto p = Ice::createProperties(); p->parseCommandLineOptions("", overrides); - Ice::PropertyDict propDict = p->getPropertiesForPrefix(""); - for(Ice::PropertyDict::const_iterator q = propDict.begin(); q != propDict.end(); ++q) + auto propDict = p->getPropertiesForPrefix(""); + for(const auto& prop : propDict) { - _propertiesOverride.push_back(createProperty(q->first, q->second)); + _propertiesOverride.push_back({ prop.first, prop.second }); } } } void -NodeI::Update::completed(const Ice::AsyncResultPtr& result) -{ - try - { - result->throwLocalException(); - finished(true); - } - catch(const Ice::LocalException&) - { - finished(false); - } -} - -NodeI::~NodeI() +NodeI::loadServerAsync(shared_ptr<InternalServerDescriptor> descriptor, string replicaName, + function<void(const shared_ptr<ServerPrx>&, const AdapterPrxDict&, int, int)> response, + function<void(exception_ptr)> exception, const Ice::Current& current) { + loadServer(move(descriptor), move(replicaName), false, move(response), move(exception), current); } void -NodeI::loadServer_async(const AMD_Node_loadServerPtr& amdCB, - const InternalServerDescriptorPtr& descriptor, - const string& replicaName, - const Ice::Current& current) +NodeI::loadServerWithoutRestartAsync(shared_ptr<InternalServerDescriptor> descriptor, + string replicaName, + function<void(const shared_ptr<ServerPrx>&, + const AdapterPrxDict&, int, int)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) { - loadServer(amdCB, descriptor, replicaName, false, current); -} - -void -NodeI::loadServerWithoutRestart_async(const AMD_Node_loadServerWithoutRestartPtr& amdCB, - const InternalServerDescriptorPtr& descriptor, - const string& replicaName, - const Ice::Current& current) -{ - class LoadServerCB : public AMD_Node_loadServer - { - public: - - LoadServerCB(const AMD_Node_loadServerWithoutRestartPtr& cb) : _cb(cb) - { - } - - virtual void - ice_response(const ServerPrx& server, const AdapterPrxDict& adapters, Ice::Int actTimeout, Ice::Int deacTimeout) - { - _cb->ice_response(server, adapters, actTimeout, deacTimeout); - }; - - virtual void - ice_exception(const ::std::exception& ex) - { - _cb->ice_exception(ex); - } - - virtual void - ice_exception() - { - _cb->ice_exception(); - } - - private: - - const AMD_Node_loadServerWithoutRestartPtr _cb; - }; - loadServer(new LoadServerCB(amdCB), descriptor, replicaName, true, current); + loadServer(move(descriptor), move(replicaName), true, move(response), move(exception), current); } void -NodeI::destroyServer_async(const AMD_Node_destroyServerPtr& amdCB, - const string& serverId, - const string& uuid, - int revision, - const string& replicaName, - const Ice::Current& current) +NodeI::destroyServerAsync(string serverId, string uuid, int revision, string replicaName, + function<void()> response, function<void(exception_ptr)> exception, + const Ice::Current& current) { - destroyServer(amdCB, serverId, uuid, revision, replicaName, false, current); + destroyServer(move(serverId), move(uuid), move(revision), move(replicaName), false, + move(response), move(exception), current); } void -NodeI::destroyServerWithoutRestart_async(const AMD_Node_destroyServerWithoutRestartPtr& amdCB, - const string& serverId, - const string& uuid, - int revision, - const string& replicaName, - const Ice::Current& current) +NodeI::destroyServerWithoutRestartAsync(string serverId, string uuid, int revision, string replicaName, + function<void()> response, function<void(exception_ptr)> exception, + const Ice::Current& current) { - class DestroyServerCB : public AMD_Node_destroyServer - { - public: - - DestroyServerCB(const AMD_Node_destroyServerWithoutRestartPtr& cb) : _cb(cb) - { - } - - virtual void - ice_response() - { - _cb->ice_response(); - }; - - virtual void - ice_exception(const ::std::exception& ex) - { - _cb->ice_exception(ex); - } - - virtual void - ice_exception() - { - _cb->ice_exception(); - } - - private: - - const AMD_Node_destroyServerWithoutRestartPtr _cb; - }; - destroyServer(new DestroyServerCB(amdCB), serverId, uuid, revision, replicaName, true, current); + destroyServer(move(serverId), move(uuid), move(revision), move(replicaName), true, + move(response), move(exception), current); } void -NodeI::registerWithReplica(const InternalRegistryPrx& replica, const Ice::Current&) +NodeI::registerWithReplica(shared_ptr<InternalRegistryPrx> replica, const Ice::Current&) { - _sessions.create(replica); + _sessions.create(move(replica)); } void -NodeI::replicaInit(const InternalRegistryPrxSeq& replicas, const Ice::Current&) +NodeI::replicaInit(InternalRegistryPrxSeq replicas, const Ice::Current&) { - _sessions.replicaInit(replicas); + _sessions.replicaInit(move(replicas)); } void -NodeI::replicaAdded(const InternalRegistryPrx& replica, const Ice::Current&) +NodeI::replicaAdded(shared_ptr<InternalRegistryPrx> replica, const Ice::Current&) { - _sessions.replicaAdded(replica); + _sessions.replicaAdded(move(replica)); } void -NodeI::replicaRemoved(const InternalRegistryPrx& replica, const Ice::Current&) +NodeI::replicaRemoved(shared_ptr<InternalRegistryPrx> replica, const Ice::Current&) { - _sessions.replicaRemoved(replica); + _sessions.replicaRemoved(move(replica)); } std::string @@ -356,14 +191,14 @@ NodeI::shutdown(const Ice::Current&) const _activator->shutdown(); } -Ice::Long -NodeI::getOffsetFromEnd(const string& filename, int count, const Ice::Current&) const +long long +NodeI::getOffsetFromEnd(string filename, int count, const Ice::Current&) const { return _fileCache->getOffsetFromEnd(getFilePath(filename), count); } bool -NodeI::read(const string& filename, Ice::Long pos, int size, Ice::Long& newPos, Ice::StringSeq& lines, +NodeI::read(string filename, long long pos, int size, long long& newPos, Ice::StringSeq& lines, const Ice::Current&) const { return _fileCache->read(getFilePath(filename), pos, size, newPos, lines); @@ -372,31 +207,30 @@ NodeI::read(const string& filename, Ice::Long pos, int size, Ice::Long& newPos, void NodeI::shutdown() { - IceUtil::Mutex::Lock sync(_serversLock); - for(map<string, set<ServerIPtr> >::const_iterator p = _serversByApplication.begin(); - p != _serversByApplication.end(); ++p) + lock_guard lock(_serversMutex); + for(const auto& servers : _serversByApplication) { - for(set<ServerIPtr>::const_iterator q = p->second.begin(); q != p->second.end(); ++q) + for(const auto& server : servers.second) { - (*q)->shutdown(); + server->shutdown(); } } _serversByApplication.clear(); } -Ice::CommunicatorPtr +shared_ptr<Ice::Communicator> NodeI::getCommunicator() const { return _communicator; } -Ice::ObjectAdapterPtr +shared_ptr<Ice::ObjectAdapter> NodeI::getAdapter() const { return _adapter; } -ActivatorPtr +shared_ptr<Activator> NodeI::getActivator() const { return _activator; @@ -408,31 +242,31 @@ NodeI::getTimer() const return _timer; } -TraceLevelsPtr +shared_ptr<TraceLevels> NodeI::getTraceLevels() const { return _traceLevels; } -UserAccountMapperPrx +shared_ptr<UserAccountMapperPrx> NodeI::getUserAccountMapper() const { return _userAccountMapper; } PlatformInfo& -NodeI::getPlatformInfo() const +NodeI::getPlatformInfo() { return _platform; } -FileCachePtr +shared_ptr<FileCache> NodeI::getFileCache() const { return _fileCache; } -NodePrx +shared_ptr<NodePrx> NodeI::getProxy() const { return _proxy; @@ -468,14 +302,14 @@ NodeI::allowEndpointsOverride() const return _allowEndpointsOverride; } -NodeSessionPrx -NodeI::registerWithRegistry(const InternalRegistryPrx& registry) +shared_ptr<NodeSessionPrx> +NodeI::registerWithRegistry(const shared_ptr<InternalRegistryPrx>& registry) { return registry->registerNode(_platform.getInternalNodeInfo(), _proxy, _platform.getLoadInfo()); } void -NodeI::checkConsistency(const NodeSessionPrx& session) +NodeI::checkConsistency(const shared_ptr<NodeSessionPrx>& session) { // // Only do the consistency check on the startup. This ensures that servers can't @@ -499,11 +333,11 @@ NodeI::checkConsistency(const NodeSessionPrx& session) // unsigned long serial = 0; Ice::StringSeq servers; - vector<ServerCommandPtr> commands; + vector<shared_ptr<ServerCommand>> commands; while(true) { { - Lock sync(*this); + lock_guard lock(_mutex); if(serial == _serial) { _serial = 1; // We can reset the serial number. @@ -524,54 +358,56 @@ NodeI::checkConsistency(const NodeSessionPrx& session) sort(servers.begin(), servers.end()); } - for_each(commands.begin(), commands.end(), IceUtil::voidMemFun(&ServerCommand::execute)); + for(const auto& command : commands) + { + command->execute(); + } } void -NodeI::addObserver(const NodeSessionPrx& session, const NodeObserverPrx& observer) +NodeI::addObserver(const shared_ptr<NodeSessionPrx>& session, const shared_ptr<NodeObserverPrx>& observer) { - IceUtil::Mutex::Lock sync(_observerMutex); + lock_guard observerLock(_observerMutex); assert(_observers.find(session) == _observers.end()); - _observers.insert(make_pair(session, observer)); + _observers.insert({ session, observer }); _observerUpdates.erase(observer); // Remove any updates from the previous session. ServerDynamicInfoSeq serverInfos; AdapterDynamicInfoSeq adapterInfos; - for(map<string, ServerDynamicInfo>::const_iterator p = _serversDynamicInfo.begin(); - p != _serversDynamicInfo.end(); ++p) + for(const auto& info : _serversDynamicInfo) { - assert(p->second.state != Destroyed && (p->second.state != Inactive || !p->second.enabled)); - serverInfos.push_back(p->second); + assert(info.second.state != ServerState::Destroyed && + (info.second.state != ServerState::Inactive || !info.second.enabled)); + serverInfos.push_back(info.second); } - for(map<string, AdapterDynamicInfo>::const_iterator q = _adaptersDynamicInfo.begin(); - q != _adaptersDynamicInfo.end(); ++q) + for(const auto& info : _adaptersDynamicInfo) { - assert(q->second.proxy); - adapterInfos.push_back(q->second); + assert(info.second.proxy); + adapterInfos.push_back(info.second); } - NodeDynamicInfo info; - info.info = _platform.getNodeInfo(); - info.servers = serverInfos; - info.adapters = adapterInfos; - queueUpdate(observer, new NodeUp(this, observer, info)); + NodeDynamicInfo info = { _platform.getNodeInfo(), move(serverInfos), move(adapterInfos) }; + queueUpdate(observer, [observer, info = move(info)] (auto&& response, auto&& exception) + { + observer->nodeUpAsync(info, move(response), move(exception)); + }); } void -NodeI::removeObserver(const NodeSessionPrx& session) +NodeI::removeObserver(const shared_ptr<NodeSessionPrx>& session) { - IceUtil::Mutex::Lock sync(_observerMutex); + lock_guard observerLock(_observerMutex); _observers.erase(session); } void NodeI::observerUpdateServer(const ServerDynamicInfo& info) { - IceUtil::Mutex::Lock sync(_observerMutex); + lock_guard observerLock(_observerMutex); - if(info.state == Destroyed || (info.state == Inactive && info.enabled)) + if(info.state == ServerState::Destroyed || (info.state == ServerState::Inactive && info.enabled)) { _serversDynamicInfo.erase(info.id); } @@ -586,13 +422,20 @@ NodeI::observerUpdateServer(const ServerDynamicInfo& info) // registered twice if a replica is removed and added right away // after). // - set<NodeObserverPrx> sent; - for(map<NodeSessionPrx, NodeObserverPrx>::const_iterator p = _observers.begin(); p != _observers.end(); ++p) + set<shared_ptr<NodeObserverPrx>> sent; + for(const auto& observer : _observers) { - if(sent.find(p->second) == sent.end()) + if(sent.find(observer.second) == sent.end()) { - queueUpdate(p->second, new UpdateServer(this, p->second, info)); - sent.insert(p->second); + + queueUpdate(observer.second, + [observer = observer.second, info, name = getName(Ice::emptyCurrent)](auto&& response, + auto&& exception) + { + observer->updateServerAsync(name, info, move(response), move(exception)); + }); + + sent.insert(observer.second); } } } @@ -600,7 +443,7 @@ NodeI::observerUpdateServer(const ServerDynamicInfo& info) void NodeI::observerUpdateAdapter(const AdapterDynamicInfo& info) { - IceUtil::Mutex::Lock sync(_observerMutex); + lock_guard observerLock(_observerMutex); if(info.proxy) { @@ -617,22 +460,28 @@ NodeI::observerUpdateAdapter(const AdapterDynamicInfo& info) // registered twice if a replica is removed and added right away // after). // - set<NodeObserverPrx> sent; - for(map<NodeSessionPrx, NodeObserverPrx>::const_iterator p = _observers.begin(); p != _observers.end(); ++p) + set<shared_ptr<NodeObserverPrx>> sent; + for(const auto& observer : _observers) { - if(sent.find(p->second) == sent.end()) + if(sent.find(observer.second) == sent.end()) { - queueUpdate(p->second, new UpdateAdapter(this, p->second, info)); - sent.insert(p->second); + queueUpdate(observer.second, + [observer = observer.second, info, name = getName(Ice::emptyCurrent)] (auto&& response, + auto&& exception) + { + observer->updateAdapterAsync(name, info, move(response), move(exception)); + }); + sent.insert(observer.second); } } } void -NodeI::queueUpdate(const NodeObserverPrx& proxy, const UpdatePtr& update) +NodeI::queueUpdate(const shared_ptr<NodeObserverPrx>& proxy, Update::UpdateFunction updateFunction) { - //Lock sync(*this); Called within the synchronization - map<NodeObserverPrx, deque<UpdatePtr> >::iterator p = _observerUpdates.find(proxy); + // Must be called with mutex locked + auto update = make_shared<Update>(move(updateFunction), shared_from_this(), proxy); + auto p = _observerUpdates.find(proxy); if(p == _observerUpdates.end()) { if(update->send()) @@ -647,10 +496,10 @@ NodeI::queueUpdate(const NodeObserverPrx& proxy, const UpdatePtr& update) } void -NodeI::dequeueUpdate(const NodeObserverPrx& proxy, const UpdatePtr& update, bool all) +NodeI::dequeueUpdate(const shared_ptr<NodeObserverPrx>& proxy, const shared_ptr<Update>& update, bool all) { - IceUtil::Mutex::Lock sync(_observerMutex); - map<NodeObserverPrx, deque<UpdatePtr> >::iterator p = _observerUpdates.find(proxy); + lock_guard observerLock(_observerMutex); + auto p = _observerUpdates.find(proxy); if(p == _observerUpdates.end() || p->second.front().get() != update.get()) { return; @@ -670,23 +519,22 @@ NodeI::dequeueUpdate(const NodeObserverPrx& proxy, const UpdatePtr& update, bool } void -NodeI::addServer(const ServerIPtr& server, const string& application) +NodeI::addServer(const shared_ptr<ServerI>& server, const string& application) { - IceUtil::Mutex::Lock sync(_serversLock); - map<string, set<ServerIPtr> >::iterator p = _serversByApplication.find(application); + lock_guard serversLock(_serversMutex); + auto p = _serversByApplication.find(application); if(p == _serversByApplication.end()) { - map<string, set<ServerIPtr> >::value_type v(application, set<ServerIPtr>()); - p = _serversByApplication.insert(p, v); + p = _serversByApplication.insert(p, { application, {} }); } p->second.insert(server); } void -NodeI::removeServer(const ServerIPtr& server, const std::string& application) +NodeI::removeServer(const shared_ptr<ServerI>& server, const std::string& application) { - IceUtil::Mutex::Lock sync(_serversLock); - map<string, set<ServerIPtr> >::iterator p = _serversByApplication.find(application); + lock_guard serversLock(_serversMutex); + auto p = _serversByApplication.find(application); if(p != _serversByApplication.end()) { p->second.erase(server); @@ -700,10 +548,7 @@ NodeI::removeServer(const ServerIPtr& server, const std::string& application) Ice::Identity NodeI::createServerIdentity(const string& name) const { - Ice::Identity id; - id.category = _instanceName + "-Server"; - id.name = name; - return id; + return { name, _instanceName + "-Server" }; } string @@ -712,10 +557,10 @@ NodeI::getServerAdminCategory() const return _instanceName + "-NodeServerAdminRouter"; } -vector<ServerCommandPtr> +vector<shared_ptr<ServerCommand>> NodeI::checkConsistencyNoSync(const Ice::StringSeq& servers) { - vector<ServerCommandPtr> commands; + vector<shared_ptr<ServerCommand>> commands; // // Check if the servers directory doesn't contain more servers @@ -741,10 +586,10 @@ NodeI::checkConsistencyNoSync(const Ice::StringSeq& servers) // try { - vector<string>::iterator p = remove.begin(); + auto p = remove.begin(); while(p != remove.end()) { - ServerIPtr server = ServerIPtr::dynamicCast(_adapter->find(createServerIdentity(*p))); + auto server = dynamic_pointer_cast<ServerI>(_adapter->find(createServerIdentity(*p))); if(server) { // @@ -752,7 +597,7 @@ NodeI::checkConsistencyNoSync(const Ice::StringSeq& servers) // try { - ServerCommandPtr command = server->destroy(0, "", 0, "Master", false); + auto command = server->destroy("", 0, "Master", false, nullptr); if(command) { commands.push_back(command); @@ -812,7 +657,7 @@ NodeI::checkConsistencyNoSync(const Ice::StringSeq& servers) return commands; } -NodeSessionPrx +shared_ptr<NodeSessionPrx> NodeI::getMasterNodeSession() const { return _sessions.getMasterNodeSession(); @@ -900,12 +745,12 @@ NodeI::canRemoveServerDirectory(const string& name) return true; } -set<ServerIPtr> +set<shared_ptr<ServerI>> NodeI::getApplicationServers(const string& application) const { - IceUtil::Mutex::Lock sync(_serversLock); - set<ServerIPtr> servers; - map<string, set<ServerIPtr> >::const_iterator p = _serversByApplication.find(application); + lock_guard lock(_serversMutex); + set<shared_ptr<ServerI>> servers; + auto p = _serversByApplication.find(application); if(p != _serversByApplication.end()) { servers = p->second; @@ -941,18 +786,17 @@ NodeI::getFilePath(const string& filename) const } void -NodeI::loadServer(const AMD_Node_loadServerPtr& amdCB, - const InternalServerDescriptorPtr& descriptor, - const string& replicaName, - bool noRestart, +NodeI::loadServer(shared_ptr<InternalServerDescriptor> descriptor, string replicaName, bool noRestart, + function<void(const shared_ptr<ServerPrx> &, const AdapterPrxDict &, int, int)>&& response, + function<void(exception_ptr)>&& exception, const Ice::Current& current) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); + lock_guard lock(_mutex); ++_serial; - Ice::Identity id = createServerIdentity(descriptor->id); + auto id = createServerIdentity(descriptor->id); // // Check if we already have a servant for this server. If that's @@ -962,14 +806,14 @@ NodeI::loadServer(const AMD_Node_loadServerPtr& amdCB, while(true) { bool added = false; - ServerIPtr server; + shared_ptr<ServerI> server; try { - server = ServerIPtr::dynamicCast(_adapter->find(id)); + server = dynamic_pointer_cast<ServerI>(_adapter->find(id)); if(!server) { - ServerPrx proxy = ServerPrx::uncheckedCast(_adapter->createProxy(id)); - server = new ServerI(this, proxy, _serversDir, descriptor->id, _waitTime); + auto proxy = Ice::uncheckedCast<ServerPrx>(_adapter->createProxy(id)); + server = make_shared<ServerI>(shared_from_this(), proxy, _serversDir, descriptor->id, _waitTime); _adapter->add(server, id); added = true; } @@ -989,7 +833,8 @@ NodeI::loadServer(const AMD_Node_loadServerPtr& amdCB, try { - command = server->load(amdCB, descriptor, replicaName, noRestart); + // Don't std::move response/exception as we may need to loop and call again load. + command = server->load(descriptor, replicaName, noRestart, response, exception); } catch(const Ice::ObjectNotExistException&) { @@ -1021,30 +866,27 @@ NodeI::loadServer(const AMD_Node_loadServerPtr& amdCB, } void -NodeI::destroyServer(const AMD_Node_destroyServerPtr& amdCB, - const string& serverId, - const string& uuid, - int revision, - const string& replicaName, - bool noRestart, +NodeI::destroyServer(string serverId, string uuid, int revision, string replicaName, bool noRestart, + function<void()> response, + function<void(exception_ptr)>, const Ice::Current& current) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); + lock_guard lock(_mutex); ++_serial; - ServerIPtr server; + shared_ptr<ServerI> server; try { - server = ServerIPtr::dynamicCast(_adapter->find(createServerIdentity(serverId))); + server = dynamic_pointer_cast<ServerI>(_adapter->find(createServerIdentity(serverId))); } catch(const Ice::ObjectAdapterDeactivatedException&) { // // We throw an object not exist exception to avoid // dispatch warnings. The registry will consider the node - // has being unreachable upon receival of this exception + // has being unreachable upon receipt of this exception // (like any other Ice::LocalException). We could also // have disabled dispatch warnings but they can still // useful to catch other issues. @@ -1054,7 +896,7 @@ NodeI::destroyServer(const AMD_Node_destroyServerPtr& amdCB, if(!server) { - server = new ServerI(this, 0, _serversDir, serverId, _waitTime); + server = make_shared<ServerI>(shared_from_this(), nullptr, _serversDir, serverId, _waitTime); } // @@ -1062,11 +904,12 @@ NodeI::destroyServer(const AMD_Node_destroyServerPtr& amdCB, // try { - command = server->destroy(amdCB, uuid, revision, replicaName, noRestart); + // Don't std::move response as we may need to call it if there is an exception + command = server->destroy(uuid, revision, replicaName, noRestart, response); } catch(const Ice::ObjectNotExistException&) { - amdCB->ice_response(); + response(); return; } } diff --git a/cpp/src/IceGrid/NodeI.h b/cpp/src/IceGrid/NodeI.h index f01eda09c38..0f62c78f48d 100644 --- a/cpp/src/IceGrid/NodeI.h +++ b/cpp/src/IceGrid/NodeI.h @@ -15,101 +15,83 @@ namespace IceGrid { -class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - class Activator; -typedef IceUtil::Handle<Activator> ActivatorPtr; - -class ServerI; -typedef IceUtil::Handle<ServerI> ServerIPtr; - -class ServerCommand; -typedef IceUtil::Handle<ServerCommand> ServerCommandPtr; - class NodeSessionManager; +class ServerCommand; +class ServerI; +class TraceLevels; -class NodeI; -typedef IceUtil::Handle<NodeI> NodeIPtr; - -class NodeI : public Node, public IceUtil::Monitor<IceUtil::Mutex> +class NodeI : public Node, public std::enable_shared_from_this<NodeI> { public: - class Update : public virtual IceUtil::Shared + class Update final : public std::enable_shared_from_this<Update> { public: - Update(const NodeIPtr&, const NodeObserverPrx&); - virtual ~Update(); + using UpdateFunction = std::function<void(std::function<void()>, std::function<void(std::exception_ptr)>)>; - virtual bool send() = 0; + Update(UpdateFunction, const std::shared_ptr<NodeI>&, const std::shared_ptr<NodeObserverPrx>&); + bool send(); - void finished(bool); + private: - void completed(const Ice::AsyncResultPtr&); + UpdateFunction _func; + std::shared_ptr<NodeI> _node; + std::shared_ptr<NodeObserverPrx> _observer; + }; - protected: + NodeI(const std::shared_ptr<Ice::ObjectAdapter>&, NodeSessionManager&, const std::shared_ptr<Activator>&, + const IceUtil::TimerPtr&, const std::shared_ptr<TraceLevels>&, const std::shared_ptr<NodePrx>&, + const std::string&, const std::shared_ptr<UserAccountMapperPrx>&, const std::string&); - const NodeIPtr _node; - const NodeObserverPrx _observer; - }; - typedef IceUtil::Handle<Update> UpdatePtr; - - NodeI(const Ice::ObjectAdapterPtr&, NodeSessionManager&, const ActivatorPtr&, const IceUtil::TimerPtr&, - const TraceLevelsPtr&, const NodePrx&, const std::string&, const UserAccountMapperPrx&, const std::string&); - virtual ~NodeI(); - - virtual void loadServer_async(const AMD_Node_loadServerPtr&, - const InternalServerDescriptorPtr&, - const std::string&, - const Ice::Current&); - - virtual void loadServerWithoutRestart_async(const AMD_Node_loadServerWithoutRestartPtr&, - const InternalServerDescriptorPtr&, - const std::string&, - const Ice::Current&); - - virtual void destroyServer_async(const AMD_Node_destroyServerPtr&, - const std::string&, - const std::string&, - int, - const std::string&, - const Ice::Current&); - - virtual void destroyServerWithoutRestart_async(const AMD_Node_destroyServerWithoutRestartPtr&, - const std::string&, - const std::string&, - int, - const std::string&, - const Ice::Current&); - - virtual void registerWithReplica(const InternalRegistryPrx&, const Ice::Current&); - - virtual void replicaInit(const InternalRegistryPrxSeq&, const Ice::Current&); - virtual void replicaAdded(const InternalRegistryPrx&, const Ice::Current&); - virtual void replicaRemoved(const InternalRegistryPrx&, const Ice::Current&); - - virtual std::string getName(const Ice::Current&) const; - virtual std::string getHostname(const Ice::Current&) const; - virtual LoadInfo getLoad(const Ice::Current&) const; - virtual int getProcessorSocketCount(const Ice::Current&) const; - virtual void shutdown(const Ice::Current&) const; - - virtual Ice::Long getOffsetFromEnd(const std::string&, int, const Ice::Current&) const; - virtual bool read(const std::string&, Ice::Long, int, Ice::Long&, Ice::StringSeq&, const Ice::Current&) const; + void loadServerAsync(std::shared_ptr<InternalServerDescriptor>, std::string, + std::function<void(const std::shared_ptr<ServerPrx> &, const AdapterPrxDict &, int, int)>, + std::function<void(std::exception_ptr)>, + const Ice::Current &) override; + + void loadServerWithoutRestartAsync(std::shared_ptr<InternalServerDescriptor>, std::string, + std::function<void(const std::shared_ptr<ServerPrx>&, + const AdapterPrxDict&, int, int)>, + std::function<void(std::exception_ptr)>, + const Ice::Current &) override; + + void destroyServerAsync(std::string, std::string, int, std::string, + std::function<void()>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + + void destroyServerWithoutRestartAsync(std::string, std::string, int, std::string, + std::function<void()>, + std::function<void(std::exception_ptr)>, + const ::Ice::Current& current) override; + + void registerWithReplica(std::shared_ptr<InternalRegistryPrx>, const Ice::Current&) override; + + void replicaInit(InternalRegistryPrxSeq, const Ice::Current&) override; + void replicaAdded(std::shared_ptr<InternalRegistryPrx>, const Ice::Current&) override; + void replicaRemoved(std::shared_ptr<InternalRegistryPrx>, const Ice::Current&) override; + + std::string getName(const Ice::Current&) const override; + std::string getHostname(const Ice::Current&) const override; + LoadInfo getLoad(const Ice::Current&) const override; + int getProcessorSocketCount(const Ice::Current&) const override; + void shutdown(const Ice::Current&) const override; + + long long getOffsetFromEnd(std::string, int, const Ice::Current&) const override; + bool read(std::string, long long, int, long long&, Ice::StringSeq&, const Ice::Current&) const override; void shutdown(); IceUtil::TimerPtr getTimer() const; - Ice::CommunicatorPtr getCommunicator() const; - Ice::ObjectAdapterPtr getAdapter() const; - ActivatorPtr getActivator() const; - TraceLevelsPtr getTraceLevels() const; - UserAccountMapperPrx getUserAccountMapper() const; - PlatformInfo& getPlatformInfo() const; - FileCachePtr getFileCache() const; - NodePrx getProxy() const; + std::shared_ptr<Ice::Communicator> getCommunicator() const; + std::shared_ptr<Ice::ObjectAdapter> getAdapter() const; + std::shared_ptr<Activator> getActivator() const; + std::shared_ptr<TraceLevels> getTraceLevels() const; + std::shared_ptr<UserAccountMapperPrx> getUserAccountMapper() const; + PlatformInfo& getPlatformInfo(); + std::shared_ptr<FileCache> getFileCache() const; + std::shared_ptr<NodePrx> getProxy() const; const PropertyDescriptorSeq& getPropertiesOverride() const; const std::string& getInstanceName() const; @@ -117,19 +99,20 @@ public: bool getRedirectErrToOut() const; bool allowEndpointsOverride() const; - NodeSessionPrx registerWithRegistry(const InternalRegistryPrx&); - void checkConsistency(const NodeSessionPrx&); - NodeSessionPrx getMasterNodeSession() const; + std::shared_ptr<NodeSessionPrx> registerWithRegistry(const std::shared_ptr<InternalRegistryPrx>&); + void checkConsistency(const std::shared_ptr<NodeSessionPrx>&); + std::shared_ptr<NodeSessionPrx> getMasterNodeSession() const; - void addObserver(const NodeSessionPrx&, const NodeObserverPrx&); - void removeObserver(const NodeSessionPrx&); + void addObserver(const std::shared_ptr<NodeSessionPrx>&, const std::shared_ptr<NodeObserverPrx>&); + void removeObserver(const std::shared_ptr<NodeSessionPrx>&); void observerUpdateServer(const ServerDynamicInfo&); void observerUpdateAdapter(const AdapterDynamicInfo&); - void queueUpdate(const NodeObserverPrx&, const UpdatePtr&); - void dequeueUpdate(const NodeObserverPrx&, const UpdatePtr&, bool); - void addServer(const ServerIPtr&, const std::string&); - void removeServer(const ServerIPtr&, const std::string&); + void queueUpdate(const std::shared_ptr<NodeObserverPrx>&, Update::UpdateFunction); + void dequeueUpdate(const std::shared_ptr<NodeObserverPrx>&, const std::shared_ptr<Update>&, bool); + + void addServer(const std::shared_ptr<ServerI>&, const std::string&); + void removeServer(const std::shared_ptr<ServerI>&, const std::string&); Ice::Identity createServerIdentity(const std::string&) const; std::string getServerAdminCategory() const; @@ -138,52 +121,57 @@ public: private: - std::vector<ServerCommandPtr> checkConsistencyNoSync(const Ice::StringSeq&); + std::vector<std::shared_ptr<ServerCommand>> checkConsistencyNoSync(const Ice::StringSeq&); - std::set<ServerIPtr> getApplicationServers(const std::string&) const; + std::set<std::shared_ptr<ServerI>> getApplicationServers(const std::string&) const; std::string getFilePath(const std::string&) const; - void loadServer(const AMD_Node_loadServerPtr&, const InternalServerDescriptorPtr&, const std::string&, bool, + void loadServer(std::shared_ptr<InternalServerDescriptor>, std::string, bool, + std::function<void(const std::shared_ptr<ServerPrx> &, const AdapterPrxDict &, int, int)>&&, + std::function<void(std::exception_ptr)>&&, const Ice::Current&); - void destroyServer(const AMD_Node_destroyServerPtr&, const std::string&, const std::string&, int, - const std::string&, bool, const Ice::Current&); + void destroyServer(std::string, std::string, int, std::string, bool, + std::function<void()>, + std::function<void(std::exception_ptr)>, + const Ice::Current&); - const Ice::CommunicatorPtr _communicator; - const Ice::ObjectAdapterPtr _adapter; + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<Ice::ObjectAdapter> _adapter; NodeSessionManager& _sessions; - const ActivatorPtr _activator; + const std::shared_ptr<Activator> _activator; const IceUtil::TimerPtr _timer; - const TraceLevelsPtr _traceLevels; + const std::shared_ptr<TraceLevels> _traceLevels; const std::string _name; - const NodePrx _proxy; + const std::shared_ptr<NodePrx> _proxy; const std::string _outputDir; const bool _redirectErrToOut; const bool _allowEndpointsOverride; - const Ice::Int _waitTime; + const int _waitTime; const std::string _instanceName; - const UserAccountMapperPrx _userAccountMapper; - mutable PlatformInfo _platform; + const std::shared_ptr<UserAccountMapperPrx> _userAccountMapper; + PlatformInfo _platform; const std::string _dataDir; const std::string _serversDir; const std::string _tmpDir; - const FileCachePtr _fileCache; + const std::shared_ptr<FileCache> _fileCache; PropertyDescriptorSeq _propertiesOverride; unsigned long _serial; bool _consistencyCheckDone; - IceUtil::Mutex _observerMutex; - std::map<NodeSessionPrx, NodeObserverPrx> _observers; + std::mutex _observerMutex; + std::map<std::shared_ptr<NodeSessionPrx>, std::shared_ptr<NodeObserverPrx>> _observers; std::map<std::string, ServerDynamicInfo> _serversDynamicInfo; std::map<std::string, AdapterDynamicInfo> _adaptersDynamicInfo; - std::map<NodeObserverPrx, std::deque<UpdatePtr> > _observerUpdates; + std::map<std::shared_ptr<NodeObserverPrx>, std::deque<std::shared_ptr<Update>>> _observerUpdates; + + mutable std::mutex _serversMutex; + std::map<std::string, std::set<std::shared_ptr<ServerI>> > _serversByApplication; - IceUtil::Mutex _serversLock; - std::map<std::string, std::set<ServerIPtr> > _serversByApplication; + std::mutex _mutex; }; -typedef IceUtil::Handle<NodeI> NodeIPtr; } diff --git a/cpp/src/IceGrid/NodeSessionI.cpp b/cpp/src/IceGrid/NodeSessionI.cpp index 72e57e02a8c..d57b3af112a 100644 --- a/cpp/src/IceGrid/NodeSessionI.cpp +++ b/cpp/src/IceGrid/NodeSessionI.cpp @@ -11,66 +11,74 @@ using namespace std; using namespace IceGrid; -NodeSessionI::NodeSessionI(const DatabasePtr& database, - const NodePrx& node, - const InternalNodeInfoPtr& info, - int timeout, - const LoadInfo& load) : - _database(database), - _traceLevels(database->getTraceLevels()), - _node(node), - _info(info), - _timeout(timeout), - _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)), - _load(load), - _destroy(false) +shared_ptr<NodeSessionI> +NodeSessionI::create(const shared_ptr<Database>& database, + const shared_ptr<NodePrx>& node, + const shared_ptr<InternalNodeInfo>& info, + std::chrono::seconds timeout, + const LoadInfo& load) { - __setNoDelete(true); + shared_ptr<NodeSessionI> nodeSession(new NodeSessionI(database, node, info, timeout, load)); try { - _database->getNode(info->name, true)->setSession(this); + database->getNode(info->name, true)->setSession(nodeSession); - ObjectInfo objInfo; - objInfo.type = Node::ice_staticId(); - objInfo.proxy = _node; - _database->addInternalObject(objInfo, true); // Add or update previous node proxy. + ObjectInfo objInfo = { node, Node::ice_staticId() }; + database->addInternalObject(objInfo, true); // Add or update previous node proxy. - _proxy = NodeSessionPrx::uncheckedCast(_database->getInternalAdapter()->addWithUUID(this)); + nodeSession->_proxy = Ice::uncheckedCast<NodeSessionPrx>( + database->getInternalAdapter()->addWithUUID(nodeSession)); } catch(const NodeActiveException&) { - __setNoDelete(false); throw; } - catch(...) + catch(const std::exception&) { try { - _database->removeInternalObject(_node->ice_getIdentity()); + database->removeInternalObject(node->ice_getIdentity()); } catch(const ObjectNotRegisteredException&) { } - _database->getNode(info->name)->setSession(0); + database->getNode(info->name)->setSession(nullptr); - __setNoDelete(false); throw; } - __setNoDelete(false); + + return nodeSession; +} + +NodeSessionI::NodeSessionI(const shared_ptr<Database>& database, + const shared_ptr<NodePrx>& node, + const shared_ptr<InternalNodeInfo>& info, + std::chrono::seconds timeout, + const LoadInfo& load) : + _database(database), + _traceLevels(database->getTraceLevels()), + _node(node), + _info(info), + _timeout(timeout), + _timestamp(chrono::steady_clock::now()), + _load(load), + _destroy(false) +{ } void -NodeSessionI::keepAlive(const LoadInfo& load, const Ice::Current&) +NodeSessionI::keepAlive(LoadInfo load, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); } - _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic); - _load = load; + _timestamp = chrono::steady_clock::now(); + _load = move(load); if(_traceLevels->node > 2) { @@ -81,9 +89,10 @@ NodeSessionI::keepAlive(const LoadInfo& load, const Ice::Current&) } void -NodeSessionI::setReplicaObserver(const ReplicaObserverPrx& observer, const Ice::Current&) +NodeSessionI::setReplicaObserver(shared_ptr<ReplicaObserverPrx> observer, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); + if(_destroy) { return; @@ -101,17 +110,18 @@ NodeSessionI::setReplicaObserver(const ReplicaObserverPrx& observer, const Ice:: int NodeSessionI::getTimeout(const Ice::Current&) const { - return _timeout; + return secondsToInt(_timeout); } -NodeObserverPrx +shared_ptr<NodeObserverPrx> NodeSessionI::getObserver(const Ice::Current&) const { - return NodeObserverTopicPtr::dynamicCast(_database->getObserverTopic(NodeObserverTopicName))->getPublisher(); + return dynamic_pointer_cast<NodeObserverTopic>( + _database->getObserverTopic(TopicName::NodeObserver))->getPublisher(); } void -NodeSessionI::loadServers_async(const AMD_NodeSession_loadServersPtr& amdCB, const Ice::Current&) const +NodeSessionI::loadServersAsync(function<void()> response, function<void(exception_ptr)>, const Ice::Current&) const { // // No need to wait for the servers to be loaded. If we were @@ -119,38 +129,37 @@ NodeSessionI::loadServers_async(const AMD_NodeSession_loadServersPtr& amdCB, con // calling this method since each load() call might take time to // complete. // - amdCB->ice_response(); + response(); // // Get the server proxies to load them on the node. // - ServerEntrySeq servers = _database->getNode(_info->name)->getServers(); - for(ServerEntrySeq::const_iterator p = servers.begin(); p != servers.end(); ++p) + auto servers = _database->getNode(_info->name)->getServers(); + for(const auto& server : servers) { - (*p)->sync(); - (*p)->waitForSyncNoThrow(1); // Don't wait too long. + server->sync(); + server->waitForSyncNoThrow(1s); // Don't wait too long. } } Ice::StringSeq NodeSessionI::getServers(const Ice::Current&) const { - ServerEntrySeq servers = _database->getNode(_info->name)->getServers(); + auto servers = _database->getNode(_info->name)->getServers(); Ice::StringSeq names; - for(ServerEntrySeq::const_iterator p = servers.begin(); p != servers.end(); ++p) + for(const auto& server : servers) { - names.push_back((*p)->getId()); + names.push_back(server->getId()); } return names; } void -NodeSessionI::waitForApplicationUpdate_async(const AMD_NodeSession_waitForApplicationUpdatePtr& cb, - const std::string& application, - int revision, +NodeSessionI::waitForApplicationUpdateAsync(std::string application, int revision, + function<void()> response, function<void(exception_ptr)> exception, const Ice::Current&) const { - _database->waitForApplicationUpdate(cb, application, revision); + _database->waitForApplicationUpdate(move(application), move(revision), move(response), move(exception)); } void @@ -159,10 +168,10 @@ NodeSessionI::destroy(const Ice::Current&) destroyImpl(false); } -IceUtil::Time +chrono::steady_clock::time_point NodeSessionI::timestamp() const { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -176,13 +185,13 @@ NodeSessionI::shutdown() destroyImpl(true); } -const NodePrx& +const shared_ptr<NodePrx>& NodeSessionI::getNode() const { return _node; } -const InternalNodeInfoPtr& +const shared_ptr<InternalNodeInfo>& NodeSessionI::getInfo() const { return _info; @@ -191,11 +200,11 @@ NodeSessionI::getInfo() const const LoadInfo& NodeSessionI::getLoadInfo() const { - Lock sync(*this); + lock_guard lock(_mutex); return _load; } -NodeSessionPrx +shared_ptr<NodeSessionPrx> NodeSessionI::getProxy() const { return _proxy; @@ -204,7 +213,7 @@ NodeSessionI::getProxy() const bool NodeSessionI::isDestroyed() const { - Lock sync(*this); + lock_guard lock(_mutex); return _destroy; } @@ -212,7 +221,7 @@ void NodeSessionI::destroyImpl(bool shutdown) { { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -221,7 +230,10 @@ NodeSessionI::destroyImpl(bool shutdown) } ServerEntrySeq servers = _database->getNode(_info->name)->getServers(); - for_each(servers.begin(), servers.end(), IceUtil::voidMemFun(&ServerEntry::unsync)); + for(const auto& server : servers) + { + server->unsync(); + } // // If the registry isn't being shutdown we remove the node @@ -235,7 +247,8 @@ NodeSessionI::destroyImpl(bool shutdown) // // Next we notify the observer. // - NodeObserverTopicPtr::dynamicCast(_database->getObserverTopic(NodeObserverTopicName))->nodeDown(_info->name); + static_pointer_cast<NodeObserverTopic>( + _database->getObserverTopic(TopicName::NodeObserver))->nodeDown(_info->name); // // Unsubscribe the node replica observer. @@ -243,7 +256,7 @@ NodeSessionI::destroyImpl(bool shutdown) if(_replicaObserver) { _database->getReplicaCache().unsubscribe(_replicaObserver); - _replicaObserver = 0; + _replicaObserver = nullptr; } // @@ -251,7 +264,7 @@ NodeSessionI::destroyImpl(bool shutdown) // as the node entry session is set to 0 another session might be // created. // - _database->getNode(_info->name)->setSession(0); + _database->getNode(_info->name)->setSession(nullptr); if(!shutdown) { diff --git a/cpp/src/IceGrid/NodeSessionI.h b/cpp/src/IceGrid/NodeSessionI.h index b3ee36155b5..5958bd0a84e 100644 --- a/cpp/src/IceGrid/NodeSessionI.h +++ b/cpp/src/IceGrid/NodeSessionI.h @@ -12,54 +12,58 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; -class NodeSessionI : public NodeSession, public IceUtil::Mutex +class NodeSessionI : public NodeSession { public: - NodeSessionI(const DatabasePtr&, const NodePrx&, const InternalNodeInfoPtr&, int, const LoadInfo&); - - virtual void keepAlive(const LoadInfo&, const Ice::Current&); - virtual void setReplicaObserver(const ReplicaObserverPrx&, const Ice::Current&); - virtual int getTimeout(const Ice::Current&) const; - virtual NodeObserverPrx getObserver(const Ice::Current&) const; - virtual void loadServers_async(const AMD_NodeSession_loadServersPtr&, const Ice::Current&) const; - virtual Ice::StringSeq getServers(const Ice::Current&) const; - virtual void waitForApplicationUpdate_async(const AMD_NodeSession_waitForApplicationUpdatePtr&, - const std::string&, int, const Ice::Current&) const; - virtual void destroy(const Ice::Current&); - - virtual IceUtil::Time timestamp() const; - virtual void shutdown(); - - const NodePrx& getNode() const; - const InternalNodeInfoPtr& getInfo() const; + static std::shared_ptr<NodeSessionI> create(const std::shared_ptr<Database>&, const std::shared_ptr<NodePrx>&, + const std::shared_ptr<InternalNodeInfo>&, + std::chrono::seconds, const LoadInfo&); + + void keepAlive(LoadInfo, const Ice::Current&) override; + void setReplicaObserver(std::shared_ptr<ReplicaObserverPrx>, const Ice::Current&) override; + int getTimeout(const Ice::Current&) const override; + std::shared_ptr<NodeObserverPrx> getObserver(const Ice::Current&) const override; + void loadServersAsync(std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) const override; + Ice::StringSeq getServers(const Ice::Current&) const override; + void waitForApplicationUpdateAsync(std::string, int, std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) const override; + void destroy(const Ice::Current&) override; + + std::chrono::steady_clock::time_point timestamp() const; + void shutdown(); + + const std::shared_ptr<NodePrx>& getNode() const; + const std::shared_ptr<InternalNodeInfo>& getInfo() const; const LoadInfo& getLoadInfo() const; - NodeSessionPrx getProxy() const; + std::shared_ptr<NodeSessionPrx> getProxy() const; bool isDestroyed() const; private: + NodeSessionI(const std::shared_ptr<Database>&, const std::shared_ptr<NodePrx>&, + const std::shared_ptr<InternalNodeInfo>&, std::chrono::seconds, const LoadInfo&); + void destroyImpl(bool); - const DatabasePtr _database; - const TraceLevelsPtr _traceLevels; + const std::shared_ptr<Database> _database; + const std::shared_ptr<TraceLevels> _traceLevels; const std::string _name; - const NodePrx _node; - const InternalNodeInfoPtr _info; - const int _timeout; - NodeSessionPrx _proxy; - ReplicaObserverPrx _replicaObserver; - IceUtil::Time _timestamp; + const std::shared_ptr<NodePrx> _node; + const std::shared_ptr<InternalNodeInfo> _info; + const std::chrono::seconds _timeout; + std::shared_ptr<NodeSessionPrx> _proxy; + std::shared_ptr<ReplicaObserverPrx> _replicaObserver; + std::chrono::steady_clock::time_point _timestamp; LoadInfo _load; bool _destroy; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<NodeSessionI> NodeSessionIPtr; }; diff --git a/cpp/src/IceGrid/NodeSessionManager.cpp b/cpp/src/IceGrid/NodeSessionManager.cpp index ab9ef518313..f90a242a430 100644 --- a/cpp/src/IceGrid/NodeSessionManager.cpp +++ b/cpp/src/IceGrid/NodeSessionManager.cpp @@ -10,8 +10,8 @@ using namespace std; using namespace IceGrid; -NodeSessionKeepAliveThread::NodeSessionKeepAliveThread(const InternalRegistryPrx& registry, - const NodeIPtr& node, +NodeSessionKeepAliveThread::NodeSessionKeepAliveThread(const shared_ptr<InternalRegistryPrx>& registry, + const shared_ptr<NodeI>& node, NodeSessionManager& manager) : SessionKeepAliveThread<NodeSessionPrx>(registry, node->getTraceLevels()->logger), _node(node), _manager(manager) { @@ -26,12 +26,12 @@ NodeSessionKeepAliveThread::NodeSessionKeepAliveThread(const InternalRegistryPrx const_cast<string&>(_replicaName) = name; } -NodeSessionPrx -NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil::Time& timeout) +shared_ptr<NodeSessionPrx> +NodeSessionKeepAliveThread::createSession(shared_ptr<InternalRegistryPrx>& registry, chrono::seconds& timeout) { - NodeSessionPrx session; - IceInternal::UniquePtr<Ice::Exception> exception; - TraceLevelsPtr traceLevels = _node->getTraceLevels(); + shared_ptr<NodeSessionPrx> session; + string exceptionMessage; + auto traceLevels = _node->getTraceLevels(); try { if(traceLevels && traceLevels->replica > 1) @@ -40,7 +40,7 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil out << "trying to establish session with replica `" << _replicaName << "'"; } - set<InternalRegistryPrx> used; + set<shared_ptr<InternalRegistryPrx>> used; if(!registry->ice_getEndpoints().empty()) { try @@ -49,34 +49,33 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil } catch(const Ice::LocalException& ex) { - exception.reset(ex.ice_clone()); + exceptionMessage = ex.what(); used.insert(registry); - registry = InternalRegistryPrx::uncheckedCast(registry->ice_endpoints(Ice::EndpointSeq())); + registry = Ice::uncheckedCast<InternalRegistryPrx>(registry->ice_endpoints(Ice::EndpointSeq())); } } if(!session) { - vector<Ice::AsyncResultPtr> results; - vector<QueryPrx> queryObjects = _manager.getQueryObjects(); - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + vector<future<shared_ptr<Ice::ObjectPrx>>> results; + auto queryObjects = _manager.getQueryObjects(); + for(const auto& object : queryObjects) { - results.push_back((*q)->begin_findObjectById(registry->ice_getIdentity())); + results.push_back(object->findObjectByIdAsync(registry->ice_getIdentity())); } - for(vector<Ice::AsyncResultPtr>::const_iterator p = results.begin(); p != results.end(); ++p) + for(auto& result : results) { - QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); if(isDestroyed()) { break; } - InternalRegistryPrx newRegistry; + shared_ptr<InternalRegistryPrx> newRegistry; try { - Ice::ObjectPrx obj = query->end_findObjectById(*p); - newRegistry = InternalRegistryPrx::uncheckedCast(obj); + auto obj = result.get(); + newRegistry = Ice::uncheckedCast<InternalRegistryPrx>(obj); if(newRegistry && used.find(newRegistry) == used.end()) { session = createSessionImpl(newRegistry, timeout); @@ -86,7 +85,7 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil } catch(const Ice::LocalException& ex) { - exception.reset(ex.ice_clone()); + exceptionMessage = ex.what(); if(newRegistry) { used.insert(newRegistry); @@ -102,7 +101,7 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil traceLevels->logger->error("a node with the same name is already active with the replica `" + _replicaName + "'"); } - exception.reset(ex.ice_clone()); + exceptionMessage = ex.what(); } catch(const PermissionDeniedException& ex) { @@ -110,11 +109,11 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil { traceLevels->logger->error("connection to the registry `" + _replicaName + "' was denied:\n" + ex.reason); } - exception.reset(ex.ice_clone()); + exceptionMessage = ex.what(); } catch(const Ice::Exception& ex) { - exception.reset(ex.ice_clone()); + exceptionMessage = ex.what(); } if(session) @@ -131,9 +130,9 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil { Ice::Trace out(traceLevels->logger, traceLevels->replicaCat); out << "failed to establish session with replica `" << _replicaName << "':\n"; - if(exception.get()) + if(!exceptionMessage.empty()) { - out << *exception.get(); + out << exceptionMessage; } else { @@ -145,17 +144,19 @@ NodeSessionKeepAliveThread::createSession(InternalRegistryPrx& registry, IceUtil return session; } -NodeSessionPrx -NodeSessionKeepAliveThread::createSessionImpl(const InternalRegistryPrx& registry, IceUtil::Time& timeout) +shared_ptr<NodeSessionPrx> +NodeSessionKeepAliveThread::createSessionImpl(const shared_ptr<InternalRegistryPrx>& registry, chrono::seconds& timeout) { - NodeSessionPrx session; + shared_ptr<NodeSessionPrx> session; try { session = _node->registerWithRegistry(registry); - int t = session->getTimeout(); + auto t = session->getTimeout(); if(t > 0) { - timeout = IceUtil::Time::seconds(t / 2); + // Timeout is used to configure the delay to wait between two keep alives + // If we used t directly, a delayed keep alive could kill the session + timeout = chrono::seconds(t / 2); } _node->addObserver(session, session->getObserver()); return session; @@ -168,7 +169,7 @@ NodeSessionKeepAliveThread::createSessionImpl(const InternalRegistryPrx& registr } void -NodeSessionKeepAliveThread::destroySession(const NodeSessionPrx& session) +NodeSessionKeepAliveThread::destroySession(const shared_ptr<NodeSessionPrx>& session) { _node->removeObserver(session); @@ -196,7 +197,7 @@ NodeSessionKeepAliveThread::destroySession(const NodeSessionPrx& session) } bool -NodeSessionKeepAliveThread::keepAlive(const NodeSessionPrx& session) +NodeSessionKeepAliveThread::keepAlive(const shared_ptr<NodeSessionPrx>& session) { if(_node->getTraceLevels() && _node->getTraceLevels()->replica > 2) { @@ -221,7 +222,7 @@ NodeSessionKeepAliveThread::keepAlive(const NodeSessionPrx& session) } } -NodeSessionManager::NodeSessionManager(const Ice::CommunicatorPtr& communicator, const string& instanceName) : +NodeSessionManager::NodeSessionManager(const shared_ptr<Ice::Communicator>& communicator, const string& instanceName) : SessionManager(communicator, instanceName), _destroyed(false), _activated(false) @@ -229,14 +230,13 @@ NodeSessionManager::NodeSessionManager(const Ice::CommunicatorPtr& communicator, } void -NodeSessionManager::create(const NodeIPtr& node) +NodeSessionManager::create(const shared_ptr<NodeI>& node) { { - Lock sync(*this); + lock_guard lock(_mutex); assert(!_node); - const_cast<NodeIPtr&>(_node) = node; - _thread = new Thread(*this); - _thread->start(); + const_cast<shared_ptr<NodeI>&>(_node) = node; + _thread = make_shared<Thread>(*this); } // @@ -246,14 +246,14 @@ NodeSessionManager::create(const NodeIPtr& node) // before the node is activated. // _thread->tryCreateSession(); - _thread->waitTryCreateSession(IceUtil::Time::seconds(3)); + _thread->waitTryCreateSession(3s); } void -NodeSessionManager::create(const InternalRegistryPrx& replica) +NodeSessionManager::create(const shared_ptr<InternalRegistryPrx>& replica) { assert(_thread); - NodeSessionKeepAliveThreadPtr thread; + shared_ptr<NodeSessionKeepAliveThread> thread; if(replica->ice_getIdentity() == _master->ice_getIdentity()) { thread = _thread; @@ -261,7 +261,7 @@ NodeSessionManager::create(const InternalRegistryPrx& replica) } else { - Lock sync(*this); + lock_guard lock(_mutex); thread = addReplicaSession(replica); } @@ -276,7 +276,7 @@ void NodeSessionManager::activate() { { - Lock sync(*this); + lock_guard lock(_mutex); _activated = true; } @@ -285,7 +285,7 @@ NodeSessionManager::activate() // again and make sure that the servers are synchronized and the // replica observer is set on the session. // - NodeSessionPrx session = _thread->getSession(); + auto session = _thread->getSession(); if(session) { try @@ -319,6 +319,7 @@ NodeSessionManager::terminate() { assert(_thread); _thread->terminate(); + _thread->join(); } void @@ -326,14 +327,14 @@ NodeSessionManager::destroy() { NodeSessionMap sessions; { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; } _destroyed = true; _sessions.swap(sessions); - notifyAll(); + _condVar.notify_all(); } if(_thread) @@ -341,25 +342,27 @@ NodeSessionManager::destroy() _thread->terminate(); } - for(NodeSessionMap::const_iterator p = sessions.begin(); p != sessions.end(); ++p) + for(const auto& session : sessions) { - p->second->terminate(); + session.second->terminate(); } if(_thread) { - _thread->getThreadControl().join(); + _thread->join(); } - for(NodeSessionMap::const_iterator p = sessions.begin(); p != sessions.end(); ++p) + + for(const auto& session : sessions) { - p->second->getThreadControl().join(); + session.second->join(); } + } void NodeSessionManager::replicaInit(const InternalRegistryPrxSeq& replicas) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; @@ -369,17 +372,17 @@ NodeSessionManager::replicaInit(const InternalRegistryPrxSeq& replicas) // Initialize the set of replicas known by the master. // _replicas.clear(); - for(InternalRegistryPrxSeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - _replicas.insert((*p)->ice_getIdentity()); - addReplicaSession(*p)->tryCreateSession(); + _replicas.insert(replica->ice_getIdentity()); + addReplicaSession(replica)->tryCreateSession(); } } void -NodeSessionManager::replicaAdded(const InternalRegistryPrx& replica) +NodeSessionManager::replicaAdded(const shared_ptr<InternalRegistryPrx>& replica) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; @@ -389,10 +392,10 @@ NodeSessionManager::replicaAdded(const InternalRegistryPrx& replica) } void -NodeSessionManager::replicaRemoved(const InternalRegistryPrx& replica) +NodeSessionManager::replicaRemoved(const shared_ptr<InternalRegistryPrx>& replica) { { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; @@ -406,12 +409,12 @@ NodeSessionManager::replicaRemoved(const InternalRegistryPrx& replica) // } -NodeSessionKeepAliveThreadPtr -NodeSessionManager::addReplicaSession(const InternalRegistryPrx& replica) +shared_ptr<NodeSessionKeepAliveThread> +NodeSessionManager::addReplicaSession(const shared_ptr<InternalRegistryPrx>& replica) { assert(!_destroyed); - NodeSessionMap::const_iterator p = _sessions.find(replica->ice_getIdentity()); - NodeSessionKeepAliveThreadPtr thread; + auto p = _sessions.find(replica->ice_getIdentity()); + shared_ptr<NodeSessionKeepAliveThread> thread; if(p != _sessions.end()) { thread = p->second; @@ -419,9 +422,8 @@ NodeSessionManager::addReplicaSession(const InternalRegistryPrx& replica) } else { - thread = new NodeSessionKeepAliveThread(replica, _node, *this); + thread = make_shared<NodeSessionKeepAliveThread>(replica, _node, *this); _sessions.insert(make_pair(replica->ice_getIdentity(), thread)); - thread->start(); } return thread; } @@ -429,15 +431,17 @@ NodeSessionManager::addReplicaSession(const InternalRegistryPrx& replica) void NodeSessionManager::reapReplicas() { - vector<NodeSessionKeepAliveThreadPtr> reap; + // NodeSessionKeepAliveThread's destructor will join its thread on destruction + // Keep this vector do the destruction outside the lock + vector<shared_ptr<NodeSessionKeepAliveThread>> reap; { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; } - NodeSessionMap::iterator q = _sessions.begin(); + auto q = _sessions.begin(); while(q != _sessions.end()) { if(_replicas.find(q->first) == _replicas.end() && q->second->terminateIfDisconnected()) @@ -453,14 +457,14 @@ NodeSessionManager::reapReplicas() } } - for(vector<NodeSessionKeepAliveThreadPtr>::const_iterator p = reap.begin(); p != reap.end(); ++p) + for(const auto& r : reap) { - (*p)->getThreadControl().join(); + r->join(); } } void -NodeSessionManager::syncServers(const NodeSessionPrx& session) +NodeSessionManager::syncServers(const shared_ptr<NodeSessionPrx>& session) { // // Ask the session to load the servers on the node. Once this is @@ -479,11 +483,11 @@ NodeSessionManager::syncServers(const NodeSessionPrx& session) } void -NodeSessionManager::createdSession(const NodeSessionPrx& session) +NodeSessionManager::createdSession(const shared_ptr<NodeSessionPrx>& session) { bool activated; { - Lock sync(*this); + lock_guard lock(_mutex); activated = _activated; } @@ -534,9 +538,10 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) } else { - vector<Ice::AsyncResultPtr> results1; - vector<Ice::AsyncResultPtr> results2; - vector<QueryPrx> queryObjects = findAllQueryObjects(false); + + vector<future<Ice::ObjectProxySeq>> results1; + vector<future<Ice::ObjectProxySeq>> results2; + auto queryObjects = findAllQueryObjects(false); // // Below we try to retrieve internal registry proxies either @@ -549,19 +554,19 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) // more reliable. // - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + for(const auto& object : queryObjects) { - results1.push_back((*q)->begin_findAllObjectsByType(InternalRegistry::ice_staticId())); + results1.push_back(object->findAllObjectsByTypeAsync(InternalRegistry::ice_staticId())); } - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + for(const auto& object : queryObjects) { - results2.push_back((*q)->begin_findAllObjectsByType(Registry::ice_staticId())); + results2.push_back(object->findAllObjectsByTypeAsync(Registry::ice_staticId())); } - map<Ice::Identity, Ice::ObjectPrx> proxies; - for(vector<Ice::AsyncResultPtr>::const_iterator p = results1.begin(); p != results1.end(); ++p) + map<Ice::Identity, shared_ptr<Ice::ObjectPrx>> proxies; + + for(auto& result : results1) { - QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); if(isDestroyed()) { return; @@ -569,10 +574,10 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) try { - Ice::ObjectProxySeq prxs = query->end_findAllObjectsByType(*p); - for(Ice::ObjectProxySeq::const_iterator q = prxs.begin(); q != prxs.end(); ++q) + auto prxs = result.get(); + for(const auto& prx : prxs) { - proxies[(*q)->ice_getIdentity()] = *q; + proxies[prx->ice_getIdentity()] = prx; } } catch(const Ice::LocalException&) @@ -580,9 +585,8 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) // Ignore. } } - for(vector<Ice::AsyncResultPtr>::const_iterator p = results2.begin(); p != results2.end(); ++p) + for(auto& result : results2) { - QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); if(isDestroyed()) { return; @@ -590,22 +594,24 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) try { - Ice::ObjectProxySeq prxs = query->end_findAllObjectsByType(*p); - for(Ice::ObjectProxySeq::const_iterator q = prxs.begin(); q != prxs.end(); ++q) + auto prxs = result.get(); + for(auto prx : prxs) { - Ice::Identity id = (*q)->ice_getIdentity(); + Ice::Identity id = prx->ice_getIdentity(); const string prefix("Registry-"); string::size_type pos = id.name.find(prefix); if(pos == string::npos) { continue; // Ignore the master registry proxy. } + id.name = "InternalRegistry-" + id.name.substr(prefix.size()); + prx = prx->ice_identity(id)->ice_endpoints(Ice::EndpointSeq()); - Ice::ObjectPrx prx = (*q)->ice_identity(id)->ice_endpoints(Ice::EndpointSeq()); id.name = "Locator"; - prx = prx->ice_locator(Ice::LocatorPrx::uncheckedCast((*q)->ice_identity(id))); - proxies[id] = prx; + prx = prx->ice_locator(Ice::uncheckedCast<Ice::LocatorPrx>(prx->ice_identity(id))); + + proxies[id] = move(prx); } } catch(const Ice::LocalException&) @@ -614,15 +620,15 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) } } - for(map<Ice::Identity, Ice::ObjectPrx>::const_iterator q = proxies.begin(); q != proxies.end(); ++q) + for(const auto& prx : proxies) { - replicas.push_back(InternalRegistryPrx::uncheckedCast(q->second)); + replicas.push_back(Ice::uncheckedCast<InternalRegistryPrx>(prx.second)); } } - vector<NodeSessionKeepAliveThreadPtr> sessions; + vector<shared_ptr<NodeSessionKeepAliveThread>> sessions; { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; @@ -635,21 +641,21 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) if(!session || !_activated) { _replicas.clear(); - for(InternalRegistryPrxSeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - if((*p)->ice_getIdentity() != _master->ice_getIdentity()) + if(replica->ice_getIdentity() != _master->ice_getIdentity()) { - _replicas.insert((*p)->ice_getIdentity()); + _replicas.insert(replica->ice_getIdentity()); - if(_sessions.find((*p)->ice_getIdentity()) == _sessions.end()) + if(_sessions.find(replica->ice_getIdentity()) == _sessions.end()) { - NodeSessionKeepAliveThreadPtr thread = addReplicaSession(*p); + auto thread = addReplicaSession(replica); thread->tryCreateSession(); sessions.push_back(thread); } else { - addReplicaSession(*p); // Update the session + addReplicaSession(replica); // Update the session } } } @@ -661,18 +667,18 @@ NodeSessionManager::createdSession(const NodeSessionPrx& session) // the replica sessions are created before the node adapter is // activated. // - IceUtil::Time before = IceUtil::Time::now(); - for(vector<NodeSessionKeepAliveThreadPtr>::const_iterator p = sessions.begin(); p != sessions.end(); ++p) + auto before = chrono::system_clock::now(); + for(const auto& s : sessions) { if(isDestroyed()) { return; } - IceUtil::Time timeout = IceUtil::Time::seconds(5) - (IceUtil::Time::now() - before); - if(timeout <= IceUtil::Time()) + auto timeout = 5s - (chrono::system_clock::now() - before); + if(timeout <= 0s) { break; } - (*p)->waitTryCreateSession(timeout); + s->waitTryCreateSession(chrono::duration_cast<chrono::seconds>(timeout)); } } diff --git a/cpp/src/IceGrid/NodeSessionManager.h b/cpp/src/IceGrid/NodeSessionManager.h index 27abb769ecf..791c4c286be 100644 --- a/cpp/src/IceGrid/NodeSessionManager.h +++ b/cpp/src/IceGrid/NodeSessionManager.h @@ -5,10 +5,6 @@ #ifndef ICE_GRID_NODE_SESSION_MANAGER_H #define ICE_GRID_NODE_SESSION_MANAGER_H -#include <IceUtil/Handle.h> -#include <IceUtil/Mutex.h> -#include <IceUtil/Monitor.h> - #include <IceGrid/SessionManager.h> #include <IceGrid/Registry.h> #include <IceGrid/Internal.h> @@ -18,40 +14,40 @@ namespace IceGrid { class NodeI; -typedef IceUtil::Handle<NodeI> NodeIPtr; - class NodeSessionManager; class NodeSessionKeepAliveThread : public SessionKeepAliveThread<NodeSessionPrx> { public: - NodeSessionKeepAliveThread(const InternalRegistryPrx&, const NodeIPtr&, NodeSessionManager&); + NodeSessionKeepAliveThread(const std::shared_ptr<InternalRegistryPrx>&, const std::shared_ptr<NodeI>&, + NodeSessionManager&); - virtual NodeSessionPrx createSession(InternalRegistryPrx&, IceUtil::Time&); - virtual void destroySession(const NodeSessionPrx&); - virtual bool keepAlive(const NodeSessionPrx&); + virtual std::shared_ptr<NodeSessionPrx> createSession(std::shared_ptr<InternalRegistryPrx>&, + std::chrono::seconds&) override; + virtual void destroySession(const std::shared_ptr<NodeSessionPrx>&) override; + virtual bool keepAlive(const std::shared_ptr<NodeSessionPrx>&) override; - std::string getName() const { return _name; } + std::string getName() const { return "IceGrid session keepalive thread"; } protected: - virtual NodeSessionPrx createSessionImpl(const InternalRegistryPrx&, IceUtil::Time&); + std::shared_ptr<NodeSessionPrx> createSessionImpl(const std::shared_ptr<InternalRegistryPrx>&, + std::chrono::seconds&); - const NodeIPtr _node; + const std::shared_ptr<NodeI> _node; const std::string _replicaName; NodeSessionManager& _manager; }; -typedef IceUtil::Handle<NodeSessionKeepAliveThread> NodeSessionKeepAliveThreadPtr; class NodeSessionManager : public SessionManager { public: - NodeSessionManager(const Ice::CommunicatorPtr&, const std::string&); + NodeSessionManager(const std::shared_ptr<Ice::Communicator>&, const std::string&); - void create(const NodeIPtr&); - void create(const InternalRegistryPrx&); + void create(const std::shared_ptr<NodeI>&); + void create(const std::shared_ptr<InternalRegistryPrx>&); void activate(); bool isWaitingForCreate(); bool waitForCreate(); @@ -59,27 +55,27 @@ public: void destroy(); void replicaInit(const InternalRegistryPrxSeq&); - void replicaAdded(const InternalRegistryPrx&); - void replicaRemoved(const InternalRegistryPrx&); + void replicaAdded(const std::shared_ptr<InternalRegistryPrx>&); + void replicaRemoved(const std::shared_ptr<InternalRegistryPrx>&); - NodeSessionPrx getMasterNodeSession() const { return _thread->getSession(); } - std::vector<IceGrid::QueryPrx> getQueryObjects() { return findAllQueryObjects(true); } + std::shared_ptr<NodeSessionPrx> getMasterNodeSession() const { return _thread->getSession(); } + std::vector<std::shared_ptr<IceGrid::QueryPrx>> getQueryObjects() { return findAllQueryObjects(true); } private: - NodeSessionKeepAliveThreadPtr addReplicaSession(const InternalRegistryPrx&); + std::shared_ptr<NodeSessionKeepAliveThread> addReplicaSession(const std::shared_ptr<InternalRegistryPrx>&); void reapReplicas(); - void syncServers(const NodeSessionPrx&); + void syncServers(const std::shared_ptr<NodeSessionPrx>&); bool isDestroyed() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); return _destroyed; } - class Thread : public NodeSessionKeepAliveThread + class Thread final : public NodeSessionKeepAliveThread { public: @@ -87,41 +83,40 @@ private: { } - virtual NodeSessionPrx - createSession(InternalRegistryPrx& master, IceUtil::Time& timeout) + std::shared_ptr<NodeSessionPrx> + createSession(std::shared_ptr<InternalRegistryPrx>& master, std::chrono::seconds& timeout) override { - NodeSessionPrx session = NodeSessionKeepAliveThread::createSession(master, timeout); + auto session = NodeSessionKeepAliveThread::createSession(master, timeout); _manager.createdSession(session); _manager.reapReplicas(); return session; } - virtual void - destroySession(const NodeSessionPrx& session) + void + destroySession(const std::shared_ptr<NodeSessionPrx>& session) override { NodeSessionKeepAliveThread::destroySession(session); _manager.reapReplicas(); } - virtual bool - keepAlive(const NodeSessionPrx& session) + bool + keepAlive(const std::shared_ptr<NodeSessionPrx>& session) override { bool alive = NodeSessionKeepAliveThread::keepAlive(session); _manager.reapReplicas(); return alive; } }; - typedef IceUtil::Handle<Thread> ThreadPtr; friend class Thread; - void createdSession(const NodeSessionPrx&); + void createdSession(const std::shared_ptr<NodeSessionPrx>&); - const NodeIPtr _node; - ThreadPtr _thread; + const std::shared_ptr<NodeI> _node; + std::shared_ptr<Thread> _thread; bool _destroyed; bool _activated; - typedef std::map<Ice::Identity, NodeSessionKeepAliveThreadPtr> NodeSessionMap; + using NodeSessionMap = std::map<Ice::Identity, std::shared_ptr<NodeSessionKeepAliveThread>>; NodeSessionMap _sessions; std::set<Ice::Identity> _replicas; }; diff --git a/cpp/src/IceGrid/ObjectCache.cpp b/cpp/src/IceGrid/ObjectCache.cpp index caa5a75d3db..3ea4e33495d 100644 --- a/cpp/src/IceGrid/ObjectCache.cpp +++ b/cpp/src/IceGrid/ObjectCache.cpp @@ -14,57 +14,43 @@ using namespace std; using namespace IceGrid; -pointer_to_unary_function<int, unsigned int> ObjectCache::_rand(IceUtilInternal::random); - namespace IceGrid { -struct ObjectEntryCI : binary_function<ObjectEntryPtr&, ObjectEntryPtr&, bool> +bool compareObjectEntryCI(const shared_ptr<ObjectEntry>& lhs, const shared_ptr<ObjectEntry>& rhs) { + return Ice::proxyIdentityLess(lhs->getProxy(), rhs->getProxy()); +} - bool - operator()(const ObjectEntryPtr& lhs, const ObjectEntryPtr& rhs) - { - return ::Ice::proxyIdentityLess(lhs->getProxy(), rhs->getProxy()); - } -}; - -struct ObjectLoadCI : binary_function<pair<Ice::ObjectPrx, float>&, pair<Ice::ObjectPrx, float>&, bool> +bool compareObjectLoadCI(const pair<Ice::ObjectPrx, float>& lhs, const pair<Ice::ObjectPrx, float>& rhs) { - bool operator()(const pair<Ice::ObjectPrx, float>& lhs, const pair<Ice::ObjectPrx, float>& rhs) - { - return lhs.second < rhs.second; - } -}; + return lhs.second < rhs.second; +} }; -ObjectCache::TypeEntry::TypeEntry() -{ -} - void -ObjectCache::TypeEntry::add(const ObjectEntryPtr& obj) +ObjectCache::TypeEntry::add(const shared_ptr<ObjectEntry>& obj) { // // No mutex protection here, this is called with the cache locked. // - _objects.insert(lower_bound(_objects.begin(), _objects.end(), obj, ObjectEntryCI()), obj); + _objects.insert(lower_bound(_objects.begin(), _objects.end(), obj, compareObjectEntryCI), obj); } bool -ObjectCache::TypeEntry::remove(const ObjectEntryPtr& obj) +ObjectCache::TypeEntry::remove(const shared_ptr<ObjectEntry>& obj) { // // No mutex protection here, this is called with the cache locked. // - vector<ObjectEntryPtr>::iterator q = lower_bound(_objects.begin(), _objects.end(), obj, ObjectEntryCI()); + auto q = lower_bound(_objects.begin(), _objects.end(), obj, compareObjectEntryCI); assert(q->get() == obj.get()); _objects.erase(q); return _objects.empty(); } -ObjectCache::ObjectCache(const Ice::CommunicatorPtr& communicator) : _communicator(communicator) +ObjectCache::ObjectCache(const shared_ptr<Ice::Communicator>& communicator) : _communicator(communicator) { } @@ -73,7 +59,7 @@ ObjectCache::add(const ObjectInfo& info, const string& application, const string { const Ice::Identity& id = info.proxy->ice_getIdentity(); - Lock sync(*this); + lock_guard lock(_mutex); if(getImpl(id)) { Ice::Error out(_communicator->getLogger()); @@ -81,13 +67,13 @@ ObjectCache::add(const ObjectInfo& info, const string& application, const string return; } - ObjectEntryPtr entry = new ObjectEntry(info, application, server); + auto entry = make_shared<ObjectEntry>(info, application, server); addImpl(id, entry); map<string, TypeEntry>::iterator p = _types.find(entry->getType()); if(p == _types.end()) { - p = _types.insert(p, map<string, TypeEntry>::value_type(entry->getType(), TypeEntry())); + p = _types.insert(p, { entry->getType(), TypeEntry() }); } p->second.add(entry); @@ -98,11 +84,11 @@ ObjectCache::add(const ObjectInfo& info, const string& application, const string } } -ObjectEntryPtr +shared_ptr<ObjectEntry> ObjectCache::get(const Ice::Identity& id) const { - Lock sync(*this); - ObjectEntryPtr entry = getImpl(id); + lock_guard lock(_mutex); + shared_ptr<ObjectEntry> entry = getImpl(id); if(!entry) { throw ObjectNotRegisteredException(id); @@ -113,8 +99,8 @@ ObjectCache::get(const Ice::Identity& id) const void ObjectCache::remove(const Ice::Identity& id) { - Lock sync(*this); - ObjectEntryPtr entry = getImpl(id); + lock_guard lock(_mutex); + shared_ptr<ObjectEntry> entry = getImpl(id); if(!entry) { Ice::Error out(_communicator->getLogger()); @@ -137,14 +123,14 @@ ObjectCache::remove(const Ice::Identity& id) } } -vector<ObjectEntryPtr> +vector<shared_ptr<ObjectEntry>> ObjectCache::getObjectsByType(const string& type) { - Lock sync(*this); + lock_guard lock(_mutex); map<string, TypeEntry>::const_iterator p = _types.find(type); if(p == _types.end()) { - return vector<ObjectEntryPtr>(); + return vector<shared_ptr<ObjectEntry>>(); } return p->second.getObjects(); } @@ -152,9 +138,9 @@ ObjectCache::getObjectsByType(const string& type) ObjectInfoSeq ObjectCache::getAll(const string& expression) { - Lock sync(*this); + lock_guard lock(_mutex); ObjectInfoSeq infos; - for(map<Ice::Identity, ObjectEntryPtr>::const_iterator p = _entries.begin(); p != _entries.end(); ++p) + for(auto p = _entries.cbegin(); p != _entries.cend(); ++p) { if(expression.empty() || IceUtilInternal::match(_communicator->identityToString(p->first), expression, true)) { @@ -167,7 +153,7 @@ ObjectCache::getAll(const string& expression) ObjectInfoSeq ObjectCache::getAllByType(const string& type) { - Lock sync(*this); + lock_guard lock(_mutex); ObjectInfoSeq infos; map<string, TypeEntry>::const_iterator p = _types.find(type); if(p == _types.end()) @@ -175,8 +161,8 @@ ObjectCache::getAllByType(const string& type) return infos; } - const vector<ObjectEntryPtr>& objects = p->second.getObjects(); - for(vector<ObjectEntryPtr>::const_iterator q = objects.begin(); q != objects.end(); ++q) + const vector<shared_ptr<ObjectEntry>>& objects = p->second.getObjects(); + for(vector<shared_ptr<ObjectEntry>>::const_iterator q = objects.begin(); q != objects.end(); ++q) { infos.push_back((*q)->getObjectInfo()); } @@ -190,7 +176,7 @@ ObjectEntry::ObjectEntry(const ObjectInfo& info, const string& application, cons { } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> ObjectEntry::getProxy() const { return _info.proxy; diff --git a/cpp/src/IceGrid/ObjectCache.h b/cpp/src/IceGrid/ObjectCache.h index 3ad01e04679..a0b3f01bf25 100644 --- a/cpp/src/IceGrid/ObjectCache.h +++ b/cpp/src/IceGrid/ObjectCache.h @@ -5,7 +5,6 @@ #ifndef ICE_GRID_OBJECTCACHE_H #define ICE_GRID_OBJECTCACHE_H -#include <IceUtil/Mutex.h> #include <Ice/CommunicatorF.h> #include <IceGrid/Cache.h> #include <IceGrid/Internal.h> @@ -15,12 +14,12 @@ namespace IceGrid class ObjectCache; -class ObjectEntry : public IceUtil::Shared +class ObjectEntry { public: ObjectEntry(const ObjectInfo&, const std::string&, const std::string&); - Ice::ObjectPrx getProxy() const; + std::shared_ptr<Ice::ObjectPrx> getProxy() const; std::string getType() const; std::string getApplication() const; std::string getServer() const; @@ -34,24 +33,23 @@ private: const std::string _application; const std::string _server; }; -typedef IceUtil::Handle<ObjectEntry> ObjectEntryPtr; class ObjectCache : public Cache<Ice::Identity, ObjectEntry> { public: - ObjectCache(const Ice::CommunicatorPtr&); + ObjectCache(const std::shared_ptr<Ice::Communicator>&); void add(const ObjectInfo&, const std::string&, const std::string&); - ObjectEntryPtr get(const Ice::Identity&) const; + std::shared_ptr<ObjectEntry> get(const Ice::Identity&) const; void remove(const Ice::Identity&); - std::vector<ObjectEntryPtr> getObjectsByType(const std::string&); + std::vector<std::shared_ptr<ObjectEntry>> getObjectsByType(const std::string&); ObjectInfoSeq getAll(const std::string&); ObjectInfoSeq getAllByType(const std::string&); - const Ice::CommunicatorPtr& getCommunicator() const { return _communicator; } + const std::shared_ptr<Ice::Communicator>& getCommunicator() const { return _communicator; } private: @@ -59,22 +57,19 @@ private: { public: - TypeEntry(); + void add(const std::shared_ptr<ObjectEntry>&); + bool remove(const std::shared_ptr<ObjectEntry>&); - void add(const ObjectEntryPtr&); - bool remove(const ObjectEntryPtr&); - - const std::vector<ObjectEntryPtr>& getObjects() const { return _objects; } + const std::vector<std::shared_ptr<ObjectEntry>>& getObjects() const { return _objects; } private: - std::vector<ObjectEntryPtr> _objects; + std::vector<std::shared_ptr<ObjectEntry>> _objects; }; - const Ice::CommunicatorPtr _communicator; + const std::shared_ptr<Ice::Communicator> _communicator; std::map<std::string, TypeEntry> _types; - static std::pointer_to_unary_function<int, unsigned int> _rand; }; }; diff --git a/cpp/src/IceGrid/Parser.cpp b/cpp/src/IceGrid/Parser.cpp index 736bd3ed421..8d85f207cd0 100644 --- a/cpp/src/IceGrid/Parser.cpp +++ b/cpp/src/IceGrid/Parser.cpp @@ -13,8 +13,9 @@ #include <IceGrid/DescriptorHelper.h> #include <IceBox/IceBox.h> -#if defined(__APPLE__) || defined(__linux__) -# include <editline/readline.h> +#ifdef HAVE_READLINE +# include <readline/readline.h> +# include <readline/history.h> #endif #include <iterator> @@ -233,7 +234,7 @@ const char* _commandsHelp[][3] = { int loggerCallbackCount = 0; #ifdef _WIN32 -Ice::StringConverterPtr windowsConsoleConverter = 0; +shared_ptr<Ice::StringConverter> windowsConsoleConverter = nullptr; #endif void outputNewline() @@ -283,12 +284,12 @@ void printLogMessage(const string& p, const Ice::LogMessage& logMessage) switch(logMessage.type) { - case Ice::PrintMessage: + case Ice::LogMessageType::PrintMessage: { writeMessage(timestamp + " " + logMessage.message, false); break; } - case Ice::TraceMessage: + case Ice::LogMessageType::TraceMessage: { string s = "-- " + timestamp + " " + prefix; if(!logMessage.traceCategory.empty()) @@ -299,12 +300,12 @@ void printLogMessage(const string& p, const Ice::LogMessage& logMessage) writeMessage(s, true); break; } - case Ice::WarningMessage: + case Ice::LogMessageType::WarningMessage: { writeMessage("!- " + timestamp + " " + prefix + "warning: " + logMessage.message, true); break; } - case Ice::ErrorMessage: + case Ice::LogMessageType::ErrorMessage: { writeMessage("!! " + timestamp + " " + prefix + "error: " + logMessage.message, true); break; @@ -316,27 +317,26 @@ void printLogMessage(const string& p, const Ice::LogMessage& logMessage) } } -class RemoteLoggerI : public Ice::RemoteLogger +class RemoteLoggerI final : public Ice::RemoteLogger { public: RemoteLoggerI(); - virtual void init(const string&, const Ice::LogMessageSeq&, const Ice::Current&); - virtual void log(const Ice::LogMessage&, const Ice::Current&); + void init(string, Ice::LogMessageSeq, const Ice::Current&) override; + void log(Ice::LogMessage, const Ice::Current&) override; void destroy(); private: - IceUtil::Monitor<IceUtil::Mutex> _monitor; + mutex _mutex; + condition_variable _condVar; bool _initDone; bool _destroyed; string _prefix; }; -typedef IceUtil::Handle<RemoteLoggerI> RemoteLoggerIPtr; - RemoteLoggerI::RemoteLoggerI() : _initDone(false), _destroyed(false) @@ -344,31 +344,30 @@ RemoteLoggerI::RemoteLoggerI() : } void -RemoteLoggerI::init(const string& prefix, const Ice::LogMessageSeq& logMessages, const Ice::Current&) +RemoteLoggerI::init(string prefix, Ice::LogMessageSeq logMessages, const Ice::Current&) { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + lock_guard lock(_mutex); if(!_destroyed) { _prefix = prefix; - for(Ice::LogMessageSeq::const_iterator p = logMessages.begin(); p != logMessages.end(); ++p) + for(const auto& message : logMessages) { - printLogMessage(_prefix, *p); + printLogMessage(_prefix, message); } _initDone = true; - _monitor.notifyAll(); + _condVar.notify_all(); } } void -RemoteLoggerI::log(const Ice::LogMessage& logMessage, const Ice::Current&) +RemoteLoggerI::log(Ice::LogMessage logMessage, const Ice::Current&) { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); - while(!_initDone && !_destroyed) - { - _monitor.wait(); - } + unique_lock lock(_mutex); + + _condVar.wait(lock, [this] { return _initDone || _destroyed; } ); + if(!_destroyed) { printLogMessage(_prefix, logMessage); @@ -378,9 +377,9 @@ RemoteLoggerI::log(const Ice::LogMessage& logMessage, const Ice::Current&) void RemoteLoggerI::destroy() { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + lock_guard lock(_mutex); _destroyed = true; - _monitor.notifyAll(); + _condVar.notify_all(); } } @@ -392,11 +391,31 @@ Parser* parser; } -ParserPtr -Parser::createParser(const CommunicatorPtr& communicator, const AdminSessionPrx& session, const AdminPrx& admin, - bool interactive) +Parser::Parser(shared_ptr<Communicator> communicator, + shared_ptr<AdminSessionPrx> session, + shared_ptr<AdminPrx> admin, + bool interactive) : + _communicator(move(communicator)), + _session(move(session)), + _admin(move(admin)), + _interrupted(false), + _interactive(interactive) { - return new Parser(communicator, session, admin, interactive); + for(int i = 0; _commandsHelp[i][0]; i++) + { + const string category = _commandsHelp[i][0]; + const string cmd = _commandsHelp[i][1]; + const string help = _commandsHelp[i][2]; + _helpCommands[category][""] += help; + _helpCommands[category][cmd] += help; + } + +#ifdef _WIN32 + if(!windowsConsoleConverter) + { + windowsConsoleConverter = Ice::createWindowsStringConverter(GetConsoleOutputCP()); + } +#endif } void @@ -459,22 +478,22 @@ Parser::usage() void Parser::interrupt() { - Lock sync(*this); + lock_guard lock(_mutex); _interrupted = true; - notifyAll(); + _condVar.notify_all(); } bool Parser::interrupted() const { - Lock sync(*this); + lock_guard lock(_mutex); return _interrupted; } void Parser::resetInterrupt() { - Lock sync(*this); + lock_guard lock(_mutex); _interrupted = false; } @@ -483,7 +502,7 @@ Parser::checkInterrupted() { if(!_interactive) { - Lock sync(*this); + lock_guard lock(_mutex); if(_interrupted) { throw runtime_error("interrupted with Ctrl-C"); @@ -501,9 +520,9 @@ Parser::addApplication(const list<string>& origArgs) vector<string> args; try { - for(list<string>::const_iterator p = copyArgs.begin(); p != copyArgs.end(); ++p) + for(const auto& arg : copyArgs) { - args.push_back(*p); + args.push_back(arg); } args = opts.parse(args); } @@ -614,9 +633,9 @@ Parser::diffApplication(const list<string>& origArgs) vector<string> args; try { - for(list<string>::const_iterator p = copyArgs.begin(); p != copyArgs.end(); ++p) + for(const auto& arg : copyArgs) { - args.push_back(*p); + args.push_back(arg); } args = opts.parse(args); } @@ -840,8 +859,8 @@ Parser::describeServerTemplate(const list<string>& args) out << nl << "parameters = `" << toString(q->second.parameters) << "'"; out << nl; - ServerDescriptorPtr server = ServerDescriptorPtr::dynamicCast(q->second.descriptor); - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(server); + auto server = dynamic_pointer_cast<ServerDescriptor>(q->second.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(server); if(iceBox) { IceBoxHelper(iceBox).print(_communicator, out); @@ -931,7 +950,7 @@ Parser::describeServiceTemplate(const list<string>& args) out << nl << "parameters = `" << toString(q->second.parameters) << "'"; out << nl; - ServiceDescriptorPtr desc = ServiceDescriptorPtr::dynamicCast(q->second.descriptor); + auto desc = dynamic_pointer_cast<ServiceDescriptor>(q->second.descriptor); ServiceHelper(desc).print(_communicator, out); out << eb; out << nl; @@ -1346,8 +1365,8 @@ Parser::writeMessage(const list<string>& args, int fd) list<string>::const_iterator p = args.begin(); string server = *p++; - Ice::ObjectPrx serverAdmin = _admin->getServerAdmin(server); - Ice::ProcessPrx process = Ice::ProcessPrx::uncheckedCast(serverAdmin, "Process"); + auto serverAdmin = _admin->getServerAdmin(server); + auto process = Ice::uncheckedCast<Ice::ProcessPrx>(serverAdmin, "Process"); process->writeMessage(*p, fd); } @@ -1379,7 +1398,7 @@ Parser::describeServer(const list<string>& args) ServerInfo info = _admin->getServerInfo(args.front()); ostringstream os; Output out(os); - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(info.descriptor); if(iceBox) { IceBoxHelper(iceBox).print(_communicator, out, info); @@ -1412,39 +1431,39 @@ Parser::stateServer(const list<string>& args) string enabled = _admin->isServerEnabled(args.front()) ? "enabled" : "disabled"; switch(state) { - case Inactive: + case ServerState::Inactive: { consoleOut << "inactive (" << enabled << ")" << endl; break; } - case Activating: + case ServerState::Activating: { consoleOut << "activating (" << enabled << ")" << endl; break; } - case Active: + case ServerState::Active: { int pid = _admin->getServerPid(args.front()); consoleOut << "active (pid = " << pid << ", " << enabled << ")" << endl; break; } - case ActivationTimedOut: + case ServerState::ActivationTimedOut: { int pid = _admin->getServerPid(args.front()); consoleOut << "activation timed out (pid = " << pid << ", " << enabled << ")" << endl; break; } - case Deactivating: + case ServerState::Deactivating: { consoleOut << "deactivating (" << enabled << ")" << endl; break; } - case Destroying: + case ServerState::Destroying: { consoleOut << "destroying (" << enabled << ")" << endl; break; } - case Destroyed: + case ServerState::Destroyed: { consoleOut << "destroyed (" << enabled << ")" << endl; break; @@ -1502,8 +1521,8 @@ Parser::propertiesServer(const list<string>& args, bool single) try { - Ice::ObjectPrx serverAdmin = _admin->getServerAdmin(args.front()); - Ice::PropertiesAdminPrx propAdmin = Ice::PropertiesAdminPrx::uncheckedCast(serverAdmin, "Properties"); + auto serverAdmin = _admin->getServerAdmin(args.front()); + auto propAdmin = Ice::uncheckedCast<Ice::PropertiesAdminPrx>(serverAdmin, "Properties"); if(single) { @@ -1512,10 +1531,9 @@ Parser::propertiesServer(const list<string>& args, bool single) } else { - Ice::PropertyDict properties = propAdmin->getPropertiesForPrefix(""); - for(Ice::PropertyDict::const_iterator p = properties.begin(); p != properties.end(); ++p) + for(const auto& prop : propAdmin->getPropertiesForPrefix("")) { - consoleOut << p->first << "=" << p->second << endl; + consoleOut << prop.first << "=" << prop.second << endl; } } } @@ -1594,8 +1612,8 @@ Parser::startService(const list<string>& args) string service = *(++args.begin()); try { - Ice::ObjectPrx admin = _admin->getServerAdmin(server); - IceBox::ServiceManagerPrx manager = IceBox::ServiceManagerPrx::uncheckedCast(admin, "IceBox.ServiceManager"); + auto admin = _admin->getServerAdmin(server); + auto manager = Ice::uncheckedCast<IceBox::ServiceManagerPrx>(admin, "IceBox.ServiceManager"); manager->startService(service); } catch(const IceBox::AlreadyStartedException&) @@ -1633,8 +1651,8 @@ Parser::stopService(const list<string>& args) string service = *(++args.begin()); try { - Ice::ObjectPrx admin = _admin->getServerAdmin(server); - IceBox::ServiceManagerPrx manager = IceBox::ServiceManagerPrx::uncheckedCast(admin, "IceBox.ServiceManager"); + auto admin = _admin->getServerAdmin(server); + auto manager = Ice::uncheckedCast<IceBox::ServiceManagerPrx>(admin, "IceBox.ServiceManager"); manager->stopService(service); } catch(const IceBox::AlreadyStoppedException&) @@ -1673,7 +1691,7 @@ Parser::describeService(const list<string>& args) try { ServerInfo info = _admin->getServerInfo(server); - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(info.descriptor); if(!iceBox) { error("server `" + server + "' is not an IceBox server"); @@ -1683,11 +1701,11 @@ Parser::describeService(const list<string>& args) ostringstream os; Output out(os); bool found = false; - for(ServiceInstanceDescriptorSeq::const_iterator p = iceBox->services.begin(); p != iceBox->services.end(); ++p) + for(const auto& s : iceBox->services) { - if(p->descriptor && p->descriptor->name == service) + if(s.descriptor && s.descriptor->name == service) { - ServiceHelper(p->descriptor).print(_communicator, out); + ServiceHelper(s.descriptor).print(_communicator, out); out << nl; found = true; break; @@ -1732,7 +1750,7 @@ Parser::propertiesService(const list<string>& args, bool single) // First, we ensure that the service exists. // ServerInfo info = _admin->getServerInfo(server); - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(info.descriptor); if(!iceBox) { error("server `" + server + "' is not an IceBox server"); @@ -1740,9 +1758,10 @@ Parser::propertiesService(const list<string>& args, bool single) } bool found = false; - for(ServiceInstanceDescriptorSeq::const_iterator p = iceBox->services.begin(); p != iceBox->services.end(); ++p) + + for(const auto& s : iceBox->services) { - if(p->descriptor && p->descriptor->name == service) + if(s.descriptor && s.descriptor->name == service) { found = true; break; @@ -1754,15 +1773,15 @@ Parser::propertiesService(const list<string>& args, bool single) return; } - Ice::ObjectPrx admin = _admin->getServerAdmin(server); - Ice::PropertiesAdminPrx propAdmin; + auto admin = _admin->getServerAdmin(server); + shared_ptr<Ice::PropertiesAdminPrx> propAdmin; if(getPropertyAsInt(info.descriptor->propertySet.properties, "IceBox.UseSharedCommunicator." + service) > 0) { - propAdmin = Ice::PropertiesAdminPrx::uncheckedCast(admin, "IceBox.SharedCommunicator.Properties"); + propAdmin = Ice::uncheckedCast<Ice::PropertiesAdminPrx>(admin, "IceBox.SharedCommunicator.Properties"); } else { - propAdmin = Ice::PropertiesAdminPrx::uncheckedCast(admin, "IceBox.Service." + service + ".Properties"); + propAdmin = Ice::uncheckedCast<Ice::PropertiesAdminPrx>(admin, "IceBox.Service." + service + ".Properties"); } if(single) @@ -1806,17 +1825,17 @@ Parser::listServices(const list<string>& args) try { ServerInfo info = _admin->getServerInfo(server); - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(info.descriptor); if(!iceBox) { error("server `" + server + "' is not an IceBox server"); return; } - for(ServiceInstanceDescriptorSeq::const_iterator p = iceBox->services.begin(); p != iceBox->services.end(); ++p) + for(const auto& s : iceBox->services) { - if(p->descriptor) + if(s.descriptor) { - consoleOut << p->descriptor->name << endl; + consoleOut << s.descriptor->name << endl; } } } @@ -2152,9 +2171,9 @@ Parser::showFile(const string& id, const string& reader, const string& filename, bool head, bool tail, bool follow, int lineCount) { - int maxBytes = _communicator->getProperties()->getPropertyAsIntWithDefault("Ice.MessageSizeMax", 1024) * 1024; + int maxBytes = _communicator->getProperties()->getPropertyAsIntWithDefault("Ice.MessageMaxSize", 1024) * 1024; - FileIteratorPrx it; + shared_ptr<FileIteratorPrx> it; try { @@ -2217,10 +2236,10 @@ Parser::showFile(const string& id, const string& reader, const string& filename, while(!interrupted() && !eof && i < lineCount) { eof = it->read(maxBytes, lines); - for(Ice::StringSeq::const_iterator p = lines.begin(); i < lineCount && p != lines.end(); ++p, ++i) + for(const auto& line : lines) { outputNewline(); - outputString(*p); + outputString(line); flushOutput(); } } @@ -2231,10 +2250,10 @@ Parser::showFile(const string& id, const string& reader, const string& filename, while(!interrupted() && !eof) { eof = it->read(maxBytes, lines); - for(Ice::StringSeq::const_iterator p = lines.begin(); p != lines.end(); ++p) + for(const auto& line : lines) { outputNewline(); - outputString(*p); + outputString(line); flushOutput(); } } @@ -2260,12 +2279,12 @@ Parser::showFile(const string& id, const string& reader, const string& filename, if(eof) { - Lock sync(*this); + unique_lock lock(_mutex); if(_interrupted) { break; } - timedWait(IceUtil::Time::seconds(5)); + _condVar.wait_for(lock, 5s); } } } @@ -2299,7 +2318,7 @@ Parser::showLog(const string& id, const string& reader, bool tail, bool follow, { outputNewline(); - Ice::ObjectPrx admin; + shared_ptr<Ice::ObjectPrx> admin; if(reader == "server") { @@ -2320,11 +2339,11 @@ Parser::showLog(const string& id, const string& reader, bool tail, bool follow, return; } - Ice::LoggerAdminPrx loggerAdmin; + shared_ptr<Ice::LoggerAdminPrx> loggerAdmin; try { - loggerAdmin = Ice::LoggerAdminPrx::checkedCast(admin, "Logger"); + loggerAdmin = Ice::checkedCast<Ice::LoggerAdminPrx>(admin, "Logger"); } catch(const Ice::Exception&) { @@ -2338,7 +2357,7 @@ Parser::showLog(const string& id, const string& reader, bool tail, bool follow, if(follow) { - Ice::ObjectPrx adminCallbackTemplate = _session->getAdminCallbackTemplate(); + auto adminCallbackTemplate = _session->getAdminCallbackTemplate(); if(adminCallbackTemplate == 0) { @@ -2349,44 +2368,39 @@ Parser::showLog(const string& id, const string& reader, bool tail, bool follow, const Ice::EndpointSeq endpoints = adminCallbackTemplate->ice_getEndpoints(); string publishedEndpoints; - for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) + for(const auto& endpoint : endpoints) { if(publishedEndpoints.empty()) { - publishedEndpoints = (*p)->toString(); + publishedEndpoints = endpoint->toString(); } else { - publishedEndpoints += ":" + (*p)->toString(); + publishedEndpoints += ":" + endpoint->toString(); } } _communicator->getProperties()->setProperty("RemoteLoggerAdapter.PublishedEndpoints", publishedEndpoints); - Ice::ObjectAdapterPtr adapter = _communicator->createObjectAdapter("RemoteLoggerAdapter"); + auto adapter = _communicator->createObjectAdapter("RemoteLoggerAdapter"); _session->ice_getConnection()->setAdapter(adapter); - Ice::Identity ident; - ostringstream name; - name << "RemoteLogger-" << loggerCallbackCount++; - ident.name = name.str(); - ident.category = adminCallbackTemplate->ice_getIdentity().category; + ostringstream os; + os << "RemoteLogger-" << loggerCallbackCount++; + Ice::Identity ident = { os.str(), + adminCallbackTemplate->ice_getIdentity().category }; - RemoteLoggerIPtr servant = new RemoteLoggerI; - Ice::RemoteLoggerPrx prx = - Ice::RemoteLoggerPrx::uncheckedCast(adapter->add(servant, ident)); + auto servant = make_shared<RemoteLoggerI>(); + auto prx = Ice::uncheckedCast<Ice::RemoteLoggerPrx>(adapter->add(servant, ident)); adapter->activate(); loggerAdmin->attachRemoteLogger(prx, Ice::LogMessageTypeSeq(), Ice::StringSeq(), tail ? lineCount : -1); resetInterrupt(); { - Lock lock(*this); - while(!_interrupted) - { - wait(); - } + unique_lock lock(_mutex); + _condVar.wait(lock, [this] { return _interrupted; }); } servant->destroy(); @@ -2467,78 +2481,72 @@ Parser::getInput(char* buf, size_t& result, size_t maxSize) } else { -#if defined(__APPLE__) || defined(__linux__) - if (isatty(fileno(stdin)) == 1) +#ifdef HAVE_READLINE + + const char* prompt = parser->getPrompt(); + char* line = readline(const_cast<char*>(prompt)); + if(!line) { - const char* prompt = parser->getPrompt(); - char* line = readline(const_cast<char*>(prompt)); - if(!line) + result = 0; + } + else + { + if(*line) + { + add_history(line); + } + + result = strlen(line) + 1; + if(result > maxSize) { + free(line); + error("input line too long"); result = 0; } else { - if(*line) - { - add_history(line); - } - - result = strlen(line) + 1; - if(result > maxSize) - { - free(line); - error("input line too long"); - result = 0; - } - else - { - strcpy(buf, line); - strcat(buf, "\n"); - free(line); - } + strcpy(buf, line); + strcat(buf, "\n"); + free(line); } } - else +#else + consoleOut << parser->getPrompt() << flush; + string line; + while(true) { -#endif - consoleOut << parser->getPrompt() << flush; - string line; - while(true) + int c = getc(yyin); + if(c == EOF) { - int c = getc(yyin); - if(c == EOF) + if(line.size()) { - if(line.size()) - { - line += '\n'; - } - break; - } - - line += static_cast<char>(c); - if(c == '\n') - { - break; + line += '\n'; } + break; } -#ifdef _WIN32 - if(windowsConsoleConverter) + + line += static_cast<char>(c); + if(c == '\n') { - line = nativeToUTF8(line, windowsConsoleConverter); + break; } + } +#ifdef _WIN32 + if(windowsConsoleConverter) + { + line = nativeToUTF8(line, windowsConsoleConverter); + } #endif - result = line.length(); - if(result > maxSize) - { - error("input line too long"); - buf[0] = EOF; - result = 1; - } - else - { - strcpy(buf, line.c_str()); - } -#if defined(__APPLE__) || defined(__linux__) + result = line.length(); + if(result > maxSize) + { + error("input line too long"); + buf[0] = EOF; + result = 1; + } + else + { + strcpy(buf, line.c_str()); } #endif } @@ -2692,33 +2700,6 @@ Parser::parse(const std::string& commands, bool debug) return status; } -Parser::Parser(const CommunicatorPtr& communicator, - const AdminSessionPrx& session, - const AdminPrx& admin, - bool interactive) : - _communicator(communicator), - _session(session), - _admin(admin), - _interrupted(false), - _interactive(interactive) -{ - for(int i = 0; _commandsHelp[i][0]; i++) - { - const string category = _commandsHelp[i][0]; - const string cmd = _commandsHelp[i][1]; - const string help = _commandsHelp[i][2]; - _helpCommands[category][""] += help; - _helpCommands[category][cmd] += help; - } - -#ifdef _WIN32 - if(!windowsConsoleConverter) - { - windowsConsoleConverter = Ice::createWindowsStringConverter(GetConsoleOutputCP()); - } -#endif -} - void Parser::exception(const Ice::Exception& pex) { diff --git a/cpp/src/IceGrid/Parser.h b/cpp/src/IceGrid/Parser.h index b28492f08e2..3c3f8d19a25 100644 --- a/cpp/src/IceGrid/Parser.h +++ b/cpp/src/IceGrid/Parser.h @@ -5,9 +5,9 @@ #ifndef ICE_GRID_PARSER_H #define ICE_GRID_PARSER_H -#include <IceUtil/Handle.h> #include <IceGrid/Admin.h> #include <IceGrid/Registry.h> + #include <list> #include <stdio.h> @@ -38,19 +38,11 @@ YY_DECL; namespace IceGrid { -class Parser; -typedef ::IceUtil::Handle<Parser> ParserPtr; - -} - -namespace IceGrid -{ - -class Parser : public ::IceUtil::SimpleShared, IceUtil::Monitor<IceUtil::Mutex> +class Parser { public: - static ParserPtr createParser(const Ice::CommunicatorPtr&, const AdminSessionPrx&, const AdminPrx&, bool); + Parser(std::shared_ptr<Ice::Communicator>, std::shared_ptr<AdminSessionPrx>, std::shared_ptr<AdminPrx>, bool); void usage(); void usage(const std::string&, const std::string& = std::string()); @@ -145,16 +137,18 @@ public: private: - Parser(const Ice::CommunicatorPtr&, const AdminSessionPrx&, const AdminPrx&, bool); void exception(const Ice::Exception&); void showFile(const std::string&, const std::string&, const std::string&, bool, bool, bool, int); void showLog(const std::string&, const std::string&, bool, bool, int); + mutable std::mutex _mutex; + std::condition_variable _condVar; + std::string _commands; - Ice::CommunicatorPtr _communicator; - AdminSessionPrx _session; - AdminPrx _admin; + std::shared_ptr<Ice::Communicator> _communicator; + std::shared_ptr<AdminSessionPrx> _session; + std::shared_ptr<AdminPrx> _admin; bool _continue; bool _interrupted; int _errors; diff --git a/cpp/src/IceGrid/PlatformInfo.cpp b/cpp/src/IceGrid/PlatformInfo.cpp index 5b953d0ebb1..a15e2fd89dc 100644 --- a/cpp/src/IceGrid/PlatformInfo.cpp +++ b/cpp/src/IceGrid/PlatformInfo.cpp @@ -22,13 +22,6 @@ # include <sys/utsname.h> # if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) # include <sys/sysctl.h> -# elif defined(__sun) -# include <sys/loadavg.h> -# elif defined(__hpux) -# include <sys/pstat.h> -# elif defined(_AIX) -# include <nlist.h> -# include <fcntl.h> # endif #endif @@ -47,7 +40,7 @@ pdhErrorToString(PDH_STATUS err) } static string -getLocalizedPerfName(int idx, const Ice::LoggerPtr& logger) +getLocalizedPerfName(int idx, const shared_ptr<Ice::Logger>& logger) { vector<char> localized; unsigned long size = 256; @@ -95,7 +88,7 @@ private: typedef BOOL (WINAPI *LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD); int -getSocketCount(const Ice::LoggerPtr& logger) +getSocketCount(const shared_ptr<Ice::Logger>& logger) { LPFN_GLPI glpi; glpi = (LPFN_GLPI) GetProcAddress(GetModuleHandle(TEXT("kernel32")), "GetLogicalProcessorInformation"); @@ -149,7 +142,7 @@ namespace IceGrid { RegistryInfo -toRegistryInfo(const InternalReplicaInfoPtr& replica) +toRegistryInfo(const shared_ptr<InternalReplicaInfo>& replica) { RegistryInfo info; info.name = replica->name; @@ -158,7 +151,7 @@ toRegistryInfo(const InternalReplicaInfoPtr& replica) } NodeInfo -toNodeInfo(const InternalNodeInfoPtr& node) +toNodeInfo(const shared_ptr<InternalNodeInfo>& node) { NodeInfo info; info.name = node->name; @@ -175,8 +168,8 @@ toNodeInfo(const InternalNodeInfoPtr& node) } PlatformInfo::PlatformInfo(const string& prefix, - const Ice::CommunicatorPtr& communicator, - const TraceLevelsPtr& traceLevels) : + const shared_ptr<Ice::Communicator>& communicator, + const shared_ptr<TraceLevels>& traceLevels) : _traceLevels(traceLevels) { // @@ -190,25 +183,6 @@ PlatformInfo::PlatformInfo(const string& prefix, _last1Total = 0; _last5Total = 0; _last15Total = 0; -#elif defined(_AIX) - struct nlist nl; - nl.n_name = const_cast<char*>("avenrun"); - nl.n_value = 0; - if(knlist(&nl, 1, sizeof(nl)) == 0) - { - _kmem = open("/dev/kmem", O_RDONLY); - - // - // Give up root permissions to minimize security risks, it's - // only needed to access /dev/kmem. - // - setuid(getuid()); - setgid(getgid()); - } - else - { - _kmem = -1; - } #endif // @@ -253,11 +227,11 @@ PlatformInfo::PlatformInfo(const string& prefix, // // GetVersionEx deprecated in Windows 8.1 // -# if defined(_MSC_VER) && _MSC_VER >= 1800 +# if defined(_MSC_VER) # pragma warning (disable : 4996) # endif GetVersionEx(&osInfo); -# if defined(_MSC_VER) && _MSC_VER >= 1800 +# if defined(_MSC_VER) # pragma warning (default : 4996) # endif @@ -323,7 +297,7 @@ PlatformInfo::PlatformInfo(const string& prefix, _machine = utsinfo.machine; #endif - Ice::PropertiesPtr properties = communicator->getProperties(); + auto properties = communicator->getProperties(); // // Try to obtain the number of processor sockets. @@ -400,22 +374,11 @@ PlatformInfo::PlatformInfo(const string& prefix, } } -PlatformInfo::~PlatformInfo() -{ -#if defined(_AIX) - if(_kmem > 0) - { - close(_kmem); - } -#endif -} - void PlatformInfo::start() { #if defined(_WIN32) - _updateUtilizationThread = new UpdateUtilizationAverageThread(*this); - _updateUtilizationThread->start(); + _updateUtilizationThread = std::thread([this] { runUpdateLoadInfo(); }); #endif } @@ -424,14 +387,11 @@ PlatformInfo::stop() { #if defined(_WIN32) { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_utilizationMonitor); + lock_guard lock(_utilizationMutex); _terminated = true; - _utilizationMonitor.notify(); + _utilizationCondVar.notify_one(); } - - assert(_updateUtilizationThread); - _updateUtilizationThread->getThreadControl().join(); - _updateUtilizationThread = 0; + _updateUtilizationThread.join(); #endif } @@ -447,40 +407,26 @@ PlatformInfo::getRegistryInfo() const return toRegistryInfo(getInternalReplicaInfo()); } -InternalNodeInfoPtr +shared_ptr<InternalNodeInfo> PlatformInfo::getInternalNodeInfo() const { - InternalNodeInfoPtr info = new InternalNodeInfo(); - info->name = _name; - info->os = _os; - info->hostname = _hostname; - info->release = _release; - info->version = _version; - info->machine = _machine; - info->nProcessors = _nProcessorThreads; - info->dataDir = _dataDir; - return info; + return make_shared<InternalNodeInfo>(_name, _os, _hostname, _release, _version, + _machine, _nProcessorThreads, _dataDir); } -InternalReplicaInfoPtr +shared_ptr<InternalReplicaInfo> PlatformInfo::getInternalReplicaInfo() const { - InternalReplicaInfoPtr info = new InternalReplicaInfo(); - info->name = _name; - info->hostname = _hostname; - return info; + return make_shared<InternalReplicaInfo>(_name, _hostname); } LoadInfo -PlatformInfo::getLoadInfo() +PlatformInfo::getLoadInfo() const { - LoadInfo info; - info.avg1 = -1.0f; - info.avg5 = -1.0f; - info.avg15 = -1.0f; + LoadInfo info = { -1.0f, -1.0f, -1.0f }; #if defined(_WIN32) - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_utilizationMonitor); + lock_guard lock(_utilizationMutex); info.avg1 = static_cast<float>(_last1Total) / _usages1.size() / 100.0f; info.avg5 = static_cast<float>(_last5Total) / _usages5.size() / 100.0f; info.avg15 = static_cast<float>(_last15Total) / _usages15.size() / 100.0f; @@ -491,37 +437,12 @@ PlatformInfo::getLoadInfo() // not. The result is capped at 1.0f. // double loadAvg[3]; - if(getloadavg(loadAvg, 3) != -1) + if (getloadavg(loadAvg, 3) != -1) { info.avg1 = static_cast<float>(loadAvg[0]); info.avg5 = static_cast<float>(loadAvg[1]); info.avg15 = static_cast<float>(loadAvg[2]); } -#elif defined(__hpux) - struct pst_dynamic dynInfo; - if(pstat_getdynamic(&dynInfo, sizeof(dynInfo), 1, 0) >= 0) - { - info.avg1 = dynInfo.psd_avg_1_min; - info.avg5 = dynInfo.psd_avg_5_min; - info.avg15 = dynInfo.psd_avg_15_min; - } -#elif defined(_AIX) - if(_kmem > 1) - { - long long avenrun[3]; - struct nlist nl; - nl.n_name = const_cast<char*>("avenrun"); - nl.n_value = 0; - if(knlist(&nl, 1, sizeof(nl)) == 0) - { - if(pread(_kmem, avenrun, sizeof(avenrun), nl.n_value) >= sizeof(avenrun)) - { - info.avg1 = avenrun[0] / 65536.0f; - info.avg5 = avenrun[1] / 65536.0f; - info.avg15 = avenrun[2] / 65536.0f; - } - } - } #endif return info; } @@ -614,8 +535,8 @@ PlatformInfo::runUpdateLoadInfo() while(true) { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_utilizationMonitor); - _utilizationMonitor.timedWait(IceUtil::Time::seconds(5)); // 5 seconds. + unique_lock lock(_utilizationMutex); + _utilizationCondVar.wait_for(lock, 5s); if(_terminated) { break; diff --git a/cpp/src/IceGrid/PlatformInfo.h b/cpp/src/IceGrid/PlatformInfo.h index e9ca4942eff..6615908ada3 100644 --- a/cpp/src/IceGrid/PlatformInfo.h +++ b/cpp/src/IceGrid/PlatformInfo.h @@ -5,7 +5,6 @@ #ifndef ICE_GRID_PLATFORM_INFO_H #define ICE_GRID_PLATFORM_INFO_H -#include <IceUtil/Thread.h> #include <IceGrid/Internal.h> #ifdef _WIN32 @@ -17,28 +16,26 @@ namespace IceGrid { class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; -NodeInfo toNodeInfo(const InternalNodeInfoPtr&); -RegistryInfo toRegistryInfo(const InternalReplicaInfoPtr&); +NodeInfo toNodeInfo(const std::shared_ptr<InternalNodeInfo>&); +RegistryInfo toRegistryInfo(const std::shared_ptr<InternalReplicaInfo>&); -class PlatformInfo +class PlatformInfo final { public: - PlatformInfo(const std::string&, const Ice::CommunicatorPtr&, const TraceLevelsPtr&); - ~PlatformInfo(); + PlatformInfo(const std::string&, const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<TraceLevels>&); void start(); void stop(); - InternalNodeInfoPtr getInternalNodeInfo() const; - InternalReplicaInfoPtr getInternalReplicaInfo() const; + std::shared_ptr<InternalNodeInfo> getInternalNodeInfo() const; + std::shared_ptr<InternalReplicaInfo> getInternalReplicaInfo() const; NodeInfo getNodeInfo() const; RegistryInfo getRegistryInfo() const; - LoadInfo getLoadInfo(); + LoadInfo getLoadInfo() const; int getProcessorSocketCount() const; std::string getHostname() const; std::string getDataDir() const; @@ -50,7 +47,7 @@ public: private: - const TraceLevelsPtr _traceLevels; + const std::shared_ptr<TraceLevels> _traceLevels; std::string _name; std::string _os; std::string _hostname; @@ -64,17 +61,16 @@ private: int _nProcessorSockets; #if defined(_WIN32) - IceUtil::ThreadPtr _updateUtilizationThread; - IceUtil::Monitor<IceUtil::Mutex> _utilizationMonitor; - bool _terminated; std::deque<int> _usages1; std::deque<int> _usages5; std::deque<int> _usages15; int _last1Total; int _last5Total; int _last15Total; -#elif defined(_AIX) - int _kmem; + bool _terminated; + mutable std::mutex _utilizationMutex; + std::condition_variable _utilizationCondVar; + std::thread _updateUtilizationThread; #endif }; diff --git a/cpp/src/IceGrid/PluginFacadeI.cpp b/cpp/src/IceGrid/PluginFacadeI.cpp index 2aab4145681..79fd99739d4 100644 --- a/cpp/src/IceGrid/PluginFacadeI.cpp +++ b/cpp/src/IceGrid/PluginFacadeI.cpp @@ -13,7 +13,7 @@ using namespace IceGrid; namespace IceGrid { -ICEGRID_API void setRegistryPluginFacade(const RegistryPluginFacadePtr&); +ICEGRID_API void setRegistryPluginFacade(const shared_ptr<RegistryPluginFacade>&); } @@ -26,23 +26,23 @@ public: Init() { - IceGrid::setRegistryPluginFacade(new RegistryPluginFacadeI); + IceGrid::setRegistryPluginFacade(make_shared<RegistryPluginFacadeI>()); } ~Init() { - IceGrid::setRegistryPluginFacade(0); + IceGrid::setRegistryPluginFacade(nullptr); } }; Init init; bool -hasAdapter(const CommunicatorDescriptorPtr& descriptor, const string& adapterId) +hasAdapter(const shared_ptr<CommunicatorDescriptor>& descriptor, const string& adapterId) { - for(AdapterDescriptorSeq::const_iterator p = descriptor->adapters.begin(); p != descriptor->adapters.end(); ++p) + for(const auto& adapter : descriptor->adapters) { - if(p->id == adapterId) + if(adapter.id == adapterId) { return true; } @@ -52,14 +52,10 @@ hasAdapter(const CommunicatorDescriptorPtr& descriptor, const string& adapterId) } -RegistryPluginFacadeI::RegistryPluginFacadeI() -{ -} - ApplicationInfo RegistryPluginFacadeI::getApplicationInfo(const string& name) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -70,7 +66,7 @@ RegistryPluginFacadeI::getApplicationInfo(const string& name) const ServerInfo RegistryPluginFacadeI::getServerInfo(const string& serverId) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -81,7 +77,7 @@ RegistryPluginFacadeI::getServerInfo(const string& serverId) const AdapterInfoSeq RegistryPluginFacadeI::getAdapterInfo(const string& adapterId) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -92,7 +88,7 @@ RegistryPluginFacadeI::getAdapterInfo(const string& adapterId) const string RegistryPluginFacadeI::getAdapterServer(const string& adapterId) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -103,7 +99,7 @@ RegistryPluginFacadeI::getAdapterServer(const string& adapterId) const string RegistryPluginFacadeI::getAdapterNode(const string& adapterId) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -114,7 +110,7 @@ RegistryPluginFacadeI::getAdapterNode(const string& adapterId) const string RegistryPluginFacadeI::getAdapterApplication(const string& adapterId) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -125,7 +121,7 @@ RegistryPluginFacadeI::getAdapterApplication(const string& adapterId) const ObjectInfo RegistryPluginFacadeI::getObjectInfo(const Ice::Identity& id) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -136,7 +132,7 @@ RegistryPluginFacadeI::getObjectInfo(const Ice::Identity& id) const NodeInfo RegistryPluginFacadeI::getNodeInfo(const string& name) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -147,7 +143,7 @@ RegistryPluginFacadeI::getNodeInfo(const string& name) const LoadInfo RegistryPluginFacadeI::getNodeLoad(const string& name) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_database) { throw RegistryUnreachableException("", "registry not initialized yet"); @@ -166,7 +162,7 @@ RegistryPluginFacadeI::getPropertyForAdapter(const std::string& adapterId, const return IceGrid::getProperty(info.descriptor->propertySet.properties, name); } - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor); + auto iceBox = dynamic_pointer_cast<IceBoxDescriptor>(info.descriptor); if(!iceBox) { return ""; @@ -190,29 +186,29 @@ RegistryPluginFacadeI::getPropertyForAdapter(const std::string& adapterId, const } void -RegistryPluginFacadeI::addReplicaGroupFilter(const string& id, const ReplicaGroupFilterPtr& filter) ICE_NOEXCEPT +RegistryPluginFacadeI::addReplicaGroupFilter(const string& id, const shared_ptr<ReplicaGroupFilter>& filter) noexcept { - Lock sync(*this); - map<string, vector<ReplicaGroupFilterPtr> >::iterator p = _replicaGroupFilters.find(id); + lock_guard lock(_mutex); + map<string, vector<shared_ptr<ReplicaGroupFilter>> >::iterator p = _replicaGroupFilters.find(id); if(p == _replicaGroupFilters.end()) { - p = _replicaGroupFilters.insert(make_pair(id, vector<ReplicaGroupFilterPtr>())).first; + p = _replicaGroupFilters.insert(make_pair(id, vector<shared_ptr<ReplicaGroupFilter>>())).first; } p->second.push_back(filter); } bool -RegistryPluginFacadeI::removeReplicaGroupFilter(const string& id, const ReplicaGroupFilterPtr& filter) ICE_NOEXCEPT +RegistryPluginFacadeI::removeReplicaGroupFilter(const string& id, const shared_ptr<ReplicaGroupFilter>& filter) noexcept { - Lock sync(*this); + lock_guard lock(_mutex); - map<string, vector<ReplicaGroupFilterPtr> >::iterator p = _replicaGroupFilters.find(id); + map<string, vector<shared_ptr<ReplicaGroupFilter>> >::iterator p = _replicaGroupFilters.find(id); if(p == _replicaGroupFilters.end()) { return false; } - vector<ReplicaGroupFilterPtr>::iterator q = find(p->second.begin(), p->second.end(), filter); + vector<shared_ptr<ReplicaGroupFilter>>::iterator q = find(p->second.begin(), p->second.end(), filter); if(q == p->second.end()) { return false; @@ -227,29 +223,29 @@ RegistryPluginFacadeI::removeReplicaGroupFilter(const string& id, const ReplicaG } void -RegistryPluginFacadeI::addTypeFilter(const string& id, const TypeFilterPtr& filter) ICE_NOEXCEPT +RegistryPluginFacadeI::addTypeFilter(const string& id, const shared_ptr<TypeFilter>& filter) noexcept { - Lock sync(*this); - map<string, vector<TypeFilterPtr> >::iterator p = _typeFilters.find(id); + lock_guard lock(_mutex); + map<string, vector<shared_ptr<TypeFilter>> >::iterator p = _typeFilters.find(id); if(p == _typeFilters.end()) { - p = _typeFilters.insert(make_pair(id, vector<TypeFilterPtr>())).first; + p = _typeFilters.insert(make_pair(id, vector<shared_ptr<TypeFilter>>())).first; } p->second.push_back(filter); } bool -RegistryPluginFacadeI::removeTypeFilter(const string& id, const TypeFilterPtr& filter) ICE_NOEXCEPT +RegistryPluginFacadeI::removeTypeFilter(const string& id, const shared_ptr<TypeFilter>& filter) noexcept { - Lock sync(*this); + lock_guard lock(_mutex); - map<string, vector<TypeFilterPtr> >::iterator p = _typeFilters.find(id); + map<string, vector<shared_ptr<TypeFilter>> >::iterator p = _typeFilters.find(id); if(p == _typeFilters.end()) { return false; } - vector<TypeFilterPtr>::iterator q = find(p->second.begin(), p->second.end(), filter); + vector<shared_ptr<TypeFilter>>::iterator q = find(p->second.begin(), p->second.end(), filter); if(q == p->second.end()) { return false; @@ -263,16 +259,16 @@ RegistryPluginFacadeI::removeTypeFilter(const string& id, const TypeFilterPtr& f return true; } -vector<ReplicaGroupFilterPtr> +vector<shared_ptr<ReplicaGroupFilter>> RegistryPluginFacadeI::getReplicaGroupFilters(const string& id) const { - Lock sync(*this); - map<string, vector<ReplicaGroupFilterPtr> >::const_iterator p = _replicaGroupFilters.find(id); + lock_guard lock(_mutex); + map<string, vector<shared_ptr<ReplicaGroupFilter>> >::const_iterator p = _replicaGroupFilters.find(id); if(p != _replicaGroupFilters.end()) { return p->second; } - return vector<ReplicaGroupFilterPtr>(); + return vector<shared_ptr<ReplicaGroupFilter>>(); } bool @@ -281,16 +277,16 @@ RegistryPluginFacadeI::hasReplicaGroupFilters() const return !_replicaGroupFilters.empty(); } -vector<TypeFilterPtr> +vector<shared_ptr<TypeFilter>> RegistryPluginFacadeI::getTypeFilters(const string& id) const { - Lock sync(*this); - map<string, vector<TypeFilterPtr> >::const_iterator p = _typeFilters.find(id); + lock_guard lock(_mutex); + map<string, vector<shared_ptr<TypeFilter>> >::const_iterator p = _typeFilters.find(id); if(p != _typeFilters.end()) { return p->second; } - return vector<TypeFilterPtr>(); + return vector<shared_ptr<TypeFilter>>(); } bool @@ -300,8 +296,8 @@ RegistryPluginFacadeI::hasTypeFilters() const } void -RegistryPluginFacadeI::setDatabase(const DatabasePtr& database) +RegistryPluginFacadeI::setDatabase(const shared_ptr<Database>& database) { - Lock sync(*this); + lock_guard lock(_mutex); _database = database; } diff --git a/cpp/src/IceGrid/PluginFacadeI.h b/cpp/src/IceGrid/PluginFacadeI.h index 3972eee6b11..2f9ee7624a6 100644 --- a/cpp/src/IceGrid/PluginFacadeI.h +++ b/cpp/src/IceGrid/PluginFacadeI.h @@ -5,60 +5,55 @@ #ifndef ICEGRID_PLUGIN_FACADE_I_H #define ICEGRID_PLUGIN_FACADE_I_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Handle.h> - #include <IceGrid/PluginFacade.h> namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; -class RegistryPluginFacadeI : public RegistryPluginFacade, private IceUtil::Mutex +class RegistryPluginFacadeI : public RegistryPluginFacade { public: - RegistryPluginFacadeI(); - - virtual ApplicationInfo getApplicationInfo(const ::std::string&) const; + ApplicationInfo getApplicationInfo(const ::std::string&) const override; - virtual ServerInfo getServerInfo(const std::string&) const; + ServerInfo getServerInfo(const std::string&) const override; - virtual std::string getAdapterServer(const std::string&) const; - virtual std::string getAdapterApplication(const std::string&) const; - virtual std::string getAdapterNode(const std::string&) const; - virtual AdapterInfoSeq getAdapterInfo(const ::std::string&) const; + std::string getAdapterServer(const std::string&) const override; + std::string getAdapterApplication(const std::string&) const override; + std::string getAdapterNode(const std::string&) const override; + AdapterInfoSeq getAdapterInfo(const ::std::string&) const override; - virtual ObjectInfo getObjectInfo(const Ice::Identity&) const; + ObjectInfo getObjectInfo(const Ice::Identity&) const override; - virtual NodeInfo getNodeInfo(const std::string&) const; - virtual LoadInfo getNodeLoad(const std::string&) const; + NodeInfo getNodeInfo(const std::string&) const override; + LoadInfo getNodeLoad(const std::string&) const override; - virtual std::string getPropertyForAdapter(const std::string&, const std::string&) const; + std::string getPropertyForAdapter(const std::string&, const std::string&) const override; - virtual void addReplicaGroupFilter(const std::string&, const ReplicaGroupFilterPtr&) ICE_NOEXCEPT; - virtual bool removeReplicaGroupFilter(const std::string&, const ReplicaGroupFilterPtr&) ICE_NOEXCEPT; + void addReplicaGroupFilter(const std::string&, const std::shared_ptr<ReplicaGroupFilter>&) noexcept override; + bool removeReplicaGroupFilter(const std::string&, const std::shared_ptr<ReplicaGroupFilter>&) noexcept override; - virtual void addTypeFilter(const std::string&, const TypeFilterPtr&) ICE_NOEXCEPT; - virtual bool removeTypeFilter(const std::string&, const TypeFilterPtr&) ICE_NOEXCEPT; + void addTypeFilter(const std::string&, const std::shared_ptr<TypeFilter>&) noexcept override; + bool removeTypeFilter(const std::string&, const std::shared_ptr<TypeFilter>&) noexcept override; - std::vector<ReplicaGroupFilterPtr> getReplicaGroupFilters(const std::string&) const; + std::vector<std::shared_ptr<ReplicaGroupFilter>> getReplicaGroupFilters(const std::string&) const; bool hasReplicaGroupFilters() const; - std::vector<TypeFilterPtr> getTypeFilters(const std::string&) const; + std::vector<std::shared_ptr<TypeFilter>> getTypeFilters(const std::string&) const; bool hasTypeFilters() const; - void setDatabase(const DatabasePtr&); + void setDatabase(const std::shared_ptr<Database>&); private: - DatabasePtr _database; - std::map<std::string, std::vector<ReplicaGroupFilterPtr> > _replicaGroupFilters; - std::map<std::string, std::vector<TypeFilterPtr> > _typeFilters; + std::shared_ptr<Database> _database; + std::map<std::string, std::vector<std::shared_ptr<ReplicaGroupFilter>> > _replicaGroupFilters; + std::map<std::string, std::vector<std::shared_ptr<TypeFilter>> > _typeFilters; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<RegistryPluginFacadeI> RegistryPluginFacadeIPtr; } diff --git a/cpp/src/IceGrid/QueryI.cpp b/cpp/src/IceGrid/QueryI.cpp index e6f5b1ee090..3e47319dff3 100644 --- a/cpp/src/IceGrid/QueryI.cpp +++ b/cpp/src/IceGrid/QueryI.cpp @@ -10,18 +10,14 @@ using namespace std; using namespace Ice; using namespace IceGrid; -QueryI::QueryI(const CommunicatorPtr& communicator, const DatabasePtr& database) : +QueryI::QueryI(const shared_ptr<Communicator>& communicator, const shared_ptr<Database>& database) : _communicator(communicator), _database(database) { } -QueryI::~QueryI() -{ -} - -Ice::ObjectPrx -QueryI::findObjectById(const Ice::Identity& id, const Ice::Current&) const +shared_ptr<Ice::ObjectPrx> +QueryI::findObjectById(Ice::Identity id, const Ice::Current&) const { try { @@ -29,30 +25,30 @@ QueryI::findObjectById(const Ice::Identity& id, const Ice::Current&) const } catch(const ObjectNotRegisteredException&) { - return 0; + return nullptr; } } -Ice::ObjectPrx -QueryI::findObjectByType(const string& type, const Ice::Current& current) const +shared_ptr<Ice::ObjectPrx> +QueryI::findObjectByType(string type, const Ice::Current& current) const { - return _database->getObjectByType(type, current.con, current.ctx); + return _database->getObjectByType(move(type), current.con, current.ctx); } -Ice::ObjectPrx -QueryI::findObjectByTypeOnLeastLoadedNode(const string& type, LoadSample sample, const Ice::Current& current) const +shared_ptr<Ice::ObjectPrx> +QueryI::findObjectByTypeOnLeastLoadedNode(string type, LoadSample sample, const Ice::Current& current) const { - return _database->getObjectByTypeOnLeastLoadedNode(type, sample, current.con, current.ctx); + return _database->getObjectByTypeOnLeastLoadedNode(move(type), move(sample), current.con, current.ctx); } Ice::ObjectProxySeq -QueryI::findAllObjectsByType(const string& type, const Ice::Current& current) const +QueryI::findAllObjectsByType(string type, const Ice::Current& current) const { - return _database->getObjectsByType(type, current.con, current.ctx); + return _database->getObjectsByType(move(type), current.con, current.ctx); } Ice::ObjectProxySeq -QueryI::findAllReplicas(const Ice::ObjectPrx& proxy, const Ice::Current& current) const +QueryI::findAllReplicas(shared_ptr<Ice::ObjectPrx> proxy, const Ice::Current& current) const { if(!proxy) { @@ -64,13 +60,12 @@ QueryI::findAllReplicas(const Ice::ObjectPrx& proxy, const Ice::Current& current // well-known object. If it's a well-known object we use the // registered proxy instead. // - Ice::ObjectPrx prx = proxy; - if(prx->ice_getAdapterId().empty()) + if(proxy->ice_getAdapterId().empty()) { try { - ObjectInfo info = _database->getObjectInfo(prx->ice_getIdentity()); - prx = info.proxy; + ObjectInfo info = _database->getObjectInfo(proxy->ice_getIdentity()); + proxy = info.proxy; } catch(const ObjectNotRegisteredException&) { @@ -80,18 +75,18 @@ QueryI::findAllReplicas(const Ice::ObjectPrx& proxy, const Ice::Current& current try { - AdapterInfoSeq infos = _database->getFilteredAdapterInfo(prx->ice_getAdapterId(), current.con, current.ctx); - if(infos.empty() || infos[0].replicaGroupId != prx->ice_getAdapterId()) + AdapterInfoSeq infos = _database->getFilteredAdapterInfo(proxy->ice_getAdapterId(), current.con, current.ctx); + if(infos.empty() || infos[0].replicaGroupId != proxy->ice_getAdapterId()) { // The adapter id doesn't refer to a replica group or the replica group is empty. return Ice::ObjectProxySeq(); } Ice::ObjectProxySeq proxies; - for(AdapterInfoSeq::const_iterator p = infos.begin(); p != infos.end(); ++p) + for(const auto& info : infos) { - assert(!p->id.empty()); - proxies.push_back(prx->ice_adapterId(p->id)); + assert(!info.id.empty()); + proxies.push_back(proxy->ice_adapterId(info.id)); } return proxies; } diff --git a/cpp/src/IceGrid/QueryI.h b/cpp/src/IceGrid/QueryI.h index d9f9dec92c2..9fed187cc11 100644 --- a/cpp/src/IceGrid/QueryI.h +++ b/cpp/src/IceGrid/QueryI.h @@ -12,30 +12,28 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; -class QueryI : public Query, public IceUtil::Mutex +class QueryI final : public Query { public: - QueryI(const Ice::CommunicatorPtr&, const DatabasePtr&); - virtual ~QueryI(); + QueryI(const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<Database>&); - virtual Ice::ObjectPrx findObjectById(const ::Ice::Identity&, const ::Ice::Current&) const; + std::shared_ptr<Ice::ObjectPrx> findObjectById(Ice::Identity, const Ice::Current&) const override; - virtual Ice::ObjectPrx findObjectByType(const ::std::string&, const ::Ice::Current&) const; + std::shared_ptr<Ice::ObjectPrx> findObjectByType(std::string, const Ice::Current&) const override; - virtual Ice::ObjectPrx findObjectByTypeOnLeastLoadedNode(const ::std::string&, LoadSample, - const ::Ice::Current&) const; + std::shared_ptr<Ice::ObjectPrx> findObjectByTypeOnLeastLoadedNode(std::string, LoadSample, + const Ice::Current&) const override; - virtual Ice::ObjectProxySeq findAllObjectsByType(const ::std::string&, const ::Ice::Current&) const; + Ice::ObjectProxySeq findAllObjectsByType(std::string, const Ice::Current&) const override; - virtual Ice::ObjectProxySeq findAllReplicas(const Ice::ObjectPrx&, const Ice::Current&) const; + Ice::ObjectProxySeq findAllReplicas(std::shared_ptr<Ice::ObjectPrx>, const Ice::Current&) const override; private: - const Ice::CommunicatorPtr _communicator; - const DatabasePtr _database; + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<Database> _database; }; } diff --git a/cpp/src/IceGrid/ReapThread.cpp b/cpp/src/IceGrid/ReapThread.cpp index 54626b1cdbf..649c5092795 100644 --- a/cpp/src/IceGrid/ReapThread.cpp +++ b/cpp/src/IceGrid/ReapThread.cpp @@ -8,54 +8,11 @@ using namespace std; using namespace IceGrid; -namespace -{ - -class CloseCallbackI : public Ice::CloseCallback -{ -public: - - CloseCallbackI(const ReapThreadPtr& reaper) : _reaper(reaper) - { - } - - virtual void - closed(const Ice::ConnectionPtr& con) - { - _reaper->connectionClosed(con); - } - -private: - - const ReapThreadPtr _reaper; -}; - -class HeartbeatCallbackI : public Ice::HeartbeatCallback -{ -public: - - HeartbeatCallbackI(const ReapThreadPtr& reaper) : _reaper(reaper) - { - } - - virtual void - heartbeat(const Ice::ConnectionPtr& con) - { - _reaper->connectionHeartbeat(con); - } - -private: - - const ReapThreadPtr _reaper; -}; - -} - ReapThread::ReapThread() : - IceUtil::Thread("Icegrid reaper thread"), - _closeCallback(new CloseCallbackI(this)), - _heartbeatCallback(new HeartbeatCallbackI(this)), - _terminated(false) + _closeCallback([this](const auto& con) { connectionClosed(con); }), + _heartbeatCallback([this](const auto& con) { connectionHeartbeat(con); }), + _terminated(false), + _thread([this] { run(); }) { } @@ -66,7 +23,7 @@ ReapThread::run() while(true) { { - Lock sync(*this); + unique_lock lock(_mutex); if(_terminated) { break; @@ -77,13 +34,13 @@ ReapThread::run() // // If the wake interval is zero then we wait forever. // - if(_wakeInterval == IceUtil::Time()) + if(_wakeInterval == 0s) { - wait(); + _condVar.wait(lock); } else { - timedWait(_wakeInterval); + _condVar.wait_for(lock, _wakeInterval); } if(_terminated) @@ -91,18 +48,18 @@ ReapThread::run() break; } - list<ReapableItem>::iterator p = _sessions.begin(); + auto p = _sessions.begin(); while(p != _sessions.end()) { try { - if(p->timeout == IceUtil::Time()) + if(p->timeout == 0s) { p->item->timestamp(); // This should throw if the reapable is destroyed. ++p; continue; } - else if((IceUtil::Time::now(IceUtil::Time::Monotonic) - p->item->timestamp()) > p->timeout) + else if((chrono::steady_clock::now() - p->item->timestamp()) > p->timeout) { reap.push_back(*p); } @@ -121,14 +78,14 @@ ReapThread::run() // if(p->connection) { - map<Ice::ConnectionPtr, set<ReapablePtr> >::iterator q = _connections.find(p->connection); + auto q = _connections.find(p->connection); if(q != _connections.end()) { q->second.erase(p->item); if(q->second.empty()) { - p->connection->setCloseCallback(0); - p->connection->setHeartbeatCallback(0); + p->connection->setCloseCallback(nullptr); + p->connection->setHeartbeatCallback(nullptr); _connections.erase(q); } } @@ -137,9 +94,9 @@ ReapThread::run() } } - for(vector<ReapableItem>::const_iterator p = reap.begin(); p != reap.end(); ++p) + for(const auto& r : reap) { - p->item->destroy(false); + r.item->destroy(false); } reap.clear(); } @@ -150,36 +107,43 @@ ReapThread::terminate() { list<ReapableItem> reap; { - Lock sync(*this); + lock_guard lock(_mutex); if(_terminated) { assert(_sessions.empty()); return; } _terminated = true; - notify(); + _condVar.notify_one(); reap.swap(_sessions); - for(map<Ice::ConnectionPtr, set<ReapablePtr> >::iterator p = _connections.begin(); p != _connections.end(); ++p) + for(const auto& conn : _connections) { - p->first->setCloseCallback(0); - p->first->setHeartbeatCallback(0); + conn.first->setCloseCallback(nullptr); + conn.first->setHeartbeatCallback(nullptr); } _connections.clear(); - _closeCallback = 0; - _heartbeatCallback = 0; + _closeCallback = nullptr; + _heartbeatCallback = nullptr; } - for(list<ReapableItem>::iterator p = reap.begin(); p != reap.end(); ++p) + for(const auto& r : reap) { - p->item->destroy(true); + r.item->destroy(true); } } void -ReapThread::add(const ReapablePtr& reapable, int timeout, const Ice::ConnectionPtr& connection) +ReapThread::join() { - Lock sync(*this); + _thread.join(); +} + +void +ReapThread::add(const shared_ptr<Reapable>& reapable, chrono::seconds timeout, + const shared_ptr<Ice::Connection>& connection) +{ + lock_guard lock(_mutex); if(_terminated) { return; @@ -193,31 +157,26 @@ ReapThread::add(const ReapablePtr& reapable, int timeout, const Ice::ConnectionP // // 10 seconds is the minimum permissable timeout. // - if(timeout > 0 && timeout < 10) + if(timeout > 0s && timeout < 10s) { - timeout = 10; + timeout = 10s; } - ReapableItem item; - item.item = reapable; - item.connection = connection; - item.timeout = timeout == 0 ? IceUtil::Time() : IceUtil::Time::seconds(timeout); - _sessions.push_back(item); + _sessions.push_back({ reapable, connection, timeout }); if(connection) { - map<Ice::ConnectionPtr, set<ReapablePtr> >::iterator p = _connections.find(connection); + auto p = _connections.find(connection); if(p == _connections.end()) { - p = _connections.insert(make_pair(connection, set<ReapablePtr>())).first; + p = _connections.insert({connection, {} }).first; connection->setCloseCallback(_closeCallback); connection->setHeartbeatCallback(_heartbeatCallback); - } p->second.insert(reapable); } - if(timeout > 0) + if(timeout > 0s) { // // If there is a new minimum wake interval then wake the reaping @@ -225,50 +184,52 @@ ReapThread::add(const ReapablePtr& reapable, int timeout, const Ice::ConnectionP // if(calcWakeInterval()) { - notify(); + _condVar.notify_one(); } // // Since we just added a new session with a non null timeout there // must be a non-zero wakeInterval. // - assert(_wakeInterval != IceUtil::Time()); + assert(_wakeInterval != 0s); } } void -ReapThread::connectionHeartbeat(const Ice::ConnectionPtr& con) +ReapThread::connectionHeartbeat(const shared_ptr<Ice::Connection>& con) { - Lock sync(*this); - map<Ice::ConnectionPtr, set<ReapablePtr> >::const_iterator p = _connections.find(con); + lock_guard lock(_mutex); + + auto p = _connections.find(con); if(p == _connections.end()) { - con->setCloseCallback(0); - con->setHeartbeatCallback(0); + con->setCloseCallback(nullptr); + con->setHeartbeatCallback(nullptr); return; } - for(set<ReapablePtr>::const_iterator q = p->second.begin(); q != p->second.end(); ++q) + for(const auto& reapable : p->second) { - (*q)->heartbeat(); + reapable->heartbeat(); } } void -ReapThread::connectionClosed(const Ice::ConnectionPtr& con) +ReapThread::connectionClosed(const shared_ptr<Ice::Connection>& con) { - Lock sync(*this); - map<Ice::ConnectionPtr, set<ReapablePtr> >::iterator p = _connections.find(con); + lock_guard lock(_mutex); + + auto p = _connections.find(con); if(p == _connections.end()) { - con->setCloseCallback(0); - con->setHeartbeatCallback(0); + con->setCloseCallback(nullptr); + con->setHeartbeatCallback(nullptr); return; } - for(set<ReapablePtr>::const_iterator q = p->second.begin(); q != p->second.end(); ++q) + for(const auto& reapable : p->second) { - (*q)->destroy(false); + reapable->destroy(false); } _connections.erase(p); } @@ -281,18 +242,18 @@ bool ReapThread::calcWakeInterval() { // Re-calculate minimum timeout - IceUtil::Time oldWakeInterval = _wakeInterval; - IceUtil::Time minimum; + auto oldWakeInterval = _wakeInterval; + chrono::milliseconds minimum = 0s; bool first = true; - for(list<ReapableItem>::const_iterator p = _sessions.begin(); p != _sessions.end(); ++p) + for(const auto& session : _sessions) { - if(p->timeout != IceUtil::Time() && (first || p->timeout < minimum)) + if(session.timeout != 0s && (first || session.timeout < minimum)) { - minimum = p->timeout; + minimum = session.timeout; first = false; } } _wakeInterval = minimum; - return oldWakeInterval == IceUtil::Time() || minimum < oldWakeInterval; + return oldWakeInterval == 0s || minimum < oldWakeInterval; } diff --git a/cpp/src/IceGrid/ReapThread.h b/cpp/src/IceGrid/ReapThread.h index a847b9e720f..99afaa8f56f 100644 --- a/cpp/src/IceGrid/ReapThread.h +++ b/cpp/src/IceGrid/ReapThread.h @@ -5,10 +5,6 @@ #ifndef ICEGRID_REAPER_THREAD_H #define ICEGRID_REAPER_THREAD_H -#include <IceUtil/Thread.h> -#include <IceUtil/Mutex.h> -#include <IceUtil/Monitor.h> - #include <Ice/Logger.h> #include <Ice/LocalException.h> #include <Ice/LoggerUtil.h> @@ -19,44 +15,37 @@ namespace IceGrid { -class Reapable : public Ice::LocalObject +class Reapable { public: - virtual ~Reapable() { } + virtual ~Reapable() = default; virtual void heartbeat() const { }; - virtual IceUtil::Time timestamp() const = 0; + virtual std::chrono::steady_clock::time_point timestamp() const = 0; virtual void destroy(bool) = 0; }; -typedef IceUtil::Handle<Reapable> ReapablePtr; template<class T> class SessionReapable : public Reapable { - typedef IceUtil::Handle<T> TPtr; - public: - SessionReapable(const Ice::LoggerPtr& logger, const TPtr& session) : + SessionReapable(const std::shared_ptr<Ice::Logger>& logger, const std::shared_ptr<T>& session) : _logger(logger), _session(session) { } - virtual ~SessionReapable() - { - } - - virtual IceUtil::Time - timestamp() const + std::chrono::steady_clock::time_point + timestamp() const override { return _session->timestamp(); } - virtual void - destroy(bool shutdown) + void + destroy(bool shutdown) override { try { @@ -81,24 +70,22 @@ public: protected: - const Ice::LoggerPtr _logger; - const TPtr _session; + const std::shared_ptr<Ice::Logger> _logger; + const std::shared_ptr<T> _session; }; template<class T> -class SessionReapableWithHeartbeat : public SessionReapable<T> +class SessionReapableWithHeartbeat final : public SessionReapable<T> { - typedef IceUtil::Handle<T> TPtr; - public: - SessionReapableWithHeartbeat(const Ice::LoggerPtr& logger, const TPtr& session) : + SessionReapableWithHeartbeat(const std::shared_ptr<Ice::Logger>& logger, const std::shared_ptr<T>& session) : SessionReapable<T>(logger, session) { } - virtual void - heartbeat() const + void + heartbeat() const override { try { @@ -110,39 +97,44 @@ public: } }; -class ReapThread : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex> +class ReapThread final { public: ReapThread(); - virtual void run(); void terminate(); - void add(const ReapablePtr&, int, const Ice::ConnectionPtr& = Ice::ConnectionPtr()); + void join(); + void add(const std::shared_ptr<Reapable>&, std::chrono::seconds, const std::shared_ptr<Ice::Connection>& = nullptr); - void connectionHeartbeat(const Ice::ConnectionPtr&); - void connectionClosed(const Ice::ConnectionPtr&); + void connectionHeartbeat(const std::shared_ptr<Ice::Connection>&); + void connectionClosed(const std::shared_ptr<Ice::Connection>&); private: + void run(); + bool calcWakeInterval(); - Ice::CloseCallbackPtr _closeCallback; - Ice::HeartbeatCallbackPtr _heartbeatCallback; - IceUtil::Time _wakeInterval; + Ice::CloseCallback _closeCallback; + Ice::HeartbeatCallback _heartbeatCallback; + std::chrono::milliseconds _wakeInterval; bool _terminated; struct ReapableItem { - ReapablePtr item; - Ice::ConnectionPtr connection; - IceUtil::Time timeout; + std::shared_ptr<Reapable> item; + std::shared_ptr<Ice::Connection> connection; + std::chrono::milliseconds timeout; }; std::list<ReapableItem> _sessions; - std::map<Ice::ConnectionPtr, std::set<ReapablePtr> > _connections; -}; -typedef IceUtil::Handle<ReapThread> ReapThreadPtr; + std::map<std::shared_ptr<Ice::Connection>, std::set<std::shared_ptr<Reapable>> > _connections; + std::mutex _mutex; + std::condition_variable _condVar; + std::thread _thread; }; +} + #endif diff --git a/cpp/src/IceGrid/RegistryAdminRouter.cpp b/cpp/src/IceGrid/RegistryAdminRouter.cpp index cb88ed843e8..71184b0cbb9 100644 --- a/cpp/src/IceGrid/RegistryAdminRouter.cpp +++ b/cpp/src/IceGrid/RegistryAdminRouter.cpp @@ -3,6 +3,7 @@ // #include <IceGrid/RegistryAdminRouter.h> +#include <IceGrid/Internal.h> #include <Ice/Ice.h> using namespace IceGrid; @@ -12,15 +13,20 @@ using namespace std; namespace { -class SynchronizationCallbackI : public SynchronizationCallback +class SynchronizationCallbackI final : public SynchronizationCallback { public: - SynchronizationCallbackI(const IceUtil::Handle<RegistryServerAdminRouter>& adminRouter, - const AMD_Object_ice_invokePtr& cb, + SynchronizationCallbackI(const shared_ptr<RegistryServerAdminRouter>& adminRouter, const pair<const Byte*, const Byte*>& inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, const Current& current) : - _adminRouter(adminRouter), _callback(cb), _inParams(inParams.first, inParams.second), _current(current) + _adminRouter(adminRouter), + _response(move(response)), + _exception(move(exception)), + _inParams(inParams.first, inParams.second), + _current(current) { } @@ -29,47 +35,51 @@ public: // // Retry to forward the call. // - _adminRouter->ice_invoke_async(_callback, make_pair(&_inParams[0], &_inParams[0] + _inParams.size()), _current); + _adminRouter->ice_invokeAsync({ &_inParams[0], &_inParams[0] + _inParams.size() }, + move(_response), move(_exception), _current); } - void synchronized(const Ice::Exception&) + void synchronized(exception_ptr) { - _callback->ice_exception(Ice::ObjectNotExistException(__FILE__, __LINE__)); + _exception(make_exception_ptr(Ice::ObjectNotExistException(__FILE__, __LINE__))); } private: - const IceUtil::Handle<RegistryServerAdminRouter> _adminRouter; - const AMD_Object_ice_invokePtr _callback; + const shared_ptr<RegistryServerAdminRouter> _adminRouter; + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> _response; + function<void(exception_ptr)> _exception; const vector<Byte> _inParams; const Current _current; }; } -IceGrid::RegistryServerAdminRouter::RegistryServerAdminRouter(const DatabasePtr& database) : +RegistryServerAdminRouter::RegistryServerAdminRouter(const shared_ptr<Database>& database) : AdminRouter(database->getTraceLevels()), _database(database) { } void -IceGrid::RegistryServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, - const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams, - const Current& current) +RegistryServerAdminRouter::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) { - ObjectPrx target = 0; + shared_ptr<ObjectPrx> target; try { - ServerEntryPtr server = _database->getServer(current.id.name); + auto server = _database->getServer(current.id.name); try { target = server->getAdminProxy(); } catch(const SynchronizationException&) { - server->addSyncCallback(new SynchronizationCallbackI(this, cb, inParams, current)); + server->addSyncCallback(make_shared<SynchronizationCallbackI>(shared_from_this(), inParams, + move(response), move(exception), current)); return; // Wait for the server synchronization to complete and retry. } } @@ -83,17 +93,17 @@ IceGrid::RegistryServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invoke { } - if(target == 0) + if(target == nullptr) { throw ObjectNotExistException(__FILE__, __LINE__); } target = target->ice_facet(current.facet); - invokeOnTarget(target, cb, inParams, current); + invokeOnTarget(target, inParams, move(response), move(exception), current); } -IceGrid::RegistryNodeAdminRouter::RegistryNodeAdminRouter(const string& collocNodeName, const DatabasePtr& database) : +RegistryNodeAdminRouter::RegistryNodeAdminRouter(const string& collocNodeName, const shared_ptr<Database>& database) : AdminRouter(database->getTraceLevels()), _collocNodeName(collocNodeName), _database(database) @@ -101,11 +111,12 @@ IceGrid::RegistryNodeAdminRouter::RegistryNodeAdminRouter(const string& collocNo } void -IceGrid::RegistryNodeAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, - const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams, - const Current& current) +RegistryNodeAdminRouter::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) { - ObjectPrx target; + shared_ptr<ObjectPrx> target; if(!_collocNodeName.empty() && current.id.name == _collocNodeName) { @@ -139,11 +150,11 @@ IceGrid::RegistryNodeAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePt target = target->ice_facet(current.facet); - invokeOnTarget(target, cb, inParams, current); + invokeOnTarget(target, inParams, move(response), move(exception), current); } -IceGrid::RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& name, - const DatabasePtr& database) : +RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& name, + const shared_ptr<Database>& database) : AdminRouter(database->getTraceLevels()), _name(name), _database(database) @@ -151,11 +162,12 @@ IceGrid::RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& na } void -IceGrid::RegistryReplicaAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, - const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams, - const Current& current) +RegistryReplicaAdminRouter::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams, + function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> response, + function<void(exception_ptr)> exception, + const Ice::Current& current) { - ObjectPrx target; + shared_ptr<ObjectPrx> target; if(current.id.name == _name) { @@ -174,7 +186,7 @@ IceGrid::RegistryReplicaAdminRouter::ice_invoke_async(const AMD_Object_ice_invok } } - if(target == 0) + if(target == nullptr) { if(_traceLevels->admin > 0) { @@ -187,5 +199,5 @@ IceGrid::RegistryReplicaAdminRouter::ice_invoke_async(const AMD_Object_ice_invok target = target->ice_facet(current.facet); - invokeOnTarget(target, cb, inParams, current); + invokeOnTarget(target, inParams, move(response), move(exception), current); } diff --git a/cpp/src/IceGrid/RegistryAdminRouter.h b/cpp/src/IceGrid/RegistryAdminRouter.h index 8deb750fd86..3e214c21cee 100644 --- a/cpp/src/IceGrid/RegistryAdminRouter.h +++ b/cpp/src/IceGrid/RegistryAdminRouter.h @@ -11,51 +11,55 @@ namespace IceGrid { -class RegistryServerAdminRouter : public AdminRouter +class RegistryServerAdminRouter final : public AdminRouter, + public std::enable_shared_from_this<RegistryServerAdminRouter> { public: - RegistryServerAdminRouter(const DatabasePtr&); + RegistryServerAdminRouter(const std::shared_ptr<Database>&); - virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, - const std::pair<const Ice::Byte*, const Ice::Byte*>&, - const Ice::Current&); + void ice_invokeAsync(std::pair<const Ice::Byte*, const Ice::Byte*>, + std::function<void(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current& current) override; private: - const DatabasePtr _database; + const std::shared_ptr<Database> _database; }; -class RegistryNodeAdminRouter : public AdminRouter +class RegistryNodeAdminRouter final : public AdminRouter { public: - RegistryNodeAdminRouter(const std::string&, const DatabasePtr&); + RegistryNodeAdminRouter(const std::string&, const std::shared_ptr<Database>&); - virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, - const std::pair<const Ice::Byte*, const Ice::Byte*>&, - const Ice::Current&); + void ice_invokeAsync(std::pair<const Ice::Byte*, const Ice::Byte*>, + std::function<void(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current& current) override; private: const std::string _collocNodeName; - const DatabasePtr _database; + const std::shared_ptr<Database> _database; }; -class RegistryReplicaAdminRouter : public AdminRouter +class RegistryReplicaAdminRouter final : public AdminRouter { public: - RegistryReplicaAdminRouter(const std::string&, const DatabasePtr&); + RegistryReplicaAdminRouter(const std::string&, const std::shared_ptr<Database>&); - virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, - const std::pair<const Ice::Byte*, const Ice::Byte*>&, - const Ice::Current&); + void ice_invokeAsync(std::pair<const Ice::Byte*, const Ice::Byte*>, + std::function<void(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current& current) override; private: const std::string _name; - const DatabasePtr _database; + const std::shared_ptr<Database> _database; }; } diff --git a/cpp/src/IceGrid/RegistryI.cpp b/cpp/src/IceGrid/RegistryI.cpp index 092ac2bf322..df387dbd09a 100644 --- a/cpp/src/IceGrid/RegistryI.cpp +++ b/cpp/src/IceGrid/RegistryI.cpp @@ -44,19 +44,20 @@ using namespace IceGrid; namespace { -class LookupI : public IceLocatorDiscovery::Lookup +class LookupI final : public IceLocatorDiscovery::Lookup { public: - LookupI(const std::string& instanceName, - const WellKnownObjectsManagerPtr& wellKnownObjects, - const TraceLevelsPtr& traceLevels) : + LookupI(const string& instanceName, + const shared_ptr<WellKnownObjectsManager>& wellKnownObjects, + const shared_ptr<TraceLevels>& traceLevels) : _instanceName(instanceName), _wellKnownObjects(wellKnownObjects), _traceLevels(traceLevels) { } - virtual void - findLocator(const string& instanceName, const IceLocatorDiscovery::LookupReplyPrx& reply, const Ice::Current&) + void + findLocator(string instanceName, shared_ptr<IceLocatorDiscovery::LookupReplyPrx> reply, + const Ice::Current&) override { if(!instanceName.empty() && instanceName != _instanceName) { @@ -75,11 +76,11 @@ public: Trace out(_traceLevels->logger, _traceLevels->discoveryCat); out << "replying to discovery lookup:\nreply = " << reply; } - reply->begin_foundLocator(_wellKnownObjects->getLocator()); + reply->foundLocatorAsync(_wellKnownObjects->getLocator()); } } - virtual Ice::LocatorPrx + shared_ptr<Ice::LocatorPrx> getLocator(const Ice::Current&) { return _wellKnownObjects->getLocator(); @@ -88,59 +89,59 @@ public: private: const string _instanceName; - const WellKnownObjectsManagerPtr _wellKnownObjects; - const TraceLevelsPtr _traceLevels; + const shared_ptr<WellKnownObjectsManager> _wellKnownObjects; + const shared_ptr<TraceLevels> _traceLevels; }; -class FinderI : public Ice::LocatorFinder +class FinderI final : public Ice::LocatorFinder { public: - FinderI(const WellKnownObjectsManagerPtr& wellKnownObjects) : _wellKnownObjects(wellKnownObjects) + FinderI(const shared_ptr<WellKnownObjectsManager>& wellKnownObjects) : _wellKnownObjects(wellKnownObjects) { } - virtual Ice::LocatorPrx - getLocator(const Ice::Current&) + shared_ptr<Ice::LocatorPrx> + getLocator(const Ice::Current&) override { return _wellKnownObjects->getLocator(); } private: - const WellKnownObjectsManagerPtr _wellKnownObjects; + const shared_ptr<WellKnownObjectsManager> _wellKnownObjects; }; -class ProcessI : public Process +class ProcessI final : public Process { public: - ProcessI(const RegistryIPtr&, const ProcessPtr&); + ProcessI(const shared_ptr<RegistryI>&, const shared_ptr<Process>&); - virtual void shutdown(const Current&); - virtual void writeMessage(const std::string&, Int, const Current&); + void shutdown(const Current&) override; + void writeMessage(string, int, const Current&) override; private: - RegistryIPtr _registry; - ProcessPtr _origProcess; + shared_ptr<RegistryI> _registry; + shared_ptr<Process> _origProcess; }; -Ice::IPConnectionInfoPtr -getIPConnectionInfo(const Ice::ConnectionInfoPtr& info) +shared_ptr<IPConnectionInfo> +getIPConnectionInfo(const shared_ptr<ConnectionInfo>& info) { - for(Ice::ConnectionInfoPtr p = info; p; p = p->underlying) + for(auto p = info; p; p = p->underlying) { - Ice::IPConnectionInfoPtr ipInfo = Ice::IPConnectionInfoPtr::dynamicCast(p); + auto ipInfo = dynamic_pointer_cast<IPConnectionInfo>(p); if(ipInfo) { return ipInfo; } } - return ICE_NULLPTR; + return nullptr; } -ProcessI::ProcessI(const RegistryIPtr& registry, const ProcessPtr& origProcess) : +ProcessI::ProcessI(const shared_ptr<RegistryI>& registry, const shared_ptr<Process>& origProcess) : _registry(registry), _origProcess(origProcess) { @@ -153,15 +154,15 @@ ProcessI::shutdown(const Current&) } void -ProcessI::writeMessage(const string& message, Int fd, const Current& current) +ProcessI::writeMessage(string message, int fd, const Current& current) { - _origProcess->writeMessage(message, fd, current); + _origProcess->writeMessage(move(message), move(fd), current); } } -RegistryI::RegistryI(const CommunicatorPtr& communicator, - const TraceLevelsPtr& traceLevels, +RegistryI::RegistryI(const shared_ptr<Communicator>& communicator, + const shared_ptr<TraceLevels>& traceLevels, bool nowarn, bool readonly, const string& initFromReplica, @@ -176,10 +177,6 @@ RegistryI::RegistryI(const CommunicatorPtr& communicator, { } -RegistryI::~RegistryI() -{ -} - bool RegistryI::start() { @@ -203,7 +200,7 @@ bool RegistryI::startImpl() { assert(_communicator); - PropertiesPtr properties = _communicator->getProperties(); + auto properties = _communicator->getProperties(); // // Check that required properties are set and valid. @@ -275,7 +272,7 @@ RegistryI::startImpl() _replicaName = properties->getPropertyWithDefault("IceGrid.Registry.ReplicaName", "Master"); _master = _replicaName == "Master"; - _sessionTimeout = properties->getPropertyAsIntWithDefault("IceGrid.Registry.SessionTimeout", 30); + _sessionTimeout = chrono::seconds(properties->getPropertyAsIntWithDefault("IceGrid.Registry.SessionTimeout", 30)); if(!_initFromReplica.empty() && (_initFromReplica == _replicaName || (_master && _initFromReplica == "Master"))) { @@ -284,11 +281,9 @@ RegistryI::startImpl() return false; } - if(_sessionTimeout > 0 && properties->getProperty("IceGrid.Registry.Client.ACM.Timeout").empty()) + if(_sessionTimeout > 0s && properties->getProperty("IceGrid.Registry.Client.ACM.Timeout").empty()) { - ostringstream os; - os << _sessionTimeout; - properties->setProperty("IceGrid.Registry.Client.ACM.Timeout", os.str()); + properties->setProperty("IceGrid.Registry.Client.ACM.Timeout", to_string(secondsToInt(_sessionTimeout))); } if(properties->getProperty("IceGrid.Registry.Server.ACM.Timeout").empty()) @@ -300,9 +295,7 @@ RegistryI::startImpl() { int nt = properties->getPropertyAsIntWithDefault("IceGrid.Registry.NodeSessionTimeout", 30); int rt = properties->getPropertyAsIntWithDefault("IceGrid.Registry.ReplicaSessionTimeout", 30); - ostringstream os; - os << std::max(nt, rt); - properties->setProperty("IceGrid.Registry.Internal.ACM.Timeout", os.str()); + properties->setProperty("IceGrid.Registry.Internal.ACM.Timeout", to_string(max(nt, rt))); } properties->setProperty("Ice.ACM.Server.Close", "3"); // Close on invocation and idle. @@ -315,7 +308,7 @@ RegistryI::startImpl() } else if(_master) { - _communicator->setDefaultLocator(0); // Clear the default locator in case it's set. + _communicator->setDefaultLocator(nullptr); // Clear the default locator in case it's set. } // @@ -338,7 +331,7 @@ RegistryI::startImpl() // // Create the replica session manager // - _session.reset(new ReplicaSessionManager(_communicator, _instanceName)); + _session = make_unique<ReplicaSessionManager>(_communicator, _instanceName); // // Create the registry database. @@ -384,8 +377,7 @@ RegistryI::startImpl() // // Create the reaper thread. // - _reaper = new ReapThread(); - _reaper->start(); + _reaper = make_shared<ReapThread>(); // // Create the internal registry object adapter. @@ -405,11 +397,11 @@ RegistryI::startImpl() "IceGrid.Registry", registryTopicManagerId, ""); - const IceStorm::TopicManagerPrx topicManager = _iceStorm->getTopicManager(); + const auto topicManager = _iceStorm->getTopicManager(); try { - _database = new Database(_registryAdapter, topicManager, _instanceName, _traceLevels, getInfo(), _readonly); + _database = Database::create(_registryAdapter, topicManager, _instanceName, _traceLevels, getInfo(), _readonly); } catch(const IceDB::LMDBException& ex) { @@ -418,19 +410,20 @@ RegistryI::startImpl() out << ex; return false; } - _wellKnownObjects = new WellKnownObjectsManager(_database); + _wellKnownObjects = make_shared<WellKnownObjectsManager>(_database); if(!_initFromReplica.empty()) { - Ice::Identity id; + Identity id; id.category = _instanceName; id.name = (_initFromReplica == "Master") ? "Registry" : "Registry-" + _initFromReplica; - Ice::ObjectPrx proxy; + + shared_ptr<ObjectPrx> proxy; try { proxy = _database->getObjectProxy(id); id.name = "Query"; - IceGrid::QueryPrx query = IceGrid::QueryPrx::uncheckedCast(proxy->ice_identity(id)); + auto query = uncheckedCast<IceGrid::QueryPrx>(proxy->ice_identity(id)); if(query) { id.name = "InternalRegistry-" + _initFromReplica; @@ -475,8 +468,8 @@ RegistryI::startImpl() try { - Ice::Long serial; - IceGrid::InternalRegistryPrx registry = IceGrid::InternalRegistryPrx::checkedCast(proxy); + long long serial; + auto registry = checkedCast<IceGrid::InternalRegistryPrx>(proxy); ApplicationInfoSeq applications = registry->getApplications(serial); _database->syncApplications(applications, serial); AdapterInfoSeq adapters = registry->getAdapters(serial); @@ -506,9 +499,9 @@ RegistryI::startImpl() // NodePrxSeq nodes; ObjectProxySeq proxies = _database->getInternalObjectsByType(Node::ice_staticId()); - for(ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) + for(const auto& proxy : proxies) { - nodes.push_back(NodePrx::uncheckedCast(*p)); + nodes.push_back(uncheckedCast<NodePrx>(proxy)); } // @@ -517,7 +510,7 @@ RegistryI::startImpl() // replica/node register as soon as the internal registry is setup // we might clear valid proxies. // - InternalRegistryPrx internalRegistry = setupInternalRegistry(); + auto internalRegistry = setupInternalRegistry(); if(_master) { nodes = registerReplicas(internalRegistry, nodes); @@ -525,7 +518,7 @@ RegistryI::startImpl() } else { - InternalReplicaInfoPtr info = _platform.getInternalReplicaInfo(); + auto info = _platform.getInternalReplicaInfo(); _session->create(_replicaName, info, _database, _wellKnownObjects, internalRegistry); registerNodes(internalRegistry, _session->getNodes(nodes)); } @@ -533,8 +526,7 @@ RegistryI::startImpl() _serverAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Server"); _clientAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Client"); - Ice::Identity dummy; - dummy.name = "dummy"; + Ice::Identity dummy = { "dummy", "" }; _wellKnownObjects->addEndpoint("Client", _clientAdapter->createDirectProxy(dummy)); _wellKnownObjects->addEndpoint("Server", _serverAdapter->createDirectProxy(dummy)); _wellKnownObjects->addEndpoint("Internal", _registryAdapter->createDirectProxy(dummy)); @@ -544,11 +536,11 @@ RegistryI::startImpl() return false; } - QueryPrx query = setupQuery(); - RegistryPrx registry = setupRegistry(); + auto query = setupQuery(); + auto registry = setupRegistry(); setupLocatorRegistry(); - LocatorPrx internalLocator = setupLocator(registry, query); + auto internalLocator = setupLocator(registry, query); // // Create the session servant manager. The session servant manager is responsible @@ -556,16 +548,16 @@ RegistryI::startImpl() // accessed by the connection that created the session. The session servant manager // also takes care of providing router servants for admin objects. // - ObjectPtr serverAdminRouter = new RegistryServerAdminRouter(_database); - ObjectPtr nodeAdminRouter = new RegistryNodeAdminRouter(_collocatedNodeName, _database); - ObjectPtr replicaAdminRouter = new RegistryReplicaAdminRouter(_replicaName, _database); - AdminCallbackRouterPtr adminCallbackRouter = new AdminCallbackRouter; + auto serverAdminRouter = make_shared<RegistryServerAdminRouter>(_database); + auto nodeAdminRouter = make_shared<RegistryNodeAdminRouter>(_collocatedNodeName, _database); + auto replicaAdminRouter = make_shared<RegistryReplicaAdminRouter>(_replicaName, _database); + auto adminCallbackRouter = make_shared<AdminCallbackRouter>(); - _servantManager = new SessionServantManager(_clientAdapter, _instanceName, true, - getServerAdminCategory(), serverAdminRouter, - getNodeAdminCategory(), nodeAdminRouter, - getReplicaAdminCategory(), replicaAdminRouter, - adminCallbackRouter); + _servantManager = make_shared<SessionServantManager>(_clientAdapter, _instanceName, true, + getServerAdminCategory(), serverAdminRouter, + getNodeAdminCategory(), nodeAdminRouter, + getReplicaAdminCategory(), replicaAdminRouter, + adminCallbackRouter); _clientAdapter->addServantLocator(_servantManager, ""); _serverAdapter->addDefaultServant(adminCallbackRouter, ""); @@ -578,9 +570,9 @@ RegistryI::startImpl() Glacier2Internal::setupNullPermissionsVerifier(_communicator, _instanceName, verifierProperties); - ObjectAdapterPtr sessionAdpt = setupClientSessionFactory(internalLocator); - ObjectAdapterPtr admSessionAdpt = setupAdminSessionFactory(serverAdminRouter, nodeAdminRouter, replicaAdminRouter, - internalLocator); + auto sessionAdpt = setupClientSessionFactory(internalLocator); + auto admSessionAdpt = setupAdminSessionFactory(serverAdminRouter, nodeAdminRouter, replicaAdminRouter, + internalLocator); _wellKnownObjects->finish(); if(_master) @@ -595,13 +587,13 @@ RegistryI::startImpl() // // Add the locator finder object to the client adapter. // - _clientAdapter->add(new FinderI(_wellKnownObjects), stringToIdentity("Ice/LocatorFinder")); + _clientAdapter->add(make_shared<FinderI>(_wellKnownObjects), stringToIdentity("Ice/LocatorFinder")); // // Setup the discovery object adapter and also add it the lookup // servant to receive multicast lookup queries. // - Ice::ObjectAdapterPtr discoveryAdapter; + shared_ptr<ObjectAdapter> discoveryAdapter; if(properties->getPropertyAsIntWithDefault("IceGrid.Registry.Discovery.Enabled", 1) > 0) { bool ipv4 = properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0; @@ -630,9 +622,9 @@ RegistryI::startImpl() try { - Ice::Identity lookupId = stringToIdentity("IceLocatorDiscovery/Lookup"); + auto lookupId = stringToIdentity("IceLocatorDiscovery/Lookup"); discoveryAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Discovery"); - discoveryAdapter->add(new LookupI(_instanceName, _wellKnownObjects, _traceLevels), lookupId); + discoveryAdapter->add(make_shared<LookupI>(_instanceName, _wellKnownObjects, _traceLevels), lookupId); } catch(const Ice::LocalException& ex) { @@ -672,16 +664,14 @@ void RegistryI::setupLocatorRegistry() { const bool dynReg = _communicator->getProperties()->getPropertyAsInt("IceGrid.Registry.DynamicRegistration") > 0; - Identity locatorRegId; - locatorRegId.category = _instanceName; - locatorRegId.name = "LocatorRegistry"; - _serverAdapter->add(new LocatorRegistryI(_database, dynReg, _master, *_session), locatorRegId); + Identity locatorRegId = { "LocatorRegistry", _instanceName }; + _serverAdapter->add(make_shared<LocatorRegistryI>(_database, dynReg, _master, *_session), locatorRegId); } -IceGrid::LocatorPrx -RegistryI::setupLocator(const RegistryPrx& registry, const QueryPrx& query) +shared_ptr<IceGrid::LocatorPrx> +RegistryI::setupLocator(const shared_ptr<RegistryPrx>& registry, const shared_ptr<QueryPrx>& query) { - LocatorPtr locator = new LocatorI(_communicator, _database, _wellKnownObjects, registry, query); + auto locator = make_shared<LocatorI>(_communicator, _database, _wellKnownObjects, registry, query); Identity locatorId; locatorId.category = _instanceName; @@ -691,42 +681,41 @@ RegistryI::setupLocator(const RegistryPrx& registry, const QueryPrx& query) locatorId.name = "Locator-" + _replicaName; _clientAdapter->add(locator, locatorId); - return LocatorPrx::uncheckedCast(_registryAdapter->addWithUUID(locator)); + return uncheckedCast<LocatorPrx>(_registryAdapter->addWithUUID(locator)); } -QueryPrx +shared_ptr<QueryPrx> RegistryI::setupQuery() { - Identity queryId; - queryId.category = _instanceName; - queryId.name = "Query"; - return QueryPrx::uncheckedCast(_clientAdapter->add(new QueryI(_communicator, _database), queryId)); + Identity queryId = { "Query", _instanceName }; + return uncheckedCast<QueryPrx>(_clientAdapter->add(make_shared<QueryI>(_communicator, _database), move(queryId))); } -RegistryPrx +shared_ptr<RegistryPrx> RegistryI::setupRegistry() { - Identity registryId; - registryId.category = _instanceName; - registryId.name = "Registry"; + Identity registryId = { "Registry", _instanceName }; if(!_master) { registryId.name += "-" + _replicaName; } - RegistryPrx proxy = RegistryPrx::uncheckedCast(_clientAdapter->add(this, registryId)); + + auto proxy = uncheckedCast<RegistryPrx>(_clientAdapter->add(shared_from_this(), move(registryId))); _wellKnownObjects->add(proxy, Registry::ice_staticId()); return proxy; } -InternalRegistryPrx +shared_ptr<InternalRegistryPrx> RegistryI::setupInternalRegistry() { - Identity internalRegistryId; - internalRegistryId.category = _instanceName; - internalRegistryId.name = "InternalRegistry-" + _replicaName; assert(_reaper); - ObjectPtr internalRegistry = new InternalRegistryI(this, _database, _reaper, _wellKnownObjects, *_session); - Ice::ObjectPrx proxy = _registryAdapter->add(internalRegistry, internalRegistryId); + + Identity internalRegistryId = { "InternalRegistry-" + _replicaName, _instanceName }; + + auto internalRegistry = make_shared<InternalRegistryI>(shared_from_this(), _database, _reaper, _wellKnownObjects, + *_session); + auto proxy = _registryAdapter->add(internalRegistry, internalRegistryId); + _wellKnownObjects->add(proxy, InternalRegistry::ice_staticId()); // @@ -735,16 +724,14 @@ RegistryI::setupInternalRegistry() if(_communicator->getProperties()->getPropertyAsInt("Ice.Admin.Enabled") > 0) { // Replace Admin facet - ProcessPtr origProcess = ProcessPtr::dynamicCast(_communicator->removeAdminFacet("Process")); - _communicator->addAdminFacet(new ProcessI(this, origProcess), "Process"); + auto origProcess = dynamic_pointer_cast<Process>(_communicator->removeAdminFacet("Process")); + _communicator->addAdminFacet(make_shared<ProcessI>(shared_from_this(), origProcess), "Process"); - Identity adminId; - adminId.name = "RegistryAdmin-" + _replicaName; - adminId.category = _instanceName; - _communicator->createAdmin(_registryAdapter, adminId); + Identity adminId = { "RegistryAdmin-" + _replicaName, _instanceName }; + _communicator->createAdmin(_registryAdapter, move(adminId)); } - InternalRegistryPrx registry = InternalRegistryPrx::uncheckedCast(proxy); + auto registry = uncheckedCast<InternalRegistryPrx>(proxy); _database->getReplicaCache().setInternalRegistry(registry); return registry; } @@ -752,7 +739,7 @@ RegistryI::setupInternalRegistry() bool RegistryI::setupUserAccountMapper() { - Ice::PropertiesPtr properties = _communicator->getProperties(); + auto properties = _communicator->getProperties(); // // Setup file user account mapper object if the property is set. @@ -762,17 +749,16 @@ RegistryI::setupUserAccountMapper() { try { - Identity mapperId; - mapperId.category = _instanceName; - mapperId.name = "RegistryUserAccountMapper"; + Identity mapperId = { "RegistryUserAccountMapper", _instanceName }; if(!_master) { mapperId.name += "-" + _replicaName; } - _registryAdapter->add(new FileUserAccountMapperI(userAccountFileProperty), mapperId); + + _registryAdapter->add(make_shared<FileUserAccountMapperI>(userAccountFileProperty), mapperId); _wellKnownObjects->add(_registryAdapter->createProxy(mapperId), UserAccountMapper::ice_staticId()); } - catch(const std::string& msg) + catch(const string& msg) { Error out(_communicator->getLogger()); out << msg; @@ -782,35 +768,32 @@ RegistryI::setupUserAccountMapper() return true; } -Ice::ObjectAdapterPtr -RegistryI::setupClientSessionFactory(const IceGrid::LocatorPrx& locator) +shared_ptr<ObjectAdapter> +RegistryI::setupClientSessionFactory(const shared_ptr<IceGrid::LocatorPrx>& locator) { - Ice::PropertiesPtr properties = _communicator->getProperties(); + auto properties = _communicator->getProperties(); - Ice::ObjectAdapterPtr adapter; - SessionServantManagerPtr servantManager; + shared_ptr<ObjectAdapter> adapter; + shared_ptr<SessionServantManager> servantManager; if(!properties->getProperty("IceGrid.Registry.SessionManager.Endpoints").empty()) { adapter = _communicator->createObjectAdapter("IceGrid.Registry.SessionManager"); - servantManager = new SessionServantManager(adapter, _instanceName, false, "", 0, "", 0, "", 0, 0); + servantManager = make_shared<SessionServantManager>(adapter, _instanceName, false, + "", nullptr, "", nullptr, "", nullptr, nullptr); adapter->addServantLocator(servantManager, ""); } assert(_reaper); - _timer = new IceUtil::Timer(); // Used for session allocation timeout. - _clientSessionFactory = new ClientSessionFactory(servantManager, _database, _timer, _reaper); + _timer = new IceUtil::Timer; // Used for session allocation timeout. + _clientSessionFactory = make_shared<ClientSessionFactory>(servantManager, _database, _timer, _reaper); if(servantManager && _master) // Slaves don't support client session manager objects. { - Identity sessionMgrId; - sessionMgrId.category = _instanceName; - sessionMgrId.name = "SessionManager"; - Identity sslSessionMgrId; - sslSessionMgrId.category = _instanceName; - sslSessionMgrId.name = "SSLSessionManager"; + Identity sessionMgrId = { "SessionManager", _instanceName }; + Identity sslSessionMgrId = { "SSLSessionManager", _instanceName }; - adapter->add(new ClientSessionManagerI(_clientSessionFactory), sessionMgrId); - adapter->add(new ClientSSLSessionManagerI(_clientSessionFactory), sslSessionMgrId); + adapter->add(make_shared<ClientSessionManagerI>(_clientSessionFactory), sessionMgrId); + adapter->add(make_shared<ClientSSLSessionManagerI>(_clientSessionFactory), sslSessionMgrId); _wellKnownObjects->add(adapter->createProxy(sessionMgrId), Glacier2::SessionManager::ice_staticId()); _wellKnownObjects->add(adapter->createProxy(sslSessionMgrId), Glacier2::SSLSessionManager::ice_staticId()); @@ -818,9 +801,8 @@ RegistryI::setupClientSessionFactory(const IceGrid::LocatorPrx& locator) if(adapter) { - Ice::Identity dummy; - dummy.name = "dummy"; - _wellKnownObjects->addEndpoint("SessionManager", adapter->createDirectProxy(dummy)); + Ice::Identity dummy = { "dummy", "" }; + _wellKnownObjects->addEndpoint("SessionManager", adapter->createDirectProxy(move(dummy))); } _clientVerifier = getPermissionsVerifier(locator, "IceGrid.Registry.PermissionsVerifier"); @@ -829,43 +811,41 @@ RegistryI::setupClientSessionFactory(const IceGrid::LocatorPrx& locator) return adapter; } -Ice::ObjectAdapterPtr -RegistryI::setupAdminSessionFactory(const Ice::ObjectPtr& serverAdminRouter, const Ice::ObjectPtr& nodeAdminRouter, - const Ice::ObjectPtr& replicaAdminRouter, const IceGrid::LocatorPrx& locator) +shared_ptr<ObjectAdapter> +RegistryI::setupAdminSessionFactory(const shared_ptr<Object>& serverAdminRouter, + const shared_ptr<Object>& nodeAdminRouter, + const shared_ptr<Object>& replicaAdminRouter, + const shared_ptr<IceGrid::LocatorPrx>& locator) { - Ice::PropertiesPtr properties = _communicator->getProperties(); + auto properties = _communicator->getProperties(); - Ice::ObjectAdapterPtr adapter; - SessionServantManagerPtr servantManager; + shared_ptr<ObjectAdapter> adapter; + shared_ptr<SessionServantManager> servantManager; if(!properties->getProperty("IceGrid.Registry.AdminSessionManager.Endpoints").empty()) { adapter = _communicator->createObjectAdapter("IceGrid.Registry.AdminSessionManager"); - servantManager = new SessionServantManager(adapter, _instanceName, false, + servantManager = make_shared<SessionServantManager>(adapter, _instanceName, false, getServerAdminCategory(), serverAdminRouter, getNodeAdminCategory(), nodeAdminRouter, - getReplicaAdminCategory(), replicaAdminRouter, 0); + getReplicaAdminCategory(), replicaAdminRouter, nullptr); adapter->addServantLocator(servantManager, ""); } assert(_reaper); - _adminSessionFactory = new AdminSessionFactory(servantManager, _database, _reaper, this); + _adminSessionFactory = make_shared<AdminSessionFactory>(servantManager, _database, _reaper, shared_from_this()); if(servantManager) { - Identity sessionMgrId; - sessionMgrId.category = _instanceName; - sessionMgrId.name = "AdminSessionManager"; - Identity sslSessionMgrId; - sslSessionMgrId.category = _instanceName; - sslSessionMgrId.name = "AdminSSLSessionManager"; + Identity sessionMgrId = { "AdminSessionManager", _instanceName }; + Identity sslSessionMgrId = { "AdminSSLSessionManager", _instanceName }; if(!_master) { sessionMgrId.name += "-" + _replicaName; sslSessionMgrId.name += "-" + _replicaName; } - adapter->add(new AdminSessionManagerI(_adminSessionFactory), sessionMgrId); - adapter->add(new AdminSSLSessionManagerI(_adminSessionFactory), sslSessionMgrId); + adapter->add(make_shared<AdminSessionManagerI>(_adminSessionFactory), sessionMgrId); + adapter->add(make_shared<AdminSSLSessionManagerI>(_adminSessionFactory), sslSessionMgrId); _wellKnownObjects->add(adapter->createProxy(sessionMgrId), Glacier2::SessionManager::ice_staticId()); _wellKnownObjects->add(adapter->createProxy(sslSessionMgrId), Glacier2::SSLSessionManager::ice_staticId()); @@ -873,9 +853,8 @@ RegistryI::setupAdminSessionFactory(const Ice::ObjectPtr& serverAdminRouter, con if(adapter) { - Ice::Identity dummy; - dummy.name = "dummy"; - _wellKnownObjects->addEndpoint("AdminSessionManager", adapter->createDirectProxy(dummy)); + Ice::Identity dummy = { "dummy", "" }; + _wellKnownObjects->addEndpoint("AdminSessionManager", adapter->createDirectProxy(move(dummy))); } _adminVerifier = getPermissionsVerifier(locator, "IceGrid.Registry.AdminPermissionsVerifier"); @@ -887,7 +866,7 @@ RegistryI::setupAdminSessionFactory(const Ice::ObjectPtr& serverAdminRouter, con void RegistryI::stop() { - if(_session.get()) + if(_session) { _session->destroy(); } @@ -916,30 +895,30 @@ RegistryI::stop() if(_reaper) { _reaper->terminate(); - _reaper->getThreadControl().join(); - _reaper = 0; + _reaper->join(); + _reaper = nullptr; } if(_timer) { _timer->destroy(); - _timer = 0; + _timer = nullptr; } if(_iceStorm) { _iceStorm->stop(); - _iceStorm = 0; + _iceStorm = nullptr; } - _wellKnownObjects = 0; - _clientSessionFactory = 0; - _adminSessionFactory = 0; - _database = 0; + _wellKnownObjects = nullptr; + _clientSessionFactory = nullptr; + _adminSessionFactory = nullptr; + _database = nullptr; } -SessionPrx -RegistryI::createSession(const string& user, const string& password, const Current& current) +shared_ptr<SessionPrx> +RegistryI::createSession(string user, string password, const Current& current) { if(!_master) { @@ -983,15 +962,15 @@ RegistryI::createSession(const string& user, const string& password, const Curre throw PermissionDeniedException("internal server error"); } - SessionIPtr session = _clientSessionFactory->createSessionServant(user, 0); - Ice::ObjectPrx proxy = session->_register(_servantManager, current.con); - _reaper->add(new SessionReapableWithHeartbeat<SessionI>(_traceLevels->logger, session), _sessionTimeout, + auto session = _clientSessionFactory->createSessionServant(user, nullptr); + auto proxy = session->_register(_servantManager, current.con); + _reaper->add(make_shared<SessionReapableWithHeartbeat<SessionI>>(_traceLevels->logger, session), _sessionTimeout, current.con); - return SessionPrx::uncheckedCast(proxy); + return uncheckedCast<SessionPrx>(proxy); } -AdminSessionPrx -RegistryI::createAdminSession(const string& user, const string& password, const Current& current) +shared_ptr<AdminSessionPrx> +RegistryI::createAdminSession(string user, string password, const Current& current) { assert(_reaper && _adminSessionFactory); @@ -1030,14 +1009,14 @@ RegistryI::createAdminSession(const string& user, const string& password, const throw PermissionDeniedException("internal server error"); } - AdminSessionIPtr session = _adminSessionFactory->createSessionServant(user); - Ice::ObjectPrx proxy = session->_register(_servantManager, current.con); - _reaper->add(new SessionReapableWithHeartbeat<AdminSessionI>(_traceLevels->logger, session), _sessionTimeout, + auto session = _adminSessionFactory->createSessionServant(user); + auto proxy = session->_register(_servantManager, current.con); + _reaper->add(make_shared<SessionReapableWithHeartbeat<AdminSessionI>>(_traceLevels->logger, session), _sessionTimeout, current.con); - return AdminSessionPrx::uncheckedCast(proxy); + return uncheckedCast<AdminSessionPrx>(proxy); } -SessionPrx +shared_ptr<SessionPrx> RegistryI::createSessionFromSecureConnection(const Current& current) { if(!_master) @@ -1084,14 +1063,14 @@ RegistryI::createSessionFromSecureConnection(const Current& current) throw PermissionDeniedException("internal server error"); } - SessionIPtr session = _clientSessionFactory->createSessionServant(userDN, 0); - Ice::ObjectPrx proxy = session->_register(_servantManager, current.con); - _reaper->add(new SessionReapableWithHeartbeat<SessionI>(_traceLevels->logger, session), _sessionTimeout, + auto session = _clientSessionFactory->createSessionServant(userDN, 0); + auto proxy = session->_register(_servantManager, current.con); + _reaper->add(make_shared<SessionReapableWithHeartbeat<SessionI>>(_traceLevels->logger, session), _sessionTimeout, current.con); - return SessionPrx::uncheckedCast(proxy); + return uncheckedCast<SessionPrx>(proxy); } -AdminSessionPrx +shared_ptr<AdminSessionPrx> RegistryI::createAdminSessionFromSecureConnection(const Current& current) { assert(_reaper && _adminSessionFactory); @@ -1131,17 +1110,17 @@ RegistryI::createAdminSessionFromSecureConnection(const Current& current) // // We let the connection access the administrative interface. // - AdminSessionIPtr session = _adminSessionFactory->createSessionServant(userDN); - Ice::ObjectPrx proxy = session->_register(_servantManager, current.con); - _reaper->add(new SessionReapableWithHeartbeat<AdminSessionI>(_traceLevels->logger, session), _sessionTimeout, + auto session = _adminSessionFactory->createSessionServant(userDN); + auto proxy = session->_register(_servantManager, current.con); + _reaper->add(make_shared<SessionReapableWithHeartbeat<AdminSessionI>>(_traceLevels->logger, session), _sessionTimeout, current.con); - return AdminSessionPrx::uncheckedCast(proxy); + return uncheckedCast<AdminSessionPrx>(proxy); } int -RegistryI::getSessionTimeout(const Ice::Current& /*current*/) const +RegistryI::getSessionTimeout(const Ice::Current&) const { - return _sessionTimeout; + return secondsToInt(_sessionTimeout); } int @@ -1176,26 +1155,26 @@ RegistryI::shutdown() _clientAdapter->deactivate(); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> RegistryI::createAdminCallbackProxy(const Identity& id) const { return _serverAdapter->createProxy(id); } -Ice::LocatorPrx +shared_ptr<Ice::LocatorPrx> RegistryI::getLocator() { return _wellKnownObjects->getLocator(); } -Glacier2::PermissionsVerifierPrx -RegistryI::getPermissionsVerifier(const IceGrid::LocatorPrx& locator, +shared_ptr<Glacier2::PermissionsVerifierPrx> +RegistryI::getPermissionsVerifier(const shared_ptr<IceGrid::LocatorPrx>& locator, const string& verifierProperty) { // // Get the permissions verifier // - ObjectPrx verifier; + shared_ptr<ObjectPrx> verifier; try { @@ -1206,15 +1185,15 @@ RegistryI::getPermissionsVerifier(const IceGrid::LocatorPrx& locator, Error out(_communicator->getLogger()); out << "permissions verifier `" << _communicator->getProperties()->getProperty(verifierProperty) << "' is invalid:\n" << ex; - return 0; + return nullptr; } if(!verifier) { - return 0; + return nullptr; } - Glacier2::PermissionsVerifierPrx verifierPrx; + shared_ptr<Glacier2::PermissionsVerifierPrx> verifierPrx; try { // @@ -1223,13 +1202,13 @@ RegistryI::getPermissionsVerifier(const IceGrid::LocatorPrx& locator, // to deadlocks if there's not enough threads in the client // thread pool anymore. // - verifierPrx = Glacier2::PermissionsVerifierPrx::checkedCast(verifier->ice_locator(locator)); + verifierPrx = checkedCast<Glacier2::PermissionsVerifierPrx>(verifier->ice_locator(locator)); if(!verifierPrx) { Error out(_communicator->getLogger()); out << "permissions verifier `" << _communicator->getProperties()->getProperty(verifierProperty) << "' is invalid"; - return 0; + return nullptr; } } catch(const LocalException& ex) @@ -1240,19 +1219,19 @@ RegistryI::getPermissionsVerifier(const IceGrid::LocatorPrx& locator, out << "couldn't contact permissions verifier `" << _communicator->getProperties()->getProperty(verifierProperty) << "':\n" << ex; } - verifierPrx = Glacier2::PermissionsVerifierPrx::uncheckedCast(verifier->ice_locator(locator)); + verifierPrx = uncheckedCast<Glacier2::PermissionsVerifierPrx>(verifier->ice_locator(locator)); } return verifierPrx; } -Glacier2::SSLPermissionsVerifierPrx -RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const string& verifierProperty) +shared_ptr<Glacier2::SSLPermissionsVerifierPrx> +RegistryI::getSSLPermissionsVerifier(const shared_ptr<IceGrid::LocatorPrx>& locator, const string& verifierProperty) { // // Get the permissions verifier, or create a default one if no // verifier is specified. // - ObjectPrx verifier; + shared_ptr<ObjectPrx> verifier; try { verifier = _communicator->propertyToProxy(verifierProperty); @@ -1262,15 +1241,15 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s Error out(_communicator->getLogger()); out << "ssl permissions verifier `" << _communicator->getProperties()->getProperty(verifierProperty) << "' is invalid:\n" << ex; - return 0; + return nullptr; } if(!verifier) { - return 0; + return nullptr; } - Glacier2::SSLPermissionsVerifierPrx verifierPrx; + shared_ptr<Glacier2::SSLPermissionsVerifierPrx> verifierPrx; try { // @@ -1279,13 +1258,13 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s // to deadlocks if there's not enough threads in the client // thread pool anymore. // - verifierPrx = Glacier2::SSLPermissionsVerifierPrx::checkedCast(verifier->ice_locator(locator)); + verifierPrx = checkedCast<Glacier2::SSLPermissionsVerifierPrx>(verifier->ice_locator(locator)); if(!verifierPrx) { Error out(_communicator->getLogger()); out << "ssl permissions verifier `" << _communicator->getProperties()->getProperty(verifierProperty) << "' is invalid"; - return 0; + return nullptr; } } catch(const LocalException& ex) @@ -1296,32 +1275,32 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s out << "couldn't contact ssl permissions verifier `" << _communicator->getProperties()->getProperty(verifierProperty) << "':\n" << ex; } - verifierPrx = Glacier2::SSLPermissionsVerifierPrx::uncheckedCast(verifier->ice_locator(locator)); + verifierPrx = uncheckedCast<Glacier2::SSLPermissionsVerifierPrx>(verifier->ice_locator(locator)); } return verifierPrx; } Glacier2::SSLInfo -RegistryI::getSSLInfo(const ConnectionPtr& connection, string& userDN) +RegistryI::getSSLInfo(const shared_ptr<Connection>& connection, string& userDN) { Glacier2::SSLInfo sslinfo; try { - IceSSL::ConnectionInfoPtr info = IceSSL::ConnectionInfoPtr::dynamicCast(connection->getInfo()); + auto info = dynamic_pointer_cast<IceSSL::ConnectionInfo>(connection->getInfo()); if(!info) { throw PermissionDeniedException("not ssl connection"); } - Ice::IPConnectionInfoPtr ipInfo = getIPConnectionInfo(info); + auto ipInfo = getIPConnectionInfo(info); sslinfo.remotePort = ipInfo->remotePort; sslinfo.remoteHost = ipInfo->remoteAddress; sslinfo.localPort = ipInfo->localPort; sslinfo.localHost = ipInfo->localAddress; sslinfo.cipher = info->cipher; - for(std::vector<IceSSL::CertificatePtr>::const_iterator i = info->certs.begin(); i != info->certs.end(); ++i) + for(const auto& cert : info->certs) { - sslinfo.certs.push_back((*i)->encode()); + sslinfo.certs.push_back(cert->encode()); } if(info->certs.size() > 0) { @@ -1341,7 +1320,7 @@ RegistryI::getSSLInfo(const ConnectionPtr& connection, string& userDN) } NodePrxSeq -RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const NodePrxSeq& dbNodes) +RegistryI::registerReplicas(const shared_ptr<InternalRegistryPrx>& internalRegistry, const NodePrxSeq& dbNodes) { // // Get proxies for slaves that we we connected with on last @@ -1355,17 +1334,16 @@ RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const N // version <= 3.5.0 also kept the internal proxy in the database // instead of the public proxy. // - map<InternalRegistryPrx, RegistryPrx> replicas; - Ice::ObjectProxySeq proxies = _database->getObjectsByType(InternalRegistry::ice_staticId()); - for(ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) + map<shared_ptr<InternalRegistryPrx>, shared_ptr<RegistryPrx>> replicas; + + for(const auto& p : _database->getObjectsByType(InternalRegistry::ice_staticId())) { - replicas.insert(pair<InternalRegistryPrx, RegistryPrx>(InternalRegistryPrx::uncheckedCast(*p), RegistryPrx())); + replicas.insert({ uncheckedCast<InternalRegistryPrx>(p), nullptr }); } - proxies = _database->getObjectsByType(Registry::ice_staticId()); - for(ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) + for(const auto& p : _database->getObjectsByType(Registry::ice_staticId())) { - Ice::Identity id = (*p)->ice_getIdentity(); + Ice::Identity id = p->ice_getIdentity(); const string prefix("Registry-"); string::size_type pos = id.name.find(prefix); if(pos == string::npos) @@ -1374,11 +1352,11 @@ RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const N } id.name = "InternalRegistry-" + id.name.substr(prefix.size()); - Ice::ObjectPrx prx = (*p)->ice_identity(id)->ice_endpoints(Ice::EndpointSeq()); + auto prx = p->ice_identity(id)->ice_endpoints(Ice::EndpointSeq()); id.name = "Locator"; - prx = prx->ice_locator(Ice::LocatorPrx::uncheckedCast((*p)->ice_identity(id))); + prx = prx->ice_locator(uncheckedCast<Ice::LocatorPrx>(p->ice_identity(id))); - for(map<InternalRegistryPrx, RegistryPrx>::iterator q = replicas.begin(); q != replicas.end(); ++q) + for(auto q = replicas.begin(); q != replicas.end(); ++q) { if(q->first->ice_getIdentity() == prx->ice_getIdentity()) { @@ -1386,24 +1364,24 @@ RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const N break; } } - replicas.insert(pair<InternalRegistryPrx, RegistryPrx>(InternalRegistryPrx::uncheckedCast(prx), - RegistryPrx::uncheckedCast(*p))); + replicas.insert({uncheckedCast<InternalRegistryPrx>(prx), uncheckedCast<RegistryPrx>(p)}); } - set<NodePrx> nodes; + set<shared_ptr<NodePrx>> nodes; nodes.insert(dbNodes.begin(), dbNodes.end()); - vector<Ice::AsyncResultPtr> results; - for(map<InternalRegistryPrx, RegistryPrx>::const_iterator r = replicas.begin(); r != replicas.end(); ++r) + map<shared_ptr<InternalRegistryPrx>, future<void>> results; + for(const auto& registryPrx : replicas) { - if(r->first->ice_getIdentity() != internalRegistry->ice_getIdentity()) + if(registryPrx.first->ice_getIdentity() != internalRegistry->ice_getIdentity()) { - results.push_back(r->first->begin_registerWithReplica(internalRegistry)); + auto fut = registryPrx.first->registerWithReplicaAsync(internalRegistry); + results.insert({registryPrx.first, move(fut)}); } } - for(vector<Ice::AsyncResultPtr>::const_iterator p = results.begin(); p != results.end(); ++p) + for(const auto& result : results) { - InternalRegistryPrx replica = InternalRegistryPrx::uncheckedCast((*p)->getProxy()); + const auto& replica = result.first; string replicaName; if(_traceLevels && _traceLevels->replica > 1) @@ -1422,7 +1400,7 @@ RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const N try { - replica->end_registerWithReplica(*p); + result.second.wait(); NodePrxSeq nds = replica->getNodes(); nodes.insert(nds.begin(), nds.end()); @@ -1439,12 +1417,12 @@ RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const N // Clear the proxy from the database if we can't // contact the replica. // - RegistryPrx registry; - for(map<InternalRegistryPrx, RegistryPrx>::const_iterator q = replicas.begin(); q != replicas.end(); ++q) + shared_ptr<RegistryPrx> registry; + for(const auto& r : replicas) { - if(q->first->ice_getIdentity() == replica->ice_getIdentity()) + if(r.first->ice_getIdentity() == replica->ice_getIdentity()) { - registry = q->second; + registry = r.second; break; } } @@ -1477,24 +1455,24 @@ RegistryI::registerReplicas(const InternalRegistryPrx& internalRegistry, const N } NodePrxSeq result; - for(set<NodePrx>::iterator p = nodes.begin(); p != nodes.end(); ++p) + for(const auto& node : nodes) { - result.push_back(*p); + result.push_back(node); } return result; } void -RegistryI::registerNodes(const InternalRegistryPrx& /*internalRegistry*/, const NodePrxSeq& nodes) +RegistryI::registerNodes(const shared_ptr<InternalRegistryPrx>&, const NodePrxSeq& nodes) { const string prefix("Node-"); - for(NodePrxSeq::const_iterator p = nodes.begin(); p != nodes.end(); ++p) + for(const auto& node : nodes) { - assert((*p)->ice_getIdentity().name.find(prefix) != string::npos); + assert(node->ice_getIdentity().name.find(prefix) != string::npos); try { - _database->getNode((*p)->ice_getIdentity().name.substr(prefix.size()))->setProxy(*p); + _database->getNode(node->ice_getIdentity().name.substr(prefix.size()))->setProxy(node); } catch(const NodeNotExistException&) { @@ -1505,7 +1483,7 @@ RegistryI::registerNodes(const InternalRegistryPrx& /*internalRegistry*/, const // try { - _database->removeInternalObject((*p)->ice_getIdentity()); + _database->removeInternalObject(node->ice_getIdentity()); } catch(const ObjectNotRegisteredException&) { diff --git a/cpp/src/IceGrid/RegistryI.h b/cpp/src/IceGrid/RegistryI.h index 7589bdada8b..ca6f9d997d9 100644 --- a/cpp/src/IceGrid/RegistryI.h +++ b/cpp/src/IceGrid/RegistryI.h @@ -6,60 +6,47 @@ #define ICE_GRID_REGISTRYI_H #include <IceUtil/Timer.h> -#include <Ice/UniquePtr.h> #include <IceGrid/Registry.h> #include <IceGrid/Internal.h> #include <IceGrid/PlatformInfo.h> #include <IceGrid/ReplicaSessionManager.h> #include <IceGrid/PluginFacade.h> -#include <Glacier2/PermissionsVerifierF.h> +#include <Glacier2/PermissionsVerifier.h> #include <IceStorm/Service.h> namespace IceGrid { +class AdminSessionFactory; +class ClientSessionFactory; class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class WellKnownObjectsManager; -typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr; - -class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - class ReapThread; -typedef IceUtil::Handle<ReapThread> ReapThreadPtr; - class SessionServantManager; -typedef IceUtil::Handle<SessionServantManager> SessionServantManagerPtr; - -class ClientSessionFactory; -typedef IceUtil::Handle<ClientSessionFactory> ClientSessionFactoryPtr; - -class AdminSessionFactory; -typedef IceUtil::Handle<AdminSessionFactory> AdminSessionFactoryPtr; +class TraceLevels; +class WellKnownObjectsManager; -std::string getInstanceName(const Ice::CommunicatorPtr&); +std::string getInstanceName(const std::shared_ptr<Ice::Communicator>&); -class RegistryI : public Registry +class RegistryI : public Registry, public std::enable_shared_from_this<RegistryI> { public: - RegistryI(const Ice::CommunicatorPtr&, const TraceLevelsPtr&, bool, bool, const std::string&, const std::string&); - ~RegistryI(); + RegistryI(const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<TraceLevels>&, bool, bool, + const std::string&, const std::string&); + virtual ~RegistryI() = default; bool start(); bool startImpl(); void stop(); - virtual SessionPrx createSession(const std::string&, const std::string&, const Ice::Current&); - virtual AdminSessionPrx createAdminSession(const std::string&, const std::string&, const Ice::Current&); + std::shared_ptr<SessionPrx> createSession(std::string, std::string, const Ice::Current&) override; + std::shared_ptr<AdminSessionPrx> createAdminSession(std::string, std::string, const Ice::Current&) override; - virtual SessionPrx createSessionFromSecureConnection(const Ice::Current&); - virtual AdminSessionPrx createAdminSessionFromSecureConnection(const Ice::Current&); + std::shared_ptr<SessionPrx> createSessionFromSecureConnection(const Ice::Current&) override; + std::shared_ptr<AdminSessionPrx> createAdminSessionFromSecureConnection(const Ice::Current&) override; - virtual int getSessionTimeout(const Ice::Current&) const; - virtual int getACMTimeout(const Ice::Current&) const; + int getSessionTimeout(const Ice::Current&) const override; + int getACMTimeout(const Ice::Current&) const override; std::string getName() const; RegistryInfo getInfo() const; @@ -71,64 +58,67 @@ public: std::string getNodeAdminCategory() const { return _instanceName + "-RegistryNodeAdminRouter"; } std::string getReplicaAdminCategory() const { return _instanceName + "-RegistryReplicaAdminRouter"; } - Ice::ObjectPrx createAdminCallbackProxy(const Ice::Identity&) const; + std::shared_ptr<Ice::ObjectPrx> createAdminCallbackProxy(const Ice::Identity&) const; - const Ice::ObjectAdapterPtr& getRegistryAdapter() { return _registryAdapter; } + const std::shared_ptr<Ice::ObjectAdapter>& getRegistryAdapter() { return _registryAdapter; } - Ice::LocatorPrx getLocator(); + std::shared_ptr<Ice::LocatorPrx> getLocator(); private: void setupLocatorRegistry(); - LocatorPrx setupLocator(const RegistryPrx&, const QueryPrx&); - QueryPrx setupQuery(); - RegistryPrx setupRegistry(); - InternalRegistryPrx setupInternalRegistry(); + std::shared_ptr<LocatorPrx> setupLocator(const std::shared_ptr<RegistryPrx>&, const std::shared_ptr<QueryPrx>&); + std::shared_ptr<QueryPrx> setupQuery(); + std::shared_ptr<RegistryPrx> setupRegistry(); + std::shared_ptr<InternalRegistryPrx> setupInternalRegistry(); bool setupUserAccountMapper(); - Ice::ObjectAdapterPtr setupClientSessionFactory(const LocatorPrx&); - Ice::ObjectAdapterPtr setupAdminSessionFactory(const Ice::ObjectPtr&, const Ice::ObjectPtr&, - const Ice::ObjectPtr&, const LocatorPrx&); - - Glacier2::PermissionsVerifierPrx getPermissionsVerifier(const LocatorPrx&, const std::string&); - Glacier2::SSLPermissionsVerifierPrx getSSLPermissionsVerifier(const LocatorPrx&, const std::string&); - Glacier2::SSLInfo getSSLInfo(const Ice::ConnectionPtr&, std::string&); - - NodePrxSeq registerReplicas(const InternalRegistryPrx&, const NodePrxSeq&); - void registerNodes(const InternalRegistryPrx&, const NodePrxSeq&); - - const Ice::CommunicatorPtr _communicator; - const TraceLevelsPtr _traceLevels; + std::shared_ptr<Ice::ObjectAdapter> setupClientSessionFactory(const std::shared_ptr<LocatorPrx>&); + std::shared_ptr<Ice::ObjectAdapter> setupAdminSessionFactory(const std::shared_ptr<Ice::Object>&, + const std::shared_ptr<Ice::Object>&, + const std::shared_ptr<Ice::Object>&, + const std::shared_ptr<LocatorPrx>&); + + std::shared_ptr<Glacier2::PermissionsVerifierPrx> getPermissionsVerifier(const std::shared_ptr<LocatorPrx>&, + const std::string&); + std::shared_ptr<Glacier2::SSLPermissionsVerifierPrx> getSSLPermissionsVerifier(const std::shared_ptr<LocatorPrx>&, + const std::string&); + Glacier2::SSLInfo getSSLInfo(const std::shared_ptr<Ice::Connection>&, std::string&); + + NodePrxSeq registerReplicas(const std::shared_ptr<InternalRegistryPrx>&, const NodePrxSeq&); + void registerNodes(const std::shared_ptr<InternalRegistryPrx>&, const NodePrxSeq&); + + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<TraceLevels> _traceLevels; const bool _nowarn; const bool _readonly; const std::string _initFromReplica; const std::string _collocatedNodeName; - DatabasePtr _database; - Ice::ObjectAdapterPtr _clientAdapter; - Ice::ObjectAdapterPtr _serverAdapter; - Ice::ObjectAdapterPtr _registryAdapter; - WellKnownObjectsManagerPtr _wellKnownObjects; + std::shared_ptr<Database> _database; + std::shared_ptr<Ice::ObjectAdapter> _clientAdapter; + std::shared_ptr<Ice::ObjectAdapter> _serverAdapter; + std::shared_ptr<Ice::ObjectAdapter> _registryAdapter; + std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects; std::string _instanceName; bool _master; std::string _replicaName; - ReapThreadPtr _reaper; + std::shared_ptr<ReapThread> _reaper; IceUtil::TimerPtr _timer; - SessionServantManagerPtr _servantManager; - int _sessionTimeout; - IceInternal::UniquePtr<ReplicaSessionManager> _session; + std::shared_ptr<SessionServantManager> _servantManager; + std::chrono::seconds _sessionTimeout; + std::unique_ptr<ReplicaSessionManager> _session; mutable PlatformInfo _platform; - ClientSessionFactoryPtr _clientSessionFactory; - Glacier2::PermissionsVerifierPrx _clientVerifier; - Glacier2::SSLPermissionsVerifierPrx _sslClientVerifier; + std::shared_ptr<ClientSessionFactory> _clientSessionFactory; + std::shared_ptr<Glacier2::PermissionsVerifierPrx> _clientVerifier; + std::shared_ptr<Glacier2::SSLPermissionsVerifierPrx> _sslClientVerifier; - AdminSessionFactoryPtr _adminSessionFactory; - Glacier2::PermissionsVerifierPrx _adminVerifier; - Glacier2::SSLPermissionsVerifierPrx _sslAdminVerifier; + std::shared_ptr<AdminSessionFactory> _adminSessionFactory; + std::shared_ptr<Glacier2::PermissionsVerifierPrx> _adminVerifier; + std::shared_ptr<Glacier2::SSLPermissionsVerifierPrx> _sslAdminVerifier; - IceStormInternal::ServicePtr _iceStorm; + std::shared_ptr<IceStormInternal::Service> _iceStorm; }; -typedef IceUtil::Handle<RegistryI> RegistryIPtr; } diff --git a/cpp/src/IceGrid/ReplicaCache.cpp b/cpp/src/IceGrid/ReplicaCache.cpp index 56cfac1d3e7..93ac8cb652d 100644 --- a/cpp/src/IceGrid/ReplicaCache.cpp +++ b/cpp/src/IceGrid/ReplicaCache.cpp @@ -12,10 +12,11 @@ using namespace std; using namespace IceGrid; -ReplicaCache::ReplicaCache(const Ice::CommunicatorPtr& communicator, const IceStorm::TopicManagerPrx& topicManager) : +ReplicaCache::ReplicaCache(const shared_ptr<Ice::Communicator>& communicator, + const shared_ptr<IceStorm::TopicManagerPrx>& topicManager) : _communicator(communicator) { - IceStorm::TopicPrx t; + shared_ptr<IceStorm::TopicPrx> t; try { t = topicManager->create("ReplicaObserverTopic"); @@ -25,22 +26,25 @@ ReplicaCache::ReplicaCache(const Ice::CommunicatorPtr& communicator, const IceSt t = topicManager->retrieve("ReplicaObserverTopic"); } - const_cast<IceStorm::TopicPrx&>(_topic) = IceStorm::TopicPrx::uncheckedCast(t->ice_endpoints(Ice::EndpointSeq())); - const_cast<ReplicaObserverPrx&>(_observers) = ReplicaObserverPrx::uncheckedCast(_topic->getPublisher()->ice_endpoints(Ice::EndpointSeq())); + const_cast<shared_ptr<IceStorm::TopicPrx>&>(_topic) = + Ice::uncheckedCast<IceStorm::TopicPrx>(t->ice_endpoints(Ice::EndpointSeq())); + const_cast<shared_ptr<ReplicaObserverPrx>&>(_observers) = + Ice::uncheckedCast<ReplicaObserverPrx>(_topic->getPublisher()->ice_endpoints(Ice::EndpointSeq())); } -ReplicaEntryPtr -ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session) +shared_ptr<ReplicaEntry> +ReplicaCache::add(const string& name, const shared_ptr<ReplicaSessionI>& session) { - Lock sync(*this); + unique_lock lock(_mutex); - ReplicaEntryPtr entry; + shared_ptr<ReplicaEntry> entry; while((entry = getImpl(name))) { - ReplicaSessionIPtr s = entry->getSession(); + auto s = entry->getSession(); if(s->isDestroyed()) { - wait(); // Wait for the session to be removed. + // Wait for the session to be removed. + _condVar.wait(lock); } else { @@ -48,7 +52,7 @@ ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session) // Check if the replica is still reachable, if not, we // destroy its session. // - sync.release(); + lock.unlock(); try { s->getInternalRegistry()->ice_ping(); @@ -64,7 +68,7 @@ ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session) { } } - sync.acquire(); + lock.lock(); } } @@ -88,7 +92,7 @@ ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session) } catch(const Ice::LocalException& ex) { - TraceLevelsPtr traceLevels = getTraceLevels(); + auto traceLevels = getTraceLevels(); if(traceLevels) { Ice::Warning out(traceLevels->logger); @@ -96,18 +100,18 @@ ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session) } } - return addImpl(name, new ReplicaEntry(name, session)); + return addImpl(name, make_shared<ReplicaEntry>(name, session)); } -ReplicaEntryPtr +shared_ptr<ReplicaEntry> ReplicaCache::remove(const string& name, bool shutdown) { - Lock sync(*this); + lock_guard lock(_mutex); - ReplicaEntryPtr entry = getImpl(name); + auto entry = getImpl(name); assert(entry); removeImpl(name); - notifyAll(); + _condVar.notify_all(); if(_traceLevels && _traceLevels->replica > 0) { @@ -131,7 +135,7 @@ ReplicaCache::remove(const string& name, bool shutdown) } catch(const Ice::LocalException& ex) { - TraceLevelsPtr traceLevels = getTraceLevels(); + auto traceLevels = getTraceLevels(); if(traceLevels) { Ice::Warning out(traceLevels->logger); @@ -143,11 +147,11 @@ ReplicaCache::remove(const string& name, bool shutdown) return entry; } -ReplicaEntryPtr +shared_ptr<ReplicaEntry> ReplicaCache::get(const string& name) const { - Lock sync(*this); - ReplicaEntryPtr entry = getImpl(name); + lock_guard lock(_mutex); + auto entry = getImpl(name); if(!entry) { throw RegistryNotExistException(name); @@ -156,21 +160,21 @@ ReplicaCache::get(const string& name) const } void -ReplicaCache::subscribe(const ReplicaObserverPrx& observer) +ReplicaCache::subscribe(const shared_ptr<ReplicaObserverPrx>& observer) { try { - Lock sync(*this); + lock_guard lock(_mutex); InternalRegistryPrxSeq replicas; - for(map<string, ReplicaEntryPtr>::const_iterator p = _entries.begin(); p != _entries.end(); ++p) + for(const auto& entry : _entries) { - replicas.push_back(p->second->getProxy()); + replicas.push_back(entry.second->getProxy()); } IceStorm::QoS qos; qos["reliability"] = "ordered"; - Ice::ObjectPrx publisher = _topic->subscribeAndGetPublisher(qos, observer->ice_twoway()); - ReplicaObserverPrx::uncheckedCast(publisher)->replicaInit(replicas); + auto publisher = _topic->subscribeAndGetPublisher(qos, observer->ice_twoway()); + Ice::uncheckedCast<ReplicaObserverPrx>(publisher)->replicaInit(replicas); } catch(const Ice::NoEndpointException&) { @@ -182,7 +186,7 @@ ReplicaCache::subscribe(const ReplicaObserverPrx& observer) } catch(const Ice::LocalException& ex) { - TraceLevelsPtr traceLevels = getTraceLevels(); + auto traceLevels = getTraceLevels(); if(traceLevels) { Ice::Warning out(traceLevels->logger); @@ -192,7 +196,7 @@ ReplicaCache::subscribe(const ReplicaObserverPrx& observer) } void -ReplicaCache::unsubscribe(const ReplicaObserverPrx& observer) +ReplicaCache::unsubscribe(const shared_ptr<ReplicaObserverPrx>& observer) { try { @@ -208,7 +212,7 @@ ReplicaCache::unsubscribe(const ReplicaObserverPrx& observer) } catch(const Ice::LocalException& ex) { - TraceLevelsPtr traceLevels = getTraceLevels(); + auto traceLevels = getTraceLevels(); if(traceLevels) { Ice::Warning out(traceLevels->logger); @@ -217,8 +221,8 @@ ReplicaCache::unsubscribe(const ReplicaObserverPrx& observer) } } -Ice::ObjectPrx -ReplicaCache::getEndpoints(const string& name, const Ice::ObjectPrx& proxy) const +shared_ptr<Ice::ObjectPrx> +ReplicaCache::getEndpoints(const string& name, const shared_ptr<Ice::ObjectPrx>& proxy) const { Ice::EndpointSeq endpoints; @@ -228,10 +232,10 @@ ReplicaCache::getEndpoints(const string& name, const Ice::ObjectPrx& proxy) cons endpoints.insert(endpoints.end(), endpts.begin(), endpts.end()); } - Lock sync(*this); - for(map<string, ReplicaEntryPtr>::const_iterator p = _entries.begin(); p != _entries.end(); ++p) + lock_guard lock(_mutex); + for(const auto& entry : _entries) { - Ice::ObjectPrx prx = p->second->getSession()->getEndpoint(name); + auto prx = entry.second->getSession()->getEndpoint(name); if(prx) { Ice::EndpointSeq endpts = prx->ice_getEndpoints(); @@ -243,7 +247,7 @@ ReplicaCache::getEndpoints(const string& name, const Ice::ObjectPrx& proxy) cons } void -ReplicaCache::setInternalRegistry(const InternalRegistryPrx& proxy) +ReplicaCache::setInternalRegistry(const shared_ptr<InternalRegistryPrx>& proxy) { // // Setup this replica internal registry proxy. @@ -251,7 +255,7 @@ ReplicaCache::setInternalRegistry(const InternalRegistryPrx& proxy) _self = proxy; } -InternalRegistryPrx +shared_ptr<InternalRegistryPrx> ReplicaCache::getInternalRegistry() const { // @@ -260,41 +264,35 @@ ReplicaCache::getInternalRegistry() const return _self; } -ReplicaEntry::ReplicaEntry(const std::string& name, const ReplicaSessionIPtr& session) : +ReplicaEntry::ReplicaEntry(const std::string& name, const shared_ptr<ReplicaSessionI>& session) : _name(name), _session(session) { } -ReplicaEntry::~ReplicaEntry() -{ -} - -const ReplicaSessionIPtr& +const shared_ptr<ReplicaSessionI>& ReplicaEntry::getSession() const { return _session; } -InternalReplicaInfoPtr +shared_ptr<InternalReplicaInfo> ReplicaEntry::getInfo() const { return _session->getInfo(); } -InternalRegistryPrx +shared_ptr<InternalRegistryPrx> ReplicaEntry::getProxy() const { return _session->getInternalRegistry(); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> ReplicaEntry::getAdminProxy() const { - Ice::ObjectPrx prx = getProxy(); + auto prx = getProxy(); assert(prx); - Ice::Identity adminId; - adminId.name = "RegistryAdmin-" + _name; - adminId.category = prx->ice_getIdentity().category; - return prx->ice_identity(adminId); + Ice::Identity adminId = { "RegistryAdmin-" + _name, prx->ice_getIdentity().category }; + return prx->ice_identity(move(adminId)); } diff --git a/cpp/src/IceGrid/ReplicaCache.h b/cpp/src/IceGrid/ReplicaCache.h index 9e38f0cadfd..c0c90e9b5eb 100644 --- a/cpp/src/IceGrid/ReplicaCache.h +++ b/cpp/src/IceGrid/ReplicaCache.h @@ -5,8 +5,6 @@ #ifndef ICE_GRID_REPLICACACHE_H #define ICE_GRID_REPLICACACHE_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Shared.h> #include <IceGrid/Cache.h> #include <IceGrid/Internal.h> #include <IceStorm/IceStorm.h> @@ -15,59 +13,51 @@ namespace IceGrid { class ReplicaCache; - class ReplicaSessionI; -typedef IceUtil::Handle<ReplicaSessionI> ReplicaSessionIPtr; -class ReplicaEntry : public IceUtil::Shared +class ReplicaEntry final { public: - ReplicaEntry(const std::string&, const ReplicaSessionIPtr&); - virtual ~ReplicaEntry(); + ReplicaEntry(const std::string&, const std::shared_ptr<ReplicaSessionI>&); bool canRemove() const { return true; } - const ReplicaSessionIPtr& getSession() const; - InternalReplicaInfoPtr getInfo() const; - InternalRegistryPrx getProxy() const; + const std::shared_ptr<ReplicaSessionI>& getSession() const; + std::shared_ptr<InternalReplicaInfo> getInfo() const; + std::shared_ptr<InternalRegistryPrx> getProxy() const; - Ice::ObjectPrx getAdminProxy() const; + std::shared_ptr<Ice::ObjectPrx> getAdminProxy() const; private: const std::string _name; - const ReplicaSessionIPtr _session; + const std::shared_ptr<ReplicaSessionI> _session; }; -typedef IceUtil::Handle<ReplicaEntry> ReplicaEntryPtr; -class ReplicaCache : public CacheByString<ReplicaEntry> +class ReplicaCache final : public CacheByString<ReplicaEntry> { public: -#ifdef __SUNPRO_CC - using CacheByString<ReplicaEntry>::remove; -#endif - - ReplicaCache(const Ice::CommunicatorPtr&, const IceStorm::TopicManagerPrx&); + ReplicaCache(const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<IceStorm::TopicManagerPrx>&); - ReplicaEntryPtr add(const std::string&, const ReplicaSessionIPtr&); - ReplicaEntryPtr remove(const std::string&, bool); - ReplicaEntryPtr get(const std::string&) const; + std::shared_ptr<ReplicaEntry> add(const std::string&, const std::shared_ptr<ReplicaSessionI>&); + std::shared_ptr<ReplicaEntry> remove(const std::string&, bool); + std::shared_ptr<ReplicaEntry> get(const std::string&) const; - void subscribe(const ReplicaObserverPrx&); - void unsubscribe(const ReplicaObserverPrx&); + void subscribe(const std::shared_ptr<ReplicaObserverPrx>&); + void unsubscribe(const std::shared_ptr<ReplicaObserverPrx>&); - Ice::ObjectPrx getEndpoints(const std::string&, const Ice::ObjectPrx&) const; + std::shared_ptr<Ice::ObjectPrx> getEndpoints(const std::string&, const std::shared_ptr<Ice::ObjectPrx>&) const; - void setInternalRegistry(const InternalRegistryPrx&); - InternalRegistryPrx getInternalRegistry() const; + void setInternalRegistry(const std::shared_ptr<InternalRegistryPrx>&); + std::shared_ptr<InternalRegistryPrx> getInternalRegistry() const; private: - const Ice::CommunicatorPtr _communicator; - const IceStorm::TopicPrx _topic; - const ReplicaObserverPrx _observers; - InternalRegistryPrx _self; // This replica internal registry proxy. + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<IceStorm::TopicPrx> _topic; + const std::shared_ptr<ReplicaObserverPrx> _observers; + std::shared_ptr<InternalRegistryPrx> _self; // This replica internal registry proxy. }; }; diff --git a/cpp/src/IceGrid/ReplicaSessionI.cpp b/cpp/src/IceGrid/ReplicaSessionI.cpp index 6d9030fb886..381e9afe036 100644 --- a/cpp/src/IceGrid/ReplicaSessionI.cpp +++ b/cpp/src/IceGrid/ReplicaSessionI.cpp @@ -23,58 +23,69 @@ operator==(const ObjectInfo& info, const Ice::Identity& id) } -ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database, - const WellKnownObjectsManagerPtr& wellKnownObjects, - const InternalReplicaInfoPtr& info, - const InternalRegistryPrx& proxy, - int timeout) : - _database(database), - _wellKnownObjects(wellKnownObjects), - _traceLevels(database->getTraceLevels()), - _internalRegistry(proxy), - _info(info), - _timeout(timeout), - _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)), - _destroy(false) +shared_ptr<ReplicaSessionI> +ReplicaSessionI::create(const shared_ptr<Database>& database, + const shared_ptr<WellKnownObjectsManager>& wellKnownObjects, + const shared_ptr<InternalReplicaInfo>& info, + const shared_ptr<InternalRegistryPrx>& proxy, + chrono::seconds timeout) { - __setNoDelete(true); + + shared_ptr<ReplicaSessionI> replicaSession(new ReplicaSessionI(database, wellKnownObjects, info, proxy, timeout)); + try { - _database->getReplicaCache().add(info->name, this); + database->getReplicaCache().add(info->name, replicaSession); - ObserverTopicPtr obsv = _database->getObserverTopic(RegistryObserverTopicName); - RegistryObserverTopicPtr::dynamicCast(obsv)->registryUp(toRegistryInfo(_info)); + auto obsv = database->getObserverTopic(TopicName::RegistryObserver); + static_pointer_cast<RegistryObserverTopic>(obsv)->registryUp(toRegistryInfo(info)); - _proxy = ReplicaSessionPrx::uncheckedCast(_database->getInternalAdapter()->addWithUUID(this)); + replicaSession->_proxy = + Ice::uncheckedCast<ReplicaSessionPrx>(database->getInternalAdapter()->addWithUUID(replicaSession)); } catch(const ReplicaActiveException&) { - __setNoDelete(false); throw; } - catch(...) + catch(const std::exception&) { - ObserverTopicPtr obsv = _database->getObserverTopic(RegistryObserverTopicName); - RegistryObserverTopicPtr::dynamicCast(obsv)->registryDown(_info->name); + auto obsv = database->getObserverTopic(TopicName::RegistryObserver); + static_pointer_cast<RegistryObserverTopic>(obsv)->registryDown(info->name); - _database->getReplicaCache().remove(_info->name, false); + database->getReplicaCache().remove(info->name, false); - __setNoDelete(false); throw; } - __setNoDelete(false); + + return replicaSession; +} + +ReplicaSessionI::ReplicaSessionI(const shared_ptr<Database>& database, + const shared_ptr<WellKnownObjectsManager>& wellKnownObjects, + const shared_ptr<InternalReplicaInfo>& info, + const shared_ptr<InternalRegistryPrx>& proxy, + chrono::seconds timeout) : + _database(database), + _wellKnownObjects(wellKnownObjects), + _traceLevels(database->getTraceLevels()), + _internalRegistry(proxy), + _info(info), + _timeout(timeout), + _timestamp(chrono::steady_clock::now()), + _destroy(false) +{ } void ReplicaSessionI::keepAlive(const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); } - _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic); + _timestamp = chrono::steady_clock::now(); if(_traceLevels->replica > 2) { @@ -86,12 +97,12 @@ ReplicaSessionI::keepAlive(const Ice::Current&) int ReplicaSessionI::getTimeout(const Ice::Current&) const { - return _timeout; + return secondsToInt(_timeout); } void -ReplicaSessionI::setDatabaseObserver(const DatabaseObserverPrx& observer, - const IceUtil::Optional<StringLongDict>& slaveSerials, +ReplicaSessionI::setDatabaseObserver(shared_ptr<DatabaseObserverPrx> observer, + IceUtil::Optional<StringLongDict> slaveSerials, const Ice::Current&) { // @@ -146,12 +157,12 @@ ReplicaSessionI::setDatabaseObserver(const DatabaseObserverPrx& observer, int serialAdapterObserver; int serialObjectObserver; - const ObserverTopicPtr applicationObserver = _database->getObserverTopic(ApplicationObserverTopicName); - const ObserverTopicPtr adapterObserver = _database->getObserverTopic(AdapterObserverTopicName); - const ObserverTopicPtr objectObserver = _database->getObserverTopic(ObjectObserverTopicName); + const auto applicationObserver = _database->getObserverTopic(TopicName::ApplicationObserver); + const auto adapterObserver = _database->getObserverTopic(TopicName::AdapterObserver); + const auto objectObserver = _database->getObserverTopic(TopicName::ObjectObserver); { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -169,25 +180,25 @@ ReplicaSessionI::setDatabaseObserver(const DatabaseObserverPrx& observer, } void -ReplicaSessionI::setEndpoints(const StringObjectProxyDict& endpoints, const Ice::Current&) +ReplicaSessionI::setEndpoints(StringObjectProxyDict endpoints, const Ice::Current&) { { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); } - _replicaEndpoints = endpoints; + _replicaEndpoints = move(endpoints); } _wellKnownObjects->updateReplicatedWellKnownObjects(); } void -ReplicaSessionI::registerWellKnownObjects(const ObjectInfoSeq& objects, const Ice::Current&) +ReplicaSessionI::registerWellKnownObjects(ObjectInfoSeq objects, const Ice::Current&) { int serial; { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -202,13 +213,13 @@ ReplicaSessionI::registerWellKnownObjects(const ObjectInfoSeq& objects, const Ic // are correctly setup when the replica starts accepting requests // from clients (if the replica is being started). // - _database->getObserverTopic(ObjectObserverTopicName)->waitForSyncedSubscribers(serial, _info->name); + _database->getObserverTopic(TopicName::ObjectObserver)->waitForSyncedSubscribers(serial, _info->name); } void -ReplicaSessionI::setAdapterDirectProxy(const string& adapterId, - const string& replicaGroupId, - const Ice::ObjectPrx& proxy, +ReplicaSessionI::setAdapterDirectProxy(string adapterId, + string replicaGroupId, + shared_ptr<Ice::ObjectPrx> proxy, const Ice::Current&) { if(_database->getCommunicator()->getProperties()->getPropertyAsInt("IceGrid.Registry.DynamicRegistration") <= 0) @@ -219,9 +230,9 @@ ReplicaSessionI::setAdapterDirectProxy(const string& adapterId, } void -ReplicaSessionI::receivedUpdate(TopicName topicName, int serial, const string& failure, const Ice::Current&) +ReplicaSessionI::receivedUpdate(TopicName topicName, int serial, string failure, const Ice::Current&) { - ObserverTopicPtr topic = _database->getObserverTopic(topicName); + auto topic = _database->getObserverTopic(topicName); if(topic) { topic->receivedUpdate(_info->name, serial, failure); @@ -234,10 +245,10 @@ ReplicaSessionI::destroy(const Ice::Current&) destroyImpl(false); } -IceUtil::Time +chrono::steady_clock::time_point ReplicaSessionI::timestamp() const { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -251,31 +262,31 @@ ReplicaSessionI::shutdown() destroyImpl(true); } -const InternalRegistryPrx& +const shared_ptr<InternalRegistryPrx>& ReplicaSessionI::getInternalRegistry() const { return _internalRegistry; } -const InternalReplicaInfoPtr& +const shared_ptr<InternalReplicaInfo>& ReplicaSessionI::getInfo() const { return _info; } -ReplicaSessionPrx +shared_ptr<ReplicaSessionPrx> ReplicaSessionI::getProxy() const { return _proxy; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> ReplicaSessionI::getEndpoint(const std::string& name) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { - return 0; + return nullptr; } return _replicaEndpoints[name]; } @@ -283,7 +294,7 @@ ReplicaSessionI::getEndpoint(const std::string& name) bool ReplicaSessionI::isDestroyed() const { - Lock sync(*this); + lock_guard lock(_mutex); return _destroy; } @@ -291,7 +302,7 @@ void ReplicaSessionI::destroyImpl(bool shutdown) { { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroy) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -301,9 +312,9 @@ ReplicaSessionI::destroyImpl(bool shutdown) if(_observer) { - _database->getObserverTopic(ApplicationObserverTopicName)->unsubscribe(_observer, _info->name); - _database->getObserverTopic(AdapterObserverTopicName)->unsubscribe(_observer, _info->name); - _database->getObserverTopic(ObjectObserverTopicName)->unsubscribe(_observer, _info->name); + _database->getObserverTopic(TopicName::ApplicationObserver)->unsubscribe(_observer, _info->name); + _database->getObserverTopic(TopicName::AdapterObserver)->unsubscribe(_observer, _info->name); + _database->getObserverTopic(TopicName::ObjectObserver)->unsubscribe(_observer, _info->name); } // Don't remove the replica proxy from the database if the registry is being shutdown. @@ -311,10 +322,8 @@ ReplicaSessionI::destroyImpl(bool shutdown) { if(shutdown) // Don't remove the replica proxy from the database if the registry is being shutdown. { - Ice::Identity id; - id.category = _internalRegistry->ice_getIdentity().category; - id.name = "Registry-" + _info->name; - ObjectInfoSeq::iterator p = find(_replicaWellKnownObjects.begin(), _replicaWellKnownObjects.end(), id); + Ice::Identity id = { "Registry-" + _info->name, _internalRegistry->ice_getIdentity().category }; + auto p = find(_replicaWellKnownObjects.begin(), _replicaWellKnownObjects.end(), id); if(p != _replicaWellKnownObjects.end()) { _replicaWellKnownObjects.erase(p); @@ -331,8 +340,8 @@ ReplicaSessionI::destroyImpl(bool shutdown) // // Notify the observer that the registry is down. // - ObserverTopicPtr obsv = _database->getObserverTopic(RegistryObserverTopicName); - RegistryObserverTopicPtr::dynamicCast(obsv)->registryDown(_info->name); + auto obsv = _database->getObserverTopic(TopicName::RegistryObserver); + static_pointer_cast<RegistryObserverTopic>(obsv)->registryDown(_info->name); // // Remove the replica from the cache. This must be done last. As diff --git a/cpp/src/IceGrid/ReplicaSessionI.h b/cpp/src/IceGrid/ReplicaSessionI.h index 1977d7e9734..86f3277d703 100644 --- a/cpp/src/IceGrid/ReplicaSessionI.h +++ b/cpp/src/IceGrid/ReplicaSessionI.h @@ -12,60 +12,62 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class WellKnownObjectsManager; -typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr; - class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; +class WellKnownObjectsManager; -class ReplicaSessionI : public ReplicaSession, public IceUtil::Mutex +class ReplicaSessionI final : public ReplicaSession { public: - ReplicaSessionI(const DatabasePtr&, const WellKnownObjectsManagerPtr&, const InternalReplicaInfoPtr&, - const InternalRegistryPrx&, int); - - virtual void keepAlive(const Ice::Current&); - virtual int getTimeout(const Ice::Current&) const; - virtual void setDatabaseObserver(const DatabaseObserverPrx&, const IceUtil::Optional<StringLongDict>&, - const Ice::Current&); - virtual void setEndpoints(const StringObjectProxyDict&, const Ice::Current&); - virtual void registerWellKnownObjects(const ObjectInfoSeq&, const Ice::Current&); - virtual void setAdapterDirectProxy(const std::string&, const std::string&, const Ice::ObjectPrx&, - const Ice::Current&); - virtual void receivedUpdate(TopicName, int, const std::string&, const Ice::Current&); - virtual void destroy(const Ice::Current&); - - virtual IceUtil::Time timestamp() const; - virtual void shutdown(); - - const InternalRegistryPrx& getInternalRegistry() const; - const InternalReplicaInfoPtr& getInfo() const; - ReplicaSessionPrx getProxy() const; - - Ice::ObjectPrx getEndpoint(const std::string&); + static std::shared_ptr<ReplicaSessionI> create(const std::shared_ptr<Database>&, + const std::shared_ptr<WellKnownObjectsManager>&, + const std::shared_ptr<InternalReplicaInfo>&, + const std::shared_ptr<InternalRegistryPrx>&, + std::chrono::seconds); + + void keepAlive(const Ice::Current&) override; + int getTimeout(const Ice::Current&) const override; + void setDatabaseObserver(std::shared_ptr<DatabaseObserverPrx>, IceUtil::Optional<StringLongDict>, + const Ice::Current&) override; + void setEndpoints(StringObjectProxyDict, const Ice::Current&) override; + void registerWellKnownObjects(ObjectInfoSeq, const Ice::Current&) override; + void setAdapterDirectProxy(std::string, std::string, std::shared_ptr<Ice::ObjectPrx>, const Ice::Current&) override; + void receivedUpdate(TopicName, int, std::string, const Ice::Current&) override; + void destroy(const Ice::Current&) override; + + std::chrono::steady_clock::time_point timestamp() const; + void shutdown(); + + const std::shared_ptr<InternalRegistryPrx>& getInternalRegistry() const; + const std::shared_ptr<InternalReplicaInfo>& getInfo() const; + std::shared_ptr<ReplicaSessionPrx> getProxy() const; + + std::shared_ptr<Ice::ObjectPrx> getEndpoint(const std::string&); bool isDestroyed() const; private: + ReplicaSessionI(const std::shared_ptr<Database>&, const std::shared_ptr<WellKnownObjectsManager>&, + const std::shared_ptr<InternalReplicaInfo>&, const std::shared_ptr<InternalRegistryPrx>&, + std::chrono::seconds); + void destroyImpl(bool); - const DatabasePtr _database; - const WellKnownObjectsManagerPtr _wellKnownObjects; - const TraceLevelsPtr _traceLevels; - const InternalRegistryPrx _internalRegistry; - const InternalReplicaInfoPtr _info; - const int _timeout; - ReplicaSessionPrx _proxy; - DatabaseObserverPrx _observer; + const std::shared_ptr<Database> _database; + const std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects; + const std::shared_ptr<TraceLevels> _traceLevels; + const std::shared_ptr<InternalRegistryPrx> _internalRegistry; + const std::shared_ptr<InternalReplicaInfo> _info; + const std::chrono::seconds _timeout; + std::shared_ptr<ReplicaSessionPrx> _proxy; + std::shared_ptr<DatabaseObserverPrx> _observer; ObjectInfoSeq _replicaWellKnownObjects; StringObjectProxyDict _replicaEndpoints; - IceUtil::Time _timestamp; + std::chrono::steady_clock::time_point _timestamp; bool _destroy; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<ReplicaSessionI> ReplicaSessionIPtr; }; diff --git a/cpp/src/IceGrid/ReplicaSessionManager.cpp b/cpp/src/IceGrid/ReplicaSessionManager.cpp index da6f5cb4983..73547a5a304 100644 --- a/cpp/src/IceGrid/ReplicaSessionManager.cpp +++ b/cpp/src/IceGrid/ReplicaSessionManager.cpp @@ -14,35 +14,35 @@ using namespace IceGrid; namespace IceGrid { -class MasterDatabaseObserverI : public DatabaseObserver, public IceUtil::Mutex +class MasterDatabaseObserverI : public DatabaseObserver { public: - MasterDatabaseObserverI(const ReplicaSessionManager::ThreadPtr& thread, - const DatabasePtr& database, - const ReplicaSessionPrx& session) : + MasterDatabaseObserverI(const shared_ptr<ReplicaSessionManager::Thread>& thread, + const shared_ptr<Database>& database, + const shared_ptr<ReplicaSessionPrx>& session) : _thread(thread), _database(database), _session(session) { } - virtual void - applicationInit(int, const ApplicationInfoSeq& applications, const Ice::Current& current) + void + applicationInit(int, ApplicationInfoSeq applications, const Ice::Current& current) override { int serial = 0; - _database->syncApplications(applications, getSerials(current.ctx, serial)); - receivedUpdate(ApplicationObserverTopicName, serial); + _database->syncApplications(move(applications), getSerials(current.ctx, serial)); + receivedUpdate(TopicName::ApplicationObserver, serial); } - virtual void - applicationAdded(int, const ApplicationInfo& application, const Ice::Current& current) + void + applicationAdded(int, ApplicationInfo application, const Ice::Current& current) override { int serial = 0; string failure; try { - _database->addApplication(application, 0, getSerials(current.ctx, serial)); + _database->addApplication(move(application), nullptr, getSerials(current.ctx, serial)); } catch(const DeploymentException& ex) { @@ -50,17 +50,17 @@ public: os << ex << ":\n" << ex.reason; failure = os.str(); } - receivedUpdate(ApplicationObserverTopicName, serial, failure); + receivedUpdate(TopicName::ApplicationObserver, serial, failure); } - virtual void - applicationRemoved(int, const std::string& name, const Ice::Current& current) + void + applicationRemoved(int, std::string name, const Ice::Current& current) override { int serial = 0; string failure; try { - _database->removeApplication(name, 0, getSerials(current.ctx, serial)); + _database->removeApplication(name, nullptr, getSerials(current.ctx, serial)); } catch(const ApplicationNotExistException& ex) { @@ -68,17 +68,17 @@ public: os << ex << ":\napplication: " << ex.name; failure = os.str(); } - receivedUpdate(ApplicationObserverTopicName, serial, failure); + receivedUpdate(TopicName::ApplicationObserver, serial, failure); } - virtual void - applicationUpdated(int, const ApplicationUpdateInfo& update, const Ice::Current& current) + void + applicationUpdated(int, ApplicationUpdateInfo update, const Ice::Current& current) override { int serial = 0; string failure; try { - _database->updateApplication(update, false, 0, getSerials(current.ctx, serial)); + _database->updateApplication(move(update), false, nullptr, getSerials(current.ctx, serial)); } catch(const DeploymentException& ex) { @@ -92,19 +92,19 @@ public: os << ex << ":\napplication: " << ex.name; failure = os.str(); } - receivedUpdate(ApplicationObserverTopicName, serial, failure); + receivedUpdate(TopicName::ApplicationObserver, serial, failure); } - virtual void - adapterInit(const AdapterInfoSeq& adapters, const Ice::Current& current) + void + adapterInit(AdapterInfoSeq adapters, const Ice::Current& current) override { int serial = 0; _database->syncAdapters(adapters, getSerials(current.ctx, serial)); - receivedUpdate(AdapterObserverTopicName, serial); + receivedUpdate(TopicName::AdapterObserver, serial); } - virtual void - adapterAdded(const AdapterInfo& info, const Ice::Current& current) + void + adapterAdded(AdapterInfo info, const Ice::Current& current) override { int serial = 0; string failure; @@ -116,11 +116,11 @@ public: { failure = "adapter `" + info.id + "' already exists and belongs to an application"; } - receivedUpdate(AdapterObserverTopicName, serial, failure); + receivedUpdate(TopicName::AdapterObserver, serial, failure); } - virtual void - adapterUpdated(const AdapterInfo& info, const Ice::Current& current) + void + adapterUpdated(AdapterInfo info, const Ice::Current& current) override { int serial = 0; string failure; @@ -132,35 +132,35 @@ public: { failure = "adapter `" + info.id + "' already exists and belongs to an application"; } - receivedUpdate(AdapterObserverTopicName, serial, failure); + receivedUpdate(TopicName::AdapterObserver, serial, failure); } - virtual void - adapterRemoved(const std::string& id, const Ice::Current& current) + void + adapterRemoved(std::string id, const Ice::Current& current) override { int serial = 0; string failure; try { - _database->setAdapterDirectProxy(id, "", 0, getSerials(current.ctx, serial)); + _database->setAdapterDirectProxy(id, "", nullptr, getSerials(current.ctx, serial)); } catch(const AdapterExistsException&) { failure = "adapter `" + id + "' already exists and belongs to an application"; } - receivedUpdate(AdapterObserverTopicName, serial, failure); + receivedUpdate(TopicName::AdapterObserver, serial, failure); } - virtual void - objectInit(const ObjectInfoSeq& objects, const Ice::Current& current) + void + objectInit(ObjectInfoSeq objects, const Ice::Current& current) override { int serial = 0; - _database->syncObjects(objects, getSerials(current.ctx, serial)); - receivedUpdate(ObjectObserverTopicName, serial); + _database->syncObjects(move(objects), getSerials(current.ctx, serial)); + receivedUpdate(TopicName::ObjectObserver, serial); } - virtual void - objectAdded(const ObjectInfo& info, const Ice::Current& current) + void + objectAdded(ObjectInfo info, const Ice::Current& current) override { int serial = 0; string failure; @@ -175,11 +175,11 @@ public: os << "id: " << _database->getCommunicator()->identityToString(info.proxy->ice_getIdentity()); failure = os.str(); } - receivedUpdate(ObjectObserverTopicName, serial, failure); + receivedUpdate(TopicName::ObjectObserver, serial, failure); } - virtual void - objectUpdated(const ObjectInfo& info, const Ice::Current& current) + void + objectUpdated(ObjectInfo info, const Ice::Current& current) override { int serial = 0; string failure; @@ -200,11 +200,11 @@ public: os << ex << ":\n" << ex.reason; failure = os.str(); } - receivedUpdate(ObjectObserverTopicName, serial, failure); + receivedUpdate(TopicName::ObjectObserver, serial, failure); } - virtual void - objectRemoved(const Ice::Identity& id, const Ice::Current& current) + void + objectRemoved(Ice::Identity id, const Ice::Current& current) override { int serial = 0; string failure; @@ -221,15 +221,15 @@ public: catch(const ObjectNotRegisteredException&) { } - receivedUpdate(ObjectObserverTopicName, serial, failure); + receivedUpdate(TopicName::ObjectObserver, serial, failure); } private: - Ice::Long + long long getSerials(const Ice::Context& context, int& serial) { - Ice::Context::const_iterator p = context.find("serial"); + auto p = context.find("serial"); if(p != context.end()) { istringstream is(p->second); @@ -243,7 +243,7 @@ private: p = context.find("dbSerial"); if(p != context.end()) { - Ice::Long dbSerial; + long long dbSerial; istringstream is(p->second); is >> dbSerial; return dbSerial; @@ -270,27 +270,22 @@ private: } } - const ReplicaSessionManager::ThreadPtr _thread; - const DatabasePtr _database; - const ReplicaSessionPrx _session; + const shared_ptr<ReplicaSessionManager::Thread> _thread; + const shared_ptr<Database> _database; + const shared_ptr<ReplicaSessionPrx> _session; }; }; -ReplicaSessionManager::ReplicaSessionManager(const Ice::CommunicatorPtr& communicator, const string& instanceName) : - SessionManager(communicator, instanceName) -{ -} - void ReplicaSessionManager::create(const string& name, - const InternalReplicaInfoPtr& info, - const DatabasePtr& database, - const WellKnownObjectsManagerPtr& wellKnownObjects, - const InternalRegistryPrx& internalRegistry) + const shared_ptr<InternalReplicaInfo>& info, + const shared_ptr<Database>& database, + const shared_ptr<WellKnownObjectsManager>& wellKnownObjects, + const shared_ptr<InternalRegistryPrx>& internalRegistry) { { - Lock sync(*this); + lock_guard lock(_mutex); _name = name; _info = info; @@ -299,9 +294,8 @@ ReplicaSessionManager::create(const string& name, _wellKnownObjects = wellKnownObjects; _traceLevels = _database->getTraceLevels(); - _thread = new Thread(*this, _master, _traceLevels->logger); - _thread->start(); - notifyAll(); + _thread = make_shared<Thread>(*this, _master, _traceLevels->logger); + _condVar.notify_all(); } _thread->tryCreateSession(); @@ -309,14 +303,13 @@ ReplicaSessionManager::create(const string& name, } void -ReplicaSessionManager::create(const InternalRegistryPrx& replica) +ReplicaSessionManager::create(const std::shared_ptr<InternalRegistryPrx>& replica) { { - Lock sync(*this); - while(!_master) // Wait to be initialized. - { - wait(); - } + unique_lock lock(_mutex); + + // Wait to be initialized. + _condVar.wait(lock, [this] { return _master; }); } if(replica->ice_getIdentity() != _master->ice_getIdentity()) @@ -354,27 +347,27 @@ ReplicaSessionManager::getNodes(const NodePrxSeq& nodes) const void ReplicaSessionManager::destroy() { - ThreadPtr thread; + shared_ptr<Thread> thread; { - Lock sync(*this); + lock_guard lock(_mutex); if(!_communicator) { return; } thread = _thread; - _thread = 0; + _thread = nullptr; - _communicator = 0; + _communicator = nullptr; } if(thread) { thread->terminate(); - thread->getThreadControl().join(); + thread->join(); } - _database = 0; - _wellKnownObjects = 0; + _database = nullptr; + _wellKnownObjects = nullptr; } void @@ -392,7 +385,7 @@ ReplicaSessionManager::registerAllWellKnownObjects() // If there's an active session, register the well-known objects // with the session. // - ReplicaSessionPrx session = _thread->getSession(); + auto session = _thread->getSession(); if(session) { try @@ -406,33 +399,31 @@ ReplicaSessionManager::registerAllWellKnownObjects() } } -IceGrid::InternalRegistryPrx +shared_ptr<InternalRegistryPrx> ReplicaSessionManager::findInternalRegistryForReplica(const Ice::Identity& id) { - vector<Ice::AsyncResultPtr> results; - vector<QueryPrx> queryObjects = findAllQueryObjects(true); - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + vector<future<shared_ptr<Ice::ObjectPrx>>> results; + for(const auto& obj : findAllQueryObjects(true)) { - results.push_back((*q)->begin_findObjectById(id)); + results.push_back(obj->findObjectByIdAsync(id)); } - for(vector<Ice::AsyncResultPtr>::const_iterator p = results.begin(); p != results.end(); ++p) + for(auto& result : results) { - QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); try { - return InternalRegistryPrx::checkedCast(query->end_findObjectById(*p)); + return Ice::checkedCast<InternalRegistryPrx>(result.get()); } catch(const Ice::Exception&) { } } - return 0; + return nullptr; } bool -ReplicaSessionManager::keepAlive(const ReplicaSessionPrx& session) +ReplicaSessionManager::keepAlive(const shared_ptr<ReplicaSessionPrx>& session) { try { @@ -456,11 +447,11 @@ ReplicaSessionManager::keepAlive(const ReplicaSessionPrx& session) } } -ReplicaSessionPrx -ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Time& timeout) +shared_ptr<ReplicaSessionPrx> +ReplicaSessionManager::createSession(shared_ptr<InternalRegistryPrx>& registry, chrono::seconds& timeout) { - ReplicaSessionPrx session; - IceInternal::UniquePtr<Ice::Exception> exception; + shared_ptr<ReplicaSessionPrx> session; + string exceptionMsg = ""; try { if(_traceLevels && _traceLevels->replica > 1) @@ -469,7 +460,7 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim out << "trying to establish session with master replica"; } - set<InternalRegistryPrx> used; + set<shared_ptr<InternalRegistryPrx>> used; if(!registry->ice_getEndpoints().empty()) { try @@ -478,34 +469,32 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim } catch(const Ice::LocalException& ex) { - exception.reset(ex.ice_clone()); + exceptionMsg = ex.what(); used.insert(registry); - registry = InternalRegistryPrx::uncheckedCast(registry->ice_endpoints(Ice::EndpointSeq())); + registry = Ice::uncheckedCast<InternalRegistryPrx>(registry->ice_endpoints({})); } } if(!session) { - vector<Ice::AsyncResultPtr> results; - vector<QueryPrx> queryObjects = findAllQueryObjects(false); - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + vector<future<shared_ptr<Ice::ObjectPrx>>> results; + for(const auto& obj : findAllQueryObjects(false)) { - results.push_back((*q)->begin_findObjectById(registry->ice_getIdentity())); + results.push_back(obj->findObjectByIdAsync(registry->ice_getIdentity())); } - for(vector<Ice::AsyncResultPtr>::const_iterator p = results.begin(); p != results.end(); ++p) + for(auto& result : results) { - QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); if(isDestroyed()) { break; } - InternalRegistryPrx newRegistry; + shared_ptr<InternalRegistryPrx> newRegistry; try { - Ice::ObjectPrx obj = query->end_findObjectById(*p); - newRegistry = InternalRegistryPrx::uncheckedCast(obj); + auto obj = result.get(); + newRegistry = Ice::uncheckedCast<InternalRegistryPrx>(obj); if(newRegistry && used.find(newRegistry) == used.end()) { session = createSessionImpl(newRegistry, timeout); @@ -515,7 +504,7 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim } catch(const Ice::LocalException& ex) { - exception.reset(ex.ice_clone()); + exceptionMsg = ex.what(); if(newRegistry) { used.insert(newRegistry); @@ -530,7 +519,7 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim { _traceLevels->logger->error("a replica with the same name is already registered and active"); } - exception.reset(ex.ice_clone()); + exceptionMsg = ex.what(); } catch(const DeploymentException& ex) { @@ -538,7 +527,7 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim { _traceLevels->logger->error("database synchronization with master failed:\n" + ex.reason); } - exception.reset(ex.ice_clone()); + exceptionMsg = ex.what(); } catch(const PermissionDeniedException& ex) { @@ -546,11 +535,11 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim { _traceLevels->logger->error("connection to master was denied:\n" + ex.reason); } - exception.reset(ex.ice_clone()); + exceptionMsg = ex.what(); } catch(const Ice::Exception& ex) { - exception.reset(ex.ice_clone()); + exceptionMsg = ex.what(); } if(session) @@ -578,30 +567,30 @@ ReplicaSessionManager::createSession(InternalRegistryPrx& registry, IceUtil::Tim else { out << "failed to establish session with master replica:\n"; - if(exception.get()) + if(exceptionMsg.empty()) { - out << *exception.get(); + out << "failed to get replica proxy"; } else { - out << "failed to get replica proxy"; + out << exceptionMsg; } } } return session; } -ReplicaSessionPrx -ReplicaSessionManager::createSessionImpl(const InternalRegistryPrx& registry, IceUtil::Time& timeout) +shared_ptr<ReplicaSessionPrx> +ReplicaSessionManager::createSessionImpl(const shared_ptr<InternalRegistryPrx>& registry, chrono::seconds& timeout) { - ReplicaSessionPrx session; + shared_ptr<ReplicaSessionPrx> session; try { session = registry->registerReplica(_info, _internalRegistry); - int t = session->getTimeout(); + auto t = session->getTimeout(); if(t > 0) { - timeout = IceUtil::Time::seconds(t / 2); + timeout = chrono::seconds(t / 2); } // @@ -609,8 +598,8 @@ ReplicaSessionManager::createSessionImpl(const InternalRegistryPrx& registry, Ic // to the session so that it can subscribe it. This call only // returns once the observer is subscribed and initialized. // - DatabaseObserverPtr servant = new MasterDatabaseObserverI(_thread, _database, session); - _observer = DatabaseObserverPrx::uncheckedCast(_database->getInternalAdapter()->addWithUUID(servant)); + auto servant = make_shared<MasterDatabaseObserverI>(_thread, _database, session); + _observer = Ice::uncheckedCast<DatabaseObserverPrx>(_database->getInternalAdapter()->addWithUUID(servant)); StringLongDict serials = _database->getSerials(); IceUtil::Optional<StringLongDict> serialsOpt; if(!serials.empty()) @@ -628,7 +617,7 @@ ReplicaSessionManager::createSessionImpl(const InternalRegistryPrx& registry, Ic } void -ReplicaSessionManager::destroySession(const ReplicaSessionPrx& session) +ReplicaSessionManager::destroySession(const shared_ptr<ReplicaSessionPrx>& session) { if(session) { @@ -661,6 +650,6 @@ ReplicaSessionManager::destroySession(const ReplicaSessionPrx& session) catch(const Ice::LocalException&) { } - _observer = 0; + _observer = nullptr; } } diff --git a/cpp/src/IceGrid/ReplicaSessionManager.h b/cpp/src/IceGrid/ReplicaSessionManager.h index 9203bf49d87..de781b9c233 100644 --- a/cpp/src/IceGrid/ReplicaSessionManager.h +++ b/cpp/src/IceGrid/ReplicaSessionManager.h @@ -16,13 +16,8 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class WellKnownObjectsManager; -typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr; - class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; +class WellKnownObjectsManager; class ReplicaSessionManager : public SessionManager { @@ -32,26 +27,27 @@ public: { public: - Thread(ReplicaSessionManager& manager, const InternalRegistryPrx& master, const Ice::LoggerPtr& logger) : + Thread(ReplicaSessionManager& manager, const std::shared_ptr<InternalRegistryPrx>& master, + const std::shared_ptr<Ice::Logger>& logger) : SessionKeepAliveThread<ReplicaSessionPrx>(master, logger), _manager(manager) { } - virtual ReplicaSessionPrx - createSession(InternalRegistryPrx& master, IceUtil::Time& timeout) + std::shared_ptr<ReplicaSessionPrx> + createSession(std::shared_ptr<InternalRegistryPrx>& master, std::chrono::seconds& timeout) override { return _manager.createSession(master, timeout); } - virtual void - destroySession(const ReplicaSessionPrx& session) + void + destroySession(const std::shared_ptr<ReplicaSessionPrx>& session) override { _manager.destroySession(session); } - virtual bool - keepAlive(const ReplicaSessionPrx& session) + bool + keepAlive(const std::shared_ptr<ReplicaSessionPrx>& session) override { return _manager.keepAlive(session); } @@ -62,19 +58,20 @@ public: ReplicaSessionManager& _manager; }; - typedef IceUtil::Handle<Thread> ThreadPtr; - ReplicaSessionManager(const Ice::CommunicatorPtr&, const std::string&); - void create(const std::string&, const InternalReplicaInfoPtr&, const DatabasePtr&, - const WellKnownObjectsManagerPtr&, const InternalRegistryPrx&); - void create(const InternalRegistryPrx&); + using SessionManager::SessionManager; + + void create(const std::string&, const std::shared_ptr<InternalReplicaInfo>&, const std::shared_ptr<Database>&, + const std::shared_ptr<WellKnownObjectsManager>&, const std::shared_ptr<InternalRegistryPrx>&); + void create(const std::shared_ptr<InternalRegistryPrx>&); + NodePrxSeq getNodes(const NodePrxSeq&) const; void destroy(); void registerAllWellKnownObjects(); - ReplicaSessionPrx getSession() const { return _thread ? _thread->getSession() : ReplicaSessionPrx(); } + std::shared_ptr<ReplicaSessionPrx> getSession() const { return _thread ? _thread->getSession() : nullptr; } - IceGrid::InternalRegistryPrx findInternalRegistryForReplica(const Ice::Identity&); + std::shared_ptr<InternalRegistryPrx> findInternalRegistryForReplica(const Ice::Identity&); private: @@ -82,24 +79,24 @@ private: bool isDestroyed() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); return !_communicator; } - ReplicaSessionPrx createSession(InternalRegistryPrx&, IceUtil::Time&); - ReplicaSessionPrx createSessionImpl(const InternalRegistryPrx&, IceUtil::Time&); - void destroySession(const ReplicaSessionPrx&); - bool keepAlive(const ReplicaSessionPrx&); + std::shared_ptr<ReplicaSessionPrx> createSession(std::shared_ptr<InternalRegistryPrx>&, std::chrono::seconds&); + std::shared_ptr<ReplicaSessionPrx> createSessionImpl(const std::shared_ptr<InternalRegistryPrx>&, std::chrono::seconds&); + void destroySession(const std::shared_ptr<ReplicaSessionPrx>&); + bool keepAlive(const std::shared_ptr<ReplicaSessionPrx>&); - ThreadPtr _thread; + std::shared_ptr<Thread> _thread; std::string _name; - InternalReplicaInfoPtr _info; - RegistryPrx _registry; - InternalRegistryPrx _internalRegistry; - DatabaseObserverPrx _observer; - DatabasePtr _database; - WellKnownObjectsManagerPtr _wellKnownObjects; - TraceLevelsPtr _traceLevels; + std::shared_ptr<InternalReplicaInfo> _info; + std::shared_ptr<RegistryPrx> _registry; + std::shared_ptr<InternalRegistryPrx> _internalRegistry; + std::shared_ptr<DatabaseObserverPrx> _observer; + std::shared_ptr<Database> _database; + std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects; + std::shared_ptr<TraceLevels> _traceLevels; }; } diff --git a/cpp/src/IceGrid/Scanner.cpp b/cpp/src/IceGrid/Scanner.cpp index 2c831ddb927..7250014a61b 100644 --- a/cpp/src/IceGrid/Scanner.cpp +++ b/cpp/src/IceGrid/Scanner.cpp @@ -1,7 +1,12 @@ #include <IceUtil/ScannerConfig.h> -#line 2 "src/IceGrid/Scanner.cpp" +#line 1 "src/IceGrid/Scanner.cpp" +// +// Copyright (c) ZeroC, Inc. All rights reserved. +// + +#include <IceUtil/ScannerConfig.h> -#line 4 "src/IceGrid/Scanner.cpp" +#line 8 "src/IceGrid/Scanner.cpp" #define YY_INT_ALIGNED short int @@ -9,8 +14,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 35 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -87,63 +92,61 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif -#endif /* ! FLEXINT_H */ - -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) +#endif /* ! C99 */ -#define YY_USE_CONST +#endif /* ! FLEXINT_H */ -#endif /* defined (__STDC__) */ -#endif /* ! __cplusplus */ +/* begin standard C++ headers. */ -#ifdef YY_USE_CONST +/* TODO: this is always defined, so inline it */ #define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) #else -#define yyconst +#define yynoreturn #endif /* Returned upon end-of-file. */ #define YY_NULL 0 -/* Promotes a possibly negative, possibly signed char to an unsigned - * integer for use as an array index. If the signed char is negative, - * we want to instead treat it as an 8-bit unsigned char, hence the - * double cast. +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. */ -#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN (yy_start) = 1 + 2 * - /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ #define YY_START (((yy_start) - 1) / 2) #define YYSTATE YY_START - /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) - /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart(yyin ) - +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else #define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -160,15 +163,16 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif -extern yy_size_t yyleng; +extern int yyleng; extern FILE *yyin, *yyout; #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 - + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ @@ -183,7 +187,6 @@ extern FILE *yyin, *yyout; YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) - #define unput(c) yyunput( c, (yytext_ptr) ) #ifndef YY_STRUCT_YY_BUFFER_STATE @@ -198,12 +201,12 @@ struct yy_buffer_state /* Size of input buffer in bytes, not including room for EOB * characters. */ - yy_size_t yy_buf_size; + int yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -226,7 +229,7 @@ struct yy_buffer_state int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ - + /* Whether to try to fill the input buffer when we reach the * end of it. */ @@ -254,7 +257,7 @@ struct yy_buffer_state /* Stack of input buffers. */ static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general @@ -265,7 +268,6 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL) - /* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */ @@ -273,11 +275,11 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; -static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ -yy_size_t yyleng; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; /* Points to current character in buffer. */ -static char *yy_c_buf_p = (char *) 0; +static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ @@ -286,85 +288,81 @@ static int yy_start = 0; /* start state number */ */ static int yy_did_buffer_switch_on_eof; -void yyrestart (FILE *input_file ); -void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); -void yy_delete_buffer (YY_BUFFER_STATE b ); -void yy_flush_buffer (YY_BUFFER_STATE b ); -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); -void yypop_buffer_state (void ); - -static void yyensure_buffer_stack (void ); -static void yy_load_buffer_state (void ); -static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); -YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); -void *yyalloc (yy_size_t ); -void *yyrealloc (void *,yy_size_t ); -void yyfree (void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); #define yy_new_buffer yy_create_buffer - #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer(yyin,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } - #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer(yyin,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } - #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) /* Begin user sect3 */ -#define yywrap(n) 1 +#define yywrap() (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; -typedef unsigned char YY_CHAR; - -FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; extern int yylineno; - int yylineno = 1; extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif #define yytext_ptr yytext -static yy_state_type yy_get_previous_state (void ); -static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); -static int yy_get_next_buffer (void ); -static void yy_fatal_error (yyconst char msg[] ); +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ - yyleng = (yy_size_t) (yy_cp - yy_bp); \ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; - #define YY_NUM_RULES 8 #define YY_END_OF_BUFFER 9 /* This struct is not used in this scanner, @@ -374,13 +372,13 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[19] = +static const flex_int16_t yy_accept[19] = { 0, 3, 3, 9, 7, 3, 4, 5, 6, 7, 4, 7, 3, 0, 2, 1, 0, 3, 0 } ; -static yyconst flex_int32_t yy_ec[256] = +static const YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, @@ -412,24 +410,24 @@ static yyconst flex_int32_t yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[10] = +static const YY_CHAR yy_meta[10] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[19] = +static const flex_int16_t yy_base[19] = { 0, 0, 0, 11, 22, 8, 22, 22, 22, 12, 22, 18, 0, 0, 22, 22, 0, 22, 22 } ; -static yyconst flex_int16_t yy_def[19] = +static const flex_int16_t yy_def[19] = { 0, 18, 1, 18, 18, 18, 18, 18, 18, 18, 18, 18, 5, 11, 18, 18, 11, 18, 0 } ; -static yyconst flex_int16_t yy_nxt[32] = +static const flex_int16_t yy_nxt[32] = { 0, 4, 5, 6, 7, 8, 4, 9, 10, 11, 12, 18, 18, 18, 18, 18, 18, 13, 14, 15, 16, @@ -437,7 +435,7 @@ static yyconst flex_int16_t yy_nxt[32] = 18 } ; -static yyconst flex_int16_t yy_chk[32] = +static const flex_int16_t yy_chk[32] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 0, 0, 0, 0, 0, 5, 9, 9, 11, @@ -460,35 +458,13 @@ int yy_flex_debug = 0; #define YY_RESTORE_YY_MORE_OFFSET char *yytext; #line 1 "src/IceGrid/Scanner.l" -#line 2 "src/IceGrid/Scanner.l" -// -// Copyright (c) ZeroC, Inc. All rights reserved. -// +#line 11 "src/IceGrid/Scanner.l" #include <Ice/Ice.h> #include <IceGrid/Parser.h> #include <IceGrid/Grammar.h> -#if defined(_MSC_VER) -// '<' : signed/unsigned mismatch -# pragma warning(disable:4018) -// 'initializing' : conversion from '__int64' to 'int', possible loss of data -# pragma warning(disable:4244) - -# if defined(ICE_64) -// -// '=' : conversion from 'size_t' to 'int', possible loss of data -// The result of fread() is a size_t and gets inserted into an int -// -# pragma warning(disable:4267) -# endif -#endif - -#if defined(__GNUC__) -# pragma GCC diagnostic ignored "-Wsign-compare" -#endif - using namespace std; using namespace Ice; using namespace IceGrid; @@ -498,17 +474,6 @@ using namespace IceGrid; # undef yywrap # define yywrap() 1 # endif -# define YY_NO_UNISTD_H -#endif - -#ifdef __SUNPRO_CC -# ifdef yywrap -# undef yywrap -# define yywrap() 1 -# endif -# ifdef ICE_64 -# pragma error_messages(off,truncwarn) -# endif #endif #define YY_INPUT(buf, result, maxSize) parser->getInput(buf, result, maxSize) @@ -516,8 +481,7 @@ using namespace IceGrid; namespace IceGrid { -typedef std::map<std::string, int> StringTokenMap; -static StringTokenMap keywordMap; +static std::map<std::string, int> keywordMap; void initScanner(); std::string parseDoubleQuotedString(); @@ -526,7 +490,8 @@ std::string parseSingleQuotedString(); } #define YY_USER_INIT initScanner(); -#line 529 "src/IceGrid/Scanner.cpp" +#line 490 "src/IceGrid/Scanner.cpp" +#line 491 "src/IceGrid/Scanner.cpp" #define INITIAL 0 @@ -542,36 +507,36 @@ std::string parseSingleQuotedString(); #define YY_EXTRA_TYPE void * #endif -static int yy_init_globals (void ); +static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int yylex_destroy (void ); +int yylex_destroy ( void ); -int yyget_debug (void ); +int yyget_debug ( void ); -void yyset_debug (int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE yyget_extra (void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void yyset_extra (YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *yyget_in (void ); +FILE *yyget_in ( void ); -void yyset_in (FILE * in_str ); +void yyset_in ( FILE * _in_str ); -FILE *yyget_out (void ); +FILE *yyget_out ( void ); -void yyset_out (FILE * out_str ); +void yyset_out ( FILE * _out_str ); -yy_size_t yyget_leng (void ); + int yyget_leng ( void ); -char *yyget_text (void ); +char *yyget_text ( void ); -int yyget_lineno (void ); +int yyget_lineno ( void ); -void yyset_lineno (int line_number ); +void yyset_lineno ( int _line_number ); /* Macros after this point can all be overridden by user definitions in * section 1. @@ -579,35 +544,43 @@ void yyset_lineno (int line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int yywrap (void ); +extern "C" int yywrap ( void ); #else -extern int yywrap (void ); +extern int yywrap ( void ); #endif #endif - static void yyunput (int c,char *buf_ptr ); +#ifndef YY_NO_UNPUT + static void yyunput ( int c, char *buf_ptr ); + +#endif + #ifndef yytext_ptr -static void yy_flex_strncpy (char *,yyconst char *,int ); +static void yy_flex_strncpy ( char *, const char *, int ); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * ); +static int yy_flex_strlen ( const char * ); #endif #ifndef YY_NO_INPUT - #ifdef __cplusplus -static int yyinput (void ); +static int yyinput ( void ); #else -static int input (void ); +static int input ( void ); #endif #endif /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else #define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -615,7 +588,7 @@ static int input (void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -626,7 +599,7 @@ static int input (void ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - yy_size_t n; \ + int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -639,7 +612,7 @@ static int input (void ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -694,7 +667,7 @@ extern int yylex (void); /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK /*LINTED*/break; #endif #define YY_RULE_SETUP \ @@ -704,15 +677,10 @@ extern int yylex (void); */ YY_DECL { - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; -#line 76 "src/IceGrid/Scanner.l" - - -#line 714 "src/IceGrid/Scanner.cpp" - if ( !(yy_init) ) { (yy_init) = 1; @@ -733,13 +701,19 @@ YY_DECL if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer(yyin,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - yy_load_buffer_state( ); + yy_load_buffer_state( ); } - while ( 1 ) /* loops until end-of-file is reached */ + { +#line 50 "src/IceGrid/Scanner.l" + + +#line 711 "src/IceGrid/Scanner.cpp" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yy_cp = (yy_c_buf_p); @@ -755,7 +729,7 @@ YY_DECL yy_match: do { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; @@ -765,9 +739,9 @@ yy_match: { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 19 ) - yy_c = yy_meta[(unsigned int) yy_c]; + yy_c = yy_meta[yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 22 ); @@ -796,7 +770,7 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 78 "src/IceGrid/Scanner.l" +#line 52 "src/IceGrid/Scanner.l" { // C++-style comment int c; @@ -809,7 +783,7 @@ YY_RULE_SETUP YY_BREAK case 2: YY_RULE_SETUP -#line 88 "src/IceGrid/Scanner.l" +#line 62 "src/IceGrid/Scanner.l" { // C-style comment while(true) @@ -838,7 +812,7 @@ YY_RULE_SETUP case 3: /* rule 3 can match eol */ YY_RULE_SETUP -#line 113 "src/IceGrid/Scanner.l" +#line 87 "src/IceGrid/Scanner.l" { size_t len = strlen(yytext); for(size_t i = 0; i < len; ++i) @@ -853,14 +827,14 @@ YY_RULE_SETUP case 4: /* rule 4 can match eol */ YY_RULE_SETUP -#line 124 "src/IceGrid/Scanner.l" +#line 98 "src/IceGrid/Scanner.l" { return ';'; } YY_BREAK case 5: YY_RULE_SETUP -#line 128 "src/IceGrid/Scanner.l" +#line 102 "src/IceGrid/Scanner.l" { // "..."-type strings string s = parseDoubleQuotedString(); @@ -871,7 +845,7 @@ YY_RULE_SETUP YY_BREAK case 6: YY_RULE_SETUP -#line 136 "src/IceGrid/Scanner.l" +#line 110 "src/IceGrid/Scanner.l" { // '...'-type strings string s; @@ -899,7 +873,7 @@ YY_RULE_SETUP YY_BREAK case 7: YY_RULE_SETUP -#line 161 "src/IceGrid/Scanner.l" +#line 135 "src/IceGrid/Scanner.l" { // Simple strings string s; @@ -932,16 +906,16 @@ YY_RULE_SETUP yylvalp->clear(); yylvalp->push_back(s); - StringTokenMap::const_iterator pos = keywordMap.find(s); + const auto pos = keywordMap.find(s); return pos != keywordMap.end() ? pos->second : ICE_GRID_STRING; } YY_BREAK case 8: YY_RULE_SETUP -#line 197 "src/IceGrid/Scanner.l" +#line 171 "src/IceGrid/Scanner.l" ECHO; YY_BREAK -#line 944 "src/IceGrid/Scanner.cpp" +#line 915 "src/IceGrid/Scanner.cpp" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1019,7 +993,7 @@ case YY_STATE_EOF(INITIAL): { (yy_did_buffer_switch_on_eof) = 0; - if ( yywrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up @@ -1072,6 +1046,7 @@ case YY_STATE_EOF(INITIAL): "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ + } /* end of user's declarations */ } /* end of yylex */ /* yy_get_next_buffer - try to read in a new buffer @@ -1083,9 +1058,9 @@ case YY_STATE_EOF(INITIAL): */ static int yy_get_next_buffer (void) { - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = (yytext_ptr); - register int number_to_move, i; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; int ret_val; if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) @@ -1114,7 +1089,7 @@ static int yy_get_next_buffer (void) /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); @@ -1127,7 +1102,7 @@ static int yy_get_next_buffer (void) else { - yy_size_t num_to_read = + int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) @@ -1141,7 +1116,7 @@ static int yy_get_next_buffer (void) if ( b->yy_is_our_buffer ) { - yy_size_t new_size = b->yy_buf_size * 2; + int new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1150,11 +1125,12 @@ static int yy_get_next_buffer (void) b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ - b->yy_ch_buf = 0; + b->yy_ch_buf = NULL; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( @@ -1182,7 +1158,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - yyrestart(yyin ); + yyrestart( yyin ); } else @@ -1196,12 +1172,15 @@ static int yy_get_next_buffer (void) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -1217,14 +1196,14 @@ static int yy_get_next_buffer (void) static yy_state_type yy_get_previous_state (void) { - register yy_state_type yy_current_state; - register char *yy_cp; + yy_state_type yy_current_state; + char *yy_cp; yy_current_state = (yy_start); for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; @@ -1234,9 +1213,9 @@ static int yy_get_next_buffer (void) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 19 ) - yy_c = yy_meta[(unsigned int) yy_c]; + yy_c = yy_meta[yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; } return yy_current_state; @@ -1249,10 +1228,10 @@ static int yy_get_next_buffer (void) */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) { - register int yy_is_jam; - register char *yy_cp = (yy_c_buf_p); + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); - register YY_CHAR yy_c = 1; + YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; @@ -1262,17 +1241,19 @@ static int yy_get_next_buffer (void) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 19 ) - yy_c = yy_meta[(unsigned int) yy_c]; + yy_c = yy_meta[yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; yy_is_jam = (yy_current_state == 18); return yy_is_jam ? 0 : yy_current_state; } - static void yyunput (int c, register char * yy_bp ) +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) { - register char *yy_cp; + char *yy_cp; yy_cp = (yy_c_buf_p); @@ -1282,10 +1263,10 @@ static int yy_get_next_buffer (void) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - register yy_size_t number_to_move = (yy_n_chars) + 2; - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - register char *source = + char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) @@ -1294,7 +1275,7 @@ static int yy_get_next_buffer (void) yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); @@ -1307,6 +1288,8 @@ static int yy_get_next_buffer (void) (yy_c_buf_p) = yy_cp; } +#endif + #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void) @@ -1331,7 +1314,7 @@ static int yy_get_next_buffer (void) else { /* need more input */ - yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); ++(yy_c_buf_p); switch ( yy_get_next_buffer( ) ) @@ -1348,13 +1331,13 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - yyrestart(yyin ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( yywrap( ) ) + if ( yywrap( ) ) return 0; if ( ! (yy_did_buffer_switch_on_eof) ) @@ -1392,11 +1375,11 @@ static int yy_get_next_buffer (void) if ( ! YY_CURRENT_BUFFER ){ yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer(yyin,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - yy_init_buffer(YY_CURRENT_BUFFER,input_file ); - yy_load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /** Switch to a different input buffer. @@ -1424,7 +1407,7 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag @@ -1452,7 +1435,7 @@ static void yy_load_buffer_state (void) { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); @@ -1461,13 +1444,13 @@ static void yy_load_buffer_state (void) /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ - b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - yy_init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -1486,9 +1469,9 @@ static void yy_load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - yyfree((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - yyfree((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. @@ -1500,7 +1483,7 @@ static void yy_load_buffer_state (void) { int oerrno = errno; - yy_flush_buffer(b ); + yy_flush_buffer( b ); b->yy_input_file = file; b->yy_fill_buffer = 1; @@ -1543,7 +1526,7 @@ static void yy_load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( ); + yy_load_buffer_state( ); } /** Pushes the new state onto the stack. The new state becomes @@ -1574,7 +1557,7 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } @@ -1593,7 +1576,7 @@ void yypop_buffer_state (void) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -1611,15 +1594,15 @@ static void yyensure_buffer_stack (void) * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ - num_to_alloc = 1; + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - + (yy_buffer_stack_max) = num_to_alloc; (yy_buffer_stack_top) = 0; return; @@ -1628,7 +1611,7 @@ static void yyensure_buffer_stack (void) if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; + yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc @@ -1648,7 +1631,7 @@ static void yyensure_buffer_stack (void) * @param base the character buffer * @param size the size in bytes of the character buffer * - * @return the newly allocated buffer state object. + * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { @@ -1658,23 +1641,23 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ - return 0; + return NULL; - b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; - b->yy_input_file = 0; + b->yy_input_file = NULL; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - yy_switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } @@ -1687,10 +1670,10 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */ -YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return yy_scan_bytes(yystr,strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /** Setup the input buffer state to scan the given bytes. The next call to yylex() will @@ -1700,15 +1683,15 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; yy_size_t n, i; /* Get memory for full buffer, including space for trailing EOB's. */ - n = _yybytes_len + 2; - buf = (char *) yyalloc(n ); + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); @@ -1717,7 +1700,7 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = yy_scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); @@ -1733,9 +1716,9 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len #define YY_EXIT_FAILURE 2 #endif -static void yy_fatal_error (yyconst char* msg ) +static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -1763,7 +1746,7 @@ static void yy_fatal_error (yyconst char* msg ) */ int yyget_lineno (void) { - + return yylineno; } @@ -1786,7 +1769,7 @@ FILE *yyget_out (void) /** Get the length of the current token. * */ -yy_size_t yyget_leng (void) +int yyget_leng (void) { return yyleng; } @@ -1801,29 +1784,29 @@ char *yyget_text (void) } /** Set the current line number. - * @param line_number + * @param _line_number line number * */ -void yyset_lineno (int line_number ) +void yyset_lineno (int _line_number ) { - yylineno = line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. - * @param in_str A readable stream. + * @param _in_str A readable stream. * * @see yy_switch_to_buffer */ -void yyset_in (FILE * in_str ) +void yyset_in (FILE * _in_str ) { - yyin = in_str ; + yyin = _in_str ; } -void yyset_out (FILE * out_str ) +void yyset_out (FILE * _out_str ) { - yyout = out_str ; + yyout = _out_str ; } int yyget_debug (void) @@ -1831,9 +1814,9 @@ int yyget_debug (void) return yy_flex_debug; } -void yyset_debug (int bdebug ) +void yyset_debug (int _bdebug ) { - yy_flex_debug = bdebug ; + yy_flex_debug = _bdebug ; } static int yy_init_globals (void) @@ -1842,10 +1825,10 @@ static int yy_init_globals (void) * This function is called from yylex_destroy(), so don't allocate here. */ - (yy_buffer_stack) = 0; + (yy_buffer_stack) = NULL; (yy_buffer_stack_top) = 0; (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = (char *) 0; + (yy_c_buf_p) = NULL; (yy_init) = 0; (yy_start) = 0; @@ -1854,8 +1837,8 @@ static int yy_init_globals (void) yyin = stdin; yyout = stdout; #else - yyin = (FILE *) 0; - yyout = (FILE *) 0; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by @@ -1870,7 +1853,7 @@ int yylex_destroy (void) /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - yy_delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; yypop_buffer_state(); } @@ -1891,18 +1874,19 @@ int yylex_destroy (void) */ #ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +static void yy_flex_strncpy (char* s1, const char * s2, int n ) { - register int i; + + int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * s ) +static int yy_flex_strlen (const char * s ) { - register int n; + int n; for ( n = 0; s[n]; ++n ) ; @@ -1912,11 +1896,12 @@ static int yy_flex_strlen (yyconst char * s ) void *yyalloc (yy_size_t size ) { - return (void *) malloc( size ); + return malloc(size); } void *yyrealloc (void * ptr, yy_size_t size ) { + /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -1924,18 +1909,17 @@ void *yyrealloc (void * ptr, yy_size_t size ) * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ - return (void *) realloc( (char *) ptr, size ); + return realloc(ptr, size); } void yyfree (void * ptr ) { - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" -#line 197 "src/IceGrid/Scanner.l" - +#line 171 "src/IceGrid/Scanner.l" namespace IceGrid { @@ -1947,46 +1931,48 @@ namespace IceGrid { void initScanner() { - keywordMap["help"] = ICE_GRID_HELP; - keywordMap["quit"] = ICE_GRID_EXIT; - keywordMap["exit"] = ICE_GRID_EXIT; - keywordMap["application"] = ICE_GRID_APPLICATION; - keywordMap["server"] = ICE_GRID_SERVER; - keywordMap["adapter"] = ICE_GRID_ADAPTER; - keywordMap["add"] = ICE_GRID_ADD; - keywordMap["remove"] = ICE_GRID_REMOVE; - keywordMap["list"] = ICE_GRID_LIST; - keywordMap["shutdown"] = ICE_GRID_SHUTDOWN; - keywordMap["describe"] = ICE_GRID_DESCRIBE; - keywordMap["properties"] = ICE_GRID_PROPERTIES; - keywordMap["property"] = ICE_GRID_PROPERTY; - keywordMap["state"] = ICE_GRID_STATE; - keywordMap["pid"] = ICE_GRID_PID; - keywordMap["endpoints"] = ICE_GRID_ENDPOINTS; - keywordMap["start"] = ICE_GRID_START; - keywordMap["stop"] = ICE_GRID_STOP; - keywordMap["signal"] = ICE_GRID_SIGNAL; - keywordMap["stdout"] = ICE_GRID_STDOUT; - keywordMap["stderr"] = ICE_GRID_STDERR; - keywordMap["node"] = ICE_GRID_NODE; - keywordMap["registry"] = ICE_GRID_REGISTRY; - keywordMap["ping"] = ICE_GRID_PING; - keywordMap["load"] = ICE_GRID_LOAD; - keywordMap["processors"] = ICE_GRID_SOCKETS; - keywordMap["sockets"] = ICE_GRID_SOCKETS; - keywordMap["activation"] = ICE_GRID_ACTIVATION; - keywordMap["object"] = ICE_GRID_OBJECT; - keywordMap["find"] = ICE_GRID_FIND; - keywordMap["show"] = ICE_GRID_SHOW; - keywordMap["copying"] = ICE_GRID_COPYING; - keywordMap["warranty"] = ICE_GRID_WARRANTY; - keywordMap["diff"] = ICE_GRID_DIFF; - keywordMap["update"] = ICE_GRID_UPDATE; - keywordMap["instantiate"] = ICE_GRID_INSTANTIATE; - keywordMap["template"] = ICE_GRID_TEMPLATE; - keywordMap["service"] = ICE_GRID_SERVICE; - keywordMap["enable"] = ICE_GRID_ENABLE; - keywordMap["disable"] = ICE_GRID_DISABLE; + keywordMap = { + {"help", ICE_GRID_HELP}, + {"quit", ICE_GRID_EXIT}, + {"exit", ICE_GRID_EXIT}, + {"application", ICE_GRID_APPLICATION}, + {"server", ICE_GRID_SERVER}, + {"adapter", ICE_GRID_ADAPTER}, + {"add", ICE_GRID_ADD}, + {"remove", ICE_GRID_REMOVE}, + {"list", ICE_GRID_LIST}, + {"shutdown", ICE_GRID_SHUTDOWN}, + {"describe", ICE_GRID_DESCRIBE}, + {"properties", ICE_GRID_PROPERTIES}, + {"property", ICE_GRID_PROPERTY}, + {"state", ICE_GRID_STATE}, + {"pid", ICE_GRID_PID}, + {"endpoints", ICE_GRID_ENDPOINTS}, + {"start", ICE_GRID_START}, + {"stop", ICE_GRID_STOP}, + {"signal", ICE_GRID_SIGNAL}, + {"stdout", ICE_GRID_STDOUT}, + {"stderr", ICE_GRID_STDERR}, + {"node", ICE_GRID_NODE}, + {"registry", ICE_GRID_REGISTRY}, + {"ping", ICE_GRID_PING}, + {"load", ICE_GRID_LOAD}, + {"processors", ICE_GRID_SOCKETS}, + {"sockets", ICE_GRID_SOCKETS}, + {"activation", ICE_GRID_ACTIVATION}, + {"object", ICE_GRID_OBJECT}, + {"find", ICE_GRID_FIND}, + {"show", ICE_GRID_SHOW}, + {"copying", ICE_GRID_COPYING}, + {"warranty", ICE_GRID_WARRANTY}, + {"diff", ICE_GRID_DIFF}, + {"update", ICE_GRID_UPDATE}, + {"instantiate", ICE_GRID_INSTANTIATE}, + {"template", ICE_GRID_TEMPLATE}, + {"service", ICE_GRID_SERVICE}, + {"enable", ICE_GRID_ENABLE}, + {"disable", ICE_GRID_DISABLE} + }; } std::string diff --git a/cpp/src/IceGrid/Scanner.l b/cpp/src/IceGrid/Scanner.l index c3287b086e0..0a0e0c0a158 100644 --- a/cpp/src/IceGrid/Scanner.l +++ b/cpp/src/IceGrid/Scanner.l @@ -1,31 +1,17 @@ -%{ - +%top{ // // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <Ice/Ice.h> -#include <IceGrid/Parser.h> -#include <IceGrid/Grammar.h> +#include <IceUtil/ScannerConfig.h> -#if defined(_MSC_VER) -// '<' : signed/unsigned mismatch -# pragma warning(disable:4018) -// 'initializing' : conversion from '__int64' to 'int', possible loss of data -# pragma warning(disable:4244) +} -# if defined(ICE_64) -// -// '=' : conversion from 'size_t' to 'int', possible loss of data -// The result of fread() is a size_t and gets inserted into an int -// -# pragma warning(disable:4267) -# endif -#endif +%{ -#if defined(__GNUC__) -# pragma GCC diagnostic ignored "-Wsign-compare" -#endif +#include <Ice/Ice.h> +#include <IceGrid/Parser.h> +#include <IceGrid/Grammar.h> using namespace std; using namespace Ice; @@ -36,17 +22,6 @@ using namespace IceGrid; # undef yywrap # define yywrap() 1 # endif -# define YY_NO_UNISTD_H -#endif - -#ifdef __SUNPRO_CC -# ifdef yywrap -# undef yywrap -# define yywrap() 1 -# endif -# ifdef ICE_64 -# pragma error_messages(off,truncwarn) -# endif #endif #define YY_INPUT(buf, result, maxSize) parser->getInput(buf, result, maxSize) @@ -54,8 +29,7 @@ using namespace IceGrid; namespace IceGrid { -typedef std::map<std::string, int> StringTokenMap; -static StringTokenMap keywordMap; +static std::map<std::string, int> keywordMap; void initScanner(); std::string parseDoubleQuotedString(); @@ -190,7 +164,7 @@ keyword [[:alpha:]]* yylvalp->clear(); yylvalp->push_back(s); - StringTokenMap::const_iterator pos = keywordMap.find(s); + const auto pos = keywordMap.find(s); return pos != keywordMap.end() ? pos->second : ICE_GRID_STRING; } @@ -205,46 +179,48 @@ namespace IceGrid { void initScanner() { - keywordMap["help"] = ICE_GRID_HELP; - keywordMap["quit"] = ICE_GRID_EXIT; - keywordMap["exit"] = ICE_GRID_EXIT; - keywordMap["application"] = ICE_GRID_APPLICATION; - keywordMap["server"] = ICE_GRID_SERVER; - keywordMap["adapter"] = ICE_GRID_ADAPTER; - keywordMap["add"] = ICE_GRID_ADD; - keywordMap["remove"] = ICE_GRID_REMOVE; - keywordMap["list"] = ICE_GRID_LIST; - keywordMap["shutdown"] = ICE_GRID_SHUTDOWN; - keywordMap["describe"] = ICE_GRID_DESCRIBE; - keywordMap["properties"] = ICE_GRID_PROPERTIES; - keywordMap["property"] = ICE_GRID_PROPERTY; - keywordMap["state"] = ICE_GRID_STATE; - keywordMap["pid"] = ICE_GRID_PID; - keywordMap["endpoints"] = ICE_GRID_ENDPOINTS; - keywordMap["start"] = ICE_GRID_START; - keywordMap["stop"] = ICE_GRID_STOP; - keywordMap["signal"] = ICE_GRID_SIGNAL; - keywordMap["stdout"] = ICE_GRID_STDOUT; - keywordMap["stderr"] = ICE_GRID_STDERR; - keywordMap["node"] = ICE_GRID_NODE; - keywordMap["registry"] = ICE_GRID_REGISTRY; - keywordMap["ping"] = ICE_GRID_PING; - keywordMap["load"] = ICE_GRID_LOAD; - keywordMap["processors"] = ICE_GRID_SOCKETS; - keywordMap["sockets"] = ICE_GRID_SOCKETS; - keywordMap["activation"] = ICE_GRID_ACTIVATION; - keywordMap["object"] = ICE_GRID_OBJECT; - keywordMap["find"] = ICE_GRID_FIND; - keywordMap["show"] = ICE_GRID_SHOW; - keywordMap["copying"] = ICE_GRID_COPYING; - keywordMap["warranty"] = ICE_GRID_WARRANTY; - keywordMap["diff"] = ICE_GRID_DIFF; - keywordMap["update"] = ICE_GRID_UPDATE; - keywordMap["instantiate"] = ICE_GRID_INSTANTIATE; - keywordMap["template"] = ICE_GRID_TEMPLATE; - keywordMap["service"] = ICE_GRID_SERVICE; - keywordMap["enable"] = ICE_GRID_ENABLE; - keywordMap["disable"] = ICE_GRID_DISABLE; + keywordMap = { + {"help", ICE_GRID_HELP}, + {"quit", ICE_GRID_EXIT}, + {"exit", ICE_GRID_EXIT}, + {"application", ICE_GRID_APPLICATION}, + {"server", ICE_GRID_SERVER}, + {"adapter", ICE_GRID_ADAPTER}, + {"add", ICE_GRID_ADD}, + {"remove", ICE_GRID_REMOVE}, + {"list", ICE_GRID_LIST}, + {"shutdown", ICE_GRID_SHUTDOWN}, + {"describe", ICE_GRID_DESCRIBE}, + {"properties", ICE_GRID_PROPERTIES}, + {"property", ICE_GRID_PROPERTY}, + {"state", ICE_GRID_STATE}, + {"pid", ICE_GRID_PID}, + {"endpoints", ICE_GRID_ENDPOINTS}, + {"start", ICE_GRID_START}, + {"stop", ICE_GRID_STOP}, + {"signal", ICE_GRID_SIGNAL}, + {"stdout", ICE_GRID_STDOUT}, + {"stderr", ICE_GRID_STDERR}, + {"node", ICE_GRID_NODE}, + {"registry", ICE_GRID_REGISTRY}, + {"ping", ICE_GRID_PING}, + {"load", ICE_GRID_LOAD}, + {"processors", ICE_GRID_SOCKETS}, + {"sockets", ICE_GRID_SOCKETS}, + {"activation", ICE_GRID_ACTIVATION}, + {"object", ICE_GRID_OBJECT}, + {"find", ICE_GRID_FIND}, + {"show", ICE_GRID_SHOW}, + {"copying", ICE_GRID_COPYING}, + {"warranty", ICE_GRID_WARRANTY}, + {"diff", ICE_GRID_DIFF}, + {"update", ICE_GRID_UPDATE}, + {"instantiate", ICE_GRID_INSTANTIATE}, + {"template", ICE_GRID_TEMPLATE}, + {"service", ICE_GRID_SERVICE}, + {"enable", ICE_GRID_ENABLE}, + {"disable", ICE_GRID_DISABLE} + }; } std::string diff --git a/cpp/src/IceGrid/ServerAdapterI.cpp b/cpp/src/IceGrid/ServerAdapterI.cpp index ef2e664cfbb..4ce13b38c79 100644 --- a/cpp/src/IceGrid/ServerAdapterI.cpp +++ b/cpp/src/IceGrid/ServerAdapterI.cpp @@ -11,10 +11,10 @@ using namespace std; using namespace IceGrid; -ServerAdapterI::ServerAdapterI(const NodeIPtr& node, +ServerAdapterI::ServerAdapterI(const shared_ptr<NodeI>& node, ServerI* server, const string& serverName, - const AdapterPrx& proxy, + const shared_ptr<AdapterPrx>& proxy, const string& id, bool enabled) : _node(node), @@ -32,16 +32,18 @@ ServerAdapterI::~ServerAdapterI() } void -ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Current&) +ServerAdapterI::activateAsync(function<void(const shared_ptr<Ice::ObjectPrx>&)> response, + function<void(exception_ptr)>, + const Ice::Current&) { { - Lock sync(*this); + lock_guard lock(_mutex); if(_enabled && _proxy) { // // Return the adapter direct proxy. // - cb->ice_response(_proxy); + response(_proxy); return; } else if(_activateCB.empty()) @@ -52,7 +54,7 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur // if(!_enabled || !_server->isAdapterActivatable(_id)) { - cb->ice_response(0); + response(nullptr); return; } } @@ -63,13 +65,13 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur out << "waiting for activation of server `" + _serverId + "' adapter `" << _id << "'"; } - _activateCB.push_back(cb); + _activateCB.push_back(response); if(_activateCB.size() > 1) { return; } - _activateAfterDeactivating = _server->getState(Ice::emptyCurrent) >= Deactivating && - _server->getState(Ice::emptyCurrent) < Destroying; + _activateAfterDeactivating = _server->getState(Ice::emptyCurrent) >= ServerState::Deactivating && + _server->getState(Ice::emptyCurrent) < ServerState::Destroying; } // @@ -79,7 +81,7 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur // try { - _server->start(ServerI::OnDemand); + _server->start(ServerI::ServerActivation::OnDemand); return; } catch(const ServerStartException& ex) @@ -102,10 +104,10 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur } } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> ServerAdapterI::getDirectProxy(const Ice::Current&) const { - Lock sync(*this); + lock_guard lock(_mutex); // // Return the adapter direct proxy if it's set. Otherwise, throw. The caller can eventually @@ -122,9 +124,9 @@ ServerAdapterI::getDirectProxy(const Ice::Current&) const } void -ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&) +ServerAdapterI::setDirectProxy(shared_ptr<Ice::ObjectPrx> prx, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); // // We don't allow to override an existing proxy by another non @@ -134,7 +136,7 @@ ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&) { if(prx && _proxy) { - if(_server->getState(Ice::emptyCurrent) == Active) + if(_server->getState(Ice::emptyCurrent) == ServerState::Active) { throw AdapterActiveException(); } @@ -142,7 +144,7 @@ ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&) } bool updated = _proxy != prx; - _proxy = prx; + _proxy = move(prx); // // If the server is being deactivated and the activation callback @@ -150,22 +152,19 @@ ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&) // now. The server is going to be activated again and the adapter // activated. // - if(_server->getState(Ice::emptyCurrent) < Deactivating || - _server->getState(Ice::emptyCurrent) >= Destroying || !_activateAfterDeactivating) + if(_server->getState(Ice::emptyCurrent) < ServerState::Deactivating || + _server->getState(Ice::emptyCurrent) >= ServerState::Destroying || !_activateAfterDeactivating) { - for(vector<AMD_Adapter_activatePtr>::const_iterator p = _activateCB.begin(); p != _activateCB.end(); ++p) + for(const auto& response : _activateCB) { - (*p)->ice_response(_proxy); + response(_proxy); } _activateCB.clear(); } if(updated) { - AdapterDynamicInfo info; - info.id = _id; - info.proxy = _proxy; - _node->observerUpdateAdapter(info); + _node->observerUpdateAdapter({ _id, _proxy }); } if(_proxy) @@ -205,15 +204,15 @@ ServerAdapterI::destroy() void ServerAdapterI::updateEnabled() { - Lock sync(*this); + lock_guard lock(_mutex); _enabled = _server->isEnabled(Ice::emptyCurrent); } void ServerAdapterI::clear() { - Lock sync(*this); - _proxy = 0; + lock_guard lock(_mutex); + _proxy = nullptr; _activateAfterDeactivating = false; } @@ -230,10 +229,10 @@ ServerAdapterI::activationFailed(const std::string& reason) out << "server `" + _serverId + "' adapter `" << _id << "' activation failed: " << reason; } - Lock sync(*this); - for(vector<AMD_Adapter_activatePtr>::const_iterator p = _activateCB.begin(); p != _activateCB.end(); ++p) + lock_guard lock(_mutex); + for(const auto& response : _activateCB) { - (*p)->ice_response(0); + response(nullptr); } _activateCB.clear(); } @@ -241,7 +240,7 @@ ServerAdapterI::activationFailed(const std::string& reason) void ServerAdapterI::activationCompleted() { - Lock sync(*this); + lock_guard lock(_mutex); if(!_proxy) { // @@ -254,14 +253,14 @@ ServerAdapterI::activationCompleted() } } - for(vector<AMD_Adapter_activatePtr>::const_iterator p = _activateCB.begin(); p != _activateCB.end(); ++p) + for(const auto& response : _activateCB) { - (*p)->ice_response(_proxy); + response(_proxy); } _activateCB.clear(); } -AdapterPrx +shared_ptr<AdapterPrx> ServerAdapterI::getProxy() const { return _this; diff --git a/cpp/src/IceGrid/ServerAdapterI.h b/cpp/src/IceGrid/ServerAdapterI.h index ce818a7f8cc..28805919ae3 100644 --- a/cpp/src/IceGrid/ServerAdapterI.h +++ b/cpp/src/IceGrid/ServerAdapterI.h @@ -5,50 +5,52 @@ #ifndef ICE_GRID_SERVER_ADAPTER_I_H #define ICE_GRID_SERVER_ADAPTER_I_H -#include <IceUtil/Mutex.h> #include <IceGrid/Internal.h> namespace IceGrid { class NodeI; -typedef IceUtil::Handle<NodeI> NodeIPtr; - class ServerI; -class ServerAdapterI : public Adapter, public IceUtil::Mutex +class ServerAdapterI : public Adapter { public: - ServerAdapterI(const NodeIPtr&, ServerI*, const std::string&, const AdapterPrx&, const std::string&, bool); - virtual ~ServerAdapterI(); + ServerAdapterI(const std::shared_ptr<NodeI>&, ServerI*, const std::string&, + const std::shared_ptr<AdapterPrx>&, const std::string&, bool); + ~ServerAdapterI() override; + + void activateAsync(std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>, + std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + std::shared_ptr<Ice::ObjectPrx> getDirectProxy(const Ice::Current&) const override; + void setDirectProxy(std::shared_ptr<Ice::ObjectPrx>, const ::Ice::Current&) override; - virtual void activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Current&); - virtual Ice::ObjectPrx getDirectProxy(const Ice::Current&) const; - virtual void setDirectProxy(const ::Ice::ObjectPrx&, const ::Ice::Current&); void destroy(); void updateEnabled(); void clear(); void activationFailed(const std::string&); void activationCompleted(); - AdapterPrx getProxy() const; + std::shared_ptr<AdapterPrx> getProxy() const; private: - const NodeIPtr _node; - const AdapterPrx _this; + const std::shared_ptr<NodeI> _node; + const std::shared_ptr<AdapterPrx> _this; const std::string _serverId; const std::string _id; const std::string _replicaId; ServerI* _server; - Ice::ObjectPrx _proxy; + std::shared_ptr<Ice::ObjectPrx> _proxy; bool _enabled; - std::vector<AMD_Adapter_activatePtr> _activateCB; + std::vector<std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>> _activateCB; bool _activateAfterDeactivating; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<ServerAdapterI> ServerAdapterIPtr; } diff --git a/cpp/src/IceGrid/ServerCache.cpp b/cpp/src/IceGrid/ServerCache.cpp index 725b0b08757..64365ace22d 100644 --- a/cpp/src/IceGrid/ServerCache.cpp +++ b/cpp/src/IceGrid/ServerCache.cpp @@ -14,68 +14,17 @@ #include <IceGrid/SessionI.h> #include <IceGrid/DescriptorHelper.h> #include <IceGrid/Topics.h> +#include <IceGrid/Internal.h> using namespace std; using namespace IceGrid; -namespace IceGrid -{ - - struct AddCommunicator : std::unary_function<CommunicatorDescriptorPtr&, void> - { - AddCommunicator(ServerCache& serverCache, const ServerEntryPtr& entry, const string& application) : - _serverCache(serverCache), _entry(entry), _application(application) - { - } - - void - operator()(const CommunicatorDescriptorPtr& desc) - { - _serverCache.addCommunicator(0, desc, _entry, _application); - } - - void - operator()(const CommunicatorDescriptorPtr& oldDesc, const CommunicatorDescriptorPtr& newDesc) - { - _serverCache.addCommunicator(oldDesc, newDesc, _entry, _application); - } - - ServerCache& _serverCache; - const ServerEntryPtr _entry; - const string _application; - }; - - struct RemoveCommunicator : std::unary_function<CommunicatorDescriptorPtr&, void> - { - RemoveCommunicator(ServerCache& serverCache, const ServerEntryPtr& entry) : - _serverCache(serverCache), _entry(entry) - { - } - - void - operator()(const CommunicatorDescriptorPtr& desc) - { - _serverCache.removeCommunicator(desc, 0, _entry); - } - - void - operator()(const CommunicatorDescriptorPtr& oldDesc, const CommunicatorDescriptorPtr& newDesc) - { - _serverCache.removeCommunicator(oldDesc, newDesc, _entry); - } - - ServerCache& _serverCache; - const ServerEntryPtr _entry; - }; - -} - CheckUpdateResult::CheckUpdateResult(const string& server, const string& node, bool noRestart, bool remove, - const Ice::AsyncResultPtr& result) : - _server(server), _node(node), _remove(remove), _noRestart(noRestart), _result(result) + future<bool>&& result) : + _server(server), _node(node), _remove(remove), _noRestart(noRestart), _result(move(result)) { } @@ -84,7 +33,7 @@ CheckUpdateResult::getResult() { try { - return ServerPrx::uncheckedCast(_result->getProxy())->end_checkUpdate(_result); + return _result.get(); } catch(const DeploymentException& ex) { @@ -115,7 +64,7 @@ CheckUpdateResult::getResult() } } -ServerCache::ServerCache(const Ice::CommunicatorPtr& communicator, +ServerCache::ServerCache(const shared_ptr<Ice::Communicator>& communicator, const string& instanceName, NodeCache& nodeCache, AdapterCache& adapterCache, @@ -130,22 +79,25 @@ ServerCache::ServerCache(const Ice::CommunicatorPtr& communicator, { } -ServerEntryPtr +shared_ptr<ServerEntry> ServerCache::add(const ServerInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); - ServerEntryPtr entry = getImpl(info.descriptor->id); + auto entry = getImpl(info.descriptor->id); if(!entry) { - entry = new ServerEntry(*this, info.descriptor->id); + entry = make_shared<ServerEntry>(*this, info.descriptor->id); addImpl(info.descriptor->id, entry); } entry->update(info, false); _nodeCache.get(info.node, true)->addServer(entry); - forEachCommunicator(AddCommunicator(*this, entry, info.application))(info.descriptor); + forEachCommunicator(info.descriptor, [this, entry, application = info.application](const auto& descriptor) + { + addCommunicator(nullptr, descriptor, entry, application); + }); if(_traceLevels && _traceLevels->server > 0) { @@ -156,11 +108,11 @@ ServerCache::add(const ServerInfo& info) return entry; } -ServerEntryPtr +shared_ptr<ServerEntry> ServerCache::get(const string& id) const { - Lock sync(*this); - ServerEntryPtr entry = getImpl(id); + lock_guard lock(_mutex); + auto entry = getImpl(id); if(!entry) { throw ServerNotExistException(id); @@ -171,22 +123,24 @@ ServerCache::get(const string& id) const bool ServerCache::has(const string& id) const { - Lock sync(*this); - ServerEntryPtr entry = getImpl(id); + lock_guard lock(_mutex); + auto entry = getImpl(id); return entry && !entry->isDestroyed(); } -ServerEntryPtr +shared_ptr<ServerEntry> ServerCache::remove(const string& id, bool noRestart) { - Lock sync(*this); + lock_guard lock(_mutex); - ServerEntryPtr entry = getImpl(id); + auto entry = getImpl(id); assert(entry); ServerInfo info = entry->getInfo(); - forEachCommunicator(RemoveCommunicator(*this, entry))(info.descriptor); - + forEachCommunicator(info.descriptor, [this, entry](const auto& desc) + { + removeCommunicator(desc, nullptr, entry); + }); _nodeCache.get(info.node)->removeServer(entry); entry->destroy(noRestart); // This must be done after otherwise some allocatable objects @@ -204,16 +158,19 @@ ServerCache::remove(const string& id, bool noRestart) void ServerCache::preUpdate(const ServerInfo& newInfo, bool noRestart) { - Lock sync(*this); + lock_guard lock(_mutex); const string& id = newInfo.descriptor->id; - ServerEntryPtr entry = getImpl(id); + auto entry = getImpl(id); assert(entry); if(!noRestart) { ServerInfo info = entry->getInfo(); - forEachCommunicator(RemoveCommunicator(*this, entry))(info.descriptor, newInfo.descriptor); + forEachCommunicator(info.descriptor, newInfo.descriptor, [this, entry](const auto& oldDesc, const auto& newDesc) + { + removeCommunicator(oldDesc, newDesc, entry); + }); _nodeCache.get(info.node)->removeServer(entry); } @@ -228,12 +185,12 @@ ServerCache::preUpdate(const ServerInfo& newInfo, bool noRestart) } } -ServerEntryPtr +shared_ptr<ServerEntry> ServerCache::postUpdate(const ServerInfo& info, bool noRestart) { - Lock sync(*this); + lock_guard lock(_mutex); - ServerEntryPtr entry = getImpl(info.descriptor->id); + auto entry = getImpl(info.descriptor->id); assert(entry); ServerInfo oldInfo = entry->getInfo(); @@ -242,7 +199,12 @@ ServerCache::postUpdate(const ServerInfo& info, bool noRestart) if(!noRestart) { _nodeCache.get(info.node, true)->addServer(entry); - forEachCommunicator(AddCommunicator(*this, entry, info.application))(oldInfo.descriptor, info.descriptor); + + forEachCommunicator(oldInfo.descriptor, info.descriptor, + [this, entry, application = info.application](const auto& oldDesc, const auto& newDesc) + { + addCommunicator(oldDesc, newDesc, entry, application); + }); } if(_traceLevels && _traceLevels->server > 0) @@ -257,20 +219,20 @@ ServerCache::postUpdate(const ServerInfo& info, bool noRestart) void ServerCache::clear(const string& id) { - Lock sync(*this); + lock_guard lock(_mutex); CacheByString<ServerEntry>::removeImpl(id); } void -ServerCache::setNodeObserverTopic(const NodeObserverTopicPtr& nodeObserverTopic) +ServerCache::setNodeObserverTopic(const shared_ptr<NodeObserverTopic>& nodeObserverTopic) { _nodeObserverTopic = nodeObserverTopic; } void -ServerCache::addCommunicator(const CommunicatorDescriptorPtr& oldDesc, - const CommunicatorDescriptorPtr& newDesc, - const ServerEntryPtr& server, +ServerCache::addCommunicator(const shared_ptr<CommunicatorDescriptor>& oldDesc, + const shared_ptr<CommunicatorDescriptor>& newDesc, + const shared_ptr<ServerEntry>& server, const string& application) { if(!newDesc) @@ -311,9 +273,9 @@ ServerCache::addCommunicator(const CommunicatorDescriptorPtr& oldDesc, } void -ServerCache::removeCommunicator(const CommunicatorDescriptorPtr& oldDesc, - const CommunicatorDescriptorPtr& newDesc, - const ServerEntryPtr& /*entry*/) +ServerCache::removeCommunicator(const shared_ptr<CommunicatorDescriptor>& oldDesc, + const shared_ptr<CommunicatorDescriptor>& newDesc, + const shared_ptr<ServerEntry>&) { if(!oldDesc) { @@ -353,7 +315,7 @@ ServerCache::removeCommunicator(const CommunicatorDescriptorPtr& oldDesc, } ServerEntry::ServerEntry(ServerCache& cache, const string& id) : - Allocatable(false, 0), + Allocatable(false, nullptr), _cache(cache), _id(id), _activationTimeout(-1), @@ -371,13 +333,13 @@ ServerEntry::sync() } void -ServerEntry::waitForSync(int timeout) +ServerEntry::waitForSync(chrono::seconds timeout) { - waitImpl(timeout); + waitImpl(move(timeout)); } void -ServerEntry::waitForSyncNoThrow(int timeout) +ServerEntry::waitForSyncNoThrow(chrono::seconds timeout) { try { @@ -385,7 +347,7 @@ ServerEntry::waitForSyncNoThrow(int timeout) } catch(const SynchronizationException&) { - assert(timeout >= 0); + assert(timeout >= 0s); } catch(const Ice::Exception&) { @@ -395,21 +357,21 @@ ServerEntry::waitForSyncNoThrow(int timeout) void ServerEntry::unsync() { - Lock sync(*this); + lock_guard lock(_mutex); if(_loaded.get()) { _load.reset(_loaded.release()); } - _proxy = 0; + _proxy = nullptr; _adapters.clear(); - _activationTimeout = -1; - _deactivationTimeout = -1; + _activationTimeout = -1s; + _deactivationTimeout = -1s; } bool -ServerEntry::addSyncCallback(const SynchronizationCallbackPtr& callback) +ServerEntry::addSyncCallback(const shared_ptr<SynchronizationCallback>& callback) { - Lock sync(*this); + lock_guard lock(_mutex); if(!_loaded.get() && !_load.get()) { throw ServerNotExistException(); @@ -424,10 +386,9 @@ ServerEntry::addSyncCallback(const SynchronizationCallbackPtr& callback) void ServerEntry::update(const ServerInfo& info, bool noRestart) { - Lock sync(*this); + lock_guard lock(_mutex); - IceInternal::UniquePtr<ServerInfo> descriptor(new ServerInfo()); - *descriptor = info; + auto descriptor = make_unique<ServerInfo>(info); _updated = true; @@ -457,7 +418,7 @@ ServerEntry::update(const ServerInfo& info, bool noRestart) void ServerEntry::destroy(bool noRestart) { - Lock sync(*this); + lock_guard lock(_mutex); _updated = true; @@ -486,9 +447,9 @@ ServerInfo ServerEntry::getInfo(bool resolve) const { ServerInfo info; - SessionIPtr session; + shared_ptr<SessionI> session; { - Lock sync(*this); + lock_guard lock(_mutex); if(!_loaded.get() && !_load.get()) { throw ServerNotExistException(); @@ -522,21 +483,22 @@ ServerEntry::getId() const return _id; } -ServerPrx -ServerEntry::getProxy(bool upToDate, int timeout) +shared_ptr<ServerPrx> +ServerEntry::getProxy(bool upToDate, chrono::seconds timeout) { // // NOTE: this might throw ServerNotExistException, NodeUnreachableException // or DeploymentException. // - int actTimeout, deactTimeout; + chrono::seconds actTimeout, deactTimeout; string node; return getProxy(actTimeout, deactTimeout, node, upToDate, timeout); } -ServerPrx -ServerEntry::getProxy(int& activationTimeout, int& deactivationTimeout, string& node, bool upToDate, int timeout) +shared_ptr<ServerPrx> +ServerEntry::getProxy(chrono::seconds& activationTimeout, chrono::seconds& deactivationTimeout, string& node, + bool upToDate, chrono::seconds timeout) { // // NOTE: this might throw ServerNotExistException, NodeUnreachableException @@ -545,7 +507,7 @@ ServerEntry::getProxy(int& activationTimeout, int& deactivationTimeout, string& while(true) { { - Lock sync(*this); + lock_guard lock(_mutex); if(_loaded.get() || (_proxy && _synchronizing && !upToDate)) // Synced or if not up to date is fine { assert(_loaded.get() || _load.get() || _destroy.get()); @@ -565,19 +527,16 @@ ServerEntry::getProxy(int& activationTimeout, int& deactivationTimeout, string& } } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> ServerEntry::getAdminProxy() { // // The category must match the server admin category used by nodes // - Ice::Identity adminId; - adminId.name = _id; - adminId.category = _cache.getInstanceName() + "-NodeServerAdminRouter"; - return getProxy(true)->ice_identity(adminId); + return getProxy(true)->ice_identity({ _id, _cache.getInstanceName() + "-NodeServerAdminRouter" }); } -AdapterPrx +shared_ptr<AdapterPrx> ServerEntry::getAdapter(const string& id, bool upToDate) { // @@ -585,12 +544,13 @@ ServerEntry::getAdapter(const string& id, bool upToDate) // or DeploymentException. // - int activationTimeout, deactivationTimeout; + chrono::seconds activationTimeout, deactivationTimeout; return getAdapter(activationTimeout, deactivationTimeout, id, upToDate); } -AdapterPrx -ServerEntry::getAdapter(int& activationTimeout, int& deactivationTimeout, const string& id, bool upToDate) +shared_ptr<AdapterPrx> +ServerEntry::getAdapter(chrono::seconds& activationTimeout, chrono::seconds& deactivationTimeout, const string& id, + bool upToDate) { // // NOTE: this might throw AdapterNotExistException, NodeUnreachableException @@ -599,8 +559,8 @@ ServerEntry::getAdapter(int& activationTimeout, int& deactivationTimeout, const while(true) { { - Lock sync(*this); - if(_loaded.get() || (_proxy && _synchronizing && !upToDate)) // Synced or if not up to date is fine + lock_guard lock(_mutex); + if(_loaded || (_proxy && _synchronizing && !upToDate)) // Synced or if not up to date is fine { AdapterPrxDict::const_iterator p = _adapters.find(id); if(p != _adapters.end()) @@ -615,14 +575,14 @@ ServerEntry::getAdapter(int& activationTimeout, int& deactivationTimeout, const throw AdapterNotExistException(id); } } - else if(!_load.get() && !_destroy.get()) + else if(!_load && !_destroy) { throw AdapterNotExistException(id); } } syncImpl(); - waitImpl(0); // Don't wait, just check for the result or throw SynchronizationException + waitImpl(0s); // Don't wait, just check for the result or throw SynchronizationException } } @@ -632,7 +592,7 @@ ServerEntry::getLoad(LoadSample sample) const string application; string node; { - Lock sync(*this); + lock_guard lock(_mutex); if(_loaded.get()) { application = _loaded->application; @@ -653,11 +613,11 @@ ServerEntry::getLoad(LoadSample sample) const LoadInfo load = _cache.getNodeCache().get(node)->getLoadInfoAndLoadFactor(application, factor); switch(sample) { - case LoadSample1: + case LoadSample::LoadSample1: return load.avg1 < 0.f ? 1.0f : load.avg1 * factor; - case LoadSample5: + case LoadSample::LoadSample5: return load.avg5 < 0.f ? 1.0f : load.avg5 * factor; - case LoadSample15: + case LoadSample::LoadSample15: return load.avg15 < 0.f ? 1.0f : load.avg15 * factor; default: assert(false); @@ -669,13 +629,13 @@ void ServerEntry::syncImpl() { ServerInfo load; - SessionIPtr session; + shared_ptr<SessionI> session; ServerInfo destroy; - int timeout = -1; + auto timeout = -1s; bool noRestart = false; { - Lock sync(*this); + lock_guard lock(_mutex); if(_synchronizing) { return; @@ -687,7 +647,7 @@ ServerEntry::syncImpl() } _updated = false; - _exception.reset(0); + _exception = nullptr; if(_destroy.get()) { @@ -713,44 +673,44 @@ ServerEntry::syncImpl() { try { - _cache.getNodeCache().get(destroy.node)->destroyServer(this, destroy, timeout, noRestart); + _cache.getNodeCache().get(destroy.node)->destroyServer(static_pointer_cast<ServerEntry>(shared_from_this()), destroy, timeout, noRestart); } catch(const NodeNotExistException&) { - exception(NodeUnreachableException(destroy.node, "node is not active")); + exception(make_exception_ptr(NodeUnreachableException(destroy.node, "node is not active"))); } } else if(load.descriptor) { try { - _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout, noRestart); + _cache.getNodeCache().get(load.node)->loadServer(static_pointer_cast<ServerEntry>(shared_from_this()), load, session, timeout, noRestart); } catch(const NodeNotExistException&) { - exception(NodeUnreachableException(load.node, "node is not active")); + exception(make_exception_ptr(NodeUnreachableException(load.node, "node is not active"))); } } } void -ServerEntry::waitImpl(int timeout) +ServerEntry::waitImpl(chrono::seconds timeout) { - Lock sync(*this); - if(timeout != 0) + unique_lock lock(_mutex); + if(timeout != 0s) { while(_synchronizing) { - if(timeout > 0) + if(timeout > 0s) { - if(!timedWait(IceUtil::Time::seconds(timeout))) + if(_condVar.wait_for(lock, timeout) == cv_status::timeout) { break; // Timeout } } else { - wait(); + _condVar.wait(lock); } } } @@ -759,11 +719,11 @@ ServerEntry::waitImpl(int timeout) throw SynchronizationException(__FILE__, __LINE__); } - if(_exception.get()) + if(_exception) { try { - _exception->ice_throw(); + rethrow_exception(_exception); } catch(const DeploymentException&) { @@ -773,11 +733,11 @@ ServerEntry::waitImpl(int timeout) { throw; } - catch(const Ice::Exception& ex) // This shouln't happen. + catch(const Ice::Exception& ex) // This shouldn't happen. { ostringstream os; os << "unexpected exception while synchronizing server `" + _id + "':\n" << ex; - TraceLevelsPtr traceLevels = _cache.getTraceLevels(); + auto traceLevels = _cache.getTraceLevels(); if(traceLevels) { Ice::Error err(traceLevels->logger); @@ -791,18 +751,18 @@ ServerEntry::waitImpl(int timeout) void ServerEntry::synchronized() { - vector<SynchronizationCallbackPtr> callbacks; + vector<shared_ptr<SynchronizationCallback>> callbacks; { - Lock sync(*this); + lock_guard lock(_mutex); _callbacks.swap(callbacks); } - for(vector<SynchronizationCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p) + for(const auto& callback : callbacks) { try { - (*p)->synchronized(); + callback->synchronized(); } - catch(...) + catch(const std::exception&) { assert(false); } @@ -810,20 +770,20 @@ ServerEntry::synchronized() } void -ServerEntry::synchronized(const Ice::Exception& ex) +ServerEntry::synchronized(exception_ptr ex) { - vector<SynchronizationCallbackPtr> callbacks; + vector<shared_ptr<SynchronizationCallback>> callbacks; { - Lock sync(*this); + lock_guard lock(_mutex); _callbacks.swap(callbacks); } - for(vector<SynchronizationCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p) + for(const auto& callback : callbacks) { try { - (*p)->synchronized(ex); + callback->synchronized(ex); } - catch(...) + catch(const std::exception&) { assert(false); } @@ -831,17 +791,18 @@ ServerEntry::synchronized(const Ice::Exception& ex) } void -ServerEntry::loadCallback(const ServerPrx& proxy, const AdapterPrxDict& adpts, int at, int dt) +ServerEntry::loadCallback(const shared_ptr<ServerPrx>& proxy, const AdapterPrxDict& adpts, + chrono::seconds activationTimeout, chrono::seconds deactivationTimeout) { ServerInfo load; - SessionIPtr session; + shared_ptr<SessionI> session; ServerInfo destroy; - int timeout = -1; + chrono::seconds timeout = -1s; bool synced = false; bool noRestart = false; { - Lock sync(*this); + lock_guard lock(_mutex); if(!_updated) { // @@ -855,13 +816,13 @@ ServerEntry::loadCallback(const ServerPrx& proxy, const AdapterPrxDict& adpts, i _loaded.reset(_load.release()); _proxy = proxy; _adapters = adpts; - _activationTimeout = at; - _deactivationTimeout = dt; + _activationTimeout = activationTimeout; + _deactivationTimeout = deactivationTimeout; assert(!_destroy.get() && !_load.get()); _synchronizing = false; synced = true; - notifyAll(); + _condVar.notify_all(); } else { @@ -892,22 +853,22 @@ ServerEntry::loadCallback(const ServerPrx& proxy, const AdapterPrxDict& adpts, i { try { - _cache.getNodeCache().get(destroy.node)->destroyServer(this, destroy, timeout, noRestart); + _cache.getNodeCache().get(destroy.node)->destroyServer(static_pointer_cast<ServerEntry>(shared_from_this()), destroy, timeout, noRestart); } catch(const NodeNotExistException&) { - exception(NodeUnreachableException(destroy.node, "node is not active")); + exception(make_exception_ptr(NodeUnreachableException(destroy.node, "node is not active"))); } } else if(load.descriptor) { try { - _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout, noRestart); + _cache.getNodeCache().get(load.node)->loadServer(static_pointer_cast<ServerEntry>(shared_from_this()), load, session, timeout, noRestart); } catch(const NodeNotExistException&) { - exception(NodeUnreachableException(load.node, "node is not active")); + exception(make_exception_ptr(NodeUnreachableException(load.node, "node is not active"))); } } } @@ -917,21 +878,21 @@ ServerEntry::destroyCallback() { ServerInfo load; bool noRestart = false; - SessionIPtr session; + shared_ptr<SessionI> session; { - Lock sync(*this); - _destroy.reset(0); - _proxy = 0; + lock_guard lock(_mutex); + _destroy = nullptr; + _proxy = nullptr; _adapters.clear(); - _activationTimeout = -1; - _deactivationTimeout = -1; + _activationTimeout = -1s; + _deactivationTimeout = -1s; if(!_load.get()) { assert(!_load.get() && !_loaded.get()); _synchronizing = false; - notifyAll(); + _condVar.notify_all(); } else { @@ -946,11 +907,12 @@ ServerEntry::destroyCallback() { try { - _cache.getNodeCache().get(load.node)->loadServer(this, load, session, -1, noRestart); + _cache.getNodeCache().get(load.node)->loadServer(static_pointer_cast<ServerEntry>(shared_from_this()), load, + session, -1s, noRestart); } catch(const NodeNotExistException&) { - exception(NodeUnreachableException(load.node, "node is not active")); + exception(make_exception_ptr(NodeUnreachableException(load.node, "node is not active"))); } } else @@ -961,31 +923,31 @@ ServerEntry::destroyCallback() } void -ServerEntry::exception(const Ice::Exception& ex) +ServerEntry::exception(exception_ptr ex) { ServerInfo load; - SessionIPtr session; + shared_ptr<SessionI> session; bool noRestart = false; bool remove = false; - int timeout = -1; + chrono::seconds timeout = -1s; { - Lock sync(*this); + lock_guard lock(_mutex); if((_destroy.get() && !_load.get()) || (!_destroy.get() && !_updated)) { remove = _destroy.get(); - _destroy.reset(0); - _exception.reset(ex.ice_clone()); - _proxy = 0; + _destroy = nullptr; + _exception = ex; + _proxy = nullptr; _adapters.clear(); - _activationTimeout = -1; - _deactivationTimeout = -1; + _activationTimeout = -1s; + _deactivationTimeout = -1s; _synchronizing = false; - notifyAll(); + _condVar.notify_all(); } else { - _destroy.reset(0); + _destroy = nullptr; _updated = false; load = *_load.get(); noRestart = _noRestart; @@ -998,11 +960,12 @@ ServerEntry::exception(const Ice::Exception& ex) { try { - _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout, noRestart); + _cache.getNodeCache().get(load.node)->loadServer(static_pointer_cast<ServerEntry>(shared_from_this()), load, + session, timeout, noRestart); } catch(const NodeNotExistException&) { - exception(NodeUnreachableException(load.node, "node is not active")); + exception(make_exception_ptr(NodeUnreachableException(load.node, "node is not active"))); } } else @@ -1018,24 +981,24 @@ ServerEntry::exception(const Ice::Exception& ex) bool ServerEntry::isDestroyed() { - Lock sync(*this); + lock_guard lock(_mutex); return !_loaded.get() && !_load.get(); } bool ServerEntry::canRemove() { - Lock sync(*this); + lock_guard lock(_mutex); return !_loaded.get() && !_load.get() && !_destroy.get(); } -CheckUpdateResultPtr +shared_ptr<CheckUpdateResult> ServerEntry::checkUpdate(const ServerInfo& info, bool noRestart) { - SessionIPtr session; + shared_ptr<SessionI> session; ServerInfo oldInfo; { - Lock sync(*this); + lock_guard lock(_mutex); if(!_loaded.get() && !_load.get()) { throw ServerNotExistException(); @@ -1045,7 +1008,7 @@ ServerEntry::checkUpdate(const ServerInfo& info, bool noRestart) session = _allocationSession; } - NodeEntryPtr node; + shared_ptr<NodeEntry> node; try { node = _cache.getNodeCache().get(oldInfo.node); @@ -1055,10 +1018,10 @@ ServerEntry::checkUpdate(const ServerInfo& info, bool noRestart) throw NodeUnreachableException(info.node, "node is not active"); } - ServerPrx server; + shared_ptr<ServerPrx> server; try { - server = getProxy(true, 5); + server = getProxy(true, 5s); } catch(const SynchronizationException&) { @@ -1078,7 +1041,7 @@ ServerEntry::checkUpdate(const ServerInfo& info, bool noRestart) else { // Otherwise, we do as if the update is valid. - return 0; + return nullptr; } } @@ -1087,13 +1050,14 @@ ServerEntry::checkUpdate(const ServerInfo& info, bool noRestart) // the node. In this case, the check just ensures that the server // is stopped. // - InternalServerDescriptorPtr desc; + shared_ptr<InternalServerDescriptor> desc; if(info.node == oldInfo.node && info.descriptor) { desc = node->getInternalServerDescriptor(info, session); // The new descriptor } - return new CheckUpdateResult(_id, oldInfo.node, noRestart, desc, server->begin_checkUpdate(desc, noRestart)); + return make_shared<CheckUpdateResult>(_id, oldInfo.node, noRestart, desc != nullptr, + server->checkUpdateAsync(desc, noRestart)); } bool @@ -1103,21 +1067,21 @@ ServerEntry::isEnabled() const } void -ServerEntry::allocated(const SessionIPtr& session) +ServerEntry::allocated(const shared_ptr<SessionI>& session) { if(!_loaded.get() && !_load.get()) { return; } - TraceLevelsPtr traceLevels = _cache.getTraceLevels(); + auto traceLevels = _cache.getTraceLevels(); if(traceLevels && traceLevels->server > 1) { Ice::Trace out(traceLevels->logger, traceLevels->serverCat); out << "server `" << _id << "' allocated by `" << session->getId() << "' (" << _count << ")"; } - ServerDescriptorPtr desc = _loaded.get() ? _loaded->descriptor : _load->descriptor; + auto desc = _loaded.get() ? _loaded->descriptor : _load->descriptor; // // If the server has the session activation mode, we re-load the @@ -1136,34 +1100,18 @@ ServerEntry::allocated(const SessionIPtr& session) _load->sessionId = session->getId(); } - Glacier2::IdentitySetPrx identitySet = session->getGlacier2IdentitySet(); - Glacier2::StringSetPrx adapterIdSet = session->getGlacier2AdapterIdSet(); + auto identitySet = session->getGlacier2IdentitySet(); + auto adapterIdSet = session->getGlacier2AdapterIdSet(); if(identitySet && adapterIdSet) { - ServerHelperPtr helper = createHelper(desc); + auto helper = createHelper(desc); multiset<string> adapterIds; multiset<Ice::Identity> identities; helper->getIds(adapterIds, identities); try { - // - // SunCC won't accept the following: - // - // ctl->adapterIds()->add(Ice::StringSeq(adapterIds.begin(), adapterIds.end())); - // ctl->identities()->add(Ice::IdentitySeq(identities.begin(), identities.end())); - // - Ice::StringSeq adapterIdSeq; - for(multiset<string>::iterator p = adapterIds.begin(); p != adapterIds.end(); ++p) - { - adapterIdSeq.push_back(*p); - } - Ice::IdentitySeq identitySeq; - for(multiset<Ice::Identity>::iterator q = identities.begin(); q != identities.end(); ++q) - { - identitySeq.push_back(*q); - } - adapterIdSet->add(adapterIdSeq); - identitySet->add(identitySeq); + adapterIdSet->add({ adapterIds.begin(), adapterIds.end() }); + identitySet->add({ identities.begin(), identities.end() }); } catch(const Ice::LocalException& ex) { @@ -1178,10 +1126,10 @@ ServerEntry::allocated(const SessionIPtr& session) } void -ServerEntry::allocatedNoSync(const SessionIPtr& /*session*/) +ServerEntry::allocatedNoSync(const shared_ptr<SessionI>&) { { - Lock sync(*this); + lock_guard lock(_mutex); if(!_updated || (_loaded.get() && _loaded->descriptor->activation != "session") || (_load.get() && _load->descriptor->activation != "session")) @@ -1195,14 +1143,14 @@ ServerEntry::allocatedNoSync(const SessionIPtr& /*session*/) } void -ServerEntry::released(const SessionIPtr& session) +ServerEntry::released(const shared_ptr<SessionI>& session) { if(!_loaded.get() && !_load.get()) { return; } - ServerDescriptorPtr desc = _loaded.get() ? _loaded->descriptor : _load->descriptor; + auto desc = _loaded.get() ? _loaded->descriptor : _load->descriptor; // // If the server has the session activation mode, we re-load the @@ -1219,39 +1167,23 @@ ServerEntry::released(const SessionIPtr& session) _load.reset(_loaded.release()); } _load->sessionId = ""; - _allocationSession = 0; + _allocationSession = nullptr; } - TraceLevelsPtr traceLevels = _cache.getTraceLevels(); + auto traceLevels = _cache.getTraceLevels(); - Glacier2::IdentitySetPrx identitySet = session->getGlacier2IdentitySet(); - Glacier2::StringSetPrx adapterIdSet = session->getGlacier2AdapterIdSet(); + auto identitySet = session->getGlacier2IdentitySet(); + auto adapterIdSet = session->getGlacier2AdapterIdSet(); if(identitySet && adapterIdSet) { - ServerHelperPtr helper = createHelper(desc); + auto helper = createHelper(desc); multiset<string> adapterIds; multiset<Ice::Identity> identities; helper->getIds(adapterIds, identities); try { - // - // SunCC won't accept the following: - // - // ctl->adapterIds()->remove(Ice::StringSeq(adapterIds.begin(), adapterIds.end())); - // ctl->identities()->remove(Ice::IdentitySeq(identities.begin(), identities.end())); - // - Ice::StringSeq adapterIdSeq; - for(multiset<string>::iterator p = adapterIds.begin(); p != adapterIds.end(); ++p) - { - adapterIdSeq.push_back(*p); - } - Ice::IdentitySeq identitySeq; - for(multiset<Ice::Identity>::iterator q = identities.begin(); q != identities.end(); ++q) - { - identitySeq.push_back(*q); - } - adapterIdSet->remove(adapterIdSeq); - identitySet->remove(identitySeq); + adapterIdSet->remove({ adapterIds.begin(), adapterIds.end() }); + identitySet->remove({ identities.begin(), identities.end() }); } catch(const Ice::LocalException& ex) { @@ -1272,10 +1204,10 @@ ServerEntry::released(const SessionIPtr& session) } void -ServerEntry::releasedNoSync(const SessionIPtr& /*session*/) +ServerEntry::releasedNoSync(const shared_ptr<SessionI>& /*session*/) { { - Lock sync(*this); + lock_guard lock(_mutex); if(!_updated || (_loaded.get() && _loaded->descriptor->activation != "session") || (_load.get() && _load->descriptor->activation != "session")) diff --git a/cpp/src/IceGrid/ServerCache.h b/cpp/src/IceGrid/ServerCache.h index 15bee8989c6..86a991e79fd 100644 --- a/cpp/src/IceGrid/ServerCache.h +++ b/cpp/src/IceGrid/ServerCache.h @@ -5,9 +5,6 @@ #ifndef ICE_GRID_SERVERCACHE_H #define ICE_GRID_SERVERCACHE_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Shared.h> -#include <Ice/UniquePtr.h> #include <IceGrid/Descriptor.h> #include <IceGrid/Internal.h> #include <IceGrid/Registry.h> @@ -17,26 +14,20 @@ namespace IceGrid { -class ServerCache; -class ObjectCache; class AdapterCache; class AllocatableObjectCache; +class CheckServerResult; class NodeCache; - class NodeEntry; -typedef IceUtil::Handle<NodeEntry> NodeEntryPtr; - -class CheckServerResult; -typedef IceUtil::Handle<CheckServerResult> CheckServerResultPtr; - class NodeObserverTopic; -typedef IceUtil::Handle<NodeObserverTopic> NodeObserverTopicPtr; +class ObjectCache; +class ServerCache; -class CheckUpdateResult : public IceUtil::Shared +class CheckUpdateResult final { public: - CheckUpdateResult(const std::string&, const std::string&, bool, bool, const Ice::AsyncResultPtr&); + CheckUpdateResult(const std::string&, const std::string&, bool, bool, std::future<bool>&&); bool getResult(); @@ -48,30 +39,29 @@ private: const std::string _node; const bool _remove; const bool _noRestart; - const Ice::AsyncResultPtr _result; + std::future<bool> _result; }; -typedef IceUtil::Handle<CheckUpdateResult> CheckUpdateResultPtr; -class ServerEntry : public Allocatable +class ServerEntry final : public Allocatable { public: ServerEntry(ServerCache&, const std::string&); void sync(); - void waitForSync(int); + void waitForSync(std::chrono::seconds); void waitForSync() { - waitForSync(-1); + waitForSync(std::chrono::seconds(-1)); } - void waitForSyncNoThrow(int); + void waitForSyncNoThrow(std::chrono::seconds); void waitForSyncNoThrow() { - waitForSyncNoThrow(-1); + waitForSyncNoThrow(std::chrono::seconds(-1)); } void unsync(); - bool addSyncCallback(const SynchronizationCallbackPtr&); + bool addSyncCallback(const std::shared_ptr<SynchronizationCallback>&); void update(const ServerInfo&, bool); @@ -80,101 +70,104 @@ public: ServerInfo getInfo(bool = false) const; std::string getId() const; - ServerPrx getProxy(int&, int&, std::string&, bool = true, int = 0); - ServerPrx getProxy(bool = true, int = 0); - Ice::ObjectPrx getAdminProxy(); + std::shared_ptr<ServerPrx> getProxy(std::chrono::seconds&, std::chrono::seconds&, std::string&, bool = true, + std::chrono::seconds = std::chrono::seconds(0)); + std::shared_ptr<ServerPrx> getProxy(bool = true, std::chrono::seconds = std::chrono::seconds(0)); + std::shared_ptr<Ice::ObjectPrx> getAdminProxy(); - AdapterPrx getAdapter(const std::string&, bool); - AdapterPrx getAdapter(int&, int&, const std::string&, bool); + std::shared_ptr<AdapterPrx> getAdapter(const std::string&, bool); + std::shared_ptr<AdapterPrx> getAdapter(std::chrono::seconds&, std::chrono::seconds&, const std::string&, bool); float getLoad(LoadSample) const; bool canRemove(); - CheckUpdateResultPtr checkUpdate(const ServerInfo&, bool); + std::shared_ptr<CheckUpdateResult> checkUpdate(const ServerInfo&, bool); bool isDestroyed(); - void loadCallback(const ServerPrx&, const AdapterPrxDict&, int, int); + void loadCallback(const std::shared_ptr<ServerPrx>&, const AdapterPrxDict&, std::chrono::seconds, + std::chrono::seconds); void destroyCallback(); - void exception(const Ice::Exception&); + void exception(std::exception_ptr); - virtual bool isEnabled() const; - virtual void allocated(const SessionIPtr&); - virtual void allocatedNoSync(const SessionIPtr&); - virtual void released(const SessionIPtr&); - virtual void releasedNoSync(const SessionIPtr&); + bool isEnabled() const override; + void allocated(const std::shared_ptr<SessionI>&) override; + void allocatedNoSync(const std::shared_ptr<SessionI>&) override; + void released(const std::shared_ptr<SessionI>&) override; + void releasedNoSync(const std::shared_ptr<SessionI>&) override; private: void syncImpl(); - void waitImpl(int); + void waitImpl(std::chrono::seconds); void synchronized(); - void synchronized(const Ice::Exception&); + void synchronized(std::exception_ptr); ServerCache& _cache; const std::string _id; - IceInternal::UniquePtr<ServerInfo> _loaded; - IceInternal::UniquePtr<ServerInfo> _load; - IceInternal::UniquePtr<ServerInfo> _destroy; + std::unique_ptr<ServerInfo> _loaded; + std::unique_ptr<ServerInfo> _load; + std::unique_ptr<ServerInfo> _destroy; - ServerPrx _proxy; + std::shared_ptr<ServerPrx> _proxy; AdapterPrxDict _adapters; - int _activationTimeout; - int _deactivationTimeout; + std::chrono::seconds _activationTimeout; + std::chrono::seconds _deactivationTimeout; bool _synchronizing; bool _updated; - IceInternal::UniquePtr<Ice::Exception> _exception; + std::exception_ptr _exception; bool _noRestart; - std::vector<SynchronizationCallbackPtr> _callbacks; + std::vector<std::shared_ptr<SynchronizationCallback>> _callbacks; + + std::shared_ptr<SessionI> _allocationSession; - SessionIPtr _allocationSession; + mutable std::mutex _mutex; + std::condition_variable _condVar; }; -typedef IceUtil::Handle<ServerEntry> ServerEntryPtr; -typedef std::vector<ServerEntryPtr> ServerEntrySeq; +using ServerEntrySeq = std::vector<std::shared_ptr<ServerEntry>>; class ServerCache : public CacheByString<ServerEntry> { public: -#ifdef __SUNPRO_CC - using CacheByString<ServerEntry>::remove; -#endif - - ServerCache(const Ice::CommunicatorPtr&, const std::string&, NodeCache&, AdapterCache&, ObjectCache&, + ServerCache(const std::shared_ptr<Ice::Communicator>&, const std::string&, NodeCache&, AdapterCache&, ObjectCache&, AllocatableObjectCache&); - ServerEntryPtr add(const ServerInfo&); - ServerEntryPtr get(const std::string&) const; + std::shared_ptr<ServerEntry> add(const ServerInfo&); + std::shared_ptr<ServerEntry> get(const std::string&) const; bool has(const std::string&) const; - ServerEntryPtr remove(const std::string&, bool); + std::shared_ptr<ServerEntry> remove(const std::string&, bool); void preUpdate(const ServerInfo&, bool); - ServerEntryPtr postUpdate(const ServerInfo&, bool); + std::shared_ptr<ServerEntry> postUpdate(const ServerInfo&, bool); void clear(const std::string&); NodeCache& getNodeCache() const { return _nodeCache; } - Ice::CommunicatorPtr getCommunicator() const { return _communicator; } + std::shared_ptr<Ice::Communicator> getCommunicator() const { return _communicator; } const std::string& getInstanceName() const { return _instanceName; } - const NodeObserverTopicPtr& getNodeObserverTopic() const { return _nodeObserverTopic; } - void setNodeObserverTopic(const NodeObserverTopicPtr&); + const std::shared_ptr<NodeObserverTopic>& getNodeObserverTopic() const { return _nodeObserverTopic; } + void setNodeObserverTopic(const std::shared_ptr<NodeObserverTopic>&); private: - void addCommunicator(const CommunicatorDescriptorPtr&, const CommunicatorDescriptorPtr&, const ServerEntryPtr&, - const std::string&); - void removeCommunicator(const CommunicatorDescriptorPtr&, const CommunicatorDescriptorPtr&, const ServerEntryPtr&); + void addCommunicator(const std::shared_ptr<CommunicatorDescriptor>&, const std::shared_ptr<CommunicatorDescriptor>&, + const std::shared_ptr<ServerEntry>&, const std::string&); + void removeCommunicator(const std::shared_ptr<CommunicatorDescriptor>&, + const std::shared_ptr<CommunicatorDescriptor>&, const std::shared_ptr<ServerEntry>&); friend struct AddCommunicator; friend struct RemoveCommunicator; - const Ice::CommunicatorPtr _communicator; + const std::shared_ptr<Ice::Communicator> _communicator; const std::string _instanceName; NodeCache& _nodeCache; AdapterCache& _adapterCache; ObjectCache& _objectCache; AllocatableObjectCache& _allocatableObjectCache; - NodeObserverTopicPtr _nodeObserverTopic; + std::shared_ptr<NodeObserverTopic> _nodeObserverTopic; + + mutable std::mutex _mutex; }; }; diff --git a/cpp/src/IceGrid/ServerI.cpp b/cpp/src/IceGrid/ServerI.cpp index 8a2f6b36380..734bffa44d2 100644 --- a/cpp/src/IceGrid/ServerI.cpp +++ b/cpp/src/IceGrid/ServerI.cpp @@ -101,7 +101,7 @@ chownRecursive(const string& path, uid_t uid, gid_t gid) #endif static bool -descriptorUpdated(const InternalServerDescriptorPtr& lhs, const InternalServerDescriptorPtr& rhs, bool noProps = false) +descriptorUpdated(const shared_ptr<InternalServerDescriptor>& lhs, const shared_ptr<InternalServerDescriptor>& rhs, bool noProps = false) { if(lhs->uuid == rhs->uuid && lhs->revision == rhs->revision) { @@ -142,22 +142,6 @@ descriptorUpdated(const InternalServerDescriptorPtr& lhs, const InternalServerDe } } - if(lhs->dbEnvs.size() != rhs->dbEnvs.size()) - { - return true; - } - else - { - InternalDbEnvDescriptorSeq::const_iterator q = rhs->dbEnvs.begin(); - for(InternalDbEnvDescriptorSeq::const_iterator p = lhs->dbEnvs.begin(); p != lhs->dbEnvs.end(); ++p, ++q) - { - if((*p)->name != (*q)->name || (*p)->properties != (*q)->properties) - { - return true; - } - } - } - if(!noProps && lhs->properties != rhs->properties) { return true; @@ -189,39 +173,39 @@ toPropertyDict(const PropertyDescriptorSeq& seq) return props; } -class CommandTimeoutTimerTask : public IceUtil::TimerTask +class CommandTimeoutTimerTask final : public IceUtil::TimerTask { public: - CommandTimeoutTimerTask(const TimedServerCommandPtr& command) : _command(command) + CommandTimeoutTimerTask(const shared_ptr<TimedServerCommand>& command) : _command(command) { } - virtual void runTimerTask() + void runTimerTask() override { _command->timeout(); } private: - const TimedServerCommandPtr _command; + const shared_ptr<TimedServerCommand> _command; }; class DelayedStart : public IceUtil::TimerTask { public: - DelayedStart(const ServerIPtr& server, const TraceLevelsPtr& traceLevels) : + DelayedStart(const shared_ptr<ServerI>& server, const shared_ptr<TraceLevels>& traceLevels) : _server(server), _traceLevels(traceLevels) { } - virtual void runTimerTask() + void runTimerTask() override { try { - _server->start(ServerI::Always); + _server->start(ServerI::ServerActivation::Always); } catch(const ServerStartException& ex) { @@ -237,19 +221,19 @@ public: private: - const ServerIPtr _server; - const TraceLevelsPtr _traceLevels; + const shared_ptr<ServerI> _server; + const shared_ptr<TraceLevels> _traceLevels; }; -class ResetPropertiesCB : public IceUtil::Shared +class ResetPropertiesCB : public enable_shared_from_this<ResetPropertiesCB> { public: - ResetPropertiesCB(const ServerIPtr& server, - const Ice::ObjectPrx admin, - const InternalServerDescriptorPtr& desc, - const InternalServerDescriptorPtr& old, - const TraceLevelsPtr& traceLevels) : + ResetPropertiesCB(const shared_ptr<ServerI>& server, + const shared_ptr<Ice::ObjectPrx> admin, + const shared_ptr<InternalServerDescriptor>& desc, + const shared_ptr<InternalServerDescriptor>& old, + const shared_ptr<TraceLevels>& traceLevels) : _server(server), _admin(admin), _desc(desc), @@ -282,13 +266,13 @@ private: return; } - Ice::PropertyDict oldProps = toPropertyDict(_oldProperties[_p->first]); - Ice::PropertyDict props = toPropertyDict(_p->second); - for(Ice::PropertyDict::const_iterator q = oldProps.begin(); q != oldProps.end(); ++q) + auto oldProps = toPropertyDict(_oldProperties[_p->first]); + auto props = toPropertyDict(_p->second); + for(const auto& oldProp : oldProps) { - if(props.find(q->first) == props.end()) + if(props.find(oldProp.first) == props.end()) { - props[q->first] = ""; + props[oldProp.first] = ""; } } @@ -329,107 +313,97 @@ private: // ++_p; - Ice::PropertiesAdminPrx p = Ice::PropertiesAdminPrx::uncheckedCast(_admin, facet); - p->begin_setProperties(props, Ice::newCallback_PropertiesAdmin_setProperties(this, - &ResetPropertiesCB::next, - &ResetPropertiesCB::exception)); - } - - void - exception(const Ice::Exception& ex) - { - _server->updateRuntimePropertiesCallback(ex, _desc); - } - - const ServerIPtr _server; - const Ice::ObjectPrx _admin; - const InternalServerDescriptorPtr _desc; - const TraceLevelsPtr _traceLevels; + auto p = Ice::uncheckedCast<Ice::PropertiesAdminPrx>(_admin, facet); + p->setPropertiesAsync(props, + [self = shared_from_this()] + { + self->next(); + }, + [server = _server, desc = _desc](exception_ptr ex) + { + server->updateRuntimePropertiesCallback(ex, desc); + }); + } + + const shared_ptr<ServerI> _server; + const shared_ptr<Ice::ObjectPrx> _admin; + const shared_ptr<InternalServerDescriptor> _desc; + const shared_ptr<TraceLevels> _traceLevels; PropertyDescriptorSeqDict _properties; PropertyDescriptorSeqDict _oldProperties; PropertyDescriptorSeqDict::const_iterator _p; }; -typedef IceUtil::Handle<ResetPropertiesCB> ResetPropertiesCBPtr; -struct EnvironmentEval : std::unary_function<string, string> +string environmentEval(const std::string& value) { + string::size_type assignment = value.find("="); + if(assignment == string::npos || assignment >= value.size() - 1) + { + return value; + } - string - operator()(const std::string& value) + string v = value.substr(assignment + 1); + assert(v.size()); + string::size_type beg = 0; + string::size_type end; +#ifdef _WIN32 + vector<wchar_t> buf; + buf.resize(32767); + while((beg = v.find("%", beg)) != string::npos && beg < v.size() - 1) { - string::size_type assignment = value.find("="); - if(assignment == string::npos || assignment >= value.size() - 1) + end = v.find("%", beg + 1); + if(end == string::npos) { - return value; + break; } - - string v = value.substr(assignment + 1); - assert(v.size()); - string::size_type beg = 0; - string::size_type end; -#ifdef _WIN32 - vector<wchar_t> buf; - buf.resize(32767); - while((beg = v.find("%", beg)) != string::npos && beg < v.size() - 1) + string variable = v.substr(beg + 1, end - beg - 1); + DWORD ret = GetEnvironmentVariableW(Ice::stringToWstring(variable).c_str(), &buf[0], + static_cast<DWORD>(buf.size())); + string valstr = (ret > 0 && ret < buf.size()) ? Ice::wstringToString(&buf[0]) : string(""); + v.replace(beg, end - beg + 1, valstr); + beg += valstr.size(); + } +#else + while((beg = v.find("$", beg)) != string::npos && beg < v.size() - 1) + { + string variable; + if(v[beg + 1] == '{') { - end = v.find("%", beg + 1); + end = v.find("}"); if(end == string::npos) { break; } - string variable = v.substr(beg + 1, end - beg - 1); - DWORD ret = GetEnvironmentVariableW(Ice::stringToWstring(variable).c_str(), &buf[0], - static_cast<DWORD>(buf.size())); - string valstr = (ret > 0 && ret < buf.size()) ? Ice::wstringToString(&buf[0]) : string(""); - v.replace(beg, end - beg + 1, valstr); - beg += valstr.size(); + variable = v.substr(beg + 2, end - beg - 2); } -#else - while((beg = v.find("$", beg)) != string::npos && beg < v.size() - 1) + else { - string variable; - if(v[beg + 1] == '{') + end = beg + 1; + while((isalnum(static_cast<unsigned char>(v[end])) || v[end] == '_') && end < v.size()) { - end = v.find("}"); - if(end == string::npos) - { - break; - } - variable = v.substr(beg + 2, end - beg - 2); + ++end; } - else - { - end = beg + 1; - while((isalnum(static_cast<unsigned char>(v[end])) || v[end] == '_') && end < v.size()) - { - ++end; - } - variable = v.substr(beg + 1, end - beg - 1); - --end; - } - - char* val = getenv(variable.c_str()); - string valstr = val ? string(val) : ""; - v.replace(beg, end - beg + 1, valstr); - beg += valstr.size(); + variable = v.substr(beg + 1, end - beg - 1); + --end; } -#endif - return value.substr(0, assignment) + "=" + v; - } - -}; + char* val = getenv(variable.c_str()); + string valstr = val ? string(val) : ""; + v.replace(beg, end - beg + 1, valstr); + beg += valstr.size(); + } +#endif + return value.substr(0, assignment) + "=" + v; } -ServerCommand::ServerCommand(const ServerIPtr& server) : _server(server) -{ } -ServerCommand::~ServerCommand() +ServerCommand::ServerCommand(const shared_ptr<ServerI>& server) : _server(server) { } -TimedServerCommand::TimedServerCommand(const ServerIPtr& server, const IceUtil::TimerPtr& timer, int timeout) : +TimedServerCommand::TimedServerCommand(const shared_ptr<ServerI>& server, const IceUtil::TimerPtr& timer, + chrono::seconds timeout) : ServerCommand(server), _timer(timer), _timeout(timeout) { } @@ -437,12 +411,12 @@ TimedServerCommand::TimedServerCommand(const ServerIPtr& server, const IceUtil:: void TimedServerCommand::startTimer() { - _timerTask = new CommandTimeoutTimerTask(this); + _timerTask = make_shared<CommandTimeoutTimerTask>(shared_from_this()); try { - _timer->schedule(_timerTask, IceUtil::Time::seconds(_timeout)); + _timer->schedule(_timerTask, IceUtil::Time::seconds(_timeout.count())); } - catch(const IceUtil::Exception&) + catch(const std::exception&) { // Ignore, timer is destroyed because node is shutting down. } @@ -454,13 +428,13 @@ TimedServerCommand::stopTimer() if(_timerTask) { _timer->cancel(_timerTask); - _timerTask = 0; + _timerTask = nullptr; } } -LoadCommand::LoadCommand(const ServerIPtr& server, - const InternalServerDescriptorPtr& runtime, - const TraceLevelsPtr& traceLevels) : +LoadCommand::LoadCommand(const shared_ptr<ServerI>& server, + const shared_ptr<InternalServerDescriptor>& runtime, + const shared_ptr<TraceLevels>& traceLevels) : ServerCommand(server), _runtime(runtime), _updating(false), _traceLevels(traceLevels) { } @@ -474,7 +448,7 @@ LoadCommand::canExecute(ServerI::InternalServerState state) ServerI::InternalServerState LoadCommand::nextState() { - return ServerI::Loading; + return ServerI::InternalServerState::Loading; } void @@ -484,13 +458,13 @@ LoadCommand::execute() } void -LoadCommand::setUpdate(const InternalServerDescriptorPtr& descriptor, bool clearDir) +LoadCommand::setUpdate(const shared_ptr<InternalServerDescriptor>& descriptor, bool clearDir) { _clearDir = clearDir; _desc = descriptor; } -InternalServerDescriptorPtr +shared_ptr<InternalServerDescriptor> LoadCommand::getInternalServerDescriptor() const { return _desc; @@ -503,13 +477,14 @@ LoadCommand::clearDir() const } void -LoadCommand::addCallback(const AMD_Node_loadServerPtr& amdCB) +LoadCommand::addCallback(function<void(const shared_ptr<ServerPrx>&, const AdapterPrxDict &, int, int)> response, + function<void(exception_ptr)> exception) { - _loadCB.push_back(amdCB); + _loadCB.push_back({move(response), move(exception)}); } void -LoadCommand::startRuntimePropertiesUpdate(const Ice::ObjectPrx& process) +LoadCommand::startRuntimePropertiesUpdate(const shared_ptr<Ice::ObjectPrx>& process) { if(_updating) { @@ -518,12 +493,13 @@ LoadCommand::startRuntimePropertiesUpdate(const Ice::ObjectPrx& process) assert(_desc != _runtime); _updating = true; - ResetPropertiesCBPtr cb = new ResetPropertiesCB(_server, process, _desc, _runtime, _traceLevels); + auto cb = make_shared<ResetPropertiesCB>(_server, process, _desc, _runtime, _traceLevels); cb->execute(); } bool -LoadCommand::finishRuntimePropertiesUpdate(const InternalServerDescriptorPtr& runtime, const Ice::ObjectPrx& process) +LoadCommand::finishRuntimePropertiesUpdate(const shared_ptr<InternalServerDescriptor>& runtime, + const shared_ptr<Ice::ObjectPrx>& process) { _updating = false; _runtime = runtime; // The new runtime server descriptor. @@ -546,26 +522,27 @@ LoadCommand::finishRuntimePropertiesUpdate(const InternalServerDescriptorPtr& ru } void -LoadCommand::failed(const Ice::Exception& ex) +LoadCommand::failed(exception_ptr ex) { - for(vector<AMD_Node_loadServerPtr>::const_iterator p = _loadCB.begin(); p != _loadCB.end(); ++p) + for(const auto& cb : _loadCB) { - (*p)->ice_exception(ex); + cb.second(ex); } _loadCB.clear(); } void -LoadCommand::finished(const ServerPrx& proxy, const AdapterPrxDict& adapters, int at, int dt) +LoadCommand::finished(const shared_ptr<ServerPrx>& proxy, const AdapterPrxDict& adapters, + chrono::seconds at, chrono::seconds dt) { - for(vector<AMD_Node_loadServerPtr>::const_iterator p = _loadCB.begin(); p != _loadCB.end(); ++p) + for(const auto& cb : _loadCB) { - (*p)->ice_response(proxy, adapters, at, dt); + cb.first(proxy, adapters, secondsToInt(at), secondsToInt(dt)); } _loadCB.clear(); } -DestroyCommand::DestroyCommand(const ServerIPtr& server, bool loadFailure, bool clearDir) : +DestroyCommand::DestroyCommand(const shared_ptr<ServerI>& server, bool loadFailure, bool clearDir) : ServerCommand(server), _loadFailure(loadFailure), _clearDir(clearDir) @@ -591,17 +568,17 @@ DestroyCommand::execute() } void -DestroyCommand::addCallback(const AMD_Node_destroyServerPtr& amdCB) +DestroyCommand::addCallback(function<void()> response) { - _destroyCB.push_back(amdCB); + _destroyCB.push_back(move(response)); } void DestroyCommand::finished() { - for(vector<AMD_Node_destroyServerPtr>::const_iterator p = _destroyCB.begin(); p != _destroyCB.end(); ++p) + for(const auto& cb : _destroyCB) { - (*p)->ice_response(); + cb(); } } @@ -617,11 +594,6 @@ DestroyCommand::clearDir() const return _clearDir; } -StartCommand::StartCommand(const ServerIPtr& server, const IceUtil::TimerPtr& timer, int timeout) : - TimedServerCommand(server, timer, timeout) -{ -} - bool StartCommand::canExecute(ServerI::InternalServerState state) { @@ -648,19 +620,19 @@ StartCommand::timeout() } void -StartCommand::addCallback(const AMD_Server_startPtr& amdCB) +StartCommand::addCallback(function<void()> response, function<void(exception_ptr)> exception) { - _startCB.push_back(amdCB); + _startCB.push_back({move(response), move(exception)}); } void StartCommand::failed(const string& reason) { stopTimer(); - ServerStartException ex(_server->getId(), reason); - for(vector<AMD_Server_startPtr>::const_iterator p = _startCB.begin(); p != _startCB.end(); ++p) + auto ex = make_exception_ptr(ServerStartException(_server->getId(), reason)); + for(const auto& cb : _startCB) { - (*p)->ice_exception(ex); + cb.second(ex); } _startCB.clear(); } @@ -669,14 +641,15 @@ void StartCommand::finished() { stopTimer(); - for(vector<AMD_Server_startPtr>::const_iterator p = _startCB.begin(); p != _startCB.end(); ++p) + for(const auto& cb : _startCB) { - (*p)->ice_response(); + cb.first(); } _startCB.clear(); } -StopCommand::StopCommand(const ServerIPtr& server, const IceUtil::TimerPtr& timer, int timeout, bool deactivate) +StopCommand::StopCommand(const shared_ptr<ServerI>& server, const IceUtil::TimerPtr& timer, + chrono::seconds timeout, bool deactivate) : TimedServerCommand(server, timer, timeout), _deactivate(deactivate) { } @@ -717,19 +690,19 @@ StopCommand::timeout() } void -StopCommand::addCallback(const AMD_Server_stopPtr& amdCB) +StopCommand::addCallback(function<void()> response, function<void(exception_ptr)> exception) { - _stopCB.push_back(amdCB); + _stopCB.push_back({move(response), move(exception)}); } void StopCommand::failed(const string& reason) { stopTimer(); - ServerStopException ex(_server->getId(), reason); - for(vector<AMD_Server_stopPtr>::const_iterator p = _stopCB.begin(); p != _stopCB.end(); ++p) + auto ex = make_exception_ptr(ServerStopException(_server->getId(), reason)); + for(const auto& cb : _stopCB) { - (*p)->ice_exception(ex); + cb.second(ex); } _stopCB.clear(); } @@ -738,52 +711,46 @@ void StopCommand::finished() { stopTimer(); - for(vector<AMD_Server_stopPtr>::const_iterator p = _stopCB.begin(); p != _stopCB.end(); ++p) + for(const auto& cb : _stopCB) { - (*p)->ice_response(); + cb.first(); } _stopCB.clear(); } -ServerI::ServerI(const NodeIPtr& node, const ServerPrx& proxy, const string& serversDir, const string& id, int wt) : +ServerI::ServerI(const shared_ptr<NodeI>& node, const shared_ptr<ServerPrx>& proxy, const string& serversDir, const string& id, int wt) : _node(node), _this(proxy), _id(id), _waitTime(wt), _serverDir(serversDir + "/" + id), - _disableOnFailure(0), + _disableOnFailure(_node->getCommunicator()->getProperties()->getPropertyAsIntWithDefault("IceGrid.Node.DisableOnFailure", 0)), _state(ServerI::Inactive), _activation(ServerI::Disabled), - _failureTime(IceUtil::Time::now(IceUtil::Time::Monotonic)), // Ensure that _activation is init. in updateImpl(). + _failureTime(chrono::steady_clock::now()), // Ensure that _activation is init. in updateImpl(). _pid(0) { assert(_node->getActivator()); - const_cast<int&>(_disableOnFailure) = - _node->getCommunicator()->getProperties()->getPropertyAsIntWithDefault("IceGrid.Node.DisableOnFailure", 0); -} - -ServerI::~ServerI() -{ } void -ServerI::waitForApplicationUpdateCompleted(const Ice::AsyncResultPtr&) +ServerI::waitForApplicationUpdateCompleted() { activate(); } void -ServerI::start_async(const AMD_Server_startPtr& amdCB, const Ice::Current&) +ServerI::startAsync(function<void()> response, function<void(exception_ptr)> exception, const Ice::Current&) { - start(Manual, amdCB); + start(Manual, move(response), move(exception)); } void -ServerI::stop_async(const AMD_Server_stopPtr& amdCB, const Ice::Current&) +ServerI::stopAsync(function<void()> response, function<void(exception_ptr)> exception, const Ice::Current&) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); if(StopCommand::isStopped(_state)) @@ -797,11 +764,12 @@ ServerI::stop_async(const AMD_Server_stopPtr& amdCB, const Ice::Current&) if(!_stop) { - _stop = new StopCommand(this, _node->getTimer(), _deactivationTimeout); + _stop = make_shared<StopCommand>(shared_from_this(), _node->getTimer(), _deactivationTimeout); } - if(amdCB) + if(response) { - _stop->addCallback(amdCB); + assert(exception); + _stop->addCallback(move(response), move(exception)); } command = nextCommand(); } @@ -812,23 +780,23 @@ ServerI::stop_async(const AMD_Server_stopPtr& amdCB, const Ice::Current&) } void -ServerI::sendSignal(const string& signal, const Ice::Current&) +ServerI::sendSignal(string signal, const Ice::Current&) { - _node->getActivator()->sendSignal(_id, signal); + _node->getActivator()->sendSignal(_id, move(signal)); } void -ServerI::writeMessage(const string& message, Ice::Int fd, const Ice::Current&) +ServerI::writeMessage(string message, int fd, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); - if(_process != 0) + if(_process) { try { - _process->writeMessage(message, fd); + _process->writeMessage(move(message), fd); } - catch(const Ice::LocalException&) + catch(const std::exception&) { } } @@ -837,7 +805,7 @@ ServerI::writeMessage(const string& message, Ice::Int fd, const Ice::Current&) ServerState ServerI::getState(const Ice::Current&) const { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); return toServerState(_state); } @@ -848,14 +816,14 @@ ServerI::getPid(const Ice::Current&) const return _node->getActivator()->getServerPid(_id); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> ServerI::getProcess() const { - Lock sync(*this); + lock_guard lock(_mutex); - if(_process == 0 || _state <= Inactive || _state >= Deactivating) + if(_process == nullptr || _state <= Inactive || _state >= Deactivating) { - return 0; + return nullptr; } else { @@ -869,24 +837,24 @@ ServerI::setEnabled(bool enabled, const ::Ice::Current&) bool activate = false; ServerAdapterDict adpts; { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); assert(_desc); if(enabled && _activation == Disabled) { - _failureTime = IceUtil::Time(); + _failureTime = nullopt; _activation = toServerActivation(_desc->activation); activate = _state == Inactive && _activation == Always; } - else if(!enabled && (_activation != Disabled || _failureTime != IceUtil::Time())) + else if(!enabled && (_activation != Disabled || _failureTime != nullopt)) { - _failureTime = IceUtil::Time(); + _failureTime = nullopt; _activation = Disabled; if(_timerTask) { _node->getTimer()->cancel(_timerTask); - _timerTask = 0; + _timerTask = nullptr; } } else @@ -898,9 +866,9 @@ ServerI::setEnabled(bool enabled, const ::Ice::Current&) _node->observerUpdateServer(getDynamicInfo()); } - for(ServerAdapterDict::iterator r = adpts.begin(); r != adpts.end(); ++r) + for(const auto& adpt : adpts) { - r->second->updateEnabled(); + adpt.second->updateEnabled(); } if(activate) @@ -924,21 +892,22 @@ ServerI::setEnabled(bool enabled, const ::Ice::Current&) bool ServerI::isEnabled(const ::Ice::Current&) const { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); return _activation != Disabled; } void -ServerI::setProcess_async(const AMD_Server_setProcessPtr& amdCB, const Ice::ProcessPrx& process, const Ice::Current&) +ServerI::setProcessAsync(shared_ptr<Ice::ProcessPrx> process, function<void()> response, + function<void(exception_ptr)>, const Ice::Current&) { bool deact = false; ServerAdapterDict adpts; - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); - _process = process; + _process = move(process); if(_state == DeactivatingWaitForProcess) { deact = true; @@ -952,13 +921,14 @@ ServerI::setProcess_async(const AMD_Server_setProcessPtr& amdCB, const Ice::Proc command = nextCommand(); } } - amdCB->ice_response(); - for(ServerAdapterDict::iterator r = adpts.begin(); r != adpts.end(); ++r) + response(); + + for(const auto& adpt : adpts) { try { - r->second->activationCompleted(); + adpt.second->activationCompleted(); } catch(const Ice::ObjectNotExistException&) { @@ -976,23 +946,23 @@ ServerI::setProcess_async(const AMD_Server_setProcessPtr& amdCB, const Ice::Proc } } -Ice::Long -ServerI::getOffsetFromEnd(const string& filename, int count, const Ice::Current&) const +long long +ServerI::getOffsetFromEnd(string filename, int count, const Ice::Current&) const { - return _node->getFileCache()->getOffsetFromEnd(getFilePath(filename), count); + return _node->getFileCache()->getOffsetFromEnd(getFilePath(move(filename)), count); } bool -ServerI::read(const string& filename, Ice::Long pos, int size, Ice::Long& newPos, Ice::StringSeq& lines, +ServerI::read(string filename, long long pos, int size, long long& newPos, Ice::StringSeq& lines, const Ice::Current&) const { - return _node->getFileCache()->read(getFilePath(filename), pos, size, newPos, lines); + return _node->getFileCache()->read(getFilePath(move(filename)), pos, size, newPos, lines); } bool ServerI::isAdapterActivatable(const string& id) const { - Lock sync(*this); + lock_guard lock(_mutex); if(!_desc || _activation == Disabled) { return false; @@ -1034,24 +1004,23 @@ ServerI::getId() const } void -ServerI::start(ServerActivation activation, const AMD_Server_startPtr& amdCB) +ServerI::start(ServerActivation activation, function<void()> response , function<void(exception_ptr)> exception) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); // // Eventually re-enable the server if it's disabled because of a failure. // - if(_disableOnFailure > 0 && _failureTime != IceUtil::Time()) + if(_disableOnFailure > 0s && _failureTime != nullopt) { if(activation == Manual || - (_failureTime + IceUtil::Time::seconds(_disableOnFailure) < - IceUtil::Time::now(IceUtil::Time::Monotonic))) + (*_failureTime + _disableOnFailure < chrono::steady_clock::now())) { _activation = _previousActivation; - _failureTime = IceUtil::Time(); + _failureTime = nullopt; } } @@ -1064,7 +1033,7 @@ ServerI::start(ServerActivation activation, const AMD_Server_startPtr& amdCB) } else if(_activation != Always && activation == Always) { - assert(!amdCB); + assert(!response && !exception); return; // Nothing to do. } else if(_activation == Manual && activation != Manual) @@ -1101,16 +1070,17 @@ ServerI::start(ServerActivation activation, const AMD_Server_startPtr& amdCB) if(_timerTask) { _node->getTimer()->cancel(_timerTask); - _timerTask = 0; + _timerTask = nullptr; } if(!_start) { - _start = new StartCommand(this, _node->getTimer(), _activationTimeout); + _start = make_shared<StartCommand>(shared_from_this(), _node->getTimer(), _activationTimeout); } - if(amdCB) + if(response) { - _start->addCallback(amdCB); + assert(response && exception); + _start->addCallback(move(response), move(exception)); } command = nextCommand(); } @@ -1120,11 +1090,12 @@ ServerI::start(ServerActivation activation, const AMD_Server_startPtr& amdCB) } } -ServerCommandPtr -ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescriptorPtr& desc, const string& replicaName, - bool noRestart) +shared_ptr<ServerCommand> +ServerI::load(const shared_ptr<InternalServerDescriptor>& desc, const string& replicaName, bool noRestart, + function<void(const shared_ptr<ServerPrx> &, const AdapterPrxDict &, int, int)> response, + function<void(exception_ptr)> exception) { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); checkRevision(replicaName, desc->uuid, desc->revision); @@ -1138,7 +1109,7 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto // we don't re-load the server. We just return the server // proxy and the proxies of its adapters. // - InternalServerDescriptorPtr d = _load ? _load->getInternalServerDescriptor() : _desc; + auto d = _load ? _load->getInternalServerDescriptor() : _desc; if(d && (replicaName != "Master" || d->sessionId == desc->sessionId) && !descriptorUpdated(d, desc)) { if(d->revision != desc->revision) @@ -1152,19 +1123,19 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto // If the server initial loading didn't complete yet or there's a new updated descriptor // waiting to be loaded, we wait for the loading to complete before replying. // - _load->addCallback(amdCB); + _load->addCallback(response, exception); return 0; } - else if(amdCB) + else if(response) { AdapterPrxDict adapters; - for(ServerAdapterDict::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + for(const auto& [id, servant] : _adapters) { - adapters.insert(make_pair(p->first, p->second->getProxy())); + adapters.insert({ id, servant->getProxy() }); } - amdCB->ice_response(_this, adapters, _activationTimeout, _deactivationTimeout); + response(_this, adapters, secondsToInt(_activationTimeout), secondsToInt(_deactivationTimeout)); } - return 0; + return nullptr; } if(!StopCommand::isStopped(_state) && !_stop) // Server is running and no stop is scheduled @@ -1181,28 +1152,28 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto } else { - _stop = new StopCommand(this, _node->getTimer(), _deactivationTimeout); + _stop = make_shared<StopCommand>(shared_from_this(), _node->getTimer(), _deactivationTimeout); } } if(!_load) { - _load = new LoadCommand(this, _desc, _node->getTraceLevels()); + _load = make_shared<LoadCommand>(shared_from_this(), _desc, _node->getTraceLevels()); } - _load->setUpdate(desc, _destroy); + _load->setUpdate(desc, _destroy != nullptr); if(_destroy && _state != Destroying) { _destroy->finished(); - _destroy = 0; + _destroy = nullptr; } if(_stop || StopCommand::isStopped(_state)) { - _load->addCallback(amdCB); // Load will return once the server is loaded. + _load->addCallback(response, exception); // Load will return once the server is loaded. } else { - if(_state >= ServerI::Activating && _state < ServerI::Active) + if(_state >= InternalServerState::Activating && _state < InternalServerState::Active) { // // If the server is being activated, return the response @@ -1212,30 +1183,30 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto // with the node. // AdapterPrxDict adapters; - for(ServerAdapterDict::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + for(const auto& adapter : _adapters) { - adapters.insert(make_pair(p->first, p->second->getProxy())); + adapters.insert({ adapter.first, adapter.second->getProxy() }); } - amdCB->ice_response(_this, adapters, _activationTimeout, _deactivationTimeout); + response(_this, adapters, secondsToInt(_activationTimeout), secondsToInt(_deactivationTimeout)); } - else if(_state == ServerI::Active) + else if(_state == InternalServerState::Active) { - _load->addCallback(amdCB); // Must be called before startRuntimePropertiesUpdate! + _load->addCallback(response, exception); // Must be called before startRuntimePropertiesUpdate! updateRevision(desc->uuid, desc->revision); _load->startRuntimePropertiesUpdate(_process); } else { - _load->addCallback(amdCB); + _load->addCallback(response, exception); } } return nextCommand(); } bool -ServerI::checkUpdate(const InternalServerDescriptorPtr& desc, bool noRestart, const Ice::Current&) +ServerI::checkUpdate(shared_ptr<InternalServerDescriptor> desc, bool noRestart, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); if(!_desc) @@ -1252,7 +1223,7 @@ ServerI::checkUpdate(const InternalServerDescriptorPtr& desc, bool noRestart, co return true; } - InternalServerDescriptorPtr d = _load ? _load->getInternalServerDescriptor() : _desc; + auto d = _load ? _load->getInternalServerDescriptor() : _desc; if(!descriptorUpdated(d, desc)) { return StopCommand::isStopped(_state); @@ -1278,7 +1249,7 @@ ServerI::checkUpdate(const InternalServerDescriptorPtr& desc, bool noRestart, co void ServerI::checkRemove(bool noRestart, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); if(noRestart && !StopCommand::isStopped(_state) && !_stop) @@ -1287,18 +1258,17 @@ ServerI::checkRemove(bool noRestart, const Ice::Current&) } } -ServerCommandPtr -ServerI::destroy(const AMD_Node_destroyServerPtr& amdCB, const string& uuid, int revision, const string& replicaName, - bool noRestart) +shared_ptr<ServerCommand> +ServerI::destroy(const string& uuid, int revision, const string& replicaName, bool noRestart, function<void()> response) { - Lock sync(*this); + lock_guard lock(_mutex); checkDestroyed(); checkRevision(replicaName, uuid, revision); if(!_desc) { - amdCB->ice_response(); - return 0; // Server is already destroyed. + response(); + return nullptr; // Server is already destroyed. } if(!StopCommand::isStopped(_state) && !_stop) @@ -1307,7 +1277,7 @@ ServerI::destroy(const AMD_Node_destroyServerPtr& amdCB, const string& uuid, int { throw DeploymentException("removal requires server to be stopped"); } - _stop = new StopCommand(this, _node->getTimer(), _deactivationTimeout); + _stop = make_shared<StopCommand>(shared_from_this(), _node->getTimer(), _deactivationTimeout); } if(!_destroy) @@ -1316,11 +1286,11 @@ ServerI::destroy(const AMD_Node_destroyServerPtr& amdCB, const string& uuid, int // If uuid is empty, the destroy call comes from the consistency check. In // this case, we clear the server directory only if it contains non-user data. // - _destroy = new DestroyCommand(this, false, !uuid.empty()); + _destroy = make_shared<DestroyCommand>(shared_from_this(), false, !uuid.empty()); } - if(amdCB) + if(response) { - _destroy->addCallback(amdCB); + _destroy->addCallback(move(response)); } return nextCommand(); } @@ -1328,13 +1298,13 @@ ServerI::destroy(const AMD_Node_destroyServerPtr& amdCB, const string& uuid, int void ServerI::adapterActivated(const string& id) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; ServerAdapterDict adpts; { - Lock sync(*this); - if(_state != ServerI::Activating && - _state != ServerI::WaitForActivation && - _state != ServerI::ActivationTimeout) + lock_guard lock(_mutex); + if(_state != InternalServerState::Activating && + _state != InternalServerState::WaitForActivation && + _state != InternalServerState::ActivationTimeout) { return; } @@ -1345,13 +1315,13 @@ ServerI::adapterActivated(const string& id) } command = nextCommand(); } - for(ServerAdapterDict::iterator r = adpts.begin(); r != adpts.end(); ++r) + for(const auto& adpt : adpts) { - if(r->first != id) + if(adpt.first != id) { try { - r->second->activationCompleted(); + adpt.second->activationCompleted(); } catch(const Ice::ObjectNotExistException&) { @@ -1367,18 +1337,16 @@ ServerI::adapterActivated(const string& id) void ServerI::adapterDeactivated(const string& id) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); - while(_state == ServerI::Activating) - { - wait(); // Wait for activate() to set the state to WaitForActivation - } + unique_lock lock(_mutex); + // Wait for activate() to set the state to WaitForActivation + _condVar.wait(lock, [this] { return _state != InternalServerState::Activating; }); if((_state == Active || _state == WaitForActivation) && _serverLifetimeAdapters.find(id) != _serverLifetimeAdapters.end()) { - _stop = new StopCommand(this, _node->getTimer(), _deactivationTimeout, false); + _stop = make_shared<StopCommand>(shared_from_this(), _node->getTimer(), _deactivationTimeout, false); } command = nextCommand(); } @@ -1413,27 +1381,27 @@ ServerI::disableOnFailure() // is always and the server wasn't active at the time of the // failure we disable the server. // - if(_disableOnFailure != 0 || (_activation == Always && (_state == Activating || _state == WaitForActivation))) + if(_disableOnFailure != 0s || (_activation == Always && (_state == Activating || _state == WaitForActivation))) { _previousActivation = _activation; _activation = Disabled; - _failureTime = IceUtil::Time::now(IceUtil::Time::Monotonic); + _failureTime = chrono::steady_clock::now(); } } void ServerI::activationTimedOut() { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; ServerAdapterDict adapters; { - Lock sync(*this); - if(_state != ServerI::WaitForActivation) + lock_guard lock(_mutex); + if(_state != InternalServerState::WaitForActivation) { return; } - setStateNoSync(ServerI::ActivationTimeout, "The server activation timed out."); + setStateNoSync(InternalServerState::ActivationTimeout, "The server activation timed out."); if(_node->getTraceLevels()->server > 1) { @@ -1444,11 +1412,11 @@ ServerI::activationTimedOut() command = nextCommand(); } - for(ServerAdapterDict::const_iterator p = adapters.begin(); p != adapters.end(); ++p) + for(const auto& adapter : adapters) { try { - p->second->activationFailed("server activation timed out"); + adapter.second->activationFailed("server activation timed out"); } catch(const Ice::ObjectNotExistException&) { @@ -1464,7 +1432,7 @@ ServerI::activationTimedOut() void ServerI::activate() { - InternalServerDescriptorPtr desc; + shared_ptr<InternalServerDescriptor> desc; ServerAdapterDict adpts; bool waitForReplication; @@ -1476,7 +1444,7 @@ ServerI::activate() try { { - Lock sync(*this); + lock_guard lock(_mutex); assert(_state == Activating && _desc); desc = _desc; adpts = _adapters; @@ -1510,11 +1478,18 @@ ServerI::activate() // if(waitForReplication) { - NodeSessionPrx session = _node->getMasterNodeSession(); + auto session = _node->getMasterNodeSession(); if(session) { - _node->getMasterNodeSession()->begin_waitForApplicationUpdate( - desc->uuid, desc->revision, ::Ice::newCallback(this, &ServerI::waitForApplicationUpdateCompleted)); + _node->getMasterNodeSession()->waitForApplicationUpdateAsync(desc->uuid, desc->revision, + [self = shared_from_this()] + { + self->waitForApplicationUpdateCompleted(); + }, + [self = shared_from_this()](exception_ptr) + { + self->waitForApplicationUpdateCompleted(); + }); return; } } @@ -1523,27 +1498,27 @@ ServerI::activate() // Compute the server command line options. // Ice::StringSeq options; - for(Ice::StringSeq::const_iterator p = desc->options.begin(); p != desc->options.end(); ++p) + for(const auto& opt : desc->options) { - if(!p->empty()) + if(!opt.empty()) { - options.push_back(*p); + options.push_back(opt); } } options.push_back("--Ice.Config=" + escapeProperty(_serverDir + "/config/config")); Ice::StringSeq envs; - transform(desc->envs.begin(), desc->envs.end(), back_inserter(envs), EnvironmentEval()); + transform(desc->envs.begin(), desc->envs.end(), back_inserter(envs), environmentEval); // // Clear the adapters direct proxy (this is usefull if the server // was manually activated). // - for(ServerAdapterDict::iterator p = adpts.begin(); p != adpts.end(); ++p) + for(const auto& adpt : adpts) { try { - p->second->clear(); + adpt.second->clear(); } catch(const Ice::ObjectNotExistException&) { @@ -1551,28 +1526,28 @@ ServerI::activate() } #ifndef _WIN32 - int pid = _node->getActivator()->activate(desc->id, desc->exe, desc->pwd, uid, gid, options, envs, this); + int pid = _node->getActivator()->activate(desc->id, desc->exe, desc->pwd, uid, gid, options, envs, shared_from_this()); #else - int pid = _node->getActivator()->activate(desc->id, desc->exe, desc->pwd, options, envs, this); + int pid = _node->getActivator()->activate(desc->id, desc->exe, desc->pwd, options, envs, shared_from_this()); #endif - ServerCommandPtr command; + shared_ptr<ServerCommand> command; bool active = false; { - Lock sync(*this); + lock_guard lock(_mutex); assert(_state == Activating); _pid = pid; - setStateNoSync(ServerI::WaitForActivation); + setStateNoSync(InternalServerState::WaitForActivation); active = checkActivation(); command = nextCommand(); - notifyAll(); // Terminated might be waiting for the state change. + _condVar.notify_all(); // Terminated might be waiting for the state change. } if(active) { - for(ServerAdapterDict::iterator r = adpts.begin(); r != adpts.end(); ++r) + for(const auto& adpt : adpts) { try { - r->second->activationCompleted(); + adpt.second->activationCompleted(); } catch(const Ice::ObjectNotExistException&) { @@ -1599,16 +1574,16 @@ ServerI::activate() } { - Lock sync(*this); + lock_guard lock(_mutex); disableOnFailure(); - setStateNoSync(ServerI::Deactivating, failure); + setStateNoSync(InternalServerState::Deactivating, failure); } - for(ServerAdapterDict::iterator r = adpts.begin(); r != adpts.end(); ++r) + for(const auto& adpt : adpts) { try { - r->second->activationFailed(failure); + adpt.second->activationFailed(failure); } catch(const Ice::ObjectNotExistException&) { @@ -1622,7 +1597,7 @@ void ServerI::kill() { { - Lock sync(*this); + lock_guard lock(_mutex); if(_state != Destroying && _state != Deactivating && _state != DeactivatingWaitForProcess) { return; @@ -1645,9 +1620,9 @@ ServerI::kill() void ServerI::deactivate() { - Ice::ProcessPrx process; + shared_ptr<Ice::ProcessPrx> process; { - Lock sync(*this); + lock_guard lock(_mutex); if(_state != Deactivating && _state != DeactivatingWaitForProcess) { return; @@ -1662,7 +1637,7 @@ ServerI::deactivate() // if(_desc->processRegistered && !_process) { - setStateNoSync(ServerI::DeactivatingWaitForProcess); + setStateNoSync(InternalServerState::DeactivatingWaitForProcess); return; } process = _process; @@ -1673,7 +1648,7 @@ ServerI::deactivate() // // Deactivate the server and for the termination of the server. // - _node->getActivator()->deactivate(_id, process); + _node->getActivator()->deactivate(_id, move(process)); return; } catch(const Ice::Exception& ex) @@ -1705,13 +1680,13 @@ ServerI::destroy() { ServerAdapterDict adpts; { - Lock sync(*this); + lock_guard lock(_mutex); assert(_desc); assert(_state == Destroying); adpts = _adapters; } - _node->removeServer(this, _desc->application); + _node->removeServer(shared_from_this(), _desc->application); // // Remove the server directory only if the clear dir flag is set (user @@ -1737,11 +1712,11 @@ ServerI::destroy() // // Destroy the object adapters. // - for(ServerAdapterDict::const_iterator p = adpts.begin(); p != adpts.end(); ++p) + for(const auto& adpt : adpts) { try { - p->second->destroy(); + adpt.second->destroy(); } catch(const Ice::LocalException&) { @@ -1756,11 +1731,10 @@ ServerI::terminated(const string& msg, int status) { ServerAdapterDict adpts; { - Lock sync(*this); - while(_state == ServerI::Activating) - { - wait(); // Wait for activate() to set the state to WaitForActivation - } + unique_lock lock(_mutex); + + // Wait for activate() to set the state to WaitForActivation + _condVar.wait(lock, [this] { return _state != Activating; }); adpts = _adapters; _activatedAdapters.clear(); @@ -1782,9 +1756,9 @@ ServerI::terminated(const string& msg, int status) disableOnFailure(); } - if(_state != ServerI::Deactivating && - _state != ServerI::DeactivatingWaitForProcess && - _state != ServerI::Destroying) + if(_state != InternalServerState::Deactivating && + _state != InternalServerState::DeactivatingWaitForProcess && + _state != InternalServerState::Destroying) { ostringstream os; os << "The server terminated unexpectedly"; @@ -1801,7 +1775,7 @@ ServerI::terminated(const string& msg, int status) os << " with exit code " << status; #endif os << (msg.empty() ? string(".") : ":\n" + msg); - setStateNoSync(ServerI::Deactivating, os.str()); + setStateNoSync(InternalServerState::Deactivating, os.str()); } } @@ -1810,11 +1784,11 @@ ServerI::terminated(const string& msg, int status) // null to cause the server re-activation if one of its adapter // direct proxy is requested. // - for(ServerAdapterDict::iterator p = adpts.begin(); p != adpts.end(); ++p) + for(const auto& adpt : adpts) { try { - p->second->setDirectProxy(0, Ice::emptyCurrent); + adpt.second->setDirectProxy(nullptr, Ice::emptyCurrent); } catch(const Ice::ObjectNotExistException&) { @@ -1822,16 +1796,16 @@ ServerI::terminated(const string& msg, int status) } bool doDestroy = false; - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); - if(_state == ServerI::Destroying) + lock_guard lock(_mutex); + if(_state == InternalServerState::Destroying) { doDestroy = true; } else { - setStateNoSync(ServerI::Inactive); + setStateNoSync(InternalServerState::Inactive); command = nextCommand(); } } @@ -1848,27 +1822,27 @@ ServerI::terminated(const string& msg, int status) void ServerI::shutdown() { - Lock sync(*this); - assert(_state == ServerI::Inactive); + lock_guard lock(_mutex); + assert(_state == InternalServerState::Inactive); assert(!_destroy); assert(!_stop); assert(!_load); assert(!_start); - _timerTask = 0; + _timerTask = nullptr; } void ServerI::update() { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); - if(_state != ServerI::Loading) + lock_guard lock(_mutex); + if(_state != InternalServerState::Loading) { return; } - InternalServerDescriptorPtr oldDescriptor = _desc; + auto oldDescriptor = _desc; bool disabled = oldDescriptor && _activation == Disabled; try { @@ -1901,8 +1875,8 @@ ServerI::update() { if(oldDescriptor->application != _desc->application) { - _node->removeServer(this, oldDescriptor->application); - _node->addServer(this, _desc->application); + _node->removeServer(shared_from_this(), oldDescriptor->application); + _node->addServer(shared_from_this(), _desc->application); } if(_node->getTraceLevels()->server > 0) @@ -1913,13 +1887,13 @@ ServerI::update() } else { - _node->addServer(this, _desc->application); + _node->addServer(shared_from_this(), _desc->application); } AdapterPrxDict adapters; - for(ServerAdapterDict::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + for(const auto& adpt : _adapters) { - adapters.insert(make_pair(p->first, p->second->getProxy())); + adapters.insert({ adpt.first, adpt.second->getProxy() }); } _load->finished(_this, adapters, _activationTimeout, _deactivationTimeout); } @@ -1937,7 +1911,7 @@ ServerI::update() catch(const Ice::Exception& e) { Ice::Warning out(_node->getTraceLevels()->logger); - out << "update failed:\n" << ex.reason << "\nand couldn't rollback old descriptor:\n" << e; + out << "update failed:\n" << ex.reason << "\nand couldn't rollback old descriptor:\n" << e.what(); } catch(const exception& e) { @@ -1947,10 +1921,10 @@ ServerI::update() } else if(!_destroy) { - _destroy = new DestroyCommand(this, true, true); + _destroy = make_shared<DestroyCommand>(shared_from_this(), true, true); } - _load->failed(ex); + _load->failed(current_exception()); } if(oldDescriptor && disabled != (_activation == Disabled)) @@ -1967,7 +1941,7 @@ ServerI::update() } void -ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) +ServerI::updateImpl(const shared_ptr<InternalServerDescriptor>& descriptor) { assert(_load && descriptor); @@ -1993,27 +1967,26 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) ServerAdapterDict oldAdapters; oldAdapters.swap(_adapters); _serverLifetimeAdapters.clear(); - Ice::ObjectAdapterPtr adapter = _node->getAdapter(); - for(InternalAdapterDescriptorSeq::const_iterator r = _desc->adapters.begin(); r != _desc->adapters.end(); ++r) + auto adapter = _node->getAdapter(); + for(const auto& adpt : _desc->adapters) { try { - Ice::Identity id; - id.category = _this->ice_getIdentity().category + "Adapter"; - id.name = _id + "-" + (*r)->id; - ServerAdapterIPtr servant = ServerAdapterIPtr::dynamicCast(adapter->find(id)); + Ice::Identity id = { _id + "-" + adpt->id, _this->ice_getIdentity().category + "Adapter" }; + auto servant = dynamic_pointer_cast<ServerAdapterI>(adapter->find(id)); if(!servant) { - AdapterPrx proxy = AdapterPrx::uncheckedCast(adapter->createProxy(id)); - servant = new ServerAdapterI(_node, this, _id, proxy, (*r)->id, _activation != Disabled || - _failureTime != IceUtil::Time()); + auto proxy = Ice::uncheckedCast<AdapterPrx>(adapter->createProxy(id)); + servant = make_shared<ServerAdapterI>(_node, this, _id, proxy, adpt->id, + _activation != Disabled || + _failureTime != nullopt); adapter->add(servant, id); } - _adapters.insert(make_pair((*r)->id, servant)); + _adapters.insert(make_pair(adpt->id, servant)); - if((*r)->serverLifetime) + if(adpt->serverLifetime) { - _serverLifetimeAdapters.insert((*r)->id); + _serverLifetimeAdapters.insert(adpt->id); } } catch(const Ice::ObjectAdapterDeactivatedException&) @@ -2023,19 +1996,19 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) catch(const Ice::LocalException& ex) { Ice::Error out(_node->getTraceLevels()->logger); - out << "couldn't add adapter `" << (*r)->id << "':\n" << ex; + out << "couldn't add adapter `" << adpt->id << "':\n" << ex; } - oldAdapters.erase((*r)->id); + oldAdapters.erase(adpt->id); } // // Remove old object adapters. // - for(ServerAdapterDict::const_iterator t = oldAdapters.begin(); t != oldAdapters.end(); ++t) + for(const auto& adpt : oldAdapters) { try { - t->second->destroy(); + adpt.second->destroy(); } catch(const Ice::ObjectAdapterDeactivatedException&) { @@ -2044,7 +2017,7 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) catch(const Ice::LocalException& ex) { Ice::Error out(_node->getTraceLevels()->logger); - out << "couldn't destroy adapter `" << t->first << "':\n" << ex; + out << "couldn't destroy adapter `" << adpt.first << "':\n" << ex; } } } @@ -2056,27 +2029,44 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) // disabled and failure time isn't set, we don't change the // activation since the user explicitely disabled the server. // - if(_activation != Disabled || _failureTime != IceUtil::Time()) + if(_activation != Disabled || _failureTime != nullopt) { _activation = toServerActivation(_desc->activation); - _failureTime = IceUtil::Time(); + _failureTime = nullopt; } if(_timerTask) { _node->getTimer()->cancel(_timerTask); - _timerTask = 0; + _timerTask = nullptr; } checkAndUpdateUser(_desc, true); // we pass true to update _uid/_gid. - istringstream at(_desc->activationTimeout); - if(!(at >> _activationTimeout) || !at.eof() || _activationTimeout == 0) + try + { + _activationTimeout = chrono::seconds(stoi(_desc->activationTimeout)); + } + catch(const std::exception&) + { + _activationTimeout = 0s; + } + + if(_activationTimeout == 0s) { _activationTimeout = _waitTime; } - istringstream dt(_desc->deactivationTimeout); - if(!(dt >> _deactivationTimeout) || !dt.eof() || _deactivationTimeout == 0) + + try + { + _deactivationTimeout = chrono::seconds(stoi(_desc->deactivationTimeout)); + } + catch(const std::exception&) + { + _deactivationTimeout = 0s; + } + + if (_deactivationTimeout == 0s) { _deactivationTimeout = _waitTime; } @@ -2085,9 +2075,9 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) // Simplify the log paths and transform relative paths into // absolute paths, also make sure the logs are sorted. // - for(Ice::StringSeq::const_iterator p = _desc->logs.begin(); p != _desc->logs.end(); ++p) + for(const auto& log : _desc->logs) { - string path = simplify(*p); + string path = simplify(log); if(IceUtilInternal::isAbsolutePath(path)) { _logs.push_back(path); @@ -2105,7 +2095,7 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) _stdOutFile = getProperty(props, "Ice.StdOut"); // - // If the server is a session server and it wasn't udpated but + // If the server is a session server and it wasn't updated but // just released by a session, we don't update the configuration, // it will be done when the server is re-allocated. // @@ -2136,26 +2126,26 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) // previous to Ice 3.3. // Ice::StringSeq knownFiles; - for(PropertyDescriptorSeqDict::const_iterator p = properties.begin(); p != properties.end(); ++p) + for(const auto& prop : properties) { - knownFiles.push_back(p->first); + knownFiles.push_back(prop.first); - const string configFilePath = _serverDir + "/config/" + p->first; + const string configFilePath = _serverDir + "/config/" + prop.first; ofstream configfile(IceUtilInternal::streamFilename(configFilePath).c_str()); // configFilePath is a UTF-8 string if(!configfile.good()) { throw runtime_error("couldn't create configuration file: " + configFilePath); } configfile << "# Configuration file (" << IceUtil::Time::now().toDateTime() << ")" << endl << endl; - for(PropertyDescriptorSeq::const_iterator r = p->second.begin(); r != p->second.end(); ++r) + for(const auto& propertyDescriptor : prop.second) { - if(r->value.empty() && r->name.find('#') == 0) + if(propertyDescriptor.value.empty() && propertyDescriptor.name.find('#') == 0) { - configfile << r->name << endl; + configfile << propertyDescriptor.name << endl; } else { - configfile << r->name << "=" << r->value << endl; + configfile << propertyDescriptor.name << "=" << propertyDescriptor.value << endl; } } configfile.close(); @@ -2167,19 +2157,19 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) // Ice::StringSeq files = readDirectory(_serverDir + "/config"); Ice::StringSeq toDel; - set_difference(files.begin(), files.end(), knownFiles.begin(), knownFiles.end(), back_inserter(toDel)); - for(Ice::StringSeq::const_iterator q = toDel.begin(); q != toDel.end(); ++q) + std::set_difference(files.begin(), files.end(), knownFiles.begin(), knownFiles.end(), back_inserter(toDel)); + for(const auto& str : toDel) { - if(q->find("config_") == 0) + if(str.find("config_") == 0) { try { - remove(_serverDir + "/config/" + *q); + remove(_serverDir + "/config/" + str); } catch(const exception& ex) { Ice::Warning out(_node->getTraceLevels()->logger); - out << "couldn't remove file `" << _serverDir << "/config/" << *q << "':\n" << ex.what(); + out << "couldn't remove file `" << _serverDir << "/config/" << str << "':\n" << ex.what(); } } } @@ -2203,86 +2193,25 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor) // Ice::StringSeq dirs = readDirectory(_serverDir); Ice::StringSeq svcDirs; - for(Ice::StringSeq::const_iterator p = dirs.begin(); p != dirs.end(); ++p) + for(const auto& dir : dirs) { - if(p->find("data_") == 0) + if(dir.find("data_") == 0) { - svcDirs.push_back(*p); + svcDirs.push_back(dir); } } Ice::StringSeq toDel; - set_difference(svcDirs.begin(), svcDirs.end(), knownDirs.begin(), knownDirs.end(), back_inserter(toDel)); - for(Ice::StringSeq::const_iterator p = toDel.begin(); p != toDel.end(); ++p) - { - try - { - removeRecursive(_serverDir + "/" + *p); - } - catch(const exception& ex) - { - Ice::Warning out(_node->getTraceLevels()->logger); - out << "couldn't remove directory `" << _serverDir << "/" << *p << "':\n" << ex.what(); - } - } - } - - // - // Update the database environments if necessary and remove the - // old ones. - // - { - Ice::StringSeq knownDbEnvs; - for(InternalDbEnvDescriptorSeq::const_iterator q = _desc->dbEnvs.begin(); q != _desc->dbEnvs.end(); ++q) - { - knownDbEnvs.push_back((*q)->name); - - string dbEnvHome = _serverDir + "/dbs/" + (*q)->name; - createDirectory(dbEnvHome); - - if(!(*q)->properties.empty()) - { - string file = dbEnvHome + "/DB_CONFIG"; - - ofstream configfile(IceUtilInternal::streamFilename(file).c_str()); // file is a UTF-8 string - if(!configfile.good()) - { - throw runtime_error("couldn't create configuration file `" + file + "'"); - } - - for(PropertyDescriptorSeq::const_iterator p = (*q)->properties.begin(); - p != (*q)->properties.end(); ++p) - { - if(!p->name.empty()) - { - configfile << p->name; - if(!p->value.empty()) - { - configfile << " " << p->value; - } - configfile << endl; - } - } - configfile.close(); - } - } - sort(knownDbEnvs.begin(), knownDbEnvs.end()); - - // - // Remove old database environments. - // - Ice::StringSeq dbEnvs = readDirectory(_serverDir + "/dbs"); - Ice::StringSeq toDel; - set_difference(dbEnvs.begin(), dbEnvs.end(), knownDbEnvs.begin(), knownDbEnvs.end(), back_inserter(toDel)); - for(Ice::StringSeq::const_iterator p = toDel.begin(); p != toDel.end(); ++p) + std::set_difference(svcDirs.begin(), svcDirs.end(), knownDirs.begin(), knownDirs.end(), back_inserter(toDel)); + for(const auto& str : toDel) { try { - removeRecursive(_serverDir + "/dbs/" + *p); + removeRecursive(_serverDir + "/" + str); } catch(const exception& ex) { Ice::Warning out(_node->getTraceLevels()->logger); - out << "couldn't remove directory `" << _serverDir << "/dbs/" << *p << "':\n" << ex.what(); + out << "couldn't remove directory `" << _serverDir << "/" << str << "':\n" << ex.what(); } } } @@ -2345,7 +2274,7 @@ ServerI::checkRevision(const string& replicaName, const string& uuid, int revisi } void -ServerI::checkNoRestart(const InternalServerDescriptorPtr& desc) +ServerI::checkNoRestart(const shared_ptr<InternalServerDescriptor>& desc) { assert(_desc); @@ -2362,10 +2291,10 @@ ServerI::checkNoRestart(const InternalServerDescriptorPtr& desc) #ifndef _WIN32 void -ServerI::checkAndUpdateUser(const InternalServerDescriptorPtr& desc, bool update) +ServerI::checkAndUpdateUser(const shared_ptr<InternalServerDescriptor>& desc, bool update) #else void -ServerI::checkAndUpdateUser(const InternalServerDescriptorPtr& desc, bool /*update*/) +ServerI::checkAndUpdateUser(const shared_ptr<InternalServerDescriptor>& desc, bool /*update*/) #endif { #ifndef _WIN32 @@ -2400,7 +2329,7 @@ ServerI::checkAndUpdateUser(const InternalServerDescriptorPtr& desc, bool /*upda if(!user.empty()) { - UserAccountMapperPrx mapper = _node->getUserAccountMapper(); + auto mapper = _node->getUserAccountMapper(); if(mapper) { try @@ -2529,9 +2458,9 @@ ServerI::updateRevision(const string& uuid, int revision) } void -ServerI::updateRuntimePropertiesCallback(const InternalServerDescriptorPtr& desc) +ServerI::updateRuntimePropertiesCallback(const shared_ptr<InternalServerDescriptor>& desc) { - Lock sync(*this); + lock_guard lock(_mutex); if(_state != Active || !_load) { return; @@ -2540,18 +2469,18 @@ ServerI::updateRuntimePropertiesCallback(const InternalServerDescriptorPtr& desc if(_load->finishRuntimePropertiesUpdate(desc, _process)) { AdapterPrxDict adapters; - for(ServerAdapterDict::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + for(const auto& [id, servant] : _adapters) { - adapters.insert(make_pair(p->first, p->second->getProxy())); + adapters.insert({ id, servant->getProxy() }); } _load->finished(_this, adapters, _activationTimeout, _deactivationTimeout); } } void -ServerI::updateRuntimePropertiesCallback(const Ice::Exception& ex, const InternalServerDescriptorPtr& desc) +ServerI::updateRuntimePropertiesCallback(exception_ptr ex, const shared_ptr<InternalServerDescriptor>& desc) { - Lock sync(*this); + lock_guard lock(_mutex); if(_state != Active || !_load) { return; @@ -2567,7 +2496,7 @@ bool ServerI::checkActivation() { //assert(locked()); - if(_state == ServerI::WaitForActivation || _state == ServerI::ActivationTimeout) + if(_state == InternalServerState::WaitForActivation || _state == InternalServerState::ActivationTimeout) { // // Mark the server as active if the server process proxy is registered (or it's not expecting @@ -2577,7 +2506,7 @@ ServerI::checkActivation() includes(_activatedAdapters.begin(), _activatedAdapters.end(), _serverLifetimeAdapters.begin(), _serverLifetimeAdapters.end())) { - setStateNoSync(ServerI::Active); + setStateNoSync(InternalServerState::Active); return true; } } @@ -2587,9 +2516,9 @@ ServerI::checkActivation() void ServerI::setState(InternalServerState st, const std::string& reason) { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; { - Lock sync(*this); + lock_guard lock(_mutex); setStateNoSync(st, reason); command = nextCommand(); } @@ -2599,10 +2528,10 @@ ServerI::setState(InternalServerState st, const std::string& reason) } } -ServerCommandPtr +shared_ptr<ServerCommand> ServerI::nextCommand() { - ServerCommandPtr command; + shared_ptr<ServerCommand> command; if(_stop && _stop->canExecute(_state)) { command = _stop; @@ -2627,7 +2556,7 @@ ServerI::nextCommand() } void -ServerI::setStateNoSync(InternalServerState st, const std::string& reason) +ServerI::setStateNoSync(InternalServerState st, const string& reason) { // // Ensure that the given state can be switched to. @@ -2680,51 +2609,51 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason) case Inactive: if(previous == Loading) { - _load = 0; + _load = nullptr; } if(_stop) { _stop->finished(); - _stop = 0; + _stop = nullptr; } break; case Active: if(_start) { _start->finished(); - _start = 0; + _start = nullptr; } break; case ActivationTimeout: if(_start) { _start->failed(reason); - _start = 0; + _start = nullptr; } break; case Deactivating: if(_start) { _start->failed(reason.empty() ? string("The server is being deactivated.") : reason); - _start = 0; + _start = nullptr; } break; case Destroying: loadFailure = _destroy->loadFailure(); if(_load) { - _load->failed(DeploymentException("The server is being destroyed.")); - _load = 0; + _load->failed(make_exception_ptr(DeploymentException("The server is being destroyed."))); + _load = nullptr; } if(_start) { _start->failed("The server is being destroyed."); - _start = 0; + _start = nullptr; } if(_stop) { _stop->failed("The server is being destroyed."); - _stop = 0; + _stop = nullptr; } break; case Destroyed: @@ -2732,9 +2661,9 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason) { loadFailure = _destroy->loadFailure(); _destroy->finished(); - _destroy = 0; + _destroy = nullptr; } - notifyAll(); // for getProperties() + _condVar.notify_all(); // for getProperties() break; default: break; @@ -2743,7 +2672,7 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason) if(_timerTask) { _node->getTimer()->cancel(_timerTask); - _timerTask = 0; + _timerTask = nullptr; } if(_state == Destroyed && !_load) @@ -2760,14 +2689,14 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason) { // IGNORE } - _desc = 0; + _desc = nullptr; } else if(_state == Inactive) { if(_activation == Always) { assert(!_timerTask); - _timerTask = new DelayedStart(this, _node->getTraceLevels()); + _timerTask = make_shared<DelayedStart>(shared_from_this(), _node->getTraceLevels()); try { _node->getTimer()->schedule(_timerTask, IceUtil::Time::milliSeconds(500)); @@ -2777,7 +2706,9 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason) // Ignore, timer is destroyed because node is shutting down. } } - else if(_activation == Disabled && _disableOnFailure > 0 && _failureTime != IceUtil::Time()) + else if(_activation == Disabled && + _disableOnFailure > 0s && + _failureTime != nullopt ) { // // If the server was disabled because it failed, we @@ -2787,15 +2718,15 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason) // callback is executed. // assert(!_timerTask); - _timerTask = new DelayedStart(this, _node->getTraceLevels()); + _timerTask = make_shared<DelayedStart>(shared_from_this(), _node->getTraceLevels()); try { - IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic); - if(now - _failureTime < IceUtil::Time::seconds(_disableOnFailure)) + using namespace std::chrono; + auto now = steady_clock::now(); + if(now - *_failureTime < _disableOnFailure) { - _node->getTimer()->schedule(_timerTask, - IceUtil::Time::seconds(_disableOnFailure) - now + _failureTime + - IceUtil::Time::milliSeconds(500)); + auto delay = duration_cast<milliseconds>(_disableOnFailure - (now - *_failureTime)); + _node->getTimer()->schedule(_timerTask, IceUtil::Time::milliSeconds((delay + 500ms).count())); } else { @@ -2892,26 +2823,26 @@ ServerI::toServerState(InternalServerState st) const { switch(st) { - case ServerI::Inactive: - case ServerI::Activating: - case ServerI::Loading: - return IceGrid::Inactive; - case ServerI::WaitForActivation: - return IceGrid::Activating; - case ServerI::ActivationTimeout: - return IceGrid::ActivationTimedOut; - case ServerI::Active: - return IceGrid::Active; - case ServerI::Deactivating: - case ServerI::DeactivatingWaitForProcess: - return IceGrid::Deactivating; - case ServerI::Destroying: - return IceGrid::Destroying; - case ServerI::Destroyed: - return IceGrid::Destroyed; + case InternalServerState::Inactive: + case InternalServerState::Activating: + case InternalServerState::Loading: + return ServerState::Inactive; + case InternalServerState::WaitForActivation: + return ServerState::Activating; + case InternalServerState::ActivationTimeout: + return ServerState::ActivationTimedOut; + case InternalServerState::Active: + return ServerState::Active; + case InternalServerState::Deactivating: + case InternalServerState::DeactivatingWaitForProcess: + return ServerState::Deactivating; + case InternalServerState::Destroying: + return ServerState::Destroying; + case InternalServerState::Destroyed: + return ServerState::Destroyed; default: assert(false); - return IceGrid::Destroyed; + return ServerState::Destroyed; } } @@ -2998,7 +2929,7 @@ ServerI::getFilePath(const string& filename) const } PropertyDescriptorSeqDict -ServerI::getProperties(const InternalServerDescriptorPtr& desc) +ServerI::getProperties(const shared_ptr<InternalServerDescriptor>& desc) { // // Copy the descriptor properties. @@ -3038,7 +2969,7 @@ ServerI::getProperties(const InternalServerDescriptorPtr& desc) { if(getProperty(p->second, "Ice.Default.Locator").empty()) { - Ice::PropertiesPtr properties = _node->getCommunicator()->getProperties(); + auto properties = _node->getCommunicator()->getProperties(); string locator = properties->getProperty("Ice.Default.Locator"); if(!locator.empty()) diff --git a/cpp/src/IceGrid/ServerI.h b/cpp/src/IceGrid/ServerI.h index a41fc9efd0d..22ae58ed6b5 100644 --- a/cpp/src/IceGrid/ServerI.h +++ b/cpp/src/IceGrid/ServerI.h @@ -5,10 +5,11 @@ #ifndef ICE_GRID_SERVER_I_H #define ICE_GRID_SERVER_I_H -#include <IceUtil/Mutex.h> #include <IceUtil/Timer.h> #include <IceGrid/Activator.h> #include <IceGrid/Internal.h> + +#include <optional> #include <set> #ifndef _WIN32 @@ -19,21 +20,14 @@ namespace IceGrid { class NodeI; -typedef IceUtil::Handle<NodeI> NodeIPtr; class ServerAdapterI; -typedef IceUtil::Handle<ServerAdapterI> ServerAdapterIPtr; class ServerCommand; -typedef IceUtil::Handle<ServerCommand> ServerCommandPtr; class DestroyCommand; -typedef IceUtil::Handle<DestroyCommand> DestroyCommandPtr; class StopCommand; -typedef IceUtil::Handle<StopCommand> StopCommandPtr; class StartCommand; -typedef IceUtil::Handle<StartCommand> StartCommandPtr; class LoadCommand; -typedef IceUtil::Handle<LoadCommand> LoadCommandPtr; -class ServerI : public Server, public IceUtil::Monitor<IceUtil::Mutex> +class ServerI final : public Server, public std::enable_shared_from_this<ServerI> { public: @@ -67,34 +61,37 @@ public: # pragma clang diagnostic pop #endif - ServerI(const NodeIPtr&, const ServerPrx&, const std::string&, const std::string&, int); - virtual ~ServerI(); + ServerI(const std::shared_ptr<NodeI>&, const std::shared_ptr<ServerPrx>&, + const std::string&, const std::string&, int); - void waitForApplicationUpdateCompleted(const Ice::AsyncResultPtr&); + void waitForApplicationUpdateCompleted(); - virtual void start_async(const AMD_Server_startPtr&, const ::Ice::Current&); - virtual void stop_async(const AMD_Server_stopPtr&, const ::Ice::Current&); - virtual void sendSignal(const std::string&, const ::Ice::Current&); - virtual void writeMessage(const std::string&, Ice::Int, const ::Ice::Current&); + void startAsync(std::function<void()>, std::function<void(std::exception_ptr)>, const Ice::Current&) override; + void stopAsync(std::function<void()>, std::function<void(std::exception_ptr)>, const Ice::Current&) override; + void sendSignal(std::string, const Ice::Current&) override; + void writeMessage(std::string, int, const Ice::Current&) override; - virtual ServerState getState(const ::Ice::Current&) const; - virtual Ice::Int getPid(const ::Ice::Current&) const; + ServerState getState(const Ice::Current&) const override; + int getPid(const Ice::Current&) const override; - virtual void setEnabled(bool, const ::Ice::Current&); - virtual bool isEnabled(const ::Ice::Current&) const; - virtual void setProcess_async(const AMD_Server_setProcessPtr&, const ::Ice::ProcessPrx&, const ::Ice::Current&); + void setEnabled(bool, const Ice::Current&) override; + bool isEnabled(const Ice::Current&) const override; + void setProcessAsync(std::shared_ptr<Ice::ProcessPrx>, std::function<void()>, + std::function<void(std::exception_ptr)>, const Ice::Current&) override; - virtual Ice::Long getOffsetFromEnd(const std::string&, int, const Ice::Current&) const; - virtual bool read(const std::string&, Ice::Long, int, Ice::Long&, Ice::StringSeq&, const Ice::Current&) const; + long long getOffsetFromEnd(std::string, int, const Ice::Current&) const override; + bool read(std::string, long long, int, long long&, Ice::StringSeq&, const Ice::Current&) const override; bool isAdapterActivatable(const std::string&) const; const std::string& getId() const; - void start(ServerActivation, const AMD_Server_startPtr& = AMD_Server_startPtr()); - ServerCommandPtr load(const AMD_Node_loadServerPtr&, const InternalServerDescriptorPtr&, const std::string&, bool); - bool checkUpdate(const InternalServerDescriptorPtr&, bool, const Ice::Current&); + void start(ServerActivation, std::function<void()> = nullptr, std::function<void(std::exception_ptr)> = nullptr); + std::shared_ptr<ServerCommand> load(const std::shared_ptr<InternalServerDescriptor>&, const std::string&, bool, + std::function<void(const std::shared_ptr<ServerPrx> &, const AdapterPrxDict &, int, int)>, + std::function<void(std::exception_ptr)>); + bool checkUpdate(std::shared_ptr<InternalServerDescriptor>, bool, const Ice::Current&) override; void checkRemove(bool, const Ice::Current&); - ServerCommandPtr destroy(const AMD_Node_destroyServerPtr&, const std::string&, int, const std::string&, bool); + std::shared_ptr<ServerCommand> destroy(const std::string&, int, const std::string &, bool, std::function<void()>); void adapterActivated(const std::string&); void adapterDeactivated(const std::string&); @@ -111,26 +108,26 @@ public: // // A proxy to the Process facet of the real Admin object; called by the AdminFacade servant implementation // - Ice::ObjectPrx getProcess() const; + std::shared_ptr<Ice::ObjectPrx> getProcess() const; - PropertyDescriptorSeqDict getProperties(const InternalServerDescriptorPtr&); + PropertyDescriptorSeqDict getProperties(const std::shared_ptr<InternalServerDescriptor>&); - void updateRuntimePropertiesCallback(const InternalServerDescriptorPtr&); - void updateRuntimePropertiesCallback(const Ice::Exception&, const InternalServerDescriptorPtr&); + void updateRuntimePropertiesCallback(const std::shared_ptr<InternalServerDescriptor>&); + void updateRuntimePropertiesCallback(std::exception_ptr, const std::shared_ptr<InternalServerDescriptor>&); private: - void updateImpl(const InternalServerDescriptorPtr&); + void updateImpl(const std::shared_ptr<InternalServerDescriptor>&); void checkRevision(const std::string&, const std::string&, int) const; - void checkNoRestart(const InternalServerDescriptorPtr&); - void checkAndUpdateUser(const InternalServerDescriptorPtr&, bool); + void checkNoRestart(const std::shared_ptr<InternalServerDescriptor>&); + void checkAndUpdateUser(const std::shared_ptr<InternalServerDescriptor>&, bool); void updateRevision(const std::string&, int); bool checkActivation(); void checkDestroyed() const; void disableOnFailure(); void setState(InternalServerState, const std::string& = std::string()); - ServerCommandPtr nextCommand(); + std::shared_ptr<ServerCommand> nextCommand(); void setStateNoSync(InternalServerState, const std::string& = std::string()); ServerState toServerState(InternalServerState) const; @@ -138,66 +135,68 @@ private: ServerDynamicInfo getDynamicInfo() const; std::string getFilePath(const std::string&) const; - const NodeIPtr _node; - const ServerPrx _this; + const std::shared_ptr<NodeI> _node; + const std::shared_ptr<ServerPrx> _this; const std::string _id; - const Ice::Int _waitTime; + const std::chrono::seconds _waitTime; const std::string _serverDir; - const int _disableOnFailure; + const std::chrono::seconds _disableOnFailure; - InternalServerDescriptorPtr _desc; + std::shared_ptr<InternalServerDescriptor> _desc; #ifndef _WIN32 uid_t _uid; gid_t _gid; #endif InternalServerState _state; ServerActivation _activation; - int _activationTimeout; - int _deactivationTimeout; - typedef std::map<std::string, ServerAdapterIPtr> ServerAdapterDict; + std::chrono::seconds _activationTimeout; + std::chrono::seconds _deactivationTimeout; + using ServerAdapterDict = std::map<std::string, std::shared_ptr<ServerAdapterI>> ; ServerAdapterDict _adapters; std::set<std::string> _serverLifetimeAdapters; - Ice::ProcessPrx _process; + std::shared_ptr<Ice::ProcessPrx> _process; std::set<std::string> _activatedAdapters; - IceUtil::Time _failureTime; + std::optional<std::chrono::steady_clock::time_point> _failureTime; ServerActivation _previousActivation; - IceUtil::TimerTaskPtr _timerTask; + std::shared_ptr<IceUtil::TimerTask>_timerTask; bool _waitForReplication; std::string _stdErrFile; std::string _stdOutFile; Ice::StringSeq _logs; PropertyDescriptorSeq _properties; - DestroyCommandPtr _destroy; - StopCommandPtr _stop; - LoadCommandPtr _load; - StartCommandPtr _start; + std::shared_ptr<DestroyCommand> _destroy; + std::shared_ptr<StopCommand> _stop; + std::shared_ptr<LoadCommand> _load; + std::shared_ptr<StartCommand> _start; int _pid; + + mutable std::mutex _mutex; + std::condition_variable _condVar; }; -typedef IceUtil::Handle<ServerI> ServerIPtr; -class ServerCommand : public IceUtil::SimpleShared +class ServerCommand { public: - ServerCommand(const ServerIPtr&); - virtual ~ServerCommand(); + ServerCommand(const std::shared_ptr<ServerI>&); + virtual ~ServerCommand() = default; + virtual bool canExecute(ServerI::InternalServerState) = 0; virtual void execute() = 0; virtual ServerI::InternalServerState nextState() = 0; protected: - const ServerIPtr _server; + const std::shared_ptr<ServerI> _server; }; -typedef IceUtil::Handle<ServerCommand> ServerCommandPtr; -class TimedServerCommand : public ServerCommand +class TimedServerCommand : public ServerCommand, public std::enable_shared_from_this<TimedServerCommand> { public: - TimedServerCommand(const ServerIPtr&, const IceUtil::TimerPtr&, int); + TimedServerCommand(const std::shared_ptr<ServerI>&, const IceUtil::TimerPtr&, std::chrono::seconds); virtual void timeout() = 0; void startTimer(); @@ -206,22 +205,21 @@ public: private: IceUtil::TimerPtr _timer; - IceUtil::TimerTaskPtr _timerTask; - int _timeout; + std::shared_ptr<IceUtil::TimerTask> _timerTask; + std::chrono::seconds _timeout; }; -typedef IceUtil::Handle<TimedServerCommand> TimedServerCommandPtr; class DestroyCommand : public ServerCommand { public: - DestroyCommand(const ServerIPtr&, bool, bool); + DestroyCommand(const std::shared_ptr<ServerI>&, bool, bool); - bool canExecute(ServerI::InternalServerState); - ServerI::InternalServerState nextState(); - void execute(); + bool canExecute(ServerI::InternalServerState) override; + ServerI::InternalServerState nextState() override; + void execute() override; - void addCallback(const AMD_Node_destroyServerPtr&); + void addCallback(std::function<void()>); void finished(); bool loadFailure() const; bool clearDir() const; @@ -230,29 +228,30 @@ private: const bool _loadFailure; const bool _clearDir; - std::vector<AMD_Node_destroyServerPtr> _destroyCB; + std::vector<std::function<void()>> _destroyCB; }; class StopCommand : public TimedServerCommand { public: - StopCommand(const ServerIPtr&, const IceUtil::TimerPtr&, int, bool = true); + StopCommand(const std::shared_ptr<ServerI>&, const IceUtil::TimerPtr&, std::chrono::seconds, + bool = true); static bool isStopped(ServerI::InternalServerState); - bool canExecute(ServerI::InternalServerState); - ServerI::InternalServerState nextState(); - void execute(); - void timeout(); + bool canExecute(ServerI::InternalServerState) override; + ServerI::InternalServerState nextState() override; + void execute() override; + void timeout() override; - void addCallback(const AMD_Server_stopPtr&); + void addCallback(std::function<void()>, std::function<void(std::exception_ptr)>); void failed(const std::string& reason); void finished(); private: - std::vector<AMD_Server_stopPtr> _stopCB; + std::vector<std::pair<std::function<void()>, std::function<void(std::exception_ptr)>>> _stopCB; bool _deactivate; }; @@ -260,50 +259,53 @@ class StartCommand : public TimedServerCommand { public: - StartCommand(const ServerIPtr&, const IceUtil::TimerPtr&, int); + using TimedServerCommand::TimedServerCommand; - bool canExecute(ServerI::InternalServerState); - ServerI::InternalServerState nextState(); - void execute(); - void timeout(); + bool canExecute(ServerI::InternalServerState) override; + ServerI::InternalServerState nextState() override; + void execute() override; + void timeout() override; - void addCallback(const AMD_Server_startPtr&); - void failed(const std::string& reason); + void addCallback(std::function<void()>, std::function<void(std::exception_ptr)>); + void failed(const std::string&); void finished(); private: - std::vector<AMD_Server_startPtr> _startCB; + std::vector<std::pair<std::function<void()>, std::function<void(std::exception_ptr)>>> _startCB; }; class LoadCommand : public ServerCommand { public: - LoadCommand(const ServerIPtr&, const InternalServerDescriptorPtr&, const TraceLevelsPtr&); + LoadCommand(const std::shared_ptr<ServerI>&, const std::shared_ptr<InternalServerDescriptor>&, + const std::shared_ptr<TraceLevels>&); - bool canExecute(ServerI::InternalServerState); - ServerI::InternalServerState nextState(); - void execute(); + bool canExecute(ServerI::InternalServerState) override; + ServerI::InternalServerState nextState() override; + void execute() override; - void setUpdate(const InternalServerDescriptorPtr&, bool); + void setUpdate(const std::shared_ptr<InternalServerDescriptor>&, bool); bool clearDir() const; - InternalServerDescriptorPtr getInternalServerDescriptor() const; - void addCallback(const AMD_Node_loadServerPtr&); - void startRuntimePropertiesUpdate(const Ice::ObjectPrx&); - bool finishRuntimePropertiesUpdate(const InternalServerDescriptorPtr&, const Ice::ObjectPrx&); - void failed(const Ice::Exception&); - void finished(const ServerPrx&, const AdapterPrxDict&, int, int); + std::shared_ptr<InternalServerDescriptor> getInternalServerDescriptor() const; + void addCallback(std::function<void(const std::shared_ptr<ServerPrx>&, const AdapterPrxDict &, int, int)>, + std::function<void(std::exception_ptr)>); + void startRuntimePropertiesUpdate(const std::shared_ptr<Ice::ObjectPrx>&); + bool finishRuntimePropertiesUpdate(const std::shared_ptr<InternalServerDescriptor>&, + const std::shared_ptr<Ice::ObjectPrx>&); + void failed(std::exception_ptr); + void finished(const std::shared_ptr<ServerPrx>&, const AdapterPrxDict&, std::chrono::seconds, std::chrono::seconds); private: - std::vector<AMD_Node_loadServerPtr> _loadCB; + std::vector<std::pair<std::function<void(const std::shared_ptr<ServerPrx> &, const AdapterPrxDict &, int, int)>, + std::function<void(std::exception_ptr)>>> _loadCB; bool _clearDir; - InternalServerDescriptorPtr _desc; - IceInternal::UniquePtr<DeploymentException> _exception; - InternalServerDescriptorPtr _runtime; + std::shared_ptr<InternalServerDescriptor> _desc; + std::shared_ptr<InternalServerDescriptor> _runtime; bool _updating; - TraceLevelsPtr _traceLevels; + std::shared_ptr<TraceLevels> _traceLevels; }; } diff --git a/cpp/src/IceGrid/SessionI.cpp b/cpp/src/IceGrid/SessionI.cpp index 16b27d53d11..3b9471e1c75 100644 --- a/cpp/src/IceGrid/SessionI.cpp +++ b/cpp/src/IceGrid/SessionI.cpp @@ -18,54 +18,50 @@ using namespace IceGrid; namespace IceGrid { -template<class T> -class AllocateObject : public ObjectAllocationRequest +class AllocateObject final : public ObjectAllocationRequest { - typedef IceUtil::Handle<T> TPtr; public: - AllocateObject(const SessionIPtr& session, const TPtr& cb) : - ObjectAllocationRequest(session), _cb(cb) + AllocateObject(const shared_ptr<SessionI>& session, + function<void(const shared_ptr<Ice::ObjectPrx>& returnValue)>&& response, + function<void(exception_ptr)>&& exception) : + ObjectAllocationRequest(session), _response(move(response)), _exception(move(exception)) { } - virtual void - response(const Ice::ObjectPrx& proxy) + void + response(const shared_ptr<Ice::ObjectPrx>& proxy) override { - assert(_cb); - _cb->ice_response(proxy); - _cb = 0; + assert(_response); + _response(proxy); + _response = nullptr; + } - virtual void - exception(const Ice::UserException& ex) + void + exception(exception_ptr ex) override { - assert(_cb); - _cb->ice_exception(ex); - _cb = 0; + assert(_exception); + _exception(ex); + _exception = nullptr; } private: - TPtr _cb; + function<void(const shared_ptr<Ice::ObjectPrx>& returnValue)> _response; + function<void(exception_ptr)> _exception; }; -template<class T> AllocateObject<T>* -newAllocateObject(const SessionIPtr& session, const IceUtil::Handle<T>& cb) -{ - return new AllocateObject<T>(session, cb); -} - } -BaseSessionI::BaseSessionI(const string& id, const string& prefix, const DatabasePtr& database) : +BaseSessionI::BaseSessionI(const string& id, const string& prefix, const shared_ptr<Database>& database) : _id(id), _prefix(prefix), _traceLevels(database->getTraceLevels()), _database(database), _destroyed(false), - _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)) + _timestamp(chrono::steady_clock::now()) { if(_traceLevels && _traceLevels->session > 0) { @@ -74,20 +70,16 @@ BaseSessionI::BaseSessionI(const string& id, const string& prefix, const Databas } } -BaseSessionI::~BaseSessionI() -{ -} - void BaseSessionI::keepAlive(const Ice::Current& current) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__, current.id, "", ""); } - _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic); + _timestamp = chrono::steady_clock::now(); if(_traceLevels->session > 1) { @@ -97,9 +89,9 @@ BaseSessionI::keepAlive(const Ice::Current& current) } void -BaseSessionI::destroyImpl(bool /*shutdown*/) +BaseSessionI::destroyImpl(bool) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -113,10 +105,10 @@ BaseSessionI::destroyImpl(bool /*shutdown*/) } } -IceUtil::Time +std::chrono::steady_clock::time_point BaseSessionI::timestamp() const { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -130,67 +122,70 @@ BaseSessionI::shutdown() destroyImpl(true); } -Glacier2::IdentitySetPrx +shared_ptr<Glacier2::IdentitySetPrx> BaseSessionI::getGlacier2IdentitySet() { assert(_servantManager); - return _servantManager->getGlacier2IdentitySet(this); + return _servantManager->getGlacier2IdentitySet(shared_from_this()); } -Glacier2::StringSetPrx +shared_ptr<Glacier2::StringSetPrx> BaseSessionI::getGlacier2AdapterIdSet() { assert(_servantManager); - return _servantManager->getGlacier2AdapterIdSet(this); + return _servantManager->getGlacier2AdapterIdSet(shared_from_this()); } -SessionI::SessionI(const string& id, const DatabasePtr& database, const IceUtil::TimerPtr& timer) : +SessionI::SessionI(const string& id, const shared_ptr<Database>& database, + const IceUtil::TimerPtr& timer) : BaseSessionI(id, "client", database), _timer(timer), _allocationTimeout(-1) { } -SessionI::~SessionI() -{ -} - -Ice::ObjectPrx -SessionI::_register(const SessionServantManagerPtr& servantManager, const Ice::ConnectionPtr& con) +shared_ptr<Ice::ObjectPrx> +SessionI::_register(const shared_ptr<SessionServantManager>& servantManager, const shared_ptr<Ice::Connection>& con) { // // This is supposed to be called after creation only, no need to synchronize. // _servantManager = servantManager; - return _servantManager->addSession(this, con, ""); + return _servantManager->addSession(shared_from_this(), con, ""); } void -SessionI::allocateObjectById_async(const AMD_Session_allocateObjectByIdPtr& cb, - const Ice::Identity& id, - const Ice::Current&) +SessionI::allocateObjectByIdAsync(Ice::Identity id, + function<void(const shared_ptr<Ice::ObjectPrx>& returnValue)> response, + function<void(exception_ptr)> exception, + const Ice::Current&) { - _database->getAllocatableObject(id)->allocate(newAllocateObject(this, cb)); + auto allocatedObject = make_shared<AllocateObject>(static_pointer_cast<SessionI>(shared_from_this()), + move(response), move(exception)); + _database->getAllocatableObject(id)->allocate(move(allocatedObject)); } void -SessionI::allocateObjectByType_async(const AMD_Session_allocateObjectByTypePtr& cb, - const string& type, - const Ice::Current&) +SessionI::allocateObjectByTypeAsync(string type, + function<void(const shared_ptr<Ice::ObjectPrx>& returnValue)> response, + function<void(exception_ptr)> exception, + const Ice::Current&) { - _database->getAllocatableObjectCache().allocateByType(type, newAllocateObject(this, cb)); + auto allocatedObject = make_shared<AllocateObject>(static_pointer_cast<SessionI>(shared_from_this()), + move(response), move(exception)); + _database->getAllocatableObjectCache().allocateByType(type, move(allocatedObject)); } void -SessionI::releaseObject(const Ice::Identity& id, const Ice::Current&) +SessionI::releaseObject(Ice::Identity id, const Ice::Current&) { - _database->getAllocatableObject(id)->release(this); + _database->getAllocatableObject(id)->release(static_pointer_cast<SessionI>(shared_from_this())); } void SessionI::setAllocationTimeout(int timeout, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); _allocationTimeout = timeout; } @@ -203,14 +198,14 @@ SessionI::destroy(const Ice::Current&) int SessionI::getAllocationTimeout() const { - Lock sync(*this); + lock_guard lock(_mutex); return _allocationTimeout; } bool -SessionI::addAllocationRequest(const AllocationRequestPtr& request) +SessionI::addAllocationRequest(const shared_ptr<AllocationRequest>& request) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return false; @@ -220,9 +215,9 @@ SessionI::addAllocationRequest(const AllocationRequestPtr& request) } void -SessionI::removeAllocationRequest(const AllocationRequestPtr& request) +SessionI::removeAllocationRequest(const shared_ptr<AllocationRequest>& request) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; @@ -231,9 +226,9 @@ SessionI::removeAllocationRequest(const AllocationRequestPtr& request) } void -SessionI::addAllocation(const AllocatablePtr& allocatable) +SessionI::addAllocation(const shared_ptr<Allocatable>& allocatable) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { throw SessionDestroyedException(); @@ -242,9 +237,9 @@ SessionI::addAllocation(const AllocatablePtr& allocatable) } void -SessionI::removeAllocation(const AllocatablePtr& allocatable) +SessionI::removeAllocation(const shared_ptr<Allocatable>& allocatable) { - Lock sync(*this); + lock_guard lock(_mutex); if(_destroyed) { return; @@ -257,25 +252,24 @@ SessionI::destroyImpl(bool shutdown) { BaseSessionI::destroyImpl(shutdown); - _servantManager->removeSession(this); + _servantManager->removeSession(shared_from_this()); // // NOTE: The _requests and _allocations attributes are immutable // once the session is destroyed so we don't need mutex protection // here to access them. // - - for(set<AllocationRequestPtr>::const_iterator p = _requests.begin(); p != _requests.end(); ++p) + for(const auto& request : _requests) { - (*p)->cancel(AllocationException("session destroyed")); + request->cancel(make_exception_ptr(AllocationException("session destroyed"))); } _requests.clear(); - for(set<AllocatablePtr>::const_iterator q = _allocations.begin(); q != _allocations.end(); ++q) + for(const auto& allocation : _allocations) { try { - (*q)->release(this); + allocation->release(dynamic_pointer_cast<SessionI>(shared_from_this())); } catch(const AllocationException&) { @@ -284,10 +278,10 @@ SessionI::destroyImpl(bool shutdown) _allocations.clear(); } -ClientSessionFactory::ClientSessionFactory(const SessionServantManagerPtr& servantManager, - const DatabasePtr& database, +ClientSessionFactory::ClientSessionFactory(const shared_ptr<SessionServantManager>& servantManager, + const shared_ptr<Database>& database, const IceUtil::TimerPtr& timer, - const ReapThreadPtr& reaper) : + const shared_ptr<ReapThread>& reaper) : _servantManager(servantManager), _database(database), _timer(timer), @@ -296,35 +290,31 @@ ClientSessionFactory::ClientSessionFactory(const SessionServantManagerPtr& serva { if(_servantManager) // Not set if Glacier2 session manager adapter not enabled { - Ice::PropertiesPtr properties = _database->getCommunicator()->getProperties(); + auto properties = _database->getCommunicator()->getProperties(); const_cast<bool&>(_filters) = properties->getPropertyAsIntWithDefault("IceGrid.Registry.SessionFilters", 0) > 0; } } -Glacier2::SessionPrx -ClientSessionFactory::createGlacier2Session(const string& sessionId, const Glacier2::SessionControlPrx& ctl) +shared_ptr<Glacier2::SessionPrx> +ClientSessionFactory::createGlacier2Session(const string& sessionId, + const shared_ptr<Glacier2::SessionControlPrx>& ctl) { assert(_servantManager); - SessionIPtr session = createSessionServant(sessionId, ctl); - Ice::ObjectPrx proxy = session->_register(_servantManager, 0); + auto session = createSessionServant(sessionId, ctl); + auto proxy = session->_register(_servantManager, 0); - int timeout = 0; + chrono::seconds timeout = 0s; if(ctl) { try { if(_filters) { - Ice::IdentitySeq ids; - Ice::Identity queryId; - queryId.category = _database->getInstanceName(); - queryId.name = "Query"; - ids.push_back(queryId); - - _servantManager->setSessionControl(session, ctl, ids); + Ice::Identity queryId = { "Query", _database->getInstanceName() }; + _servantManager->setSessionControl(session, ctl, { move(queryId) }); } - timeout = ctl->getSessionTimeout(); + timeout = chrono::seconds(ctl->getSessionTimeout()); } catch(const Ice::LocalException& e) { @@ -337,39 +327,39 @@ ClientSessionFactory::createGlacier2Session(const string& sessionId, const Glaci } } - _reaper->add(new SessionReapable<SessionI>(_database->getTraceLevels()->logger, session), timeout); - return Glacier2::SessionPrx::uncheckedCast(proxy); + _reaper->add(make_shared<SessionReapable<SessionI>>(_database->getTraceLevels()->logger, session), timeout); + return Ice::uncheckedCast<Glacier2::SessionPrx>(proxy); } -SessionIPtr -ClientSessionFactory::createSessionServant(const string& userId, const Glacier2::SessionControlPrx&) +shared_ptr<SessionI> +ClientSessionFactory::createSessionServant(const string& userId, const shared_ptr<Glacier2::SessionControlPrx>&) { - return new SessionI(userId, _database, _timer); + return make_shared<SessionI>(userId, _database, _timer); } -const TraceLevelsPtr& +const shared_ptr<TraceLevels>& ClientSessionFactory::getTraceLevels() const { return _database->getTraceLevels(); } -ClientSessionManagerI::ClientSessionManagerI(const ClientSessionFactoryPtr& factory) : _factory(factory) +ClientSessionManagerI::ClientSessionManagerI(const shared_ptr<ClientSessionFactory>& factory) : _factory(factory) { } -Glacier2::SessionPrx -ClientSessionManagerI::create(const string& user, const Glacier2::SessionControlPrx& ctl, const Ice::Current&) +shared_ptr<Glacier2::SessionPrx> +ClientSessionManagerI::create(string user, shared_ptr<Glacier2::SessionControlPrx> ctl, const Ice::Current&) { - return _factory->createGlacier2Session(user, ctl); + return _factory->createGlacier2Session(move(user), move(ctl)); } -ClientSSLSessionManagerI::ClientSSLSessionManagerI(const ClientSessionFactoryPtr& factory) : _factory(factory) +ClientSSLSessionManagerI::ClientSSLSessionManagerI(const shared_ptr<ClientSessionFactory>& factory) : _factory(factory) { } -Glacier2::SessionPrx -ClientSSLSessionManagerI::create(const Glacier2::SSLInfo& info, - const Glacier2::SessionControlPrx& ctl, +shared_ptr<Glacier2::SessionPrx> +ClientSSLSessionManagerI::create(Glacier2::SSLInfo info, + shared_ptr<Glacier2::SessionControlPrx> ctl, const Ice::Current&) { string userDN; @@ -377,7 +367,7 @@ ClientSSLSessionManagerI::create(const Glacier2::SSLInfo& info, { try { - IceSSL::CertificatePtr cert = IceSSL::Certificate::decode(info.certs[0]); + auto cert = IceSSL::Certificate::decode(info.certs[0]); userDN = cert->getSubjectDN(); } catch(const Ice::Exception& e) diff --git a/cpp/src/IceGrid/SessionI.h b/cpp/src/IceGrid/SessionI.h index 5184bd2b19a..d933f80163d 100644 --- a/cpp/src/IceGrid/SessionI.h +++ b/cpp/src/IceGrid/SessionI.h @@ -5,7 +5,6 @@ #ifndef ICEGRID_SESSIONI_H #define ICEGRID_SESSIONI_H -#include <IceUtil/Mutex.h> #include <IceUtil/Timer.h> #include <IceGrid/ReapThread.h> #include <IceGrid/Session.h> @@ -15,139 +14,137 @@ namespace IceGrid { -class Database; -typedef IceUtil::Handle<Database> DatabasePtr; - -class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - -class AllocationRequest; -typedef IceUtil::Handle<AllocationRequest> AllocationRequestPtr; - class Allocatable; -typedef IceUtil::Handle<Allocatable> AllocatablePtr; - +class AllocationRequest; +class Database; class SessionI; -typedef IceUtil::Handle<SessionI> SessionIPtr; +class TraceLevels; -class BaseSessionI : public virtual Ice::Object, public IceUtil::Mutex +class BaseSessionI : public virtual Ice::Object, public std::enable_shared_from_this<BaseSessionI> { public: - virtual ~BaseSessionI(); + virtual ~BaseSessionI() = default; virtual void keepAlive(const Ice::Current&); - IceUtil::Time timestamp() const; + std::chrono::steady_clock::time_point timestamp() const; void shutdown(); - Glacier2::IdentitySetPrx getGlacier2IdentitySet(); - Glacier2::StringSetPrx getGlacier2AdapterIdSet(); + std::shared_ptr<Glacier2::IdentitySetPrx> getGlacier2IdentitySet(); + std::shared_ptr<Glacier2::StringSetPrx> getGlacier2AdapterIdSet(); const std::string& getId() const { return _id; } virtual void destroyImpl(bool); protected: - BaseSessionI(const std::string&, const std::string&, const DatabasePtr&); + BaseSessionI(const std::string&, const std::string&, const std::shared_ptr<Database>&); const std::string _id; const std::string _prefix; - const TraceLevelsPtr _traceLevels; - const DatabasePtr _database; - SessionServantManagerPtr _servantManager; + const std::shared_ptr<TraceLevels> _traceLevels; + const std::shared_ptr<Database> _database; + std::shared_ptr<SessionServantManager> _servantManager; bool _destroyed; - IceUtil::Time _timestamp; + std::chrono::steady_clock::time_point _timestamp; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<BaseSessionI> BaseSessionIPtr; -class SessionDestroyedException +struct SessionDestroyedException { }; -class SessionI : public BaseSessionI, public Session +class SessionI final : public BaseSessionI, public Session { public: - SessionI(const std::string&, const DatabasePtr&, const IceUtil::TimerPtr&); - virtual ~SessionI(); - - Ice::ObjectPrx _register(const SessionServantManagerPtr&, const Ice::ConnectionPtr&); + SessionI(const std::string&, const std::shared_ptr<Database>&, const IceUtil::TimerPtr&); - virtual void keepAlive(const Ice::Current& current) { BaseSessionI::keepAlive(current); } + std::shared_ptr<Ice::ObjectPrx> _register(const std::shared_ptr<SessionServantManager>&, + const std::shared_ptr<Ice::Connection>&); - virtual void allocateObjectById_async(const AMD_Session_allocateObjectByIdPtr&, const Ice::Identity&, - const Ice::Current&); - virtual void allocateObjectByType_async(const AMD_Session_allocateObjectByTypePtr&, const std::string&, - const Ice::Current&); - virtual void releaseObject(const Ice::Identity&, const Ice::Current&); - virtual void setAllocationTimeout(int, const Ice::Current&); - virtual void destroy(const Ice::Current&); + void keepAlive(const Ice::Current& current) override { BaseSessionI::keepAlive(current); } + void allocateObjectByIdAsync(Ice::Identity id, + std::function<void(const std::shared_ptr<Ice::ObjectPrx>& returnValue)> response, + std::function<void(std::exception_ptr)> exception, const Ice::Current& current) + override; + void allocateObjectByTypeAsync(std::string, + std::function<void(const std::shared_ptr<Ice::ObjectPrx>& returnValue)> response, + std::function<void(std::exception_ptr)> exception, const Ice::Current& current) + override; + void releaseObject(Ice::Identity, const Ice::Current&) override; + void setAllocationTimeout(int, const Ice::Current&) override; + void destroy(const Ice::Current&) override; int getAllocationTimeout() const; const IceUtil::TimerPtr& getTimer() const { return _timer; } - bool addAllocationRequest(const AllocationRequestPtr&); - void removeAllocationRequest(const AllocationRequestPtr&); - void addAllocation(const AllocatablePtr&); - void removeAllocation(const AllocatablePtr&); + bool addAllocationRequest(const std::shared_ptr<AllocationRequest>&); + void removeAllocationRequest(const std::shared_ptr<AllocationRequest>&); + void addAllocation(const std::shared_ptr<Allocatable>&); + void removeAllocation(const std::shared_ptr<Allocatable>&); protected: - virtual void destroyImpl(bool); + void destroyImpl(bool) override; const IceUtil::TimerPtr _timer; int _allocationTimeout; - std::set<AllocationRequestPtr> _requests; - std::set<AllocatablePtr> _allocations; + std::set<std::shared_ptr<AllocationRequest>> _requests; + std::set<std::shared_ptr<Allocatable>> _allocations; }; -class ClientSessionFactory : public virtual IceUtil::Shared +class ClientSessionFactory final { public: - ClientSessionFactory(const SessionServantManagerPtr&, const DatabasePtr&, const IceUtil::TimerPtr&, - const ReapThreadPtr&); + ClientSessionFactory(const std::shared_ptr<SessionServantManager>&, const std::shared_ptr<Database>&, + const IceUtil::TimerPtr&, + const std::shared_ptr<ReapThread>&); - Glacier2::SessionPrx createGlacier2Session(const std::string&, const Glacier2::SessionControlPrx&); - SessionIPtr createSessionServant(const std::string&, const Glacier2::SessionControlPrx&); + std::shared_ptr<Glacier2::SessionPrx> createGlacier2Session(const std::string&, + const std::shared_ptr<Glacier2::SessionControlPrx>&); + std::shared_ptr<SessionI> createSessionServant(const std::string&, + const std::shared_ptr<Glacier2::SessionControlPrx>&); - const TraceLevelsPtr& getTraceLevels() const; + const std::shared_ptr<TraceLevels>& getTraceLevels() const; private: - const SessionServantManagerPtr _servantManager; - const DatabasePtr _database; + const std::shared_ptr<SessionServantManager> _servantManager; + const std::shared_ptr<Database> _database; const IceUtil::TimerPtr _timer; - const ReapThreadPtr _reaper; + const std::shared_ptr<ReapThread> _reaper; const bool _filters; }; -typedef IceUtil::Handle<ClientSessionFactory> ClientSessionFactoryPtr; -class ClientSessionManagerI : public virtual Glacier2::SessionManager +class ClientSessionManagerI final : public Glacier2::SessionManager { public: - ClientSessionManagerI(const ClientSessionFactoryPtr&); + ClientSessionManagerI(const std::shared_ptr<ClientSessionFactory>&); - virtual Glacier2::SessionPrx create(const std::string&, const Glacier2::SessionControlPrx&, const Ice::Current&); + std::shared_ptr<Glacier2::SessionPrx> create(std::string, std::shared_ptr<Glacier2::SessionControlPrx>, + const Ice::Current&) override; private: - const ClientSessionFactoryPtr _factory; + const std::shared_ptr<ClientSessionFactory> _factory; }; -class ClientSSLSessionManagerI : public virtual Glacier2::SSLSessionManager +class ClientSSLSessionManagerI final : public Glacier2::SSLSessionManager { public: - ClientSSLSessionManagerI(const ClientSessionFactoryPtr&); + ClientSSLSessionManagerI(const std::shared_ptr<ClientSessionFactory>&); - virtual Glacier2::SessionPrx create(const Glacier2::SSLInfo&, const Glacier2::SessionControlPrx&, - const Ice::Current&); + std::shared_ptr<Glacier2::SessionPrx> create(Glacier2::SSLInfo, std::shared_ptr<Glacier2::SessionControlPrx>, + const Ice::Current&) override; private: - const ClientSessionFactoryPtr _factory; + const std::shared_ptr<ClientSessionFactory> _factory; }; }; diff --git a/cpp/src/IceGrid/SessionManager.cpp b/cpp/src/IceGrid/SessionManager.cpp index 646db8244a4..c9fe10674da 100644 --- a/cpp/src/IceGrid/SessionManager.cpp +++ b/cpp/src/IceGrid/SessionManager.cpp @@ -10,30 +10,25 @@ using namespace std; using namespace IceGrid; -SessionManager::SessionManager(const Ice::CommunicatorPtr& communicator, const string& instanceName) : +SessionManager::SessionManager(const shared_ptr<Ice::Communicator>& communicator, const string& instanceName) : _communicator(communicator), _instanceName(instanceName) { - Ice::LocatorPrx prx = communicator->getDefaultLocator(); + auto prx = communicator->getDefaultLocator(); if(prx) { - Ice::Identity id; - id.category = instanceName; - id.name = "InternalRegistry-Master"; - _master = InternalRegistryPrx::uncheckedCast(prx->ice_identity(id)->ice_endpoints(Ice::EndpointSeq())); + Ice::Identity id = { "InternalRegistry-Master", instanceName }; + _master = + Ice::uncheckedCast<InternalRegistryPrx>(prx->ice_identity(move(id))->ice_endpoints({})); } } -SessionManager::~SessionManager() -{ -} - -vector<QueryPrx> +vector<shared_ptr<QueryPrx>> SessionManager::findAllQueryObjects(bool cached) { - vector<QueryPrx> queryObjects; - Ice::LocatorPrx locator; + vector<shared_ptr<QueryPrx>> queryObjects; + shared_ptr<Ice::LocatorPrx> locator; { - Lock sync(*this); + lock_guard lock(_mutex); if(!_communicator) { return queryObjects; @@ -48,14 +43,14 @@ SessionManager::findAllQueryObjects(bool cached) if(!cached) { - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + for(const auto& queryObject : queryObjects) { - Ice::ConnectionPtr connection = (*q)->ice_getCachedConnection(); + auto connection = queryObject->ice_getCachedConnection(); if(connection) { try { - connection->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait)); + connection->close(Ice::ConnectionClose::GracefullyWithWait); } catch(const Ice::LocalException&) { @@ -67,16 +62,14 @@ SessionManager::findAllQueryObjects(bool cached) if(queryObjects.empty() && locator) { - Ice::Identity id; - id.category = _instanceName; - id.name = "Query"; - QueryPrx query = QueryPrx::uncheckedCast(locator->ice_identity(id)); - Ice::EndpointSeq endpoints = query->ice_getEndpoints(); + Ice::Identity id = { "Query", _instanceName }; + auto query = Ice::uncheckedCast<QueryPrx>(locator->ice_identity(id)); + auto endpoints = query->ice_getEndpoints(); if(endpoints.empty()) { try { - Ice::ObjectPrx r = locator->findObjectById(id); + auto r = locator->findObjectById(id); if(r) { endpoints = r->ice_getEndpoints(); @@ -88,35 +81,32 @@ SessionManager::findAllQueryObjects(bool cached) } } - for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) + for(const auto& endpoint : endpoints) { - Ice::EndpointSeq singleEndpoint; - singleEndpoint.push_back(*p); - queryObjects.push_back(QueryPrx::uncheckedCast(query->ice_endpoints(singleEndpoint))); + queryObjects.push_back(Ice::uncheckedCast<QueryPrx>(query->ice_endpoints({endpoint}))); } } // // Find all known query objects by querying all the registries we can find. // - map<Ice::Identity, QueryPrx> proxies; - set<QueryPrx> requested; + map<Ice::Identity, shared_ptr<QueryPrx>> proxies; + set<shared_ptr<QueryPrx>> requested; while(true) { - vector<Ice::AsyncResultPtr> results; - for(vector<QueryPrx>::const_iterator q = queryObjects.begin(); q != queryObjects.end(); ++q) + vector<future<Ice::ObjectProxySeq>> results; + for(const auto& queryObject : queryObjects) { - results.push_back((*q)->begin_findAllObjectsByType(Registry::ice_staticId())); - requested.insert(*q); + results.push_back(queryObject->findAllObjectsByTypeAsync(Registry::ice_staticId())); + requested.insert(queryObject); } if(results.empty()) { break; } - for(vector<Ice::AsyncResultPtr>::const_iterator p = results.begin(); p != results.end(); ++p) + for(auto& result : results) { - QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); if(isDestroyed()) { break; @@ -124,18 +114,17 @@ SessionManager::findAllQueryObjects(bool cached) try { - Ice::ObjectProxySeq prxs = query->end_findAllObjectsByType(*p); - for(Ice::ObjectProxySeq::iterator q = prxs.begin(); q != prxs.end(); ++q) + auto prxs = result.get(); + for(const auto& prx : prxs) { - if(proxies.find((*q)->ice_getIdentity()) == proxies.end()) + if(proxies.find(prx->ice_getIdentity()) == proxies.end()) { // // Add query proxy for each IceGrid registry. The proxy contains the endpoints // of the registry since it's based on the registry interface proxy. // - Ice::Identity id = (*q)->ice_getIdentity(); - id.name = "Query"; - proxies[(*q)->ice_getIdentity()] = QueryPrx::uncheckedCast((*q)->ice_identity(id)); + Ice::Identity id = { "Query", prx->ice_getIdentity().category }; + proxies[prx->ice_getIdentity()] = Ice::uncheckedCast<QueryPrx>(prx->ice_identity(move(id))); } } } @@ -146,20 +135,20 @@ SessionManager::findAllQueryObjects(bool cached) } queryObjects.clear(); - for(map<Ice::Identity, QueryPrx>::const_iterator p = proxies.begin(); p != proxies.end(); ++p) + for(const auto& prx : proxies) { - if(requested.find(p->second) == requested.end()) + if(requested.find(prx.second) == requested.end()) { - queryObjects.push_back(p->second); + queryObjects.push_back(prx.second); } } } - Lock sync(*this); + lock_guard lock(_mutex); _queryObjects.clear(); - for(map<Ice::Identity, QueryPrx>::const_iterator p = proxies.begin(); p != proxies.end(); ++p) + for(const auto& prx : proxies) { - _queryObjects.push_back(p->second); + _queryObjects.push_back(prx.second); } return _queryObjects; } diff --git a/cpp/src/IceGrid/SessionManager.h b/cpp/src/IceGrid/SessionManager.h index 44261f603a0..243fe8b7957 100644 --- a/cpp/src/IceGrid/SessionManager.h +++ b/cpp/src/IceGrid/SessionManager.h @@ -5,22 +5,18 @@ #ifndef ICE_GRID_SESSION_MANAGER_H #define ICE_GRID_SESSION_MANAGER_H -#include <IceUtil/Handle.h> -#include <IceUtil/Mutex.h> -#include <IceUtil/Monitor.h> -#include <IceUtil/Thread.h> - #include <Ice/Logger.h> #include <Ice/LoggerUtil.h> #include <IceGrid/Registry.h> #include <IceGrid/Internal.h> +#include <IceGrid/Util.h> namespace IceGrid { template<class TPrx> -class SessionKeepAliveThread : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex> +class SessionKeepAliveThread { #if defined(__clang__) # pragma clang diagnostic push @@ -47,21 +43,28 @@ class SessionKeepAliveThread : public IceUtil::Thread, public IceUtil::Monitor<I public: - SessionKeepAliveThread(const InternalRegistryPrx& registry, const Ice::LoggerPtr& logger) : - IceUtil::Thread("IceGrid session keepalive thread"), + SessionKeepAliveThread(const std::shared_ptr<InternalRegistryPrx>& registry, + const std::shared_ptr<Ice::Logger>& logger) : _registry(registry), _logger(logger), _state(InProgress), - _nextAction(None) + _nextAction(None), + _thread([this] { run(); }) + { + } + + virtual ~SessionKeepAliveThread() { + assert(_state == Destroyed); } - virtual void + void run() { - TPrx session; - InternalRegistryPrx registry; - IceUtil::Time timeout = IceUtil::Time::seconds(10); + using namespace std::chrono_literals; + std::shared_ptr<TPrx> session; + std::shared_ptr<InternalRegistryPrx> registry; + std::chrono::seconds timeout = 10s; Action action = Connect; try @@ -69,7 +72,7 @@ public: while(true) { { - Lock sync(*this); + std::unique_lock<std::mutex> lock(_mutex); if(_state == Destroyed) { break; @@ -98,7 +101,7 @@ public: { _nextAction = Connect; } - notifyAll(); + _condVar.notify_all(); // // Wait if there's nothing to do and if we are @@ -108,12 +111,12 @@ public: { if(_state == Connected || action == Connect || action == KeepAlive) { - IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic); - IceUtil::Time wakeTime = now + timeout; + auto now = std::chrono::steady_clock::now(); + auto wakeTime = now + timeout; while(_state != Destroyed && _nextAction == None && wakeTime > now) { - timedWait(wakeTime - now); - now = IceUtil::Time::now(IceUtil::Time::Monotonic); + _condVar.wait_for(lock, wakeTime - now); + now = std::chrono::steady_clock::now(); } } if(_nextAction == None) @@ -130,23 +133,27 @@ public: assert(_nextAction != None); action = _nextAction; - registry = InternalRegistryPrx::uncheckedCast( - _registry->ice_timeout(static_cast<int>(timeout.toMilliSeconds()))); + assert(timeout != 0s); + using namespace std::chrono; + + registry = Ice::uncheckedCast<InternalRegistryPrx>(_registry->ice_timeout(secondsToInt(timeout))); _nextAction = None; _state = InProgress; - notifyAll(); + _condVar.notify_all(); } switch(action) { case Connect: assert(!session); - session = createSession(registry, timeout); + { + session = createSession(registry, timeout); + } break; case Disconnect: assert(session); destroySession(session); - session = 0; + session = nullptr; break; case KeepAlive: assert(session); @@ -186,57 +193,53 @@ public: bool isWaitingForCreate() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); return _state != Destroyed && _state != Connected; } virtual bool waitForCreate() { - Lock sync(*this); - while(_state != Destroyed && _state != Connected) - { - wait(); - } + std::unique_lock<std::mutex> lock(_mutex); + _condVar.wait(lock, [this] { return _state == Destroyed || _state == Connected; }); return _state != Destroyed; } void tryCreateSession() { + std::lock_guard<std::mutex> lock(_mutex); + if(_state == Destroyed) { - Lock sync(*this); - if(_state == Destroyed) - { - return; - } + return; + } - if(_state == Connected) - { - _nextAction = KeepAlive; - } - else - { - _nextAction = Connect; - } - notifyAll(); + if(_state == Connected) + { + _nextAction = KeepAlive; } + else + { + _nextAction = Connect; + } + _condVar.notify_all(); } void - waitTryCreateSession(const IceUtil::Time& timeout = IceUtil::Time()) + waitTryCreateSession(std::chrono::seconds timeout = std::chrono::seconds(0)) { - Lock sync(*this); + std::unique_lock<std::mutex> lock(_mutex); // Wait until the action is executed and the state changes. while(_nextAction == Connect || _nextAction == KeepAlive || _state == InProgress) { - if(timeout == IceUtil::Time()) + using namespace std::chrono_literals; + if(timeout == 0s) { - wait(); + _condVar.wait(lock); } else { - if(!timedWait(timeout)) + if(_condVar.wait_for(lock, timeout) == std::cv_status::timeout) { break; } @@ -247,19 +250,19 @@ public: void destroyActiveSession() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); if(_state == Destroyed || _state == Disconnected) { return; } _nextAction = Disconnect; - notifyAll(); + _condVar.notify_all(); } bool terminateIfDisconnected() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); if(_state != Disconnected) { return false; // Nothing we can do for now. @@ -267,14 +270,14 @@ public: assert(_state != Destroyed); _state = Destroyed; _nextAction = None; - notifyAll(); + _condVar.notify_all(); return true; } void terminate(bool destroySession = true) { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); if(_state == Destroyed) { return; @@ -282,67 +285,80 @@ public: assert(_state != Destroyed); _state = Destroyed; _nextAction = destroySession ? Disconnect : None; - notifyAll(); + _condVar.notify_all(); + } + + void + join() + { + _thread.join(); } bool isDestroyed() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); return _state == Destroyed; } - TPrx + std::shared_ptr<TPrx> getSession() { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); return _session; } void - setRegistry(const InternalRegistryPrx& registry) + setRegistry(const std::shared_ptr<InternalRegistryPrx>& registry) { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); _registry = registry; } - InternalRegistryPrx + std::shared_ptr<InternalRegistryPrx> getRegistry() const { - Lock sync(*this); + std::lock_guard<std::mutex> lock(_mutex); return _registry; } - virtual TPrx createSession(InternalRegistryPrx&, IceUtil::Time&) = 0; - virtual void destroySession(const TPrx&) = 0; - virtual bool keepAlive(const TPrx&) = 0; + virtual std::shared_ptr<TPrx> createSession(std::shared_ptr<InternalRegistryPrx>&, std::chrono::seconds&) = 0; + virtual void destroySession(const std::shared_ptr<TPrx>&) = 0; + virtual bool keepAlive(const std::shared_ptr<TPrx>&) = 0; protected: - InternalRegistryPrx _registry; - Ice::LoggerPtr _logger; - TPrx _session; + std::shared_ptr<InternalRegistryPrx> _registry; + std::shared_ptr<Ice::Logger> _logger; + std::shared_ptr<TPrx> _session; State _state; Action _nextAction; + + mutable std::mutex _mutex; + std::condition_variable _condVar; + std::thread _thread; }; -class SessionManager : public IceUtil::Monitor<IceUtil::Mutex> +class SessionManager { public: - SessionManager(const Ice::CommunicatorPtr&, const std::string&); - virtual ~SessionManager(); + SessionManager(const std::shared_ptr<Ice::Communicator>&, const std::string&); + virtual ~SessionManager() = default; virtual bool isDestroyed() = 0; protected: - std::vector<IceGrid::QueryPrx> findAllQueryObjects(bool); + std::vector<std::shared_ptr<IceGrid::QueryPrx>> findAllQueryObjects(bool); - Ice::CommunicatorPtr _communicator; + std::shared_ptr<Ice::Communicator> _communicator; std::string _instanceName; - InternalRegistryPrx _master; - std::vector<IceGrid::QueryPrx> _queryObjects; + std::shared_ptr<InternalRegistryPrx> _master; + std::vector<std::shared_ptr<IceGrid::QueryPrx>> _queryObjects; + + std::mutex _mutex; + std::condition_variable _condVar; }; }; diff --git a/cpp/src/IceGrid/SessionServantManager.cpp b/cpp/src/IceGrid/SessionServantManager.cpp index 58f9c0fbfab..47be2baeabc 100644 --- a/cpp/src/IceGrid/SessionServantManager.cpp +++ b/cpp/src/IceGrid/SessionServantManager.cpp @@ -11,16 +11,16 @@ using namespace std; using namespace IceGrid; -SessionServantManager::SessionServantManager(const Ice::ObjectAdapterPtr& adapter, +SessionServantManager::SessionServantManager(const shared_ptr<Ice::ObjectAdapter>& adapter, const string& instanceName, bool checkConnection, const string& serverAdminCategory, - const Ice::ObjectPtr& serverAdminRouter, + const shared_ptr<Ice::Object>& serverAdminRouter, const string& nodeAdminCategory, - const Ice::ObjectPtr& nodeAdminRouter, + const shared_ptr<Ice::Object>& nodeAdminRouter, const string& replicaAdminCategory, - const Ice::ObjectPtr& replicaAdminRouter, - const AdminCallbackRouterPtr& adminCallbackRouter) : + const shared_ptr<Ice::Object>& replicaAdminRouter, + const shared_ptr<AdminCallbackRouter>& adminCallbackRouter) : _adapter(adapter), _instanceName(instanceName), _checkConnection(checkConnection), @@ -34,11 +34,12 @@ SessionServantManager::SessionServantManager(const Ice::ObjectAdapterPtr& adapte { } -Ice::ObjectPtr -SessionServantManager::locate(const Ice::Current& current, Ice::LocalObjectPtr&) +shared_ptr<Ice::Object> +SessionServantManager::locate(const Ice::Current& current, shared_ptr<void>&) { - Lock sync(*this); - Ice::ObjectPtr servant; + lock_guard lock(_mutex); + + shared_ptr<Ice::Object> servant; bool plainServant = false; if(_serverAdminRouter && current.id.category == _serverAdminCategory) @@ -57,7 +58,7 @@ SessionServantManager::locate(const Ice::Current& current, Ice::LocalObjectPtr&) { plainServant = true; - map<Ice::Identity, ServantInfo>::const_iterator p = _servants.find(current.id); + auto p = _servants.find(current.id); if(p == _servants.end() || (_checkConnection && p->second.connection != current.con)) { servant = 0; @@ -78,24 +79,25 @@ SessionServantManager::locate(const Ice::Current& current, Ice::LocalObjectPtr&) } void -SessionServantManager::finished(const Ice::Current&, const Ice::ObjectPtr&, const Ice::LocalObjectPtr&) +SessionServantManager::finished(const Ice::Current&, const shared_ptr<Ice::Object>&, const shared_ptr<void>&) { } void SessionServantManager::deactivate(const std::string&) { - Lock sync(*this); + lock_guard lock(_mutex); assert(_servants.empty()); assert(_sessions.empty()); assert(_adminConnections.empty()); } -Ice::ObjectPrx -SessionServantManager::addSession(const Ice::ObjectPtr& session, const Ice::ConnectionPtr& con, const string& category) +shared_ptr<Ice::ObjectPrx> +SessionServantManager::addSession(const shared_ptr<Ice::Object>& session, + const shared_ptr<Ice::Connection>& con, const string& category) { - Lock sync(*this); - _sessions.insert(make_pair(session, SessionInfo(con, category))); + lock_guard lock(_mutex); + _sessions.insert({ session, SessionInfo(con, category) }); // // Keep track of all the connections which have an admin session to allow access @@ -114,13 +116,13 @@ SessionServantManager::addSession(const Ice::ObjectPtr& session, const Ice::Conn } void -SessionServantManager::setSessionControl(const Ice::ObjectPtr& session, - const Glacier2::SessionControlPrx& ctl, +SessionServantManager::setSessionControl(const shared_ptr<Ice::Object>& session, + const shared_ptr<Glacier2::SessionControlPrx>& ctl, const Ice::IdentitySeq& ids) { - Lock sync(*this); + lock_guard lock(_mutex); - map<Ice::ObjectPtr, SessionInfo>::iterator p = _sessions.find(session); + auto p = _sessions.find(session); assert(p != _sessions.end()); p->second.sessionControl = ctl; @@ -144,11 +146,11 @@ SessionServantManager::setSessionControl(const Ice::ObjectPtr& session, } } -Glacier2::IdentitySetPrx -SessionServantManager::getGlacier2IdentitySet(const Ice::ObjectPtr& session) +shared_ptr<Glacier2::IdentitySetPrx> +SessionServantManager::getGlacier2IdentitySet(const shared_ptr<Ice::Object>& session) { - Lock sync(*this); - map<Ice::ObjectPtr, SessionInfo>::iterator p = _sessions.find(session); + lock_guard lock(_mutex); + auto p = _sessions.find(session); if(p != _sessions.end() && p->second.sessionControl) { if(!p->second.identitySet) // Cache the identity set proxy @@ -159,15 +161,15 @@ SessionServantManager::getGlacier2IdentitySet(const Ice::ObjectPtr& session) } else { - return 0; + return nullptr; } } -Glacier2::StringSetPrx -SessionServantManager::getGlacier2AdapterIdSet(const Ice::ObjectPtr& session) +shared_ptr<Glacier2::StringSetPrx> +SessionServantManager::getGlacier2AdapterIdSet(const shared_ptr<Ice::Object>& session) { - Lock sync(*this); - map<Ice::ObjectPtr, SessionInfo>::iterator p = _sessions.find(session); + lock_guard lock(_mutex); + auto p = _sessions.find(session); if(p != _sessions.end() && p->second.sessionControl) { if(!p->second.adapterIdSet) // Cache the adapterId set proxy @@ -178,22 +180,22 @@ SessionServantManager::getGlacier2AdapterIdSet(const Ice::ObjectPtr& session) } else { - return 0; + return nullptr; } } void -SessionServantManager::removeSession(const Ice::ObjectPtr& session) +SessionServantManager::removeSession(const shared_ptr<Ice::Object>& session) { - Lock sync(*this); + lock_guard lock(_mutex); - map<Ice::ObjectPtr, SessionInfo>::iterator p = _sessions.find(session); + auto p = _sessions.find(session); assert(p != _sessions.end()); // // Remove all the servants associated with the session. // - for(set<Ice::Identity>::const_iterator q = p->second.identities.begin(); q != p->second.identities.end(); ++q) + for(auto q = p->second.identities.cbegin(); q != p->second.identities.cend(); ++q) { _servants.erase(*q); } @@ -207,7 +209,7 @@ SessionServantManager::removeSession(const Ice::ObjectPtr& session) assert(_adminConnections.find(p->second.connection) != _adminConnections.end()); _adminConnections.erase(_adminConnections.find(p->second.connection)); - if(_adminCallbackRouter != 0) + if(_adminCallbackRouter != nullptr) { _adminCallbackRouter->removeMapping(p->second.category); } @@ -216,17 +218,17 @@ SessionServantManager::removeSession(const Ice::ObjectPtr& session) _sessions.erase(p); } -Ice::ObjectPrx -SessionServantManager::add(const Ice::ObjectPtr& servant, const Ice::ObjectPtr& session) +shared_ptr<Ice::ObjectPrx> +SessionServantManager::add(const shared_ptr<Ice::Object>& servant, const shared_ptr<Ice::Object>& session) { - Lock sync(*this); + lock_guard lock(_mutex); return addImpl(servant, session); } void SessionServantManager::remove(const Ice::Identity& id) { - Lock sync(*this); + lock_guard lock(_mutex); map<Ice::Identity, ServantInfo>::iterator p = _servants.find(id); assert(p != _servants.end()); @@ -234,7 +236,7 @@ SessionServantManager::remove(const Ice::Identity& id) // Find the session associated to the servant and remove the servant identity from the // session identities. // - map<Ice::ObjectPtr, SessionInfo>::iterator q = _sessions.find(p->second.session); + map<shared_ptr<Ice::Object>, SessionInfo>::iterator q = _sessions.find(p->second.session); assert(q != _sessions.end()); q->second.identities.erase(id); @@ -245,9 +247,7 @@ SessionServantManager::remove(const Ice::Identity& id) { try { - Ice::IdentitySeq ids; - ids.push_back(id); - q->second.identitySet->remove(ids); + q->second.identitySet->remove({id}); } catch(const Ice::LocalException&) { @@ -260,10 +260,10 @@ SessionServantManager::remove(const Ice::Identity& id) _servants.erase(p); } -Ice::ObjectPrx -SessionServantManager::addImpl(const Ice::ObjectPtr& servant, const Ice::ObjectPtr& session) +shared_ptr<Ice::ObjectPrx> +SessionServantManager::addImpl(const shared_ptr<Ice::Object>& servant, const shared_ptr<Ice::Object>& session) { - map<Ice::ObjectPtr, SessionInfo>::iterator p = _sessions.find(session); + auto p = _sessions.find(session); assert(p != _sessions.end()); Ice::Identity id; @@ -282,9 +282,7 @@ SessionServantManager::addImpl(const Ice::ObjectPtr& servant, const Ice::ObjectP { try { - Ice::IdentitySeq ids; - ids.push_back(id); - p->second.identitySet->add(ids); + p->second.identitySet->add({id}); } catch(const Ice::LocalException&) { diff --git a/cpp/src/IceGrid/SessionServantManager.h b/cpp/src/IceGrid/SessionServantManager.h index 766171e9ba5..817f4c11714 100644 --- a/cpp/src/IceGrid/SessionServantManager.h +++ b/cpp/src/IceGrid/SessionServantManager.h @@ -6,7 +6,6 @@ #define ICE_GRID_SESSIONSERVANTLOCATOR_H #include <IceGrid/AdminCallbackRouter.h> -#include <IceUtil/Mutex.h> #include <Ice/ServantLocator.h> #include <Glacier2/Session.h> @@ -16,77 +15,85 @@ namespace IceGrid { -class SessionServantManager : public Ice::ServantLocator, public IceUtil::Mutex +class SessionServantManager final : public Ice::ServantLocator { public: - SessionServantManager(const Ice::ObjectAdapterPtr&, const std::string&, bool, - const std::string&, const Ice::ObjectPtr&, - const std::string&, const Ice::ObjectPtr&, - const std::string&, const Ice::ObjectPtr&, - const AdminCallbackRouterPtr&); + SessionServantManager(const std::shared_ptr<Ice::ObjectAdapter>&, const std::string&, bool, + const std::string&, const std::shared_ptr<Ice::Object>&, + const std::string&, const std::shared_ptr<Ice::Object>&, + const std::string&, const std::shared_ptr<Ice::Object>&, + const std::shared_ptr<AdminCallbackRouter>&); - Ice::ObjectPtr locate(const Ice::Current&, Ice::LocalObjectPtr&); - void finished(const Ice::Current&, const Ice::ObjectPtr&, const Ice::LocalObjectPtr&); + std::shared_ptr<Ice::Object> locate(const Ice::Current&, std::shared_ptr<void>&); + void finished(const Ice::Current&, const std::shared_ptr<Ice::Object>&, const std::shared_ptr<void>&); void deactivate(const std::string&); - Ice::ObjectPrx addSession(const Ice::ObjectPtr&, const Ice::ConnectionPtr&, const std::string&); - void setSessionControl(const Ice::ObjectPtr&, const Glacier2::SessionControlPrx&, const Ice::IdentitySeq&); - Glacier2::IdentitySetPrx getGlacier2IdentitySet(const Ice::ObjectPtr&); - Glacier2::StringSetPrx getGlacier2AdapterIdSet(const Ice::ObjectPtr&); - void removeSession(const Ice::ObjectPtr&); + std::shared_ptr<Ice::ObjectPrx> addSession(const std::shared_ptr<Ice::Object>&, + const std::shared_ptr<Ice::Connection>&, + const std::string&); + void setSessionControl(const std::shared_ptr<Ice::Object>&, + const std::shared_ptr<Glacier2::SessionControlPrx>&, const Ice::IdentitySeq&); + std::shared_ptr<Glacier2::IdentitySetPrx> getGlacier2IdentitySet(const std::shared_ptr<Ice::Object>&); + std::shared_ptr<Glacier2::StringSetPrx> getGlacier2AdapterIdSet(const std::shared_ptr<Ice::Object>&); + void removeSession(const std::shared_ptr<Ice::Object>&); - Ice::ObjectPrx add(const Ice::ObjectPtr&, const Ice::ObjectPtr&); + std::shared_ptr<Ice::ObjectPrx> add(const std::shared_ptr<Ice::Object>&, const std::shared_ptr<Ice::Object>&); void remove(const Ice::Identity&); - void connectionHeartbeat(const Ice::ConnectionPtr&); - void connectionClosed(const Ice::ConnectionPtr&); + void connectionHeartbeat(const std::shared_ptr<Ice::Connection>&); + void connectionClosed(const std::shared_ptr<Ice::Connection>&); private: - Ice::ObjectPrx addImpl(const Ice::ObjectPtr&, const Ice::ObjectPtr&); + std::shared_ptr<Ice::ObjectPrx> addImpl(const std::shared_ptr<Ice::Object>&, const std::shared_ptr<Ice::Object>&); struct ServantInfo { - ServantInfo(const Ice::ObjectPtr& s, const Ice::ConnectionPtr& con, const Ice::ObjectPtr& ss) : + ServantInfo(const std::shared_ptr<Ice::Object>& s, + const std::shared_ptr<Ice::Connection>& con, + const std::shared_ptr<Ice::Object>& ss) : servant(s), connection(con), session(ss) { } - const Ice::ObjectPtr servant; - const Ice::ConnectionPtr connection; - const Ice::ObjectPtr session; + const std::shared_ptr<Ice::Object> servant; + const std::shared_ptr<Ice::Connection> connection; + const std::shared_ptr<Ice::Object> session; }; struct SessionInfo { - SessionInfo(const Ice::ConnectionPtr& c, const std::string& cat) : connection(c), category(cat) { } + SessionInfo(const std::shared_ptr<Ice::Connection>& c, const std::string& cat) : connection(c), category(cat) + { + } - const Ice::ConnectionPtr connection; + const std::shared_ptr<Ice::Connection> connection; const std::string category; - Glacier2::SessionControlPrx sessionControl; - Glacier2::IdentitySetPrx identitySet; - Glacier2::StringSetPrx adapterIdSet; + std::shared_ptr<Glacier2::SessionControlPrx> sessionControl; + std::shared_ptr<Glacier2::IdentitySetPrx> identitySet; + std::shared_ptr<Glacier2::StringSetPrx> adapterIdSet; std::set<Ice::Identity> identities; }; - const Ice::ObjectAdapterPtr _adapter; + const std::shared_ptr<Ice::ObjectAdapter> _adapter; const std::string _instanceName; const bool _checkConnection; const std::string _serverAdminCategory; - const Ice::ObjectPtr _serverAdminRouter; + const std::shared_ptr<Ice::Object> _serverAdminRouter; const std::string _nodeAdminCategory; - const Ice::ObjectPtr _nodeAdminRouter; + const std::shared_ptr<Ice::Object> _nodeAdminRouter; const std::string _replicaAdminCategory; - const Ice::ObjectPtr _replicaAdminRouter; - const AdminCallbackRouterPtr _adminCallbackRouter; + const std::shared_ptr<Ice::Object> _replicaAdminRouter; + const std::shared_ptr<AdminCallbackRouter> _adminCallbackRouter; std::map<Ice::Identity, ServantInfo> _servants; - std::map<Ice::ObjectPtr, SessionInfo> _sessions; - std::multiset<Ice::ConnectionPtr> _adminConnections; + std::map<std::shared_ptr<Ice::Object>, SessionInfo> _sessions; + std::multiset<std::shared_ptr<Ice::Connection>> _adminConnections; + + std::mutex _mutex; }; -typedef IceUtil::Handle<SessionServantManager> SessionServantManagerPtr; }; diff --git a/cpp/src/IceGrid/Topics.cpp b/cpp/src/IceGrid/Topics.cpp index 8ab60af908a..119209dd636 100644 --- a/cpp/src/IceGrid/Topics.cpp +++ b/cpp/src/IceGrid/Topics.cpp @@ -24,14 +24,15 @@ Ice::EncodingVersion encodings[] = { } -ObserverTopic::ObserverTopic(const IceStorm::TopicManagerPrx& topicManager, const string& name, Ice::Long dbSerial) : +ObserverTopic::ObserverTopic(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, const string& name, + long long dbSerial) : _logger(topicManager->ice_getCommunicator()->getLogger()), _serial(0), _dbSerial(dbSerial) { for(int i = 0; i < static_cast<int>(sizeof(encodings) / sizeof(Ice::EncodingVersion)); ++i) { ostringstream os; os << name << "-" << Ice::encodingVersionToString(encodings[i]); - IceStorm::TopicPrx t; + shared_ptr<IceStorm::TopicPrx> t; try { t = topicManager->create(os.str()); @@ -51,14 +52,10 @@ ObserverTopic::ObserverTopic(const IceStorm::TopicManagerPrx& topicManager, cons } } -ObserverTopic::~ObserverTopic() -{ -} - int -ObserverTopic::subscribe(const Ice::ObjectPrx& obsv, const string& name) +ObserverTopic::subscribe(const shared_ptr<Ice::ObjectPrx>& obsv, const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -70,7 +67,7 @@ ObserverTopic::subscribe(const Ice::ObjectPrx& obsv, const string& name) IceStorm::QoS qos; qos["reliability"] = "ordered"; Ice::EncodingVersion v = IceInternal::getCompatibleEncoding(obsv->ice_getEncodingVersion()); - map<Ice::EncodingVersion, IceStorm::TopicPrx>::const_iterator p = _topics.find(v); + auto p = _topics.find(v); if(p == _topics.end()) { Ice::Warning out(_logger); @@ -95,11 +92,11 @@ ObserverTopic::subscribe(const Ice::ObjectPrx& obsv, const string& name) } void -ObserverTopic::unsubscribe(const Ice::ObjectPrx& observer, const string& name) +ObserverTopic::unsubscribe(const shared_ptr<Ice::ObjectPrx>& observer, const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); Ice::EncodingVersion v = IceInternal::getCompatibleEncoding(observer->ice_getEncodingVersion()); - map<Ice::EncodingVersion, IceStorm::TopicPrx>::const_iterator q = _topics.find(v); + auto q = _topics.find(v); if(q == _topics.end()) { return; @@ -119,7 +116,7 @@ ObserverTopic::unsubscribe(const Ice::ObjectPrx& observer, const string& name) assert(_syncSubscribers.find(name) != _syncSubscribers.end()); _syncSubscribers.erase(name); - map<int, set<string> >::iterator p = _waitForUpdates.begin(); + auto p = _waitForUpdates.begin(); bool notifyMonitor = false; while(p != _waitForUpdates.end()) { @@ -137,7 +134,7 @@ ObserverTopic::unsubscribe(const Ice::ObjectPrx& observer, const string& name) if(notifyMonitor) { - notifyAll(); + _condVar.notify_all(); } } } @@ -145,15 +142,15 @@ ObserverTopic::unsubscribe(const Ice::ObjectPrx& observer, const string& name) void ObserverTopic::destroy() { - Lock sync(*this); + lock_guard lock(_mutex); _topics.clear(); - notifyAll(); + _condVar.notify_all(); } void ObserverTopic::receivedUpdate(const string& name, int serial, const string& failure) { - Lock sync(*this); + lock_guard lock(_mutex); map<int, set<string> >::iterator p = _waitForUpdates.find(serial); if(p != _waitForUpdates.end()) { @@ -174,47 +171,15 @@ ObserverTopic::receivedUpdate(const string& name, int serial, const string& fail _waitForUpdates.erase(p); } - notifyAll(); + _condVar.notify_all(); } } void ObserverTopic::waitForSyncedSubscribers(int serial, const string& name) { - Lock sync(*this); - waitForSyncedSubscribersNoSync(serial, name); -} - -int -ObserverTopic::getSerial() const -{ - Lock sync(*this); - return _serial; -} - -void -ObserverTopic::addExpectedUpdate(int serial, const string& name) -{ - if(_syncSubscribers.empty() && name.empty()) - { - return; - } + unique_lock lock(_mutex); - // Must be called with the lock held. - if(name.empty()) - { - assert(_waitForUpdates[serial].empty()); - _waitForUpdates[serial] = _syncSubscribers; - } - else - { - _waitForUpdates[serial].insert(name); - } -} - -void -ObserverTopic::waitForSyncedSubscribersNoSync(int serial, const string& name) -{ if(serial < 0) { return; @@ -225,10 +190,10 @@ ObserverTopic::waitForSyncedSubscribersNoSync(int serial, const string& name) // while(!_topics.empty()) { - map<int, set<string> >::const_iterator p = _waitForUpdates.find(serial); + auto p = _waitForUpdates.find(serial); if(p == _waitForUpdates.end()) { - map<int, map<string, string> >::iterator q = _updateFailures.find(serial); + auto q = _updateFailures.find(serial); if(q != _updateFailures.end()) { map<string, string> failures = q->second; @@ -250,13 +215,40 @@ ObserverTopic::waitForSyncedSubscribersNoSync(int serial, const string& name) { return; } - wait(); + _condVar.wait(lock); } } } +int +ObserverTopic::getSerial() const +{ + lock_guard lock(_mutex); + return _serial; +} + +void +ObserverTopic::addExpectedUpdate(int serial, const string& name) +{ + if(_syncSubscribers.empty() && name.empty()) + { + return; + } + + // Must be called with the lock held. + if(name.empty()) + { + assert(_waitForUpdates[serial].empty()); + _waitForUpdates[serial] = _syncSubscribers; + } + else + { + _waitForUpdates[serial].insert(name); + } +} + void -ObserverTopic::updateSerial(Ice::Long dbSerial) +ObserverTopic::updateSerial(long long dbSerial) { ++_serial; if(dbSerial > 0) @@ -266,7 +258,7 @@ ObserverTopic::updateSerial(Ice::Long dbSerial) } Ice::Context -ObserverTopic::getContext(int serial, Ice::Long dbSerial) const +ObserverTopic::getContext(int serial, long long dbSerial) const { Ice::Context context; { @@ -283,7 +275,7 @@ ObserverTopic::getContext(int serial, Ice::Long dbSerial) const return context; } -RegistryObserverTopic::RegistryObserverTopic(const IceStorm::TopicManagerPrx& topicManager) : +RegistryObserverTopic::RegistryObserverTopic(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager) : ObserverTopic(topicManager, "RegistryObserver") { _publishers = getPublishers<RegistryObserverPrx>(); @@ -292,18 +284,18 @@ RegistryObserverTopic::RegistryObserverTopic(const IceStorm::TopicManagerPrx& to void RegistryObserverTopic::registryUp(const RegistryInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return; } updateSerial(); - _registries.insert(make_pair(info.name, info)); + _registries.insert({ info.name, info }); try { - for(vector<RegistryObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->registryUp(info); + publisher->registryUp(info); } } catch(const Ice::LocalException& ex) @@ -316,7 +308,7 @@ RegistryObserverTopic::registryUp(const RegistryInfo& info) void RegistryObserverTopic::registryDown(const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return; @@ -331,9 +323,9 @@ RegistryObserverTopic::registryDown(const string& name) _registries.erase(name); try { - for(vector<RegistryObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->registryDown(name); + publisher->registryDown(name); } } catch(const Ice::LocalException& ex) @@ -344,57 +336,67 @@ RegistryObserverTopic::registryDown(const string& name) } void -RegistryObserverTopic::initObserver(const Ice::ObjectPrx& obsv) +RegistryObserverTopic::initObserver(const shared_ptr<Ice::ObjectPrx>& obsv) { - RegistryObserverPrx observer = RegistryObserverPrx::uncheckedCast(obsv); + auto observer = Ice::uncheckedCast<RegistryObserverPrx>(obsv); RegistryInfoSeq registries; registries.reserve(_registries.size()); - for(map<string, RegistryInfo>::const_iterator p = _registries.begin(); p != _registries.end(); ++p) + for(const auto& registry : _registries) { - registries.push_back(p->second); + registries.push_back(registry.second); } observer->registryInit(registries, getContext(_serial)); } -NodeObserverTopic::NodeObserverTopic(const IceStorm::TopicManagerPrx& topicManager, - const Ice::ObjectAdapterPtr& adapter) : - ObserverTopic(topicManager, "NodeObserver") +shared_ptr<NodeObserverTopic> +NodeObserverTopic::create(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, + const shared_ptr<Ice::ObjectAdapter>& adapter) { - _publishers = getPublishers<NodeObserverPrx>(); + shared_ptr<NodeObserverTopic> topic(new NodeObserverTopic(topicManager)); + try { - const_cast<NodeObserverPrx&>(_externalPublisher) = NodeObserverPrx::uncheckedCast(adapter->addWithUUID(this)); + const_cast<shared_ptr<NodeObserverPrx>&>(topic->_externalPublisher) = + Ice::uncheckedCast<NodeObserverPrx>(adapter->addWithUUID(topic)); } catch(const Ice::LocalException&) { } + + return topic; +} + +NodeObserverTopic::NodeObserverTopic(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager) : + ObserverTopic(topicManager, "NodeObserver") +{ + _publishers = getPublishers<NodeObserverPrx>(); } void -NodeObserverTopic::nodeInit(const NodeDynamicInfoSeq&, const Ice::Current&) +NodeObserverTopic::nodeInit(NodeDynamicInfoSeq, const Ice::Current&) { assert(false); } void -NodeObserverTopic::nodeUp(const NodeDynamicInfo& info, const Ice::Current&) +NodeObserverTopic::nodeUp(NodeDynamicInfo info, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return; } updateSerial(); - _nodes.insert(make_pair(info.info.name, info)); - for(ServerDynamicInfoSeq::const_iterator p = info.servers.begin(); p != info.servers.end(); ++p) + _nodes.insert({ info.info.name, info }); + for(const auto& server : info.servers) { - _serverStatus[p->id] = p->enabled; + _serverStatus[server.id] = server.enabled; } try { - for(vector<NodeObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->nodeUp(info); + publisher->nodeUp(info); } } catch(const Ice::LocalException& ex) @@ -405,15 +407,15 @@ NodeObserverTopic::nodeUp(const NodeDynamicInfo& info, const Ice::Current&) } void -NodeObserverTopic::nodeDown(const string& /*name*/, const Ice::Current&) +NodeObserverTopic::nodeDown(string, const Ice::Current&) { assert(false); } void -NodeObserverTopic::updateServer(const string& node, const ServerDynamicInfo& server, const Ice::Current&) +NodeObserverTopic::updateServer(string node, ServerDynamicInfo server, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return; @@ -435,7 +437,7 @@ NodeObserverTopic::updateServer(const string& node, const ServerDynamicInfo& ser { if(p->id == server.id) { - if(server.state == Destroyed || (server.state == Inactive && server.enabled)) + if(server.state == ServerState::Destroyed || (server.state == ServerState::Inactive && server.enabled)) { servers.erase(p); } @@ -447,12 +449,13 @@ NodeObserverTopic::updateServer(const string& node, const ServerDynamicInfo& ser } ++p; } - if(server.state != Destroyed && (server.state != Inactive || !server.enabled) && p == servers.end()) + if(server.state != ServerState::Destroyed && (server.state != ServerState::Inactive + || !server.enabled) && p == servers.end()) { servers.push_back(server); } - if(server.state != Destroyed) + if(server.state != ServerState::Destroyed) { _serverStatus[server.id] = server.enabled; } @@ -463,9 +466,9 @@ NodeObserverTopic::updateServer(const string& node, const ServerDynamicInfo& ser try { - for(vector<NodeObserverPrx>::const_iterator q = _publishers.begin(); q != _publishers.end(); ++q) + for(const auto& publisher : _publishers) { - (*q)->updateServer(node, server); + publisher->updateServer(node, server); } } catch(const Ice::LocalException& ex) @@ -476,9 +479,9 @@ NodeObserverTopic::updateServer(const string& node, const ServerDynamicInfo& ser } void -NodeObserverTopic::updateAdapter(const string& node, const AdapterDynamicInfo& adapter, const Ice::Current&) +NodeObserverTopic::updateAdapter(string node, AdapterDynamicInfo adapter, const Ice::Current&) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return; @@ -519,9 +522,9 @@ NodeObserverTopic::updateAdapter(const string& node, const AdapterDynamicInfo& a try { - for(vector<NodeObserverPrx>::const_iterator q = _publishers.begin(); q != _publishers.end(); ++q) + for(const auto& publisher : _publishers) { - (*q)->updateAdapter(node, adapter); + publisher->updateAdapter(node, adapter); } } catch(const Ice::LocalException& ex) @@ -534,7 +537,7 @@ NodeObserverTopic::updateAdapter(const string& node, const AdapterDynamicInfo& a void NodeObserverTopic::nodeDown(const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return; @@ -548,17 +551,17 @@ NodeObserverTopic::nodeDown(const string& name) } ServerDynamicInfoSeq& servers = _nodes[name].servers; - for(ServerDynamicInfoSeq::const_iterator p = servers.begin(); p != servers.end(); ++p) + for(const auto& server : servers) { - _serverStatus.erase(p->id); + _serverStatus.erase(server.id); } _nodes.erase(name); try { - for(vector<NodeObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->nodeDown(name); + publisher->nodeDown(name); } } catch(const Ice::LocalException& ex) @@ -569,14 +572,14 @@ NodeObserverTopic::nodeDown(const string& name) } void -NodeObserverTopic::initObserver(const Ice::ObjectPrx& obsv) +NodeObserverTopic::initObserver(const shared_ptr<Ice::ObjectPrx>& obsv) { - NodeObserverPrx observer = NodeObserverPrx::uncheckedCast(obsv); + auto observer = Ice::uncheckedCast<NodeObserverPrx>(obsv); NodeDynamicInfoSeq nodes; nodes.reserve(_nodes.size()); - for(map<string, NodeDynamicInfo>::const_iterator p = _nodes.begin(); p != _nodes.end(); ++p) + for(const auto& node : _nodes ) { - nodes.push_back(p->second); + nodes.push_back(node.second); } observer->nodeInit(nodes, getContext(_serial)); } @@ -584,7 +587,7 @@ NodeObserverTopic::initObserver(const Ice::ObjectPrx& obsv) bool NodeObserverTopic::isServerEnabled(const string& server) const { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return false; @@ -600,8 +603,8 @@ NodeObserverTopic::isServerEnabled(const string& server) const } } -ApplicationObserverTopic::ApplicationObserverTopic(const IceStorm::TopicManagerPrx& topicManager, - const map<string, ApplicationInfo>& applications, Ice::Long serial) : +ApplicationObserverTopic::ApplicationObserverTopic(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, + const map<string, ApplicationInfo>& applications, long long serial) : ObserverTopic(topicManager, "ApplicationObserver", serial), _applications(applications) { @@ -609,9 +612,9 @@ ApplicationObserverTopic::ApplicationObserverTopic(const IceStorm::TopicManagerP } int -ApplicationObserverTopic::applicationInit(Ice::Long dbSerial, const ApplicationInfoSeq& apps) +ApplicationObserverTopic::applicationInit(long long dbSerial, const ApplicationInfoSeq& apps) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -624,9 +627,9 @@ ApplicationObserverTopic::applicationInit(Ice::Long dbSerial, const ApplicationI } try { - for(vector<ApplicationObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->applicationInit(_serial, apps, getContext(_serial, dbSerial)); + publisher->applicationInit(_serial, apps, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -639,9 +642,9 @@ ApplicationObserverTopic::applicationInit(Ice::Long dbSerial, const ApplicationI } int -ApplicationObserverTopic::applicationAdded(Ice::Long dbSerial, const ApplicationInfo& info) +ApplicationObserverTopic::applicationAdded(long long dbSerial, const ApplicationInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -651,9 +654,9 @@ ApplicationObserverTopic::applicationAdded(Ice::Long dbSerial, const Application _applications.insert(make_pair(info.descriptor.name, info)); try { - for(vector<ApplicationObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->applicationAdded(_serial, info, getContext(_serial, dbSerial)); + publisher->applicationAdded(_serial, info, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -666,9 +669,9 @@ ApplicationObserverTopic::applicationAdded(Ice::Long dbSerial, const Application } int -ApplicationObserverTopic::applicationRemoved(Ice::Long dbSerial, const string& name) +ApplicationObserverTopic::applicationRemoved(long long dbSerial, const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -677,9 +680,9 @@ ApplicationObserverTopic::applicationRemoved(Ice::Long dbSerial, const string& n _applications.erase(name); try { - for(vector<ApplicationObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->applicationRemoved(_serial, name, getContext(_serial, dbSerial)); + publisher->applicationRemoved(_serial, name, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -692,9 +695,9 @@ ApplicationObserverTopic::applicationRemoved(Ice::Long dbSerial, const string& n } int -ApplicationObserverTopic::applicationUpdated(Ice::Long dbSerial, const ApplicationUpdateInfo& info) +ApplicationObserverTopic::applicationUpdated(long long dbSerial, const ApplicationUpdateInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -733,9 +736,9 @@ ApplicationObserverTopic::applicationUpdated(Ice::Long dbSerial, const Applicati } try { - for(vector<ApplicationObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->applicationUpdated(_serial, info, getContext(_serial, dbSerial)); + publisher->applicationUpdated(_serial, info, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -748,19 +751,19 @@ ApplicationObserverTopic::applicationUpdated(Ice::Long dbSerial, const Applicati } void -ApplicationObserverTopic::initObserver(const Ice::ObjectPrx& obsv) +ApplicationObserverTopic::initObserver(const shared_ptr<Ice::ObjectPrx>& obsv) { - ApplicationObserverPrx observer = ApplicationObserverPrx::uncheckedCast(obsv); + auto observer = Ice::uncheckedCast<ApplicationObserverPrx>(obsv); ApplicationInfoSeq applications; - for(map<string, ApplicationInfo>::const_iterator p = _applications.begin(); p != _applications.end(); ++p) + for(const auto& application : _applications) { - applications.push_back(p->second); + applications.push_back(application.second); } observer->applicationInit(_serial, applications, getContext(_serial, _dbSerial)); } -AdapterObserverTopic::AdapterObserverTopic(const IceStorm::TopicManagerPrx& topicManager, - const map<string, AdapterInfo>& adapters, Ice::Long serial) : +AdapterObserverTopic::AdapterObserverTopic(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, + const map<string, AdapterInfo>& adapters, long long serial) : ObserverTopic(topicManager, "AdapterObserver", serial), _adapters(adapters) { @@ -768,24 +771,24 @@ AdapterObserverTopic::AdapterObserverTopic(const IceStorm::TopicManagerPrx& topi } int -AdapterObserverTopic::adapterInit(Ice::Long dbSerial, const AdapterInfoSeq& adpts) +AdapterObserverTopic::adapterInit(long long dbSerial, const AdapterInfoSeq& adpts) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; } updateSerial(dbSerial); _adapters.clear(); - for(AdapterInfoSeq::const_iterator q = adpts.begin(); q != adpts.end(); ++q) + for(const auto& adpt : adpts) { - _adapters.insert(make_pair(q->id, *q)); + _adapters.insert({ adpt.id, adpt }); } try { - for(vector<AdapterObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->adapterInit(adpts, getContext(_serial, dbSerial)); + publisher->adapterInit(adpts, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -798,9 +801,9 @@ AdapterObserverTopic::adapterInit(Ice::Long dbSerial, const AdapterInfoSeq& adpt } int -AdapterObserverTopic::adapterAdded(Ice::Long dbSerial, const AdapterInfo& info) +AdapterObserverTopic::adapterAdded(long long dbSerial, const AdapterInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -809,9 +812,9 @@ AdapterObserverTopic::adapterAdded(Ice::Long dbSerial, const AdapterInfo& info) _adapters.insert(make_pair(info.id, info)); try { - for(vector<AdapterObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->adapterAdded(info, getContext(_serial, dbSerial)); + publisher->adapterAdded(info, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -824,9 +827,9 @@ AdapterObserverTopic::adapterAdded(Ice::Long dbSerial, const AdapterInfo& info) } int -AdapterObserverTopic::adapterUpdated(Ice::Long dbSerial, const AdapterInfo& info) +AdapterObserverTopic::adapterUpdated(long long dbSerial, const AdapterInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -835,9 +838,9 @@ AdapterObserverTopic::adapterUpdated(Ice::Long dbSerial, const AdapterInfo& info _adapters[info.id] = info; try { - for(vector<AdapterObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->adapterUpdated(info, getContext(_serial, dbSerial)); + publisher->adapterUpdated(info, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -850,9 +853,9 @@ AdapterObserverTopic::adapterUpdated(Ice::Long dbSerial, const AdapterInfo& info } int -AdapterObserverTopic::adapterRemoved(Ice::Long dbSerial, const string& id) +AdapterObserverTopic::adapterRemoved(long long dbSerial, const string& id) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -861,9 +864,9 @@ AdapterObserverTopic::adapterRemoved(Ice::Long dbSerial, const string& id) _adapters.erase(id); try { - for(vector<AdapterObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->adapterRemoved(id, getContext(_serial, dbSerial)); + publisher->adapterRemoved(id, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -876,19 +879,19 @@ AdapterObserverTopic::adapterRemoved(Ice::Long dbSerial, const string& id) } void -AdapterObserverTopic::initObserver(const Ice::ObjectPrx& obsv) +AdapterObserverTopic::initObserver(const shared_ptr<Ice::ObjectPrx>& obsv) { - AdapterObserverPrx observer = AdapterObserverPrx::uncheckedCast(obsv); + auto observer = Ice::uncheckedCast<AdapterObserverPrx>(obsv); AdapterInfoSeq adapters; - for(map<string, AdapterInfo>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + for(const auto& adapter : _adapters) { - adapters.push_back(p->second); + adapters.push_back(adapter.second); } observer->adapterInit(adapters, getContext(_serial, _dbSerial)); } -ObjectObserverTopic::ObjectObserverTopic(const IceStorm::TopicManagerPrx& topicManager, - const map<Ice::Identity, ObjectInfo>& objects, Ice::Long serial) : +ObjectObserverTopic::ObjectObserverTopic(const shared_ptr<IceStorm::TopicManagerPrx>& topicManager, + const map<Ice::Identity, ObjectInfo>& objects, long long serial) : ObserverTopic(topicManager, "ObjectObserver", serial), _objects(objects) { @@ -896,24 +899,24 @@ ObjectObserverTopic::ObjectObserverTopic(const IceStorm::TopicManagerPrx& topicM } int -ObjectObserverTopic::objectInit(Ice::Long dbSerial, const ObjectInfoSeq& objects) +ObjectObserverTopic::objectInit(long long dbSerial, const ObjectInfoSeq& objects) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; } updateSerial(dbSerial); _objects.clear(); - for(ObjectInfoSeq::const_iterator r = objects.begin(); r != objects.end(); ++r) + for(const auto& object : objects) { - _objects.insert(make_pair(r->proxy->ice_getIdentity(), *r)); + _objects.insert(make_pair(object.proxy->ice_getIdentity(), object)); } try { - for(vector<ObjectObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->objectInit(objects, getContext(_serial, dbSerial)); + publisher->objectInit(objects, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -926,9 +929,9 @@ ObjectObserverTopic::objectInit(Ice::Long dbSerial, const ObjectInfoSeq& objects } int -ObjectObserverTopic::objectAdded(Ice::Long dbSerial, const ObjectInfo& info) +ObjectObserverTopic::objectAdded(long long dbSerial, const ObjectInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -937,9 +940,9 @@ ObjectObserverTopic::objectAdded(Ice::Long dbSerial, const ObjectInfo& info) _objects.insert(make_pair(info.proxy->ice_getIdentity(), info)); try { - for(vector<ObjectObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->objectAdded(info, getContext(_serial, dbSerial)); + publisher->objectAdded(info, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -952,9 +955,9 @@ ObjectObserverTopic::objectAdded(Ice::Long dbSerial, const ObjectInfo& info) } int -ObjectObserverTopic::objectUpdated(Ice::Long dbSerial, const ObjectInfo& info) +ObjectObserverTopic::objectUpdated(long long dbSerial, const ObjectInfo& info) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -963,9 +966,9 @@ ObjectObserverTopic::objectUpdated(Ice::Long dbSerial, const ObjectInfo& info) _objects[info.proxy->ice_getIdentity()] = info; try { - for(vector<ObjectObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->objectUpdated(info, getContext(_serial, dbSerial)); + publisher->objectUpdated(info, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -978,9 +981,9 @@ ObjectObserverTopic::objectUpdated(Ice::Long dbSerial, const ObjectInfo& info) } int -ObjectObserverTopic::objectRemoved(Ice::Long dbSerial, const Ice::Identity& id) +ObjectObserverTopic::objectRemoved(long long dbSerial, const Ice::Identity& id) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; @@ -989,9 +992,9 @@ ObjectObserverTopic::objectRemoved(Ice::Long dbSerial, const Ice::Identity& id) _objects.erase(id); try { - for(vector<ObjectObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p) + for(const auto& publisher : _publishers) { - (*p)->objectRemoved(id, getContext(_serial, dbSerial)); + publisher->objectRemoved(id, getContext(_serial, dbSerial)); } } catch(const Ice::LocalException& ex) @@ -1006,24 +1009,24 @@ ObjectObserverTopic::objectRemoved(Ice::Long dbSerial, const Ice::Identity& id) int ObjectObserverTopic::wellKnownObjectsAddedOrUpdated(const ObjectInfoSeq& infos) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; } - for(ObjectInfoSeq::const_iterator p = infos.begin(); p != infos.end(); ++p) + for(const auto& info : infos) { updateSerial(); - map<Ice::Identity, ObjectInfo>::iterator q = _objects.find(p->proxy->ice_getIdentity()); + auto q = _objects.find(info.proxy->ice_getIdentity()); if(q != _objects.end()) { - q->second = *p; + q->second = info; try { - for(vector<ObjectObserverPrx>::const_iterator r = _publishers.begin(); r != _publishers.end(); ++r) + for(const auto& publisher : _publishers) { - (*r)->objectUpdated(*p, getContext(_serial)); + publisher->objectUpdated(info, getContext(_serial)); } } catch(const Ice::LocalException& ex) @@ -1034,12 +1037,12 @@ ObjectObserverTopic::wellKnownObjectsAddedOrUpdated(const ObjectInfoSeq& infos) } else { - _objects.insert(make_pair(p->proxy->ice_getIdentity(), *p)); + _objects.insert(make_pair(info.proxy->ice_getIdentity(), info)); try { - for(vector<ObjectObserverPrx>::const_iterator r = _publishers.begin(); r != _publishers.end(); ++r) + for(const auto& publisher : _publishers) { - (*r)->objectAdded(*p, getContext(_serial)); + publisher->objectAdded(info, getContext(_serial)); } } catch(const Ice::LocalException& ex) @@ -1055,28 +1058,27 @@ ObjectObserverTopic::wellKnownObjectsAddedOrUpdated(const ObjectInfoSeq& infos) // here. This operation is called by ReplicaSessionI. // addExpectedUpdate(_serial); - //waitForSyncedSubscribersNoSync(_serial); return _serial; } int ObjectObserverTopic::wellKnownObjectsRemoved(const ObjectInfoSeq& infos) { - Lock sync(*this); + lock_guard lock(_mutex); if(_topics.empty()) { return -1; } - for(ObjectInfoSeq::const_iterator p = infos.begin(); p != infos.end(); ++p) + for(const auto& info : infos) { updateSerial(); - _objects.erase(p->proxy->ice_getIdentity()); + _objects.erase(info.proxy->ice_getIdentity()); try { - for(vector<ObjectObserverPrx>::const_iterator q = _publishers.begin(); q != _publishers.end(); ++q) + for(const auto& publisher : _publishers) { - (*q)->objectRemoved(p->proxy->ice_getIdentity(), getContext(_serial)); + publisher->objectRemoved(info.proxy->ice_getIdentity(), getContext(_serial)); } } catch(const Ice::LocalException& ex) @@ -1088,22 +1090,21 @@ ObjectObserverTopic::wellKnownObjectsRemoved(const ObjectInfoSeq& infos) // // We don't need to wait for the update to be received by the - // replicas here. This operation is only called internaly by + // replicas here. This operation is only called internally by // IceGrid. // addExpectedUpdate(_serial); - //waitForSyncedSubscribersNoSync(_serial); return _serial; } void -ObjectObserverTopic::initObserver(const Ice::ObjectPrx& obsv) +ObjectObserverTopic::initObserver(const shared_ptr<Ice::ObjectPrx>& obsv) { - ObjectObserverPrx observer = ObjectObserverPrx::uncheckedCast(obsv); + auto observer = Ice::uncheckedCast<ObjectObserverPrx>(obsv); ObjectInfoSeq objects; - for(map<Ice::Identity, ObjectInfo>::const_iterator p = _objects.begin(); p != _objects.end(); ++p) + for(const auto& object : _objects) { - objects.push_back(p->second); + objects.push_back(object.second); } observer->objectInit(objects, getContext(_serial, _dbSerial)); } diff --git a/cpp/src/IceGrid/Topics.h b/cpp/src/IceGrid/Topics.h index 01288d76715..48d60c2df7a 100644 --- a/cpp/src/IceGrid/Topics.h +++ b/cpp/src/IceGrid/Topics.h @@ -5,7 +5,6 @@ #ifndef ICEGRID_TOPICS_H #define ICEGRID_TOPICS_H -#include <IceUtil/Mutex.h> #include <IceStorm/IceStorm.h> #include <IceGrid/Internal.h> #include <IceGrid/Registry.h> @@ -14,20 +13,20 @@ namespace IceGrid { -class ObserverTopic : public IceUtil::Monitor<IceUtil::Mutex>, public virtual Ice::Object +class ObserverTopic { public: - ObserverTopic(const IceStorm::TopicManagerPrx&, const std::string&, Ice::Long = 0); - virtual ~ObserverTopic(); + ObserverTopic(const std::shared_ptr<IceStorm::TopicManagerPrx>&, const std::string&, long long = 0); + virtual ~ObserverTopic() = default; - int subscribe(const Ice::ObjectPrx&, const std::string& = std::string()); - void unsubscribe(const Ice::ObjectPrx&, const std::string& = std::string()); + int subscribe(const std::shared_ptr<Ice::ObjectPrx>&, const std::string& = std::string()); + void unsubscribe(const std::shared_ptr<Ice::ObjectPrx>&, const std::string& = std::string()); void destroy(); void receivedUpdate(const std::string&, int, const std::string&); - virtual void initObserver(const Ice::ObjectPrx&) = 0; + virtual void initObserver(const std::shared_ptr<Ice::ObjectPrx>&) = 0; void waitForSyncedSubscribers(int, const std::string& = std::string()); @@ -36,140 +35,139 @@ public: protected: void addExpectedUpdate(int, const std::string& = std::string()); - void waitForSyncedSubscribersNoSync(int, const std::string& = std::string()); - void updateSerial(Ice::Long = 0); - Ice::Context getContext(int, Ice::Long = 0) const; + void updateSerial(long long = 0); + Ice::Context getContext(int, long long = 0) const; - template<typename T> std::vector<T> getPublishers() const + template<typename T> std::vector<std::shared_ptr<T>> getPublishers() const { - std::vector<T> publishers; - for(std::vector<Ice::ObjectPrx>::const_iterator p = _basePublishers.begin(); p != _basePublishers.end(); ++p) + std::vector<std::shared_ptr<T>> publishers; + for(const auto& publisher :_basePublishers) { - publishers.push_back(T::uncheckedCast(*p)); + publishers.push_back(Ice::uncheckedCast<T>(publisher)); } return publishers; } - Ice::LoggerPtr _logger; - std::map<Ice::EncodingVersion, IceStorm::TopicPrx> _topics; - std::vector<Ice::ObjectPrx> _basePublishers; + std::shared_ptr<Ice::Logger> _logger; + std::map<Ice::EncodingVersion, std::shared_ptr<IceStorm::TopicPrx>> _topics; + std::vector<std::shared_ptr<Ice::ObjectPrx>> _basePublishers; int _serial; - Ice::Long _dbSerial; + long long _dbSerial; std::set<std::string> _syncSubscribers; std::map<int, std::set<std::string> > _waitForUpdates; std::map<int, std::map<std::string, std::string> > _updateFailures; + + mutable std::mutex _mutex; + std::condition_variable _condVar; }; -typedef IceUtil::Handle<ObserverTopic> ObserverTopicPtr; class RegistryObserverTopic : public ObserverTopic { public: - RegistryObserverTopic(const IceStorm::TopicManagerPrx&); + RegistryObserverTopic(const std::shared_ptr<IceStorm::TopicManagerPrx>&); void registryUp(const RegistryInfo&); void registryDown(const std::string&); - virtual void initObserver(const Ice::ObjectPrx&); + virtual void initObserver(const std::shared_ptr<Ice::ObjectPrx>&); private: - std::vector<RegistryObserverPrx> _publishers; + std::vector<std::shared_ptr<RegistryObserverPrx>> _publishers; std::map<std::string, RegistryInfo> _registries; }; -typedef IceUtil::Handle<RegistryObserverTopic> RegistryObserverTopicPtr; -class NodeObserverTopic : public ObserverTopic, public NodeObserver +class NodeObserverTopic final : public ObserverTopic, public NodeObserver { public: - NodeObserverTopic(const IceStorm::TopicManagerPrx&, const Ice::ObjectAdapterPtr&); + static std::shared_ptr<NodeObserverTopic> + create(const std::shared_ptr<IceStorm::TopicManagerPrx>&, const std::shared_ptr<Ice::ObjectAdapter>&); - virtual void nodeInit(const NodeDynamicInfoSeq&, const Ice::Current&); - virtual void nodeUp(const NodeDynamicInfo&, const Ice::Current&); - virtual void nodeDown(const std::string&, const Ice::Current&); - virtual void updateServer(const std::string&, const ServerDynamicInfo&, const Ice::Current&); - virtual void updateAdapter(const std::string&, const AdapterDynamicInfo&, const Ice::Current&); + void nodeInit(NodeDynamicInfoSeq, const Ice::Current&) override; + void nodeUp(NodeDynamicInfo, const Ice::Current&) override; + void nodeDown(std::string, const Ice::Current&) override; + void updateServer(std::string, ServerDynamicInfo, const Ice::Current&) override; + void updateAdapter(std::string, AdapterDynamicInfo, const Ice::Current&) override; - const NodeObserverPrx& getPublisher() { return _externalPublisher; } + const std::shared_ptr<NodeObserverPrx>& getPublisher() { return _externalPublisher; } void nodeDown(const std::string&); - virtual void initObserver(const Ice::ObjectPrx&); + void initObserver(const std::shared_ptr<Ice::ObjectPrx>&) override; bool isServerEnabled(const std::string&) const; private: - const NodeObserverPrx _externalPublisher; - std::vector<NodeObserverPrx> _publishers; + NodeObserverTopic(const std::shared_ptr<IceStorm::TopicManagerPrx>&); + + const std::shared_ptr<NodeObserverPrx> _externalPublisher; + std::vector<std::shared_ptr<NodeObserverPrx>> _publishers; std::map<std::string, NodeDynamicInfo> _nodes; std::map<std::string, bool> _serverStatus; }; -typedef IceUtil::Handle<NodeObserverTopic> NodeObserverTopicPtr; class ApplicationObserverTopic : public ObserverTopic { public: - ApplicationObserverTopic(const IceStorm::TopicManagerPrx&, const std::map<std::string, ApplicationInfo>&, Ice::Long); + ApplicationObserverTopic(const std::shared_ptr<IceStorm::TopicManagerPrx>&, const std::map<std::string, ApplicationInfo>&, long long); - int applicationInit(Ice::Long, const ApplicationInfoSeq&); - int applicationAdded(Ice::Long, const ApplicationInfo&); - int applicationRemoved(Ice::Long, const std::string&); - int applicationUpdated(Ice::Long, const ApplicationUpdateInfo&); + int applicationInit(long long, const ApplicationInfoSeq&); + int applicationAdded(long long, const ApplicationInfo&); + int applicationRemoved(long long, const std::string&); + int applicationUpdated(long long, const ApplicationUpdateInfo&); - virtual void initObserver(const Ice::ObjectPrx&); + virtual void initObserver(const std::shared_ptr<Ice::ObjectPrx>&); private: - std::vector<ApplicationObserverPrx> _publishers; + std::vector<std::shared_ptr<ApplicationObserverPrx>> _publishers; std::map<std::string, ApplicationInfo> _applications; }; -typedef IceUtil::Handle<ApplicationObserverTopic> ApplicationObserverTopicPtr; class AdapterObserverTopic : public ObserverTopic { public: - AdapterObserverTopic(const IceStorm::TopicManagerPrx&, const std::map<std::string, AdapterInfo>&, Ice::Long); + AdapterObserverTopic(const std::shared_ptr<IceStorm::TopicManagerPrx>&, const std::map<std::string, AdapterInfo>&, long long); - int adapterInit(Ice::Long, const AdapterInfoSeq&); - int adapterAdded(Ice::Long, const AdapterInfo&); - int adapterUpdated(Ice::Long, const AdapterInfo&); - int adapterRemoved(Ice::Long, const std::string&); + int adapterInit(long long, const AdapterInfoSeq&); + int adapterAdded(long long, const AdapterInfo&); + int adapterUpdated(long long, const AdapterInfo&); + int adapterRemoved(long long, const std::string&); - virtual void initObserver(const Ice::ObjectPrx&); + virtual void initObserver(const std::shared_ptr<Ice::ObjectPrx>&); private: - std::vector<AdapterObserverPrx> _publishers; + std::vector<std::shared_ptr<AdapterObserverPrx>> _publishers; std::map<std::string, AdapterInfo> _adapters; }; -typedef IceUtil::Handle<AdapterObserverTopic> AdapterObserverTopicPtr; class ObjectObserverTopic : public ObserverTopic { public: - ObjectObserverTopic(const IceStorm::TopicManagerPrx&, const std::map<Ice::Identity, ObjectInfo>&, Ice::Long); + ObjectObserverTopic(const std::shared_ptr<IceStorm::TopicManagerPrx>&, const std::map<Ice::Identity, ObjectInfo>&, long long); - int objectInit(Ice::Long, const ObjectInfoSeq&); - int objectAdded(Ice::Long, const ObjectInfo&); - int objectUpdated(Ice::Long, const ObjectInfo&); - int objectRemoved(Ice::Long, const Ice::Identity&); + int objectInit(long long, const ObjectInfoSeq&); + int objectAdded(long long, const ObjectInfo&); + int objectUpdated(long long, const ObjectInfo&); + int objectRemoved(long long, const Ice::Identity&); int wellKnownObjectsAddedOrUpdated(const ObjectInfoSeq&); int wellKnownObjectsRemoved(const ObjectInfoSeq&); - virtual void initObserver(const Ice::ObjectPrx&); + virtual void initObserver(const std::shared_ptr<Ice::ObjectPrx>&); private: - std::vector<ObjectObserverPrx> _publishers; + std::vector<std::shared_ptr<ObjectObserverPrx>> _publishers; std::map<Ice::Identity, ObjectInfo> _objects; }; -typedef IceUtil::Handle<ObjectObserverTopic> ObjectObserverTopicPtr; }; diff --git a/cpp/src/IceGrid/TraceLevels.cpp b/cpp/src/IceGrid/TraceLevels.cpp index 530661196ac..c65b20c3308 100644 --- a/cpp/src/IceGrid/TraceLevels.cpp +++ b/cpp/src/IceGrid/TraceLevels.cpp @@ -9,32 +9,32 @@ using namespace std; using namespace IceGrid; -TraceLevels::TraceLevels(const Ice::CommunicatorPtr& communicator, const string& prefix) : - admin(0), +TraceLevels::TraceLevels(const shared_ptr<Ice::Communicator>& communicator, const string& prefix) : + admin(), adminCat("Admin"), - application(0), + application(), applicationCat("Application"), - node(0), + node(), nodeCat("Node"), - replica(0), + replica(), replicaCat("Replica"), - server(0), + server(), serverCat("Server"), - adapter(0), + adapter(), adapterCat("Adapter"), - object(0), + object(), objectCat("Object"), - activator(0), + activator(), activatorCat("Activator"), - locator(0), + locator(), locatorCat("Locator"), - session(0), + session(), sessionCat("Session"), - discovery(0), + discovery(), discoveryCat("Discovery"), logger(communicator->getLogger()) { - Ice::PropertiesPtr properties = communicator->getProperties(); + auto properties = communicator->getProperties(); string keyBase = prefix + ".Trace."; const_cast<int&>(admin) = properties->getPropertyAsInt(keyBase + adminCat); @@ -49,7 +49,3 @@ TraceLevels::TraceLevels(const Ice::CommunicatorPtr& communicator, const string& const_cast<int&>(session) = properties->getPropertyAsInt(keyBase + sessionCat); const_cast<int&>(discovery) = properties->getPropertyAsInt(keyBase + discoveryCat); } - -TraceLevels::~TraceLevels() -{ -} diff --git a/cpp/src/IceGrid/TraceLevels.h b/cpp/src/IceGrid/TraceLevels.h index 11e5a852355..6d949d1a8b2 100644 --- a/cpp/src/IceGrid/TraceLevels.h +++ b/cpp/src/IceGrid/TraceLevels.h @@ -5,58 +5,54 @@ #ifndef ICE_GRID_TRACE_LEVELS_H #define ICE_GRID_TRACE_LEVELS_H -#include <IceUtil/Shared.h> #include <Ice/CommunicatorF.h> #include <Ice/LoggerF.h> namespace IceGrid { -class TraceLevels : public ::IceUtil::Shared +class TraceLevels { public: - TraceLevels(const Ice::CommunicatorPtr&, const std::string&); - virtual ~TraceLevels(); + TraceLevels(const std::shared_ptr<Ice::Communicator>&, const std::string&); const int admin; - const char* adminCat; + const std::string adminCat; const int application; - const char* applicationCat; + const std::string applicationCat; const int node; - const char* nodeCat; + const std::string nodeCat; const int replica; - const char* replicaCat; + const std::string replicaCat; const int server; - const char* serverCat; + const std::string serverCat; const int adapter; - const char* adapterCat; + const std::string adapterCat; const int object; - const char* objectCat; + const std::string objectCat; const int activator; - const char* activatorCat; + const std::string activatorCat; const int locator; - const char* locatorCat; + const std::string locatorCat; const int session; - const char* sessionCat; + const std::string sessionCat; const int discovery; - const char* discoveryCat; + const std::string discoveryCat; - const Ice::LoggerPtr logger; + const std::shared_ptr<Ice::Logger> logger; }; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - } // End namespace IceGrid #endif diff --git a/cpp/src/IceGrid/Util.cpp b/cpp/src/IceGrid/Util.cpp index f9dfe622877..d7778805171 100644 --- a/cpp/src/IceGrid/Util.cpp +++ b/cpp/src/IceGrid/Util.cpp @@ -71,12 +71,12 @@ IceGrid::toString(const vector<string>& v, const string& sep) } string -IceGrid::toString(const Ice::Exception& exception) +IceGrid::toString(exception_ptr exception) { std::ostringstream os; try { - exception.ice_throw(); + rethrow_exception(exception); } catch(const NodeUnreachableException& ex) { @@ -239,7 +239,8 @@ IceGrid::escapeProperty(const string& s, bool escapeEqual) } ObjectInfo -IceGrid::toObjectInfo(const Ice::CommunicatorPtr& communicator, const ObjectDescriptor& obj, const string& adapterId) +IceGrid::toObjectInfo(const shared_ptr<Ice::Communicator>& communicator, const ObjectDescriptor& obj, + const string& adapterId) { ObjectInfo info; info.type = obj.type; @@ -264,7 +265,7 @@ IceGrid::toObjectInfo(const Ice::CommunicatorPtr& communicator, const ObjectDesc } void -IceGrid::setupThreadPool(const PropertiesPtr& properties, const string& name, int size, int sizeMax, bool serialize) +IceGrid::setupThreadPool(const shared_ptr<Properties>& properties, const string& name, int size, int maxSize, bool serialize) { if(properties->getPropertyAsIntWithDefault(name + ".Size", 0) < size) { @@ -277,16 +278,16 @@ IceGrid::setupThreadPool(const PropertiesPtr& properties, const string& name, in size = properties->getPropertyAsInt(name + ".Size"); } - if(sizeMax > 0 && properties->getPropertyAsIntWithDefault(name + ".SizeMax", 0) < sizeMax) + if(maxSize > 0 && properties->getPropertyAsIntWithDefault(name + ".MaxSize", 0) < maxSize) { - if(size >= sizeMax) + if(size >= maxSize) { - sizeMax = size * 10; + maxSize = size * 10; } ostringstream os; - os << sizeMax; - properties->setProperty(name + ".SizeMax", os.str()); + os << maxSize; + properties->setProperty(name + ".MaxSize", os.str()); } if(serialize) @@ -298,13 +299,18 @@ IceGrid::setupThreadPool(const PropertiesPtr& properties, const string& name, in int IceGrid::getMMVersion(const string& o) { - // // Strip the version - // string::size_type beg = o.find_first_not_of(' '); string::size_type end = o.find_last_not_of(' '); string version = o.substr(beg == string::npos ? 0 : beg, end == string::npos ? o.length() - 1 : end - beg + 1); + // Remove any pre-release information from the version string. + string::size_type dashPos = version.find('-'); + if(dashPos != string::npos) + { + version = version.substr(0, dashPos); + } + string::size_type minorPos = version.find('.'); string::size_type patchPos = version.find('.', minorPos + 1); @@ -636,3 +642,9 @@ IceGrid::createDirectoryRecursive(const string& pa) } } } + +int +IceGrid::secondsToInt(const std::chrono::seconds& sec) +{ + return chrono::duration_cast<chrono::duration<int>>(sec).count(); +} diff --git a/cpp/src/IceGrid/Util.h b/cpp/src/IceGrid/Util.h index 6f5312102c4..d2792a595da 100644 --- a/cpp/src/IceGrid/Util.h +++ b/cpp/src/IceGrid/Util.h @@ -5,6 +5,7 @@ #ifndef ICE_GRID_UTIL_H #define ICE_GRID_UTIL_H +#include <Ice/Properties.h> #include <IceGrid/Descriptor.h> #include <IceUtil/StringUtil.h> #include <IceGrid/Exception.h> @@ -23,7 +24,7 @@ inline set_inserter(T& container) } std::string toString(const std::vector<std::string>&, const std::string& = std::string(" ")); -std::string toString(const Ice::Exception&); +std::string toString(std::exception_ptr); std::string getProperty(const PropertyDescriptorSeq&, const std::string&, const std::string& = std::string()); int getPropertyAsInt(const PropertyDescriptorSeq&, const std::string&, int = 0); @@ -32,9 +33,9 @@ bool hasProperty(const PropertyDescriptorSeq&, const std::string&); PropertyDescriptor createProperty(const std::string&, const std::string& = std::string()); std::string escapeProperty(const std::string&, bool = false); -ObjectInfo toObjectInfo(const Ice::CommunicatorPtr&, const ObjectDescriptor&, const std::string&); +ObjectInfo toObjectInfo(const std::shared_ptr<Ice::Communicator>&, const ObjectDescriptor&, const std::string&); -void setupThreadPool(const Ice::PropertiesPtr&, const std::string&, int, int = 0, bool = false); +void setupThreadPool(const std::shared_ptr<Ice::Properties>&, const std::string&, int, int = 0, bool = false); int getMMVersion(const std::string&); @@ -45,118 +46,82 @@ Ice::StringSeq readDirectory(const std::string&); void createDirectory(const std::string&); void createDirectoryRecursive(const std::string&); -template<class Function> -struct ForEachCommunicator : std::unary_function<CommunicatorDescriptorPtr&, void> +int secondsToInt(const std::chrono::seconds&); + +inline void +forEachCommunicator(const std::shared_ptr<CommunicatorDescriptor>& descriptor, + std::function<void(const std::shared_ptr<CommunicatorDescriptor>&)> callback) { - ForEachCommunicator(Function f) : _function(f) + callback(descriptor); + auto iceBox = std::dynamic_pointer_cast<IceBoxDescriptor>(descriptor); + if(iceBox) { + for(const auto& service : iceBox->services) + { + forEachCommunicator(service.descriptor, callback); + } } +} - void - operator()(const ServiceInstanceDescriptor& descriptor) +inline void +forEachCommunicator(const std::shared_ptr<CommunicatorDescriptor>& oldDescriptor, + const std::shared_ptr<CommunicatorDescriptor>& newDescriptor, + std::function<void(const std::shared_ptr<CommunicatorDescriptor>&, + const std::shared_ptr<CommunicatorDescriptor>&)> callback) +{ + callback(oldDescriptor, newDescriptor); + + auto oldIceBox = std::dynamic_pointer_cast<IceBoxDescriptor>(oldDescriptor); + auto newIceBox = std::dynamic_pointer_cast<IceBoxDescriptor>(newDescriptor); + + if(oldIceBox && !newIceBox) { - assert(descriptor.descriptor); - operator()(descriptor.descriptor); + for(const auto& service : oldIceBox->services) + { + callback(service.descriptor, nullptr); + } } - - void - operator()(const CommunicatorDescriptorPtr& descriptor) + else if(!oldIceBox && newIceBox) { - _function(descriptor); - IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(descriptor); - if(iceBox) + for(const auto& service: newIceBox->services) { - for_each(iceBox->services.begin(), iceBox->services.end(), forEachCommunicator(_function)); + callback(nullptr, service.descriptor); } } - - void - operator()(const CommunicatorDescriptorPtr& oldDesc, const CommunicatorDescriptorPtr& newDesc) + else if(oldIceBox && newIceBox) { - _function(oldDesc, newDesc); - - IceBoxDescriptorPtr oldIceBox = IceBoxDescriptorPtr::dynamicCast(oldDesc); - IceBoxDescriptorPtr newIceBox = IceBoxDescriptorPtr::dynamicCast(newDesc); - ServiceInstanceDescriptorSeq::const_iterator p; - if(oldIceBox && !newIceBox) + for(const auto& oldService : oldIceBox->services) { - for(p = oldIceBox->services.begin(); p != oldIceBox->services.end(); ++p) + ServiceInstanceDescriptorSeq::const_iterator q; + for(q = newIceBox->services.begin(); q != newIceBox->services.end(); ++q) { - _function(p->descriptor, 0); + if(oldService.descriptor->name == q->descriptor->name) + { + callback(oldService.descriptor, q->descriptor); + break; + } } - } - else if(!oldIceBox && newIceBox) - { - for(p = newIceBox->services.begin(); p != newIceBox->services.end(); ++p) + if(q == newIceBox->services.end()) { - _function(0, p->descriptor); + callback(oldService.descriptor, nullptr); } } - else if(oldIceBox && newIceBox) + for(const auto& newService : newIceBox->services) { - for(p = oldIceBox->services.begin(); p != oldIceBox->services.end(); ++p) + ServiceInstanceDescriptorSeq::const_iterator q; + for(q = oldIceBox->services.begin(); q != oldIceBox->services.end(); ++q) { - ServiceInstanceDescriptorSeq::const_iterator q; - for(q = newIceBox->services.begin(); q != newIceBox->services.end(); ++q) - { - if(p->descriptor->name == q->descriptor->name) - { - _function(p->descriptor, q->descriptor); - break; - } - } - if(q == newIceBox->services.end()) + if(newService.descriptor->name == q->descriptor->name) { - _function(p->descriptor, 0); + break; } } - for(p = newIceBox->services.begin(); p != newIceBox->services.end(); ++p) + if(q == oldIceBox->services.end()) { - ServiceInstanceDescriptorSeq::const_iterator q; - for(q = oldIceBox->services.begin(); q != oldIceBox->services.end(); ++q) - { - if(p->descriptor->name == q->descriptor->name) - { - break; - } - } - if(q == oldIceBox->services.end()) - { - _function(0, p->descriptor); - } + callback(nullptr, newService.descriptor); } } } - - Function _function; -}; - -template<typename Function> ForEachCommunicator<Function> -inline forEachCommunicator(Function function) -{ - return ForEachCommunicator<Function>(function); -} - -template<class T, class A> -struct ObjFunc : std::unary_function<A, void> -{ - T& _obj; - typedef void (T::*MemberFN)(A); - MemberFN _mfn; - -public: - - explicit ObjFunc(T& obj, void (T::*f)(A)) : _obj(obj), _mfn(f) { } - void operator()(A arg) const - { - (_obj.*_mfn)(arg); - } -}; - -template<class T, class A> ObjFunc<T, A> -inline objFunc(T& obj, void (T::*p)(A)) -{ - return ObjFunc<T, A>(obj, p); } template <class T> std::vector<std::string> diff --git a/cpp/src/IceGrid/WaitQueue.cpp b/cpp/src/IceGrid/WaitQueue.cpp deleted file mode 100644 index 9111fbd9534..00000000000 --- a/cpp/src/IceGrid/WaitQueue.cpp +++ /dev/null @@ -1,175 +0,0 @@ -// -// Copyright (c) ZeroC, Inc. All rights reserved. -// - -#include <Ice/Ice.h> -#include <IceGrid/WaitQueue.h> - -using namespace std; -using namespace IceGrid; - -WaitItem::WaitItem() -{ -} - -WaitItem::~WaitItem() -{ -} - -const IceUtil::Time& -WaitItem:: getExpirationTime() -{ - return _expiration; -} - -void -WaitItem::setExpirationTime(const IceUtil::Time& time) -{ - _expiration = time; -} - -WaitQueue::WaitQueue() : - Thread("IceGrid wait queue thread"), - _destroyed(false) -{ -} - -void -WaitQueue::run() -{ - while(true) - { - list<WaitItemPtr> expired; - { - Lock sync(*this); - if(_waitQueue.empty() && !_destroyed) - { - wait(); - } - - if(_destroyed) - { - break; - } - - // - // Notify expired items. - // - while(!_waitQueue.empty() && !_destroyed) - { - WaitItemPtr item = _waitQueue.front(); - if(item->getExpirationTime() <= IceUtil::Time::now(IceUtil::Time::Monotonic)) - { - expired.push_back(item); - _waitQueue.pop_front(); - } - else if(!expired.empty()) - { - break; - } - else - { - // - // Wait until the next item expire or a notification. Note: in any case we - // get out of this loop to get a chance to execute the work queue. - // - timedWait(item->getExpirationTime() - IceUtil::Time::now(IceUtil::Time::Monotonic)); - } - } - } - - if(!expired.empty()) - { - for(list<WaitItemPtr>::iterator p = expired.begin(); p != expired.end(); ++p) - { - try - { - (*p)->expired(false); - } - catch(const Ice::LocalException&) - { - // - // TODO: Add some tracing. - // - } - } - } - - if(_destroyed) - { - break; - } - } - - if(!_waitQueue.empty()) - { - for(list<WaitItemPtr>::iterator p = _waitQueue.begin(); p != _waitQueue.end(); ++p) - { - (*p)->expired(true); - } - } - _waitQueue.clear(); // Break cyclic reference counts. -} - -void -WaitQueue::destroy() -{ - { - Lock sync(*this); - _destroyed = true; - notify(); - } - - getThreadControl().join(); -} - -void -WaitQueue::add(const WaitItemPtr& item, const IceUtil::Time& wait) -{ - Lock sync(*this); - if(_destroyed) - { - return; - } - - // - // We'll have to notify the thread if it's sleeping for good. - // - bool notifyThread = _waitQueue.empty(); - - IceUtil::Time expire = IceUtil::Time::now(IceUtil::Time::Monotonic) + wait; - item->setExpirationTime(expire); - - list<WaitItemPtr>::iterator p = _waitQueue.begin(); - while(p != _waitQueue.end()) - { - if((*p)->getExpirationTime() >= expire) - { - break; - } - ++p; - } - _waitQueue.insert(p, item); - - if(notifyThread) - { - notify(); - } -} - -bool -WaitQueue::remove(const WaitItemPtr& item) -{ - Lock sync(*this); - list<WaitItemPtr>::iterator p = _waitQueue.begin(); - while(p != _waitQueue.end()) - { - if((*p).get() == item.get()) - { - _waitQueue.erase(p); - return true; - } - ++p; - } - return false; -} diff --git a/cpp/src/IceGrid/WaitQueue.h b/cpp/src/IceGrid/WaitQueue.h deleted file mode 100644 index 84edb2ba79a..00000000000 --- a/cpp/src/IceGrid/WaitQueue.h +++ /dev/null @@ -1,57 +0,0 @@ -// -// Copyright (c) ZeroC, Inc. All rights reserved. -// - -#ifndef ICE_GRID_WAIT_QUEUE_H -#define ICE_GRID_WAIT_QUEUE_H - -#include <IceUtil/Thread.h> -#include <IceUtil/Monitor.h> - -#include <list> - -namespace IceGrid -{ - -class WaitItem : public virtual IceUtil::Shared -{ -public: - - WaitItem(); - virtual ~WaitItem(); - - virtual void expired(bool) = 0; - - const IceUtil::Time& getExpirationTime(); - void setExpirationTime(const IceUtil::Time&); - -private: - - IceUtil::Time _expiration; -}; - -typedef IceUtil::Handle<WaitItem> WaitItemPtr; - -class WaitQueue : public IceUtil::Thread, public IceUtil::Monitor< IceUtil::Mutex> -{ -public: - - WaitQueue(); - - virtual void run(); - void destroy(); - - void add(const WaitItemPtr&, const IceUtil::Time&); - bool remove(const WaitItemPtr&); - -private: - - std::list<WaitItemPtr> _waitQueue; - bool _destroyed; -}; - -typedef IceUtil::Handle<WaitQueue> WaitQueuePtr; - -} - -#endif diff --git a/cpp/src/IceGrid/WellKnownObjectsManager.cpp b/cpp/src/IceGrid/WellKnownObjectsManager.cpp index f4f7227bcd1..c100b67d7f7 100644 --- a/cpp/src/IceGrid/WellKnownObjectsManager.cpp +++ b/cpp/src/IceGrid/WellKnownObjectsManager.cpp @@ -10,23 +10,21 @@ using namespace std; using namespace IceGrid; -WellKnownObjectsManager::WellKnownObjectsManager(const DatabasePtr& database) : +WellKnownObjectsManager::WellKnownObjectsManager(const shared_ptr<Database>& database) : _database(database), _initialized(false) { } void -WellKnownObjectsManager::add(const Ice::ObjectPrx& proxy, const string& type) +WellKnownObjectsManager::add(const std::shared_ptr<Ice::ObjectPrx>& proxy, const string& type) { assert(!_initialized); - ObjectInfo info; - info.type = type; - info.proxy = proxy; - _wellKnownObjects.push_back(info); + ObjectInfo info = { proxy, type }; + _wellKnownObjects.push_back(move(info)); } void -WellKnownObjectsManager::addEndpoint(const string& name, const Ice::ObjectPrx& proxy) +WellKnownObjectsManager::addEndpoint(const string& name, const std::shared_ptr<Ice::ObjectPrx>& proxy) { _endpoints.insert(make_pair(name, proxy)); } @@ -34,12 +32,12 @@ WellKnownObjectsManager::addEndpoint(const string& name, const Ice::ObjectPrx& p void WellKnownObjectsManager::finish() { - Lock sync(*this); + lock_guard lock(_mutex); _initialized = true; } void -WellKnownObjectsManager::registerAll(const ReplicaSessionPrx& session) +WellKnownObjectsManager::registerAll(const shared_ptr<ReplicaSessionPrx>& session) { if(!initialized()) { @@ -93,9 +91,9 @@ WellKnownObjectsManager::updateReplicatedWellKnownObjects() ObjectInfo info; ObjectInfoSeq objects; - Lock sync(*this); + lock_guard lock(_mutex); - Ice::ObjectPrx replicatedClientProxy = _database->getReplicaCache().getEndpoints("Client", _endpoints["Client"]); + auto replicatedClientProxy = _database->getReplicaCache().getEndpoints("Client", _endpoints["Client"]); id.name = "Query"; info.type = Query::ice_staticId(); @@ -118,41 +116,37 @@ WellKnownObjectsManager::updateReplicatedWellKnownObjects() bool WellKnownObjectsManager::initialized() const { - Lock sync(*this); + lock_guard lock(_mutex); return _initialized; } -Ice::ObjectPrx +std::shared_ptr<Ice::ObjectPrx> WellKnownObjectsManager::getEndpoints(const string& name) { - Lock sync(*this); + lock_guard lock(_mutex); return _endpoints[name]; } -LocatorPrx +shared_ptr<LocatorPrx> WellKnownObjectsManager::getLocator() { - Ice::Identity id; - id.name = "Locator"; - id.category = _database->getInstanceName(); - return LocatorPrx::uncheckedCast(getWellKnownObjectReplicatedProxy(id, "Client")); + Ice::Identity id = { "Locator", _database->getInstanceName() }; + return Ice::uncheckedCast<LocatorPrx>(getWellKnownObjectReplicatedProxy(move(id), "Client")); } -Ice::LocatorRegistryPrx +shared_ptr<Ice::LocatorRegistryPrx> WellKnownObjectsManager::getLocatorRegistry() { - Ice::Identity id; - id.name = "LocatorRegistry"; - id.category = _database->getInstanceName(); - return Ice::LocatorRegistryPrx::uncheckedCast(getWellKnownObjectReplicatedProxy(id, "Server")); + Ice::Identity id = { "LocatorRegistry", _database->getInstanceName() }; + return Ice::uncheckedCast<Ice::LocatorRegistryPrx>(getWellKnownObjectReplicatedProxy(move(id), "Server")); } -Ice::ObjectPrx +std::shared_ptr<Ice::ObjectPrx> WellKnownObjectsManager::getWellKnownObjectReplicatedProxy(const Ice::Identity& id, const string& endpt) { try { - Ice::ObjectPrx proxy = _database->getObjectProxy(id); + auto proxy = _database->getObjectProxy(id); Ice::EndpointSeq registryEndpoints = getEndpoints(endpt)->ice_getEndpoints(); // diff --git a/cpp/src/IceGrid/WellKnownObjectsManager.h b/cpp/src/IceGrid/WellKnownObjectsManager.h index 6f921719e7c..1b286c76a83 100644 --- a/cpp/src/IceGrid/WellKnownObjectsManager.h +++ b/cpp/src/IceGrid/WellKnownObjectsManager.h @@ -12,40 +12,40 @@ namespace IceGrid { class Database; -typedef IceUtil::Handle<Database> DatabasePtr; -class WellKnownObjectsManager : public IceUtil::Mutex, public IceUtil::Shared +class WellKnownObjectsManager { public: - WellKnownObjectsManager(const DatabasePtr&); + WellKnownObjectsManager(const std::shared_ptr<Database>&); - void add(const Ice::ObjectPrx&, const std::string&); - void addEndpoint(const std::string&, const Ice::ObjectPrx&); + void add(const std::shared_ptr<Ice::ObjectPrx>&, const std::string&); + void addEndpoint(const std::string&, const std::shared_ptr<Ice::ObjectPrx>&); void finish(); void registerAll(); - void registerAll(const ReplicaSessionPrx&); + void registerAll(const std::shared_ptr<ReplicaSessionPrx>&); void updateReplicatedWellKnownObjects(); - Ice::ObjectPrx getEndpoints(const std::string&); + std::shared_ptr<Ice::ObjectPrx> getEndpoints(const std::string&); - LocatorPrx getLocator(); - Ice::LocatorRegistryPrx getLocatorRegistry(); + std::shared_ptr<LocatorPrx> getLocator(); + std::shared_ptr<Ice::LocatorRegistryPrx> getLocatorRegistry(); private: bool initialized() const; - Ice::ObjectPrx getWellKnownObjectReplicatedProxy(const Ice::Identity&, const std::string&); + std::shared_ptr<Ice::ObjectPrx> getWellKnownObjectReplicatedProxy(const Ice::Identity&, const std::string&); - const DatabasePtr _database; + const std::shared_ptr<Database> _database; bool _initialized; StringObjectProxyDict _endpoints; ObjectInfoSeq _wellKnownObjects; + + mutable std::mutex _mutex; }; -typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr; }; diff --git a/cpp/src/IceStorm/Admin.cpp b/cpp/src/IceStorm/Admin.cpp index 8307b04eb6a..63a54d1ac9d 100644 --- a/cpp/src/IceStorm/Admin.cpp +++ b/cpp/src/IceStorm/Admin.cpp @@ -15,15 +15,7 @@ using namespace std; using namespace IceInternal; -int run(const Ice::StringSeq&); - -Ice::CommunicatorPtr communicator; - -void -destroyCommunicator(int) -{ - communicator->destroy(); -} +int run(const shared_ptr<Ice::Communicator>&, const Ice::StringSeq&); int #ifdef _WIN32 @@ -41,18 +33,19 @@ main(int argc, char* argv[]) try { - Ice::CtrlCHandler ctrlCHandler; + IceUtil::CtrlCHandler ctrlCHandler; Ice::InitializationData id; Ice::StringSeq args = Ice::argsToStringSeq(argc, argv); id.properties = Ice::createProperties(args); id.properties->setProperty("Ice.Warn.Endpoints", "0"); + Ice::CommunicatorHolder ich(id); - communicator = ich.communicator(); + auto communicator = ich.communicator(); - ctrlCHandler.setCallback(&destroyCommunicator); + ctrlCHandler.setCallback([communicator](int) { communicator->destroy(); }); - status = run(args); + status = run(communicator, args); } catch(const std::exception& ex) { @@ -77,7 +70,7 @@ usage(const string& name) } int -run(const Ice::StringSeq& args) +run(const shared_ptr<Ice::Communicator>& communicator, const Ice::StringSeq& args) { string commands; bool debug; @@ -125,29 +118,28 @@ run(const Ice::StringSeq& args) debug = opts.isSet("debug"); // The complete set of Ice::Identity -> manager proxies. - map<Ice::Identity, IceStorm::TopicManagerPrx> managers; - Ice::PropertiesPtr properties = communicator->getProperties(); - IceStorm::TopicManagerPrx defaultManager; + map<Ice::Identity, shared_ptr<IceStorm::TopicManagerPrx>> managers; + auto properties = communicator->getProperties(); + shared_ptr<IceStorm::TopicManagerPrx> defaultManager; - Ice::PropertyDict props = communicator->getProperties()->getPropertiesForPrefix("IceStormAdmin.TopicManager."); + auto props = communicator->getProperties()->getPropertiesForPrefix("IceStormAdmin.TopicManager."); { - for(Ice::PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) + for(const auto& p : props) { // // Ignore proxy property settings. eg IceStormAdmin.TopicManager.*.LocatorCacheTimeout // - if(p->first.find('.', strlen("IceStormAdmin.TopicManager.")) == string::npos) + if(p.first.find('.', strlen("IceStormAdmin.TopicManager.")) == string::npos) { try { - IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::uncheckedCast( - communicator->propertyToProxy(p->first)); - managers.insert(map<Ice::Identity, IceStorm::TopicManagerPrx>::value_type( - manager->ice_getIdentity(), manager)); + auto manager = Ice::uncheckedCast<IceStorm::TopicManagerPrx>( + communicator->propertyToProxy(p.first)); + managers.insert({manager->ice_getIdentity(), manager}); } catch(const Ice::ProxyParseException&) { - consoleErr << args[0] << ": malformed proxy: " << p->second << endl; + consoleErr << args[0] << ": malformed proxy: " << p.second << endl; return 1; } } @@ -156,8 +148,7 @@ run(const Ice::StringSeq& args) string managerProxy = properties->getProperty("IceStormAdmin.TopicManager.Default"); if(!managerProxy.empty()) { - defaultManager = IceStorm::TopicManagerPrx::uncheckedCast( - communicator->stringToProxy(managerProxy)); + defaultManager = Ice::uncheckedCast<IceStorm::TopicManagerPrx>(communicator->stringToProxy(managerProxy)); } else if(!managers.empty()) { @@ -175,7 +166,7 @@ run(const Ice::StringSeq& args) os << "IceStorm/Finder"; os << ":tcp" << (host.empty() ? "" : (" -h \"" + host + "\"")) << " -p " << port << " -t " << timeout; os << ":ssl" << (host.empty() ? "" : (" -h \"" + host + "\"")) << " -p " << port << " -t " << timeout; - IceStorm::FinderPrx finder = IceStorm::FinderPrx::uncheckedCast(communicator->stringToProxy(os.str())); + auto finder = Ice::uncheckedCast<IceStorm::FinderPrx>(communicator->stringToProxy(os.str())); try { defaultManager = finder->getTopicManager(); @@ -192,12 +183,12 @@ run(const Ice::StringSeq& args) return 1; } - IceStorm::ParserPtr p = IceStorm::Parser::createParser(communicator, defaultManager, managers); + IceStorm::Parser p(communicator, defaultManager, managers); int status = 0; if(!commands.empty()) // Commands were given { - int parseStatus = p->parse(commands, debug); + int parseStatus = p.parse(commands, debug); if(parseStatus == 1) { status = 1; @@ -205,9 +196,9 @@ run(const Ice::StringSeq& args) } else // No commands, let's use standard input { - p->showBanner(); + p.showBanner(); - int parseStatus = p->parse(stdin, debug); + int parseStatus = p.parse(stdin, debug); if(parseStatus == 1) { status = 1; diff --git a/cpp/src/IceStorm/Grammar.cpp b/cpp/src/IceStorm/Grammar.cpp index 0673c7b9e2d..88fc2e3a0d3 100644 --- a/cpp/src/IceStorm/Grammar.cpp +++ b/cpp/src/IceStorm/Grammar.cpp @@ -58,14 +58,10 @@ /* Pull parsers. */ #define YYPULL 1 - - - /* Copy the first part of user declarations. */ /* Line 371 of yacc.c */ #line 1 "src/IceStorm/Grammar.y" - // // Copyright (c) ZeroC, Inc. All rights reserved. // @@ -109,7 +105,6 @@ yyerror(const char* s) parser->error(s); } - /* Line 371 of yacc.c */ #line 112 "src/IceStorm/Grammar.cpp" @@ -162,7 +157,6 @@ extern int yydebug; }; #endif - #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef int YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 @@ -170,7 +164,6 @@ typedef int YYSTYPE; # define YYSTYPE_IS_DECLARED 1 #endif - #ifdef YYPARSE_PARAM #if defined __STDC__ || defined __cplusplus int yyparse (void *YYPARSE_PARAM); @@ -346,7 +339,6 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - #if (! defined yyoverflow \ && (! defined __cplusplus \ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) @@ -628,7 +620,6 @@ static const yytype_uint8 yystos[] = #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab - /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. However, @@ -667,13 +658,11 @@ while (YYID (0)) #define YYTERROR 1 #define YYERRCODE 256 - /* This macro is provided for backward compatibility. */ #ifndef YY_LOCATION_PRINT # define YY_LOCATION_PRINT(File, Loc) ((void) 0) #endif - /* YYLEX -- calling `yylex' with the right arguments. */ #ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, YYLEX_PARAM) @@ -706,7 +695,6 @@ do { \ } \ } while (YYID (0)) - /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ @@ -741,7 +729,6 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep) } } - /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ @@ -798,7 +785,6 @@ do { \ yy_stack_print ((Bottom), (Top)); \ } while (YYID (0)) - /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ @@ -846,7 +832,6 @@ int yydebug; # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ - /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 @@ -863,7 +848,6 @@ int yydebug; # define YYMAXDEPTH 10000 #endif - #if YYERROR_VERBOSE # ifndef yystrlen @@ -1136,9 +1120,6 @@ yydestruct (yymsg, yytype, yyvaluep) } } - - - /*----------. | yyparse. | `----------*/ @@ -1168,7 +1149,6 @@ yyparse () /* The lookahead symbol. */ int yychar; - #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ @@ -1397,7 +1377,6 @@ yybackup: goto yynewstate; - /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ @@ -1407,7 +1386,6 @@ yydefault: goto yyerrlab; goto yyreduce; - /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ @@ -1425,7 +1403,6 @@ yyreduce: GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; - YY_REDUCE_PRINT (yyn); switch (yyn) { @@ -1657,7 +1634,6 @@ yyreduce: } break; - /* Line 1792 of yacc.c */ #line 1660 "src/IceStorm/Grammar.cpp" default: break; @@ -1695,7 +1671,6 @@ yyreduce: goto yynewstate; - /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ @@ -1744,8 +1719,6 @@ yyerrlab: #endif } - - if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an @@ -1769,7 +1742,6 @@ yyerrlab: token. */ goto yyerrlab1; - /*---------------------------------------------------. | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ @@ -1789,7 +1761,6 @@ yyerrorlab: yystate = *yyssp; goto yyerrlab1; - /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ @@ -1814,7 +1785,6 @@ yyerrlab1: if (yyssp == yyss) YYABORT; - yydestruct ("Error: popping", yystos[yystate], yyvsp); YYPOPSTACK (1); @@ -1826,14 +1796,12 @@ yyerrlab1: *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END - /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; - /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ @@ -1889,7 +1857,5 @@ yyreturn: return YYID (yyresult); } - /* Line 2055 of yacc.c */ #line 199 "src/IceStorm/Grammar.y" - diff --git a/cpp/src/IceStorm/Grammar.h b/cpp/src/IceStorm/Grammar.h index 0fa1457e828..55a216cf87c 100644 --- a/cpp/src/IceStorm/Grammar.h +++ b/cpp/src/IceStorm/Grammar.h @@ -61,7 +61,6 @@ extern int yydebug; }; #endif - #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef int YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 @@ -69,7 +68,6 @@ typedef int YYSTYPE; # define YYSTYPE_IS_DECLARED 1 #endif - #ifdef YYPARSE_PARAM #if defined __STDC__ || defined __cplusplus int yyparse (void *YYPARSE_PARAM); diff --git a/cpp/src/IceStorm/IceStormDB.cpp b/cpp/src/IceStorm/IceStormDB.cpp index ccd7d0e3d7f..55a1d488856 100644 --- a/cpp/src/IceStorm/IceStormDB.cpp +++ b/cpp/src/IceStorm/IceStormDB.cpp @@ -9,20 +9,14 @@ #include <Ice/ConsoleUtil.h> #include <IceDB/IceDB.h> #include <IceStorm/DBTypes.h> + #include <fstream> +#include <iterator> using namespace std; using namespace IceInternal; -int run(const Ice::StringSeq&); - -Ice::CommunicatorPtr communicator; - -void -destroyCommunicator(int) -{ - communicator->destroy(); -} +int run(const shared_ptr<Ice::Communicator>&, const Ice::StringSeq&); int #ifdef _WIN32 @@ -35,13 +29,8 @@ main(int argc, char* argv[]) try { - Ice::CtrlCHandler ctrlCHandler; Ice::CommunicatorHolder ich(argc, argv); - communicator = ich.communicator(); - - ctrlCHandler.setCallback(&destroyCommunicator); - - status = run(Ice::argsToStringSeq(argc, argv)); + status = run(ich.communicator(), Ice::argsToStringSeq(argc, argv)); } catch(const std::exception& ex) { @@ -70,7 +59,7 @@ usage(const string& name) } int -run(const Ice::StringSeq& args) +run(const shared_ptr<Ice::Communicator>& communicator, const Ice::StringSeq& args) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); @@ -144,10 +133,7 @@ run(const Ice::StringSeq& args) { IceStorm::AllData data; - IceDB::IceContext dbContext; - dbContext.communicator = communicator; - dbContext.encoding.major = 1; - dbContext.encoding.minor = 1; + IceDB::IceContext dbContext = { communicator, {1, 1} }; if(import) { @@ -234,14 +220,14 @@ run(const Ice::StringSeq& args) IceDB::Dbi<IceStorm::SubscriberRecordKey, IceStorm::SubscriberRecord, IceDB::IceContext, Ice::OutputStream> subscriberMap(txn, "subscribers", dbContext, MDB_CREATE); - for(IceStorm::SubscriberRecordDict::const_iterator q = data.subscribers.begin(); q != data.subscribers.end(); ++q) + for(const auto& subscriber : data.subscribers) { if(debug) { - consoleOut << " KEY = TOPIC(" << communicator->identityToString(q->first.topic) - << ") ID(" << communicator->identityToString(q->first.id) << ")" << endl; + consoleOut << " KEY = TOPIC(" << communicator->identityToString(subscriber.first.topic) + << ") ID(" << communicator->identityToString(subscriber.first.id) << ")" << endl; } - subscriberMap.put(txn, q->first, q->second); + subscriberMap.put(txn, subscriber.first, subscriber.second); } txn.commit(); diff --git a/cpp/src/IceStorm/IceStormInternal.ice b/cpp/src/IceStorm/IceStormInternal.ice index 302446d7070..e5d5031b93b 100644 --- a/cpp/src/IceStorm/IceStormInternal.ice +++ b/cpp/src/IceStorm/IceStormInternal.ice @@ -22,7 +22,7 @@ module IceStorm * The event data. * **/ -["cpp:class"] struct EventData +struct EventData { /** The operation name. */ string op; @@ -39,7 +39,7 @@ local exception SendQueueSizeMaxReached } /** A sequence of EventData. */ -["cpp:type:std::deque< ::IceStorm::EventDataPtr>"] sequence<EventData> EventDataSeq; +["cpp:type:std::deque<IceStorm::EventData>"] sequence<EventData> EventDataSeq; /** * diff --git a/cpp/src/IceStorm/Instance.cpp b/cpp/src/IceStorm/Instance.cpp index ad22c9151ad..f1b5e764fb0 100644 --- a/cpp/src/IceStorm/Instance.cpp +++ b/cpp/src/IceStorm/Instance.cpp @@ -27,109 +27,64 @@ extern IceDB::IceContext dbContext; void TopicReaper::add(const string& name) { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); _topics.push_back(name); } vector<string> TopicReaper::consumeReapedTopics() { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); vector<string> reaped; reaped.swap(_topics); return reaped; } -PersistentInstance::PersistentInstance( - const string& instanceName, - const string& name, - const Ice::CommunicatorPtr& communicator, - const Ice::ObjectAdapterPtr& publishAdapter, - const Ice::ObjectAdapterPtr& topicAdapter, - const Ice::ObjectAdapterPtr& nodeAdapter, - const NodePrx& nodeProxy) : - Instance(instanceName, name, communicator, publishAdapter, topicAdapter, nodeAdapter, nodeProxy), - _dbLock(communicator->getProperties()->getPropertyWithDefault(name + ".LMDB.Path", name) + "/icedb.lock"), - _dbEnv(communicator->getProperties()->getPropertyWithDefault(name + ".LMDB.Path", name), 2, - IceDB::getMapSize(communicator->getProperties()->getPropertyAsInt(name + ".LMDB.MapSize"))) -{ - try - { - dbContext.communicator = communicator; - dbContext.encoding.minor = 1; - dbContext.encoding.major = 1; - - IceDB::ReadWriteTxn txn(_dbEnv); - - _lluMap = LLUMap(txn, "llu", dbContext, MDB_CREATE); - _subscriberMap = SubscriberMap(txn, "subscribers", dbContext, MDB_CREATE, compareSubscriberRecordKey); - - txn.commit(); - } - catch(...) - { - shutdown(); - destroy(); - - throw; - } -} - -void -PersistentInstance::destroy() -{ - _dbEnv.close(); - dbContext.communicator = 0; - - Instance::destroy(); -} - -Instance::Instance( - const string& instanceName, - const string& name, - const Ice::CommunicatorPtr& communicator, - const Ice::ObjectAdapterPtr& publishAdapter, - const Ice::ObjectAdapterPtr& topicAdapter, - const Ice::ObjectAdapterPtr& nodeAdapter, - const NodePrx& nodeProxy) : +Instance::Instance(const string& instanceName, + const string& name, + shared_ptr<Ice::Communicator> communicator, + shared_ptr<Ice::ObjectAdapter> publishAdapter, + shared_ptr<Ice::ObjectAdapter> topicAdapter, + shared_ptr<Ice::ObjectAdapter> nodeAdapter, + shared_ptr<NodePrx> nodeProxy) : _instanceName(instanceName), _serviceName(name), - _communicator(communicator), - _publishAdapter(publishAdapter), - _topicAdapter(topicAdapter), - _nodeAdapter(nodeAdapter), - _nodeProxy(nodeProxy), - _traceLevels(new TraceLevels(name, communicator->getProperties(), communicator->getLogger())), - _discardInterval(IceUtil::Time::seconds(communicator->getProperties()->getPropertyAsIntWithDefault( - name + ".Discard.Interval", 60))), // default one minute. - _flushInterval(IceUtil::Time::milliSeconds(communicator->getProperties()->getPropertyAsIntWithDefault( - name + ".Flush.Timeout", 1000))), // default one second. + _communicator(move(communicator)), + _publishAdapter(move(publishAdapter)), + _topicAdapter(move(topicAdapter)), + _nodeAdapter(move(nodeAdapter)), + _nodeProxy(move(nodeProxy)), + _traceLevels(make_shared<TraceLevels>(name, _communicator->getProperties(), _communicator->getLogger())), + // default one minute. + _discardInterval(_communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Discard.Interval", 60)), + // default one second. + _flushInterval(_communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Flush.Timeout", 1000)), // default one minute. - _sendTimeout(communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Send.Timeout", 60 * 1000)), - _sendQueueSizeMax(communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Send.QueueSizeMax", -1)), + _sendTimeout(_communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Send.Timeout", 60 * 1000)), + _sendQueueSizeMax(_communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Send.QueueSizeMax", -1)), _sendQueueSizeMaxPolicy(RemoveSubscriber), - _topicReaper(new TopicReaper()) + _topicReaper(make_shared<TopicReaper>()), + _observers(make_shared<Observers>(_traceLevels)) { try { - __setNoDelete(true); - - Ice::PropertiesPtr properties = communicator->getProperties(); + auto properties = _communicator->getProperties(); if(properties->getProperty(name + ".TopicManager.AdapterId").empty()) { string p = properties->getProperty(name + ".ReplicatedTopicManagerEndpoints"); if(!p.empty()) { - const_cast<Ice::ObjectPrx&>(_topicReplicaProxy) = communicator->stringToProxy("dummy:" + p); + const_cast<shared_ptr<Ice::ObjectPrx>&>(_topicReplicaProxy) = + _communicator->stringToProxy("dummy:" + p); } p = properties->getProperty(name + ".ReplicatedPublishEndpoints"); if(!p.empty()) { - const_cast<Ice::ObjectPrx&>(_publisherReplicaProxy) = communicator->stringToProxy("dummy:" + p); + const_cast<shared_ptr<Ice::ObjectPrx>&>(_publisherReplicaProxy) = + _communicator->stringToProxy("dummy:" + p); } } - _observers = new Observers(this); - _batchFlusher = new IceUtil::Timer(); + _timer = new IceUtil::Timer(); string policy = properties->getProperty(name + ".Send.QueueSizeMaxPolicy"); @@ -151,28 +106,28 @@ Instance::Instance( // If an Ice metrics observer is setup on the communicator, also // enable metrics for IceStorm. // - IceInternal::CommunicatorObserverIPtr o = - IceInternal::CommunicatorObserverIPtr::dynamicCast(communicator->getObserver()); + auto o = dynamic_pointer_cast<IceInternal::CommunicatorObserverI>(_communicator->getObserver()); if(o) { - _observer = new TopicManagerObserverI(o->getFacet()); + _observer = make_shared<TopicManagerObserverI>(o->getFacet()); } } - catch(...) + catch(const std::exception&) { shutdown(); destroy(); - __setNoDelete(false); - throw; } - __setNoDelete(false); +} + +Instance::~Instance() +{ } void -Instance::setNode(const NodeIPtr& node) +Instance::setNode(shared_ptr<NodeI> node) { - _node = node; + _node = move(node); } string @@ -187,109 +142,103 @@ Instance::serviceName() const return _serviceName; } -Ice::CommunicatorPtr +shared_ptr<Ice::Communicator> Instance::communicator() const { return _communicator; } -Ice::PropertiesPtr +shared_ptr<Ice::Properties> Instance::properties() const { return _communicator->getProperties(); } -Ice::ObjectAdapterPtr +shared_ptr<Ice::ObjectAdapter> Instance::publishAdapter() const { return _publishAdapter; } -Ice::ObjectAdapterPtr +shared_ptr<Ice::ObjectAdapter> Instance::topicAdapter() const { return _topicAdapter; } -Ice::ObjectAdapterPtr +shared_ptr<Ice::ObjectAdapter> Instance::nodeAdapter() const { return _nodeAdapter; } -ObserversPtr +shared_ptr<Observers> Instance::observers() const { return _observers; } -NodeIPtr +shared_ptr<NodeI> Instance::node() const { return _node; } -NodePrx +shared_ptr<NodePrx> Instance::nodeProxy() const { return _nodeProxy; } -TraceLevelsPtr +shared_ptr<TraceLevels> Instance::traceLevels() const { return _traceLevels; } IceUtil::TimerPtr -Instance::batchFlusher() const -{ - return _batchFlusher; -} - -IceUtil::TimerPtr Instance::timer() const { return _timer; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> Instance::topicReplicaProxy() const { return _topicReplicaProxy; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> Instance::publisherReplicaProxy() const { return _publisherReplicaProxy; } -IceStorm::Instrumentation::TopicManagerObserverPtr +shared_ptr<IceStorm::Instrumentation::TopicManagerObserver> Instance::observer() const { return _observer; } -IceStorm::TopicReaperPtr +shared_ptr<IceStorm::TopicReaper> Instance::topicReaper() const { return _topicReaper; } -IceUtil::Time +chrono::seconds Instance::discardInterval() const { return _discardInterval; } -IceUtil::Time +chrono::milliseconds Instance::flushInterval() const { return _flushInterval; } -int +chrono::milliseconds Instance::sendTimeout() const { return _sendTimeout; @@ -329,19 +278,58 @@ Instance::shutdown() void Instance::destroy() { - if(_batchFlusher) - { - _batchFlusher->destroy(); - } - // The node instance must be cleared as the node holds the // replica (TopicManager) which holds the instance causing a // cyclic reference. - _node = 0; + _node = nullptr; // // The observer instance must be cleared as it holds the - // TopicManagerImpl which hodlds the instance causing a + // TopicManagerImpl which holds the instance causing a // cyclic reference. // - _observer = 0; + _observer = nullptr; +} + +PersistentInstance::PersistentInstance(const string& instanceName, + const string& name, + shared_ptr<Ice::Communicator> communicator, + shared_ptr<Ice::ObjectAdapter> publishAdapter, + shared_ptr<Ice::ObjectAdapter> topicAdapter, + shared_ptr<Ice::ObjectAdapter> nodeAdapter, + shared_ptr<NodePrx> nodeProxy) : + Instance(instanceName, name, communicator, move(publishAdapter), move(topicAdapter), move(nodeAdapter), + move(nodeProxy)), + _dbLock(communicator->getProperties()->getPropertyWithDefault(name + ".LMDB.Path", name) + "/icedb.lock"), + _dbEnv(communicator->getProperties()->getPropertyWithDefault(name + ".LMDB.Path", name), 2, + IceDB::getMapSize(communicator->getProperties()->getPropertyAsInt(name + ".LMDB.MapSize"))) +{ + try + { + dbContext.communicator = move(communicator); + dbContext.encoding.minor = 1; + dbContext.encoding.major = 1; + + IceDB::ReadWriteTxn txn(_dbEnv); + + _lluMap = LLUMap(txn, "llu", dbContext, MDB_CREATE); + _subscriberMap = SubscriberMap(txn, "subscribers", dbContext, MDB_CREATE, compareSubscriberRecordKey); + + txn.commit(); + } + catch(const std::exception&) + { + shutdown(); + destroy(); + + throw; + } +} + +void +PersistentInstance::destroy() +{ + _dbEnv.close(); + dbContext.communicator = nullptr; + + Instance::destroy(); } diff --git a/cpp/src/IceStorm/Instance.h b/cpp/src/IceStorm/Instance.h index 897ea2eaa55..5f1e1fe1739 100644 --- a/cpp/src/IceStorm/Instance.h +++ b/cpp/src/IceStorm/Instance.h @@ -8,27 +8,15 @@ #include <Ice/CommunicatorF.h> #include <Ice/ObjectAdapterF.h> #include <Ice/PropertiesF.h> -#include <IceUtil/Time.h> #include <IceStorm/Election.h> #include <IceStorm/Instrumentation.h> #include <IceStorm/Util.h> -namespace IceUtil -{ - -class Timer; -typedef IceUtil::Handle<Timer> TimerPtr; - -} - namespace IceStormElection { class Observers; -typedef IceUtil::Handle<Observers> ObserversPtr; - class NodeI; -typedef IceUtil::Handle<NodeI> NodeIPtr; } @@ -36,9 +24,8 @@ namespace IceStorm { class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; -class TopicReaper : public IceUtil::Shared, private IceUtil::Mutex +class TopicReaper { public: @@ -48,10 +35,11 @@ public: private: std::vector<std::string> _topics; + + std::mutex _mutex; }; -typedef IceUtil::Handle<TopicReaper> TopicReaperPtr; -class Instance : public IceUtil::Shared +class Instance { public: @@ -61,32 +49,35 @@ public: DropEvents }; - Instance(const std::string&, const std::string&, const Ice::CommunicatorPtr&, const Ice::ObjectAdapterPtr&, - const Ice::ObjectAdapterPtr&, const Ice::ObjectAdapterPtr& = 0, const IceStormElection::NodePrx& = 0); + Instance(const std::string&, const std::string&, std::shared_ptr<Ice::Communicator>, + std::shared_ptr<Ice::ObjectAdapter>, std::shared_ptr<Ice::ObjectAdapter>, + std::shared_ptr<Ice::ObjectAdapter> = nullptr, + std::shared_ptr<IceStormElection::NodePrx> = nullptr); + + virtual ~Instance(); - void setNode(const IceStormElection::NodeIPtr&); + void setNode(std::shared_ptr<IceStormElection::NodeI>); std::string instanceName() const; std::string serviceName() const; - Ice::CommunicatorPtr communicator() const; - Ice::PropertiesPtr properties() const; - Ice::ObjectAdapterPtr publishAdapter() const; - Ice::ObjectAdapterPtr topicAdapter() const; - Ice::ObjectAdapterPtr nodeAdapter() const; - IceStormElection::ObserversPtr observers() const; - IceStormElection::NodeIPtr node() const; - IceStormElection::NodePrx nodeProxy() const; - TraceLevelsPtr traceLevels() const; - IceUtil::TimerPtr batchFlusher() const; + std::shared_ptr<Ice::Communicator> communicator() const; + std::shared_ptr<Ice::Properties> properties() const; + std::shared_ptr<Ice::ObjectAdapter> publishAdapter() const; + std::shared_ptr<Ice::ObjectAdapter> topicAdapter() const; + std::shared_ptr<Ice::ObjectAdapter> nodeAdapter() const; + std::shared_ptr<IceStormElection::Observers> observers() const; + std::shared_ptr<IceStormElection::NodeI> node() const; + std::shared_ptr<IceStormElection::NodePrx> nodeProxy() const; + std::shared_ptr<TraceLevels> traceLevels() const; IceUtil::TimerPtr timer() const; - Ice::ObjectPrx topicReplicaProxy() const; - Ice::ObjectPrx publisherReplicaProxy() const; - IceStorm::Instrumentation::TopicManagerObserverPtr observer() const; - TopicReaperPtr topicReaper() const; - - IceUtil::Time discardInterval() const; - IceUtil::Time flushInterval() const; - int sendTimeout() const; + std::shared_ptr<Ice::ObjectPrx> topicReplicaProxy() const; + std::shared_ptr<Ice::ObjectPrx> publisherReplicaProxy() const; + std::shared_ptr<IceStorm::Instrumentation::TopicManagerObserver> observer() const; + std::shared_ptr<TopicReaper> topicReaper() const; + + std::chrono::seconds discardInterval() const; + std::chrono::milliseconds flushInterval() const; + std::chrono::milliseconds sendTimeout() const; int sendQueueSizeMax() const; SendQueueSizeMaxPolicy sendQueueSizeMaxPolicy() const; @@ -97,45 +88,45 @@ private: const std::string _instanceName; const std::string _serviceName; - const Ice::CommunicatorPtr _communicator; - const Ice::ObjectAdapterPtr _publishAdapter; - const Ice::ObjectAdapterPtr _topicAdapter; - const Ice::ObjectAdapterPtr _nodeAdapter; - const IceStormElection::NodePrx _nodeProxy; - const TraceLevelsPtr _traceLevels; - const IceUtil::Time _discardInterval; - const IceUtil::Time _flushInterval; - const int _sendTimeout; + const std::shared_ptr<Ice::Communicator> _communicator; + const std::shared_ptr<Ice::ObjectAdapter> _publishAdapter; + const std::shared_ptr<Ice::ObjectAdapter> _topicAdapter; + const std::shared_ptr<Ice::ObjectAdapter> _nodeAdapter; + const std::shared_ptr<IceStormElection::NodePrx> _nodeProxy; + const std::shared_ptr<TraceLevels> _traceLevels; + const std::chrono::seconds _discardInterval; + const std::chrono::milliseconds _flushInterval; + const std::chrono::milliseconds _sendTimeout; const int _sendQueueSizeMax; const SendQueueSizeMaxPolicy _sendQueueSizeMaxPolicy; - const Ice::ObjectPrx _topicReplicaProxy; - const Ice::ObjectPrx _publisherReplicaProxy; - const TopicReaperPtr _topicReaper; - IceStormElection::NodeIPtr _node; - IceStormElection::ObserversPtr _observers; - IceUtil::TimerPtr _batchFlusher; + const std::shared_ptr<Ice::ObjectPrx> _topicReplicaProxy; + const std::shared_ptr<Ice::ObjectPrx> _publisherReplicaProxy; + const std::shared_ptr<TopicReaper> _topicReaper; + std::shared_ptr<IceStormElection::NodeI> _node; + std::shared_ptr<IceStormElection::Observers> _observers; IceUtil::TimerPtr _timer; - IceStorm::Instrumentation::TopicManagerObserverPtr _observer; - + std::shared_ptr<IceStorm::Instrumentation::TopicManagerObserver> _observer; }; -typedef IceUtil::Handle<Instance> InstancePtr; -typedef IceDB::ReadWriteCursor<SubscriberRecordKey, SubscriberRecord, IceDB::IceContext, Ice::OutputStream> - SubscriberMapRWCursor; +using SubscriberMapRWCursor = IceDB::ReadWriteCursor<SubscriberRecordKey, + SubscriberRecord, + IceDB::IceContext, + Ice::OutputStream>; -class PersistentInstance : public Instance +class PersistentInstance final : public Instance { public: - PersistentInstance(const std::string&, const std::string&, const Ice::CommunicatorPtr&, - const Ice::ObjectAdapterPtr&, const Ice::ObjectAdapterPtr&, const Ice::ObjectAdapterPtr& = 0, - const IceStormElection::NodePrx& = 0); + PersistentInstance(const std::string&, const std::string&, std::shared_ptr<Ice::Communicator>, + std::shared_ptr<Ice::ObjectAdapter>, std::shared_ptr<Ice::ObjectAdapter>, + std::shared_ptr<Ice::ObjectAdapter> = nullptr, + std::shared_ptr<IceStormElection::NodePrx> = nullptr); const IceDB::Env& dbEnv() const { return _dbEnv; } LLUMap lluMap() const { return _lluMap; } SubscriberMap subscriberMap() const { return _subscriberMap; } - virtual void destroy(); + void destroy() override; private: @@ -144,7 +135,6 @@ private: LLUMap _lluMap; SubscriberMap _subscriberMap; }; -typedef IceUtil::Handle<PersistentInstance> PersistentInstancePtr; } // End namespace IceStorm diff --git a/cpp/src/IceStorm/InstrumentationI.cpp b/cpp/src/IceStorm/InstrumentationI.cpp index 5675c261122..ca4330917a0 100644 --- a/cpp/src/IceStorm/InstrumentationI.cpp +++ b/cpp/src/IceStorm/InstrumentationI.cpp @@ -77,8 +77,8 @@ public: add("service", &SubscriberHelper::getService); add("identity", &SubscriberHelper::getIdentity); - add("facet", &SubscriberHelper::getProxy, &IceProxy::Ice::Object::ice_getFacet); - add("encoding", &SubscriberHelper::getProxy, &IceProxy::Ice::Object::ice_getEncodingVersion); + add("facet", &SubscriberHelper::getProxy, &Ice::ObjectPrx::ice_getFacet); + add("encoding", &SubscriberHelper::getProxy, &Ice::ObjectPrx::ice_getEncodingVersion); add("mode", &SubscriberHelper::getMode); add("proxy", &SubscriberHelper::getProxy); add("link", &SubscriberHelper::_link); @@ -89,13 +89,13 @@ public: }; static Attributes attributes; - SubscriberHelper(const string& svc, const string& topic, const ::Ice::ObjectPrx& proxy, const IceStorm::QoS& qos, - const IceStorm::TopicPrx& link, SubscriberState state) : - _service(svc), _topic(topic), _proxy(proxy), _qos(qos), _link(link), _state(state) + SubscriberHelper(const string& svc, const string& topic, const shared_ptr<Ice::ObjectPrx>& proxy, + const IceStorm::QoS& qos, shared_ptr<IceStorm::TopicPrx> link, SubscriberState state) : + _service(svc), _topic(topic), _proxy(proxy), _qos(qos), _link(move(link)), _state(state) { } - virtual string operator()(const string& attribute) const + string operator()(const string& attribute) const override { return attributes(this, attribute); } @@ -175,7 +175,7 @@ public: return _id; } - const ::Ice::ObjectPrx& + const shared_ptr<Ice::ObjectPrx>& getProxy() const { return _proxy; @@ -186,11 +186,11 @@ public: { switch(_state) { - case SubscriberStateOnline: + case SubscriberState::SubscriberStateOnline: return "online"; - case SubscriberStateOffline: + case SubscriberState::SubscriberStateOffline: return "offline"; - case SubscriberStateError: + case SubscriberState::SubscriberStateError: return "error"; default: assert(false); @@ -208,9 +208,9 @@ private: const string& _service; const string& _topic; - const ::Ice::ObjectPrx& _proxy; + const shared_ptr<Ice::ObjectPrx>& _proxy; const IceStorm::QoS& _qos; - const IceStorm::TopicPrx _link; + const shared_ptr<IceStorm::TopicPrx> _link; const SubscriberState _state; mutable string _id; }; @@ -240,7 +240,7 @@ struct QueuedUpdate { } - void operator()(const SubscriberMetricsPtr& v) + void operator()(const shared_ptr<SubscriberMetrics>& v) { v->queued += count; } @@ -264,7 +264,7 @@ struct OutstandingUpdate { } - void operator()(const SubscriberMetricsPtr& v) + void operator()(const shared_ptr<SubscriberMetrics>& v) { if(v->queued > 0) { @@ -293,7 +293,7 @@ struct DeliveredUpdate { } - void operator()(const SubscriberMetricsPtr& v) + void operator()(const shared_ptr<SubscriberMetrics>& v) { if(v->outstanding > 0) { @@ -313,7 +313,7 @@ SubscriberObserverI::delivered(int count) forEach(DeliveredUpdate(count)); } -TopicManagerObserverI::TopicManagerObserverI(const IceInternal::MetricsAdminIPtr& metrics) : +TopicManagerObserverI::TopicManagerObserverI(const shared_ptr<IceInternal::MetricsAdminI>& metrics) : _metrics(metrics), _topics(metrics, "Topic"), _subscribers(metrics, "Subscriber") @@ -321,14 +321,14 @@ TopicManagerObserverI::TopicManagerObserverI(const IceInternal::MetricsAdminIPtr } void -TopicManagerObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater) +TopicManagerObserverI::setObserverUpdater(const shared_ptr<ObserverUpdater>& updater) { _topics.setUpdater(newUpdater(updater, &ObserverUpdater::updateTopicObservers)); _subscribers.setUpdater(newUpdater(updater, &ObserverUpdater::updateSubscriberObservers)); } -TopicObserverPtr -TopicManagerObserverI::getTopicObserver(const string& service, const string& topic, const TopicObserverPtr& old) +shared_ptr<TopicObserver> +TopicManagerObserverI::getTopicObserver(const string& service, const string& topic, const shared_ptr<TopicObserver>& old) { if(_topics.isEnabled()) { @@ -338,21 +338,21 @@ TopicManagerObserverI::getTopicObserver(const string& service, const string& top } catch(const exception& ex) { - ::Ice::Error error(_metrics->getLogger()); + Ice::Error error(_metrics->getLogger()); error << "unexpected exception trying to obtain observer:\n" << ex; } } - return 0; + return nullptr; } -SubscriberObserverPtr +shared_ptr<SubscriberObserver> TopicManagerObserverI::getSubscriberObserver(const string& svc, const string& topic, - const ::Ice::ObjectPrx& proxy, + const shared_ptr<Ice::ObjectPrx>& proxy, const IceStorm::QoS& qos, - const IceStorm::TopicPrx& link, + const shared_ptr<IceStorm::TopicPrx>& link, SubscriberState state, - const SubscriberObserverPtr& old) + const shared_ptr<SubscriberObserver>& old) { if(_subscribers.isEnabled()) { @@ -362,9 +362,9 @@ TopicManagerObserverI::getSubscriberObserver(const string& svc, } catch(const exception& ex) { - ::Ice::Error error(_metrics->getLogger()); + Ice::Error error(_metrics->getLogger()); error << "unexpected exception trying to obtain observer:\n" << ex; } } - return 0; + return nullptr; } diff --git a/cpp/src/IceStorm/InstrumentationI.h b/cpp/src/IceStorm/InstrumentationI.h index 9627a72b3c9..c223778d808 100644 --- a/cpp/src/IceStorm/InstrumentationI.h +++ b/cpp/src/IceStorm/InstrumentationI.h @@ -13,54 +13,54 @@ namespace IceStorm { -class TopicObserverI : public IceStorm::Instrumentation::TopicObserver, - public IceMX::ObserverT<IceMX::TopicMetrics> +class TopicObserverI final : public IceStorm::Instrumentation::TopicObserver, + public IceMX::ObserverT<IceMX::TopicMetrics> { public: - virtual void published(); - virtual void forwarded(); + void published() override; + void forwarded() override; }; -class SubscriberObserverI : public IceStorm::Instrumentation::SubscriberObserver, - public IceMX::ObserverT<IceMX::SubscriberMetrics> +class SubscriberObserverI final : public IceStorm::Instrumentation::SubscriberObserver, + public IceMX::ObserverT<IceMX::SubscriberMetrics> { public: - virtual void queued(int); - virtual void outstanding(int); - virtual void delivered(int); + void queued(int) override; + void outstanding(int) override; + void delivered(int) override; }; -class TopicManagerObserverI : public IceStorm::Instrumentation::TopicManagerObserver +class TopicManagerObserverI final : public IceStorm::Instrumentation::TopicManagerObserver { public: - TopicManagerObserverI(const IceInternal::MetricsAdminIPtr&); + TopicManagerObserverI(const std::shared_ptr<IceInternal::MetricsAdminI>&); - virtual void setObserverUpdater(const IceStorm::Instrumentation::ObserverUpdaterPtr&); + void setObserverUpdater(const std::shared_ptr<IceStorm::Instrumentation::ObserverUpdater>&) override; - virtual IceStorm::Instrumentation::TopicObserverPtr getTopicObserver( - const std::string&, const std::string&, const IceStorm::Instrumentation::TopicObserverPtr&); + std::shared_ptr<IceStorm::Instrumentation::TopicObserver> + getTopicObserver(const std::string&, const std::string&, + const std::shared_ptr<IceStorm::Instrumentation::TopicObserver>&) override; - virtual IceStorm::Instrumentation::SubscriberObserverPtr getSubscriberObserver( - const std::string&, - const std::string&, - const Ice::ObjectPrx&, - const IceStorm::QoS&, - const IceStorm::TopicPrx&, - IceStorm::Instrumentation::SubscriberState, - const IceStorm::Instrumentation::SubscriberObserverPtr&); + std::shared_ptr<IceStorm::Instrumentation::SubscriberObserver> + getSubscriberObserver(const std::string &, + const std::string &, + const std::shared_ptr<Ice::ObjectPrx> &, + const IceStorm::QoS &, + const std::shared_ptr<IceStorm::TopicPrx> &, + IceStorm::Instrumentation::SubscriberState, + const std::shared_ptr<IceStorm::Instrumentation::SubscriberObserver>&) override; private: - const IceInternal::MetricsAdminIPtr _metrics; + const std::shared_ptr<IceInternal::MetricsAdminI> _metrics; IceMX::ObserverFactoryT<TopicObserverI> _topics; IceMX::ObserverFactoryT<SubscriberObserverI> _subscribers; }; -typedef IceUtil::Handle<TopicManagerObserverI> TopicManagerObserverIPtr; -}; +} #endif diff --git a/cpp/src/IceStorm/Makefile.mk b/cpp/src/IceStorm/Makefile.mk index 3604e7ffcdb..528e766226e 100644 --- a/cpp/src/IceStorm/Makefile.mk +++ b/cpp/src/IceStorm/Makefile.mk @@ -6,10 +6,10 @@ $(project)_libraries := IceStormService $(project)_programs := icestormadmin icestormdb $(project)_sliceflags := -Isrc --include-dir IceStorm $(project)_generated_includedir := $(project)/generated/IceStorm -$(project)_dependencies := IceStorm Ice +$(project)_dependencies := IceStorm Ice Glacier2 IceStormService_targetdir := $(libdir) -IceStormService_dependencies := IceGrid Glacier2 IceBox IceDB +IceStormService_dependencies := IceGrid IceBox IceDB IceStormService_cppflags := $(if $(lmdb_includedir),-I$(lmdb_includedir)) IceStormService_devinstall := no IceStormService_sources := $(addprefix $(currentdir)/,Instance.cpp \ @@ -45,6 +45,6 @@ icestormadmin_sources := $(addprefix $(currentdir)/,Admin.cpp \ icestormdb_targetdir := $(bindir) icestormdb_dependencies := IceDB icestormdb_cppflags := $(if $(lmdb_includedir),-I$(lmdb_includedir)) -icestormdb_sources := $(addprefix $(currentdir)/,IceStormDB.cpp DBTypes.ice) +icestormdb_sources := $(addprefix $(currentdir)/,IceStormDB.cpp SubscriberRecord.ice DBTypes.ice) projects += $(project) diff --git a/cpp/src/IceStorm/NodeI.cpp b/cpp/src/IceStorm/NodeI.cpp index 48563f2f701..794b04761fb 100644 --- a/cpp/src/IceStorm/NodeI.cpp +++ b/cpp/src/IceStorm/NodeI.cpp @@ -16,11 +16,11 @@ namespace class CheckTask : public IceUtil::TimerTask { - const NodeIPtr _node; + const shared_ptr<NodeI> _node; public: - CheckTask(const NodeIPtr& node) : _node(node) { } + CheckTask(shared_ptr<NodeI> node) : _node(move(node)) { } virtual void runTimerTask() { _node->check(); @@ -29,12 +29,12 @@ public: class MergeTask : public IceUtil::TimerTask { - const NodeIPtr _node; + const shared_ptr<NodeI> _node; const set<int> _s; public: - MergeTask(const NodeIPtr& node, const set<int>& s) : _node(node), _s(s) { } + MergeTask(shared_ptr<NodeI> node, const set<int>& s) : _node(move(node)), _s(s) { } virtual void runTimerTask() { _node->merge(_s); @@ -43,11 +43,11 @@ public: class MergeContinueTask : public IceUtil::TimerTask { - const NodeIPtr _node; + const shared_ptr<NodeI> _node; public: - MergeContinueTask(const NodeIPtr& node) : _node(node) { } + MergeContinueTask(shared_ptr<NodeI> node) : _node(move(node)) { } virtual void runTimerTask() { _node->mergeContinue(); @@ -56,11 +56,11 @@ public: class TimeoutTask: public IceUtil::TimerTask { - const NodeIPtr _node; + const shared_ptr<NodeI> _node; public: - TimeoutTask(const NodeIPtr& node) : _node(node) { } + TimeoutTask(shared_ptr<NodeI> node) : _node(move(node)) { } virtual void runTimerTask() { _node->timeout(); @@ -81,8 +81,8 @@ GroupNodeInfo::GroupNodeInfo(int i) : { } -GroupNodeInfo::GroupNodeInfo(int i, LogUpdate l, const Ice::ObjectPrx& o) : - id(i), llu(l), observer(o) +GroupNodeInfo::GroupNodeInfo(int i, LogUpdate l, shared_ptr<Ice::ObjectPrx> o) : + id(i), llu(l), observer(move(o)) { } @@ -98,34 +98,22 @@ GroupNodeInfo::operator==(const GroupNodeInfo& rhs) const return id == rhs.id; } -// -// COMPILER FIX: Clang using libc++ requires to define operator= -// -#if defined(__clang__) && defined(_LIBCPP_VERSION) -GroupNodeInfo& -GroupNodeInfo::operator=(const GroupNodeInfo& other) - -{ - const_cast<int&>(this->id) = other.id; - const_cast<LogUpdate&>(this->llu) = other.llu; - const_cast<Ice::ObjectPrx&>(this->observer) = other.observer; - return *this; -} -#endif - namespace { -static IceUtil::Time -getTimeout(const string& key, int def, const Ice::PropertiesPtr& properties, const TraceLevelsPtr& traceLevels) +static chrono::seconds +getTimeout(const shared_ptr<Instance> instance, const string& key, int def) { - int t = properties->getPropertyAsIntWithDefault(key, def); - if(t < 0) + auto properties = instance->communicator()->getProperties(); + auto traceLevels = instance->traceLevels(); + + auto t = chrono::seconds(properties->getPropertyAsIntWithDefault(key, def)); + if(t < 0s) { Ice::Warning out(traceLevels->logger); out << traceLevels->electionCat << ": " << key << " < 0; Adjusted to 1"; - t = 1; + t = 1s; } - return IceUtil::Time::seconds(t); + return t; } static string @@ -147,37 +135,31 @@ toString(const set<int>& s) } -NodeI::NodeI(const InstancePtr& instance, - const ReplicaPtr& replica, - const Ice::ObjectPrx& replicaProxy, - int id, const map<int, NodePrx>& nodes) : +NodeI::NodeI(const shared_ptr<Instance>& instance, + shared_ptr<Replica> replica, + shared_ptr<Ice::ObjectPrx> replicaProxy, + int id, const map<int, shared_ptr<NodePrx>>& nodes) : _timer(instance->timer()), _traceLevels(instance->traceLevels()), _observers(instance->observers()), - _replica(replica), - _replicaProxy(replicaProxy), + _replica(move(replica)), + _replicaProxy(move(replicaProxy)), _id(id), _nodes(nodes), - _state(NodeStateInactive), + _masterTimeout(getTimeout(instance, instance->serviceName() + ".Election.MasterTimeout", 10)), + _electionTimeout(getTimeout(instance, instance->serviceName() + ".Election.ElectionTimeout", 10)), + _mergeTimeout(getTimeout(instance, instance->serviceName() + ".Election.ResponseTimeout", 10)), + _state(NodeState::NodeStateInactive), _updateCounter(0), _max(0), _generation(-1), _destroy(false) { - map<int, NodePrx> oneway; - for(map<int, NodePrx>::const_iterator p = _nodes.begin(); p != _nodes.end(); ++p) + for(const auto& node : _nodes) { - oneway[p->first] = NodePrx::uncheckedCast(p->second->ice_oneway()); + auto prx = Ice::uncheckedCast<NodePrx>(node.second->ice_oneway()); + const_cast<map<int, shared_ptr<NodePrx>>& >(_nodesOneway)[node.first] = move(prx); } - const_cast<map<int, NodePrx>& >(_nodesOneway) = oneway; - - Ice::PropertiesPtr properties = instance->communicator()->getProperties(); - const_cast<IceUtil::Time&>(_masterTimeout) = getTimeout( - instance->serviceName() + ".Election.MasterTimeout", 10, properties, _traceLevels); - const_cast<IceUtil::Time&>(_electionTimeout) = getTimeout( - instance->serviceName() + ".Election.ElectionTimeout", 10, properties, _traceLevels); - const_cast<IceUtil::Time&>(_mergeTimeout) = getTimeout( - instance->serviceName() + ".Election.ResponseTimeout", 10, properties, _traceLevels); } void @@ -204,9 +186,9 @@ NodeI::start() // We use this lock to ensure that recovery is called before CheckTask // is scheduled, even if timeout is 0 // - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - _checkTask = new CheckTask(this); + _checkTask = make_shared<CheckTask>(shared_from_this()); _timer->schedule(_checkTask, IceUtil::Time::seconds(static_cast<IceUtil::Int64>(_nodes.size() - static_cast<size_t>(_id)) * 2)); recovery(); @@ -216,17 +198,17 @@ void NodeI::check() { { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); if(_destroy) { return; } assert(!_mergeTask); - if(_state == NodeStateElection || _state == NodeStateReorganization || _coord != _id) + if(_state == NodeState::NodeStateElection || _state == NodeState::NodeStateReorganization || _coord != _id) { assert(_checkTask); - _timer->schedule(_checkTask, _electionTimeout); + _timer->schedule(_checkTask, IceUtil::Time::seconds(_electionTimeout.count())); return; } @@ -236,15 +218,15 @@ NodeI::check() _observers->getReapedSlaves(dead); if(!dead.empty()) { - for(vector<int>::const_iterator p = dead.begin(); p != dead.end(); ++p) + for(const auto& node : dead) { - set<GroupNodeInfo>::iterator q = _up.find(GroupNodeInfo(*p)); + auto q = _up.find(GroupNodeInfo(node)); if(q != _up.end()) { if(_traceLevels->election > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->electionCat); - out << "node " << _id << ": reaping slave " << *p; + out << "node " << _id << ": reaping slave " << node; } _up.erase(q); } @@ -272,21 +254,21 @@ NodeI::check() // See if other groups exist for possible merge. set<int> tmpset; int max = -1; - for(map<int, NodePrx>::const_iterator p = _nodes.begin(); p != _nodes.end(); ++p) + for(const auto& node : _nodes) { - if(p->first == _id) + if(node.first == _id) { continue; } try { - if(p->second->areYouCoordinator()) + if(node.second->areYouCoordinator()) { - if(p->first > max) + if(node.first > max) { - max = p->first; + max = node.first; } - tmpset.insert(p->first); + tmpset.insert(node.first); } } catch(const Ice::Exception& ex) @@ -294,18 +276,18 @@ NodeI::check() if(_traceLevels->election > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->electionCat); - out << "node " << _id << ": call on node " << p->first << " failed: " << ex; + out << "node " << _id << ": call on node " << node.first << " failed: " << ex; } } } - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); // If the node state has changed while the mutex has been released // then bail. We don't schedule a re-check since we're either // destroyed in which case we're going to terminate or the end of // the election/reorg will re-schedule the check. - if(_destroy || _state == NodeStateElection || _state == NodeStateReorganization || _coord != _id) + if(_destroy || _state == NodeState::NodeStateElection || _state == NodeState::NodeStateReorganization || _coord != _id) { _checkTask = 0; return; @@ -316,7 +298,7 @@ NodeI::check() if(tmpset.empty()) { assert(_checkTask); - _timer->schedule(_checkTask, _electionTimeout); + _timer->schedule(_checkTask, IceUtil::Time::seconds(_electionTimeout.count())); return; } @@ -329,22 +311,21 @@ NodeI::check() out << "node " << _id << ": highest priority node count: " << max; } - IceUtil::Time delay = IceUtil::Time::seconds(0); + chrono::seconds delay = 0s; if(_id < max) { - // Reschedule timer proportial to p-i. + // Reschedule timer proportional to p-i. delay = _mergeTimeout + _mergeTimeout * (max - _id); if(_traceLevels->election > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->electionCat); - out << "node " << _id << ": scheduling merge in " << delay.toDuration() - << " seconds"; + out << "node " << _id << ": scheduling merge in " << delay.count() << " seconds"; } } assert(!_mergeTask); - _mergeTask = new MergeTask(this, tmpset); - _timer->schedule(_mergeTask, delay); + _mergeTask = make_shared<MergeTask>(shared_from_this(), tmpset); + _timer->schedule(_mergeTask, IceUtil::Time::seconds(delay.count())); } // Called if the node has not heard from the coordinator in some time. @@ -354,7 +335,7 @@ NodeI::timeout() int myCoord; string myGroup; { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); // If we're destroyed or we are our own coordinator then we're // done. if(_destroy || _coord == _id) @@ -368,7 +349,7 @@ NodeI::timeout() bool failed = false; try { - map<int, NodePrx>::const_iterator p = _nodes.find(myCoord); + auto p = _nodes.find(myCoord); assert(p != _nodes.end()); if(!p->second->areYouThere(myGroup, _id)) { @@ -402,24 +383,26 @@ NodeI::merge(const set<int>& coordinatorSet) set<int> invited; string gp; { - Lock sync(*this); + unique_lock<recursive_mutex> lock(_mutex); + _mergeTask = 0; // If the node is currently in an election, or reorganizing // then we're done. - if(_state == NodeStateElection || _state == NodeStateReorganization) + if(_state == NodeState::NodeStateElection || _state == NodeState::NodeStateReorganization) { return; } // This state change prevents this node from accepting // invitations while the merge is executing. - setState(NodeStateElection); + setState(NodeState::NodeStateElection); // No more replica changes are permitted. while(!_destroy && _updateCounter > 0) { - wait(); + // The recursive mutex (_mutex) must only be locked once by this tread + _condVar.wait(lock); } if(_destroy) { @@ -437,9 +420,9 @@ NodeI::merge(const set<int>& coordinatorSet) // Construct a set of node ids to invite. This is the union of // _up and set of coordinators gathered in the check stage. invited = coordinatorSet; - for(set<GroupNodeInfo>::const_iterator p = _up.begin(); p != _up.end(); ++p) + for(const auto& node : _up) { - invited.insert(p->id); + invited.insert(node.id); } _coord = _id; @@ -462,7 +445,7 @@ NodeI::merge(const set<int>& coordinatorSet) Ice::Trace out(_traceLevels->logger, _traceLevels->electionCat); out << "node " << _id << ": inviting node " << *p << " to group " << gp; } - map<int, NodePrx>::const_iterator node = _nodesOneway.find(*p); + auto node = _nodesOneway.find(*p); assert(node != _nodesOneway.end()); node->second->invitation(_id, gp); ++p; @@ -475,7 +458,7 @@ NodeI::merge(const set<int>& coordinatorSet) // Now we wait for responses to our invitation. { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); if(_destroy) { return; @@ -492,17 +475,17 @@ NodeI::merge(const set<int>& coordinatorSet) // Schedule the mergeContinueTask. assert(_mergeContinueTask == 0); - _mergeContinueTask = new MergeContinueTask(this); + _mergeContinueTask = make_shared<MergeContinueTask>(shared_from_this()); // At this point we may have already accepted all of the // invitations, if so then we want to schedule the // mergeContinue immediately. - IceUtil::Time timeout = _mergeTimeout; + chrono::seconds timeout = _mergeTimeout; if(_up.size() == _nodes.size()-1 || _invitesIssued == _invitesAccepted) { - timeout = IceUtil::Time::seconds(0); + timeout = 0s; } - _timer->schedule(_mergeContinueTask, timeout); + _timer->schedule(_mergeContinueTask, IceUtil::Time::seconds(timeout.count())); } } @@ -512,7 +495,7 @@ NodeI::mergeContinue() string gp; set<GroupNodeInfo> tmpSet; { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); if(_destroy) { return; @@ -520,14 +503,14 @@ NodeI::mergeContinue() // Copy variables for thread safety. gp = _group; - tmpSet = _up; + tmpSet = set<GroupNodeInfo>(_up); assert(_mergeContinueTask); _mergeContinueTask = 0; // The node is now reorganizing. - assert(_state == NodeStateElection); - setState(NodeStateReorganization); + assert(_state == NodeState::NodeStateElection); + setState(NodeState::NodeStateReorganization); if(_traceLevels->election > 0) { @@ -562,18 +545,18 @@ NodeI::mergeContinue() // updates. int maxid = -1; LogUpdate maxllu = { -1, 0 }; - for(set<GroupNodeInfo>::const_iterator p = tmpSet.begin(); p != tmpSet.end(); ++p) + for(const auto& n : tmpSet) { if(_traceLevels->election > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->electionCat); - out << "node id=" << p->id << " llu=" << p->llu.generation << "/" << p->llu.iteration; + out << "node id=" << n.id << " llu=" << n.llu.generation << "/" << n.llu.iteration; } - if(p->llu.generation > maxllu.generation || - (p->llu.generation == maxllu.generation && p->llu.iteration > maxllu.iteration)) + if(n.llu.generation > maxllu.generation || + (n.llu.generation == maxllu.generation && n.llu.iteration > maxllu.iteration)) { - maxid = p->id; - maxllu = p->llu; + maxid = n.id; + maxllu = n.llu; } } @@ -596,7 +579,7 @@ NodeI::mergeContinue() } try { - map<int, NodePrx>::const_iterator node = _nodes.find(maxid); + auto node = _nodes.find(maxid); assert(node != _nodes.end()); _replica->sync(node->second->sync()); } @@ -625,7 +608,7 @@ NodeI::mergeContinue() // state, as such we can set our _max flag. unsigned int max = static_cast<unsigned int>(tmpSet.size()) + 1; { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); if(max > _max) { _max = max; @@ -655,11 +638,11 @@ NodeI::mergeContinue() } // Tell each node to go. - for(set<GroupNodeInfo>::const_iterator p = tmpSet.begin(); p != tmpSet.end(); ++p) + for(const auto& n : tmpSet) { try { - map<int, NodePrx>::const_iterator node = _nodes.find(p->id); + auto node = _nodes.find(n.id); assert(node != _nodes.end()); node->second->ready(_id, gp, _replicaProxy, static_cast<Ice::Int>(max), maxllu.generation); } @@ -668,7 +651,7 @@ NodeI::mergeContinue() if(_traceLevels->election > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->electionCat); - out << "node " << _id << ": error calling ready on " << p->id << " ex: " << ex; + out << "node " << _id << ": error calling ready on " << n.id << " ex: " << ex; } recovery(); return; @@ -676,7 +659,7 @@ NodeI::mergeContinue() } { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); if(_destroy) { return; @@ -688,19 +671,19 @@ NodeI::mergeContinue() out << "replication commencing with " << _up.size()+1 << "/" << _nodes.size() << " nodes with llu generation: " << maxllu.generation; } - setState(NodeStateNormal); + setState(NodeState::NodeStateNormal); _coordinatorProxy = 0; _generation = maxllu.generation; assert(!_checkTask); - _checkTask = new CheckTask(this); - _timer->schedule(_checkTask, _electionTimeout); + _checkTask = make_shared<CheckTask>(shared_from_this()); + _timer->schedule(_checkTask, IceUtil::Time::seconds(_electionTimeout.count())); } } void -NodeI::invitation(int j, const string& gn, const Ice::Current&) +NodeI::invitation(int j, string gn, const Ice::Current&) { if(_traceLevels->election > 0) { @@ -720,14 +703,14 @@ NodeI::invitation(int j, const string& gn, const Ice::Current&) int max = -1; set<GroupNodeInfo> tmpSet; { - Lock sync(*this); + unique_lock<recursive_mutex> lock(_mutex); if(_destroy) { return; } // If we're in the election or reorg state a merge has already // started, so ignore the invitation. - if(_state == NodeStateElection || _state == NodeStateReorganization) + if(_state == NodeState::NodeStateElection || _state == NodeState::NodeStateReorganization) { if(_traceLevels->election > 0) { @@ -751,18 +734,18 @@ NodeI::invitation(int j, const string& gn, const Ice::Current&) // The merge task is cleared in the merge. This // ensures two invitations cannot cause a race with // the merge. - //_mergeTask = 0; return; } - _mergeTask = 0; + _mergeTask = nullptr; } // We're now joining with another group. If we are active we // must stop serving as a master or slave. - setState(NodeStateElection); + setState(NodeState::NodeStateElection); while(!_destroy && _updateCounter > 0) { - wait(); + // The recursive mutex (_mutex) must only be locked once by this tread + _condVar.wait(lock); } if(_destroy) { @@ -770,7 +753,7 @@ NodeI::invitation(int j, const string& gn, const Ice::Current&) } tmpCoord = _coord; - tmpSet = _up; + tmpSet = set<GroupNodeInfo>(_up); _coord = j; _group = gn; @@ -780,14 +763,14 @@ NodeI::invitation(int j, const string& gn, const Ice::Current&) Ice::IntSeq forwardedInvites; if(tmpCoord == _id) // Forward invitation to my old members. { - for(set<GroupNodeInfo>::const_iterator p = tmpSet.begin(); p != tmpSet.end(); ++p) + for(const auto& n : tmpSet) { try { - map<int, NodePrx>::const_iterator node = _nodesOneway.find(p->id); + auto node = _nodesOneway.find(n.id); assert(node != _nodesOneway.end()); node->second->invitation(j, gn); - forwardedInvites.push_back(p->id); + forwardedInvites.push_back(n.id); } catch(const Ice::Exception&) { @@ -800,23 +783,24 @@ NodeI::invitation(int j, const string& gn, const Ice::Current&) // everything is fine. Setting the state *after* calling accept // can cause a race. { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); if(_destroy) { return; } - assert(_state == NodeStateElection); - setState(NodeStateReorganization); + + assert(_state == NodeState::NodeStateElection); + setState(NodeState::NodeStateReorganization); if(!_timeoutTask) { - _timeoutTask = new TimeoutTask(this); - _timer->scheduleRepeated(_timeoutTask, _masterTimeout); + _timeoutTask = make_shared<TimeoutTask>(shared_from_this()); + _timer->scheduleRepeated(_timeoutTask, IceUtil::Time::seconds(_masterTimeout.count())); } } try { - map<int, NodePrx>::const_iterator node = _nodesOneway.find(j); + auto node = _nodesOneway.find(j); assert(node != _nodesOneway.end()); node->second->accept(_id, gn, forwardedInvites, _replica->getObserver(), _replica->getLastLogUpdate(), max); } @@ -828,11 +812,11 @@ NodeI::invitation(int j, const string& gn, const Ice::Current&) } void -NodeI::ready(int j, const string& gn, const Ice::ObjectPrx& coordinator, int max, Ice::Long generation, +NodeI::ready(int j, string gn, shared_ptr<Ice::ObjectPrx> coordinator, int max, Ice::Long generation, const Ice::Current&) { - Lock sync(*this); - if(!_destroy && _state == NodeStateReorganization && _group == gn) + lock_guard<recursive_mutex> lg(_mutex); + if(!_destroy && _state == NodeState::NodeStateReorganization && _group == gn) { // The coordinator must be j (this was set in the invitation). if(_coord != j) @@ -859,20 +843,20 @@ NodeI::ready(int j, const string& gn, const Ice::ObjectPrx& coordinator, int max // Activate the replica here since the replica is now ready // for duty. - setState(NodeStateNormal); + setState(NodeState::NodeStateNormal); _coordinatorProxy = coordinator; if(!_checkTask) { - _checkTask = new CheckTask(this); - _timer->schedule(_checkTask, _electionTimeout); + _checkTask = make_shared<CheckTask>(shared_from_this()); + _timer->schedule(_checkTask, IceUtil::Time::seconds(_electionTimeout.count())); } } } void -NodeI::accept(int j, const string& gn, const Ice::IntSeq& forwardedInvites, const Ice::ObjectPrx& observer, - const LogUpdate& llu, int max, const Ice::Current&) +NodeI::accept(int j, string gn, Ice::IntSeq forwardedInvites, shared_ptr<Ice::ObjectPrx> observer, LogUpdate llu, + int max, const Ice::Current&) { // Verify that j exists in our node set. if(_nodes.find(j) == _nodes.end()) @@ -882,8 +866,8 @@ NodeI::accept(int j, const string& gn, const Ice::IntSeq& forwardedInvites, cons return; } - Lock sync(*this); - if(!_destroy && _state == NodeStateElection && _group == gn && _coord == _id) + lock_guard<recursive_mutex> lg(_mutex); + if(!_destroy && _state == NodeState::NodeStateElection && _group == gn && _coord == _id) { _up.insert(GroupNodeInfo(j, llu, observer)); @@ -928,7 +912,7 @@ NodeI::accept(int j, const string& gn, const Ice::IntSeq& forwardedInvites, cons // merge continue immediately. Otherwise, we let the existing // merge() schedule continue. if((_up.size() == _nodes.size()-1 || _invitesIssued == _invitesAccepted) && - _mergeContinueTask && _timer->cancel(_mergeContinueTask)) + _mergeContinueTask && _timer->cancel(_mergeContinueTask)) { _timer->schedule(_mergeContinueTask, IceUtil::Time::seconds(0)); } @@ -938,18 +922,18 @@ NodeI::accept(int j, const string& gn, const Ice::IntSeq& forwardedInvites, cons bool NodeI::areYouCoordinator(const Ice::Current&) const { - Lock sync(*this); - return _state != NodeStateElection && _state != NodeStateReorganization && _coord == _id; + lock_guard<recursive_mutex> lg(_mutex); + return _state != NodeState::NodeStateElection && _state != NodeState::NodeStateReorganization && _coord == _id; } bool -NodeI::areYouThere(const string& gn, int j, const Ice::Current&) const +NodeI::areYouThere(string gn, int j, const Ice::Current&) const { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); return _group == gn && _coord == _id && _up.find(GroupNodeInfo(j)) != _up.end(); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> NodeI::sync(const Ice::Current&) const { return _replica->getSync(); @@ -959,12 +943,9 @@ NodeInfoSeq NodeI::nodes(const Ice::Current&) const { NodeInfoSeq seq; - for(map<int, NodePrx>::const_iterator q = _nodes.begin(); q != _nodes.end(); ++q) + for(const auto& n : _nodes) { - NodeInfo ni; - ni.id = q->first; - ni.n = q->second; - seq.push_back(ni); + seq.push_back({ n.first, n.second }); } return seq; @@ -973,21 +954,18 @@ NodeI::nodes(const Ice::Current&) const QueryInfo NodeI::query(const Ice::Current&) const { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); QueryInfo info; info.id = _id; info.coord = _coord; info.group = _group; info.replica = _replicaProxy; info.state = _state; - info.max = static_cast<Ice::Int>(_max); + info.max = static_cast<int>(_max); - for(set<GroupNodeInfo>::const_iterator p = _up.begin(); p != _up.end(); ++p) + for(const auto& gni : _up) { - GroupInfo gi; - gi.id = p->id; - gi.llu = p->llu; - info.up.push_back(gi); + info.up.push_back( { gni.id, gni.llu }); } return info; @@ -996,7 +974,7 @@ NodeI::query(const Ice::Current&) const void NodeI::recovery(Ice::Long generation) { - Lock sync(*this); + unique_lock<recursive_mutex> lock(_mutex); // Ignore the recovery if the node has already advanced a // generation. @@ -1005,10 +983,10 @@ NodeI::recovery(Ice::Long generation) return; } - setState(NodeStateInactive); + setState(NodeState::NodeStateInactive); while(!_destroy && _updateCounter > 0) { - wait(); + _condVar.wait(lock); } if(_destroy) { @@ -1042,23 +1020,23 @@ NodeI::recovery(Ice::Long generation) } if(!_checkTask) { - _checkTask = new CheckTask(this); - _timer->schedule(_checkTask, _electionTimeout); + _checkTask = make_shared<CheckTask>(shared_from_this()); + _timer->schedule(_checkTask, IceUtil::Time::seconds(_electionTimeout.count())); } } void NodeI::destroy() { - Lock sync(*this); + unique_lock<recursive_mutex> lock(_mutex); assert(!_destroy); while(_updateCounter > 0) { - wait(); + _condVar.wait(lock); } _destroy = true; - notifyAll(); + _condVar.notify_all(); // Cancel the timers. if(_checkTask) @@ -1083,10 +1061,10 @@ NodeI::destroy() // A node should only receive an observer init call if the node is // reorganizing and its not the coordinator. void -NodeI::checkObserverInit(Ice::Long /*generation*/) +NodeI::checkObserverInit(Ice::Long) { - Lock sync(*this); - if(_state != NodeStateReorganization) + lock_guard<recursive_mutex> lg(_mutex); + if(_state != NodeState::NodeStateReorganization) { throw ObserverInconsistencyException("init cannot block when state != NodeStateReorganization"); } @@ -1097,23 +1075,21 @@ NodeI::checkObserverInit(Ice::Long /*generation*/) } // Notify the node that we're about to start an update. -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> NodeI::startUpdate(Ice::Long& generation, const char* file, int line) { bool majority = _observers->check(); - Lock sync(*this); + unique_lock<recursive_mutex> lock(_mutex); // If we've actively replicating & lost the majority of our replicas then recover. - if(!_coordinatorProxy && !_destroy && _state == NodeStateNormal && !majority) + if(!_coordinatorProxy && !_destroy && _state == NodeState::NodeStateNormal && !majority) { recovery(); } - while(!_destroy && _state != NodeStateNormal) - { - wait(); - } + _condVar.wait(lock, [this] { return _destroy || _state == NodeState::NodeStateNormal; } ); + if(_destroy) { throw Ice::UnknownException(file, line); @@ -1127,11 +1103,11 @@ NodeI::startUpdate(Ice::Long& generation, const char* file, int line) } bool -NodeI::updateMaster(const char* /*file*/, int /*line*/) +NodeI::updateMaster(const char*, int) { bool majority = _observers->check(); - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); // If the node is destroyed, or is not a coordinator then we're // done. @@ -1141,13 +1117,13 @@ NodeI::updateMaster(const char* /*file*/, int /*line*/) } // If we've lost the majority of our replicas then recover. - if(_state == NodeStateNormal && !majority) + if(_state == NodeState::NodeStateNormal && !majority) { recovery(); } // If we're not replicating then we're done. - if(_state != NodeStateNormal) + if(_state != NodeState::NodeStateNormal) { return false; } @@ -1157,14 +1133,13 @@ NodeI::updateMaster(const char* /*file*/, int /*line*/) return true; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> NodeI::startCachedRead(Ice::Long& generation, const char* file, int line) { - Lock sync(*this); - while(!_destroy && _state != NodeStateNormal) - { - wait(); - } + unique_lock<recursive_mutex> lock(_mutex); + + _condVar.wait(lock, [this] { return _destroy || _state == NodeState::NodeStateNormal; }); + if(_destroy) { throw Ice::UnknownException(file, line); @@ -1177,12 +1152,13 @@ NodeI::startCachedRead(Ice::Long& generation, const char* file, int line) void NodeI::startObserverUpdate(Ice::Long generation, const char* file, int line) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); + if(_destroy) { throw Ice::UnknownException(file, line); } - if(_state != NodeStateNormal) + if(_state != NodeState::NodeStateNormal) { throw ObserverInconsistencyException("update called on inactive node"); } @@ -1200,13 +1176,13 @@ NodeI::startObserverUpdate(Ice::Long generation, const char* file, int line) void NodeI::finishUpdate() { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); assert(!_destroy); --_updateCounter; assert(_updateCounter >= 0); if(_updateCounter == 0) { - notifyAll(); + _condVar.notify_all(); } } @@ -1217,13 +1193,13 @@ stateToString(NodeState s) { switch(s) { - case NodeStateInactive: + case NodeState::NodeStateInactive: return "inactive"; - case NodeStateElection: + case NodeState::NodeStateElection: return "election"; - case NodeStateReorganization: + case NodeState::NodeStateReorganization: return "reorganization"; - case NodeStateNormal: + case NodeState::NodeStateNormal: return "normal"; } return "unknown"; @@ -1241,10 +1217,10 @@ NodeI::setState(NodeState s) out << "node " << _id << ": transition from " << stateToString(_state) << " to " << stateToString(s); } - _state = s; - if(_state == NodeStateNormal) + _state = move(s); + if(_state == NodeState::NodeStateNormal) { - notifyAll(); + _condVar.notify_all(); } } } diff --git a/cpp/src/IceStorm/NodeI.h b/cpp/src/IceStorm/NodeI.h index 5b0ba169def..37a6ce66967 100644 --- a/cpp/src/IceStorm/NodeI.h +++ b/cpp/src/IceStorm/NodeI.h @@ -2,8 +2,8 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#ifndef ELECTION_I_H -#define ELECTION_I_H +#ifndef NODE_I_H +#define NODE_I_H #include <IceUtil/IceUtil.h> #include <Ice/Ice.h> @@ -11,20 +11,21 @@ #include <IceStorm/Replica.h> #include <IceStorm/Instance.h> #include <IceUtil/Timer.h> + #include <set> +#include <condition_variable> namespace IceStormElection { class Observers; -typedef IceUtil::Handle<Observers> ObserversPtr; -class NodeI : public Node, public IceUtil::Monitor<IceUtil::RecMutex> +class NodeI final : public Node, public std::enable_shared_from_this<NodeI> { public: - NodeI(const IceStorm::InstancePtr&, const ReplicaPtr&, const Ice::ObjectPrx&, - int, const std::map<int, NodePrx>&); + NodeI(const std::shared_ptr<IceStorm::Instance>&, std::shared_ptr<Replica>, std::shared_ptr<Ice::ObjectPrx>, + int, const std::map<int, std::shared_ptr<NodePrx>>&); void start(); @@ -32,23 +33,23 @@ public: void timeout(); void merge(const std::set<int>&); void mergeContinue(); - virtual void invitation(int, const std::string&, const Ice::Current&); - virtual void ready(int, const std::string&, const Ice::ObjectPrx&, int, Ice::Long, const Ice::Current&); - virtual void accept(int, const std::string&, const Ice::IntSeq&, const Ice::ObjectPrx&, const LogUpdate&, int, - const Ice::Current&); - virtual bool areYouCoordinator(const Ice::Current&) const; - virtual bool areYouThere(const std::string&, int, const Ice::Current&) const; - virtual Ice::ObjectPrx sync(const Ice::Current&) const; - virtual NodeInfoSeq nodes(const Ice::Current&) const; - virtual QueryInfo query(const Ice::Current&) const; + void invitation(int, std::string, const Ice::Current&) override; + void ready(int, std::string, std::shared_ptr<Ice::ObjectPrx>, int, Ice::Long, const Ice::Current&) override; + void accept(int, std::string, Ice::IntSeq, std::shared_ptr<Ice::ObjectPrx>, LogUpdate, int, + const Ice::Current&) override; + bool areYouCoordinator(const Ice::Current&) const override; + bool areYouThere(std::string, int, const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> sync(const Ice::Current&) const override; + NodeInfoSeq nodes(const Ice::Current&) const override; + QueryInfo query(const Ice::Current&) const override; void recovery(Ice::Long = -1); void destroy(); // Notify the node that we're about to start an update. void checkObserverInit(Ice::Long); - Ice::ObjectPrx startUpdate(Ice::Long&, const char*, int); - Ice::ObjectPrx startCachedRead(Ice::Long&, const char*, int); + std::shared_ptr<Ice::ObjectPrx> startUpdate(Ice::Long&, const char*, int); + std::shared_ptr<Ice::ObjectPrx> startCachedRead(Ice::Long&, const char*, int); void startObserverUpdate(Ice::Long, const char*, int); bool updateMaster(const char*, int); @@ -60,18 +61,18 @@ private: void setState(NodeState); const IceUtil::TimerPtr _timer; - const IceStorm::TraceLevelsPtr _traceLevels; - const IceStormElection::ObserversPtr _observers; - const ReplicaPtr _replica; // The replica. - const Ice::ObjectPrx _replicaProxy; // A proxy to the individual replica. + const std::shared_ptr<IceStorm::TraceLevels> _traceLevels; + const std::shared_ptr<IceStormElection::Observers> _observers; + const std::shared_ptr<Replica> _replica; // The replica. + const std::shared_ptr<Ice::ObjectPrx> _replicaProxy; // A proxy to the individual replica. const int _id; // My node id. - const std::map<int, NodePrx> _nodes; // The nodes indexed by their id. - const std::map<int, NodePrx> _nodesOneway; // The nodes indexed by their id (as oneway proxies). + const std::map<int, std::shared_ptr<NodePrx>> _nodes; // The nodes indexed by their id. + const std::map<int, std::shared_ptr<NodePrx>> _nodesOneway; // The nodes indexed by their id (as oneway proxies). - const IceUtil::Time _masterTimeout; - const IceUtil::Time _electionTimeout; - const IceUtil::Time _mergeTimeout; + const std::chrono::seconds _masterTimeout; + const std::chrono::seconds _electionTimeout; + const std::chrono::seconds _mergeTimeout; NodeState _state; int _updateCounter; @@ -86,23 +87,24 @@ private: unsigned int _max; // The highest group count I've seen. Ice::Long _generation; // The current generation (or -1 if not set). - Ice::ObjectPrx _coordinatorProxy; + std::shared_ptr<Ice::ObjectPrx> _coordinatorProxy; bool _destroy; - // Various timers. IceUtil::TimerTaskPtr _mergeTask; IceUtil::TimerTaskPtr _timeoutTask; IceUtil::TimerTaskPtr _checkTask; IceUtil::TimerTaskPtr _mergeContinueTask; + + mutable std::recursive_mutex _mutex; + std::condition_variable_any _condVar; }; -typedef IceUtil::Handle<NodeI> NodeIPtr; class FinishUpdateHelper { public: - FinishUpdateHelper(const NodeIPtr& node) : - _node(node) + FinishUpdateHelper(std::shared_ptr<NodeI> node) : + _node(std::move(node)) { } @@ -116,15 +118,15 @@ public: private: - const NodeIPtr _node; + const std::shared_ptr<NodeI> _node; }; class CachedReadHelper { public: - CachedReadHelper(const NodeIPtr& node, const char* file, int line) : - _node(node) + CachedReadHelper(std::shared_ptr<NodeI> node, const char* file, int line) : + _node(std::move(node)) { if(_node) { @@ -140,7 +142,7 @@ public: } } - Ice::ObjectPrx + std::shared_ptr<Ice::ObjectPrx> getMaster() const { return _master; @@ -160,8 +162,8 @@ public: private: - const NodeIPtr _node; - Ice::ObjectPrx _master; + const std::shared_ptr<NodeI> _node; + std::shared_ptr<Ice::ObjectPrx> _master; Ice::Long _generation; }; @@ -169,8 +171,8 @@ class ObserverUpdateHelper { public: - ObserverUpdateHelper(const NodeIPtr& node, Ice::Long generation, const char* file, int line) : - _node(node) + ObserverUpdateHelper(std::shared_ptr<NodeI> node, Ice::Long generation, const char* file, int line) : + _node(std::move(node)) { if(_node) { @@ -188,9 +190,9 @@ public: private: - const NodeIPtr _node; + const std::shared_ptr<NodeI> _node; }; } -#endif // ELECTION_I_H +#endif // NODE_I_H diff --git a/cpp/src/IceStorm/Observers.cpp b/cpp/src/IceStorm/Observers.cpp index b38a2db5da5..f714477b82c 100644 --- a/cpp/src/IceStorm/Observers.cpp +++ b/cpp/src/IceStorm/Observers.cpp @@ -10,8 +10,8 @@ using namespace std; using namespace IceStorm; using namespace IceStormElection; -Observers::Observers(const InstancePtr& instance) : - _traceLevels(instance->traceLevels()), +Observers::Observers(shared_ptr<TraceLevels> traceLevels) : + _traceLevels(move(traceLevels)), _majority(0) { } @@ -25,10 +25,11 @@ Observers::setMajority(unsigned int majority) bool Observers::check() { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); + if(_observers.size() >= _majority) { - vector<ObserverInfo>::iterator p = _observers.begin(); + auto p = _observers.begin(); while(p != _observers.end()) { try @@ -45,11 +46,8 @@ Observers::check() int id = p->id; p = _observers.erase(p); - // COMPILERFIX: Just using following causes double unlock with C++Builder 2007 - //IceUtil::Mutex::Lock sync(_reapedMutex); - _reapedMutex.lock(); + lock_guard<mutex> reapedLock(_reapedMutex); _reaped.push_back(id); - _reapedMutex.unlock(); continue; } ++p; @@ -61,14 +59,14 @@ Observers::check() void Observers::clear() { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); _observers.clear(); } void Observers::getReapedSlaves(std::vector<int>& d) { - IceUtil::Mutex::Lock sync(_reapedMutex); + lock_guard<mutex> reapedLock(_reapedMutex); d.swap(_reaped); } @@ -76,65 +74,64 @@ void Observers::init(const set<GroupNodeInfo>& slaves, const LogUpdate& llu, const TopicContentSeq& content) { { - IceUtil::Mutex::Lock sync(_reapedMutex); + lock_guard<mutex> reapedLock(_reapedMutex); _reaped.clear(); } - Lock sync(*this); + lock_guard<mutex> lg(_mutex); _observers.clear(); vector<ObserverInfo> observers; - for(set<GroupNodeInfo>::const_iterator p = slaves.begin(); p != slaves.end(); ++p) + for(const auto& slave : slaves) { try { - assert(p->observer); + assert(slave.observer); + + auto observer = Ice::uncheckedCast<ReplicaObserverPrx>(slave.observer); - ReplicaObserverPrx observer = ReplicaObserverPrx::uncheckedCast(p->observer); + auto future = observer->initAsync(llu, content); - Ice::AsyncResultPtr result = observer->begin_init(llu, content); - observers.push_back(ObserverInfo(p->id, observer, result)); + observers.push_back({ slave.id, observer, move(future) }); } catch(const Ice::Exception& ex) { if(_traceLevels->replication > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->replicationCat); - out << "error calling init on " << p->id << ", exception: " << ex; + out << "error calling init on " << slave.id << ", exception: " << ex; } throw; } } - for(vector<ObserverInfo>::iterator p = observers.begin(); p != observers.end(); ++p) + for(auto& o : observers) { try { - p->observer->end_init(p->result); - p->result = 0; + o.future.get(); } catch(const Ice::Exception& ex) { if(_traceLevels->replication > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->replicationCat); - out << "init on " << p->id << " failed with exception " << ex; + out << "init on " << o.id << " failed with exception " << ex; } throw; } } - - _observers.swap(observers); + _observers = move(observers); } void Observers::createTopic(const LogUpdate& llu, const string& name) { - Lock sync(*this); - for(vector<ObserverInfo>::iterator p = _observers.begin(); p != _observers.end(); ++p) + lock_guard<mutex> lg(_mutex); + for(auto& o : _observers) { - p->result = p->observer->begin_createTopic(llu, name); + o.future = o.observer->createTopicAsync(llu, name); } wait("createTopic"); } @@ -142,10 +139,10 @@ Observers::createTopic(const LogUpdate& llu, const string& name) void Observers::destroyTopic(const LogUpdate& llu, const string& id) { - Lock sync(*this); - for(vector<ObserverInfo>::iterator p = _observers.begin(); p != _observers.end(); ++p) + lock_guard<mutex> lg(_mutex); + for(auto& o : _observers) { - p->result = p->observer->begin_destroyTopic(llu, id); + o.future = o.observer->destroyTopicAsync(llu, id); } wait("destroyTopic"); } @@ -153,10 +150,10 @@ Observers::destroyTopic(const LogUpdate& llu, const string& id) void Observers::addSubscriber(const LogUpdate& llu, const string& name, const SubscriberRecord& rec) { - Lock sync(*this); - for(vector<ObserverInfo>::iterator p = _observers.begin(); p != _observers.end(); ++p) + lock_guard<mutex> lg(_mutex); + for(auto& o : _observers) { - p->result = p->observer->begin_addSubscriber(llu, name, rec); + o.future = o.observer->addSubscriberAsync(llu, name, rec); } wait("addSubscriber"); } @@ -164,10 +161,10 @@ Observers::addSubscriber(const LogUpdate& llu, const string& name, const Subscri void Observers::removeSubscriber(const LogUpdate& llu, const string& name, const Ice::IdentitySeq& id) { - Lock sync(*this); - for(vector<ObserverInfo>::iterator p = _observers.begin(); p != _observers.end(); ++p) + lock_guard<mutex> lg(_mutex); + for(auto& o : _observers) { - p->result = p->observer->begin_removeSubscriber(llu, name, id); + o.future = o.observer->removeSubscriberAsync(llu, name, id); } wait("removeSubscriber"); } @@ -180,8 +177,7 @@ Observers::wait(const string& op) { try { - p->result->waitForCompleted(); - p->result->throwLocalException(); + p->future.get(); } catch(const Ice::Exception& ex) { @@ -193,18 +189,18 @@ Observers::wait(const string& op) int id = p->id; p = _observers.erase(p); - IceUtil::Mutex::Lock sync(_reapedMutex); + lock_guard<mutex> reapedLock(_mutex); _reaped.push_back(id); continue; } ++p; } + // If we now no longer have the majority of observers we raise. if(_observers.size() < _majority) { - // TODO: Trace here? - //Ice::Trace out(_traceLevels->logger, _traceLevels->replicationCat); - //out << op; + Ice::Trace out(_traceLevels->logger, _traceLevels->replicationCat); + out << "number of observers `" << _observers.size() << "' is less than the majority '" << _majority << "'"; throw Ice::UnknownException(__FILE__, __LINE__); } } diff --git a/cpp/src/IceStorm/Observers.h b/cpp/src/IceStorm/Observers.h index 89b26217b73..ed7a6d535fa 100644 --- a/cpp/src/IceStorm/Observers.h +++ b/cpp/src/IceStorm/Observers.h @@ -10,25 +10,18 @@ #include <IceStorm/Election.h> #include <IceStorm/Replica.h> -#ifdef __SUNPRO_CC -# pragma error_messages(off,hidef) -#endif - namespace IceStorm { -class Instance; -typedef IceUtil::Handle<Instance> InstancePtr; class TraceLevels; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; } namespace IceStormElection { -class Observers : public IceUtil::Shared, public IceUtil::Mutex +class Observers { public: - Observers(const IceStorm::InstancePtr&); + Observers(std::shared_ptr<IceStorm::TraceLevels>); void setMajority(unsigned int); @@ -47,26 +40,22 @@ private: void wait(const std::string&); - const IceStorm::TraceLevelsPtr _traceLevels; + const std::shared_ptr<IceStorm::TraceLevels> _traceLevels; unsigned int _majority; struct ObserverInfo { - ObserverInfo(int i, const ReplicaObserverPrx& o, const Ice::AsyncResultPtr& r = 0) : - id(i), observer(o), result (r) {} int id; - ReplicaObserverPrx observer; - ::Ice::AsyncResultPtr result; + std::shared_ptr<ReplicaObserverPrx> observer; + std::future<void> future; }; std::vector<ObserverInfo> _observers; - IceUtil::Mutex _reapedMutex; + + std::mutex _reapedMutex; std::vector<int> _reaped; + + std::mutex _mutex; }; -typedef IceUtil::Handle<Observers> ObserversPtr; } -#ifdef __SUNPRO_CC -# pragma error_messages(default,hidef) -#endif - #endif // OBSERVERS_H diff --git a/cpp/src/IceStorm/Parser.cpp b/cpp/src/IceStorm/Parser.cpp index 0629ca0e393..faa857157e0 100644 --- a/cpp/src/IceStorm/Parser.cpp +++ b/cpp/src/IceStorm/Parser.cpp @@ -9,8 +9,9 @@ #include <IceStorm/IceStormInternal.h> #include <algorithm> -#if defined(__APPLE__) || defined(__linux__) -# include <editline/readline.h> +#ifdef HAVE_READLINE +# include <readline/readline.h> +# include <readline/history.h> #endif extern FILE* yyin; @@ -29,7 +30,7 @@ namespace IceStorm Parser* parser; #ifdef _WIN32 -Ice::StringConverterPtr windowsConsoleConverter = 0; +shared_ptr<Ice::StringConverter> windowsConsoleConverter = nullptr; #endif } @@ -37,51 +38,37 @@ Ice::StringConverterPtr windowsConsoleConverter = 0; namespace { -class UnknownManagerException : public Exception +class UnknownManagerException : public std::exception { public: - UnknownManagerException(const string& nameP, const char* file, int line) : - Exception(file, line), - name(nameP) + explicit UnknownManagerException(const std::string& name) : _name(name) { } -#ifndef ICE_CPP11_COMPILER - virtual - ~UnknownManagerException() throw() + const char* what() const noexcept override { - } -#endif - - virtual string - ice_id() const - { - return "::UnknownManagerException"; - } - - virtual Exception* - ice_clone() const - { - return new UnknownManagerException(*this); - } - - virtual void - ice_throw() const - { - throw *this; + return _name.c_str(); } - const string name; +private: + const string _name; }; } -ParserPtr -Parser::createParser(const CommunicatorPtr& communicator, const TopicManagerPrx& admin, - const map<Ice::Identity, TopicManagerPrx>& managers) +Parser::Parser(shared_ptr<Communicator> communicator, shared_ptr<TopicManagerPrx> admin, + map<Ice::Identity, shared_ptr<TopicManagerPrx>> managers) : + _communicator(move(communicator)), + _defaultManager(move(admin)), + _managers(move(managers)) { - return new Parser(communicator, admin, managers); +#ifdef _WIN32 + if(!windowsConsoleConverter) + { + windowsConsoleConverter = Ice::createWindowsStringConverter(GetConsoleOutputCP()); + } +#endif } void @@ -114,17 +101,17 @@ Parser::create(const list<string>& args) return; } - for(list<string>::const_iterator i = args.begin(); i != args.end() ; ++i) + for(const auto& arg : args) { try { string topicName; - TopicManagerPrx manager = findManagerById(*i, topicName); + auto manager = findManagerById(arg, topicName); manager->create(topicName); } - catch(const Ice::Exception& ex) + catch(const std::exception&) { - exception(ex, args.size() > 1); // Print a warning if we're creating multiple topics, an error otherwise. + exception(current_exception(), args.size() > 1); // Print a warning if we're creating multiple topics, an error otherwise. } } } @@ -138,15 +125,15 @@ Parser::destroy(const list<string>& args) return; } - for(list<string>::const_iterator i = args.begin(); i != args.end() ; ++i) + for(const auto& arg : args) { try { - findTopic(*i)->destroy(); + findTopic(arg)->destroy(); } - catch(const Ice::Exception& ex) + catch(const std::exception&) { - exception(ex, args.size() > 1); // Print a warning if we're destroying multiple topics, an error otherwise. + exception(current_exception(), args.size() > 1); // Print a warning if we're destroying multiple topics, an error otherwise. } } } @@ -164,15 +151,15 @@ Parser::link(const list<string>& args) { list<string>::const_iterator p = args.begin(); - TopicPrx fromTopic = findTopic(*p++); - TopicPrx toTopic = findTopic(*p++); - Ice::Int cost = p != args.end() ? atoi(p->c_str()) : 0; + auto fromTopic = findTopic(*p++); + auto toTopic = findTopic(*p++); + auto cost = p != args.end() ? atoi(p->c_str()) : 0; fromTopic->link(toTopic, cost); } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -189,14 +176,14 @@ Parser::unlink(const list<string>& args) { list<string>::const_iterator p = args.begin(); - TopicPrx fromTopic = findTopic(*p++); - TopicPrx toTopic = findTopic(*p++); + auto fromTopic = findTopic(*p++); + auto toTopic = findTopic(*p++); fromTopic->unlink(toTopic); } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -211,7 +198,7 @@ Parser::links(const list<string>& args) try { - TopicManagerPrx manager; + shared_ptr<TopicManagerPrx> manager; if(args.size() == 0) { manager = _defaultManager; @@ -221,19 +208,17 @@ Parser::links(const list<string>& args) manager = findManagerByCategory(args.front()); } - TopicDict d = manager->retrieveAll(); - for(TopicDict::iterator i = d.begin(); i != d.end(); ++i) + for(const auto& topic : manager->retrieveAll()) { - LinkInfoSeq links = i->second->getLinkInfoSeq(); - for(LinkInfoSeq::const_iterator p = links.begin(); p != links.end(); ++p) + for(const auto& linkInfo : topic.second->getLinkInfoSeq()) { - consoleOut << i->first << " to " << p->name << " with cost " << p->cost << endl; + consoleOut << topic.first << " to " << linkInfo.name << " with cost " << linkInfo.cost << endl; } } } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -248,7 +233,7 @@ Parser::topics(const list<string>& args) try { - TopicManagerPrx manager; + shared_ptr<TopicManagerPrx> manager; if(args.size() == 0) { manager = _defaultManager; @@ -258,15 +243,14 @@ Parser::topics(const list<string>& args) manager = findManagerByCategory(args.front()); } - TopicDict d = manager->retrieveAll(); - for(TopicDict::iterator i = d.begin(); i != d.end(); ++i) + for(const auto& topic : manager->retrieveAll()) { - consoleOut << i->first << endl; + consoleOut << topic.first << endl; } } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -281,7 +265,7 @@ Parser::replica(const list<string>& args) try { - TopicManagerPrx m; + shared_ptr<TopicManagerPrx> m; if(args.size() == 0) { m = _defaultManager; @@ -290,63 +274,63 @@ Parser::replica(const list<string>& args) { m = findManagerByCategory(args.front()); } - TopicManagerInternalPrx manager = TopicManagerInternalPrx::uncheckedCast(m); - IceStormElection::NodePrx node = manager->getReplicaNode(); + auto manager = Ice::uncheckedCast<TopicManagerInternalPrx>(m); + auto node = manager->getReplicaNode(); if(!node) { error("This topic is not replicated"); } - IceStormElection::NodeInfoSeq nodes = node->nodes(); + auto nodes = node->nodes(); consoleOut << "replica count: " << nodes.size() << endl; - for(IceStormElection::NodeInfoSeq::const_iterator p = nodes.begin(); p != nodes.end(); ++p) + for(const auto& n : nodes) { try { - IceStormElection::QueryInfo info = p->n->query(); - consoleOut << p->id << ": id: " << info.id << endl; - consoleOut << p->id << ": coord: " << info.coord << endl; - consoleOut << p->id << ": group name: " << info.group << endl; - consoleOut << p->id << ": state: "; + auto info = n.n->query(); + consoleOut << n.id << ": id: " << info.id << endl; + consoleOut << n.id << ": coord: " << info.coord << endl; + consoleOut << n.id << ": group name: " << info.group << endl; + consoleOut << n.id << ": state: "; switch(info.state) { - case IceStormElection::NodeStateInactive: + case IceStormElection::NodeState::NodeStateInactive: consoleOut << "inactive"; break; - case IceStormElection::NodeStateElection: + case IceStormElection::NodeState::NodeStateElection: consoleOut << "election"; break; - case IceStormElection::NodeStateReorganization: + case IceStormElection::NodeState::NodeStateReorganization: consoleOut << "reorganization"; break; - case IceStormElection::NodeStateNormal: + case IceStormElection::NodeState::NodeStateNormal: consoleOut << "normal"; break; default: consoleOut << "unknown"; } consoleOut << endl; - consoleOut << p->id << ": group: "; - for(IceStormElection::GroupInfoSeq::const_iterator q = info.up.begin(); q != info.up.end(); ++q) + consoleOut << n.id << ": group: "; + for(auto q = info.up.cbegin(); q != info.up.cend(); ++q) { - if(q != info.up.begin()) + if(q != info.up.cbegin()) { consoleOut << ","; } consoleOut << q->id; } consoleOut << endl; - consoleOut << p->id << ": max: " << info.max + consoleOut << n.id << ": max: " << info.max << endl; } catch(const Exception& ex) { - consoleOut << p->id << ": " << ex.ice_id() << endl; + consoleOut << n.id << ": " << ex.ice_id() << endl; } } } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -360,20 +344,19 @@ Parser::subscribers(const list<string>& args) } try { - for(list<string>::const_iterator i = args.begin(); i != args.end() ; ++i) + for(const auto& arg : args) { - TopicPrx topic = _defaultManager->retrieve(*i); - consoleOut << (*i) << ": subscribers:" << endl; - IdentitySeq subscribers = topic->getSubscribers(); - for(IdentitySeq::const_iterator j = subscribers.begin(); j != subscribers.end(); ++j) + auto topic = _defaultManager->retrieve(arg); + consoleOut << arg << ": subscribers:" << endl; + for(const auto& subscriber : topic->getSubscribers()) { - consoleOut << "\t" << _communicator->identityToString(*j) << endl; + consoleOut << "\t" << _communicator->identityToString(subscriber) << endl; } } } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -393,13 +376,13 @@ Parser::current(const list<string>& args) try { - TopicManagerPrx manager = findManagerByCategory(args.front()); + auto manager = findManagerByCategory(args.front()); manager->ice_ping(); _defaultManager = manager; } - catch(const Exception& ex) + catch(const std::exception&) { - exception(ex); + exception(current_exception()); } } @@ -444,80 +427,77 @@ Parser::getInput(char* buf, size_t& result, size_t maxSize) } else { -#if defined(__APPLE__) || defined(__linux__) - if (isatty(fileno(stdin)) == 1) +#ifdef HAVE_READLINE + + const char* prompt = parser->getPrompt(); + char* line = readline(const_cast<char*>(prompt)); + if(!line) + { + result = 0; + } + else { - const char* prompt = parser->getPrompt(); - char* line = readline(const_cast<char*>(prompt)); - if(!line) + if(*line) + { + add_history(line); + } + + result = strlen(line) + 1; + if(result > maxSize) { + free(line); + error("input line too long"); result = 0; } else { - if(*line) - { - add_history(line); - } - - result = strlen(line) + 1; - if(result > maxSize) - { - free(line); - error("input line too long"); - result = 0; - } - else - { - strcpy(buf, line); - strcat(buf, "\n"); - free(line); - } + strcpy(buf, line); + strcat(buf, "\n"); + free(line); } } - else - { -#endif - consoleOut << parser->getPrompt() << flush; - string line; - while(true) - { - int c = getc(yyin); - if(c == EOF) - { - if(line.size()) - { - line += '\n'; - } - break; - } +#else + + consoleOut << parser->getPrompt() << flush; - line += static_cast<char>(c); - if(c == '\n') + string line; + while(true) + { + int c = getc(yyin); + if(c == EOF) + { + if(line.size()) { - break; + line += '\n'; } + break; } -#ifdef _WIN32 - if(windowsConsoleConverter) + + line += static_cast<char>(c); + if(c == '\n') { - line = nativeToUTF8(line, windowsConsoleConverter); + break; } + } +#ifdef _WIN32 + if(windowsConsoleConverter) + { + line = nativeToUTF8(line, windowsConsoleConverter); + } #endif - result = line.length(); - if(result > maxSize) - { - error("input line too long"); - buf[0] = EOF; - result = 1; - } - else - { - strcpy(buf, line.c_str()); - } -#if defined(__APPLE__) || defined(__linux__) + result = line.length(); + if(result > maxSize) + { + error("input line too long"); + buf[0] = EOF; + result = 1; + } + else + { + strcpy(buf, line.c_str()); } + #endif } } @@ -625,67 +605,51 @@ Parser::parse(const std::string& commands, bool debug) return status; } -TopicManagerPrx +shared_ptr<TopicManagerPrx> Parser::findManagerById(const string& full, string& arg) const { - Ice::Identity id = Ice::stringToIdentity(full); + auto id = Ice::stringToIdentity(full); arg = id.name; if(id.category.empty()) { return _defaultManager; } id.name = "TopicManager"; - map<Ice::Identity, TopicManagerPrx>::const_iterator p = _managers.find(id); + auto p = _managers.find(id); if(p == _managers.end()) { - throw UnknownManagerException(id.category, __FILE__, __LINE__); + throw UnknownManagerException(id.category); } return p->second; } -TopicManagerPrx +shared_ptr<TopicManagerPrx> Parser::findManagerByCategory(const string& full) const { - Ice::Identity id; - id.category = full; - id.name = "TopicManager"; - map<Ice::Identity, TopicManagerPrx>::const_iterator p = _managers.find(id); + Ice::Identity id = {"TopicManager", full}; + auto p = _managers.find(id); if(p == _managers.end()) { - throw UnknownManagerException(id.category, __FILE__, __LINE__); + throw UnknownManagerException(id.category); } return p->second; } -TopicPrx +shared_ptr<TopicPrx> Parser::findTopic(const string& full) const { string topicName; - TopicManagerPrx manager = findManagerById(full, topicName); + auto manager = findManagerById(full, topicName); return manager->retrieve(topicName); } -Parser::Parser(const CommunicatorPtr& communicator, const TopicManagerPrx& admin, - const map<Ice::Identity, TopicManagerPrx>& managers) : - _communicator(communicator), - _defaultManager(admin), - _managers(managers) -{ -#ifdef _WIN32 - if(!windowsConsoleConverter) - { - windowsConsoleConverter = Ice::createWindowsStringConverter(GetConsoleOutputCP()); - } -#endif -} - void -Parser::exception(const Ice::Exception& pex, bool warn) +Parser::exception(exception_ptr pex, bool warn) { ostringstream os; try { - pex.ice_throw(); + rethrow_exception(pex); } catch(const LinkExists& ex) { @@ -705,7 +669,7 @@ Parser::exception(const Ice::Exception& pex, bool warn) } catch(const UnknownManagerException& ex) { - os << "couldn't find IceStorm service `" << ex.name << "'"; + os << "couldn't find IceStorm service `" << ex.what() << "'"; } catch(const IdentityParseException& ex) { @@ -719,6 +683,10 @@ Parser::exception(const Ice::Exception& pex, bool warn) { os << ex; } + catch(const std::exception& ex) + { + os << ex.what(); + } if(warn) { diff --git a/cpp/src/IceStorm/Parser.h b/cpp/src/IceStorm/Parser.h index c297617f707..e2cf48481dd 100644 --- a/cpp/src/IceStorm/Parser.h +++ b/cpp/src/IceStorm/Parser.h @@ -5,7 +5,6 @@ #ifndef ICE_STORM_PARSER_H #define ICE_STORM_PARSER_H -#include <IceUtil/Handle.h> #include <IceStorm/IceStorm.h> #include <list> #include <stdio.h> @@ -37,18 +36,12 @@ YY_DECL; namespace IceStorm { -// -// Forward declaration. -// -class Parser; -typedef ::IceUtil::Handle<Parser> ParserPtr; - -class Parser : public ::IceUtil::SimpleShared +class Parser { public: - static ParserPtr createParser(const Ice::CommunicatorPtr&, const TopicManagerPrx&, - const std::map<Ice::Identity, TopicManagerPrx>&); + Parser(std::shared_ptr<Ice::Communicator>, std::shared_ptr<TopicManagerPrx>, + std::map<Ice::Identity, std::shared_ptr<TopicManagerPrx>>); void usage(); @@ -88,17 +81,15 @@ public: private: - TopicManagerPrx findManagerById(const std::string&, std::string&) const; - TopicManagerPrx findManagerByCategory(const std::string&) const; - TopicPrx findTopic(const std::string&) const; - - Parser(const Ice::CommunicatorPtr&, const TopicManagerPrx&, const std::map<Ice::Identity, TopicManagerPrx>&); + std::shared_ptr<TopicManagerPrx> findManagerById(const std::string&, std::string&) const; + std::shared_ptr<TopicManagerPrx> findManagerByCategory(const std::string&) const; + std::shared_ptr<TopicPrx> findTopic(const std::string&) const; - void exception(const Ice::Exception&, bool = false); + void exception(std::exception_ptr, bool = false); - const Ice::CommunicatorPtr _communicator; - TopicManagerPrx _defaultManager; - const std::map<Ice::Identity, TopicManagerPrx> _managers; + const std::shared_ptr<Ice::Communicator> _communicator; + std::shared_ptr<TopicManagerPrx> _defaultManager; + const std::map<Ice::Identity, std::shared_ptr<TopicManagerPrx>> _managers; std::string _commands; bool _continue; int _errors; diff --git a/cpp/src/IceStorm/Replica.h b/cpp/src/IceStorm/Replica.h index f166a8db317..5f3d7422315 100644 --- a/cpp/src/IceStorm/Replica.h +++ b/cpp/src/IceStorm/Replica.h @@ -14,32 +14,27 @@ namespace IceStormElection struct GroupNodeInfo { - GroupNodeInfo(int i); - GroupNodeInfo(int i, LogUpdate l, const Ice::ObjectPrx& o = Ice::ObjectPrx()); + explicit GroupNodeInfo(int i); + GroupNodeInfo(int i, LogUpdate l, std::shared_ptr<Ice::ObjectPrx> o = nullptr); + bool operator<(const GroupNodeInfo& rhs) const; bool operator==(const GroupNodeInfo& rhs) const; - // - // COMPILER FIX: Clang using libc++ requires to define operator= - // -#if defined(__clang__) && defined(_LIBCPP_VERSION) - GroupNodeInfo& operator=(const GroupNodeInfo&); -#endif + const int id; const LogUpdate llu; - const Ice::ObjectPrx observer; + const std::shared_ptr<Ice::ObjectPrx> observer; }; -class Replica : public virtual IceUtil::Shared +class Replica { public: virtual LogUpdate getLastLogUpdate() const = 0; - virtual void sync(const Ice::ObjectPrx&) = 0; + virtual void sync(const std::shared_ptr<Ice::ObjectPrx>&) = 0; virtual void initMaster(const std::set<IceStormElection::GroupNodeInfo>&, const LogUpdate&) = 0; - virtual Ice::ObjectPrx getObserver() const = 0; - virtual Ice::ObjectPrx getSync() const = 0; + virtual std::shared_ptr<Ice::ObjectPrx> getObserver() const = 0; + virtual std::shared_ptr<Ice::ObjectPrx> getSync() const = 0; }; -typedef IceUtil::Handle<Replica> ReplicaPtr; } diff --git a/cpp/src/IceStorm/Scanner.cpp b/cpp/src/IceStorm/Scanner.cpp index ce0e4e36e64..4d5ee833556 100644 --- a/cpp/src/IceStorm/Scanner.cpp +++ b/cpp/src/IceStorm/Scanner.cpp @@ -1,7 +1,11 @@ +#line 1 "src/IceStorm/Scanner.cpp" +// +// Copyright (c) ZeroC, Inc. All rights reserved. +// + #include <IceUtil/ScannerConfig.h> -#line 2 "src/IceStorm/Scanner.cpp" -#line 4 "src/IceStorm/Scanner.cpp" +#line 8 "src/IceStorm/Scanner.cpp" #define YY_INT_ALIGNED short int @@ -9,8 +13,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 37 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -85,65 +89,61 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + #endif /* ! C99 */ #endif /* ! FLEXINT_H */ -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ - -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) +/* begin standard C++ headers. */ -#define YY_USE_CONST - -#endif /* defined (__STDC__) */ -#endif /* ! __cplusplus */ - -#ifdef YY_USE_CONST +/* TODO: this is always defined, so inline it */ #define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) #else -#define yyconst +#define yynoreturn #endif /* Returned upon end-of-file. */ #define YY_NULL 0 -/* Promotes a possibly negative, possibly signed char to an unsigned - * integer for use as an array index. If the signed char is negative, - * we want to instead treat it as an 8-bit unsigned char, hence the - * double cast. +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. */ -#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN (yy_start) = 1 + 2 * - /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ #define YY_START (((yy_start) - 1) / 2) #define YYSTATE YY_START - /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) - /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart(yyin ) - +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else #define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -160,15 +160,16 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif -extern yy_size_t yyleng; +extern int yyleng; extern FILE *yyin, *yyout; #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 - + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ @@ -183,7 +184,6 @@ extern FILE *yyin, *yyout; YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) - #define unput(c) yyunput( c, (yytext_ptr) ) #ifndef YY_STRUCT_YY_BUFFER_STATE @@ -198,12 +198,12 @@ struct yy_buffer_state /* Size of input buffer in bytes, not including room for EOB * characters. */ - yy_size_t yy_buf_size; + int yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -226,7 +226,7 @@ struct yy_buffer_state int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ - + /* Whether to try to fill the input buffer when we reach the * end of it. */ @@ -254,7 +254,7 @@ struct yy_buffer_state /* Stack of input buffers. */ static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general @@ -265,7 +265,6 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL) - /* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */ @@ -273,11 +272,11 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; -static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ -yy_size_t yyleng; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; /* Points to current character in buffer. */ -static char *yy_c_buf_p = (char *) 0; +static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ @@ -286,85 +285,81 @@ static int yy_start = 0; /* start state number */ */ static int yy_did_buffer_switch_on_eof; -void yyrestart (FILE *input_file ); -void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); -void yy_delete_buffer (YY_BUFFER_STATE b ); -void yy_flush_buffer (YY_BUFFER_STATE b ); -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); -void yypop_buffer_state (void ); - -static void yyensure_buffer_stack (void ); -static void yy_load_buffer_state (void ); -static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); -YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); -void *yyalloc (yy_size_t ); -void *yyrealloc (void *,yy_size_t ); -void yyfree (void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); #define yy_new_buffer yy_create_buffer - #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer(yyin,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } - #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer(yyin,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } - #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) /* Begin user sect3 */ -#define yywrap() 1 +#define yywrap() (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; -typedef unsigned char YY_CHAR; - -FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; extern int yylineno; - int yylineno = 1; extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif #define yytext_ptr yytext -static yy_state_type yy_get_previous_state (void ); -static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); -static int yy_get_next_buffer (void ); -static void yy_fatal_error (yyconst char msg[] ); +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ - yyleng = (size_t) (yy_cp - yy_bp); \ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; - #define YY_NUM_RULES 8 #define YY_END_OF_BUFFER 9 /* This struct is not used in this scanner, @@ -374,13 +369,13 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[19] = +static const flex_int16_t yy_accept[19] = { 0, 3, 3, 9, 7, 3, 4, 5, 6, 7, 4, 7, 3, 0, 2, 1, 0, 3, 0 } ; -static yyconst flex_int32_t yy_ec[256] = +static const YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, @@ -412,24 +407,24 @@ static yyconst flex_int32_t yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[10] = +static const YY_CHAR yy_meta[10] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[19] = +static const flex_int16_t yy_base[19] = { 0, 0, 0, 11, 22, 8, 22, 22, 22, 12, 22, 18, 0, 0, 22, 22, 0, 22, 22 } ; -static yyconst flex_int16_t yy_def[19] = +static const flex_int16_t yy_def[19] = { 0, 18, 1, 18, 18, 18, 18, 18, 18, 18, 18, 18, 5, 11, 18, 18, 11, 18, 0 } ; -static yyconst flex_int16_t yy_nxt[32] = +static const flex_int16_t yy_nxt[32] = { 0, 4, 5, 6, 7, 8, 4, 9, 10, 11, 12, 18, 18, 18, 18, 18, 18, 13, 14, 15, 16, @@ -437,7 +432,7 @@ static yyconst flex_int16_t yy_nxt[32] = 18 } ; -static yyconst flex_int16_t yy_chk[32] = +static const flex_int16_t yy_chk[32] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 0, 0, 0, 0, 0, 5, 9, 9, 11, @@ -460,35 +455,13 @@ int yy_flex_debug = 0; #define YY_RESTORE_YY_MORE_OFFSET char *yytext; #line 1 "src/IceStorm/Scanner.l" -#line 2 "src/IceStorm/Scanner.l" -// -// Copyright (c) ZeroC, Inc. All rights reserved. -// +#line 11 "src/IceStorm/Scanner.l" #include <Ice/Ice.h> #include <IceStorm/Parser.h> #include <IceStorm/Grammar.h> -#if defined(_MSC_VER) -// '<' : signed/unsigned mismatch -# pragma warning(disable:4018) -// 'initializing' : conversion from '__int64' to 'int', possible loss of data -# pragma warning(disable:4244) - -# if defined(ICE_64) -// -// '=' : conversion from 'size_t' to 'int', possible loss of data -// The result of fread() is a size_t and gets inserted into an int -// -# pragma warning(disable:4267) -# endif -#endif - -#if defined(__GNUC__) -# pragma GCC diagnostic ignored "-Wsign-compare" -#endif - using namespace std; using namespace Ice; using namespace IceStorm; @@ -498,17 +471,6 @@ using namespace IceStorm; # undef yywrap # define yywrap() 1 # endif -# define YY_NO_UNISTD_H -#endif - -#ifdef __SUNPRO_CC -# ifdef yywrap -# undef yywrap -# define yywrap() 1 -# endif -# ifdef ICE_64 -# pragma error_messages(off,truncwarn) -# endif #endif #define YY_INPUT(buf, result, maxSize) parser->getInput(buf, result, maxSize) @@ -516,15 +478,15 @@ using namespace IceStorm; namespace IceStorm { -typedef std::map<std::string, int> StringTokenMap; -static StringTokenMap keywordMap; +static std::map<std::string, int> keywordMap; void initScanner(); } #define YY_USER_INIT initScanner(); -#line 532 "src/IceStorm/Scanner.cpp" +#line 495 "src/IceStorm/Scanner.cpp" +#line 496 "src/IceStorm/Scanner.cpp" #define INITIAL 0 @@ -540,36 +502,36 @@ void initScanner(); #define YY_EXTRA_TYPE void * #endif -static int yy_init_globals (void ); +static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int yylex_destroy (void ); +int yylex_destroy ( void ); -int yyget_debug (void ); +int yyget_debug ( void ); -void yyset_debug (int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE yyget_extra (void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void yyset_extra (YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *yyget_in (void ); +FILE *yyget_in ( void ); -void yyset_in (FILE * in_str ); +void yyset_in ( FILE * _in_str ); -FILE *yyget_out (void ); +FILE *yyget_out ( void ); -void yyset_out (FILE * out_str ); +void yyset_out ( FILE * _out_str ); -yy_size_t yyget_leng (void ); + int yyget_leng ( void ); -char *yyget_text (void ); +char *yyget_text ( void ); -int yyget_lineno (void ); +int yyget_lineno ( void ); -void yyset_lineno (int line_number ); +void yyset_lineno ( int _line_number ); /* Macros after this point can all be overridden by user definitions in * section 1. @@ -577,35 +539,43 @@ void yyset_lineno (int line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int yywrap (void ); +extern "C" int yywrap ( void ); #else -extern int yywrap (void ); +extern int yywrap ( void ); #endif #endif - static void yyunput (int c,char *buf_ptr ); +#ifndef YY_NO_UNPUT + static void yyunput ( int c, char *buf_ptr ); + +#endif + #ifndef yytext_ptr -static void yy_flex_strncpy (char *,yyconst char *,int ); +static void yy_flex_strncpy ( char *, const char *, int ); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * ); +static int yy_flex_strlen ( const char * ); #endif #ifndef YY_NO_INPUT - #ifdef __cplusplus -static int yyinput (void ); +static int yyinput ( void ); #else -static int input (void ); +static int input ( void ); #endif #endif /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else #define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -613,7 +583,7 @@ static int input (void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -624,7 +594,7 @@ static int input (void ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ + int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -637,7 +607,7 @@ static int input (void ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -692,7 +662,7 @@ extern int yylex (void); /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK /*LINTED*/break; #endif #define YY_RULE_SETUP \ @@ -702,15 +672,10 @@ extern int yylex (void); */ YY_DECL { - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; -#line 79 "src/IceStorm/Scanner.l" - - -#line 717 "src/IceStorm/Scanner.cpp" - if ( !(yy_init) ) { (yy_init) = 1; @@ -731,13 +696,18 @@ YY_DECL if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer(yyin,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - yy_load_buffer_state( ); + yy_load_buffer_state( ); } - while ( 1 ) /* loops until end-of-file is reached */ + { +#line 55 "src/IceStorm/Scanner.l" + +#line 716 "src/IceStorm/Scanner.cpp" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yy_cp = (yy_c_buf_p); @@ -753,7 +723,7 @@ YY_DECL yy_match: do { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; @@ -763,9 +733,9 @@ yy_match: { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 19 ) - yy_c = yy_meta[(unsigned int) yy_c]; + yy_c = yy_meta[yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 22 ); @@ -794,7 +764,7 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 81 "src/IceStorm/Scanner.l" +#line 57 "src/IceStorm/Scanner.l" { // C++-style comment int c; @@ -807,7 +777,7 @@ YY_RULE_SETUP YY_BREAK case 2: YY_RULE_SETUP -#line 91 "src/IceStorm/Scanner.l" +#line 67 "src/IceStorm/Scanner.l" { // C-style comment while(true) @@ -836,7 +806,7 @@ YY_RULE_SETUP case 3: /* rule 3 can match eol */ YY_RULE_SETUP -#line 116 "src/IceStorm/Scanner.l" +#line 92 "src/IceStorm/Scanner.l" { size_t len = strlen(yytext); for(size_t i = 0; i < len; ++i) @@ -851,14 +821,14 @@ YY_RULE_SETUP case 4: /* rule 4 can match eol */ YY_RULE_SETUP -#line 127 "src/IceStorm/Scanner.l" +#line 103 "src/IceStorm/Scanner.l" { return ';'; } YY_BREAK case 5: YY_RULE_SETUP -#line 131 "src/IceStorm/Scanner.l" +#line 107 "src/IceStorm/Scanner.l" { // "..."-type strings string s; @@ -905,7 +875,7 @@ YY_RULE_SETUP YY_BREAK case 6: YY_RULE_SETUP -#line 175 "src/IceStorm/Scanner.l" +#line 151 "src/IceStorm/Scanner.l" { // '...'-type strings string s; @@ -933,7 +903,7 @@ YY_RULE_SETUP YY_BREAK case 7: YY_RULE_SETUP -#line 200 "src/IceStorm/Scanner.l" +#line 176 "src/IceStorm/Scanner.l" { // Simple strings string s; @@ -957,16 +927,16 @@ YY_RULE_SETUP yylvalp->clear(); yylvalp->push_back(s); - StringTokenMap::const_iterator pos = keywordMap.find(s); + const auto pos = keywordMap.find(s); return pos != keywordMap.end() ? pos->second : ICE_STORM_STRING; } YY_BREAK case 8: YY_RULE_SETUP -#line 227 "src/IceStorm/Scanner.l" +#line 203 "src/IceStorm/Scanner.l" ECHO; YY_BREAK -#line 974 "src/IceStorm/Scanner.cpp" +#line 947 "src/IceStorm/Scanner.cpp" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1044,7 +1014,7 @@ case YY_STATE_EOF(INITIAL): { (yy_did_buffer_switch_on_eof) = 0; - if ( yywrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up @@ -1097,6 +1067,7 @@ case YY_STATE_EOF(INITIAL): "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ + } /* end of user's declarations */ } /* end of yylex */ /* yy_get_next_buffer - try to read in a new buffer @@ -1108,9 +1079,9 @@ case YY_STATE_EOF(INITIAL): */ static int yy_get_next_buffer (void) { - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = (yytext_ptr); - register int number_to_move, i; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; int ret_val; if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) @@ -1139,7 +1110,7 @@ static int yy_get_next_buffer (void) /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); @@ -1152,7 +1123,7 @@ static int yy_get_next_buffer (void) else { - yy_size_t num_to_read = + int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) @@ -1166,7 +1137,7 @@ static int yy_get_next_buffer (void) if ( b->yy_is_our_buffer ) { - yy_size_t new_size = b->yy_buf_size * 2; + int new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1175,11 +1146,12 @@ static int yy_get_next_buffer (void) b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ - b->yy_ch_buf = 0; + b->yy_ch_buf = NULL; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( @@ -1207,7 +1179,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - yyrestart(yyin ); + yyrestart( yyin ); } else @@ -1221,12 +1193,15 @@ static int yy_get_next_buffer (void) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -1242,14 +1217,14 @@ static int yy_get_next_buffer (void) static yy_state_type yy_get_previous_state (void) { - register yy_state_type yy_current_state; - register char *yy_cp; + yy_state_type yy_current_state; + char *yy_cp; yy_current_state = (yy_start); for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; @@ -1259,9 +1234,9 @@ static int yy_get_next_buffer (void) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 19 ) - yy_c = yy_meta[(unsigned int) yy_c]; + yy_c = yy_meta[yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; } return yy_current_state; @@ -1274,10 +1249,10 @@ static int yy_get_next_buffer (void) */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) { - register int yy_is_jam; - register char *yy_cp = (yy_c_buf_p); + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); - register YY_CHAR yy_c = 1; + YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; @@ -1287,17 +1262,19 @@ static int yy_get_next_buffer (void) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 19 ) - yy_c = yy_meta[(unsigned int) yy_c]; + yy_c = yy_meta[yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; yy_is_jam = (yy_current_state == 18); return yy_is_jam ? 0 : yy_current_state; } - static void yyunput (int c, register char * yy_bp ) +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) { - register char *yy_cp; + char *yy_cp; yy_cp = (yy_c_buf_p); @@ -1307,10 +1284,10 @@ static int yy_get_next_buffer (void) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - register yy_size_t number_to_move = (yy_n_chars) + 2; - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - register char *source = + char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) @@ -1319,7 +1296,7 @@ static int yy_get_next_buffer (void) yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); @@ -1332,6 +1309,8 @@ static int yy_get_next_buffer (void) (yy_c_buf_p) = yy_cp; } +#endif + #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void) @@ -1356,7 +1335,7 @@ static int yy_get_next_buffer (void) else { /* need more input */ - yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); ++(yy_c_buf_p); switch ( yy_get_next_buffer( ) ) @@ -1373,14 +1352,14 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - yyrestart(yyin ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( yywrap( ) ) - return EOF; + if ( yywrap( ) ) + return 0; if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; @@ -1417,11 +1396,11 @@ static int yy_get_next_buffer (void) if ( ! YY_CURRENT_BUFFER ){ yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer(yyin,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - yy_init_buffer(YY_CURRENT_BUFFER,input_file ); - yy_load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /** Switch to a different input buffer. @@ -1449,7 +1428,7 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag @@ -1477,7 +1456,7 @@ static void yy_load_buffer_state (void) { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); @@ -1486,13 +1465,13 @@ static void yy_load_buffer_state (void) /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ - b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - yy_init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -1511,9 +1490,9 @@ static void yy_load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - yyfree((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - yyfree((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. @@ -1525,7 +1504,7 @@ static void yy_load_buffer_state (void) { int oerrno = errno; - yy_flush_buffer(b ); + yy_flush_buffer( b ); b->yy_input_file = file; b->yy_fill_buffer = 1; @@ -1568,7 +1547,7 @@ static void yy_load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( ); + yy_load_buffer_state( ); } /** Pushes the new state onto the stack. The new state becomes @@ -1599,7 +1578,7 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } @@ -1618,7 +1597,7 @@ void yypop_buffer_state (void) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -1636,15 +1615,15 @@ static void yyensure_buffer_stack (void) * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ - num_to_alloc = 1; + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - + (yy_buffer_stack_max) = num_to_alloc; (yy_buffer_stack_top) = 0; return; @@ -1653,7 +1632,7 @@ static void yyensure_buffer_stack (void) if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; + yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc @@ -1673,7 +1652,7 @@ static void yyensure_buffer_stack (void) * @param base the character buffer * @param size the size in bytes of the character buffer * - * @return the newly allocated buffer state object. + * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { @@ -1683,23 +1662,23 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ - return 0; + return NULL; - b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; - b->yy_input_file = 0; + b->yy_input_file = NULL; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - yy_switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } @@ -1712,10 +1691,10 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */ -YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return yy_scan_bytes(yystr,strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /** Setup the input buffer state to scan the given bytes. The next call to yylex() will @@ -1725,7 +1704,7 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -1733,8 +1712,8 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len int i; /* Get memory for full buffer, including space for trailing EOB's. */ - n = _yybytes_len + 2; - buf = (char *) yyalloc(n ); + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); @@ -1743,7 +1722,7 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = yy_scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); @@ -1759,9 +1738,9 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len #define YY_EXIT_FAILURE 2 #endif -static void yy_fatal_error (yyconst char* msg ) +static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -1789,7 +1768,7 @@ static void yy_fatal_error (yyconst char* msg ) */ int yyget_lineno (void) { - + return yylineno; } @@ -1812,7 +1791,7 @@ FILE *yyget_out (void) /** Get the length of the current token. * */ -yy_size_t yyget_leng (void) +int yyget_leng (void) { return yyleng; } @@ -1827,29 +1806,29 @@ char *yyget_text (void) } /** Set the current line number. - * @param line_number + * @param _line_number line number * */ -void yyset_lineno (int line_number ) +void yyset_lineno (int _line_number ) { - yylineno = line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. - * @param in_str A readable stream. + * @param _in_str A readable stream. * * @see yy_switch_to_buffer */ -void yyset_in (FILE * in_str ) +void yyset_in (FILE * _in_str ) { - yyin = in_str ; + yyin = _in_str ; } -void yyset_out (FILE * out_str ) +void yyset_out (FILE * _out_str ) { - yyout = out_str ; + yyout = _out_str ; } int yyget_debug (void) @@ -1857,9 +1836,9 @@ int yyget_debug (void) return yy_flex_debug; } -void yyset_debug (int bdebug ) +void yyset_debug (int _bdebug ) { - yy_flex_debug = bdebug ; + yy_flex_debug = _bdebug ; } static int yy_init_globals (void) @@ -1868,10 +1847,10 @@ static int yy_init_globals (void) * This function is called from yylex_destroy(), so don't allocate here. */ - (yy_buffer_stack) = 0; + (yy_buffer_stack) = NULL; (yy_buffer_stack_top) = 0; (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = (char *) 0; + (yy_c_buf_p) = NULL; (yy_init) = 0; (yy_start) = 0; @@ -1880,8 +1859,8 @@ static int yy_init_globals (void) yyin = stdin; yyout = stdout; #else - yyin = (FILE *) 0; - yyout = (FILE *) 0; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by @@ -1896,7 +1875,7 @@ int yylex_destroy (void) /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - yy_delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; yypop_buffer_state(); } @@ -1917,18 +1896,19 @@ int yylex_destroy (void) */ #ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +static void yy_flex_strncpy (char* s1, const char * s2, int n ) { - register int i; + + int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * s ) +static int yy_flex_strlen (const char * s ) { - register int n; + int n; for ( n = 0; s[n]; ++n ) ; @@ -1938,11 +1918,12 @@ static int yy_flex_strlen (yyconst char * s ) void *yyalloc (yy_size_t size ) { - return (void *) malloc( size ); + return malloc(size); } void *yyrealloc (void * ptr, yy_size_t size ) { + /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -1950,19 +1931,17 @@ void *yyrealloc (void * ptr, yy_size_t size ) * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ - return (void *) realloc( (char *) ptr, size ); + return realloc(ptr, size); } void yyfree (void * ptr ) { - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" -#line 227 "src/IceStorm/Scanner.l" - - +#line 203 "src/IceStorm/Scanner.l" namespace IceStorm { @@ -1973,19 +1952,20 @@ namespace IceStorm { void initScanner() { - keywordMap["help"] = ICE_STORM_HELP; - keywordMap["quit"] = ICE_STORM_EXIT; - keywordMap["exit"] = ICE_STORM_EXIT; - keywordMap["current"] = ICE_STORM_CURRENT; - keywordMap["create"] = ICE_STORM_CREATE; - keywordMap["destroy"] = ICE_STORM_DESTROY; - keywordMap["link"] = ICE_STORM_LINK; - keywordMap["unlink"] = ICE_STORM_UNLINK; - keywordMap["links"] = ICE_STORM_LINKS; - keywordMap["topics"] = ICE_STORM_TOPICS; - keywordMap["replica"] = ICE_STORM_REPLICA; - keywordMap["subscribers"] = ICE_STORM_SUBSCRIBERS; + keywordMap = { + {"help", ICE_STORM_HELP}, + {"quit", ICE_STORM_EXIT}, + {"exit", ICE_STORM_EXIT}, + {"current", ICE_STORM_CURRENT}, + {"create", ICE_STORM_CREATE}, + {"destroy", ICE_STORM_DESTROY}, + {"link", ICE_STORM_LINK}, + {"unlink", ICE_STORM_UNLINK}, + {"links", ICE_STORM_LINKS}, + {"topics", ICE_STORM_TOPICS}, + {"replica", ICE_STORM_REPLICA}, + {"subscribers", ICE_STORM_SUBSCRIBERS}, + }; } } - diff --git a/cpp/src/IceStorm/Service.cpp b/cpp/src/IceStorm/Service.cpp index 453d20a4c00..09d3067f046 100644 --- a/cpp/src/IceStorm/Service.cpp +++ b/cpp/src/IceStorm/Service.cpp @@ -32,56 +32,52 @@ using namespace IceStormElection; namespace { -class ServiceI : public IceStormInternal::Service +class ServiceI final : public IceStormInternal::Service { public: - ServiceI(); - virtual ~ServiceI(); + void start(const std::shared_ptr<Ice::Communicator>&, + const std::shared_ptr<Ice::ObjectAdapter>&, + const std::shared_ptr<Ice::ObjectAdapter>&, + const std::string&, + const Ice::Identity&, + const std::string&); - virtual void start(const string&, - const CommunicatorPtr&, - const StringSeq&); + std::shared_ptr<IceStorm::TopicManagerPrx> getTopicManager() const override; - virtual void start(const CommunicatorPtr&, - const ObjectAdapterPtr&, - const ObjectAdapterPtr&, - const string&, - const Ice::Identity&, - const string&); - - virtual TopicManagerPrx getTopicManager() const; - - virtual void stop(); + void start(const std::string&, const std::shared_ptr<Ice::Communicator>&, const Ice::StringSeq&) override; + void stop() override; private: - void createDbEnv(const Ice::CommunicatorPtr&); - void validateProperties(const string&, const PropertiesPtr&, const LoggerPtr&); + void createDbEnv(const std::shared_ptr<Ice::Communicator>&); + void validateProperties(const std::string&, + const std::shared_ptr<Ice::Properties>&, + const std::shared_ptr<Ice::Logger>&); - TopicManagerImplPtr _manager; - TransientTopicManagerImplPtr _transientManager; - TopicManagerPrx _managerProxy; - InstancePtr _instance; + std::shared_ptr<IceStorm::TopicManagerImpl> _manager; + std::shared_ptr<IceStorm::TransientTopicManagerImpl> _transientManager; + std::shared_ptr<IceStorm::TopicManagerPrx> _managerProxy; + std::shared_ptr<IceStorm::Instance> _instance; }; -class FinderI : public IceStorm::Finder +class FinderI final : public IceStorm::Finder { public: - FinderI(const TopicManagerPrx& topicManager) : _topicManager(topicManager) + FinderI(shared_ptr<TopicManagerPrx> topicManager) : _topicManager(move(topicManager)) { } - virtual TopicManagerPrx - getTopicManager(const Ice::Current&) + shared_ptr<TopicManagerPrx> + getTopicManager(const Ice::Current&) override { return _topicManager; } private: - const TopicManagerPrx _topicManager; + const shared_ptr<TopicManagerPrx> _topicManager; }; } @@ -90,42 +86,30 @@ extern "C" { ICESTORM_SERVICE_API ::IceBox::Service* -createIceStorm(CommunicatorPtr) +createIceStorm(const shared_ptr<Communicator>&) { return new ServiceI; } } -ServicePtr -IceStormInternal::Service::create(const CommunicatorPtr& communicator, - const ObjectAdapterPtr& topicAdapter, - const ObjectAdapterPtr& publishAdapter, - const string& name, - const Ice::Identity& id, - const string& dbEnv) +shared_ptr<IceStormInternal::Service> +IceStormInternal::Service::create(const shared_ptr<Communicator>& communicator, + const shared_ptr<ObjectAdapter>& topicAdapter, + const shared_ptr<ObjectAdapter>& publishAdapter, + const string& name, + const Ice::Identity& id, + const string& dbEnv) { - ServiceI* service = new ServiceI; - ServicePtr svc = service; + shared_ptr<ServiceI> service(new ServiceI); service->start(communicator, topicAdapter, publishAdapter, name, id, dbEnv); - return svc; -} - -ServiceI::ServiceI() -{ -} - -ServiceI::~ServiceI() -{ + return service; } void -ServiceI::start( - const string& name, - const CommunicatorPtr& communicator, - const StringSeq& /*args*/) +ServiceI::start(const string& name, const shared_ptr<Communicator>& communicator, const StringSeq&) { - PropertiesPtr properties = communicator->getProperties(); + auto properties = communicator->getProperties(); validateProperties(name, properties, communicator->getLogger()); @@ -141,24 +125,22 @@ ServiceI::start( properties->setProperty(name + ".TopicManager.ThreadPool.SizeMax", "100"); } - Ice::ObjectAdapterPtr topicAdapter = communicator->createObjectAdapter(name + ".TopicManager"); - Ice::ObjectAdapterPtr publishAdapter = communicator->createObjectAdapter(name + ".Publish"); + auto topicAdapter = communicator->createObjectAdapter(name + ".TopicManager"); + auto publishAdapter = communicator->createObjectAdapter(name + ".Publish"); // // We use the name of the service for the name of the database environment. // string instanceName = properties->getPropertyWithDefault(name + ".InstanceName", "IceStorm"); - Identity topicManagerId; - topicManagerId.category = instanceName; - topicManagerId.name = "TopicManager"; + Identity topicManagerId = { "TopicManager", instanceName }; if(properties->getPropertyAsIntWithDefault(name+ ".Transient", 0) > 0) { - _instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter, 0); + _instance = make_shared<Instance>(instanceName, name, communicator, publishAdapter, topicAdapter, nullptr); try { - TransientTopicManagerImplPtr manager = new TransientTopicManagerImpl(_instance); - _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(manager, topicManagerId)); + auto manager = make_shared<TransientTopicManagerImpl>(_instance); + _managerProxy = Ice::uncheckedCast<TopicManagerPrx>(topicAdapter->add(manager, topicManagerId)); } catch(const Ice::Exception& ex) { @@ -178,12 +160,10 @@ ServiceI::start( { try { - PersistentInstancePtr instance = - new PersistentInstance(instanceName, name, communicator, publishAdapter, topicAdapter); - _instance = instance; - - _manager = new TopicManagerImpl(instance); - _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(_manager->getServant(), topicManagerId)); + auto instance = make_shared<PersistentInstance>(instanceName, name, communicator, publishAdapter, topicAdapter); + _manager = TopicManagerImpl::create(instance); + _instance = move(instance); + _managerProxy = uncheckedCast<TopicManagerPrx>(topicAdapter->add(_manager->getServant(), topicManagerId)); } catch(const IceUtil::Exception& ex) { @@ -198,9 +178,8 @@ ServiceI::start( } else { - // Here we want to create a map of id -> election node - // proxies. - map<int, NodePrx> nodes; + // Here we want to create a map of id -> election node proxies. + map<int, shared_ptr<NodePrx>> nodes; string topicManagerAdapterId = properties->getProperty(name + ".TopicManager.AdapterId"); @@ -212,10 +191,18 @@ ServiceI::start( Ice::PropertyDict props = properties->getPropertiesForPrefix(prefix); if(!props.empty()) { - for(Ice::PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) + for(const auto& prop : props) { - int nodeid = atoi(p->first.substr(prefix.size()).c_str()); - nodes[nodeid] = NodePrx::uncheckedCast(communicator->propertyToProxy(p->first)); + try + { + int nodeid = stoi(prop.first.substr(prefix.size())); + nodes[nodeid] = uncheckedCast<NodePrx>(communicator->propertyToProxy(prop.first)); + } + catch(const std::invalid_argument&) + { + Ice::Warning warn(communicator->getLogger()); + warn << "deployment warning: invalid node id `" << prop.first.substr(prefix.size()) << "'"; + } } } else @@ -248,15 +235,15 @@ ServiceI::start( // We work out the node id by removing the instance // name. The node id must follow. // - IceGrid::LocatorPrx locator = IceGrid::LocatorPrx::checkedCast(communicator->getDefaultLocator()); + auto locator = Ice::checkedCast<IceGrid::LocatorPrx>(communicator->getDefaultLocator()); assert(locator); - IceGrid::QueryPrx query = locator->getLocalQuery(); - Ice::ObjectProxySeq replicas = query->findAllReplicas( - communicator->stringToProxy(instanceName + "/TopicManager")); + auto query = locator->getLocalQuery(); + auto replicas = query->findAllReplicas(communicator->stringToProxy(instanceName + "/TopicManager")); for(Ice::ObjectProxySeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p) + for(const auto& replica : replicas) { - string adapterid = (*p)->ice_getAdapterId(); + string adapterid = replica->ice_getAdapterId(); // Replace TopicManager with the node endpoint. adapterid = adapterid.replace(adapterid.find(suffix), suffix.size(), ".Node"); @@ -299,7 +286,7 @@ ServiceI::start( ident.category = instanceName; ident.name = os.str(); - nodes[nodeid] = NodePrx::uncheckedCast((*p)->ice_adapterId(adapterid)->ice_identity(ident)); + nodes[nodeid] = uncheckedCast<NodePrx>((*p)->ice_adapterId(adapterid)->ice_identity(ident)); } } @@ -327,24 +314,22 @@ ServiceI::start( properties->setProperty(name + ".Node.MessageSizeMax", "0"); // No limit on data exchanged internally } - Ice::ObjectAdapterPtr nodeAdapter = communicator->createObjectAdapter(name + ".Node"); - - PersistentInstancePtr instance = - new PersistentInstance(instanceName, name, communicator, publishAdapter, topicAdapter, - nodeAdapter, nodes[id]); + auto nodeAdapter = communicator->createObjectAdapter(name + ".Node"); + auto instance = make_shared<PersistentInstance>(instanceName, name, communicator, publishAdapter, + topicAdapter, nodeAdapter, nodes[id]); _instance = instance; _instance->observers()->setMajority(static_cast<unsigned int>(nodes.size())/2); // Trace replication information. - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->election > 0) { Ice::Trace out(traceLevels->logger, traceLevels->electionCat); out << "I am node " << id << "\n"; - for(map<int, NodePrx>::const_iterator p = nodes.begin(); p != nodes.end(); ++p) + for(const auto& node : nodes) { - out << "\tnode: " << p->first << " proxy: " << p->second->ice_toString() << "\n"; + out << "\tnode: " << node.first << " proxy: " << node.second->ice_toString() << "\n"; } } @@ -353,16 +338,16 @@ ServiceI::start( // We're not using an IceGrid deployment. Here we need // a proxy which is used to create proxies to the // replicas later. - _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->createProxy(topicManagerId)); + _managerProxy = uncheckedCast<TopicManagerPrx>(topicAdapter->createProxy(topicManagerId)); } else { // If we're using IceGrid deployment we need to create // indirect proxies. - _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->createIndirectProxy(topicManagerId)); + _managerProxy = uncheckedCast<TopicManagerPrx>(topicAdapter->createIndirectProxy(topicManagerId)); } - _manager = new TopicManagerImpl(instance); + _manager = TopicManagerImpl::create(instance); topicAdapter->add(_manager->getServant(), topicManagerId); ostringstream os; // The node object identity. @@ -371,7 +356,7 @@ ServiceI::start( nodeid.category = instanceName; nodeid.name = os.str(); - NodeIPtr node = new NodeI(_instance, _manager, _managerProxy, id, nodes); + auto node = make_shared<NodeI>(_instance, _manager, _managerProxy, id, nodes); _instance->setNode(node); nodeAdapter->add(node, nodeid); nodeAdapter->activate(); @@ -390,7 +375,7 @@ ServiceI::start( } } - topicAdapter->add(new FinderI(TopicManagerPrx::uncheckedCast(topicAdapter->createProxy(topicManagerId))), + topicAdapter->add(make_shared<FinderI>(uncheckedCast<TopicManagerPrx>(topicAdapter->createProxy(topicManagerId))), stringToIdentity("IceStorm/Finder")); topicAdapter->activate(); @@ -398,12 +383,12 @@ ServiceI::start( } void -ServiceI::start(const CommunicatorPtr& communicator, - const ObjectAdapterPtr& topicAdapter, - const ObjectAdapterPtr& publishAdapter, +ServiceI::start(const shared_ptr<Communicator>& communicator, + const shared_ptr<ObjectAdapter>& topicAdapter, + const shared_ptr<ObjectAdapter>& publishAdapter, const string& name, - const Ice::Identity& id, - const string& /*dbEnv*/) + const Identity& id, + const string&) { // // For IceGrid we don't validate the properties as all sorts of @@ -414,12 +399,12 @@ ServiceI::start(const CommunicatorPtr& communicator, // This is for IceGrid only and as such we use a transient // implementation of IceStorm. string instanceName = communicator->getProperties()->getPropertyWithDefault(name + ".InstanceName", "IceStorm"); - _instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter, 0); + _instance = make_shared<Instance>(instanceName, name, communicator, publishAdapter, topicAdapter, nullptr); try { - TransientTopicManagerImplPtr manager = new TransientTopicManagerImpl(_instance); - _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(manager, id)); + auto manager = make_shared<TransientTopicManagerImpl>(_instance); + _managerProxy = uncheckedCast<TopicManagerPrx>(topicAdapter->add(manager, id)); } catch(const Ice::Exception& ex) { @@ -432,7 +417,7 @@ ServiceI::start(const CommunicatorPtr& communicator, } } -TopicManagerPrx +shared_ptr<TopicManagerPrx> ServiceI::getTopicManager() const { return _managerProxy; @@ -463,7 +448,7 @@ ServiceI::stop() } void -ServiceI::validateProperties(const string& name, const PropertiesPtr& properties, const LoggerPtr& logger) +ServiceI::validateProperties(const string& name, const shared_ptr<Properties>& properties, const shared_ptr<Logger>& logger) { static const string suffixes[] = { diff --git a/cpp/src/IceStorm/Service.h b/cpp/src/IceStorm/Service.h index 11c7a80a2ad..84916bacf75 100644 --- a/cpp/src/IceStorm/Service.h +++ b/cpp/src/IceStorm/Service.h @@ -9,7 +9,7 @@ #include <IceStorm/IceStorm.h> // -// Automatically link with IceStormService[D|++11|++11D].lib +// Automatically link with IceStormService[D].lib // #if !defined(ICE_BUILDING_ICE_STORM_SERVICE) && defined(ICESTORM_SERVICE_API_EXPORTS) @@ -20,6 +20,7 @@ # pragma comment(lib, ICE_LIBNAME("IceStormService")) #endif +// These IceStorm APIs are exported because they are used by IceGrid #ifndef ICESTORM_SERVICE_API # if defined(ICE_STATIC_LIBS) # define ICESTORM_SERVICE_API /**/ @@ -30,30 +31,22 @@ # endif #endif -// This API is internal to Ice, and should not be used by external -// applications. +// This API is internal to Ice, and should not be used by external applications. namespace IceStormInternal { -class Service; -typedef ::IceInternal::Handle< IceStormInternal::Service> ServicePtr; - -class Service : public ::IceBox::Service +class Service : public IceBox::Service { public: - ICESTORM_SERVICE_API static ServicePtr create(const Ice::CommunicatorPtr&, - const Ice::ObjectAdapterPtr&, - const Ice::ObjectAdapterPtr&, - const std::string&, - const Ice::Identity&, - const std::string&); - - virtual void start(const std::string&, const Ice::CommunicatorPtr&, const Ice::StringSeq&) = 0; - - ICESTORM_SERVICE_API virtual IceStorm::TopicManagerPrx getTopicManager() const = 0; + ICESTORM_SERVICE_API static std::shared_ptr<Service> create(const std::shared_ptr<Ice::Communicator>&, + const std::shared_ptr<Ice::ObjectAdapter>&, + const std::shared_ptr<Ice::ObjectAdapter>&, + const std::string&, + const Ice::Identity&, + const std::string&); - virtual void stop() = 0; + ICESTORM_SERVICE_API virtual std::shared_ptr<IceStorm::TopicManagerPrx> getTopicManager() const = 0; }; }; diff --git a/cpp/src/IceStorm/Subscriber.cpp b/cpp/src/IceStorm/Subscriber.cpp index 9df599eec3c..9edfe04ea21 100644 --- a/cpp/src/IceStorm/Subscriber.cpp +++ b/cpp/src/IceStorm/Subscriber.cpp @@ -21,54 +21,45 @@ using namespace IceStormElection; namespace { -class PerSubscriberPublisherI : public Ice::BlobjectArray +class PerSubscriberPublisherI final : public Ice::BlobjectArray { public: - PerSubscriberPublisherI(const InstancePtr& instance) : - _instance(instance) + PerSubscriberPublisherI(shared_ptr<Instance> instance) : + _instance(move(instance)) { } void - setSubscriber(const SubscriberPtr& subscriber) + setSubscriber(shared_ptr<Subscriber> subscriber) { - _subscriber = subscriber; + _subscriber = move(subscriber); } - virtual bool - ice_invoke(const pair<const Ice::Byte*, const Ice::Byte*>& inParams, + bool + ice_invoke(pair<const Ice::Byte*, const Ice::Byte*> inParams, vector<Ice::Byte>&, - const Ice::Current& current) + const Ice::Current& current) override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); - EventDataPtr event = new EventData( - current.operation, - current.mode, - Ice::ByteSeq(), - current.ctx); + EventData event = { current.operation, current.mode, Ice::ByteSeq(), current.ctx }; - // - // COMPILERBUG: gcc 4.0.1 doesn't like this. - // - //event->data.swap(Ice::ByteSeq(inParams.first, inParams.second)); Ice::ByteSeq data(inParams.first, inParams.second); - event->data.swap(data); + event.data.swap(data); EventDataSeq e; - e.push_back(event); - _subscriber->queue(false, e); + e.push_back(move(event)); + _subscriber->queue(false, move(e)); return true; } private: - const InstancePtr _instance; - /*const*/ SubscriberPtr _subscriber; + const shared_ptr<Instance> _instance; + shared_ptr<Subscriber> _subscriber; }; -typedef IceUtil::Handle<PerSubscriberPublisherI> PerSubscriberPublisherIPtr; IceStorm::Instrumentation::SubscriberState toSubscriberState(Subscriber::SubscriberState s) @@ -76,15 +67,15 @@ toSubscriberState(Subscriber::SubscriberState s) switch(s) { case Subscriber::SubscriberStateOnline: - return IceStorm::Instrumentation::SubscriberStateOnline; + return IceStorm::Instrumentation::SubscriberState::SubscriberStateOnline; case Subscriber::SubscriberStateOffline: - return IceStorm::Instrumentation::SubscriberStateOffline; + return IceStorm::Instrumentation::SubscriberState::SubscriberStateOffline; case Subscriber::SubscriberStateError: case Subscriber::SubscriberStateReaped: - return IceStorm::Instrumentation::SubscriberStateError; + return IceStorm::Instrumentation::SubscriberState::SubscriberStateError; default: assert(false); - return IceStorm::Instrumentation::SubscriberStateError; + return IceStorm::Instrumentation::SubscriberState::SubscriberStateError; } } @@ -94,231 +85,64 @@ toSubscriberState(Subscriber::SubscriberState s) namespace { -class SubscriberBatch : public Subscriber -{ -public: - - SubscriberBatch(const InstancePtr&, const SubscriberRecord&, const Ice::ObjectPrx&, int, const Ice::ObjectPrx&); - - virtual void flush(); - - void exception(const Ice::Exception& ex) - { - error(false, ex); - } - - void doFlush(); - void sent(bool); - -private: - - const Ice::ObjectPrx _obj; - const IceUtil::Time _interval; -}; -typedef IceUtil::Handle<SubscriberBatch> SubscriberBatchPtr; - -class SubscriberOneway : public Subscriber -{ -public: - - SubscriberOneway(const InstancePtr&, const SubscriberRecord&, const Ice::ObjectPrx&, int, const Ice::ObjectPrx&); - - virtual void flush(); - - void exception(const Ice::Exception& ex) - { - error(true, ex); - } - void sent(bool); - -private: - - const Ice::ObjectPrx _obj; -}; -typedef IceUtil::Handle<SubscriberOneway> SubscriberOnewayPtr; - -class SubscriberTwoway : public Subscriber +class SubscriberOneway final : public Subscriber { public: - SubscriberTwoway(const InstancePtr&, const SubscriberRecord&, const Ice::ObjectPrx&, int, int, - const Ice::ObjectPrx&); + SubscriberOneway(const shared_ptr<Instance>&, const SubscriberRecord&, + const shared_ptr<Ice::ObjectPrx>&, int, shared_ptr<Ice::ObjectPrx>); - virtual void flush(); + void flush() override; + void sentAsynchronously(); private: - const Ice::ObjectPrx _obj; + const shared_ptr<Ice::ObjectPrx> _obj; }; -class SubscriberLink : public Subscriber +class SubscriberTwoway final : public Subscriber { public: - SubscriberLink(const InstancePtr&, const SubscriberRecord&); + SubscriberTwoway(const shared_ptr<Instance>&, const SubscriberRecord&, const shared_ptr<Ice::ObjectPrx>&, int, int, + shared_ptr<Ice::ObjectPrx>); - virtual void flush(); + void flush() override; private: - const TopicLinkPrx _obj; + const shared_ptr<Ice::ObjectPrx> _obj; }; -class FlushTimerTask : public IceUtil::TimerTask +class SubscriberLink final : public Subscriber { public: - FlushTimerTask(const SubscriberBatchPtr& subscriber) : - _subscriber(subscriber) - { - } + SubscriberLink(const shared_ptr<Instance>&, const SubscriberRecord&); - virtual void - runTimerTask() - { - _subscriber->doFlush(); - } + void flush() override; private: - const SubscriberBatchPtr _subscriber; + const shared_ptr<TopicLinkPrx> _obj; }; } -SubscriberBatch::SubscriberBatch( - const InstancePtr& instance, - const SubscriberRecord& rec, - const Ice::ObjectPrx& proxy, - int retryCount, - const Ice::ObjectPrx& obj) : - Subscriber(instance, rec, proxy, retryCount, 1), - _obj(obj), - _interval(instance->flushInterval()) -{ -} - -void -SubscriberBatch::flush() -{ - if(_state != SubscriberStateOnline || _events.empty()) - { - return; - } - - if(_outstanding == 0) - { - ++_outstanding; - _instance->batchFlusher()->schedule(new FlushTimerTask(this), _interval); - } -} - -void -SubscriberBatch::doFlush() -{ - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); - - // - // If the subscriber isn't online we're done. - // - if(_state != SubscriberStateOnline) - { - return; - } - - EventDataSeq v; - v.swap(_events); - assert(!v.empty()); - - if(_observer) - { - _outstandingCount = static_cast<Ice::Int>(v.size()); - _observer->outstanding(_outstandingCount); - } - - try - { - vector<Ice::Byte> dummy; - for(EventDataSeq::const_iterator p = v.begin(); p != v.end(); ++p) - { - _obj->ice_invoke((*p)->op, (*p)->mode, (*p)->data, dummy, (*p)->context); - } - - Ice::AsyncResultPtr result = _obj->begin_ice_flushBatchRequests( - Ice::newCallback_Object_ice_flushBatchRequests(this, - &SubscriberBatch::exception, - &SubscriberBatch::sent)); - if(result->sentSynchronously()) - { - --_outstanding; - assert(_outstanding == 0); - if(_observer) - { - _observer->delivered(_outstandingCount); - } - } - } - catch(const Ice::Exception& ex) - { - error(false, ex); - return; - } - - if(_events.empty() && _outstanding == 0 && _shutdown) - { - _lock.notify(); - } - - // This is significantly faster than the async version, but it can - // block the calling thread. Bad news! - - //_obj->ice_flushBatchRequests(); -} - -void -SubscriberBatch::sent(bool sentSynchronously) -{ - if(sentSynchronously) - { - return; - } - - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); - - // Decrement the _outstanding count. - --_outstanding; - assert(_outstanding == 0); - if(_observer) - { - _observer->delivered(_outstandingCount); - } - - if(_events.empty() && _outstanding == 0 && _shutdown) - { - _lock.notify(); - } - else if(!_events.empty()) - { - flush(); - } - -} - -SubscriberOneway::SubscriberOneway( - const InstancePtr& instance, - const SubscriberRecord& rec, - const Ice::ObjectPrx& proxy, - int retryCount, - const Ice::ObjectPrx& obj) : +SubscriberOneway::SubscriberOneway(const shared_ptr<Instance>& instance, + const SubscriberRecord& rec, + const shared_ptr<Ice::ObjectPrx>& proxy, + int retryCount, + shared_ptr<Ice::ObjectPrx> obj) : Subscriber(instance, rec, proxy, retryCount, 5), - _obj(obj) + _obj(move(obj)) { } void SubscriberOneway::flush() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); // // If the subscriber isn't online we're done. @@ -335,8 +159,8 @@ SubscriberOneway::flush() // Dequeue the head event, count one more outstanding AMI // request. // - EventDataPtr e = _events.front(); - _events.erase(_events.begin()); + EventData e = move(_events.front()); + _events.pop_front(); if(_observer) { _observer->outstanding(1); @@ -344,11 +168,35 @@ SubscriberOneway::flush() try { - Ice::AsyncResultPtr result = _obj->begin_ice_invoke( - e->op, e->mode, e->data, e->context, Ice::newCallback_Object_ice_invoke(this, - &SubscriberOneway::exception, - &SubscriberOneway::sent)); - if(!result->sentSynchronously()) + auto self = static_pointer_cast<SubscriberOneway>(shared_from_this()); + auto isSent = make_shared<promise<bool>>(); + auto future = isSent->get_future(); + + _obj->ice_invokeAsync(e.op, e.mode, e.data, nullptr, + [self](exception_ptr ex) + { + self->error(true, ex); + }, + [self, isSent](bool sentSynchronously) + { + isSent->set_value(sentSynchronously); + if(!sentSynchronously) + { + self->sentAsynchronously(); + } + }, + e.context); + + // + // Check if the request is (or potentially was) sent asynchronously + // + // If the request was sent synchronously then the isSent promise will have been set during the call + // to ice_invokeAsync (sent callback is called immediately after sending from the current thread). + // + // Otherwise if the request was sent asynchronously but quick enough so that the isSent promise is already + // fulfilled, we need to verify the sent callback's sentSynchronously value + // + if(future.wait_for(0s) != future_status::ready || future.get() == false) { ++_outstanding; } @@ -357,28 +205,23 @@ SubscriberOneway::flush() _observer->delivered(1); } } - catch(const Ice::Exception& ex) + catch(const std::exception&) { - error(true, ex); + error(false, current_exception()); return; } } if(_events.empty() && _outstanding == 0 && _shutdown) { - _lock.notify(); + _condVar.notify_one(); } } void -SubscriberOneway::sent(bool sentSynchronously) +SubscriberOneway::sentAsynchronously() { - if(sentSynchronously) - { - return; - } - - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); // Decrement the _outstanding count. --_outstanding; @@ -390,7 +233,7 @@ SubscriberOneway::sent(bool sentSynchronously) if(_events.empty() && _outstanding == 0 && _shutdown) { - _lock.notify(); + _condVar.notify_one(); } else if(_outstanding <= 0 && !_events.empty()) { @@ -398,22 +241,21 @@ SubscriberOneway::sent(bool sentSynchronously) } } -SubscriberTwoway::SubscriberTwoway( - const InstancePtr& instance, - const SubscriberRecord& rec, - const Ice::ObjectPrx& proxy, - int retryCount, - int maxOutstanding, - const Ice::ObjectPrx& obj) : +SubscriberTwoway::SubscriberTwoway(const shared_ptr<Instance>& instance, + const SubscriberRecord& rec, + const shared_ptr<Ice::ObjectPrx>& proxy, + int retryCount, + int maxOutstanding, + shared_ptr<Ice::ObjectPrx> obj) : Subscriber(instance, rec, proxy, retryCount, maxOutstanding), - _obj(obj) + _obj(move(obj)) { } void SubscriberTwoway::flush() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); // // If the subscriber isn't online we're done. @@ -430,9 +272,11 @@ SubscriberTwoway::flush() // Dequeue the head event, count one more outstanding AMI // request. // - EventDataPtr e = _events.front(); - _events.erase(_events.begin()); + EventData e = move(_events.front()); + _events.pop_front(); + ++_outstanding; + if(_observer) { _observer->outstanding(1); @@ -440,12 +284,21 @@ SubscriberTwoway::flush() try { - _obj->begin_ice_invoke(e->op, e->mode, e->data, e->context, - Ice::newCallback(static_cast<Subscriber*>(this), &Subscriber::completed)); + auto self = static_pointer_cast<SubscriberTwoway>(shared_from_this()); + _obj->ice_invokeAsync(e.op, e.mode, e.data, + [self](bool, vector<Ice::Byte>) + { + self->completed(); + }, + [self](exception_ptr ex) + { + self->error(true, ex); + }, + nullptr, e.context); } - catch(const Ice::Exception& ex) + catch(const std::exception&) { - error(true, ex); + error(true, current_exception()); return; } } @@ -454,18 +307,18 @@ SubscriberTwoway::flush() namespace { -SubscriberLink::SubscriberLink( - const InstancePtr& instance, - const SubscriberRecord& rec) : +SubscriberLink::SubscriberLink(const shared_ptr<Instance>& instance, + const SubscriberRecord& rec) : Subscriber(instance, rec, 0, -1, 1), - _obj(TopicLinkPrx::uncheckedCast(rec.obj->ice_collocationOptimized(false)->ice_timeout(instance->sendTimeout()))) + _obj(Ice::uncheckedCast<TopicLinkPrx>( + rec.obj->ice_collocationOptimized(false)->ice_timeout(static_cast<int>(instance->sendTimeout().count())))) { } void SubscriberLink::flush() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); if(_state != SubscriberStateOnline || _outstanding > 0) { @@ -475,16 +328,23 @@ SubscriberLink::flush() EventDataSeq v; v.swap(_events); - EventDataSeq::iterator p = v.begin(); + auto p = v.begin(); while(p != v.end()) { if(_rec.cost != 0) { int cost = 0; - Ice::Context::const_iterator q = (*p)->context.find("cost"); - if(q != (*p)->context.end()) + auto q = p->context.find("cost"); + if(q != p->context.end()) { - cost = atoi(q->second.c_str()); + try + { + cost = stoi(q->second); + } + catch(const std::invalid_argument&) + { + cost = 0; + } } if(cost > _rec.cost) { @@ -502,39 +362,48 @@ SubscriberLink::flush() ++_outstanding; if(_observer) { - _outstandingCount = static_cast<Ice::Int>(v.size()); + _outstandingCount = static_cast<int>(v.size()); _observer->outstanding(_outstandingCount); } - _obj->begin_forward(v, Ice::newCallback(static_cast<Subscriber*>(this), &Subscriber::completed)); + + auto self = static_pointer_cast<SubscriberLink>(shared_from_this()); + _obj->forwardAsync(v, + [self] + { + self->completed(); + }, + [self](exception_ptr ex) + { + self->error(true, ex); + }); } - catch(const Ice::Exception& ex) + catch(const std::exception&) { - error(true, ex); + error(true, current_exception()); } } } } -SubscriberPtr -Subscriber::create( - const InstancePtr& instance, - const SubscriberRecord& rec) +shared_ptr<Subscriber> +Subscriber::create(const shared_ptr<Instance>& instance, + const SubscriberRecord& rec) { if(rec.link) { - return new SubscriberLink(instance, rec); + return make_shared<SubscriberLink>(instance, rec); } else { - PerSubscriberPublisherIPtr per = new PerSubscriberPublisherI(instance); + auto per = make_shared<PerSubscriberPublisherI>(instance); Ice::Identity perId; perId.category = instance->instanceName(); perId.name = "topic." + rec.topicName + ".publish." + instance->communicator()->identityToString(rec.obj->ice_getIdentity()); - Ice::ObjectPrx proxy = instance->publishAdapter()->add(per, perId); - TraceLevelsPtr traceLevels = instance->traceLevels(); - SubscriberPtr subscriber; + auto proxy = instance->publishAdapter()->add(per, perId); + auto traceLevels = instance->traceLevels(); + shared_ptr<Subscriber> subscriber; try { @@ -559,10 +428,10 @@ Subscriber::create( // // Override the timeout. // - Ice::ObjectPrx newObj; + shared_ptr<Ice::ObjectPrx> newObj; try { - newObj = rec.obj->ice_timeout(instance->sendTimeout()); + newObj = rec.obj->ice_timeout(static_cast<int>(instance->sendTimeout().count())); } catch(const Ice::FixedProxyException&) { @@ -598,26 +467,33 @@ Subscriber::create( newObj = newObj->ice_connectionCached(connectionCached > 0); } + if(newObj->ice_isBatchOneway()) + { + // Use Oneway in case of Batch Oneway + newObj = newObj->ice_oneway(); + } + else if(newObj->ice_isBatchDatagram()) + { + // Use Datagram in case of Batch Datagram + newObj = newObj->ice_datagram(); + } + if(reliability == "ordered") { if(!newObj->ice_isTwoway()) { throw BadQoS("ordered reliability requires a twoway proxy"); } - subscriber = new SubscriberTwoway(instance, rec, proxy, retryCount, 1, newObj); + subscriber = make_shared<SubscriberTwoway>(instance, rec, proxy, retryCount, 1, newObj); } else if(newObj->ice_isOneway() || newObj->ice_isDatagram()) { - subscriber = new SubscriberOneway(instance, rec, proxy, retryCount, newObj); - } - else if(newObj->ice_isBatchOneway() || newObj->ice_isBatchDatagram()) - { - subscriber = new SubscriberBatch(instance, rec, proxy, retryCount, newObj); + subscriber = make_shared<SubscriberOneway>(instance, rec, proxy, retryCount, newObj); } else //if(newObj->ice_isTwoway()) { assert(newObj->ice_isTwoway()); - subscriber = new SubscriberTwoway(instance, rec, proxy, retryCount, 5, newObj); + subscriber = make_shared<SubscriberTwoway>(instance, rec, proxy, retryCount, 5, newObj); } per->setSubscriber(subscriber); } @@ -631,7 +507,7 @@ Subscriber::create( } } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> Subscriber::proxy() const { return _proxyReplica; @@ -652,7 +528,7 @@ Subscriber::record() const bool Subscriber::queue(bool forwarded, const EventDataSeq& events) { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); // If this is a link subscriber if the set of events were // forwarded from another IceStorm instance then do not queue the @@ -666,7 +542,7 @@ Subscriber::queue(bool forwarded, const EventDataSeq& events) { case SubscriberStateOffline: { - if(IceUtil::Time::now(IceUtil::Time::Monotonic) < _next) + if(chrono::steady_clock::now() < _next) { break; } @@ -686,7 +562,7 @@ Subscriber::queue(bool forwarded, const EventDataSeq& events) { if(_instance->sendQueueSizeMaxPolicy() == Instance::RemoveSubscriber) { - error(false, IceStorm::SendQueueSizeMaxReached(__FILE__, __LINE__)); + error(false, make_exception_ptr(SendQueueSizeMaxReached(__FILE__, __LINE__))); return false; } else // DropEvents @@ -717,7 +593,7 @@ Subscriber::queue(bool forwarded, const EventDataSeq& events) bool Subscriber::reap() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); assert(_state >= SubscriberStateError); if(_state == SubscriberStateError) { @@ -730,7 +606,8 @@ Subscriber::reap() void Subscriber::resetIfReaped() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); + if(_state == SubscriberStateReaped) { setState(SubscriberStateError); @@ -740,7 +617,8 @@ Subscriber::resetIfReaped() bool Subscriber::errored() const { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); + return _state >= SubscriberStateError; } @@ -766,14 +644,43 @@ Subscriber::destroy() } } - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); _observer.detach(); } void -Subscriber::error(bool dec, const Ice::Exception& e) +Subscriber::completed() +{ + lock_guard<recursive_mutex> lg(_mutex); + + // Decrement the _outstanding count. + --_outstanding; + assert(_outstanding >= 0 && _outstanding < _maxOutstanding); + if(_observer) + { + _observer->delivered(_outstandingCount); + } + + // + // A successful response means we're no longer retrying, we're + // back active. + // + _currentRetry = 0; + + if(_events.empty() && _outstanding == 0 && _shutdown) + { + _condVar.notify_one(); + } + else + { + flush(); + } +} + +void +Subscriber::error(bool dec, exception_ptr e) { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); if(dec) { @@ -790,16 +697,38 @@ Subscriber::error(bool dec, const Ice::Exception& e) { if(_shutdown) { - _lock.notify(); + _condVar.notify_one(); } return; } - // A hard error is an ObjectNotExistException or - // NotRegisteredException. - bool hardError = dynamic_cast<const Ice::ObjectNotExistException*>(&e) || - dynamic_cast<const Ice::NotRegisteredException*>(&e) || - dynamic_cast<const IceStorm::SendQueueSizeMaxReached*>(&e); + // A hard error is an ObjectNotExistException, NotRegisteredException, or SendQueueSizeMaxReached + bool hardError; + string what; + try + { + rethrow_exception(e); + } + catch(const Ice::ObjectNotExistException& ex) + { + hardError = true; + what = ex.what(); + } + catch(const Ice::NotRegisteredException& ex) + { + hardError = true; + what = ex.what(); + } + catch(const SendQueueSizeMaxReached& ex) + { + hardError = true; + what = ex.what(); + } + catch(const std::exception& ex) + { + hardError = false; + what = ex.what(); + } // // A twoway subscriber can queue multiple send events and @@ -807,7 +736,7 @@ Subscriber::error(bool dec, const Ice::Exception& e) // replies if we're retrying and its not yet time to process the // next request. // - IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic); + auto now = std::chrono::steady_clock::now(); if(!hardError && _state == SubscriberStateOffline && now < _next) { return; @@ -822,7 +751,7 @@ Subscriber::error(bool dec, const Ice::Exception& e) { assert(_state < SubscriberStateError); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(_currentRetry == 0) { Ice::Warning warn(traceLevels->logger); @@ -831,8 +760,8 @@ Subscriber::error(bool dec, const Ice::Exception& e) { warn << " endpoints: " << IceStormInternal::describeEndpoints(_rec.obj); } - warn << " subscriber offline: " << e - << " discarding events: " << _instance->discardInterval() << "s retryCount: " << _retryCount; + warn << " subscriber offline: " << what + << " discarding events: " << _instance->discardInterval().count() << "s retryCount: " << _retryCount; } else { @@ -844,8 +773,8 @@ Subscriber::error(bool dec, const Ice::Exception& e) { out << " endpoints: " << IceStormInternal::describeEndpoints(_rec.obj); } - out << " subscriber offline: " << e - << " discarding events: " << _instance->discardInterval() << "s retry: " + out << " subscriber offline: " << what + << " discarding events: " << _instance->discardInterval().count() << "s retry: " << _currentRetry << "/" << _retryCount; } } @@ -863,7 +792,7 @@ Subscriber::error(bool dec, const Ice::Exception& e) _events.clear(); setState(SubscriberStateError); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->subscriber > 0) { Ice::Trace out(traceLevels->logger, traceLevels->subscriberCat); @@ -872,64 +801,26 @@ Subscriber::error(bool dec, const Ice::Exception& e) { out << " endpoints: " << IceStormInternal::describeEndpoints(_rec.obj); } - out << " subscriber errored out: " << e + out << " subscriber errored out: " << what << " retry: " << _currentRetry << "/" << _retryCount; } } if(_shutdown && _events.empty()) { - _lock.notify(); - } -} - -void -Subscriber::completed(const Ice::AsyncResultPtr& result) -{ - try - { - result->throwLocalException(); - - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); - - // Decrement the _outstanding count. - --_outstanding; - assert(_outstanding >= 0 && _outstanding < _maxOutstanding); - if(_observer) - { - _observer->delivered(_outstandingCount); - } - - // - // A successful response means we're no longer retrying, we're - // back active. - // - _currentRetry = 0; - - if(_events.empty() && _outstanding == 0 && _shutdown) - { - _lock.notify(); - } - else - { - flush(); - } - } - catch(const Ice::LocalException& ex) - { - error(true, ex); + _condVar.notify_one(); } } void Subscriber::shutdown() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + unique_lock<recursive_mutex> lock(_mutex); _shutdown = true; while(_outstanding > 0 && !_events.empty()) { - _lock.wait(); + _condVar.wait(lock); } _observer.detach(); @@ -938,7 +829,8 @@ Subscriber::shutdown() void Subscriber::updateObserver() { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock); + lock_guard<recursive_mutex> lg(_mutex); + if(_instance->observer()) { _observer.attach(_instance->observer()->getSubscriberObserver(_instance->serviceName(), @@ -951,18 +843,17 @@ Subscriber::updateObserver() } } -Subscriber::Subscriber( - const InstancePtr& instance, - const SubscriberRecord& rec, - const Ice::ObjectPrx& proxy, - int retryCount, - int maxOutstanding) : - _instance(instance), - _rec(rec), +Subscriber::Subscriber(shared_ptr<Instance> instance, + SubscriberRecord rec, + shared_ptr<Ice::ObjectPrx> proxy, + int retryCount, + int maxOutstanding) : + _instance(move(instance)), + _rec(move(rec)), _retryCount(retryCount), _maxOutstanding(maxOutstanding), - _proxy(proxy), - _proxyReplica(proxy), + _proxy(move(proxy)), + _proxyReplica(_proxy), _shutdown(false), _state(SubscriberStateOnline), _outstanding(0), @@ -971,17 +862,17 @@ Subscriber::Subscriber( { if(_proxy && _instance->publisherReplicaProxy()) { - const_cast<Ice::ObjectPrx&>(_proxyReplica) = + const_cast<shared_ptr<Ice::ObjectPrx>&>(_proxyReplica) = _instance->publisherReplicaProxy()->ice_identity(_proxy->ice_getIdentity()); } if(_instance->observer()) { _observer.attach(_instance->observer()->getSubscriberObserver(_instance->serviceName(), - rec.topicName, - rec.obj, - rec.theQoS, - rec.theTopic, + _rec.topicName, + _rec.obj, + _rec.theQoS, + _rec.theTopic, toSubscriberState(_state), 0)); } @@ -1015,7 +906,7 @@ Subscriber::setState(Subscriber::SubscriberState state) { if(state != _state) { - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->subscriber > 1) { Ice::Trace out(traceLevels->logger, traceLevels->subscriberCat); @@ -1038,7 +929,7 @@ Subscriber::setState(Subscriber::SubscriberState state) } bool -IceStorm::operator==(const SubscriberPtr& subscriber, const Ice::Identity& id) +IceStorm::operator==(const shared_ptr<Subscriber>& subscriber, const Ice::Identity& id) { return subscriber->id() == id; } diff --git a/cpp/src/IceStorm/Subscriber.h b/cpp/src/IceStorm/Subscriber.h index af5cc721f69..a192d11e0e8 100644 --- a/cpp/src/IceStorm/Subscriber.h +++ b/cpp/src/IceStorm/Subscriber.h @@ -9,24 +9,21 @@ #include <IceStorm/SubscriberRecord.h> #include <IceStorm/Instrumentation.h> #include <Ice/ObserverHelper.h> -#include <IceUtil/RecMutex.h> + +#include<condition_variable> namespace IceStorm { class Instance; -typedef IceUtil::Handle<Instance> InstancePtr; - -class Subscriber; -typedef IceUtil::Handle<Subscriber> SubscriberPtr; -class Subscriber : public IceUtil::Shared +class Subscriber : public std::enable_shared_from_this<Subscriber> { public: - static SubscriberPtr create(const InstancePtr&, const IceStorm::SubscriberRecord&); + static std::shared_ptr<Subscriber> create(const std::shared_ptr<Instance>&, const IceStorm::SubscriberRecord&); - Ice::ObjectPrx proxy() const; // Get the per subscriber object. + std::shared_ptr<Ice::ObjectPrx> proxy() const; // Get the per subscriber object. Ice::Identity id() const; // Return the id of the subscriber. IceStorm::SubscriberRecord record() const; // Get the subscriber record. @@ -39,8 +36,8 @@ public: void destroy(); // To be called by the AMI callbacks only. - void completed(const Ice::AsyncResultPtr&); - void error(bool, const Ice::Exception&); + void completed(); + void error(bool, std::exception_ptr); void shutdown(); @@ -60,17 +57,18 @@ protected: void setState(SubscriberState); - Subscriber(const InstancePtr&, const IceStorm::SubscriberRecord&, const Ice::ObjectPrx&, int, int); + Subscriber(std::shared_ptr<Instance>, IceStorm::SubscriberRecord, std::shared_ptr<Ice::ObjectPrx>, int, int); // Immutable - const InstancePtr _instance; + const std::shared_ptr<Instance> _instance; const IceStorm::SubscriberRecord _rec; // The subscriber record. const int _retryCount; // The retryCount. const int _maxOutstanding; // The maximum number of oustanding events. - const Ice::ObjectPrx _proxy; // The per subscriber object proxy, if any. - const Ice::ObjectPrx _proxyReplica; // The replicated per subscriber object proxy, if any. + const std::shared_ptr<Ice::ObjectPrx> _proxy; // The per subscriber object proxy, if any. + const std::shared_ptr<Ice::ObjectPrx> _proxyReplica; // The replicated per subscriber object proxy, if any. - IceUtil::Monitor<IceUtil::RecMutex> _lock; + mutable std::recursive_mutex _mutex; + std::condition_variable_any _condVar; bool _shutdown; @@ -81,13 +79,13 @@ protected: EventDataSeq _events; // The queue of events to send. // The next time to try sending a new event if we're offline. - IceUtil::Time _next; + std::chrono::steady_clock::time_point _next; int _currentRetry; IceInternal::ObserverHelperT<IceStorm::Instrumentation::SubscriberObserver> _observer; }; -bool operator==(const IceStorm::SubscriberPtr&, const Ice::Identity&); +bool operator==(const std::shared_ptr<IceStorm::Subscriber>&, const Ice::Identity&); bool operator==(const IceStorm::Subscriber&, const IceStorm::Subscriber&); bool operator!=(const IceStorm::Subscriber&, const IceStorm::Subscriber&); bool operator<(const IceStorm::Subscriber&, const IceStorm::Subscriber&); diff --git a/cpp/src/IceStorm/TopicI.cpp b/cpp/src/IceStorm/TopicI.cpp index 480189c6387..5dcaff63153 100644 --- a/cpp/src/IceStorm/TopicI.cpp +++ b/cpp/src/IceStorm/TopicI.cpp @@ -21,7 +21,7 @@ namespace { void -logError(const Ice::CommunicatorPtr& com, const IceDB::LMDBException& ex) +logError(const shared_ptr<Ice::Communicator>& com, const IceDB::LMDBException& ex) { Ice::Error error(com->getLogger()); error << "LMDB error: " << ex; @@ -35,28 +35,24 @@ class PublisherI : public Ice::BlobjectArray { public: - PublisherI(const TopicImplPtr& topic, const PersistentInstancePtr& instance) : - _topic(topic), _instance(instance) + PublisherI(shared_ptr<TopicImpl> topic, shared_ptr<PersistentInstance> instance) : + _topic(move(topic)), _instance(move(instance)) { } - virtual bool - ice_invoke(const pair<const Ice::Byte*, const Ice::Byte*>& inParams, + bool + ice_invoke(pair<const Ice::Byte*, const Ice::Byte*> inParams, Ice::ByteSeq&, - const Ice::Current& current) + const Ice::Current& current) override { // The publish call does a cached read. - EventDataPtr event = new EventData(current.operation, current.mode, Ice::ByteSeq(), current.ctx); + EventData event = { current.operation, current.mode, Ice::ByteSeq(), current.ctx }; - // - // COMPILERBUG: gcc 4.0.1 doesn't like this. - // - //event->data.swap(Ice::ByteSeq(inParams.first, inParams.second)); Ice::ByteSeq data(inParams.first, inParams.second); - event->data.swap(data); + event.data = move(data); EventDataSeq v; - v.push_back(event); + v.push_back(move(event)); _topic->publish(false, v); return true; @@ -64,8 +60,8 @@ public: private: - const TopicImplPtr _topic; - const PersistentInstancePtr _instance; + const shared_ptr<TopicImpl> _topic; + const shared_ptr<PersistentInstance> _instance; }; // @@ -76,66 +72,66 @@ class TopicLinkI : public TopicLink { public: - TopicLinkI(const TopicImplPtr& impl, const PersistentInstancePtr& instance) : - _impl(impl), _instance(instance) + TopicLinkI(shared_ptr<TopicImpl> impl, shared_ptr<PersistentInstance> instance) : + _impl(move(impl)), _instance(move(instance)) { } - virtual void - forward(const EventDataSeq& v, const Ice::Current& /*current*/) + void + forward(EventDataSeq v, const Ice::Current&) override { // The publish call does a cached read. - _impl->publish(true, v); + _impl->publish(true, move(v)); } private: - const TopicImplPtr _impl; - const PersistentInstancePtr _instance; + const shared_ptr<TopicImpl> _impl; + const shared_ptr<PersistentInstance> _instance; }; class TopicI : public TopicInternal { public: - TopicI(const TopicImplPtr& impl, const PersistentInstancePtr& instance) : - _impl(impl), _instance(instance) + TopicI(shared_ptr<TopicImpl> impl, shared_ptr<PersistentInstance> instance) : + _impl(move(impl)), _instance(move(instance)) { } - virtual string getName(const Ice::Current&) const + string getName(const Ice::Current&) const override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); return _impl->getName(); } - virtual Ice::ObjectPrx getPublisher(const Ice::Current&) const + shared_ptr<Ice::ObjectPrx> getPublisher(const Ice::Current&) const override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); return _impl->getPublisher(); } - virtual Ice::ObjectPrx getNonReplicatedPublisher(const Ice::Current&) const + shared_ptr<Ice::ObjectPrx> getNonReplicatedPublisher(const Ice::Current&) const override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); return _impl->getNonReplicatedPublisher(); } - virtual Ice::ObjectPrx subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj, - const Ice::Current& current) + shared_ptr<Ice::ObjectPrx> subscribeAndGetPublisher(QoS qos, shared_ptr<Ice::ObjectPrx> obj, + const Ice::Current& current) override { while(true) { Ice::Long generation = -1; - TopicPrx master = getMasterFor(current, generation, __FILE__, __LINE__); + auto master = getMasterFor(current, generation, __FILE__, __LINE__); if(master) { try { - return master->subscribeAndGetPublisher(qos, obj); + return master->subscribeAndGetPublisher(move(qos), move(obj)); } catch(const Ice::ConnectFailedException&) { @@ -151,22 +147,22 @@ public: else { FinishUpdateHelper unlock(_instance->node()); - return _impl->subscribeAndGetPublisher(qos, obj); + return _impl->subscribeAndGetPublisher(move(qos), move(obj)); } } } - virtual void unsubscribe(const Ice::ObjectPrx& subscriber, const Ice::Current& current) + void unsubscribe(shared_ptr<Ice::ObjectPrx> subscriber, const Ice::Current& current) override { while(true) { Ice::Long generation = -1; - TopicPrx master = getMasterFor(current, generation, __FILE__, __LINE__); + auto master = getMasterFor(current, generation, __FILE__, __LINE__); if(master) { try { - master->unsubscribe(subscriber); + master->unsubscribe(move(subscriber)); } catch(const Ice::ConnectFailedException&) { @@ -182,22 +178,22 @@ public: else { FinishUpdateHelper unlock(_instance->node()); - _impl->unsubscribe(subscriber); + _impl->unsubscribe(move(subscriber)); } break; } } - virtual TopicLinkPrx getLinkProxy(const Ice::Current&) + shared_ptr<TopicLinkPrx> getLinkProxy(const Ice::Current&) override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); return _impl->getLinkProxy(); } - virtual void reap(const Ice::IdentitySeq& ids, const Ice::Current& /*current*/) + void reap(Ice::IdentitySeq ids, const Ice::Current&) override { - NodeIPtr node = _instance->node(); + auto node = _instance->node(); if(!node->updateMaster(__FILE__, __LINE__)) { throw ReapWouldBlock(); @@ -206,17 +202,17 @@ public: _impl->reap(ids); } - virtual void link(const TopicPrx& topic, Ice::Int cost, const Ice::Current& current) + void link(shared_ptr<TopicPrx> topic, int cost, const Ice::Current& current) override { while(true) { Ice::Long generation = -1; - TopicPrx master = getMasterFor(current, generation, __FILE__, __LINE__); + auto master = getMasterFor(current, generation, __FILE__, __LINE__); if(master) { try { - master->link(topic, cost); + master->link(move(topic), cost); } catch(const Ice::ConnectFailedException&) { @@ -232,23 +228,23 @@ public: else { FinishUpdateHelper unlock(_instance->node()); - _impl->link(topic, cost); + _impl->link(move(topic), cost); } break; } } - virtual void unlink(const TopicPrx& topic, const Ice::Current& current) + void unlink(shared_ptr<TopicPrx> topic, const Ice::Current& current) override { while(true) { Ice::Long generation = -1; - TopicPrx master = getMasterFor(current, generation, __FILE__, __LINE__); + auto master = getMasterFor(current, generation, __FILE__, __LINE__); if(master) { try { - master->unlink(topic); + master->unlink(move(topic)); } catch(const Ice::ConnectFailedException&) { @@ -264,30 +260,30 @@ public: else { FinishUpdateHelper unlock(_instance->node()); - _impl->unlink(topic); + _impl->unlink(move(topic)); } break; } } - virtual LinkInfoSeq getLinkInfoSeq(const Ice::Current&) const + LinkInfoSeq getLinkInfoSeq(const Ice::Current&) const override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); return _impl->getLinkInfoSeq(); } - virtual Ice::IdentitySeq getSubscribers(const Ice::Current&) const + Ice::IdentitySeq getSubscribers(const Ice::Current&) const override { return _impl->getSubscribers(); } - virtual void destroy(const Ice::Current& current) + void destroy(const Ice::Current& current) override { while(true) { Ice::Long generation = -1; - TopicPrx master = getMasterFor(current, generation, __FILE__, __LINE__); + auto master = getMasterFor(current, generation, __FILE__, __LINE__); if(master) { try @@ -316,29 +312,72 @@ public: private: - TopicPrx getMasterFor(const Ice::Current& cur, Ice::Long& generation, const char* file, int line) const + shared_ptr<TopicPrx> getMasterFor(const Ice::Current& cur, Ice::Long& generation, const char* file, int line) const { - NodeIPtr node = _instance->node(); - Ice::ObjectPrx master; + auto node = _instance->node(); + shared_ptr<Ice::ObjectPrx> master; if(node) { master = _instance->node()->startUpdate(generation, file, line); } - return (master) ? TopicPrx::uncheckedCast(master->ice_identity(cur.id)) : TopicPrx(); + return master ? Ice::uncheckedCast<TopicPrx>(master->ice_identity(cur.id)) : nullptr; } - const TopicImplPtr _impl; - const PersistentInstancePtr _instance; + const shared_ptr<TopicImpl> _impl; + const shared_ptr<PersistentInstance> _instance; }; } -TopicImpl::TopicImpl( - const PersistentInstancePtr& instance, - const string& name, - const Ice::Identity& id, - const SubscriberRecordSeq& subscribers) : - _instance(instance), +shared_ptr<TopicImpl> +TopicImpl::create(shared_ptr<PersistentInstance> instance, + const string& name, + const Ice::Identity& id, + const SubscriberRecordSeq& subscribers) +{ + shared_ptr<TopicImpl> topicImpl(new TopicImpl(instance, name, id, subscribers)); + + topicImpl->_servant = make_shared<TopicI>(topicImpl, instance); + // + // Create a servant per topic to receive event data. If the + // category is empty then we are in backwards compatibility + // mode. In this case the servant's identity is + // category=<topicname>, name=publish, otherwise the name is + // <instancename>/<topicname>.publish. The same applies to the + // link proxy. + // + // Activate the object and save a reference to give to publishers. + // + Ice::Identity pubid; + Ice::Identity linkid; + if(id.category.empty()) + { + pubid.category = name; + pubid.name = "publish"; + linkid.category = name; + linkid.name = "link"; + } + else + { + pubid.category = id.category; + pubid.name = name + ".publish"; + linkid.category = id.category; + linkid.name = name + ".link"; + } + + auto publisher = make_shared<PublisherI>(topicImpl, instance); + topicImpl->_publisherPrx = instance->publishAdapter()->add(publisher, pubid); + auto topicLink = make_shared<TopicLinkI>(topicImpl, instance); + topicImpl->_linkPrx = Ice::uncheckedCast<TopicLinkPrx>(instance->publishAdapter()->add(topicLink, linkid)); + + return topicImpl; +} + +TopicImpl::TopicImpl(shared_ptr<PersistentInstance> instance, + const string& name, + const Ice::Identity& id, + const SubscriberRecordSeq& subscribers) : + _instance(move(instance)), _name(name), _id(id), _destroyed(false), @@ -347,57 +386,20 @@ TopicImpl::TopicImpl( { try { - __setNoDelete(true); - - // TODO: If we want to improve the performance of the - // non-replicated case we could allocate a null-topic impl here. - _servant = new TopicI(this, instance); - - // - // Create a servant per topic to receive event data. If the - // category is empty then we are in backwards compatibility - // mode. In this case the servant's identity is - // category=<topicname>, name=publish, otherwise the name is - // <instancename>/<topicname>.publish. The same applies to the - // link proxy. - // - // Activate the object and save a reference to give to publishers. - // - Ice::Identity pubid; - Ice::Identity linkid; - if(id.category.empty()) - { - pubid.category = _name; - pubid.name = "publish"; - linkid.category = _name; - linkid.name = "link"; - } - else - { - pubid.category = id.category; - pubid.name = _name + ".publish"; - linkid.category = id.category; - linkid.name = _name + ".link"; - } - - _publisherPrx = _instance->publishAdapter()->add(new PublisherI(this, instance), pubid); - _linkPrx = TopicLinkPrx::uncheckedCast( - _instance->publishAdapter()->add(new TopicLinkI(this, instance), linkid)); - // // Re-establish subscribers. // - for(SubscriberRecordSeq::const_iterator p = subscribers.begin(); p != subscribers.end(); ++p) + for(const auto& subscriber : subscribers) { - Ice::Identity ident = p->obj->ice_getIdentity(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + Ice::Identity ident = subscriber.obj->ice_getIdentity(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << " recreate " << _instance->communicator()->identityToString(ident); if(traceLevels->topic > 1) { - out << " endpoints: " << IceStormInternal::describeEndpoints(p->obj); + out << " endpoints: " << IceStormInternal::describeEndpoints(subscriber.obj); } } @@ -407,8 +409,7 @@ TopicImpl::TopicImpl( // Create the subscriber object add it to the set of // subscribers. // - SubscriberPtr subscriber = Subscriber::create(_instance, *p); - _subscribers.push_back(subscriber); + _subscribers.push_back(Subscriber::create(_instance, subscriber)); } catch(const Ice::Exception& ex) { @@ -416,7 +417,7 @@ TopicImpl::TopicImpl( out << _name << " recreate " << _instance->communicator()->identityToString(ident); if(traceLevels->topic > 1) { - out << " endpoints: " << IceStormInternal::describeEndpoints(p->obj); + out << " endpoints: " << IceStormInternal::describeEndpoints(subscriber.obj); } out << " failed: " << ex; } @@ -424,16 +425,14 @@ TopicImpl::TopicImpl( if(_instance->observer()) { - _observer.attach(_instance->observer()->getTopicObserver(_instance->serviceName(), _name, 0)); + _observer.attach(_instance->observer()->getTopicObserver(_instance->serviceName(), _name, nullptr)); } } - catch(...) + catch(const std::exception&) { shutdown(); - __setNoDelete(false); throw; } - __setNoDelete(false); } string @@ -443,7 +442,7 @@ TopicImpl::getName() const return _name; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> TopicImpl::getPublisher() const { // Immutable @@ -454,7 +453,7 @@ TopicImpl::getPublisher() const return _publisherPrx; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> TopicImpl::getNonReplicatedPublisher() const { // If there is an adapter id configured then we're using icegrid @@ -472,10 +471,10 @@ TopicImpl::getNonReplicatedPublisher() const namespace { void -trace(Ice::Trace& out, const PersistentInstancePtr& instance, const vector<SubscriberPtr>& s) +trace(Ice::Trace& out, const shared_ptr<PersistentInstance>& instance, const vector<shared_ptr<Subscriber>>& s) { out << '['; - for(vector<SubscriberPtr>::const_iterator p = s.begin(); p != s.end(); ++p) + for(auto p = s.cbegin(); p != s.cend(); ++p) { if(p != s.begin()) { @@ -487,12 +486,12 @@ trace(Ice::Trace& out, const PersistentInstancePtr& instance, const vector<Subsc } } -Ice::ObjectPrx -TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) +shared_ptr<Ice::ObjectPrx> +TopicImpl::subscribeAndGetPublisher(QoS qos, shared_ptr<Ice::ObjectPrx> obj) { if(!obj) { - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -500,9 +499,9 @@ TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) } throw InvalidSubscriber("subscriber is a null proxy"); } - Ice::Identity id = obj->ice_getIdentity(); + auto id = obj->ice_getIdentity(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -525,7 +524,7 @@ TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) } } - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); SubscriberRecord record; record.id = id; @@ -535,15 +534,14 @@ TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) record.link = false; record.cost = 0; - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); - if(p != _subscribers.end()) + if(find(_subscribers.begin(), _subscribers.end(), record.id) != _subscribers.end()) { throw AlreadySubscribed(); } LogUpdate llu; - SubscriberPtr subscriber = Subscriber::create(_instance, record); + auto subscriber = Subscriber::create(_instance, record); try { IceDB::ReadWriteTxn txn(_instance->dbEnv()); @@ -572,9 +570,9 @@ TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) } void -TopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber) +TopicImpl::unsubscribe(const shared_ptr<Ice::ObjectPrx>& subscriber) { - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(!subscriber) { if(traceLevels->topic > 0) @@ -599,31 +597,32 @@ TopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber) } } - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); + Ice::IdentitySeq ids; ids.push_back(id); removeSubscribers(ids); } -TopicLinkPrx +shared_ptr<TopicLinkPrx> TopicImpl::getLinkProxy() { // immutable if(_instance->publisherReplicaProxy()) { - return TopicLinkPrx::uncheckedCast(_instance->publisherReplicaProxy()->ice_identity( + return Ice::uncheckedCast<TopicLinkPrx>(_instance->publisherReplicaProxy()->ice_identity( _linkPrx->ice_getIdentity())); } return _linkPrx; } void -TopicImpl::link(const TopicPrx& topic, Ice::Int cost) +TopicImpl::link(const shared_ptr<TopicPrx>& topic, int cost) { - TopicInternalPrx internal = TopicInternalPrx::uncheckedCast(topic); - TopicLinkPrx link = internal->getLinkProxy(); + auto internal = Ice::uncheckedCast<TopicInternalPrx>(topic); + auto link = internal->getLinkProxy(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -631,7 +630,7 @@ TopicImpl::link(const TopicPrx& topic, Ice::Int cost) << " cost " << cost; } - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); Ice::Identity id = topic->ice_getIdentity(); @@ -643,8 +642,7 @@ TopicImpl::link(const TopicPrx& topic, Ice::Int cost) record.link = true; record.cost = cost; - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); - if(p != _subscribers.end()) + if(find(_subscribers.begin(), _subscribers.end(), record.id) != _subscribers.end()) { string name = IceStormInternal::identityToTopicName(id); throw LinkExists(name); @@ -652,7 +650,7 @@ TopicImpl::link(const TopicPrx& topic, Ice::Int cost) LogUpdate llu; - SubscriberPtr subscriber = Subscriber::create(_instance, record); + auto subscriber = Subscriber::create(_instance, record); try { @@ -680,9 +678,10 @@ TopicImpl::link(const TopicPrx& topic, Ice::Int cost) } void -TopicImpl::unlink(const TopicPrx& topic) +TopicImpl::unlink(const shared_ptr<TopicPrx>& topic) { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); @@ -690,11 +689,12 @@ TopicImpl::unlink(const TopicPrx& topic) Ice::Identity id = topic->ice_getIdentity(); - vector<SubscriberPtr>::const_iterator p = find(_subscribers.begin(), _subscribers.end(), id); - if(p == _subscribers.end()) + auto traceLevels = _instance->traceLevels(); + + if(find(_subscribers.begin(), _subscribers.end(), id) == _subscribers.end()) { string name = IceStormInternal::identityToTopicName(id); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -704,7 +704,6 @@ TopicImpl::unlink(const TopicPrx& topic) throw NoSuchLink(name); } - TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -719,9 +718,9 @@ TopicImpl::unlink(const TopicPrx& topic) void TopicImpl::reap(const Ice::IdentitySeq& ids) { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -742,13 +741,14 @@ TopicImpl::reap(const Ice::IdentitySeq& ids) void TopicImpl::shutdown() { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); + _servant = 0; // Shutdown each subscriber. This waits for the event queues to drain. - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - (*p)->shutdown(); + subscriber->shutdown(); } _observer.detach(); @@ -757,13 +757,13 @@ TopicImpl::shutdown() LinkInfoSeq TopicImpl::getLinkInfoSeq() const { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); LinkInfoSeq seq; - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - SubscriberRecord record = (*p)->record(); - if(record.link && !(*p)->errored()) + SubscriberRecord record = subscriber->record(); + if(record.link && !subscriber->errored()) { LinkInfo info; info.name = IceStormInternal::identityToTopicName(record.theTopic->ice_getIdentity()); @@ -778,12 +778,12 @@ TopicImpl::getLinkInfoSeq() const Ice::IdentitySeq TopicImpl::getSubscribers() const { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); Ice::IdentitySeq subscribers; - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - subscribers.push_back((*p)->id()); + subscribers.push_back(subscriber->id()); } return subscribers; } @@ -791,7 +791,7 @@ TopicImpl::getSubscribers() const void TopicImpl::destroy() { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); if(_destroyed) { @@ -799,7 +799,7 @@ TopicImpl::destroy() } _destroyed = true; - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -807,7 +807,7 @@ TopicImpl::destroy() } // destroyInternal clears out the topic content. - LogUpdate llu = {0,0}; + LogUpdate llu = { 0,0 }; _instance->observers()->destroyTopic(destroyInternal(llu, true), _name); _observer.detach(); @@ -816,18 +816,18 @@ TopicImpl::destroy() TopicContent TopicImpl::getContent() const { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); TopicContent content; content.id = _id; - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { // Don't return errored subscribers (subscribers that have // errored out, but not reaped due to a failure with the // master). This means we can avoid the reaping step later. - if(!(*p)->errored()) + if(!subscriber->errored()) { - content.records.push_back((*p)->record()); + content.records.push_back(subscriber->record()); } } return content; @@ -836,7 +836,7 @@ TopicImpl::getContent() const void TopicImpl::update(const SubscriberRecordSeq& records) { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); // We do this with two scans. The first runs through the subscribers // that we have and removes those not in the init list. The second @@ -844,7 +844,7 @@ TopicImpl::update(const SubscriberRecordSeq& records) // exist. { - vector<SubscriberPtr>::iterator p = _subscribers.begin(); + auto p = _subscribers.begin(); while(p != _subscribers.end()) { SubscriberRecordSeq::const_iterator q; @@ -871,19 +871,19 @@ TopicImpl::update(const SubscriberRecordSeq& records) } } - for(SubscriberRecordSeq::const_iterator p = records.begin(); p != records.end(); ++p) + for(const auto& record : records) { - vector<SubscriberPtr>::iterator q; + vector<shared_ptr<Subscriber>>::iterator q; for(q = _subscribers.begin(); q != _subscribers.end(); ++q) { - if((*q)->id() == p->id) + if((*q)->id() == record.id) { break; } } if(q == _subscribers.end()) { - SubscriberPtr subscriber = Subscriber::create(_instance, *p); + auto subscriber = Subscriber::create(_instance, record); _subscribers.push_back(subscriber); } } @@ -892,7 +892,8 @@ TopicImpl::update(const SubscriberRecordSeq& records) bool TopicImpl::destroyed() const { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lg(_subscribersMutex); + return _destroyed; } @@ -903,11 +904,11 @@ TopicImpl::id() const return _id; } -TopicPrx +shared_ptr<TopicPrx> TopicImpl::proxy() const { // immutable - Ice::ObjectPrx prx; + shared_ptr<Ice::ObjectPrx> prx; if(_instance->topicReplicaProxy()) { prx = _instance->topicReplicaProxy()->ice_identity(_id); @@ -916,44 +917,13 @@ TopicImpl::proxy() const { prx = _instance->topicAdapter()->createProxy(_id); } - return TopicPrx::uncheckedCast(prx); -} - -namespace -{ - -class TopicInternalReapCB : public IceUtil::Shared -{ -public: - - TopicInternalReapCB(const PersistentInstancePtr& instance, Ice::Long generation) : - _instance(instance), _generation(generation) - { - } - - virtual void exception(const Ice::Exception& ex) - { - TraceLevelsPtr traceLevels = _instance->traceLevels(); - if(traceLevels->topic > 0) - { - Ice::Trace out(traceLevels->logger, traceLevels->topicCat); - out << "exception when calling `reap' on the master replica: " << ex; - } - _instance->node()->recovery(_generation); - } - -private: - - const PersistentInstancePtr _instance; - const Ice::Long _generation; -}; - + return Ice::uncheckedCast<TopicPrx>(prx); } void TopicImpl::publish(bool forwarded, const EventDataSeq& events) { - TopicInternalPrx masterInternal; + shared_ptr<TopicInternalPrx> masterInternal; Ice::Long generation = -1; Ice::IdentitySeq reap; { @@ -964,9 +934,10 @@ TopicImpl::publish(bool forwarded, const EventDataSeq& events) // Copy of the subscriber list so that event publishing can occur // in parallel. // - vector<SubscriberPtr> copy; + vector<shared_ptr<Subscriber>> copy; { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lock(_subscribersMutex); + if(_observer) { if(forwarded) @@ -985,11 +956,11 @@ TopicImpl::publish(bool forwarded, const EventDataSeq& events) // Queue each event, gathering a list of those subscribers that // must be reaped. // - for(vector<SubscriberPtr>::const_iterator p = copy.begin(); p != copy.end(); ++p) + for(const auto& subscriber : copy) { - if(!(*p)->queue(forwarded, events) && (*p)->reap()) + if(!subscriber->queue(forwarded, events) && subscriber->reap()) { - reap.push_back((*p)->id()); + reap.push_back(subscriber->id()); } } @@ -1000,11 +971,11 @@ TopicImpl::publish(bool forwarded, const EventDataSeq& events) } if(!unlock.getMaster()) { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lock(_subscribersMutex); removeSubscribers(reap); return; } - masterInternal = TopicInternalPrx::uncheckedCast(unlock.getMaster()->ice_identity(_id)); + masterInternal = Ice::uncheckedCast<TopicInternalPrx>(unlock.getMaster()->ice_identity(_id)); generation = unlock.generation(); } @@ -1017,16 +988,32 @@ TopicImpl::publish(bool forwarded, const EventDataSeq& events) // call may raise an exception in the caller (that is directly // call ice_exception) which calls recover() on the node which // would result in a deadlock since the node is locked. - masterInternal->begin_reap(reap, newCallback_TopicInternal_reap(new TopicInternalReapCB(_instance, generation), - &TopicInternalReapCB::exception)); + + masterInternal->reapAsync(reap, nullptr, [instance = _instance, generation](exception_ptr ex) + { + auto traceLevels = instance->traceLevels(); + if(traceLevels->topic > 0) + { + try + { + rethrow_exception(ex); + } + catch(const std::exception& e) + { + Ice::Trace out(traceLevels->logger, traceLevels->topicCat); + out << "exception when calling `reap' on the master replica: " << e; + } + } + instance->node()->recovery(generation); + }); } void TopicImpl::observerAddSubscriber(const LogUpdate& llu, const SubscriberRecord& record) { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lock(_subscribersMutex); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -1048,8 +1035,7 @@ TopicImpl::observerAddSubscriber(const LogUpdate& llu, const SubscriberRecord& r out << " llu: " << llu.generation << "/" << llu.iteration; } - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); - if(p != _subscribers.end()) + if(find(_subscribers.begin(), _subscribers.end(), record.id) != _subscribers.end()) { // If the subscriber is already in the database display a // diagnostic. @@ -1061,7 +1047,7 @@ TopicImpl::observerAddSubscriber(const LogUpdate& llu, const SubscriberRecord& r return; } - SubscriberPtr subscriber = Subscriber::create(_instance, record); + auto subscriber = Subscriber::create(_instance, record); try { IceDB::ReadWriteTxn txn(_instance->dbEnv()); @@ -1089,7 +1075,7 @@ TopicImpl::observerAddSubscriber(const LogUpdate& llu, const SubscriberRecord& r void TopicImpl::observerRemoveSubscriber(const LogUpdate& llu, const Ice::IdentitySeq& ids) { - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -1105,19 +1091,16 @@ TopicImpl::observerRemoveSubscriber(const LogUpdate& llu, const Ice::IdentitySeq out << " llu: " << llu.generation << "/" << llu.iteration; } - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lock(_subscribersMutex); // First remove from the database. try { IceDB::ReadWriteTxn txn(_instance->dbEnv()); - for(Ice::IdentitySeq::const_iterator id = ids.begin(); id != ids.end(); ++id) + for(const auto& id : ids) { - SubscriberRecordKey key; - key.topic = _id; - key.id = *id; - + SubscriberRecordKey key = { _id, id }; _subscriberMap.del(txn, key); } @@ -1134,9 +1117,9 @@ TopicImpl::observerRemoveSubscriber(const LogUpdate& llu, const Ice::IdentitySeq // Then remove the subscriber from the subscribers list. If the // subscriber had a local failure and was removed from the // subscriber list it could already be gone. That's not a problem. - for(Ice::IdentitySeq::const_iterator id = ids.begin(); id != ids.end(); ++id) + for(const auto& id : ids) { - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), *id); + auto p = find(_subscribers.begin(), _subscribers.end(), id); if(p != _subscribers.end()) { (*p)->destroy(); @@ -1148,7 +1131,7 @@ TopicImpl::observerRemoveSubscriber(const LogUpdate& llu, const Ice::IdentitySeq void TopicImpl::observerDestroyTopic(const LogUpdate& llu) { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lock(_subscribersMutex); if(_destroyed) { @@ -1156,7 +1139,7 @@ TopicImpl::observerDestroyTopic(const LogUpdate& llu) } _destroyed = true; - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -1166,7 +1149,7 @@ TopicImpl::observerDestroyTopic(const LogUpdate& llu) destroyInternal(llu, false); } -Ice::ObjectPtr +shared_ptr<Ice::Object> TopicImpl::getServant() const { return _servant; @@ -1175,7 +1158,8 @@ TopicImpl::getServant() const void TopicImpl::updateObserver() { - IceUtil::Mutex::Lock sync(_subscribersMutex); + lock_guard<mutex> lock(_subscribersMutex); + if(_instance->observer()) { _observer.attach(_instance->observer()->getTopicObserver(_instance->serviceName(), _name, _observer.get())); @@ -1185,10 +1169,11 @@ TopicImpl::updateObserver() void TopicImpl::updateSubscriberObservers() { - IceUtil::Mutex::Lock sync(_subscribersMutex); - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + lock_guard<mutex> lock(_subscribersMutex); + + for(const auto& subscriber : _subscribers) { - (*p)->updateObserver(); + subscriber->updateObserver(); } } @@ -1243,9 +1228,9 @@ TopicImpl::destroyInternal(const LogUpdate& origLLU, bool master) _instance->topicReaper()->add(_name); // Destroy each of the subscribers. - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - (*p)->destroy(); + subscriber->destroy(); } _subscribers.clear(); @@ -1267,11 +1252,9 @@ TopicImpl::removeSubscribers(const Ice::IdentitySeq& ids) { IceDB::ReadWriteTxn txn(_instance->dbEnv()); - for(Ice::IdentitySeq::const_iterator id = ids.begin(); id != ids.end(); ++id) + for(const auto& id : ids) { - SubscriberRecordKey key; - key.topic = _id; - key.id = *id; + SubscriberRecordKey key = { _id, id }; if(_subscriberMap.del(txn, key)) { @@ -1305,7 +1288,7 @@ TopicImpl::removeSubscribers(const Ice::IdentitySeq& ids) // removed. for(Ice::IdentitySeq::const_iterator id = ids.begin(); id != ids.end(); ++id) { - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), *id); + auto p = find(_subscribers.begin(), _subscribers.end(), *id); if(p != _subscribers.end()) { (*p)->destroy(); diff --git a/cpp/src/IceStorm/TopicI.h b/cpp/src/IceStorm/TopicI.h index 9597fb62558..0bc37d3ae01 100644 --- a/cpp/src/IceStorm/TopicI.h +++ b/cpp/src/IceStorm/TopicI.h @@ -17,25 +17,25 @@ namespace IceStorm // Forward declarations class PersistentInstance; -typedef IceUtil::Handle<PersistentInstance> PersistentInstancePtr; - class Subscriber; -typedef IceUtil::Handle<Subscriber> SubscriberPtr; -class TopicImpl : public IceUtil::Shared +class TopicImpl { public: - TopicImpl(const PersistentInstancePtr&, const std::string&, const Ice::Identity&, const SubscriberRecordSeq&); + static std::shared_ptr<TopicImpl> create(std::shared_ptr<PersistentInstance>, + const std::string&, + const Ice::Identity&, + const SubscriberRecordSeq&); std::string getName() const; - Ice::ObjectPrx getPublisher() const; - Ice::ObjectPrx getNonReplicatedPublisher() const; - Ice::ObjectPrx subscribeAndGetPublisher(const QoS&, const Ice::ObjectPrx&); - void unsubscribe(const Ice::ObjectPrx&); - TopicLinkPrx getLinkProxy(); - void link(const TopicPrx&, Ice::Int); - void unlink(const TopicPrx&); + std::shared_ptr<Ice::ObjectPrx> getPublisher() const; + std::shared_ptr<Ice::ObjectPrx> getNonReplicatedPublisher() const; + std::shared_ptr<Ice::ObjectPrx> subscribeAndGetPublisher(QoS, std::shared_ptr<Ice::ObjectPrx>); + void unsubscribe(const std::shared_ptr<Ice::ObjectPrx>&); + std::shared_ptr<TopicLinkPrx> getLinkProxy(); + void link(const std::shared_ptr<TopicPrx>&, int); + void unlink(const std::shared_ptr<TopicPrx>&); LinkInfoSeq getLinkInfoSeq() const; Ice::IdentitySeq getSubscribers() const; void reap(const Ice::IdentitySeq&); @@ -48,7 +48,7 @@ public: // Internal methods bool destroyed() const; Ice::Identity id() const; - TopicPrx proxy() const; + std::shared_ptr<TopicPrx> proxy() const; void shutdown(); void publish(bool, const EventDataSeq&); @@ -57,33 +57,35 @@ public: void observerRemoveSubscriber(const IceStormElection::LogUpdate&, const Ice::IdentitySeq&); void observerDestroyTopic(const IceStormElection::LogUpdate&); - Ice::ObjectPtr getServant() const; + std::shared_ptr<Ice::Object> getServant() const; void updateObserver(); void updateSubscriberObservers(); private: + TopicImpl(std::shared_ptr<PersistentInstance>, const std::string&, const Ice::Identity&, const SubscriberRecordSeq&); + IceStormElection::LogUpdate destroyInternal(const IceStormElection::LogUpdate&, bool); void removeSubscribers(const Ice::IdentitySeq&); // // Immutable members. // - const Ice::ObjectPrx _publisherReplicaProxy; - const PersistentInstancePtr _instance; + const std::shared_ptr<Ice::ObjectPrx> _publisherReplicaProxy; + const std::shared_ptr<PersistentInstance> _instance; const std::string _name; // The topic name const Ice::Identity _id; // The topic identity IceInternal::ObserverHelperT<IceStorm::Instrumentation::TopicObserver> _observer; - /*const*/ Ice::ObjectPrx _publisherPrx; // The actual publisher proxy. - /*const*/ TopicLinkPrx _linkPrx; // The link proxy. + std::shared_ptr<Ice::ObjectPrx> _publisherPrx; // The actual publisher proxy. + std::shared_ptr<TopicLinkPrx> _linkPrx; // The link proxy. - Ice::ObjectPtr _servant; // The topic implementation servant. + std::shared_ptr<Ice::Object> _servant; // The topic implementation servant. // Mutex protecting the subscribers. - IceUtil::Mutex _subscribersMutex; + mutable std::mutex _subscribersMutex; // // We keep a vector of subscribers since the optimized behaviour @@ -92,7 +94,7 @@ private: // vector/list/map and although there was little difference vector // was the fastest of the three. // - std::vector<SubscriberPtr> _subscribers; + std::vector<std::shared_ptr<Subscriber>> _subscribers; bool _destroyed; // Has this Topic been destroyed? @@ -100,8 +102,6 @@ private: SubscriberMap _subscriberMap; }; -typedef IceUtil::Handle<TopicImpl> TopicImplPtr; - } // End namespace IceStorm #endif diff --git a/cpp/src/IceStorm/TopicManagerI.cpp b/cpp/src/IceStorm/TopicManagerI.cpp index 194a896a934..7215b5c7e21 100644 --- a/cpp/src/IceStorm/TopicManagerI.cpp +++ b/cpp/src/IceStorm/TopicManagerI.cpp @@ -22,32 +22,32 @@ namespace { void -logError(const Ice::CommunicatorPtr& com, const IceDB::LMDBException& ex) +logError(const shared_ptr<Ice::Communicator>& com, const IceDB::LMDBException& ex) { Ice::Error error(com->getLogger()); error << "LMDB error: " << ex; } -class TopicManagerI : public TopicManagerInternal +class TopicManagerI final : public TopicManagerInternal { public: - TopicManagerI(const PersistentInstancePtr& instance, const TopicManagerImplPtr& impl) : - _instance(instance), _impl(impl) + TopicManagerI(shared_ptr<PersistentInstance> instance, shared_ptr<TopicManagerImpl> impl) : + _instance(move(instance)), _impl(move(impl)) { } - virtual TopicPrx create(const string& id, const Ice::Current&) + shared_ptr<TopicPrx> create(string id, const Ice::Current&) override { while(true) { - Ice::Long generation; - TopicManagerPrx master = getMaster(generation, __FILE__, __LINE__); + long long generation; + auto master = getMaster(generation, __FILE__, __LINE__); if(master) { try { - return master->create(id); + return master->create(move(id)); } catch(const Ice::ConnectFailedException&) { @@ -63,26 +63,26 @@ public: else { FinishUpdateHelper unlock(_instance->node()); - return _impl->create(id); + return _impl->create(move(id)); } } } - virtual TopicPrx retrieve(const string& id, const Ice::Current&) const + shared_ptr<TopicPrx> retrieve(string id, const Ice::Current&) override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); - return _impl->retrieve(id); + return _impl->retrieve(move(id)); } - virtual TopicDict retrieveAll(const Ice::Current&) const + TopicDict retrieveAll(const Ice::Current&) override { // Use cached reads. CachedReadHelper unlock(_instance->node(), __FILE__, __LINE__); return _impl->retrieveAll(); } - virtual NodePrx getReplicaNode(const Ice::Current&) const + shared_ptr<NodePrx> getReplicaNode(const Ice::Current&) const override { // This doesn't require the replication to be running. return _instance->nodeProxy(); @@ -90,49 +90,49 @@ public: private: - TopicManagerPrx getMaster(Ice::Long& generation, const char* file, int line) const + shared_ptr<TopicManagerPrx> getMaster(long long& generation, const char* file, int line) const { - NodeIPtr node = _instance->node(); + auto node = _instance->node(); if(node) { - return TopicManagerPrx::uncheckedCast(node->startUpdate(generation, file, line)); + return Ice::uncheckedCast<TopicManagerPrx>(node->startUpdate(generation, file, line)); } else { - return TopicManagerPrx(); + return nullptr; } } - const PersistentInstancePtr _instance; - const TopicManagerImplPtr _impl; + const shared_ptr<PersistentInstance> _instance; + const shared_ptr<TopicManagerImpl> _impl; }; -class ReplicaObserverI : public ReplicaObserver +class ReplicaObserverI final : public ReplicaObserver { public: - ReplicaObserverI(const PersistentInstancePtr& instance, const TopicManagerImplPtr& impl) : - _instance(instance), - _impl(impl) + ReplicaObserverI(shared_ptr<PersistentInstance> instance, shared_ptr<TopicManagerImpl> impl) : + _instance(move(instance)), + _impl(move(impl)) { } - virtual void init(const LogUpdate& llu, const TopicContentSeq& content, const Ice::Current&) + void init(LogUpdate llu, TopicContentSeq content, const Ice::Current&) override { - NodeIPtr node = _instance->node(); + auto node = _instance->node(); if(node) { node->checkObserverInit(llu.generation); } - _impl->observerInit(llu, content); + _impl->observerInit(move(llu), move(content)); } - virtual void createTopic(const LogUpdate& llu, const string& name, const Ice::Current&) + void createTopic(LogUpdate llu, string name, const Ice::Current&) override { try { ObserverUpdateHelper unlock(_instance->node(), llu.generation, __FILE__, __LINE__); - _impl->observerCreateTopic(llu, name); + _impl->observerCreateTopic(llu, move(name)); } catch(const ObserverInconsistencyException& e) { @@ -143,12 +143,12 @@ public: } } - virtual void destroyTopic(const LogUpdate& llu, const string& name, const Ice::Current&) + void destroyTopic(LogUpdate llu, string name, const Ice::Current&) override { try { ObserverUpdateHelper unlock(_instance->node(), llu.generation, __FILE__, __LINE__); - _impl->observerDestroyTopic(llu, name); + _impl->observerDestroyTopic(llu, move(name)); } catch(const ObserverInconsistencyException& e) { @@ -159,13 +159,12 @@ public: } } - virtual void addSubscriber(const LogUpdate& llu, const string& name, const SubscriberRecord& rec, - const Ice::Current&) + void addSubscriber(LogUpdate llu, string name, SubscriberRecord rec, const Ice::Current&) override { try { ObserverUpdateHelper unlock(_instance->node(), llu.generation, __FILE__, __LINE__); - _impl->observerAddSubscriber(llu, name, rec); + _impl->observerAddSubscriber(llu, move(name), move(rec)); } catch(const ObserverInconsistencyException& e) { @@ -176,13 +175,12 @@ public: } } - virtual void removeSubscriber(const LogUpdate& llu, const string& name, const Ice::IdentitySeq& id, - const Ice::Current&) + void removeSubscriber(LogUpdate llu, string name, Ice::IdentitySeq id, const Ice::Current&) override { try { ObserverUpdateHelper unlock(_instance->node(), llu.generation, __FILE__, __LINE__); - _impl->observerRemoveSubscriber(llu, name, id); + _impl->observerRemoveSubscriber(llu, move(name), move(id)); } catch(const ObserverInconsistencyException& e) { @@ -195,110 +193,109 @@ public: private: - const PersistentInstancePtr _instance; - const TopicManagerImplPtr _impl; + const shared_ptr<PersistentInstance> _instance; + const shared_ptr<TopicManagerImpl> _impl; }; -class TopicManagerSyncI : public TopicManagerSync +class TopicManagerSyncI final : public TopicManagerSync { public: - TopicManagerSyncI(const TopicManagerImplPtr& impl) : - _impl(impl) + TopicManagerSyncI(shared_ptr<TopicManagerImpl> impl) : + _impl(move(impl)) { } - virtual void getContent(LogUpdate& llu, TopicContentSeq& content, const Ice::Current&) + void getContent(LogUpdate& llu, TopicContentSeq& content, const Ice::Current&) override { _impl->getContent(llu, content); } private: - const TopicManagerImplPtr _impl; + const shared_ptr<TopicManagerImpl> _impl; }; } -TopicManagerImpl::TopicManagerImpl(const PersistentInstancePtr& instance) : - _instance(instance), - _lluMap(instance->lluMap()), - _subscriberMap(instance->subscriberMap()) +shared_ptr<TopicManagerImpl> +TopicManagerImpl::create(const std::shared_ptr<PersistentInstance>& instance) { - try + shared_ptr<TopicManagerImpl> manager(new TopicManagerImpl(instance)); + + if(instance->observer()) { - __setNoDelete(true); + instance->observer()->setObserverUpdater(manager); + } - if(_instance->observer()) - { - _instance->observer()->setObserverUpdater(this); - } + manager->_managerImpl = make_shared<TopicManagerI>(instance, manager); - // TODO: If we want to improve the performance of the - // non-replicated case we could allocate a null-topic manager impl - // here. - _managerImpl = new TopicManagerI(instance, this); + // If there is no node adapter we don't need to start the + // observer, nor sync since we're not replicating. + if(instance->nodeAdapter()) + { + auto observerImpl = make_shared<ReplicaObserverI>(instance, manager); + manager->_observer = instance->nodeAdapter()->addWithUUID(observerImpl); + auto syncImpl = make_shared<TopicManagerSyncI>(manager); + manager->_sync = instance->nodeAdapter()->addWithUUID(syncImpl); + } - // If there is no node adapter we don't need to start the - // observer, nor sync since we're not replicating. - if(_instance->nodeAdapter()) - { - _observerImpl = new ReplicaObserverI(instance, this); - _observer = _instance->nodeAdapter()->addWithUUID(_observerImpl); - _syncImpl = new TopicManagerSyncI(this); - _sync = _instance->nodeAdapter()->addWithUUID(_syncImpl); - } + return manager; +} - { - IceDB::ReadWriteTxn txn(_instance->dbEnv()); +TopicManagerImpl::TopicManagerImpl(shared_ptr<PersistentInstance> instance) : + _instance(move(instance)), + _lluMap(_instance->lluMap()), + _subscriberMap(_instance->subscriberMap()) +{ + try + { + IceDB::ReadWriteTxn txn(_instance->dbEnv()); - // Ensure that the llu counter is present in the log. - LogUpdate empty = {0, 0}; - _instance->lluMap().put(txn, lluDbKey, empty); + // Ensure that the llu counter is present in the log. + LogUpdate empty = {0, 0}; + _instance->lluMap().put(txn, lluDbKey, empty); - // Recreate each of the topics. - SubscriberRecordKey k; - SubscriberRecord v; + // Recreate each of the topics. + SubscriberRecordKey k; + SubscriberRecord v; - SubscriberMapRWCursor cursor(_subscriberMap, txn); - if(cursor.get(k, v, MDB_FIRST)) + SubscriberMapRWCursor cursor(_subscriberMap, txn); + if(cursor.get(k, v, MDB_FIRST)) + { + bool moreTopics = false; + do { - bool moreTopics = false; - do - { - // This record has to be a place holder record, otherwise - // there is a database bug. - assert(k.id.name.empty() && k.id.category.empty()); + // This record has to be a place holder record, otherwise + // there is a database bug. + assert(k.id.name.empty() && k.id.category.empty()); - Ice::Identity topic = k.topic; + Ice::Identity topic = k.topic; - SubscriberRecordSeq content; - while((moreTopics = cursor.get(k, v, MDB_NEXT)) == true && k.topic == topic) - { - content.push_back(v); - } - - string name = identityToTopicName(topic); - installTopic(name, topic, false, content); - } while(moreTopics); - } + SubscriberRecordSeq content; + while((moreTopics = cursor.get(k, v, MDB_NEXT)) == true && k.topic == topic) + { + content.push_back(v); + } - txn.commit(); + string name = identityToTopicName(topic); + installTopic(name, topic, false, content); + } while(moreTopics); } + + txn.commit(); } - catch(...) + catch(const std::exception&) { shutdown(); - __setNoDelete(false); throw; } - __setNoDelete(false); } -TopicPrx +shared_ptr<TopicPrx> TopicManagerImpl::create(const string& name) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); reap(); if(_topics.find(name) != _topics.end()) @@ -336,15 +333,14 @@ TopicManagerImpl::create(const string& name) return installTopic(name, id, true); } -TopicPrx -TopicManagerImpl::retrieve(const string& name) const +shared_ptr<TopicPrx> +TopicManagerImpl::retrieve(const string& name) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - TopicManagerImpl* This = const_cast<TopicManagerImpl*>(this); - This->reap(); + reap(); - map<string, TopicImplPtr>::const_iterator p = _topics.find(name); + auto p = _topics.find(name); if(p == _topics.end()) { throw NoSuchTopic(name); @@ -354,17 +350,16 @@ TopicManagerImpl::retrieve(const string& name) const } TopicDict -TopicManagerImpl::retrieveAll() const +TopicManagerImpl::retrieveAll() { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - TopicManagerImpl* This = const_cast<TopicManagerImpl*>(this); - This->reap(); + reap(); TopicDict all; - for(map<string, TopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + for(auto p = _topics.begin(); p != _topics.end(); ++p) { - all.insert(TopicDict::value_type(p->first, p->second->proxy())); + all.insert({ p->first, p->second->proxy() }); } return all; @@ -373,19 +368,19 @@ TopicManagerImpl::retrieveAll() const void TopicManagerImpl::observerInit(const LogUpdate& llu, const TopicContentSeq& content) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topicMgr > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicMgrCat); out << "init"; - for(TopicContentSeq::const_iterator p = content.begin(); p != content.end(); ++p) + for(const auto& c : content) { - out << " topic: " << _instance->communicator()->identityToString(p->id) << " subscribers: "; - for(SubscriberRecordSeq::const_iterator q = p->records.begin(); q != p->records.end(); ++q) + out << " topic: " << _instance->communicator()->identityToString(c.id) << " subscribers: "; + for(auto q = c.records.cbegin(); q != c.records.cend(); ++q) { - if(q != p->records.begin()) + if(q != c.records.begin()) { out << ","; } @@ -409,22 +404,23 @@ TopicManagerImpl::observerInit(const LogUpdate& llu, const TopicContentSeq& cont _subscriberMap.clear(txn); for(TopicContentSeq::const_iterator p = content.begin(); p != content.end(); ++p) + for(const auto& c : content) { SubscriberRecordKey srkey; - srkey.topic = p->id; + srkey.topic = c.id; SubscriberRecord rec; rec.link = false; rec.cost = 0; _subscriberMap.put(txn, srkey, rec); - for(SubscriberRecordSeq::const_iterator q = p->records.begin(); q != p->records.end(); ++q) + for(const auto& record : c.records) { SubscriberRecordKey key; - key.topic = p->id; - key.id = q->id; + key.topic = c.id; + key.id = record.id; - _subscriberMap.put(txn, key, *q); + _subscriberMap.put(txn, key, record); } } txn.commit(); @@ -440,7 +436,7 @@ TopicManagerImpl::observerInit(const LogUpdate& llu, const TopicContentSeq& cont // runs through the init list and either adds the ones that don't // exist, or updates those that do. - map<string, TopicImplPtr>::iterator p = _topics.begin(); + auto p = _topics.begin(); while(p != _topics.end()) { TopicContentSeq::const_iterator q; @@ -471,10 +467,10 @@ TopicManagerImpl::observerInit(const LogUpdate& llu, const TopicContentSeq& cont // Now run through the contents updating the topics that do exist, // and creating those that do not. - for(TopicContentSeq::const_iterator q = content.begin(); q != content.end(); ++q) + for(auto q = content.cbegin(); q != content.cend(); ++q) { string name = identityToTopicName(q->id); - map<string, TopicImplPtr>::const_iterator r = _topics.find(name); + auto r = _topics.find(name); if(r == _topics.end()) { installTopic(name, q->id, true, q->records); @@ -491,7 +487,7 @@ TopicManagerImpl::observerInit(const LogUpdate& llu, const TopicContentSeq& cont void TopicManagerImpl::observerCreateTopic(const LogUpdate& llu, const string& name) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); Ice::Identity id = nameToIdentity(_instance, name); try @@ -526,9 +522,9 @@ TopicManagerImpl::observerCreateTopic(const LogUpdate& llu, const string& name) void TopicManagerImpl::observerDestroyTopic(const LogUpdate& llu, const string& name) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - map<string, TopicImplPtr>::iterator q = _topics.find(name); + auto q = _topics.find(name); if(q == _topics.end()) { throw ObserverInconsistencyException("no topic: " + name); @@ -541,11 +537,11 @@ TopicManagerImpl::observerDestroyTopic(const LogUpdate& llu, const string& name) void TopicManagerImpl::observerAddSubscriber(const LogUpdate& llu, const string& name, const SubscriberRecord& record) { - TopicImplPtr topic; + shared_ptr<TopicImpl> topic; { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - map<string, TopicImplPtr>::iterator q = _topics.find(name); + auto q = _topics.find(name); if(q == _topics.end()) { throw ObserverInconsistencyException("no topic: " + name); @@ -559,11 +555,11 @@ TopicManagerImpl::observerAddSubscriber(const LogUpdate& llu, const string& name void TopicManagerImpl::observerRemoveSubscriber(const LogUpdate& llu, const string& name, const Ice::IdentitySeq& id) { - TopicImplPtr topic; + shared_ptr<TopicImpl> topic; { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - map<string, TopicImplPtr>::iterator q = _topics.find(name); + auto q = _topics.find(name); if(q == _topics.end()) { throw ObserverInconsistencyException("no topic: " + name); @@ -578,16 +574,16 @@ void TopicManagerImpl::getContent(LogUpdate& llu, TopicContentSeq& content) { { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); reap(); } try { content.clear(); - for(map<string, TopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + for(const auto& topic : _topics) { - TopicContent rec = p->second->getContent(); + TopicContent rec = topic.second->getContent(); content.push_back(rec); } @@ -620,9 +616,9 @@ TopicManagerImpl::getLastLogUpdate() const } void -TopicManagerImpl::sync(const Ice::ObjectPrx& master) +TopicManagerImpl::sync(const shared_ptr<Ice::ObjectPrx>& master) { - TopicManagerSyncPrx sync = TopicManagerSyncPrx::uncheckedCast(master); + auto sync = Ice::uncheckedCast<TopicManagerSyncPrx>(master); LogUpdate llu; TopicContentSeq content; @@ -634,7 +630,7 @@ TopicManagerImpl::sync(const Ice::ObjectPrx& master) void TopicManagerImpl::initMaster(const set<GroupNodeInfo>& slaves, const LogUpdate& llu) { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); reap(); @@ -657,9 +653,9 @@ TopicManagerImpl::initMaster(const set<GroupNodeInfo>& slaves, const LogUpdate& IceDB::ReadWriteTxn txn(_instance->dbEnv()); - for(map<string, TopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + for(const auto& topic : _topics) { - TopicContent rec = p->second->getContent(); + TopicContent rec = topic.second->getContent(); content.push_back(rec); } @@ -677,13 +673,13 @@ TopicManagerImpl::initMaster(const set<GroupNodeInfo>& slaves, const LogUpdate& _instance->observers()->init(slaves, llu, content); } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> TopicManagerImpl::getObserver() const { return _observer; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> TopicManagerImpl::getSync() const { return _sync; @@ -695,12 +691,10 @@ TopicManagerImpl::reap() // // Always called with mutex locked. // - // Lock sync(*this); - // vector<string> reaped = _instance->topicReaper()->consumeReapedTopics(); - for(vector<string>::const_iterator p = reaped.begin(); p != reaped.end(); ++p) + for(const auto& topic : reaped) { - map<string, TopicImplPtr>::iterator q = _topics.find(*p); + auto q = _topics.find(topic); if(q != _topics.end() && q->second->destroyed()) { _topics.erase(q); @@ -711,20 +705,18 @@ TopicManagerImpl::reap() void TopicManagerImpl::shutdown() { - Lock sync(*this); + lock_guard<recursive_mutex> lg(_mutex); - for(map<string, TopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + for(const auto& topic : _topics) { - p->second->shutdown(); + topic.second->shutdown(); } _topics.clear(); - _observerImpl = 0; - _syncImpl = 0; - _managerImpl = 0; + _managerImpl = nullptr; } -Ice::ObjectPtr +shared_ptr<Ice::Object> TopicManagerImpl::getServant() const { return _managerImpl; @@ -733,31 +725,33 @@ TopicManagerImpl::getServant() const void TopicManagerImpl::updateTopicObservers() { - Lock sync(*this); - for(map<string, TopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + lock_guard<recursive_mutex> lg(_mutex); + + for(const auto& topic : _topics) { - p->second->updateObserver(); + topic.second->updateObserver(); } } void TopicManagerImpl::updateSubscriberObservers() { - Lock sync(*this); - for(map<string, TopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + lock_guard<recursive_mutex> lg(_mutex); + + for(const auto& topic : _topics) { - p->second->updateSubscriberObservers(); + topic.second->updateSubscriberObservers(); } } -TopicPrx +shared_ptr<TopicPrx> TopicManagerImpl::installTopic(const string& name, const Ice::Identity& id, bool create, const IceStorm::SubscriberRecordSeq& subscribers) { // // Called by constructor or with 'this' mutex locked. // - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topicMgr > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicMgrCat); @@ -766,7 +760,7 @@ TopicManagerImpl::installTopic(const string& name, const Ice::Identity& id, bool out << "creating new topic \"" << name << "\". id: " << _instance->communicator()->identityToString(id) << " subscribers: "; - for(SubscriberRecordSeq::const_iterator q = subscribers.begin(); q != subscribers.end(); ++q) + for(auto q = subscribers.cbegin(); q != subscribers.cend(); ++q) { if(q != subscribers.begin()) { @@ -784,7 +778,7 @@ TopicManagerImpl::installTopic(const string& name, const Ice::Identity& id, bool out << "loading topic \"" << name << "\" from database. id: " << _instance->communicator()->identityToString(id) << " subscribers: "; - for(SubscriberRecordSeq::const_iterator q = subscribers.begin(); q != subscribers.end(); ++q) + for(auto q = subscribers.cbegin(); q != subscribers.cend(); ++q) { if(q != subscribers.begin()) { @@ -800,10 +794,10 @@ TopicManagerImpl::installTopic(const string& name, const Ice::Identity& id, bool } // Create topic implementation - TopicImplPtr topicImpl = new TopicImpl(_instance, name, id, subscribers); + auto topicImpl = TopicImpl::create(_instance, name, id, subscribers); // The identity is the name of the Topic. - _topics.insert(map<string, TopicImplPtr>::value_type(name, topicImpl)); + _topics.insert({ name, topicImpl }); _instance->topicAdapter()->add(topicImpl->getServant(), id); return topicImpl->proxy(); } diff --git a/cpp/src/IceStorm/TopicManagerI.h b/cpp/src/IceStorm/TopicManagerI.h index 84cb47871cf..3d34d71fcb1 100644 --- a/cpp/src/IceStorm/TopicManagerI.h +++ b/cpp/src/IceStorm/TopicManagerI.h @@ -12,35 +12,27 @@ #include <IceStorm/Instrumentation.h> #include <IceStorm/Util.h> -#include <IceUtil/RecMutex.h> - namespace IceStorm { -// -// Forward declarations. -// class PersistentInstance; -typedef IceUtil::Handle<PersistentInstance> PersistentInstancePtr; - class TopicImpl; -typedef IceUtil::Handle<TopicImpl> TopicImplPtr; // // TopicManager implementation. // -class TopicManagerImpl : public IceStormElection::Replica, - public IceStorm::Instrumentation::ObserverUpdater, - public IceUtil::RecMutex +class TopicManagerImpl final : public IceStormElection::Replica, + public IceStorm::Instrumentation::ObserverUpdater, + public std::enable_shared_from_this<TopicManagerImpl> { public: - TopicManagerImpl(const PersistentInstancePtr&); + static std::shared_ptr<TopicManagerImpl> create(const std::shared_ptr<PersistentInstance>&); // TopicManager methods. - TopicPrx create(const std::string&); - TopicPrx retrieve(const std::string&) const; - TopicDict retrieveAll() const; + std::shared_ptr<TopicPrx> create(const std::string&); + std::shared_ptr<TopicPrx> retrieve(const std::string&); + TopicDict retrieveAll(); // Observer methods. void observerInit(const IceStormElection::LogUpdate&, const IceStormElection::TopicContentSeq&); @@ -54,40 +46,41 @@ public: void getContent(IceStormElection::LogUpdate&, IceStormElection::TopicContentSeq&); // Replica methods. - virtual IceStormElection::LogUpdate getLastLogUpdate() const; - virtual void sync(const Ice::ObjectPrx&); - virtual void initMaster(const std::set<IceStormElection::GroupNodeInfo>&, const IceStormElection::LogUpdate&); - virtual Ice::ObjectPrx getObserver() const; - virtual Ice::ObjectPrx getSync() const; + IceStormElection::LogUpdate getLastLogUpdate() const override; + void sync(const std::shared_ptr<Ice::ObjectPrx>&) override; + void initMaster(const std::set<IceStormElection::GroupNodeInfo>&, const IceStormElection::LogUpdate&) override; + std::shared_ptr<Ice::ObjectPrx> getObserver() const override; + std::shared_ptr<Ice::ObjectPrx> getSync() const override; void reap(); void shutdown(); - Ice::ObjectPtr getServant() const; + std::shared_ptr<Ice::Object> getServant() const; private: - void updateTopicObservers(); - void updateSubscriberObservers(); + TopicManagerImpl(std::shared_ptr<PersistentInstance>); + + void updateTopicObservers() override; + void updateSubscriberObservers() override; - TopicPrx installTopic(const std::string&, const Ice::Identity&, bool, - const IceStorm::SubscriberRecordSeq& = IceStorm::SubscriberRecordSeq()); + std::shared_ptr<TopicPrx> installTopic(const std::string&, const Ice::Identity&, bool, + const IceStorm::SubscriberRecordSeq& = IceStorm::SubscriberRecordSeq()); - const PersistentInstancePtr _instance; + const std::shared_ptr<PersistentInstance> _instance; - std::map<std::string, TopicImplPtr> _topics; + std::map<std::string, std::shared_ptr<TopicImpl>> _topics; - Ice::ObjectPtr _managerImpl; - Ice::ObjectPtr _observerImpl; - Ice::ObjectPrx _observer; - Ice::ObjectPtr _syncImpl; - Ice::ObjectPrx _sync; + std::shared_ptr<Ice::Object> _managerImpl; + std::shared_ptr<Ice::ObjectPrx> _observer; + std::shared_ptr<Ice::ObjectPrx> _sync; LLUMap _lluMap; SubscriberMap _subscriberMap; + + std::recursive_mutex _mutex; }; -typedef IceUtil::Handle<TopicManagerImpl> TopicManagerImplPtr; } // End namespace IceStorm diff --git a/cpp/src/IceStorm/TraceLevels.cpp b/cpp/src/IceStorm/TraceLevels.cpp index afa45876c72..508b7810df5 100644 --- a/cpp/src/IceStorm/TraceLevels.cpp +++ b/cpp/src/IceStorm/TraceLevels.cpp @@ -9,7 +9,9 @@ using namespace std; using namespace IceStorm; -TraceLevels::TraceLevels(const string name, const Ice::PropertiesPtr& properties, const Ice::LoggerPtr& theLogger) : +TraceLevels::TraceLevels(const string name, + const shared_ptr<Ice::Properties>& properties, + shared_ptr<Ice::Logger> theLogger) : topicMgr(0), topicMgrCat("TopicManager"), topic(0), @@ -20,7 +22,7 @@ TraceLevels::TraceLevels(const string name, const Ice::PropertiesPtr& properties electionCat("Election"), replication(0), replicationCat("Replication"), - logger(theLogger) + logger(move(theLogger)) { const string keyBase = name + ".Trace."; const_cast<int&>(topicMgr) = properties->getPropertyAsInt(keyBase + topicMgrCat); @@ -28,7 +30,3 @@ TraceLevels::TraceLevels(const string name, const Ice::PropertiesPtr& properties const_cast<int&>(subscriber) = properties->getPropertyAsInt(keyBase + subscriberCat); const_cast<int&>(election) = properties->getPropertyAsInt(keyBase + electionCat); } - -TraceLevels::~TraceLevels() -{ -} diff --git a/cpp/src/IceStorm/TraceLevels.h b/cpp/src/IceStorm/TraceLevels.h index 02a4ac63452..dac648c6c53 100644 --- a/cpp/src/IceStorm/TraceLevels.h +++ b/cpp/src/IceStorm/TraceLevels.h @@ -5,20 +5,17 @@ #ifndef ICE_STORM_TRACE_LEVELS_H #define ICE_STORM_TRACE_LEVELS_H -#include <IceUtil/Shared.h> -#include <IceUtil/Handle.h> -#include <Ice/PropertiesF.h> #include <Ice/LoggerF.h> +#include <Ice/PropertiesF.h> namespace IceStorm { -class TraceLevels : public IceUtil::Shared +class TraceLevels { public: - TraceLevels(const ::std::string name, const Ice::PropertiesPtr&, const Ice::LoggerPtr&); - virtual ~TraceLevels(); + TraceLevels(const ::std::string name, const std::shared_ptr<Ice::Properties>&, std::shared_ptr<Ice::Logger>); const int topicMgr; const char* topicMgrCat; @@ -35,11 +32,9 @@ public: const int replication; const char* replicationCat; - const Ice::LoggerPtr logger; + const std::shared_ptr<Ice::Logger> logger; }; -typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr; - } // End namespace IceStorm #endif diff --git a/cpp/src/IceStorm/TransientTopicI.cpp b/cpp/src/IceStorm/TransientTopicI.cpp index 055d32caf60..1691216eb3c 100644 --- a/cpp/src/IceStorm/TransientTopicI.cpp +++ b/cpp/src/IceStorm/TransientTopicI.cpp @@ -27,32 +27,22 @@ class TransientPublisherI : public Ice::BlobjectArray { public: - TransientPublisherI(const TransientTopicImplPtr& impl) : - _impl(impl) + TransientPublisherI(shared_ptr<TransientTopicImpl> impl) : + _impl(move(impl)) { } - virtual bool - ice_invoke(const pair<const Ice::Byte*, const Ice::Byte*>& inParams, - Ice::ByteSeq&, - const Ice::Current& current) + bool + ice_invoke(pair<const Ice::Byte*, const Ice::Byte*> inParams, Ice::ByteSeq&, const Ice::Current& current) override { // Use cached reads. - EventDataPtr event = new EventData( - current.operation, - current.mode, - Ice::ByteSeq(), - current.ctx); - - // - // COMPILERBUG: gcc 4.0.1 doesn't like this. - // - //event->data.swap(Ice::ByteSeq(inParams.first, inParams.second)); + EventData event = { current.operation, current.mode, Ice::ByteSeq(), current.ctx }; + Ice::ByteSeq data(inParams.first, inParams.second); - event->data.swap(data); + event.data.swap(data); EventDataSeq v; - v.push_back(event); + v.push_back(move(event)); _impl->publish(false, v); return true; @@ -60,7 +50,7 @@ public: private: - const TransientTopicImplPtr _impl; + const shared_ptr<TransientTopicImpl> _impl; }; // @@ -71,33 +61,29 @@ class TransientTopicLinkI : public TopicLink { public: - TransientTopicLinkI(const TransientTopicImplPtr& impl) : - _impl(impl) + TransientTopicLinkI(shared_ptr<TransientTopicImpl> impl) : + _impl(move(impl)) { } - virtual void - forward(const EventDataSeq& v, const Ice::Current& /*current*/) + void + forward(EventDataSeq v, const Ice::Current&) override { - _impl->publish(true, v); + _impl->publish(true, move(v)); } private: - const TransientTopicImplPtr _impl; + const shared_ptr<TransientTopicImpl> _impl; }; } -TransientTopicImpl::TransientTopicImpl( - const InstancePtr& instance, - const string& name, - const Ice::Identity& id) : - _instance(instance), - _name(name), - _id(id), - _destroyed(false) +shared_ptr<TransientTopicImpl> +TransientTopicImpl::create(const shared_ptr<Instance>& instance, const std::string& name, const Ice::Identity& id) { + shared_ptr<TransientTopicImpl> topicImpl(new TransientTopicImpl(instance, name, id)); + // // Create a servant per topic to receive event data. If the // category is empty then we are in backwards compatibility @@ -112,24 +98,34 @@ TransientTopicImpl::TransientTopicImpl( Ice::Identity linkid; if(id.category.empty()) { - pubid.category = _name; + pubid.category = name; pubid.name = "publish"; - linkid.category = _name; + linkid.category = name; linkid.name = "link"; } else { pubid.category = id.category; - pubid.name = _name + ".publish"; + pubid.name = name + ".publish"; linkid.category = id.category; - linkid.name = _name + ".link"; + linkid.name = name + ".link"; } - _publisherPrx = _instance->publishAdapter()->add(new TransientPublisherI(this), pubid); - _linkPrx = TopicLinkPrx::uncheckedCast(_instance->publishAdapter()->add(new TransientTopicLinkI(this), linkid)); + auto publisher = make_shared<TransientPublisherI>(topicImpl); + topicImpl->_publisherPrx = instance->publishAdapter()->add(publisher, pubid); + auto topicLink = make_shared<TransientTopicLinkI>(topicImpl); + topicImpl->_linkPrx = Ice::uncheckedCast<TopicLinkPrx>(instance->publishAdapter()->add(topicLink, linkid)); + + return topicImpl; } -TransientTopicImpl::~TransientTopicImpl() +TransientTopicImpl::TransientTopicImpl(shared_ptr<Instance> instance, + const std::string& name, + const Ice::Identity& id) : + _instance(move(instance)), + _name(name), + _id(id), + _destroyed(false) { } @@ -140,128 +136,26 @@ TransientTopicImpl::getName(const Ice::Current&) const return _name; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> TransientTopicImpl::getPublisher(const Ice::Current&) const { // Immutable return _publisherPrx; } -Ice::ObjectPrx +shared_ptr<Ice::ObjectPrx> TransientTopicImpl::getNonReplicatedPublisher(const Ice::Current&) const { // Immutable return _publisherPrx; } -void -TransientTopicImpl::subscribe(const QoS& origQoS, const Ice::ObjectPrx& obj, const Ice::Current&) -{ - if(!obj) - { - TraceLevelsPtr traceLevels = _instance->traceLevels(); - if(traceLevels->topic > 0) - { - Ice::Trace out(traceLevels->logger, traceLevels->topicCat); - out << _name << ": subscribe: null proxy"; - } - throw InvalidSubscriber("subscriber is a null proxy"); - } - Ice::Identity id = obj->ice_getIdentity(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); - QoS qos = origQoS; - if(traceLevels->topic > 0) - { - Ice::Trace out(traceLevels->logger, traceLevels->topicCat); - out << _name << ": subscribe: " << _instance->communicator()->identityToString(id); - - if(traceLevels->topic > 1) - { - out << " endpoints: " << IceStormInternal::describeEndpoints(obj) - << " QoS: "; - for(QoS::const_iterator p = qos.begin(); p != qos.end() ; ++p) - { - if(p != qos.begin()) - { - out << ','; - } - out << '[' << p->first << "," << p->second << ']'; - } - } - } - - string reliability = "oneway"; - { - QoS::iterator p = qos.find("reliability"); - if(p != qos.end()) - { - reliability = p->second; - qos.erase(p); - } - } - - Ice::ObjectPrx newObj = obj; - if(reliability == "batch") - { - if(newObj->ice_isDatagram()) - { - newObj = newObj->ice_batchDatagram(); - } - else - { - newObj = newObj->ice_batchOneway(); - } - } - else if(reliability == "twoway") - { - newObj = newObj->ice_twoway(); - } - else if(reliability == "twoway ordered") - { - qos["reliability"] = "ordered"; - newObj = newObj->ice_twoway(); - } - else // reliability == "oneway" - { - if(reliability != "oneway" && traceLevels->subscriber > 0) - { - Ice::Trace out(traceLevels->logger, traceLevels->subscriberCat); - out << reliability <<" mode not understood."; - } - if(!newObj->ice_isDatagram()) - { - newObj = newObj->ice_oneway(); - } - } - - Lock sync(*this); - SubscriberRecord record; - record.id = id; - record.obj = newObj; - record.theQoS = qos; - record.topicName = _name; - record.link = false; - record.cost = 0; - - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); - if(p != _subscribers.end()) - { - // If we already have this subscriber remove it from our - // subscriber list and remove it from the database. - (*p)->destroy(); - _subscribers.erase(p); - } - - SubscriberPtr subscriber = Subscriber::create(_instance, record); - _subscribers.push_back(subscriber); -} - -Ice::ObjectPrx -TransientTopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj, const Ice::Current&) +shared_ptr<Ice::ObjectPrx> +TransientTopicImpl::subscribeAndGetPublisher(QoS qos, shared_ptr<Ice::ObjectPrx> obj, const Ice::Current&) { if(!obj) { - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -271,7 +165,7 @@ TransientTopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPr } Ice::Identity id = obj->ice_getIdentity(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -292,7 +186,7 @@ TransientTopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPr } } - Lock sync(*this); + lock_guard<mutex> lg(_mutex); SubscriberRecord record; record.id = id; @@ -302,22 +196,21 @@ TransientTopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPr record.link = false; record.cost = 0; - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); - if(p != _subscribers.end()) + if(find(_subscribers.begin(), _subscribers.end(), record.id) != _subscribers.end()) { throw AlreadySubscribed(); } - SubscriberPtr subscriber = Subscriber::create(_instance, record); + auto subscriber = Subscriber::create(_instance, record); _subscribers.push_back(subscriber); return subscriber->proxy(); } void -TransientTopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber, const Ice::Current&) +TransientTopicImpl::unsubscribe(shared_ptr<Ice::ObjectPrx> subscriber, const Ice::Current&) { - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(!subscriber) { if(traceLevels->topic > 0) @@ -340,11 +233,12 @@ TransientTopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber, const Ice::Cur } } - Lock sync(*this); + lock_guard<mutex> lg(_mutex); + // First remove the subscriber from the subscribers list. Note // that its possible that the subscriber isn't in the list, but is // in the database if the subscriber was locally reaped. - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), id); + auto p = find(_subscribers.begin(), _subscribers.end(), id); if(p != _subscribers.end()) { (*p)->destroy(); @@ -352,7 +246,7 @@ TransientTopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber, const Ice::Cur } } -TopicLinkPrx +shared_ptr<TopicLinkPrx> TransientTopicImpl::getLinkProxy(const Ice::Current&) { // immutable @@ -360,12 +254,12 @@ TransientTopicImpl::getLinkProxy(const Ice::Current&) } void -TransientTopicImpl::link(const TopicPrx& topic, Ice::Int cost, const Ice::Current&) +TransientTopicImpl::link(shared_ptr<TopicPrx> topic, int cost, const Ice::Current&) { - TopicInternalPrx internal = TopicInternalPrx::uncheckedCast(topic); - TopicLinkPrx link = internal->getLinkProxy(); + auto internal = Ice::uncheckedCast<TopicInternalPrx>(topic); + auto link = internal->getLinkProxy(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -373,9 +267,9 @@ TransientTopicImpl::link(const TopicPrx& topic, Ice::Int cost, const Ice::Curren << " cost " << cost; } - Lock sync(*this); + lock_guard<mutex> lg(_mutex); - Ice::Identity id = topic->ice_getIdentity(); + auto id = topic->ice_getIdentity(); SubscriberRecord record; record.id = id; @@ -385,32 +279,32 @@ TransientTopicImpl::link(const TopicPrx& topic, Ice::Int cost, const Ice::Curren record.link = true; record.cost = cost; - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); - if(p != _subscribers.end()) + if(find(_subscribers.begin(), _subscribers.end(), record.id) != _subscribers.end()) { throw LinkExists(IceStormInternal::identityToTopicName(id)); } - SubscriberPtr subscriber = Subscriber::create(_instance, record); + auto subscriber = Subscriber::create(_instance, record); _subscribers.push_back(subscriber); } void -TransientTopicImpl::unlink(const TopicPrx& topic, const Ice::Current&) +TransientTopicImpl::unlink(shared_ptr<TopicPrx> topic, const Ice::Current&) { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); + if(_destroyed) { throw Ice::ObjectNotExistException(__FILE__, __LINE__); } - Ice::Identity id = topic->ice_getIdentity(); + auto id = topic->ice_getIdentity(); + auto traceLevels = _instance->traceLevels(); - vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), id); - if(p == _subscribers.end()) + if(find(_subscribers.begin(), _subscribers.end(), id) == _subscribers.end()) { string name = IceStormInternal::identityToTopicName(id); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -419,7 +313,6 @@ TransientTopicImpl::unlink(const TopicPrx& topic, const Ice::Current&) throw NoSuchLink(name); } - TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -429,7 +322,7 @@ TransientTopicImpl::unlink(const TopicPrx& topic, const Ice::Current&) // Remove the subscriber from the subscribers list. Note // that its possible that the subscriber isn't in the list, but is // in the database if the subscriber was locally reaped. - p = find(_subscribers.begin(), _subscribers.end(), id); + auto p = find(_subscribers.begin(), _subscribers.end(), id); if(p != _subscribers.end()) { (*p)->destroy(); @@ -440,12 +333,13 @@ TransientTopicImpl::unlink(const TopicPrx& topic, const Ice::Current&) LinkInfoSeq TransientTopicImpl::getLinkInfoSeq(const Ice::Current&) const { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); + LinkInfoSeq seq; - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - SubscriberRecord record = (*p)->record(); - if(record.link && !(*p)->errored()) + SubscriberRecord record = subscriber->record(); + if(record.link && !subscriber->errored()) { LinkInfo info; info.name = IceStormInternal::identityToTopicName(record.theTopic->ice_getIdentity()); @@ -460,12 +354,12 @@ TransientTopicImpl::getLinkInfoSeq(const Ice::Current&) const Ice::IdentitySeq TransientTopicImpl::getSubscribers(const Ice::Current&) const { - IceUtil::Mutex::Lock sync(*this); + lock_guard<mutex> lg(_mutex); Ice::IdentitySeq subscribers; - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - subscribers.push_back((*p)->id()); + subscribers.push_back(subscriber->id()); } return subscribers; } @@ -473,7 +367,7 @@ TransientTopicImpl::getSubscribers(const Ice::Current&) const void TransientTopicImpl::destroy(const Ice::Current&) { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); if(_destroyed) { @@ -481,7 +375,7 @@ TransientTopicImpl::destroy(const Ice::Current&) } _destroyed = true; - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); @@ -499,22 +393,22 @@ TransientTopicImpl::destroy(const Ice::Current&) } // Destroy all of the subscribers. - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - (*p)->destroy(); + subscriber->destroy(); } _subscribers.clear(); } void -TransientTopicImpl::reap(const Ice::IdentitySeq&, const Ice::Current&) +TransientTopicImpl::reap(Ice::IdentitySeq, const Ice::Current&) { } bool TransientTopicImpl::destroyed() const { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); return _destroyed; } @@ -532,9 +426,9 @@ TransientTopicImpl::publish(bool forwarded, const EventDataSeq& events) // Copy of the subscriber list so that event publishing can occur // in parallel. // - vector<SubscriberPtr> copy; + vector<shared_ptr<Subscriber>> copy; { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); copy = _subscribers; } @@ -542,12 +436,12 @@ TransientTopicImpl::publish(bool forwarded, const EventDataSeq& events) // Queue each event, gathering a list of those subscribers that // must be reaped. // - vector<Ice::Identity> e; - for(vector<SubscriberPtr>::const_iterator p = copy.begin(); p != copy.end(); ++p) + vector<Ice::Identity> ids; + for(const auto& subscriber : copy) { - if(!(*p)->queue(forwarded, events) && (*p)->reap()) + if(!subscriber->queue(forwarded, events) && subscriber->reap()) { - e.push_back((*p)->id()); + ids.push_back(subscriber->id()); } } @@ -555,10 +449,10 @@ TransientTopicImpl::publish(bool forwarded, const EventDataSeq& events) // Run through the error list removing those subscribers that are // in error from the subscriber list. // - if(!e.empty()) + if(!ids.empty()) { - Lock sync(*this); - for(vector<Ice::Identity>::const_iterator ep = e.begin(); ep != e.end(); ++ep) + lock_guard<mutex> lg(_mutex); + for(const auto& id : ids) { // // Its possible for the subscriber to already have been @@ -574,14 +468,13 @@ TransientTopicImpl::publish(bool forwarded, const EventDataSeq& events) // error'd subscribers and remove it from the database on // the next reap. // - vector<SubscriberPtr>::iterator q = find(_subscribers.begin(), _subscribers.end(), *ep); + auto q = find(_subscribers.begin(), _subscribers.end(), id); if(q != _subscribers.end()) { - SubscriberPtr subscriber = *q; // // Destroy the subscriber. // - subscriber->destroy(); + (*q)->destroy(); _subscribers.erase(q); } } @@ -591,11 +484,11 @@ TransientTopicImpl::publish(bool forwarded, const EventDataSeq& events) void TransientTopicImpl::shutdown() { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); // Shutdown each subscriber. This waits for the event queues to drain. - for(vector<SubscriberPtr>::const_iterator p = _subscribers.begin(); p != _subscribers.end(); ++p) + for(const auto& subscriber : _subscribers) { - (*p)->shutdown(); + subscriber->shutdown(); } } diff --git a/cpp/src/IceStorm/TransientTopicI.h b/cpp/src/IceStorm/TransientTopicI.h index 50b73d835f5..f64e2a69f42 100644 --- a/cpp/src/IceStorm/TransientTopicI.h +++ b/cpp/src/IceStorm/TransientTopicI.h @@ -12,31 +12,27 @@ namespace IceStorm // Forward declarations. class Instance; -typedef IceUtil::Handle<Instance> InstancePtr; - class Subscriber; -typedef IceUtil::Handle<Subscriber> SubscriberPtr; -class TransientTopicImpl : public TopicInternal, public IceUtil::Mutex +class TransientTopicImpl : public TopicInternal { public: - TransientTopicImpl(const InstancePtr&, const std::string&, const Ice::Identity&); - ~TransientTopicImpl(); - - virtual std::string getName(const Ice::Current&) const; - virtual Ice::ObjectPrx getPublisher(const Ice::Current&) const; - virtual Ice::ObjectPrx getNonReplicatedPublisher(const Ice::Current&) const; - virtual void subscribe(const QoS&, const Ice::ObjectPrx&, const Ice::Current&); - virtual Ice::ObjectPrx subscribeAndGetPublisher(const QoS&, const Ice::ObjectPrx&, const Ice::Current&); - virtual void unsubscribe(const Ice::ObjectPrx&, const Ice::Current&); - virtual TopicLinkPrx getLinkProxy(const Ice::Current&); - virtual void link(const TopicPrx&, Ice::Int, const Ice::Current&); - virtual void unlink(const TopicPrx&, const Ice::Current&); - virtual LinkInfoSeq getLinkInfoSeq(const Ice::Current&) const; - virtual Ice::IdentitySeq getSubscribers(const Ice::Current&) const; - virtual void destroy(const Ice::Current&); - virtual void reap(const Ice::IdentitySeq&, const Ice::Current&); + static std::shared_ptr<TransientTopicImpl> create(const std::shared_ptr<Instance>&, const std::string&, + const Ice::Identity&); + + std::string getName(const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> getNonReplicatedPublisher(const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> getPublisher(const Ice::Current&) const override; + std::shared_ptr<Ice::ObjectPrx> subscribeAndGetPublisher(QoS, std::shared_ptr<Ice::ObjectPrx>, const Ice::Current&) override; + void unsubscribe(std::shared_ptr<Ice::ObjectPrx>, const Ice::Current&) override; + std::shared_ptr<TopicLinkPrx> getLinkProxy(const Ice::Current&) override; + void link(std::shared_ptr<TopicPrx>, int, const Ice::Current&) override; + void unlink(std::shared_ptr<TopicPrx>, const Ice::Current&) override; + LinkInfoSeq getLinkInfoSeq(const Ice::Current&) const override; + Ice::IdentitySeq getSubscribers(const Ice::Current&) const override; + void destroy(const Ice::Current&) override; + void reap(Ice::IdentitySeq, const Ice::Current&) override; // Internal methods bool destroyed() const; @@ -47,15 +43,17 @@ public: private: + TransientTopicImpl(std::shared_ptr<Instance>, const std::string&, const Ice::Identity&); + // // Immutable members. // - const InstancePtr _instance; + const std::shared_ptr<Instance> _instance; const std::string _name; // The topic name const Ice::Identity _id; // The topic identity - /*const*/ Ice::ObjectPrx _publisherPrx; - /*const*/ TopicLinkPrx _linkPrx; + std::shared_ptr<Ice::ObjectPrx> _publisherPrx; + std::shared_ptr<TopicLinkPrx> _linkPrx; // // We keep a vector of subscribers since the optimized behaviour @@ -64,12 +62,12 @@ private: // vector/list/map and although there was little difference vector // was the fastest of the three. // - std::vector<SubscriberPtr> _subscribers; + std::vector<std::shared_ptr<Subscriber>> _subscribers; bool _destroyed; // Has this Topic been destroyed? -}; -typedef IceUtil::Handle<TransientTopicImpl> TransientTopicImplPtr; + mutable std::mutex _mutex; +}; } // End namespace IceStorm diff --git a/cpp/src/IceStorm/TransientTopicManagerI.cpp b/cpp/src/IceStorm/TransientTopicManagerI.cpp index 016808d9335..0eaeb00b4ba 100644 --- a/cpp/src/IceStorm/TransientTopicManagerI.cpp +++ b/cpp/src/IceStorm/TransientTopicManagerI.cpp @@ -15,19 +15,15 @@ using namespace IceStorm; using namespace std; -TransientTopicManagerImpl::TransientTopicManagerImpl(const InstancePtr& instance) : - _instance(instance) +TransientTopicManagerImpl::TransientTopicManagerImpl(shared_ptr<Instance> instance) : + _instance(move(instance)) { } -TransientTopicManagerImpl::~TransientTopicManagerImpl() +shared_ptr<TopicPrx> +TransientTopicManagerImpl::create(string name, const Ice::Current&) { -} - -TopicPrx -TransientTopicManagerImpl::create(const string& name, const Ice::Current&) -{ - Lock sync(*this); + lock_guard<mutex> lg(_mutex); reap(); @@ -41,7 +37,7 @@ TransientTopicManagerImpl::create(const string& name, const Ice::Current&) // // Called by constructor or with 'this' mutex locked. // - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topicMgr > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicMgrCat); @@ -52,25 +48,24 @@ TransientTopicManagerImpl::create(const string& name, const Ice::Current&) // // Create topic implementation // - TransientTopicImplPtr topicImpl = new TransientTopicImpl(_instance, name, id); + auto topicImpl = TransientTopicImpl::create(_instance, name, id); // // The identity is the name of the Topic. // - TopicPrx prx = TopicPrx::uncheckedCast(_instance->topicAdapter()->add(topicImpl, id)); - _topics.insert(map<string, TransientTopicImplPtr>::value_type(name, topicImpl)); + auto prx = Ice::uncheckedCast<TopicPrx>(_instance->topicAdapter()->add(topicImpl, id)); + _topics.insert({ name, topicImpl }); return prx; } -TopicPrx -TransientTopicManagerImpl::retrieve(const string& name, const Ice::Current&) const +shared_ptr<TopicPrx> +TransientTopicManagerImpl::retrieve(string name, const Ice::Current&) { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); - TransientTopicManagerImpl* This = const_cast<TransientTopicManagerImpl*>(this); - This->reap(); + reap(); - map<string, TransientTopicImplPtr>::const_iterator p = _topics.find(name); + auto p = _topics.find(name); if(p == _topics.end()) { throw NoSuchTopic(name); @@ -79,54 +74,51 @@ TransientTopicManagerImpl::retrieve(const string& name, const Ice::Current&) con // Here we cannot just reconstruct the identity since the // identity could be either instanceName/topic name, or if // created with pre-3.2 IceStorm / topic name. - return TopicPrx::uncheckedCast(_instance->topicAdapter()->createProxy(p->second->id())); + return Ice::uncheckedCast<TopicPrx>(_instance->topicAdapter()->createProxy(p->second->id())); } TopicDict -TransientTopicManagerImpl::retrieveAll(const Ice::Current&) const +TransientTopicManagerImpl::retrieveAll(const Ice::Current&) { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); - TransientTopicManagerImpl* This = const_cast<TransientTopicManagerImpl*>(this); - This->reap(); + reap(); TopicDict all; - for(map<string, TransientTopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + for(const auto& topic : _topics) { // // Here we cannot just reconstruct the identity since the // identity could be either "<instanceName>/topic.<topicname>" // name, or if created with pre-3.2 IceStorm "/<topicname>". // - all.insert(TopicDict::value_type( - p->first, TopicPrx::uncheckedCast(_instance->topicAdapter()->createProxy(p->second->id())))); + all.insert({ topic.first, + Ice::uncheckedCast<TopicPrx>(_instance->topicAdapter()->createProxy(topic.second->id())) }); } return all; } -IceStormElection::NodePrx +shared_ptr<IceStormElection::NodePrx> TransientTopicManagerImpl::getReplicaNode(const Ice::Current&) const { - return IceStormElection::NodePrx(); + return nullptr; } void TransientTopicManagerImpl::reap() { // - // Always called with mutex locked. - // - // Lock sync(*this); + // Must be called called with mutex locked. // vector<string> reaped = _instance->topicReaper()->consumeReapedTopics(); for(vector<string>::const_iterator p = reaped.begin(); p != reaped.end(); ++p) { - map<string, TransientTopicImplPtr>::iterator i = _topics.find(*p); + auto i = _topics.find(*p); if(i != _topics.end() && i->second->destroyed()) { - Ice::Identity id = i->second->id(); - TraceLevelsPtr traceLevels = _instance->traceLevels(); + auto id = i->second->id(); + auto traceLevels = _instance->traceLevels(); if(traceLevels->topicMgr > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicMgrCat); @@ -150,10 +142,10 @@ TransientTopicManagerImpl::reap() void TransientTopicManagerImpl::shutdown() { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); - for(map<string, TransientTopicImplPtr>::const_iterator p = _topics.begin(); p != _topics.end(); ++p) + for(const auto& topic : _topics) { - p->second->shutdown(); + topic.second->shutdown(); } } diff --git a/cpp/src/IceStorm/TransientTopicManagerI.h b/cpp/src/IceStorm/TransientTopicManagerI.h index 8c84b6d85d5..55824595475 100644 --- a/cpp/src/IceStorm/TransientTopicManagerI.h +++ b/cpp/src/IceStorm/TransientTopicManagerI.h @@ -10,43 +10,31 @@ namespace IceStorm { -// -// Forward declarations. -// class Instance; -typedef IceUtil::Handle<Instance> InstancePtr; - class TransientTopicImpl; -typedef IceUtil::Handle<TransientTopicImpl> TransientTopicImplPtr; -// -// TopicManager implementation. -// -class TransientTopicManagerImpl : public TopicManagerInternal, public IceUtil::Mutex +class TransientTopicManagerImpl final : public TopicManagerInternal { public: - TransientTopicManagerImpl(const InstancePtr&); - ~TransientTopicManagerImpl(); + TransientTopicManagerImpl(std::shared_ptr<Instance>); // TopicManager methods. - virtual TopicPrx create(const std::string&, const Ice::Current&); - virtual TopicPrx retrieve(const std::string&, const Ice::Current&) const; - virtual TopicDict retrieveAll(const Ice::Current&) const; - virtual IceStormElection::NodePrx getReplicaNode(const Ice::Current&) const; + std::shared_ptr<TopicPrx> create(std::string, const Ice::Current&) override; + std::shared_ptr<TopicPrx> retrieve(std::string, const Ice::Current&) override; + TopicDict retrieveAll(const Ice::Current&) override; + std::shared_ptr<IceStormElection::NodePrx> getReplicaNode(const Ice::Current&) const override; void reap(); - void shutdown(); - Ice::ObjectPtr getServant() const; - private: - const InstancePtr _instance; - std::map<std::string, TransientTopicImplPtr> _topics; + const std::shared_ptr<Instance> _instance; + std::map<std::string, std::shared_ptr<TransientTopicImpl>> _topics; + + std::mutex _mutex; }; -typedef IceUtil::Handle<TransientTopicManagerImpl> TransientTopicManagerImplPtr; } // End namespace IceStorm diff --git a/cpp/src/IceStorm/Util.cpp b/cpp/src/IceStorm/Util.cpp index 7eebdf80173..e8487cca3be 100644 --- a/cpp/src/IceStorm/Util.cpp +++ b/cpp/src/IceStorm/Util.cpp @@ -32,24 +32,20 @@ IceStormInternal::identityToTopicName(const Ice::Identity& id) } Ice::Identity -IceStormInternal::nameToIdentity(const InstancePtr& instance, const string& name) +IceStormInternal::nameToIdentity(const shared_ptr<Instance>& instance, const string& name) { - // Identity is instanceName>/topic.<topicname> - Ice::Identity id; - id.category = instance->instanceName(); - id.name = "topic." + name; - - return id; + // Identity is <instanceName>/topic.<topicname> + return { "topic." + name, instance->instanceName() }; } string -IceStormInternal::describeEndpoints(const Ice::ObjectPrx& proxy) +IceStormInternal::describeEndpoints(const shared_ptr<Ice::ObjectPrx>& proxy) { ostringstream os; if(proxy) { Ice::EndpointSeq endpoints = proxy->ice_getEndpoints(); - for(Ice::EndpointSeq::const_iterator i = endpoints.begin(); i != endpoints.end(); ++i) + for(auto i = endpoints.cbegin(); i != endpoints.cend(); ++i) { if(i != endpoints.begin()) { diff --git a/cpp/src/IceStorm/Util.h b/cpp/src/IceStorm/Util.h index 1ad63017219..22c1cbabccb 100644 --- a/cpp/src/IceStorm/Util.h +++ b/cpp/src/IceStorm/Util.h @@ -17,11 +17,12 @@ namespace IceStorm // Forward declarations. // class Instance; -typedef IceUtil::Handle<Instance> InstancePtr; -typedef IceDB::Dbi<IceStorm::SubscriberRecordKey, IceStorm::SubscriberRecord, IceDB::IceContext, Ice::OutputStream> - SubscriberMap; -typedef IceDB::Dbi<std::string, IceStormElection::LogUpdate, IceDB::IceContext, Ice::OutputStream> LLUMap; +using SubscriberMap = IceDB::Dbi<IceStorm::SubscriberRecordKey, + IceStorm::SubscriberRecord, + IceDB::IceContext, + Ice::OutputStream>; +using LLUMap = IceDB::Dbi<std::string, IceStormElection::LogUpdate, IceDB::IceContext, Ice::OutputStream>; const std::string lluDbKey = "_manager"; @@ -34,10 +35,10 @@ std::string identityToTopicName(const Ice::Identity&); Ice::Identity -nameToIdentity(const IceStorm::InstancePtr&, const std::string&); +nameToIdentity(const std::shared_ptr<IceStorm::Instance>&, const std::string&); std::string -describeEndpoints(const Ice::ObjectPrx&); +describeEndpoints(const std::shared_ptr<Ice::ObjectPrx>&); int compareSubscriberRecordKey(const MDB_val* v1, const MDB_val* v2); diff --git a/slice/IceStorm/IceStorm.ice b/slice/IceStorm/IceStorm.ice index 91a1cb923c1..20cfe77d37a 100644 --- a/slice/IceStorm/IceStorm.ice +++ b/slice/IceStorm/IceStorm.ice @@ -367,7 +367,7 @@ interface TopicManager * @throws NoSuchTopic Raised if the topic does not exist. * **/ - ["nonmutating", "cpp:const"] idempotent Topic* retrieve(string name) throws NoSuchTopic; + ["nonmutating"] idempotent Topic* retrieve(string name) throws NoSuchTopic; /** * @@ -376,7 +376,7 @@ interface TopicManager * @return A dictionary of string, topic proxy pairs. * **/ - ["nonmutating", "cpp:const"] idempotent TopicDict retrieveAll(); + ["nonmutating"] idempotent TopicDict retrieveAll(); } /** |