First cut callback support

9 files changed, 104 insertions, 22 deletions

diff --git a/cpp/src/IceGrid/AdminI.cpp b/cpp/src/IceGrid/AdminI.cpp
index 0f41bfbd9cd..22c43e316cb 100644
--- a/cpp/src/IceGrid/AdminI.cpp
+++ b/cpp/src/IceGrid/AdminI.cpp
@@ -358,6 +358,12 @@ AdminI::getServerPid(const string& id, const Current&) const
     }
 }
 
+string
+AdminI::getServerAdminCategory(const Current&) const
+{
+    return _registry->getServerAdminCategory();
+}
+
 Ice::ObjectPrx
 AdminI::getServerAdmin(const string& id, const Current& current) const
 {
diff --git a/cpp/src/IceGrid/AdminI.h b/cpp/src/IceGrid/AdminI.h
index 4170066c9e1..132c95d8d39 100644
--- a/cpp/src/IceGrid/AdminI.h
+++ b/cpp/src/IceGrid/AdminI.h
@@ -49,6 +49,7 @@ public:
     virtual ServerInfo getServerInfo(const ::std::string&, const Ice::Current&) const;
     virtual ServerState getServerState(const ::std::string&, const Ice::Current&) const;
     virtual Ice::Int getServerPid(const ::std::string&, const Ice::Current&) const;
+    virtual std::string getServerAdminCategory(const Ice::Current&) const;
     virtual Ice::ObjectPrx getServerAdmin(const std::string&, const Ice::Current&) const;
     virtual void startServer(const ::std::string&, const Ice::Current&);
     virtual void stopServer(const ::std::string&, const Ice::Current&);
@@ -95,6 +96,7 @@ private:
     const RegistryIPtr _registry;
     const TraceLevelsPtr _traceLevels;
     const AdminSessionIPtr _session;
+
 };
 typedef IceUtil::Handle<AdminI> AdminIPtr;
 
diff --git a/cpp/src/IceGrid/AdminSessionI.cpp b/cpp/src/IceGrid/AdminSessionI.cpp
index df4f2029657..4bf2c08e78a 100644
--- a/cpp/src/IceGrid/AdminSessionI.cpp
+++ b/cpp/src/IceGrid/AdminSessionI.cpp
@@ -73,7 +73,21 @@ AdminSessionI::_register(const SessionServantManagerPtr& servantManager, const I
     // This is supposed to be called after creation only, no need to synchronize.
     //
     _servantManager = servantManager;
-    Ice::ObjectPrx session =  _servantManager->addSession(this, con, true);
+
+    string category = "";
+
+    if(con != 0)
+    {
+        category = _database->getInstanceName() + "-" + IceUtil::generateUUID();
+     
+        Ice::Identity templateId;
+        templateId.name = "pick-a-name";
+        templateId.category = category;
+        
+        _adminCallbackTemplate = _registry->createAdminCallbackProxy(templateId);
+    }
+
+    Ice::ObjectPrx session =  _servantManager->addSession(this, con, category);
 
     _admin = AdminPrx::uncheckedCast(_servantManager->add(new AdminI(_database, _registry, this), this));
 
@@ -86,6 +100,12 @@ AdminSessionI::getAdmin(const Ice::Current& current) const
     return _admin;
 }
 
+Ice::ObjectPrx
+AdminSessionI::getAdminCallbackTemplate(const Ice::Current& current) const
+{
+    return _adminCallbackTemplate;
+}
+
 void
 AdminSessionI::setObservers(const RegistryObserverPrx& registryObserver, 
                             const NodeObserverPrx& nodeObserver, 
diff --git a/cpp/src/IceGrid/AdminSessionI.h b/cpp/src/IceGrid/AdminSessionI.h
index d7ed1842520..5c813fb80c9 100644
--- a/cpp/src/IceGrid/AdminSessionI.h
+++ b/cpp/src/IceGrid/AdminSessionI.h
@@ -36,6 +36,7 @@ public:
     virtual void keepAlive(const Ice::Current& current) { BaseSessionI::keepAlive(current); }
 
     virtual AdminPrx getAdmin(const Ice::Current& = Ice::Current()) const;
+    virtual Ice::ObjectPrx getAdminCallbackTemplate(const Ice::Current&) const;
 
     virtual void setObservers(const RegistryObserverPrx&, const NodeObserverPrx&, const ApplicationObserverPrx&,
                               const AdapterObserverPrx&, const ObjectObserverPrx&, const Ice::Current&);
@@ -75,6 +76,7 @@ private:
     AdminPrx _admin;
     std::map<TopicName, Ice::ObjectPrx> _observers;
     RegistryIPtr _registry;
+    Ice::ObjectPrx _adminCallbackTemplate;
 };
 typedef IceUtil::Handle<AdminSessionI> AdminSessionIPtr;
 
