zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/IceDiscovery/LocatorI.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -14,6 +14,8 @@
 #include <Ice/Communicator.h>
 #include <Ice/ObjectAdapter.h>
 
+#include <iterator>
+
 using namespace std;
 using namespace Ice;
 using namespace IceDiscovery;
@@ -23,11 +25,20 @@ LocatorRegistryI::LocatorRegistryI(const Ice::CommunicatorPtr& com) :
 {
 }
 
-void 
-LocatorRegistryI::setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb, 
-                                              const std::string& adapterId, 
-                                              const ObjectPrx& proxy, 
+#ifdef ICE_CPP11_MAPPING
+void
+LocatorRegistryI::setAdapterDirectProxyAsync(string adapterId,
+                                              shared_ptr<ObjectPrx> proxy,
+                                              function<void()> response,
+                                              function<void(exception_ptr)>,
+                                              const Ice::Current&)
+#else
+void
+LocatorRegistryI::setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb,
+                                              const std::string& adapterId,
+                                              const ObjectPrxPtr& proxy,
                                               const Current&)
+#endif
 {
     Lock sync(*this);
     if(proxy)
@@ -38,16 +49,30 @@ LocatorRegistryI::setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapt
     {
         _adapters.erase(adapterId);
     }
+#ifdef ICE_CPP11_MAPPING
+    response();
+#else
     cb->ice_response();
+#endif
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+LocatorRegistryI::setReplicatedAdapterDirectProxyAsync(string adapterId,
+                                                        string replicaGroupId,
+                                                        shared_ptr<ObjectPrx> proxy,
+                                                        function<void()> response,
+                                                        function<void(exception_ptr)>,
+                                                        const Ice::Current&)
+#else
 void
 LocatorRegistryI::setReplicatedAdapterDirectProxy_async(
     const AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr& cb,
     const std::string& adapterId,
     const std::string& replicaGroupId,
-    const ObjectPrx& proxy, 
+    const ObjectPrxPtr& proxy,
     const Current&)
+#endif
 {
     Lock sync(*this);
     if(proxy)
@@ -73,19 +98,35 @@ LocatorRegistryI::setReplicatedAdapterDirectProxy_async(
             }
         }
     }
+#ifdef ICE_CPP11_MAPPING
+    response();
+#else
     cb->ice_response();
+#endif
 }
 
+#ifdef ICE_CPP11_MAPPING
 void
