zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,120 +1,166 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/ObjectAdapterFactory.h>
-#include <Ice/ObjectAdapterI.h>
-#include <Ice/Object.h>
-#include <Ice/LocalException.h>
-#include <Ice/Functional.h>
-#include <Ice/UUID.h>
+#include "ObjectAdapterFactory.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Object.h"
+#include "Ice/Router.h"
+#include "Ice/UUID.h"
+#include "ObjectAdapterI.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(ObjectAdapterFactory* p) { return p; }
-#endif
-
 void
-IceInternal::ObjectAdapterFactory::shutdown()
+IceInternal::ObjectAdapterFactory::shutdown() noexcept
 {
-    list<ObjectAdapterIPtr> adapters;
+    list<shared_ptr<ObjectAdapterI>> adapters;
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         //
         // Ignore shutdown requests if the object adapter factory has
         // already been shut down.
         //
-        if(!_instance)
+        if (!_instance)
         {
             return;
         }
 
         adapters = _adapters;
 
-        _instance = ICE_NULLPTR;
-        _communicator = ICE_NULLPTR;
+        _instance = nullptr;
+        _communicator = nullptr;
 
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 
-    //
-    // Deactivate outside the thread synchronization, to avoid
-    // deadlocks.
-    //
-#ifdef ICE_CPP11_COMPILER
-    for_each(adapters.begin(), adapters.end(), [](const ObjectAdapterIPtr& adapter) { adapter->deactivate(); });
-#else
-    for_each(adapters.begin(), adapters.end(), IceUtil::voidMemFun(&ObjectAdapter::deactivate));
-#endif
+    // Deactivate outside the thread synchronization, to avoid deadlocks.
+    for (const auto& adapter : adapters)
+    {
+        adapter->deactivate();
+    }
 }
 
 void
-IceInternal::ObjectAdapterFactory::waitForShutdown()
+IceInternal::ObjectAdapterFactory::waitForShutdown() noexcept
 {
-    list<ObjectAdapterIPtr> adapters;
-
+    list<shared_ptr<ObjectAdapterI>> adapters;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-
-        //
-        // First we wait for the shutdown of the factory itself.
-        //
-        while(_instance)
+        unique_lock lock(_mutex);
+        if (_shutdownCompleted)
         {
-            wait();
+            return;
         }
 
+        // First we wait for the shutdown of the factory itself.
+        _conditionVariable.wait(lock, [this] { return !_instance; });
         adapters = _adapters;
     }
 
-    //
     // Now we wait for deactivation of each object adapter.
-    //
-#ifdef ICE_CPP11_COMPILER
-    for_each(adapters.begin(), adapters.end(), [](const ObjectAdapterIPtr& adapter) { adapter->waitForDeactivate(); });
-#else
-    for_each(adapters.begin(), adapters.end(), IceUtil::voidMemFun(&ObjectAdapter::waitForDeactivate));
-#endif
+    for (const auto& adapter : adapters)
+    {
+        adapter->waitForDeactivate();
+    }
+
+    {
+        lock_guard lock(_mutex);
+        _shutdownCompleted = true;
+    }
 }
 
-bool
-IceInternal::ObjectAdapterFactory::isShutdown() const
+void
+IceInternal::ObjectAdapterFactory::waitForShutdownAsync(function<void()> completed) noexcept
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    assert(completed); // the caller (Communicator) makes sure completed is callable.
+
+    bool executeCallback = false;
+    {
+        lock_guard lock(_mutex);
+        if (_shutdownCompleted)
+        {
+            executeCallback = true; // execute outside the lock
+        }
+        else
+        {
+            // Start the shutdown completed thread if there is no callback yet.
+            if (_shutdownCompletedCallbacks.empty())
+            {
+                assert(!_shutdownCompletedThread.joinable());
+                _shutdownCompletedThread = std::thread{[self = shared_from_this()]()
+                                                       {
+                                                           self->waitForShutdown();
+                                                           vector<function<void()>> callbacks;
+                                                           {
+                                                               lock_guard lg(self->_mutex);
+                                                               callbacks = std::move(self->_shutdownCompletedCallbacks);
+                                                           }
+
+                                                           for (const auto& callback : callbacks)
+                                                           {
+                                                               callback();
+                                                           }
+                                                       }};
+            }
 
-    return _instance == 0;
+            _shutdownCompletedCallbacks.push_back(std::move(completed));
+        }
+    }
+
+    if (executeCallback)
+    {
+        completed();
+    }
+}
+
+bool
+IceInternal::ObjectAdapterFactory::isShutdown() const noexcept
+{
+    lock_guard lock(_mutex);
+    return _instance == nullptr;
 }
 
 void