diff --git a/cpp/src/IceGrid/Makefile b/cpp/src/IceGrid/Makefile
index 8c52817f647..2b87eec2d9e 100644
--- a/cpp/src/IceGrid/Makefile
+++ b/cpp/src/IceGrid/Makefile
@@ -56,7 +56,8 @@ NODE_OBJS	= NodeI.o \
 	          Activator.o \
 		  NodeSessionManager.o
 
-REGISTRY_OBJS   = RegistryI.o \
+REGISTRY_OBJS   = AdminCallbackRouter.o \
+                  RegistryI.o \
                   RegistryServerAdminRouter.o \
 	  	  InternalRegistryI.o \
 		  StringApplicationInfoDict.o \
diff --git a/cpp/src/IceGrid/RegistryI.cpp b/cpp/src/IceGrid/RegistryI.cpp
index 9051af23036..294c99d76bf 100644
--- a/cpp/src/IceGrid/RegistryI.cpp
+++ b/cpp/src/IceGrid/RegistryI.cpp
@@ -27,6 +27,7 @@
 #include <IceGrid/AdminI.h>
 #include <IceGrid/QueryI.h>
 #include <IceGrid/SessionI.h>
+#include <IceGrid/AdminCallbackRouter.h>
 #include <IceGrid/AdminSessionI.h>
 #include <IceGrid/InternalRegistryI.h>
 #include <IceGrid/SessionServantManager.h>
@@ -118,6 +119,33 @@ private:
     const std::map<std::string, std::string> _passwords;
 };
 
+
+class DefaultServantLocator : public Ice::ServantLocator
+{
+public:
+
+    DefaultServantLocator(const ObjectPtr& servant) :
+        _servant(servant)
+    {
+    }
+
+    virtual ObjectPtr locate(const Current& c, LocalObjectPtr&)
+    {
+        return _servant;
+    }
+
+    virtual void finished(const Current&, const ObjectPtr&, const LocalObjectPtr&)
+    {
+    }
+
+    virtual void deactivate(const string&)
+    {
+    }
+
+private:
+    ObjectPtr _servant;
+};
+
 }
 
 RegistryI::RegistryI(const CommunicatorPtr& communicator, const TraceLevelsPtr& traceLevels) : 
@@ -349,13 +377,13 @@ RegistryI::start(bool nowarn)
         registerNodes(internalRegistry, _session.getNodes(nodes));
     }
 
-    ObjectAdapterPtr serverAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Server");
+    _serverAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Server");
     _clientAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Client");
 
     Ice::Identity dummy;
     dummy.name = "dummy";
     _wellKnownObjects->addEndpoint("Client", _clientAdapter->createDirectProxy(dummy));
-    _wellKnownObjects->addEndpoint("Server", serverAdapter->createDirectProxy(dummy));
+    _wellKnownObjects->addEndpoint("Server", _serverAdapter->createDirectProxy(dummy));
     _wellKnownObjects->addEndpoint("Internal", registryAdapter->createDirectProxy(dummy));
 
     setupNullPermissionsVerifier(registryAdapter);
@@ -367,7 +395,7 @@ RegistryI::start(bool nowarn)
     QueryPrx query = setupQuery(_clientAdapter);
     RegistryPrx registry = setupRegistry(_clientAdapter);
 
-    Ice::LocatorRegistryPrx locatorRegistry = setupLocatorRegistry(serverAdapter);
+    Ice::LocatorRegistryPrx locatorRegistry = setupLocatorRegistry(_serverAdapter);
     LocatorPrx internalLocator = setupLocator(_clientAdapter, registryAdapter, locatorRegistry, registry, query);
 
     //
@@ -376,12 +404,17 @@ RegistryI::start(bool nowarn)
     // accessed by the connection that created the session. The session servant manager
     // also takes care of providing the router servant for server admin objects.
     //
-    Ice::ObjectPtr router = new RegistryServerAdminRouter(_database);
-    _servantManager = new SessionServantManager(_clientAdapter, _instanceName, true, getServerAdminCategory(), router);
+    Ice::ObjectPtr serverAdminRouter = new RegistryServerAdminRouter(_database);
+
+    AdminCallbackRouterPtr adminCallbackRouter = new AdminCallbackRouter;
+
+    _servantManager = new SessionServantManager(_clientAdapter, _instanceName, true, getServerAdminCategory(), serverAdminRouter, adminCallbackRouter);
     _clientAdapter->addServantLocator(_servantManager, "");
