zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/IceLocatorDiscovery/Plugin.h

@@ -0,0 +1,47 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef LOCATOR_DISCOVERY_PLUGIN_I_H
+#define LOCATOR_DISCOVERY_PLUGIN_I_H
+
+#include <Ice/Config.h>
+#include <Ice/Plugin.h>
+#include <Ice/Locator.h>
+#include <IceUtil/Time.h>
+
+//
+// Automatically link IceLocatorDiscovery[D|++11|++11D].lib with Visual C++
+//
+#if !defined(ICE_BUILDING_ICE_LOCATOR_DISCOVERY) && defined(ICE_LOCATOR_DISCOVERY_API_EXPORTS)
+#   define ICE_BUILDING_ICE_LOCATOR_DISCOVERY
+#endif
+
+#if defined(_MSC_VER) && !defined(ICE_BUILDING_ICE_LOCATOR_DISCOVERY)
+#   pragma comment(lib, ICE_LIBNAME("IceLocatorDiscovery"))
+#endif
+
+#ifndef ICE_LOCATOR_DISCOVERY_API
+#   if defined(ICE_STATIC_LIBS)
+#       define ICE_LOCATOR_DISCOVERY_API /**/
+#   elif defined(ICE_LOCATOR_DISCOVERY_API_EXPORTS)
+#       define ICE_LOCATOR_DISCOVERY_API ICE_DECLSPEC_EXPORT
+#   else
+#       define ICE_LOCATOR_DISCOVERY_API ICE_DECLSPEC_IMPORT
+#   endif
+#endif
+
+namespace IceLocatorDiscovery
+{
+
+class ICE_LOCATOR_DISCOVERY_API Plugin : public Ice::Plugin
+{
+public:
+
+    virtual std::vector<Ice::LocatorPrxPtr> getLocators(const std::string&, const IceUtil::Time&) const = 0;
+};
+ICE_DEFINE_PTR(PluginPtr, Plugin);
+
+};
+
+#endif

data/ext/ice/cpp/src/IceLocatorDiscovery/PluginI.cpp

@@ -1,34 +1,36 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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.
-//
-// **********************************************************************
 
 #include <IceUtil/IceUtil.h>
 #include <Ice/Ice.h>
+#include <Ice/Network.h> // For getInterfacesForMulticast
+#include <Ice/LoggerUtil.h>
 
+#include <IceLocatorDiscovery/Plugin.h>
 #include <IceLocatorDiscovery/IceLocatorDiscovery.h>
 
 using namespace std;
 using namespace IceLocatorDiscovery;
 
-#ifndef ICE_LOCATOR_DISCOVERY_API
-#   ifdef ICE_LOCATOR_DISCOVERY_API_EXPORTS
-#       define ICE_LOCATOR_DISCOVERY_API ICE_DECLSPEC_EXPORT
-#   else
-#       define ICE_LOCATOR_DISCOVERY_API /**/
-#   endif
-#endif
-
 namespace
 {
 
 class LocatorI; // Forward declaration
 
-class Request : public IceUtil::Shared
+#ifdef ICE_CPP11_MAPPING
+typedef std::pair<function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)>,
+                  function<void(exception_ptr)>> AMDCallback;
+#else
+typedef Ice::AMD_Object_ice_invokePtr AMDCallback;
+#endif
+
+class Request :
+#ifdef ICE_CPP11_MAPPING
+        public std::enable_shared_from_this<Request>
+#else
+        public virtual IceUtil::Shared
+#endif
 {
 public:
 
@@ -37,7 +39,7 @@ public:
             Ice::OperationMode mode,
             const pair<const Ice::Byte*, const Ice::Byte*>& inParams,
             const Ice::Context& ctx,
-            const Ice::AMD_Object_ice_invokePtr& amdCB) :
+            const AMDCallback& amdCB) :
         _locator(locator),
         _operation(operation),
         _mode(mode),
@@ -47,8 +49,8 @@ public:
     {
     }
 
-    void invoke(const Ice::LocatorPrx&);
-    void response(const bool, const pair<const Ice::Byte*, const Ice::Byte*>&);
+    void invoke(const Ice::LocatorPrxPtr&);
+    void response(bool, const pair<const Ice::Byte*, const Ice::Byte*>&);
     void exception(const Ice::Exception&);
 
 protected:
@@ -58,47 +60,72 @@ protected:
     const Ice::OperationMode _mode;
     const Ice::Context _context;
     const Ice::ByteSeq _inParams;
-    const Ice::AMD_Object_ice_invokePtr _amdCB;
+    AMDCallback _amdCB;
+#ifdef ICE_CPP11_MAPPING
+    exception_ptr _exception;
+#else
+    IceInternal::UniquePtr<Ice::Exception> _exception;
+#endif
 
-    Ice::LocatorPrx _locatorPrx;
-    IceUtil::UniquePtr<Ice::Exception> _exception;
+    Ice::LocatorPrxPtr _locatorPrx;
 };
