zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/ServantManager.cpp

@@ -1,46 +1,45 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/ServantManager.h>
-#include <Ice/ServantLocator.h>
-#include <Ice/LocalException.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/Instance.h>
-#include <Ice/StringUtil.h>
+#include "ServantManager.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/ServantLocator.h"
+#include "Ice/StringUtil.h"
+#include "Instance.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-ICE_API IceUtil::Shared* IceInternal::upCast(ServantManager* p) { return p; }
+Ice::ServantLocator::~ServantLocator() = default; // avoid weak vtable
 
 void
-IceInternal::ServantManager::addServant(const ObjectPtr& object, const Identity& ident, const string& facet)
+IceInternal::ServantManager::addServant(ObjectPtr object, Identity ident, string facet)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    ServantMapMap::iterator p = _servantMapMapHint;
+    auto p = _servantMapMapHint;
 
-    if(p == _servantMapMap.end() || p->first != ident)
+    if (p == _servantMapMap.end() || p->first != ident)
     {
         p = _servantMapMap.find(ident);
     }
 
-    if(p == _servantMapMap.end())
+    if (p == _servantMapMap.end())
     {
-        p = _servantMapMap.insert(_servantMapMapHint, pair<const Identity, FacetMap>(ident, FacetMap()));
+        p = _servantMapMap.insert(_servantMapMapHint, pair<const Identity, FacetMap>(std::move(ident), FacetMap()));
     }
     else
     {
-        if(p->second.find(facet) != p->second.end())
+        if (p->second.find(facet) != p->second.end())
         {
             ToStringMode toStringMode = _instance->toStringMode();
             ostringstream os;
             os << Ice::identityToString(ident, toStringMode);
-            if(!facet.empty())
+            if (!facet.empty())
             {
                 os << " -f " << escapeString(facet, "", toStringMode);
             }
@@ -50,65 +49,62 @@ IceInternal::ServantManager::addServant(const ObjectPtr& object, const Identity&
 
     _servantMapMapHint = p;
 
-    p->second.insert(pair<const string, ObjectPtr>(facet, object));
+    p->second.insert(pair<const string, ObjectPtr>(std::move(facet), std::move(object)));
 }
 
 void
-IceInternal::ServantManager::addDefaultServant(const ObjectPtr& object, const string& category)
+IceInternal::ServantManager::addDefaultServant(ObjectPtr object, string category)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    DefaultServantMap::iterator p = _defaultServantMap.find(category);
-    if(p != _defaultServantMap.end())
+    auto p = _defaultServantMap.find(category);
+    if (p != _defaultServantMap.end())
     {
         throw AlreadyRegisteredException(__FILE__, __LINE__, "default servant", category);
     }
 
-    _defaultServantMap.insert(pair<const string, ObjectPtr>(category, object));
+    _defaultServantMap.insert(pair<const string, ObjectPtr>(std::move(category), std::move(object)));
 }
 
 ObjectPtr
-IceInternal::ServantManager::removeServant(const Identity& ident, const string& facet)
+IceInternal::ServantManager::removeServant(const Identity& ident, const string_view facet)
 {
-    //
     // We return the removed servant to avoid releasing the last reference count
     // with *this locked. We don't want to run user code, such as the servant
     // destructor, with an internal Ice mutex locked.
-    //
-    ObjectPtr servant = 0;
 
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    ServantMapMap::iterator p = _servantMapMapHint;
+    auto p = _servantMapMapHint;
     FacetMap::iterator q;
 
-    if(p == _servantMapMap.end() || p->first != ident)
+    if (p == _servantMapMap.end() || p->first != ident)
     {
         p = _servantMapMap.find(ident);
     }
 
-    if(p == _servantMapMap.end() || (q = p->second.find(facet)) == p->second.end())
+    if (p == _servantMapMap.end() || (q = p->second.find(facet)) == p->second.end())
     {
         ToStringMode toStringMode = _instance->toStringMode();
         ostringstream os;
         os << Ice::identityToString(ident, toStringMode);
-        if(!facet.empty())
+        if (!facet.empty())
         {
             os << " -f " + escapeString(facet, "", toStringMode);
         }
         throw NotRegisteredException(__FILE__, __LINE__, "servant", os.str());
     }
 
-    servant = q->second;
+    ObjectPtr servant = q->second;
     p->second.erase(q);
 
-    if(p->second.empty())
+    if (p->second.empty())
     {
-        if(p == _servantMapMapHint)
+        if (p == _servantMapMapHint)
         {
             _servantMapMap.erase(p++);
             _servantMapMapHint = p;
@@ -122,26 +118,23 @@ IceInternal::ServantManager::removeServant(const Identity& ident, const string&
 }
 
 ObjectPtr
-IceInternal::ServantManager::removeDefaultServant(const string& category)
+IceInternal::ServantManager::removeDefaultServant(const string_view category)
 {
-    //
     // We return the removed servant to avoid releasing the last reference count
     // with *this locked. We don't want to run user code, such as the servant
     // destructor, with an internal Ice mutex locked.
-    //
-    ObjectPtr servant = 0;
 
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    DefaultServantMap::iterator p = _defaultServantMap.find(category);
-    if(p == _defaultServantMap.end())
+    auto p = _defaultServantMap.find(category);
+    if (p == _defaultServantMap.end())
     {
-        throw NotRegisteredException(__FILE__, __LINE__, "default servant", category);
+        throw NotRegisteredException(__FILE__, __LINE__, "default servant", string{category});
     }
 
-    servant = p->second;
+    ObjectPtr servant = p->second;
     _defaultServantMap.erase(p);
 
     return servant;
@@ -150,26 +143,29 @@ IceInternal::ServantManager::removeDefaultServant(const string& category)
 FacetMap
 IceInternal::ServantManager::removeAllFacets(const Identity& ident)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    ServantMapMap::iterator p = _servantMapMapHint;
+    auto p = _servantMapMapHint;
 
-    if(p == _servantMapMap.end() || p->first != ident)
+    if (p == _servantMapMap.end() || p->first != ident)
     {
         p = _servantMapMap.find(ident);
     }
 
-    if(p == _servantMapMap.end())
+    if (p == _servantMapMap.end())
     {
-        throw NotRegisteredException(__FILE__, __LINE__, "servant",
-                                     Ice::identityToString(ident, _instance->toStringMode()));
+        throw NotRegisteredException(
+            __FILE__,
+            __LINE__,
+            "servant",
+            Ice::identityToString(ident, _instance->toStringMode()));
     }
 
     FacetMap result = p->second;
 
-    if(p == _servantMapMapHint)
+    if (p == _servantMapMapHint)
     {
         _servantMapMap.erase(p++);
         _servantMapMapHint = p;
@@ -183,9 +179,9 @@ IceInternal::ServantManager::removeAllFacets(const Identity& ident)
 }
 
 ObjectPtr
-IceInternal::ServantManager::findServant(const Identity& ident, const string& facet) const
+IceInternal::ServantManager::findServant(const Identity& ident, const string_view facet) const
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     //
     // This assert is not valid if the adapter dispatch incoming
@@ -193,27 +189,27 @@ IceInternal::ServantManager::findServant(const Identity& ident, const string& fa
     // requests are received over the bidir connection after the
     // adapter was deactivated.
     //
-    //assert(_instance); // Must not be called after destruction.
+    // assert(_instance); // Must not be called after destruction.
 
-    ServantMapMap::iterator p = _servantMapMapHint;
+    auto p = _servantMapMapHint;
     FacetMap::iterator q;
 
-    ServantMapMap& servantMapMap = const_cast<ServantMapMap&>(_servantMapMap);
+    auto& servantMapMap = const_cast<ServantMapMap&>(_servantMapMap);
 
-    if(p == servantMapMap.end() || p->first != ident)
+    if (p == servantMapMap.end() || p->first != ident)
     {
         p = servantMapMap.find(ident);
     }
 
-    if(p == servantMapMap.end() || (q = p->second.find(facet)) == p->second.end())
+    if (p == servantMapMap.end() || (q = p->second.find(facet)) == p->second.end())
     {
-        DefaultServantMap::const_iterator d = _defaultServantMap.find(ident.category);
-        if(d == _defaultServantMap.end())
+        auto d = _defaultServantMap.find(ident.category);
+        if (d == _defaultServantMap.end())
         {
             d = _defaultServantMap.find("");
-            if(d == _defaultServantMap.end())
+            if (d == _defaultServantMap.end())
             {
-                return 0;
+                return nullptr;
             }
             else
             {
@@ -233,14 +229,14 @@ IceInternal::ServantManager::findServant(const Identity& ident, const string& fa
 }
 
 ObjectPtr
-IceInternal::ServantManager::findDefaultServant(const string& category) const
+IceInternal::ServantManager::findDefaultServant(const string_view category) const
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    DefaultServantMap::const_iterator p = _defaultServantMap.find(category);
-    if(p == _defaultServantMap.end())
+    auto p = _defaultServantMap.find(category);
+    if (p == _defaultServantMap.end())
     {
-        return 0;
+        return nullptr;
     }
     else
     {
@@ -251,22 +247,22 @@ IceInternal::ServantManager::findDefaultServant(const string& category) const
 FacetMap
 IceInternal::ServantManager::findAllFacets(const Identity& ident) const
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    ServantMapMap::iterator p = _servantMapMapHint;
+    auto p = _servantMapMapHint;
 
-    ServantMapMap& servantMapMap = const_cast<ServantMapMap&>(_servantMapMap);
+    auto& servantMapMap = const_cast<ServantMapMap&>(_servantMapMap);
 
-    if(p == servantMapMap.end() || p->first != ident)
+    if (p == servantMapMap.end() || p->first != ident)
     {
         p = servantMapMap.find(ident);
     }
 
-    if(p == servantMapMap.end())
+    if (p == servantMapMap.end())
     {
-        return FacetMap();
+        return {};
     }
     else
     {
@@ -278,7 +274,7 @@ IceInternal::ServantManager::findAllFacets(const Identity& ident) const
 bool
 IceInternal::ServantManager::hasServant(const Identity& ident) const
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     //
     // This assert is not valid if the adapter dispatch incoming
@@ -286,17 +282,17 @@ IceInternal::ServantManager::hasServant(const Identity& ident) const
     // requests are received over the bidir connection after the
     // adapter was deactivated.
     //
-    //assert(_instance); // Must not be called after destruction.
+    // assert(_instance); // Must not be called after destruction.
 
-    ServantMapMap::iterator p = _servantMapMapHint;
-    ServantMapMap& servantMapMap = const_cast<ServantMapMap&>(_servantMapMap);
+    auto p = _servantMapMapHint;
+    auto& servantMapMap = const_cast<ServantMapMap&>(_servantMapMap);
 
-    if(p == servantMapMap.end() || p->first != ident)
+    if (p == servantMapMap.end() || p->first != ident)
     {
         p = servantMapMap.find(ident);
     }
 
-    if(p == servantMapMap.end())
+    if (p == servantMapMap.end())
     {
         return false;
     }
@@ -309,45 +305,47 @@ IceInternal::ServantManager::hasServant(const Identity& ident) const
 }
 
 void
-IceInternal::ServantManager::addServantLocator(const ServantLocatorPtr& locator, const string& category)
+IceInternal::ServantManager::addServantLocator(ServantLocatorPtr locator, string category)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    if((_locatorMapHint != _locatorMap.end() && _locatorMapHint->first == category)
-       || _locatorMap.find(category) != _locatorMap.end())
+    if ((_locatorMapHint != _locatorMap.end() && _locatorMapHint->first == category) ||
+        _locatorMap.find(category) != _locatorMap.end())
     {
         throw AlreadyRegisteredException(__FILE__, __LINE__, "servant locator", category);
     }
 
-    _locatorMapHint = _locatorMap.insert(_locatorMapHint, pair<const string, ServantLocatorPtr>(category, locator));
+    _locatorMapHint = _locatorMap.insert(
+        _locatorMapHint,
+        pair<const string, ServantLocatorPtr>(std::move(category), std::move(locator)));
 }
 
 ServantLocatorPtr
-IceInternal::ServantManager::removeServantLocator(const string& category)
+IceInternal::ServantManager::removeServantLocator(const string_view category)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(_instance); // Must not be called after destruction.
 
-    map<string, ServantLocatorPtr>::iterator p = _locatorMap.end();
-    if(_locatorMapHint != p)
+    auto p = _locatorMap.end();
+    if (_locatorMapHint != p)
     {
-        if(_locatorMapHint->first == category)
+        if (_locatorMapHint->first == category)
         {
             p = _locatorMapHint;
         }
     }
 
-    if(p == _locatorMap.end())
+    if (p == _locatorMap.end())
     {
         p = _locatorMap.find(category);
     }
 
-    if(p == _locatorMap.end())
+    if (p == _locatorMap.end())
     {
-        throw NotRegisteredException(__FILE__, __LINE__, "servant locator", category);
+        throw NotRegisteredException(__FILE__, __LINE__, "servant locator", string{category});
     }
 
     ServantLocatorPtr locator = p->second;
@@ -357,9 +355,9 @@ IceInternal::ServantManager::removeServantLocator(const string& category)
 }
 
 ServantLocatorPtr
-IceInternal::ServantManager::findServantLocator(const string& category) const
+IceInternal::ServantManager::findServantLocator(const string_view category) const
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     //
     // This assert is not valid if the adapter dispatch incoming
@@ -367,68 +365,59 @@ IceInternal::ServantManager::findServantLocator(const string& category) const
     // requests are received over the bidir connection after the
     // adapter was deactivated.
     //
-    //assert(_instance); // Must not be called after destruction.
+    // assert(_instance); // Must not be called after destruction.
 
-    map<string, ServantLocatorPtr>& locatorMap =
-        const_cast<map<string, ServantLocatorPtr>&>(_locatorMap);
+    auto& locatorMap = const_cast<map<string, ServantLocatorPtr, std::less<>>&>(_locatorMap);
 
-    map<string, ServantLocatorPtr>::iterator p = locatorMap.end();
-    if(_locatorMapHint != locatorMap.end())
+    auto p = locatorMap.end();
+    if (_locatorMapHint != locatorMap.end())
     {
-        if(_locatorMapHint->first == category)
+        if (_locatorMapHint->first == category)
         {
             p = _locatorMapHint;
         }
     }
 
-    if(p == locatorMap.end())
+    if (p == locatorMap.end())
     {
         p = locatorMap.find(category);
     }
 
-    if(p != locatorMap.end())
+    if (p != locatorMap.end())
     {
         _locatorMapHint = p;
         return p->second;
     }
     else
     {
-        return 0;
+        return nullptr;
     }
 }
 
-IceInternal::ServantManager::ServantManager(const InstancePtr& instance, const string& adapterName)
-    : _instance(instance),
-      _adapterName(adapterName),
+IceInternal::ServantManager::ServantManager(InstancePtr instance, string adapterName)
+    : _instance(std::move(instance)),
+      _adapterName(std::move(adapterName)),
       _servantMapMapHint(_servantMapMap.end()),
       _locatorMapHint(_locatorMap.end())
 {
 }
 
-IceInternal::ServantManager::~ServantManager()
-{
-    //
-    // Don't check whether destroy() has been called. It might have
-    // not been called if the associated object adapter was not
-    // properly deactivated.
-    //
-    //assert(!_instance);
-}
+IceInternal::ServantManager::~ServantManager() = default;
 
 void
 IceInternal::ServantManager::destroy()
 {
     ServantMapMap servantMapMap;
     DefaultServantMap defaultServantMap;
-    map<string, ServantLocatorPtr> locatorMap;
+    map<string, ServantLocatorPtr, std::less<>> locatorMap;
     Ice::LoggerPtr logger;
 
     {
-        IceUtil::Mutex::Lock sync(*this);
+        lock_guard lock(_mutex);
         //
         // If the ServantManager has already been destroyed, we're done.
         //
-        if(!_instance)
+        if (!_instance)
         {
             return;
         }
@@ -443,29 +432,29 @@ IceInternal::ServantManager::destroy()
         locatorMap.swap(_locatorMap);
         _locatorMapHint = _locatorMap.end();
 
-        _instance = 0;
+        _instance = nullptr;
     }
 
-    for(map<string, ServantLocatorPtr>::const_iterator p = locatorMap.begin(); p != locatorMap.end(); ++p)
+    for (const auto& p : locatorMap)
     {
         try
         {
-            p->second->deactivate(p->first);
+            p.second->deactivate(p.first);
         }
-        catch(const Exception& ex)
+        catch (const Exception& ex)
         {
             Error out(logger);
             out << "exception during locator deactivation:\n"
-                << "object adapter: `" << _adapterName << "'\n"
-                << "locator category: `" << p->first << "'\n"
+                << "object adapter: '" << _adapterName << "'\n"
+                << "locator category: '" << p.first << "'\n"
                 << ex;
         }
-        catch(...)
+        catch (...)
         {
             Error out(logger);
             out << "unknown exception during locator deactivation:\n"
-                << "object adapter: `" << _adapterName << "'\n"
-                << "locator category: `" << p->first << "'";
+                << "object adapter: '" << _adapterName << "'\n"
+                << "locator category: '" << p.first << "'";
         }
     }
 
@@ -478,3 +467,81 @@ IceInternal::ServantManager::destroy()
     locatorMap.clear();
     defaultServantMap.clear();
 }
+
+void
+ServantManager::dispatch(IncomingRequest& request, function<void(OutgoingResponse)> sendResponse)
+{
+    const Current& current = request.current();
+    ObjectPtr servant = findServant(current.id, current.facet);
+
+    if (servant)
+    {
+        // the simple, common path.
+        servant->dispatch(request, std::move(sendResponse));
+        return;
+    }
+
+    // Else, check servant locators
+    ServantLocatorPtr locator = findServantLocator(current.id.category);
+    if (!locator && !current.id.category.empty())
+    {
+        locator = findServantLocator("");
+    }
+
+    if (locator)
+    {
+        shared_ptr<void> cookie;
+        try
+        {
+            servant = locator->locate(current, cookie);
+        }
+        catch (...)
+        {
+            // Skip the encapsulation. This allows the next batch requests in the same InputStream to proceed.
+            request.inputStream().skipEncapsulation();
+            throw;
+        }
+
+        if (servant)
+        {
+            try
+            {
+                servant->dispatch(
+                    request,
+                    [sendResponse = std::move(sendResponse), locator, servant, cookie](OutgoingResponse response)
+                    {
+                        try
+                        {
+                            locator->finished(response.current(), servant, cookie);
+                        }
+                        catch (...)
+                        {
+                            sendResponse(makeOutgoingResponse(std::current_exception(), response.current()));
+                            return; // done
+                        }
+                        sendResponse(std::move(response));
+                    });
+                return; // done
+            }
+            catch (...)
+            {
+                // When we catch an exception, the dispatch logic guarantees sendResponse was not called.
+                locator->finished(current, servant, cookie);
+                throw;
+            }
+        }
+    }
+
+    assert(!servant);
+
+    // Skip the encapsulation. This allows the next batch requests in the same InputStream to proceed.
+    request.inputStream().skipEncapsulation();
+    if (hasServant(current.id))
+    {
+        throw FacetNotExistException{__FILE__, __LINE__};
+    }
+    else
+    {
+        throw ObjectNotExistException{__FILE__, __LINE__};
+    }
+}