+
+    _serverAdapter->addServantLocator(new DefaultServantLocator(adminCallbackRouter), "");
     
     Ice::ObjectAdapterPtr sessionAdpt = setupClientSessionFactory(registryAdapter, internalLocator, nowarn);
-    Ice::ObjectAdapterPtr admSessionAdpt = setupAdminSessionFactory(registryAdapter, router, internalLocator, nowarn);
+    Ice::ObjectAdapterPtr admSessionAdpt = setupAdminSessionFactory(registryAdapter, serverAdminRouter, internalLocator, nowarn);
 
     _wellKnownObjects->finish();
     if(_master)
@@ -396,7 +429,7 @@ RegistryI::start(bool nowarn)
     //
     // We are ready to go!
     //
-    serverAdapter->activate();
+    _serverAdapter->activate();
     _clientAdapter->activate();
     if(sessionAdpt)
     {
@@ -542,7 +575,7 @@ RegistryI::setupClientSessionFactory(const Ice::ObjectAdapterPtr& registryAdapte
     if(!properties->getProperty("IceGrid.Registry.SessionManager.Endpoints").empty())
     {
         adapter = _communicator->createObjectAdapter("IceGrid.Registry.SessionManager");
-        servantManager = new SessionServantManager(adapter, _instanceName, false, "", 0);
+        servantManager = new SessionServantManager(adapter, _instanceName, false, "", 0, 0);
         adapter->addServantLocator(servantManager, "");
     }
 
@@ -599,7 +632,7 @@ RegistryI::setupAdminSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter
     if(!properties->getProperty("IceGrid.Registry.AdminSessionManager.Endpoints").empty())
     {
         adapter = _communicator->createObjectAdapter("IceGrid.Registry.AdminSessionManager");
-        servantManager = new SessionServantManager(adapter, _instanceName, false, getServerAdminCategory(), router);
+        servantManager = new SessionServantManager(adapter, _instanceName, false, getServerAdminCategory(), router, 0);
         adapter->addServantLocator(servantManager, "");
     }
 
@@ -941,6 +974,12 @@ RegistryI::shutdown()
     _clientAdapter->deactivate();
 }
 
+Ice::ObjectPrx 
+RegistryI::createAdminCallbackProxy(const Identity& identity) const
+{
+    return _serverAdapter->createProxy(identity);
+}
+
 void
 RegistryI::setupThreadPool(const PropertiesPtr& properties, const string& name, int size, int sizeMax)
 {
diff --git a/cpp/src/IceGrid/RegistryI.h b/cpp/src/IceGrid/RegistryI.h
index 9fa0648cf67..a6b93c86ab5 100644
--- a/cpp/src/IceGrid/RegistryI.h
+++ b/cpp/src/IceGrid/RegistryI.h
@@ -70,6 +70,8 @@ public:
     
     std::string getServerAdminCategory() const { return _instanceName + "-RegistryRouter"; }
 
+    Ice::ObjectPrx createAdminCallbackProxy(const Ice::Identity&) const;
+
 private:
 
     Ice::LocatorRegistryPrx setupLocatorRegistry(const Ice::ObjectAdapterPtr&); 
@@ -99,6 +101,7 @@ private:
 
     DatabasePtr _database;
     Ice::ObjectAdapterPtr _clientAdapter;
+    Ice::ObjectAdapterPtr _serverAdapter;
     WellKnownObjectsManagerPtr _wellKnownObjects;
     std::string _instanceName;
     bool _master;
diff --git a/cpp/src/IceGrid/SessionServantManager.cpp b/cpp/src/IceGrid/SessionServantManager.cpp
index 5002e9ac0a2..994a9a3ff51 100644
--- a/cpp/src/IceGrid/SessionServantManager.cpp
+++ b/cpp/src/IceGrid/SessionServantManager.cpp
@@ -19,12 +19,15 @@ SessionServantManager::SessionServantManager(const Ice::ObjectAdapterPtr& adapte
                                              const string& instanceName,
                                              const bool checkConnection,
                                              const string& serverAdminCategory,
-                                             const Ice::ObjectPtr& serverAdminRouter) : 
+                                             const Ice::ObjectPtr& serverAdminRouter,
+                                             const AdminCallbackRouterPtr& adminCallbackRouter
+    ) : 
     _adapter(adapter),
     _instanceName(instanceName),
     _checkConnection(checkConnection),
     _serverAdminCategory(serverAdminCategory),
-    _serverAdminRouter(serverAdminRouter)
+    _serverAdminRouter(serverAdminRouter),
+    _adminCallbackRouter(adminCallbackRouter)
 {
 }
 
@@ -69,18 +72,21 @@ SessionServantManager::deactivate(const std::string&)
 }
 
 Ice::ObjectPrx