-typedef IceUtil::Handle<Request> RequestPtr;
+ICE_DEFINE_PTR(RequestPtr, Request);
 
-class LocatorI : public Ice::BlobjectArrayAsync, private IceUtil::TimerTask, private IceUtil::Monitor<IceUtil::Mutex>
+class LocatorI : public Ice::BlobjectArrayAsync,
+                 public IceUtil::TimerTask,
+                 private IceUtil::Monitor<IceUtil::Mutex>
+#ifdef ICE_CPP11_MAPPING
+               , public std::enable_shared_from_this<LocatorI>
+#endif
 {
 public:
 
-    LocatorI(const LookupPrx&, const Ice::PropertiesPtr&, const string&, const Ice::LocatorPrx&);
-    void setLookupReply(const LookupReplyPrx&);
+    LocatorI(const string&, const LookupPrxPtr&, const Ice::PropertiesPtr&, const string&, const Ice::LocatorPrxPtr&);
+    void setLookupReply(const LookupReplyPrxPtr&);
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*>,
+                                 function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)>,
+                                 function<void(exception_ptr)>,
+                                 const Ice::Current&);
+#else
     virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, const pair<const Ice::Byte*, const Ice::Byte*>&,
                                   const Ice::Current&);
+#endif
 
-    void foundLocator(const Ice::LocatorPrx&);
-    void invoke(const Ice::LocatorPrx&, const RequestPtr&);
+    void foundLocator(const Ice::LocatorPrxPtr&);
+    void invoke(const Ice::LocatorPrxPtr&, const RequestPtr&);
+
+    vector<Ice::LocatorPrxPtr> getLocators(const string&, const IceUtil::Time&);
+
+    void exception(const Ice::LocalException&);
 
 private:
 
     virtual void runTimerTask();
 
-    const LookupPrx _lookup;
-    const IceUtil::Time _timeout;
-    const int _retryCount;
-    const IceUtil::Time _retryDelay;
+    LookupPrxPtr _lookup;
+    vector<pair<LookupPrxPtr, LookupReplyPrxPtr> > _lookups;
+    IceUtil::Time _timeout;
+    int _retryCount;
+    IceUtil::Time _retryDelay;
     const IceUtil::TimerPtr _timer;
+    const int _traceLevel;
 
     string _instanceName;
     bool _warned;
-    LookupReplyPrx _lookupReply;
-    Ice::LocatorPrx _locator;
-    Ice::LocatorPrx _voidLocator;
+    Ice::LocatorPrxPtr _locator;
+    map<string, Ice::LocatorPrxPtr> _locators;
+    Ice::LocatorPrxPtr _voidLocator;
 
     IceUtil::Time _nextRetry;
+    bool _pending;
     int _pendingRetryCount;
+    size_t _failureCount;
+    bool _warnOnce;
     vector<RequestPtr> _pendingRequests;
 };
-typedef IceUtil::Handle<LocatorI> LocatorIPtr;
+ICE_DEFINE_PTR(LocatorIPtr, LocatorI);
 
 class LookupReplyI : public LookupReply
 {
@@ -108,7 +135,7 @@ public:
     {
     }
 
-    virtual void foundLocator(const Ice::LocatorPrx&, const Ice::Current&);
+    virtual void foundLocator(ICE_IN(Ice::LocatorPrxPtr), const Ice::Current&);
 
 private:
 
@@ -122,6 +149,25 @@ class VoidLocatorI : public Ice::Locator
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void
+    findObjectByIdAsync(::Ice::Identity,
+                        function<void(const shared_ptr<::Ice::ObjectPrx>&)> response,
+                        function<void(exception_ptr)>,
+                        const Ice::Current&) const
+    {
+        response(nullptr);
+    }
+
+    virtual void
+    findAdapterByIdAsync(string,
+                         function<void(const shared_ptr<::Ice::ObjectPrx>&)> response,
+                         function<void(exception_ptr)>,
+                         const Ice::Current&) const
+    {
+        response(nullptr);
+    }
+#else
     virtual void
     findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr& amdCB,
                          const Ice::Identity&,
@@ -137,46 +183,75 @@ public:
     {
         amdCB->ice_response(0);
     }
+#endif
 
-    virtual Ice::LocatorRegistryPrx
+    virtual Ice::LocatorRegistryPrxPtr
     getRegistry(const Ice::Current&) const
     {
-        return 0;
+        return ICE_NULLPTR;
     }
 };
 