-IceInternal::ObjectAdapterFactory::destroy()
+IceInternal::ObjectAdapterFactory::destroy() noexcept
 {
     //
     // First wait for shutdown to finish.
     //
     waitForShutdown();
 
-    list<ObjectAdapterIPtr> adapters;
-
+    list<shared_ptr<ObjectAdapterI>> adapters;
+    std::thread shutdownCompletedThread;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
+        // We make a copy because we want all callers of destroy to wait for the destruction of these adapters.
         adapters = _adapters;
+
+        shutdownCompletedThread = std::move(_shutdownCompletedThread); // take ownership
+    }
+
+    if (shutdownCompletedThread.joinable())
+    {
+        if (shutdownCompletedThread.get_id() == std::this_thread::get_id())
+        {
+            // destroy is called from a shutdown completed callback - this is fine, but the thread can't join itself.
+            shutdownCompletedThread.detach();
+        }
+        else
+        {
+            shutdownCompletedThread.join();
+        }
     }
 
-    //
     // Now we destroy each object adapter.
-    //
-#ifdef ICE_CPP11_COMPILER
-    for_each(adapters.begin(), adapters.end(), [](const ObjectAdapterIPtr& adapter) { adapter->destroy(); });
-#else
-    for_each(adapters.begin(), adapters.end(), IceUtil::voidMemFun(&ObjectAdapter::destroy));
-#endif
+    for (const auto& adapter : adapters)
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        adapter->destroy();
+    }
+
+    {
+        lock_guard lock(_mutex);
         _adapters.clear();
     }
 }
@@ -122,47 +168,58 @@ IceInternal::ObjectAdapterFactory::destroy()
 void
 IceInternal::ObjectAdapterFactory::updateObservers(void (ObjectAdapterI::*fn)())
 {
-    list<ObjectAdapterIPtr> adapters;
+    list<shared_ptr<ObjectAdapterI>> adapters;
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
         adapters = _adapters;
     }
-#ifdef ICE_CPP11_COMPILER
-    for_each(adapters.begin(), adapters.end(),
-        [fn](const ObjectAdapterIPtr& adapter)
-        {
-            (adapter.get() ->* fn)();
-        });
-#else
-    for_each(adapters.begin(), adapters.end(), IceUtil::voidMemFun(fn));
-#endif
+
+    for (const auto& adapter : adapters)
+    {
+        (adapter.get()->*fn)();
+    }
 }
 
 ObjectAdapterPtr
-IceInternal::ObjectAdapterFactory::createObjectAdapter(const string& name, const RouterPrxPtr& router)
+IceInternal::ObjectAdapterFactory::createObjectAdapter(
+    string name, // NOLINT(performance-unnecessary-value-param)
+    optional<Ice::RouterPrx> router,
+    optional<Ice::SSL::ServerAuthenticationOptions> serverAuthenticationOptions)
 {
-    ObjectAdapterIPtr adapter;
+    shared_ptr<ObjectAdapterI> adapter;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
-        if(!_instance)
+        if (!_instance)
         {
             throw CommunicatorDestroyedException(__FILE__, __LINE__);
         }
 
-        if(name.empty())
+        if (name.empty())
         {
             string uuid = Ice::generateUUID();
-            adapter = ICE_MAKE_SHARED(ObjectAdapterI, _instance, _communicator, ICE_SHARED_FROM_THIS, uuid, true);
+            adapter = make_shared<ObjectAdapterI>(
+                _instance,
+                _communicator,
+                shared_from_this(),
+                uuid,
+                true,
+                std::move(serverAuthenticationOptions));
         }
         else
         {
-            if(_adapterNamesInUse.find(name) != _adapterNamesInUse.end())
+            if (_adapterNamesInUse.find(name) != _adapterNamesInUse.end())
             {
                 throw AlreadyRegisteredException(__FILE__, __LINE__, "object adapter", name);
             }
-            adapter = ICE_MAKE_SHARED(ObjectAdapterI, _instance, _communicator, ICE_SHARED_FROM_THIS, name, false);
+            adapter = make_shared<ObjectAdapterI>(
+                _instance,
+                _communicator,
+                shared_from_this(),
+                name,
+                false,
+                std::move(serverAuthenticationOptions));
             _adapterNamesInUse.insert(name);
         }
     }