-SessionServantManager::addSession(const Ice::ObjectPtr& session, const Ice::ConnectionPtr& con, bool admin)
+SessionServantManager::addSession(const Ice::ObjectPtr& session, const Ice::ConnectionPtr& con, const string& category)
 {
     Lock sync(*this);
-    _sessions.insert(make_pair(session, SessionInfo(con, admin)));
+    _sessions.insert(make_pair(session, SessionInfo(con, category)));
 
     //
     // Keep track of all the connections which have an admin session to allow access
     // to server admin objects.
     //
-    if(admin)
+    if(category != "")
     {
+        assert(con != 0);
+
         _adminConnections.insert(con);
+        _adminCallbackRouter->addMapping(category, con);
     }
 
     return addImpl(session, session); // Register a servant for the session and return its proxy.
@@ -109,7 +115,7 @@ SessionServantManager::setSessionControl(const Ice::ObjectPtr& session,
     //
     // Allow invocations on server admin objects.
     //
-    if(p->second.admin && _serverAdminRouter) 
+    if(p->second.category != "" && _serverAdminRouter) 
     {
         Ice::StringSeq seq;
         seq.push_back(_serverAdminCategory);
@@ -174,9 +180,10 @@ SessionServantManager::removeSession(const Ice::ObjectPtr& session)
     //
     // If this is an admin session, remove its connection from the admin connections.
     //
-    if(p->second.admin)
+    if(p->second.category != "")
     {
         _adminConnections.erase(p->second.connection);
+        _adminCallbackRouter->removeMapping(p->second.category);
     }
 
     _sessions.erase(p);
diff --git a/cpp/src/IceGrid/SessionServantManager.h b/cpp/src/IceGrid/SessionServantManager.h
index 87c1e201914..c0901965cad 100644
--- a/cpp/src/IceGrid/SessionServantManager.h
+++ b/cpp/src/IceGrid/SessionServantManager.h
@@ -10,6 +10,7 @@
 #ifndef ICE_GRID_SESSIONSERVANTLOCATOR_H
 #define ICE_GRID_SESSIONSERVANTLOCATOR_H
 
+#include <IceGrid/AdminCallbackRouter.h>
 #include <IceUtil/Mutex.h>
 #include <Ice/ServantLocator.h>
 
@@ -25,13 +26,13 @@ class SessionServantManager : public Ice::ServantLocator, public IceUtil::Mutex
 public:
 
     SessionServantManager(const Ice::ObjectAdapterPtr&, const std::string&, bool, const std::string&,
-                          const Ice::ObjectPtr&);
+                          const Ice::ObjectPtr&, const AdminCallbackRouterPtr&);
 
     Ice::ObjectPtr locate(const Ice::Current&, Ice::LocalObjectPtr&);
     void finished(const Ice::Current&, const Ice::ObjectPtr&, const Ice::LocalObjectPtr&);
     void deactivate(const std::string&);
 
-    Ice::ObjectPrx addSession(const Ice::ObjectPtr&, const Ice::ConnectionPtr&, bool);
+    Ice::ObjectPrx addSession(const Ice::ObjectPtr&, const Ice::ConnectionPtr&, const std::string& = "");
     void setSessionControl(const Ice::ObjectPtr&, const Glacier2::SessionControlPrx&, const Ice::IdentitySeq&);
     Glacier2::IdentitySetPrx getGlacier2IdentitySet(const Ice::ObjectPtr&);
     Glacier2::StringSetPrx getGlacier2AdapterIdSet(const Ice::ObjectPtr&);
@@ -58,10 +59,10 @@ private:
 
     struct SessionInfo
     {
-        SessionInfo(const Ice::ConnectionPtr& c, bool a) : connection(c), admin(a) { }
+        SessionInfo(const Ice::ConnectionPtr& c, const std::string& cat) : connection(c), category(cat) { }
 
         const Ice::ConnectionPtr connection;
-        const bool admin;
+        const std::string category;
         Glacier2::SessionControlPrx sessionControl;
         Glacier2::IdentitySetPrx identitySet;
         Glacier2::StringSetPrx adapterIdSet;
@@ -73,6 +74,7 @@ private:
     const bool _checkConnection;
     const std::string _serverAdminCategory;
     const Ice::ObjectPtr _serverAdminRouter;
+    const AdminCallbackRouterPtr _adminCallbackRouter;
 
     std::map<Ice::Identity, ServantInfo> _servants;
     std::map<Ice::ObjectPtr, SessionInfo> _sessions;