-class PluginI : public Ice::Plugin
+class PluginI : public Plugin
 {
 public:
 
-    PluginI(const Ice::CommunicatorPtr&);
+    PluginI(const std::string&, const Ice::CommunicatorPtr&);
 
     virtual void initialize();
     virtual void destroy();
+    virtual vector<Ice::LocatorPrxPtr> getLocators(const string&, const IceUtil::Time&) const;
 
 private:
 
+    const string _name;
     const Ice::CommunicatorPtr _communicator;
     Ice::ObjectAdapterPtr _locatorAdapter;
     Ice::ObjectAdapterPtr _replyAdapter;
-    Ice::LocatorPrx _locatorPrx;
-    Ice::LocatorPrx _defaultLocator;
+    LocatorIPtr _locator;
+    Ice::LocatorPrxPtr _locatorPrx;
+    Ice::LocatorPrxPtr _defaultLocator;
+};
+
+#ifndef ICE_CPP11_MAPPING
+
+class CallbackI : public IceUtil::Shared
+{
+public:
+
+    CallbackI(const LocatorIPtr& locator) : _locator(locator)
+    {
+    }
+
+    void
+    completed(const Ice::AsyncResultPtr& result)
+    {
+        try
+        {
+            result->throwLocalException();
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            _locator->exception(ex);
+        }
+    }
+
+private:
+
+    LocatorIPtr _locator;
 };
 
+#endif
+
 }
 
 //
 // Plugin factory function.
 //
-extern "C"
+extern "C" ICE_LOCATOR_DISCOVERY_API Ice::Plugin*
+createIceLocatorDiscovery(const Ice::CommunicatorPtr& communicator, const string& name, const Ice::StringSeq&)
 {
-
-ICE_LOCATOR_DISCOVERY_API Ice::Plugin*
-createIceLocatorDiscovery(const Ice::CommunicatorPtr& communicator, const string&, const Ice::StringSeq&)
-{
-    return new PluginI(communicator);
-}
-
+    return new PluginI(name, communicator);
 }
 
 namespace Ice
@@ -186,12 +261,28 @@ ICE_LOCATOR_DISCOVERY_API void
 registerIceLocatorDiscovery(bool loadOnInitialize)
 {
     Ice::registerPluginFactory("IceLocatorDiscovery", createIceLocatorDiscovery, loadOnInitialize);
+
+#ifdef ICE_STATIC_LIBS
+    //
+    // Also register the UDP plugin with static builds to ensure the UDP transport is loaded.
+    //
+    registerIceUDP(true);
+#endif
 }
 
 }
 
+//
+// Objective-C function to allow Objective-C programs to register plugin.
+//
+extern "C" ICE_LOCATOR_DISCOVERY_API void
+ICEregisterIceLocatorDiscovery(bool loadOnInitialize)
+{
+    Ice::registerIceLocatorDiscovery(loadOnInitialize);
+}
 
-PluginI::PluginI(const Ice::CommunicatorPtr& communicator) : _communicator(communicator)
+PluginI::PluginI(const string& name, const Ice::CommunicatorPtr& communicator) :
+    _name(name), _communicator(communicator)
 {
 }
 
@@ -205,89 +296,83 @@ PluginI::initialize()
     string address;
     if(ipv4 && !preferIPv6)
     {
-        address = properties->getPropertyWithDefault("IceLocatorDiscovery.Address", "239.255.0.1");
+        address = properties->getPropertyWithDefault(_name + ".Address", "239.255.0.1");
     }
     else
     {
-        address = properties->getPropertyWithDefault("IceLocatorDiscovery.Address", "ff15::1");
+        address = properties->getPropertyWithDefault(_name + ".Address", "ff15::1");
     }
-    int port = properties->getPropertyAsIntWithDefault("IceLocatorDiscovery.Port", 4061);
-    string intf = properties->getProperty("IceLocatorDiscovery.Interface");
+    int port = properties->getPropertyAsIntWithDefault(_name + ".Port", 4061);
+    string intf = properties->getProperty(_name + ".Interface");
 