-LocatorRegistryI::setServerProcessProxy_async(const AMD_LocatorRegistry_setServerProcessProxyPtr& cb, 
-                                              const std::string&, 
-                                              const ProcessPrx&,
+LocatorRegistryI::setServerProcessProxyAsync(string,
+                                              shared_ptr<ProcessPrx>,
+                                              function<void()> response,
+                                              function<void(exception_ptr)>,
+                                              const Ice::Current&)
+{
+    response();
+}
+#else
+void
+LocatorRegistryI::setServerProcessProxy_async(const AMD_LocatorRegistry_setServerProcessProxyPtr& cb,
+                                              const std::string&,
+                                              const ProcessPrxPtr&,
                                               const Current&)
 {
     cb->ice_response();
 }
+#endif
 
-Ice::ObjectPrx 
+Ice::ObjectPrxPtr
 LocatorRegistryI::findObject(const Ice::Identity& id) const
 {
     Lock sync(*this);
@@ -94,7 +135,7 @@ LocatorRegistryI::findObject(const Ice::Identity& id) const
         return 0;
     }
 
-    Ice::ObjectPrx prx = _wellKnownProxy->ice_identity(id);
+    Ice::ObjectPrxPtr prx = _wellKnownProxy->ice_identity(id);
 
     vector<string> adapterIds;
     for(map<string, set<string> >::const_iterator p = _replicaGroups.begin(); p != _replicaGroups.end(); ++p)
@@ -112,7 +153,7 @@ LocatorRegistryI::findObject(const Ice::Identity& id) const
 
     if(adapterIds.empty())
     {
-        for(map<string, Ice::ObjectPrx>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p)
+        for(map<string, Ice::ObjectPrxPtr>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p)
         {
             try
             {
@@ -135,12 +176,12 @@ LocatorRegistryI::findObject(const Ice::Identity& id) const
     return prx->ice_adapterId(adapterIds[0]);
 }
 
-Ice::ObjectPrx 
+Ice::ObjectPrxPtr
 LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) const
 {
     Lock sync(*this);
 
-    map<string, Ice::ObjectPrx>::const_iterator p = _adapters.find(adapterId);
+    map<string, Ice::ObjectPrxPtr>::const_iterator p = _adapters.find(adapterId);
     if(p != _adapters.end())
     {
         isReplicaGroup = false;
@@ -151,10 +192,10 @@ LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) con
     if(q != _replicaGroups.end())
     {
         Ice::EndpointSeq endpoints;
-        Ice::ObjectPrx prx;
+        Ice::ObjectPrxPtr prx;
         for(set<string>::const_iterator r = q->second.begin(); r != q->second.end(); ++r)
         {
-            map<string, Ice::ObjectPrx>::const_iterator s = _adapters.find(*r);
+            map<string, Ice::ObjectPrxPtr>::const_iterator s = _adapters.find(*r);
             if(s == _adapters.end())
             {
                 continue; // TODO: Inconsistency
@@ -175,34 +216,53 @@ LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) con
             return prx->ice_endpoints(endpoints);
         }
     }
-    
+
     isReplicaGroup = false;
     return 0;
 }
 
-LocatorI::LocatorI(const LookupIPtr& lookup, const LocatorRegistryPrx& registry) : _lookup(lookup), _registry(registry)
+LocatorI::LocatorI(const LookupIPtr& lookup, const LocatorRegistryPrxPtr& registry) : _lookup(lookup), _registry(registry)
+{
+}
+
+#ifdef ICE_CPP11_MAPPING
+void
+LocatorI::findObjectByIdAsync(Ice::Identity id,
+                              function<void(const shared_ptr<ObjectPrx>&)> response,
+                              function<void(exception_ptr)> ex,
+                              const Ice::Current&) const
 {
+    _lookup->findObject(make_pair(response, ex), id);
 }
 
-void 
-LocatorI::findObjectById_async(const AMD_Locator_findObjectByIdPtr& cb, 
-                               const Identity& id, 
+void
+LocatorI::findAdapterByIdAsync(string adapterId,
+                               function<void(const shared_ptr<ObjectPrx>&)> response,
+                               function<void(exception_ptr)> ex,
+                               const Ice::Current&) const
+{
+    _lookup->findAdapter(make_pair(response, ex), adapterId);
+}
+#else
+void
+LocatorI::findObjectById_async(const AMD_Locator_findObjectByIdPtr& cb,
+                               const Identity& id,
                                const Current&) const
 {
     _lookup->findObject(cb, id);
 }
 
-void 
-LocatorI::findAdapterById_async(const AMD_Locator_findAdapterByIdPtr& cb, 
-                                const std::string& adapterId, 
+void
+LocatorI::findAdapterById_async(const AMD_Locator_findAdapterByIdPtr& cb,
+                                const std::string& adapterId,
                                 const Current&) const
 {
     _lookup->findAdapter(cb, adapterId);
 }
+#endif
 
-LocatorRegistryPrx 
+LocatorRegistryPrxPtr
 LocatorI::getRegistry(const Current&) const
 {
     return _registry;
 }
-

data/ext/ice/cpp/src/IceDiscovery/LocatorI.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -23,54 +23,90 @@ class LocatorRegistryI : public Ice::LocatorRegistry, private IceUtil::Mutex
 public:
 
     LocatorRegistryI(const Ice::CommunicatorPtr&);
-    
-    virtual void 
-    setAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setAdapterDirectProxyPtr&, const std::string&, 
+
+#ifdef ICE_CPP11_MAPPING
+    virtual void
+    setAdapterDirectProxyAsync(std::string,
+                               std::shared_ptr<Ice::ObjectPrx>,
+                               std::function<void()>,
+                               std::function<void(std::exception_ptr)>,
+                               const Ice::Current&);
+
+    virtual void
+    setReplicatedAdapterDirectProxyAsync(std::string,
+                                         std::string,
+                                         std::shared_ptr<Ice::ObjectPrx>,
+                                         std::function<void()>,
+                                         std::function<void(std::exception_ptr)>,
+                                         const Ice::Current&);
+
+    virtual void
+    setServerProcessProxyAsync(std::string,
+                               std::shared_ptr<Ice::ProcessPrx>,
+                               std::function<void()>,
+                               std::function<void(std::exception_ptr)>,
+                               const Ice::Current&);
+#else
+    virtual void
+    setAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setAdapterDirectProxyPtr&, const std::string&,
                                 const Ice::ObjectPrx&, const Ice::Current&);
 
     virtual void
     setReplicatedAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr&,
-                                          const std::string&, const std::string&, const Ice::ObjectPrx&, 
+                                          const std::string&, const std::string&, const Ice::ObjectPrx&,
                                           const Ice::Current&);
 
-    virtual void 
-    setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr&, const std::string&, 
+    virtual void
+    setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr&, const std::string&,
                                 const Ice::ProcessPrx&, const Ice::Current&);
-
-    Ice::ObjectPrx findObject(const Ice::Identity&) const;
-    Ice::ObjectPrx findAdapter(const std::string&, bool&) const;
+#endif
+    Ice::ObjectPrxPtr findObject(const Ice::Identity&) const;
+    Ice::ObjectPrxPtr findAdapter(const std::string&, bool&) const;
 
 private:
 
-    const Ice::ObjectPrx _wellKnownProxy;
-    std::map<std::string, Ice::ObjectPrx> _adapters;
+    const Ice::ObjectPrxPtr _wellKnownProxy;
+    std::map<std::string, Ice::ObjectPrxPtr> _adapters;
     std::map<std::string, std::set<std::string> > _replicaGroups;
 };