@@ -174,29 +231,29 @@ IceInternal::ObjectAdapterFactory::createObjectAdapter(const string& name, const
     bool initialized = false;
     try
     {
-        adapter->initialize(router);
+        adapter->initialize(std::move(router));
         initialized = true;
 
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-        if(!_instance)
+        lock_guard lock(_mutex);
+        if (!_instance)
         {
             throw CommunicatorDestroyedException(__FILE__, __LINE__);
         }
         _adapters.push_back(adapter);
     }
-    catch(const Ice::CommunicatorDestroyedException&)
+    catch (const Ice::CommunicatorDestroyedException&)
     {
-        if(initialized)
+        if (initialized)
         {
             adapter->destroy();
         }
         throw;
     }
-    catch(const std::exception&)
+    catch (const std::exception&)
     {
-        if(!name.empty())
+        if (!name.empty())
         {
-            IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+            lock_guard lock(_mutex);
             _adapterNamesInUse.erase(name);
         }
         throw;
@@ -206,51 +263,51 @@ IceInternal::ObjectAdapterFactory::createObjectAdapter(const string& name, const
 }
 
 ObjectAdapterPtr
-IceInternal::ObjectAdapterFactory::findObjectAdapter(const ObjectPrxPtr& proxy)
+IceInternal::ObjectAdapterFactory::findObjectAdapter(const ReferencePtr& reference)
 {
-    list<ObjectAdapterIPtr> adapters;
+    list<shared_ptr<ObjectAdapterI>> adapters;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
-        if(!_instance)
+        if (!_instance)
         {
-            return ICE_NULLPTR;
+            return nullptr;
         }
 
         adapters = _adapters;
     }
 
-    for(list<ObjectAdapterIPtr>::iterator p = adapters.begin(); p != adapters.end(); ++p)
+    for (const auto& adapter : adapters)
     {
         try
         {
-            if((*p)->isLocal(proxy))
+            if (adapter->isLocal(reference))
             {
-                return *p;
+                return adapter;
             }
         }
-        catch(const ObjectAdapterDeactivatedException&)
+        catch (const ObjectAdapterDestroyedException&)
         {
             // Ignore.
         }
     }
 
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 void
 IceInternal::ObjectAdapterFactory::removeObjectAdapter(const ObjectAdapterPtr& adapter)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(!_instance)
+    if (!_instance)
     {
         return;
     }
 
-    for(list<ObjectAdapterIPtr>::iterator p = _adapters.begin(); p != _adapters.end(); ++p)
+    for (auto p = _adapters.begin(); p != _adapters.end(); ++p)
     {
-        if(*p == adapter)
+        if (*p == adapter)
         {
             _adapters.erase(p);
             break;
@@ -260,26 +317,26 @@ IceInternal::ObjectAdapterFactory::removeObjectAdapter(const ObjectAdapterPtr& a
 }
 
 void
-IceInternal::ObjectAdapterFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync,
-                                                           CompressBatch compressBatch) const
+IceInternal::ObjectAdapterFactory::flushAsyncBatchRequests(
+    const CommunicatorFlushBatchAsyncPtr& outAsync,
+    CompressBatch compressBatch) const
 {
-    list<ObjectAdapterIPtr> adapters;
+    list<shared_ptr<ObjectAdapterI>> adapters;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         adapters = _adapters;
     }
 
-    for(list<ObjectAdapterIPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
+    for (const auto& adapter : adapters)
     {
-        (*p)->flushAsyncBatchRequests(outAsync, compressBatch);
+        adapter->flushAsyncBatchRequests(outAsync, compressBatch);
     }
 }
 
-IceInternal::ObjectAdapterFactory::ObjectAdapterFactory(const InstancePtr& instance,
-                                                        const CommunicatorPtr& communicator) :
-    _instance(instance),
-    _communicator(communicator)
+IceInternal::ObjectAdapterFactory::ObjectAdapterFactory(InstancePtr instance, CommunicatorPtr communicator)
+    : _instance(std::move(instance)),
+      _communicator(std::move(communicator))
 {
 }
 

data/dist/ice/cpp/src/Ice/ObjectAdapterFactory.h

@@ -1,53 +1,53 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_OBJECT_ADAPTER_FACTORY_H
 #define ICE_OBJECT_ADAPTER_FACTORY_H
 
-#include <Ice/ObjectAdapterI.h>
-#include <IceUtil/RecMutex.h>
-#include <IceUtil/Monitor.h>
+#include "ObjectAdapterI.h"
 
+#include <condition_variable>
+#include <mutex>
 #include <set>
 
 namespace IceInternal
 {
-
-class ObjectAdapterFactory : public ::IceUtil::Monitor< ::IceUtil::RecMutex>,
-#ifdef ICE_CPP11_MAPPING
-                             public std::enable_shared_from_this<ObjectAdapterFactory>
-#else
-                             public virtual IceUtil::Shared
-#endif
-{
-public:
-
-    void shutdown();
-    void waitForShutdown();
-    bool isShutdown() const;
-    void destroy();
-
-    void updateObservers(void (Ice::ObjectAdapterI::*)());
-
-    ::Ice::ObjectAdapterPtr createObjectAdapter(const std::string&, const Ice::RouterPrxPtr&);
-    ::Ice::ObjectAdapterPtr findObjectAdapter(const ::Ice::ObjectPrxPtr&);
-    void removeObjectAdapter(const ::Ice::ObjectAdapterPtr&);
-    void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, ::Ice::CompressBatch) const;
-
-    ObjectAdapterFactory(const InstancePtr&, const ::Ice::CommunicatorPtr&);
-    virtual ~ObjectAdapterFactory();
-
-private:
-
-    friend class Instance;
-
-    InstancePtr _instance;
-    ::Ice::CommunicatorPtr _communicator;
-    std::set<std::string> _adapterNamesInUse;
-    std::list<Ice::ObjectAdapterIPtr> _adapters;
-};
-
+    class ObjectAdapterFactory : public std::enable_shared_from_this<ObjectAdapterFactory>
+    {
+    public:
+        void shutdown() noexcept;
+        void waitForShutdown() noexcept;
+        void waitForShutdownAsync(std::function<void()> completed) noexcept;
+        [[nodiscard]] bool isShutdown() const noexcept;
+        void destroy() noexcept;
+
+        void updateObservers(void (Ice::ObjectAdapterI::*)());
+
+        Ice::ObjectAdapterPtr createObjectAdapter(
+            std::string name,
+            std::optional<Ice::RouterPrx>,
+            std::optional<Ice::SSL::ServerAuthenticationOptions>);
+
+        Ice::ObjectAdapterPtr findObjectAdapter(const IceInternal::ReferencePtr&);
+        void removeObjectAdapter(const Ice::ObjectAdapterPtr&);
+        void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, Ice::CompressBatch) const;
+
+        ObjectAdapterFactory(InstancePtr, Ice::CommunicatorPtr);
+        virtual ~ObjectAdapterFactory();
+
+    private:
+        friend class Instance;
+
+        InstancePtr _instance;
+        Ice::CommunicatorPtr _communicator;
+        std::set<std::string> _adapterNamesInUse;
+        std::list<std::shared_ptr<Ice::ObjectAdapterI>> _adapters;
+        std::vector<std::function<void()>> _shutdownCompletedCallbacks;
+        std::thread _shutdownCompletedThread;
+        bool _shutdownCompleted = false;
+
+        mutable std::recursive_mutex _mutex;
+        std::condition_variable_any _conditionVariable;
+    };
 }
 
 #endif

data/dist/ice/cpp/src/Ice/ObjectAdapterFactoryF.h

@@ -1,25 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_OBJECT_ADAPTER_FACTORY_F_H
 #define ICE_OBJECT_ADAPTER_FACTORY_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class ObjectAdapterFactory;
-#ifdef ICE_CPP11_MAPPING
-using ObjectAdapterFactoryPtr = ::std::shared_ptr<ObjectAdapterFactory>;
-#else
-IceUtil::Shared* upCast(ObjectAdapterFactory*);
-typedef IceInternal::Handle<ObjectAdapterFactory> ObjectAdapterFactoryPtr;
-#endif
-
+    class ObjectAdapterFactory;
+    using ObjectAdapterFactoryPtr = std::shared_ptr<ObjectAdapterFactory>;
 }
 
 #endif