-    if(properties->getProperty("IceLocatorDiscovery.Reply.Endpoints").empty())
+    string lookupEndpoints = properties->getProperty(_name + ".Lookup");
+    if(lookupEndpoints.empty())
     {
-        ostringstream os;
-        os << "udp";
-        if(!intf.empty())
+        //
+        // If no lookup endpoints are specified, we get all the network interfaces and create
+        // an endpoint for each of them. We'll send UDP multicast packages on each interface.
+        //
+        IceInternal::ProtocolSupport protocol = ipv4 && !preferIPv6 ? IceInternal::EnableIPv4 : IceInternal::EnableIPv6;
+        vector<string> interfaces = IceInternal::getInterfacesForMulticast(intf, protocol);
+        ostringstream lookup;
+        for(vector<string>::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
         {
-            os << " -h \"" << intf << "\"";
+            if(p != interfaces.begin())
+            {
+                lookup << ":";
+            }
+            lookup << "udp -h \"" << address << "\" -p " << port << " --interface \"" << *p << "\"";
         }
-        properties->setProperty("IceLocatorDiscovery.Reply.Endpoints", os.str());
+        lookupEndpoints = lookup.str();
     }
-    if(properties->getProperty("IceLocatorDiscovery.Locator.Endpoints").empty())
+
+    if(properties->getProperty(_name + ".Reply.Endpoints").empty())
     {
-        properties->setProperty("IceLocatorDiscovery.Locator.AdapterId", IceUtil::generateUUID()); // Collocated adapter
+        properties->setProperty(_name + ".Reply.Endpoints", "udp -h " + (intf.empty() ? "*" : "\"" + intf + "\""));
     }
 
-    _replyAdapter = _communicator->createObjectAdapter("IceLocatorDiscovery.Reply");
-    _locatorAdapter = _communicator->createObjectAdapter("IceLocatorDiscovery.Locator");
+    if(properties->getProperty(_name + ".Locator.Endpoints").empty())
+    {
+        properties->setProperty(_name + ".Locator.AdapterId", Ice::generateUUID()); // Collocated adapter
+    }
+
+    _replyAdapter = _communicator->createObjectAdapter(_name + ".Reply");
+    _locatorAdapter = _communicator->createObjectAdapter(_name + ".Locator");
 
     // We don't want those adapters to be registered with the locator so clear their locator.
     _replyAdapter->setLocator(0);
     _locatorAdapter->setLocator(0);
 
-    string lookupEndpoints = properties->getProperty("IceLocatorDiscovery.Lookup");
-    if(lookupEndpoints.empty())
-    {
-        ostringstream os;
-        os << "udp -h \"" << address << "\" -p " << port;
-        if(!intf.empty())
-        {
-            os << " --interface \"" << intf << "\"";
-        }
-        lookupEndpoints = os.str();
-    }
-
-    Ice::ObjectPrx lookupPrx = _communicator->stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
-     // No collocation optimization for the multicast proxy!
-    lookupPrx = lookupPrx->ice_collocationOptimized(false)->ice_router(0);
-    try
-    {
-        // Ensure we can establish a connection to the multicast proxy
-        // but don't block.
-        Ice::AsyncResultPtr result = lookupPrx->begin_ice_getConnection();
-        if(result->sentSynchronously())
-        {
-            lookupPrx->end_ice_getConnection(result);
-        }
-    }
-    catch(const Ice::LocalException& ex)
-    {
-        ostringstream os;
-        os << "IceLocatorDiscovery is unable to establish a multicast connection:\n";
-        os << "proxy = " << lookupPrx << '\n';
-        os << ex;
-        throw Ice::PluginInitializationException(__FILE__, __LINE__, os.str());
-    }
+    Ice::ObjectPrxPtr lookupPrx = _communicator->stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
+    // No collocation optimization for the multicast proxy!
+    lookupPrx = lookupPrx->ice_collocationOptimized(false)->ice_router(ICE_NULLPTR);
 
-    Ice::LocatorPrx voidLocator = Ice::LocatorPrx::uncheckedCast(_locatorAdapter->addWithUUID(new VoidLocatorI()));
+    Ice::LocatorPrxPtr voidLocator = ICE_UNCHECKED_CAST(Ice::LocatorPrx,
+                                                        _locatorAdapter->addWithUUID(ICE_MAKE_SHARED(VoidLocatorI)));
 
-    string instanceName = properties->getProperty("IceLocatorDiscovery.InstanceName");
+    string instanceName = properties->getProperty(_name + ".InstanceName");
     Ice::Identity id;
     id.name = "Locator";
-    id.category = !instanceName.empty() ? instanceName : IceUtil::generateUUID();
-    LocatorIPtr locator = new LocatorI(LookupPrx::uncheckedCast(lookupPrx), properties, instanceName, voidLocator);
+    id.category = !instanceName.empty() ? instanceName : Ice::generateUUID();
+    _locator = ICE_MAKE_SHARED(LocatorI, _name, ICE_UNCHECKED_CAST(LookupPrx, lookupPrx), properties, instanceName,
+                               voidLocator);
     _defaultLocator = _communicator->getDefaultLocator();
-    _locatorPrx = Ice::LocatorPrx::uncheckedCast(_locatorAdapter->add(locator, id));
+    _locatorPrx = ICE_UNCHECKED_CAST(Ice::LocatorPrx, _locatorAdapter->add(_locator, id));
     _communicator->setDefaultLocator(_locatorPrx);
 
-    Ice::ObjectPrx lookupReply = _replyAdapter->addWithUUID(new LookupReplyI(locator))->ice_datagram();
-    locator->setLookupReply(LookupReplyPrx::uncheckedCast(lookupReply));
+    Ice::ObjectPrxPtr lookupReply = _replyAdapter->addWithUUID(ICE_MAKE_SHARED(LookupReplyI, _locator))->ice_datagram();
+    _locator->setLookupReply(ICE_UNCHECKED_CAST(LookupReplyPrx, lookupReply));
 
     _replyAdapter->activate();
     _locatorAdapter->activate();
 }
 
