Fixed ICE-7548 - getAdminProxy no longer returns 0 if synchronization is in progress

7 files changed, 113 insertions, 52 deletions

diff --git a/cpp/src/IceGrid/AdminRouter.cpp b/cpp/src/IceGrid/AdminRouter.cpp
index 22c6bab1535..380521140dc 100644
--- a/cpp/src/IceGrid/AdminRouter.cpp
+++ b/cpp/src/IceGrid/AdminRouter.cpp
@@ -28,13 +28,13 @@ public:
     {
         _cb->ice_response(ok, outParams);
     }
-    
+
     void exception(const Ice::Exception&)
     {
         // Admin object is unreachable
         _cb->ice_exception(ObjectNotExistException(__FILE__, __LINE__));
     }
-    
+
 private:
     AMD_Object_ice_invokePtr _cb;
 };
@@ -42,19 +42,19 @@ private:
 }
 
 void
-IceGrid::AdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, 
-                                       const pair<const Byte*, const Byte*>& inParams,
-                                       const Current& current)
+IceGrid::AdminRouter::invokeOnTarget(const Ice::ObjectPrx& target,
+                                     const AMD_Object_ice_invokePtr& cb,
+                                     const pair<const Byte*, const Byte*>& inParams,
+                                     const Current& current)
 {
-    ObjectPrx target = getTarget(current);
     assert(target != 0);
 
     //
     // Call with AMI
     //
-    Callback_Object_ice_invokePtr amiCb = 
-        newCallback_Object_ice_invoke(new CallbackI(cb), &CallbackI::response, &CallbackI::exception);
-
+    Callback_Object_ice_invokePtr amiCb = newCallback_Object_ice_invoke(new CallbackI(cb),
+                                                                        &CallbackI::response,
+                                                                        &CallbackI::exception);
     target->begin_ice_invoke(current.operation, current.mode, inParams, current.ctx, amiCb);
 }
 
diff --git a/cpp/src/IceGrid/AdminRouter.h b/cpp/src/IceGrid/AdminRouter.h
index 1cdf45c5141..052fa6759f4 100644
--- a/cpp/src/IceGrid/AdminRouter.h
+++ b/cpp/src/IceGrid/AdminRouter.h
@@ -20,13 +20,12 @@ namespace IceGrid
 //
 class AdminRouter : public Ice::BlobjectArrayAsync
 {
-public:
-    
-    virtual Ice::ObjectPrx getTarget(const Ice::Current&) = 0;
+protected:
 
-    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, 
-                                  const std::pair<const Ice::Byte*, const Ice::Byte*>&,
-                                  const Ice::Current&);
+    virtual void invokeOnTarget(const Ice::ObjectPrx&,
+                                const Ice::AMD_Object_ice_invokePtr&,
+                                const std::pair<const Ice::Byte*, const Ice::Byte*>&,
+                                const Ice::Current&);
 };
 
 }
diff --git a/cpp/src/IceGrid/NodeAdminRouter.cpp b/cpp/src/IceGrid/NodeAdminRouter.cpp
index fe151155eec..fe36134a2b3 100644
--- a/cpp/src/IceGrid/NodeAdminRouter.cpp
+++ b/cpp/src/IceGrid/NodeAdminRouter.cpp
@@ -22,8 +22,10 @@ IceGrid::NodeServerAdminRouter::NodeServerAdminRouter(const NodeIPtr& node) :
 {
 }
 
-ObjectPrx
-IceGrid::NodeServerAdminRouter::getTarget(const Current& current)
+void
+IceGrid::NodeServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
+                                                 const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams,
+                                                 const Current& current)
 {
     //
     // First, get the ServerI servant
@@ -34,7 +36,7 @@ IceGrid::NodeServerAdminRouter::getTarget(const Current& current)
     {
         throw ObjectNotExistException(__FILE__, __LINE__);
     }
-    
+
     //
     // Then get a proxy to the Process facet of the real admin object
     //
@@ -44,7 +46,7 @@ IceGrid::NodeServerAdminRouter::getTarget(const Current& current)
     {
         throw ObjectNotExistException(__FILE__, __LINE__);
     }
-    
+
     //
     // If this is a legacy Process proxy with no facet, we keep target as is
     //
@@ -56,6 +58,6 @@ IceGrid::NodeServerAdminRouter::getTarget(const Current& current)
         target = target->ice_facet(current.facet);
     }
 