-typedef IceInternal::Handle<LocatorRegistryI> LocatorRegistryIPtr;
+ICE_DEFINE_PTR(LocatorRegistryIPtr, LocatorRegistryI);
 
 class LookupI;
-typedef IceInternal::Handle<LookupI> LookupIPtr;
+ICE_DEFINE_PTR(LookupIPtr, LookupI);
 
 class LocatorI : public Ice::Locator
 {
 public:
 
-    LocatorI(const LookupIPtr&, const Ice::LocatorRegistryPrx&);
+    LocatorI(const LookupIPtr&, const Ice::LocatorRegistryPrxPtr&);
 
-    virtual void 
-    findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr&, const Ice::Identity&, 
+#ifdef ICE_CPP11_MAPPING
+    virtual void
+    findObjectByIdAsync(Ice::Identity,
+                        std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
+                        std::function<void(std::exception_ptr)>,
+                        const Ice::Current&) const;
+
+    virtual void
+    findAdapterByIdAsync(std::string,
+                         std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
+                         std::function<void(std::exception_ptr)>,
+                         const Ice::Current&) const;
+#else
+    virtual void
+    findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr&, const Ice::Identity&,
                          const Ice::Current&) const;
 
-    virtual void 
-    findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr&, const std::string&, 
+    virtual void
+    findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr&, const std::string&,
                           const Ice::Current&) const;
-
-    virtual Ice::LocatorRegistryPrx getRegistry(const Ice::Current&) const;
+#endif
+    virtual Ice::LocatorRegistryPrxPtr getRegistry(const Ice::Current&) const;
 
 private:
-    
+
     LookupIPtr _lookup;
-    Ice::LocatorRegistryPrx _registry;
+    Ice::LocatorRegistryPrxPtr _registry;
 };
 
 };

data/ext/ice/cpp/src/IceDiscovery/LookupI.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -12,48 +12,145 @@
 #include <Ice/Communicator.h>
 #include <Ice/LocalException.h>
 #include <Ice/Initialize.h>
-#include <IceUtil/UUID.h>
+#include <Ice/LoggerUtil.h>
+#include <Ice/UUID.h>
+
 #include <IceDiscovery/LookupI.h>
+#include <iterator>
 
 using namespace std;
 using namespace Ice;
 using namespace IceDiscovery;
 