+vector<Ice::LocatorPrxPtr>
+PluginI::getLocators(const string& instanceName, const IceUtil::Time& waitTime) const
+{
+    return _locator->getLocators(instanceName, waitTime);
+}
+
 void
 PluginI::destroy()
 {
@@ -307,8 +392,56 @@ PluginI::destroy()
 }
 
 void
-Request::invoke(const Ice::LocatorPrx& l)
+Request::invoke(const Ice::LocatorPrxPtr& l)
 {
+#ifdef ICE_CPP11_MAPPING
+    if(l != _locatorPrx)
+    {
+        _locatorPrx = l;
+        try
+        {
+            auto self = shared_from_this();
+            l->ice_invokeAsync(_operation, _mode, _inParams,
+                               [self](bool ok, vector<Ice::Byte> outParams)
+                               {
+                                   pair<const Ice::Byte*, const Ice::Byte*> outPair;
+                                   if(outParams.empty())
+                                   {
+                                       outPair.first = outPair.second = 0;
+                                   }
+                                   else
+                                   {
+                                       outPair.first = &outParams[0];
+                                       outPair.second = outPair.first + outParams.size();
+                                   }
+                                   self->response(ok, outPair);
+                               },
+                               [self](exception_ptr e)
+                               {
+                                   try
+                                   {
+                                       rethrow_exception(e);
+                                   }
+                                   catch(const Ice::Exception& ex)
+                                   {
+                                       self->exception(ex);
+                                   }
+                               },
+                               nullptr,
+                               _context);
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            exception(ex);
+        }
+    }
+    else
+    {
+        assert(_exception); // Don't retry if the proxy didn't change
+        _amdCB.second(_exception);
+    }
+
+#else
     if(l != _locatorPrx)
     {
         _locatorPrx = l;
@@ -327,17 +460,74 @@ Request::invoke(const Ice::LocatorPrx& l)
         assert(_exception.get()); // Don't retry if the proxy didn't change
         _amdCB->ice_exception(*_exception.get());
     }
+#endif
 }
 
 void
 Request::response(bool ok, const pair<const Ice::Byte*, const Ice::Byte*>& outParams)
 {
+#ifdef ICE_CPP11_MAPPING
+    _amdCB.first(ok, outParams);
+#else
     _amdCB->ice_response(ok, outParams);
+#endif
 }
 
 void
 Request::exception(const Ice::Exception& ex)
 {
+#ifdef ICE_CPP11_MAPPING
+    try
+    {
+        ex.ice_throw();
+    }
+    catch(const Ice::RequestFailedException&)
+    {
+        _amdCB.second(current_exception());
+    }
+    catch(const Ice::UnknownException&)
+    {
+        _amdCB.second(current_exception());
+    }
+    catch(const Ice::NoEndpointException&)
+    {
+        try
+        {
+            throw Ice::ObjectNotExistException(__FILE__, __LINE__);
+        }
+        catch(...)
+        {
+            _amdCB.second(current_exception());
+        }
+    }
+    catch(const Ice::CommunicatorDestroyedException&)
+    {
+        try
+        {
+            throw Ice::ObjectNotExistException(__FILE__, __LINE__);
+        }
+        catch(...)
+        {
+            _amdCB.second(current_exception());
+        }
+    }
+    catch(const Ice::ObjectAdapterDeactivatedException&)
+    {
+        try
+        {
+            throw Ice::ObjectNotExistException(__FILE__, __LINE__);
+        }
+        catch(...)
+        {
+            _amdCB.second(current_exception());
+        }
+    }
+    catch(const Ice::Exception&)
+    {
+        _exception = current_exception();
+        _locator->invoke(_locatorPrx, shared_from_this()); // Retry with new locator proxy
+    }
+#else
     try
     {
         ex.ice_throw();
@@ -367,31 +557,98 @@ Request::exception(const Ice::Exception& ex)
         _exception.reset(ex.ice_clone());
         _locator->invoke(_locatorPrx, this); // Retry with new locator proxy
     }
+#endif
 }
 
-LocatorI::LocatorI(const LookupPrx& lookup,
+LocatorI::LocatorI(const string& name,
+                   const LookupPrxPtr& lookup,
                    const Ice::PropertiesPtr& p,
                    const string& instanceName,
-                   const Ice::LocatorPrx& voidLocator) :
+                   const Ice::LocatorPrxPtr& voidLocator) :
     _lookup(lookup),
-    _timeout(IceUtil::Time::milliSeconds(p->getPropertyAsIntWithDefault("IceLocatorDiscovery.Timeout", 300))),
-    _retryCount(p->getPropertyAsIntWithDefault("IceLocatorDiscovery.RetryCount", 3)),
-    _retryDelay(IceUtil::Time::milliSeconds(p->getPropertyAsIntWithDefault("IceLocatorDiscovery.RetryDelay", 2000))),
+    _timeout(IceUtil::Time::milliSeconds(p->getPropertyAsIntWithDefault(name + ".Timeout", 300))),
+    _retryCount(p->getPropertyAsIntWithDefault(name + ".RetryCount", 3)),
+    _retryDelay(IceUtil::Time::milliSeconds(p->getPropertyAsIntWithDefault(name + ".RetryDelay", 2000))),
     _timer(IceInternal::getInstanceTimer(lookup->ice_getCommunicator())),