-    return target;
+    invokeOnTarget(target, cb, inParams, current);
 }
 
diff --git a/cpp/src/IceGrid/NodeAdminRouter.h b/cpp/src/IceGrid/NodeAdminRouter.h
index 5798c8a9825..593b497a607 100644
--- a/cpp/src/IceGrid/NodeAdminRouter.h
+++ b/cpp/src/IceGrid/NodeAdminRouter.h
@@ -22,12 +22,15 @@ namespace IceGrid
 class NodeServerAdminRouter : public AdminRouter
 {
 public:
-    
+
     NodeServerAdminRouter(const NodeIPtr&);
 
-    virtual Ice::ObjectPrx getTarget(const Ice::Current&);
+    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&,
+                                  const std::pair<const Ice::Byte*, const Ice::Byte*>&,
+                                  const Ice::Current&);
 
 private:
+
     NodeIPtr _node;
 };
 
diff --git a/cpp/src/IceGrid/RegistryAdminRouter.cpp b/cpp/src/IceGrid/RegistryAdminRouter.cpp
index b17dc9b0ef7..e69dc2a1baa 100644
--- a/cpp/src/IceGrid/RegistryAdminRouter.cpp
+++ b/cpp/src/IceGrid/RegistryAdminRouter.cpp
@@ -14,20 +14,68 @@ using namespace IceGrid;
 using namespace Ice;
 using namespace std;
 
+namespace
+{
+
+class SynchronizationCallbackI : public SynchronizationCallback
+{
+public:
+
+    SynchronizationCallbackI(const IceUtil::Handle<RegistryServerAdminRouter>& adminRouter,
+                             const AMD_Object_ice_invokePtr& cb,
+                             const pair<const Byte*, const Byte*>& inParams,
+                             const Current& current) :
+        _callback(cb), _inParams(inParams.first, inParams.second), _current(current)
+    {
+    }
+
+    void synchronized()
+    {
+        //
+        // Retry to forward the call.
+        //
+        _adminRouter->ice_invoke_async(_callback, make_pair(&_inParams[0], &_inParams[0] + _inParams.size()), _current);
+    }
+
+    void synchronized(const Ice::Exception& ex)
+    {
+        _callback->ice_exception(Ice::ObjectNotExistException(__FILE__, __LINE__));
+    }
+
+private:
+
+    const IceUtil::Handle<RegistryServerAdminRouter> _adminRouter;
+    const AMD_Object_ice_invokePtr _callback;
+    const vector<Byte> _inParams;
+    const Current _current;
+};
+
+}
 
 IceGrid::RegistryServerAdminRouter::RegistryServerAdminRouter(const DatabasePtr& database) :
     _database(database)
 {
 }
 
-ObjectPrx
-IceGrid::RegistryServerAdminRouter::getTarget(const Current& current)
+void
+IceGrid::RegistryServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
+                                                     const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams,
+                                                     const Current& current)
 {
     ObjectPrx target = 0;
 
     try
     {
-        target = _database->getServer(current.id.name)->getAdminProxy();
+        ServerEntryPtr server = _database->getServer(current.id.name);
+        try
+        {
+            target = server->getAdminProxy();
+        }
+        catch(const SynchronizationException&)
+        {
+            server->addSyncCallback(new SynchronizationCallbackI(this, cb, inParams, current));
+            return; // Wait for the server synchronization to complete and retry.
+        }
     }
     catch(const ServerNotExistException&)
     {
@@ -43,8 +91,10 @@ IceGrid::RegistryServerAdminRouter::getTarget(const Current& current)
     {
         throw ObjectNotExistException(__FILE__, __LINE__);
     }
-    
-    return target->ice_facet(current.facet);
+
+    target = target->ice_facet(current.facet);
+
+    invokeOnTarget(target, cb, inParams, current);
 }
 
 
@@ -54,8 +104,10 @@ IceGrid::RegistryNodeAdminRouter::RegistryNodeAdminRouter(const string& collocNo
 {
 }
 
-ObjectPrx
-IceGrid::RegistryNodeAdminRouter::getTarget(const Current& current)
+void
+IceGrid::RegistryNodeAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
+                                                   const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams,
+                                                   const Current& current)
 {
     ObjectPrx target;
 
@@ -76,27 +128,31 @@ IceGrid::RegistryNodeAdminRouter::getTarget(const Current& current)
         catch(const NodeNotExistException&)
         {
         }
-        
+
         if(target == 0)
         {
             throw ObjectNotExistException(__FILE__, __LINE__);
         }
     }
 
-    return target->ice_facet(current.facet);
+    target = target->ice_facet(current.facet);
+
+    invokeOnTarget(target, cb, inParams, current);
 }
 
 
 