+#ifndef ICE_CPP11_MAPPING
+namespace
+{
+
+class AdapterCallbackI : public IceUtil::Shared
+{
+public:
+
+    AdapterCallbackI(const LookupIPtr& lookup, const AdapterRequestPtr& request) : _lookup(lookup), _request(request)
+    {
+    }
+
+    void
+    completed(const Ice::AsyncResultPtr& result)
+    {
+        try
+        {
+            result->throwLocalException();
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            _lookup->adapterRequestException(_request, ex);
+        }
+    }
+
+private:
+
+    LookupIPtr _lookup;
+    AdapterRequestPtr _request;
+};
+
+class ObjectCallbackI : public IceUtil::Shared
+{
+public:
+
+    ObjectCallbackI(const LookupIPtr& lookup, const ObjectRequestPtr& request) : _lookup(lookup), _request(request)
+    {
+    }
+
+    void
+    completed(const Ice::AsyncResultPtr& result)
+    {
+        try
+        {
+            result->throwLocalException();
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            _lookup->objectRequestException(_request, ex);
+        }
+    }
+
+private:
+
+    LookupIPtr _lookup;
+    ObjectRequestPtr _request;
+};
+
+}
+#endif
+
 IceDiscovery::Request::Request(const LookupIPtr& lookup, int retryCount) :
-    _lookup(lookup), _nRetry(retryCount), _requestId(IceUtil::generateUUID())
+    _lookup(lookup), _requestId(Ice::generateUUID()), _retryCount(retryCount), _lookupCount(0), _failureCount(0)
 {
 }
 
 bool
 IceDiscovery::Request::retry()
 {
-    return --_nRetry >= 0;
+    return --_retryCount >= 0;
+}
+
+void
+IceDiscovery::Request::invoke(const string& domainId, const vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >& lookups)
+{
+    _lookupCount = lookups.size();
+    _failureCount = 0;
+    Ice::Identity id;
+    id.name = _requestId;
+    for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::const_iterator p = lookups.begin(); p != lookups.end(); ++p)
+    {
+        invokeWithLookup(domainId, p->first, ICE_UNCHECKED_CAST(LookupReplyPrx, p->second->ice_identity(id)));
+    }
+}
+
+bool
+IceDiscovery::Request::exception()
+{
+    //
+    // If all the invocations on all the lookup proxies failed, report it to the locator.
+    //
+    if(++_failureCount == _lookupCount)
+    {
+        finished(0);
+        return true;
+    }
+    return false;
 }
 
-const string&
+string
 IceDiscovery::Request::getRequestId() const
 {
     return _requestId;
 }
 
+AdapterRequest::AdapterRequest(const LookupIPtr& lookup, const std::string& adapterId, int retryCount) :
+    RequestT<std::string, AdapterCB>(lookup, adapterId, retryCount),
+    _start(IceUtil::Time::now())
+{
+}
+
 bool
 AdapterRequest::retry()
 {
-    return _proxies.empty() && --_nRetry >= 0;
+    return _proxies.empty() && --_retryCount >= 0;
 }
 
 bool
-AdapterRequest::response(const Ice::ObjectPrx& proxy, bool isReplicaGroup)
+AdapterRequest::response(const Ice::ObjectPrxPtr& proxy, bool isReplicaGroup)
 {
     if(isReplicaGroup)
     {
         if(_latency == IceUtil::Time())
         {
             _latency = (IceUtil::Time::now() - _start) * _lookup->latencyMultiplier();
-            _lookup->timer()->cancel(this);
-            _lookup->timer()->schedule(this, _latency);
+            _lookup->timer()->cancel(ICE_SHARED_FROM_THIS);
+            _lookup->timer()->schedule(ICE_SHARED_FROM_THIS, _latency);
         }
-        _proxies.push_back(proxy);
+        _proxies.insert(proxy);
         return false;
     }
     finished(proxy);
@@ -61,60 +158,123 @@ AdapterRequest::response(const Ice::ObjectPrx& proxy, bool isReplicaGroup)
 }
 
 void