+    _traceLevel(p->getPropertyAsInt(name + ".Trace.Lookup")),
     _instanceName(instanceName),
     _warned(false),
     _locator(lookup->ice_getCommunicator()->getDefaultLocator()),
     _voidLocator(voidLocator),
-    _pendingRetryCount(0)
+    _pending(false),
+    _pendingRetryCount(0),
+    _failureCount(0),
+    _warnOnce(true)
 {
+    if(_timeout < IceUtil::Time::milliSeconds(0))
+    {
+        _timeout = IceUtil::Time::milliSeconds(300);
+    }
+    if(_retryCount < 0)
+    {
+        _retryCount = 0;
+    }
+    if(_retryDelay < IceUtil::Time::milliSeconds(0))
+    {
+        _retryDelay = IceUtil::Time::milliSeconds(0);
+    }
+
+    //
+    // Create one lookup proxy per endpoint from the given proxy. We want to send a multicast
+    // datagram on each endpoint.
+    //
+    Ice::EndpointSeq endpoints = lookup->ice_getEndpoints();
+    for(vector<Ice::EndpointPtr>::const_iterator q = endpoints.begin(); q != endpoints.end(); ++q)
+    {
+        Ice::EndpointSeq single;
+        single.push_back(*q);
+        _lookups.push_back(make_pair(lookup->ice_endpoints(single), LookupReplyPrxPtr()));
+    }
+    assert(!_lookups.empty());
 }
 
 void
-LocatorI::setLookupReply(const LookupReplyPrx& lookupReply)
+LocatorI::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)
+    {
+        Ice::UDPEndpointInfoPtr info = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, p->first->ice_getEndpoints()[0]->getInfo());
+        if(info && !info->mcastInterface.empty())
+        {
+            Ice::EndpointSeq endpts = lookupReply->ice_getEndpoints();
+            for(Ice::EndpointSeq::const_iterator q = endpts.begin(); q != endpts.end(); ++q)
+            {
+                Ice::IPEndpointInfoPtr r = ICE_DYNAMIC_CAST(Ice::IPEndpointInfo, (*q)->getInfo());
+                if(r && r->host == info->mcastInterface)
+                {
+                    Ice::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.
+        }
+    }
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+LocatorI::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams,
+                          function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> responseCB,
+                          function<void(exception_ptr)> exceptionCB,
+                          const Ice::Current& current)
+{
+    invoke(nullptr, make_shared<Request>(this, current.operation, current.mode, inParams, current.ctx,
+                                         make_pair(move(responseCB), move(exceptionCB))));
+}
+#else
 void
 LocatorI::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB,
                            const pair<const Ice::Byte*, const Ice::Byte*>& inParams,
@@ -399,13 +656,76 @@ LocatorI::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB,
 {
     invoke(0, new Request(this, current.operation, current.mode, inParams, current.ctx, amdCB));
 }
+#endif
+
+vector<Ice::LocatorPrxPtr>
+LocatorI::getLocators(const string& instanceName, const IceUtil::Time& waitTime)
+{
+    //
+    // Clear locators from previous search
+    //
+    {
+        Lock sync(*this);
+        _locators.clear();
+    }
+
+    //
+    // Find a locator
+    //
+    invoke(ICE_NULLPTR, ICE_NULLPTR);
+
+    //
+    // Wait for responses
+    //
+    if(instanceName.empty())
+    {
+        IceUtil::ThreadControl::sleep(waitTime);
+    }
+    else
+    {
+        Lock sync(*this);
+        while(_locators.find(instanceName) == _locators.end() && _pending)
+        {
+            timedWait(waitTime);
+        }
+    }
+
+    //
+    // Return found locators
+    //
+    Lock sync(*this);
+    vector<Ice::LocatorPrxPtr> locators;
+    for(map<string, Ice::LocatorPrxPtr>::const_iterator p = _locators.begin(); p != _locators.end(); ++p)
+    {
+        locators.push_back(p->second);
+    }
+    return locators;
+}
 
 void
