zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,62 +1,26 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/ConnectRequestHandler.h>
-#include <Ice/ConnectionRequestHandler.h>
-#include <Ice/RequestHandlerFactory.h>
-#include <Ice/Instance.h>
-#include <Ice/Proxy.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/Protocol.h>
-#include <Ice/Properties.h>
-#include <Ice/ThreadPool.h>
+#include "ConnectRequestHandler.h"
+#include "ConnectionI.h"
+#include "Ice/OutgoingAsync.h"
+#include "RouterInfo.h"
 
 using namespace std;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(ConnectRequestHandler* p) { return p; }
-#endif
-
-ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref, const Ice::ObjectPrxPtr& proxy) :
-    RequestHandler(ref),
-    _proxy(proxy),
-    _initialized(false),
-    _flushing(false)
-{
-}
-
-RequestHandlerPtr
-ConnectRequestHandler::connect(const Ice::ObjectPrxPtr& proxy)
-{
-    Lock sync(*this);
-    if(!initialized())
-    {
-        _proxies.insert(proxy);
-    }
-    return _requestHandler ? _requestHandler : ICE_SHARED_FROM_THIS;
-}
-
-RequestHandlerPtr
-ConnectRequestHandler::update(const RequestHandlerPtr& previousHandler, const RequestHandlerPtr& newHandler)
-{
-    return previousHandler.get() == this ? newHandler : ICE_SHARED_FROM_THIS;
-}
+ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref) : RequestHandler(ref) {}
 
 AsyncStatus
 ConnectRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& out)
 {
     {
-        Lock sync(*this);
-        if(!_initialized)
+        unique_lock lock(_mutex);
+        if (!_initialized)
         {
-            out->cancelable(ICE_SHARED_FROM_THIS); // This will throw if the request is canceled
+            out->cancelable(shared_from_this()); // This will throw if the request is canceled
         }
 
-        if(!initialized())
+        if (!initialized(lock))
         {
             _requests.push_back(out);
             return AsyncStatusQueued;
@@ -66,23 +30,23 @@ ConnectRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& out)
 }
 
 void
-ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const Ice::LocalException& ex)
+ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, exception_ptr ex)
 {
     {
-        Lock sync(*this);
-        if(_exception)
+        unique_lock lock(_mutex);
+        if (_exception)
         {
             return; // The request has been notified of a failure already.
         }
 
-        if(!initialized())
+        if (!initialized(lock))
         {
-            for(deque<ProxyOutgoingAsyncBasePtr>::iterator p = _requests.begin(); p != _requests.end(); ++p)
+            for (auto p = _requests.begin(); p != _requests.end(); ++p)
             {
-                if(p->get() == outAsync.get())
+                if (p->get() == outAsync.get())
                 {
                     _requests.erase(p);
-                    if(outAsync->exception(ex))
+                    if (outAsync->exception(ex))
                     {
                         outAsync->invokeExceptionAsync();
                     }
@@ -97,68 +61,48 @@ ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync
 Ice::ConnectionIPtr
 ConnectRequestHandler::getConnection()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     //
     // First check for the connection, it's important otherwise the user could first get a connection
     // and then the exception if he tries to obtain the proxy cached connection mutiple times (the
     // exception can be set after the connection is set if the flush of pending requests fails).
     //
-    if(_connection)
+    if (_connection)
     {
         return _connection;
     }
-    else if(_exception)
+    else if (_exception)
     {
-        _exception->ice_throw();
-    }
-    return ICE_NULLPTR;
-}
-
-Ice::ConnectionIPtr
-ConnectRequestHandler::waitForConnection()
-{
-    Lock sync(*this);
-    if(_exception)
-    {
-        throw RetryException(*_exception);
-    }
-    //
-    // Wait for the connection establishment to complete or fail.
-    //
-    while(!_initialized && !_exception)
-    {
-        wait();
-    }
-
-    if(_exception)
-    {
-        _exception->ice_throw();
-        return 0; // Keep the compiler happy.
-    }
-    else
-    {
-        return _connection;
+        rethrow_exception(_exception);
     }
+    return nullptr;
 }
 
 void
-ConnectRequestHandler::setConnection(const Ice::ConnectionIPtr& connection, bool compress)
+ConnectRequestHandler::setConnection(Ice::ConnectionIPtr connection, bool compress)
 {
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(!_flushing && !_exception && !_connection);
-        _connection = connection;
+        _connection = std::move(connection);
         _compress = compress;
     }
 
     //
-    // If this proxy is for a non-local object, and we are using a router, then
-    // add this proxy to the router info object.
+    // If we are using a router, add this proxy to the router info object.
     //
     RouterInfoPtr ri = _reference->getRouterInfo();
-    if(ri && !ri->addProxy(_proxy, ICE_SHARED_FROM_THIS))
+
+    if (ri)
     {
-        return; // The request handler will be initialized once addProxy returns.
+        auto self = shared_from_this();
+        if (!ri->addProxyAsync(
+                _reference,
+                [self] { self->flushRequests(); },
+                [self](exception_ptr ex) { self->setException(ex); }))
+        {
+            return; // The request handler will be initialized once addProxyAsync completes.
+        }
     }
 
     //
@@ -168,77 +112,49 @@ ConnectRequestHandler::setConnection(const Ice::ConnectionIPtr& connection, bool
 }
 
 void
-ConnectRequestHandler::setException(const Ice::LocalException& ex)
+ConnectRequestHandler::setException(exception_ptr ex)
 {
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(!_flushing && !_initialized && !_exception);
         _flushing = true; // Ensures request handler is removed before processing new requests.
-        ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
+        _exception = ex;
     }
 
-    //
-    // NOTE: remove the request handler *before* notifying the requests that the connection
-    // failed. It's important to ensure that future invocations will obtain a new connect
-    // request handler once invocations are notified.
-    //
-    try
-    {
-        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
-    }
-    catch(const Ice::CommunicatorDestroyedException&)
+    for (const auto& request : _requests)
     {
-        // Ignore
-    }
-
-    for(deque<ProxyOutgoingAsyncBasePtr>::const_iterator p = _requests.begin(); p != _requests.end(); ++p)
-    {
-        if((*p)->exception(ex))
+        if (request->exception(ex))
         {
-            (*p)->invokeExceptionAsync();
+            request->invokeExceptionAsync();
         }
     }
+
     _requests.clear();
 
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         _flushing = false;
-        _proxies.clear();
-        _proxy = 0; // Break cyclic reference count.
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
-void
-ConnectRequestHandler::addedProxy()
-{
-    //
-    // The proxy was added to the router info, we're now ready to send the
-    // queued requests.
-    //
-    flushRequests();
-}
-
 bool
-ConnectRequestHandler::initialized()
+ConnectRequestHandler::initialized(unique_lock<mutex>& lock)
 {
     // Must be called with the mutex locked.
 
-    if(_initialized)
+    if (_initialized)
     {
         assert(_connection);
         return true;
     }
     else
     {
-        while(_flushing)
-        {
-            wait();
-        }
+        _conditionVariable.wait(lock, [this] { return !_flushing; });
 
-        if(_exception)
+        if (_exception)
         {
-            if(_connection)
+            if (_connection)
             {
                 //
                 // Only throw if the connection didn't get established. If
@@ -248,8 +164,7 @@ ConnectRequestHandler::initialized()
                 //
                 return true;
             }
-            _exception->ice_throw();
-            return false; // Keep the compiler happy.
+            rethrow_exception(_exception);
         }
         else
         {
@@ -262,7 +177,7 @@ void
 ConnectRequestHandler::flushRequests()
 {
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(_connection && !_initialized);
 
         //
@@ -273,35 +188,27 @@ ConnectRequestHandler::flushRequests()
         _flushing = true;
     }
 
-#ifdef ICE_CPP11_MAPPING
-    std::unique_ptr<Ice::LocalException> exception;
-#else
-    IceInternal::UniquePtr<Ice::LocalException> exception;
-#endif
-    while(!_requests.empty()) // _requests is immutable when _flushing = true
+    exception_ptr exception;
+    while (!_requests.empty()) // _requests is immutable when _flushing = true
     {
         ProxyOutgoingAsyncBasePtr& req = _requests.front();
         try
         {
-            if(req->invokeRemote(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
+            if (req->invokeRemote(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
             {
                 req->invokeSentAsync();
             }
         }
-        catch(const RetryException& ex)
+        catch (const RetryException& ex)
         {
-            ICE_SET_EXCEPTION_FROM_CLONE(exception, ex.get()->ice_clone());
-
-            // Remove the request handler before retrying.
-            _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
-
-            req->retryException(*exception);
+            exception = ex.get();
+            req->retryException();
         }
-        catch(const Ice::LocalException& ex)
+        catch (const Ice::LocalException&)
         {
-            ICE_SET_EXCEPTION_FROM_CLONE(exception, ex.ice_clone());
+            exception = current_exception();
 
-            if(req->exception(ex))
+            if (req->exception(exception))
             {
                 req->invokeExceptionAsync();
             }
@@ -309,40 +216,12 @@ ConnectRequestHandler::flushRequests()
         _requests.pop_front();
     }
 
-    //
-    // If we aren't caching the connection, don't bother creating a
-    // connection request handler. Otherwise, update the proxies
-    // request handler to use the more efficient connection request
-    // handler.
-    //
-    if(_reference->getCacheConnection() && !exception)
     {
-        _requestHandler = ICE_MAKE_SHARED(ConnectionRequestHandler, _reference, _connection, _compress);
-        for(set<Ice::ObjectPrxPtr>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
-        {
-            (*p)->_updateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler);
-        }
-    }
-
-    {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(!_initialized);
-#ifdef ICE_CPP11_MAPPING
         swap(_exception, exception);
-#else
-        _exception.swap(exception);
-#endif
         _initialized = !_exception;
         _flushing = false;
-
-        //
-        // Only remove once all the requests are flushed to
-        // guarantee serialization.
-        //
-        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
-
-        _proxies.clear();
-        _proxy = ICE_NULLPTR; // Break cyclic reference count.
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }

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

@@ -1,72 +1,51 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_CONNECT_REQUEST_HANDLER_H
 #define ICE_CONNECT_REQUEST_HANDLER_H
 
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Mutex.h>
-#include <Ice/UniquePtr.h>
-
-#include <Ice/ConnectRequestHandlerF.h>
-#include <Ice/RequestHandler.h>
-#include <Ice/Reference.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/ProxyF.h>
+#include "ConnectRequestHandlerF.h"
+#include "Reference.h"
+#include "RequestHandler.h"
+#include "RouterInfo.h"
 
+#include <condition_variable>
 #include <deque>
+#include <mutex>
 #include <set>
 
 namespace IceInternal
 {
+    class ConnectRequestHandler final : public RequestHandler,
+                                        public std::enable_shared_from_this<ConnectRequestHandler>
+    {
+    public:
+        ConnectRequestHandler(const ReferencePtr&);
 
-class ConnectRequestHandler ICE_FINAL : public RequestHandler,
-                                        public Reference::GetConnectionCallback,
-                                        public RouterInfo::AddProxyCallback,
-                                        public IceUtil::Monitor<IceUtil::Mutex>
-#ifdef ICE_CPP11_MAPPING
-                            , public std::enable_shared_from_this<ConnectRequestHandler>
-#endif
-{
-public:
-
-    ConnectRequestHandler(const ReferencePtr&, const Ice::ObjectPrxPtr&);
-
-    RequestHandlerPtr connect(const Ice::ObjectPrxPtr&);
-    virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&);
-
-    virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&);
-
-    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
-
-    virtual Ice::ConnectionIPtr getConnection();
-    virtual Ice::ConnectionIPtr waitForConnection();
-
-    virtual void setConnection(const Ice::ConnectionIPtr&, bool);
-    virtual void setException(const Ice::LocalException&);
-
-    virtual void addedProxy();
+        AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) final;
 
-private:
+        void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) final;
 
-    bool initialized();
-    void flushRequests();
+        Ice::ConnectionIPtr getConnection() final;
 
-    Ice::ObjectPrxPtr _proxy;
-    std::set<Ice::ObjectPrxPtr> _proxies;
+        // setConnection and setException are the response and exception for RoutableReference::getConnectionAsync.
+        void setConnection(Ice::ConnectionIPtr, bool);
+        void setException(std::exception_ptr);
 
-    Ice::ConnectionIPtr _connection;
-    bool _compress;
-    IceInternal::UniquePtr<Ice::LocalException> _exception;
-    bool _initialized;
-    bool _flushing;
+    private:
+        bool initialized(std::unique_lock<std::mutex>&);
+        void flushRequests();
 
-    std::deque<ProxyOutgoingAsyncBasePtr> _requests;
+        Ice::ConnectionIPtr _connection;
+        bool _compress;
+        std::exception_ptr _exception;
+        bool _initialized{false};
+        bool _flushing{false};
 
-    RequestHandlerPtr _requestHandler;
-};
+        std::deque<ProxyOutgoingAsyncBasePtr> _requests;
 
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
 }
 
 #endif

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

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

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

@@ -0,0 +1,44 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Connection.h"
+
+using namespace Ice;
+using namespace std;
+
+// Implement virtual destructors out of line to avoid weak vtables.
+Ice::ConnectionInfo::~ConnectionInfo() = default;
+Ice::IPConnectionInfo::~IPConnectionInfo() = default;
+Ice::TCPConnectionInfo::~TCPConnectionInfo() = default;
+Ice::UDPConnectionInfo::~UDPConnectionInfo() = default;
+Ice::WSConnectionInfo::~WSConnectionInfo() = default;
+Ice::IAPConnectionInfo::~IAPConnectionInfo() = default;
+
+Ice::Connection::~Connection() = default; // avoid weak vtable
+
+void
+Ice::Connection::flushBatchRequests(CompressBatch compress)
+{
+    flushBatchRequestsAsync(compress).get();
+}
+
+std::future<void>
+Ice::Connection::flushBatchRequestsAsync(CompressBatch compress)
+{
+    auto promise = std::make_shared<std::promise<void>>();
+    flushBatchRequestsAsync(
+        compress,
+        [promise](std::exception_ptr ex) { promise->set_exception(ex); },
+        [promise](bool) { promise->set_value(); });
+    return promise->get_future();
+}
+
+future<void>
+Ice::Connection::close()
+{
+    auto sharedPromise = make_shared<promise<void>>();
+    close(
+        [sharedPromise]() { sharedPromise->set_value(); },
+        [sharedPromise](exception_ptr closeException) { sharedPromise->set_exception(closeException); });
+
+    return sharedPromise->get_future();
+}