-AdapterRequest::finished(const Ice::ObjectPrx& proxy)
+AdapterRequest::finished(const ObjectPrxPtr& proxy)
 {
     if(proxy || _proxies.empty())
     {
-        RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(proxy);
-        return;
+        RequestT<string, AdapterCB>::finished(proxy);
     }
     else if(_proxies.size() == 1)
     {
-        RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(_proxies[0]);
-        return;
+        RequestT<string, AdapterCB>::finished(*_proxies.begin());
     }
-
-    Ice::EndpointSeq endpoints;
-    Ice::ObjectPrx prx;
-    for(vector<Ice::ObjectPrx>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
+    else
     {
-        if(!prx)
+        EndpointSeq endpoints;
+        ObjectPrxPtr prx;
+        for(set<ObjectPrxPtr>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
         {
-            prx = *p;
+            if(!prx)
+            {
+                prx = *p;
+            }
+            Ice::EndpointSeq endpts = (*p)->ice_getEndpoints();
+            copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
         }
-        Ice::EndpointSeq endpts = (*p)->ice_getEndpoints();
-        copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
+        RequestT<string, AdapterCB>::finished(prx->ice_endpoints(endpoints));
     }
-    RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(prx->ice_endpoints(endpoints));
+}
+
+void
+AdapterRequest::invokeWithLookup(const string& domainId, const LookupPrxPtr& lookup, const LookupReplyPrxPtr& lookupReply)
+{
+#ifdef ICE_CPP11_MAPPING
+    auto self = ICE_SHARED_FROM_THIS;
+    lookup->findAdapterByIdAsync(domainId, _id, lookupReply, nullptr, [self](exception_ptr ex)
+    {
+        try
+        {
+            rethrow_exception(ex);
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            self->_lookup->adapterRequestException(self, ex);
+        }
+    });
+#else
+    lookup->begin_findAdapterById(domainId, _id, lookupReply, newCallback(new AdapterCallbackI(_lookup, this),
+                                                                          &AdapterCallbackI::completed));
+#endif
 }
 
 void
 AdapterRequest::runTimerTask()
 {
-    _lookup->adapterRequestTimedOut(this);
+    _lookup->adapterRequestTimedOut(ICE_SHARED_FROM_THIS);
+}
+
+ObjectRequest::ObjectRequest(const LookupIPtr& lookup, const Ice::Identity& id, int retryCount) :
+    RequestT<Ice::Identity, ObjectCB>(lookup, id, retryCount)
+{
 }
 
 void
-ObjectRequest::response(const Ice::ObjectPrx& proxy)
+ObjectRequest::response(const Ice::ObjectPrxPtr& proxy)
 {
     finished(proxy);
 }
 
+void
+ObjectRequest::invokeWithLookup(const string& domainId, const LookupPrxPtr& lookup, const LookupReplyPrxPtr& lookupReply)
+{
+#ifdef ICE_CPP11_MAPPING
+    auto self = ICE_SHARED_FROM_THIS;
+    lookup->findObjectByIdAsync(domainId, _id, lookupReply, nullptr, [self](exception_ptr ex)
+    {
+        try
+        {
+            rethrow_exception(ex);
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            self->_lookup->objectRequestException(self, ex);
+        }
+    });
+#else
+    lookup->begin_findObjectById(domainId, _id, lookupReply, newCallback(new ObjectCallbackI(_lookup, this),
+                                                                         &ObjectCallbackI::completed));
+
+#endif
+}
+
 void
 ObjectRequest::runTimerTask()
 {
-    _lookup->objectRequestTimedOut(this);
+    _lookup->objectRequestTimedOut(ICE_SHARED_FROM_THIS);
 }
 
-LookupI::LookupI(const LocatorRegistryIPtr& registry, const LookupPrx& lookup, const Ice::PropertiesPtr& properties) :
+LookupI::LookupI(const LocatorRegistryIPtr& registry, const LookupPrxPtr& lookup, const Ice::PropertiesPtr& properties) :
     _registry(registry),
     _lookup(lookup),
     _timeout(IceUtil::Time::milliSeconds(properties->getPropertyAsIntWithDefault("IceDiscovery.Timeout", 300))),
     _retryCount(properties->getPropertyAsIntWithDefault("IceDiscovery.RetryCount", 3)),
     _latencyMultiplier(properties->getPropertyAsIntWithDefault("IceDiscovery.LatencyMultiplier", 1)),
     _domainId(properties->getProperty("IceDiscovery.DomainId")),
-    _timer(IceInternal::getInstanceTimer(lookup->ice_getCommunicator()))
+    _timer(IceInternal::getInstanceTimer(lookup->ice_getCommunicator())),
+    _warnOnce(true)
 {
+    //
+    // Create one lookup proxy per endpoint from the given proxy. We want to send a multicast
+    // datagram on each endpoint.
+    //
+    EndpointSeq endpoints = lookup->ice_getEndpoints();
+    for(vector<EndpointPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
+    {
+        EndpointSeq single;
+        single.push_back(*p);
+        _lookups.push_back(make_pair(lookup->ice_endpoints(single), LookupReplyPrxPtr()));
+    }
+    assert(!_lookups.empty());
 }
 
 LookupI::~LookupI()
@@ -130,6 +290,7 @@ LookupI::destroy()
         p->second->finished(0);
         _timer->cancel(p->second);
     }
+    _objectRequests.clear();
 
     for(map<string, AdapterRequestPtr>::const_iterator p = _adapterRequests.begin(); p != _adapterRequests.end(); ++p)
     {
@@ -140,13 +301,38 @@ LookupI::destroy()
 }
 
 void
-LookupI::setLookupReply(const LookupReplyPrx& lookupReply)
+LookupI::setLookupReply(const LookupReplyPrxPtr& lookupReply)
 {
-    _lookupReply = lookupReply;
+    //
+    // Use a lookup reply proxy whose adress matches the interface used to send multicast datagrams.
+    //
+    for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::iterator p = _lookups.begin(); p != _lookups.end(); ++p)
+    {
+        UDPEndpointInfoPtr info = ICE_DYNAMIC_CAST(UDPEndpointInfo, p->first->ice_getEndpoints()[0]->getInfo());
+        if(info && !info->mcastInterface.empty())
+        {
+            EndpointSeq endpts = lookupReply->ice_getEndpoints();
+            for(EndpointSeq::const_iterator q = endpts.begin(); q != endpts.end(); ++q)
+            {
+                IPEndpointInfoPtr r = ICE_DYNAMIC_CAST(IPEndpointInfo, (*q)->getInfo());
+                if(r && r->host == info->mcastInterface)
+                {
+                    EndpointSeq single;
+                    single.push_back(*q);
+                    p->second = lookupReply->ice_endpoints(single);
+                }
+            }
+        }
+
+        if(!p->second)
+        {
+            p->second = lookupReply; // Fallback: just use the given lookup reply proxy if no matching endpoint found.
+        }
+    }
 }
 
 void
-LookupI::findObjectById(const string& domainId, const Ice::Identity& id, const IceDiscovery::LookupReplyPrx& reply,
+LookupI::findObjectById(ICE_IN(string) domainId, ICE_IN(Ice::Identity) id, ICE_IN(LookupReplyPrxPtr) reply,
                         const Ice::Current&)
 {
     if(domainId != _domainId)
@@ -154,7 +340,7 @@ LookupI::findObjectById(const string& domainId, const Ice::Identity& id, const I
         return; // Ignore.
     }
 
-    Ice::ObjectPrx proxy = _registry->findObject(id);
+    Ice::ObjectPrxPtr proxy = _registry->findObject(id);
     if(proxy)
     {
         //
@@ -162,7 +348,11 @@ LookupI::findObjectById(const string& domainId, const Ice::Identity& id, const I
         //
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            reply->foundObjectByIdAsync(id, proxy);
+#else
             reply->begin_foundObjectById(id, proxy);
+#endif
         }
         catch(const Ice::LocalException&)
         {
@@ -172,8 +362,8 @@ LookupI::findObjectById(const string& domainId, const Ice::Identity& id, const I
 }
 
 void
-LookupI::findAdapterById(const string& domainId, const std::string& adapterId,
-                         const IceDiscovery::LookupReplyPrx& reply, const Ice::Current&)
+LookupI::findAdapterById(ICE_IN(string) domainId, ICE_IN(string) adapterId, ICE_IN(LookupReplyPrxPtr) reply,
+                         const Ice::Current&)
 {
     if(domainId != _domainId)
     {
@@ -181,7 +371,7 @@ LookupI::findAdapterById(const string& domainId, const std::string& adapterId,
     }
 
     bool isReplicaGroup;
-    Ice::ObjectPrx proxy = _registry->findAdapter(adapterId, isReplicaGroup);
+    Ice::ObjectPrxPtr proxy = _registry->findAdapter(adapterId, isReplicaGroup);
     if(proxy)
     {
         //
@@ -189,7 +379,11 @@ LookupI::findAdapterById(const string& domainId, const std::string& adapterId,
         //
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            reply->foundAdapterByIdAsync(adapterId, proxy, isReplicaGroup);
+#else
             reply->begin_foundAdapterById(adapterId, proxy, isReplicaGroup);
+#endif
         }
         catch(const Ice::LocalException&)
         {
@@ -199,65 +393,63 @@ LookupI::findAdapterById(const string& domainId, const std::string& adapterId,
 }
 
 void
-LookupI::findObject(const Ice::AMD_Locator_findObjectByIdPtr& cb, const Ice::Identity& id)
+LookupI::findObject(const ObjectCB& cb, const Ice::Identity& id)
 {
     Lock sync(*this);
     map<Ice::Identity, ObjectRequestPtr>::iterator p = _objectRequests.find(id);
     if(p == _objectRequests.end())
     {
-        p = _objectRequests.insert(make_pair(id, new ObjectRequest(this, id, _retryCount))).first;
+        p = _objectRequests.insert(make_pair(id, ICE_MAKE_SHARED(ObjectRequest,
+                                                                 ICE_SHARED_FROM_THIS,
+                                                                 id,
+                                                                 _retryCount))).first;
     }
 
     if(p->second->addCallback(cb))
     {
         try
         {
-            Ice::Identity ident;
-            ident.name = p->second->getRequestId();
-            _lookup->begin_findObjectById(_domainId,
-                                          id,
-                                          LookupReplyPrx::uncheckedCast(_lookupReply->ice_identity(ident)));
+            p->second->invoke(_domainId, _lookups);
             _timer->schedule(p->second, _timeout);
         }
         catch(const Ice::LocalException&)
         {
-            p->second->finished(0);
+            p->second->finished(ICE_NULLPTR);
             _objectRequests.erase(p);
         }
     }
 }
 
 void
-LookupI::findAdapter(const Ice::AMD_Locator_findAdapterByIdPtr& cb, const std::string& adapterId)
+LookupI::findAdapter(const AdapterCB& cb, const std::string& adapterId)
 {
     Lock sync(*this);
     map<string, AdapterRequestPtr>::iterator p = _adapterRequests.find(adapterId);
     if(p == _adapterRequests.end())
     {
-        p = _adapterRequests.insert(make_pair(adapterId, new AdapterRequest(this, adapterId, _retryCount))).first;
+        p = _adapterRequests.insert(make_pair(adapterId, ICE_MAKE_SHARED(AdapterRequest,
+                                                                         ICE_SHARED_FROM_THIS,
+                                                                         adapterId,
+                                                                         _retryCount))).first;
     }
 
     if(p->second->addCallback(cb))
     {
         try
         {
-            Ice::Identity ident;
-            ident.name = p->second->getRequestId();
-            _lookup->begin_findAdapterById(_domainId,
-                                           adapterId,
-                                           LookupReplyPrx::uncheckedCast(_lookupReply->ice_identity(ident)));
+            p->second->invoke(_domainId, _lookups);
             _timer->schedule(p->second, _timeout);
         }
         catch(const Ice::LocalException&)
         {
-            p->second->finished(0);
+            p->second->finished(ICE_NULLPTR);
             _adapterRequests.erase(p);
         }
     }
 }
 
 void
-LookupI::foundObject(const Ice::Identity& id, const string& requestId, const Ice::ObjectPrx& proxy)
+LookupI::foundObject(const Ice::Identity& id, const string& requestId, const Ice::ObjectPrxPtr& proxy)
 {
     Lock sync(*this);
     map<Ice::Identity, ObjectRequestPtr>::iterator p = _objectRequests.find(id);
@@ -270,7 +462,7 @@ LookupI::foundObject(const Ice::Identity& id, const string& requestId, const Ice
 }
 
 void
-LookupI::foundAdapter(const std::string& adapterId, const string& requestId, const Ice::ObjectPrx& proxy,
+LookupI::foundAdapter(const string& adapterId, const string& requestId, const Ice::ObjectPrxPtr& proxy,
                       bool isReplicaGroup)
 {
     Lock sync(*this);
@@ -299,8 +491,8 @@ LookupI::objectRequestTimedOut(const ObjectRequestPtr& request)
     {
         try
         {
-            _lookup->begin_findObjectById(_domainId, request->getId(), _lookupReply);
-            _timer->schedule(p->second, _timeout);
+            request->invoke(_domainId, _lookups);
+            _timer->schedule(request, _timeout);
             return;
         }
         catch(const Ice::LocalException&)
@@ -313,6 +505,29 @@ LookupI::objectRequestTimedOut(const ObjectRequestPtr& request)
     _timer->cancel(request);
 }
 
+void
+LookupI::adapterRequestException(const AdapterRequestPtr& request, const LocalException& ex)
+{
+    Lock sync(*this);
+    map<string, AdapterRequestPtr>::iterator p = _adapterRequests.find(request->getId());
+    if(p == _adapterRequests.end() || p->second.get() != request.get())
+    {
+        return;
+    }
+
+    if(request->exception())
+    {
+        if(_warnOnce)
+        {
+            Warning warn(_lookup->ice_getCommunicator()->getLogger());
+            warn << "failed to lookup adapter `" << p->first << "' with lookup proxy `" << _lookup << "':\n" << ex;
+            _warnOnce = false;
+        }
+        _timer->cancel(request);
+        _adapterRequests.erase(p);
+    }
+}
+
 void
 LookupI::adapterRequestTimedOut(const AdapterRequestPtr& request)
 {
@@ -327,8 +542,8 @@ LookupI::adapterRequestTimedOut(const AdapterRequestPtr& request)
     {
         try
         {
-            _lookup->begin_findAdapterById(_domainId, request->getId(), _lookupReply);
-            _timer->schedule(p->second, _timeout);
+            request->invoke(_domainId, _lookups);
+            _timer->schedule(request, _timeout);
             return;
         }
         catch(const Ice::LocalException&)
@@ -341,19 +556,58 @@ LookupI::adapterRequestTimedOut(const AdapterRequestPtr& request)
     _timer->cancel(request);
 }
 
+void
+LookupI::objectRequestException(const ObjectRequestPtr& request, const LocalException& ex)
+{
+    Lock sync(*this);
+    map<Ice::Identity, ObjectRequestPtr>::iterator p = _objectRequests.find(request->getId());
+    if(p == _objectRequests.end() || p->second.get() != request.get())
+    {
+        return;
+    }
+
+    if(request->exception())
+    {
+        if(_warnOnce)
+        {
+            Warning warn(_lookup->ice_getCommunicator()->getLogger());
+            string id = _lookup->ice_getCommunicator()->identityToString(p->first);
+            warn << "failed to lookup object `" << id << "' with lookup proxy `" << _lookup << "':\n" << ex;
+            _warnOnce = false;
+        }
+        _timer->cancel(request);
+        _objectRequests.erase(p);
+    }
+}
+
 LookupReplyI::LookupReplyI(const LookupIPtr& lookup) : _lookup(lookup)
 {
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+LookupReplyI::foundObjectById(Identity id, shared_ptr<ObjectPrx> proxy, const Current& current)
+{
+    _lookup->foundObject(id, current.id.name, proxy);
+}
+
+void
+LookupReplyI::foundAdapterById(string adapterId, shared_ptr<ObjectPrx> proxy, bool isReplicaGroup,
+                               const Current& current)
+{
+    _lookup->foundAdapter(adapterId, current.id.name, proxy, isReplicaGroup);
+}
+#else
 void
-LookupReplyI::foundObjectById(const Ice::Identity& id, const Ice::ObjectPrx& proxy, const Ice::Current& current)
+LookupReplyI::foundObjectById(const Identity& id, const ObjectPrxPtr& proxy, const Current& current)
 {
     _lookup->foundObject(id, current.id.name, proxy);
 }
 
 void
-LookupReplyI::foundAdapterById(const std::string& adapterId, const Ice::ObjectPrx& proxy, bool isReplicaGroup,
-                               const Ice::Current& current)
+LookupReplyI::foundAdapterById(const string& adapterId, const ObjectPrxPtr& proxy, bool isReplicaGroup,
+                               const Current& current)
 {
     _lookup->foundAdapter(adapterId, current.id.name, proxy, isReplicaGroup);
 }
+#endif