-LocatorI::foundLocator(const Ice::LocatorPrx& locator)
+LocatorI::foundLocator(const Ice::LocatorPrxPtr& locator)
 {
     Lock sync(*this);
-    if(!locator || (!_instanceName.empty() && locator->ice_getIdentity().category != _instanceName))
+
+    if(!locator)
     {
+        if(_traceLevel > 2)
+        {
+            Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+            out << "ignoring locator reply: (null locator)";
+        }
+        return;
+    }
+
+    if(!_instanceName.empty() && locator->ice_getIdentity().category != _instanceName)
+    {
+        if(_traceLevel > 2)
+        {
+            Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+            out << "ignoring locator reply: instance name doesn't match\n";
+            out << "expected = " << _instanceName;
+            out << "received = " << locator->ice_getIdentity().category;
+        }
         return;
     }
 
@@ -413,7 +733,8 @@ LocatorI::foundLocator(const Ice::LocatorPrx& locator)
     // If we already have a locator assigned, ensure the given locator
     // has the same identity, otherwise ignore it.
     //
-    if(_locator && locator->ice_getIdentity().category != _locator->ice_getIdentity().category)
+    if(!_pendingRequests.empty() &&
+       _locator && locator->ice_getIdentity().category != _locator->ice_getIdentity().category)
     {
         if(!_warned)
         {
@@ -430,19 +751,31 @@ LocatorI::foundLocator(const Ice::LocatorPrx& locator)
         return;
     }
 
-    if(_pendingRetryCount > 0) // No need to retry, we found a locator.
+    if(_pending) // No need to continue, we found a locator.
     {
-        _timer->cancel(this);
+        _timer->cancel(ICE_SHARED_FROM_THIS);
         _pendingRetryCount = 0;
+        _pending = false;
+    }
+
+    if(_traceLevel > 0)
+    {
+        Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+        out << "locator lookup succeeded:\nlocator = " << locator;
+        if(!_instanceName.empty())
+        {
+            out << "\ninstance name = " << _instanceName;
+        }
     }
 
-    if(_locator)
+    Ice::LocatorPrxPtr l = _pendingRequests.empty() ? _locators[locator->ice_getIdentity().category] : _locator;
+    if(l)
     {
         //
         // We found another locator replica, append its endpoints to the
         // current locator proxy endpoints.
         //
-        Ice::EndpointSeq newEndpoints = _locator->ice_getEndpoints();
+        Ice::EndpointSeq newEndpoints = l->ice_getEndpoints();
         Ice::EndpointSeq endpts = locator->ice_getEndpoints();
         for(Ice::EndpointSeq::const_iterator p = endpts.begin(); p != endpts.end(); ++p)
         {
@@ -463,29 +796,39 @@ LocatorI::foundLocator(const Ice::LocatorPrx& locator)
                 newEndpoints.push_back(*p);
             }
         }
-        _locator = _locator->ice_endpoints(newEndpoints);
+        l = l->ice_endpoints(newEndpoints);
+    }
+    else
+    {
+        l = locator;
+    }
+
+    if(_pendingRequests.empty())
+    {
+        _locators[locator->ice_getIdentity().category] = l;
+        notify();
     }
     else
     {
-        _locator = locator;
+        _locator = l;
         if(_instanceName.empty())
         {
             _instanceName = _locator->ice_getIdentity().category; // Stick to the first discovered locator.
         }
-    }
 
-    //
-    // Send pending requests if any.
-    //
-    for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
-    {
-        (*p)->invoke(_locator);
+        //
+        // Send pending requests if any.
+        //
+        for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+        {
+            (*p)->invoke(_locator);
+        }
+        _pendingRequests.clear();
     }
-    _pendingRequests.clear();
 }
 
 void
-LocatorI::invoke(const Ice::LocatorPrx& locator, const RequestPtr& request)
+LocatorI::invoke(const Ice::LocatorPrxPtr& locator, const RequestPtr& request)
 {
     Lock sync(*this);
     if(request && _locator && _locator != locator)
@@ -500,39 +843,168 @@ LocatorI::invoke(const Ice::LocatorPrx& locator, const RequestPtr& request)
     {
         _locator = 0;
 
-        _pendingRequests.push_back(request);
+        if(request)
+        {
+            _pendingRequests.push_back(request);
+        }
 
-        if(_pendingRetryCount == 0) // No request in progress
+        if(!_pending) // No request in progress
         {
+            _pending = true;
+            _failureCount = 0;
             _pendingRetryCount = _retryCount;
             try
             {
-                _lookup->begin_findLocator(_instanceName, _lookupReply); // Send multicast request.
-                _timer->schedule(this, _timeout);
+                if(_traceLevel > 1)
+                {
+                    Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+                    out << "looking up locator:\nlookup = " << _lookup;
+                    if(!_instanceName.empty())
+                    {
+                        out << "\ninstance name = " << _instanceName;
+                    }
+                }
+                for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::const_iterator l = _lookups.begin();
+                    l != _lookups.end(); ++l)
+                {
+#ifdef ICE_CPP11_MAPPING
+                    auto self = shared_from_this();
+                    l->first->findLocatorAsync(_instanceName, l->second, nullptr, [self](exception_ptr ex)
+                    {
+                        try
+                        {
+                            rethrow_exception(ex);
+                        }
+                        catch(const Ice::LocalException& e)
+                        {
+                            self->exception(e);
+                        }
+                    });
+#else
+                    l->first->begin_findLocator(_instanceName, l->second, Ice::newCallback(new CallbackI(this),
+                                                                                           &CallbackI::completed));
+#endif
+                }
+                _timer->schedule(ICE_SHARED_FROM_THIS, _timeout);
             }
-            catch(const Ice::LocalException&)
+            catch(const Ice::LocalException& ex)
             {
+                if(_traceLevel > 0)
+                {
+                    Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+                    out << "locator lookup failed:\nlookup = " << _lookup;
+                    if(!_instanceName.empty())
+                    {
+                        out << "\ninstance name = " << _instanceName;
+                    }
+                    out << "\n" << ex;
+                }
+
                 for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
                 {
                     (*p)->invoke(_voidLocator);
                 }
                 _pendingRequests.clear();
+                _pending = false;
                 _pendingRetryCount = 0;
             }
         }
     }
 }
 