-IceGrid::RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& name, 
+IceGrid::RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& name,
                                                                 const DatabasePtr& database) :
     _name(name),
     _database(database)
 {
 }
 
-ObjectPrx
-IceGrid::RegistryReplicaAdminRouter::getTarget(const Current& current)
+void
+IceGrid::RegistryReplicaAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
+                                                      const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams,
+                                                      const Current& current)
 {
     ObjectPrx target;
 
@@ -121,6 +177,8 @@ IceGrid::RegistryReplicaAdminRouter::getTarget(const Current& current)
     {
         throw ObjectNotExistException(__FILE__, __LINE__);
     }
-    
-    return target->ice_facet(current.facet);    
+
+    target = target->ice_facet(current.facet);
+
+    invokeOnTarget(target, cb, inParams, current);
 }
diff --git a/cpp/src/IceGrid/RegistryAdminRouter.h b/cpp/src/IceGrid/RegistryAdminRouter.h
index d82d6742d31..244cf4170ca 100644
--- a/cpp/src/IceGrid/RegistryAdminRouter.h
+++ b/cpp/src/IceGrid/RegistryAdminRouter.h
@@ -19,10 +19,12 @@ namespace IceGrid
 class RegistryServerAdminRouter : public AdminRouter
 {
 public:
-    
+
     RegistryServerAdminRouter(const DatabasePtr&);
 
-    virtual Ice::ObjectPrx getTarget(const Ice::Current&);
+    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&,
+                                  const std::pair<const Ice::Byte*, const Ice::Byte*>&,
+                                  const Ice::Current&);
 
 private:
 
@@ -35,9 +37,11 @@ class RegistryNodeAdminRouter : public AdminRouter
 public:
 
     RegistryNodeAdminRouter(const std::string&, const DatabasePtr&);
-    
-    virtual Ice::ObjectPrx getTarget(const Ice::Current&);
-    
+
+    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&,
+                                  const std::pair<const Ice::Byte*, const Ice::Byte*>&,
+                                  const Ice::Current&);
+
 private:
 
     const std::string _collocNodeName;
@@ -49,9 +53,11 @@ class RegistryReplicaAdminRouter : public AdminRouter
 public:
 
     RegistryReplicaAdminRouter(const std::string&, const DatabasePtr&);
-    
-    virtual Ice::ObjectPrx getTarget(const Ice::Current&);
-    
+
+    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&,
+                                  const std::pair<const Ice::Byte*, const Ice::Byte*>&,
+                                  const Ice::Current&);
+
 private:
 
     const std::string _name;
diff --git a/cpp/src/IceGrid/ServerCache.cpp b/cpp/src/IceGrid/ServerCache.cpp
index 20a9d967ff3..03b4332f43b 100644
--- a/cpp/src/IceGrid/ServerCache.cpp
+++ b/cpp/src/IceGrid/ServerCache.cpp
@@ -569,14 +569,7 @@ ServerEntry::getAdminProxy()
     Ice::Identity adminId;
     adminId.name = _id;
     adminId.category = _cache.getInstanceName() + "-NodeServerAdminRouter";
-    try
-    {
-        return getProxy(true)->ice_identity(adminId);
-    }
-    catch(const SynchronizationException&)
-    {
-    }
-    return 0;
+    return getProxy(true)->ice_identity(adminId);
 }
 
 AdapterPrx