+void
+LocatorI::exception(const Ice::LocalException& ex)
+{
+    Lock sync(*this);
+    if(++_failureCount == _lookups.size() && _pending)
+    {
+        //
+        // All the lookup calls failed, cancel the timer and propagate the error to the requests.
+        //
+        _timer->cancel(ICE_SHARED_FROM_THIS);
+        _pendingRetryCount = 0;
+        _pending = false;
+
+        if(_warnOnce)
+        {
+            Ice::Warning warn(_lookup->ice_getCommunicator()->getLogger());
+            warn << "failed to lookup locator with lookup proxy `" << _lookup << "':\n" << ex;
+            _warnOnce = false;
+        }
+
+        if(_traceLevel > 0)
+        {
+            Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+            out << "locator lookup failed:\nlookup = " << _lookup;
+            if(!_instanceName.empty())
+            {
+                out << "\ninstance name = " << _instanceName;
+            }
+            out << "\n" << ex;
+        }
+
+        if(_pendingRequests.empty())
+        {
+            notify();
+        }
+        else
+        {
+            for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+            {
+                (*p)->invoke(_voidLocator);
+            }
+           _pendingRequests.clear();
+        }
+    }
+}
+
 void
 LocatorI::runTimerTask()
 {
     Lock sync(*this);
-    if(--_pendingRetryCount > 0)
+    if(!_pending)
     {
+        assert(_pendingRequests.empty());
+        return; // The request failed
+    }
+
+    if(_pendingRetryCount > 0)
+    {
+        --_pendingRetryCount;
         try
         {
-            _lookup->begin_findLocator(_instanceName, _lookupReply); // Send multicast request.
-            _timer->schedule(this, _timeout);
+            if(_traceLevel > 1)
+            {
+                Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+                out << "retrying locator lookup:\nlookup = " << _lookup << "\nretry count = " << _pendingRetryCount;
+                if(!_instanceName.empty())
+                {
+                    out << "\ninstance name = " << _instanceName;
+                }
+            }
+            _failureCount = 0;
+            for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::const_iterator l = _lookups.begin();
+                l != _lookups.end(); ++l)
+            {
+#ifdef ICE_CPP11_MAPPING
+                    auto self = shared_from_this();
+                    l->first->findLocatorAsync(_instanceName, l->second, nullptr, [self](exception_ptr ex)
+                    {
+                        try
+                        {
+                            rethrow_exception(ex);
+                        }
+                        catch(const Ice::LocalException& e)
+                        {
+                            self->exception(e);
+                        }
+                    });
+#else
+                    l->first->begin_findLocator(_instanceName, l->second, Ice::newCallback(new CallbackI(this),
+                                                                                           &CallbackI::completed));
+#endif
+            }
+            _timer->schedule(ICE_SHARED_FROM_THIS, _timeout);
             return;
         }
         catch(const Ice::LocalException&)
@@ -541,16 +1013,36 @@ LocatorI::runTimerTask()
         _pendingRetryCount = 0;
     }
 
-    for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+    assert(_pendingRetryCount == 0);
+    _pending = false;
+
+    if(_traceLevel > 0)
     {
-        (*p)->invoke(_voidLocator); // Send pending requests on void locator.
+        Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
+        out << "locator lookup timed out:\nlookup = " << _lookup;
+        if(!_instanceName.empty())
+        {
+            out << "\ninstance name = " << _instanceName;
+        }
+    }
+
+    if(_pendingRequests.empty())
+    {
+        notify();
+    }
+    else
+    {
+        for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+        {
+            (*p)->invoke(_voidLocator); // Send pending requests on void locator.
+        }
+       _pendingRequests.clear();
     }
-    _pendingRequests.clear();
     _nextRetry = IceUtil::Time::now() + _retryDelay; // Only retry when the retry delay expires
 }
 
 void
-LookupReplyI::foundLocator(const Ice::LocatorPrx& locator, const Ice::Current&)
+LookupReplyI::foundLocator(ICE_IN(Ice::LocatorPrxPtr) locator, const Ice::Current&)
 {
     _locator->foundLocator(locator);
 }