more Glacier2 work

5 files changed, 201 insertions, 168 deletions

diff --git a/cpp/src/Glacier2/ClientBlobject.cpp b/cpp/src/Glacier2/ClientBlobject.cpp
index fdc388cdd52..ad3102ec247 100644
--- a/cpp/src/Glacier2/ClientBlobject.cpp
+++ b/cpp/src/Glacier2/ClientBlobject.cpp
@@ -10,7 +10,6 @@
 
 #include <Ice/RoutingTable.h>
 #include <Ice/IdentityUtil.h>
-
 #include <Glacier2/ClientBlobject.h>
 
 using namespace std;
@@ -20,8 +19,8 @@ using namespace Glacier2;
 static const string clientTraceReject = "Glacier2.Client.Trace.Reject";
 
 Glacier2::ClientBlobject::ClientBlobject(const CommunicatorPtr& communicator,
-					const IceInternal::RoutingTablePtr& routingTable,
-					const string& allowCategories) :
+					 const IceInternal::RoutingTablePtr& routingTable,
+					 const string& allowCategories) :
     Glacier2::Blobject(communicator, false),
     _routingTable(routingTable),
     _traceLevelReject(communicator->getProperties()->getPropertyAsInt(clientTraceReject))
@@ -53,9 +52,8 @@ Glacier2::ClientBlobject::destroy()
 
 void
 Glacier2::ClientBlobject::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB, const vector<Byte>& inParams,
-					  const Current& current)
+					   const Current& current)
 {
-    cout << "xxxxxxxxxxxxxx 8" << endl;
     //
     // If there is an _allowCategories set then enforce it.
     //
@@ -75,8 +73,6 @@ Glacier2::ClientBlobject::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&
 	}
     }
 
-    cout << "xxxxxxxxxxxxxx 9" << endl;
-
     assert(_routingTable); // Destroyed?
     ObjectPrx proxy = _routingTable->get(current.id);
     if(!proxy)
@@ -86,6 +82,5 @@ Glacier2::ClientBlobject::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&
 	throw ex;
     }
 
-    cout << "xxxxxxxxxxxxxx 10" << endl;
     invoke(proxy, amdCB, inParams, current);
 }
diff --git a/cpp/src/Glacier2/RouterI.cpp b/cpp/src/Glacier2/RouterI.cpp
index f16c7fbebdf..6f600579e67 100644
--- a/cpp/src/Glacier2/RouterI.cpp
+++ b/cpp/src/Glacier2/RouterI.cpp
@@ -9,57 +9,51 @@
 
 #include <Ice/RoutingTable.h>
 #include <Glacier2/RouterI.h>
+#include <Glacier2/ServantLocator.h>
 
 using namespace std;
 using namespace Ice;
 using namespace Glacier2;
 
-Glacier2::RouterI::RouterI(const ObjectAdapterPtr& clientAdapter,
-			  const ObjectAdapterPtr& serverAdapter,
-			  const IceInternal::RoutingTablePtr& routingTable) :
+Glacier2::ClientRouterI::ClientRouterI(const ObjectAdapterPtr& clientAdapter,
+				       const ObjectAdapterPtr& serverAdapter,
+				       const TransportInfoPtr& transport) :
+    _logger(clientAdapter->getCommunicator()->getLogger()),
     _clientAdapter(clientAdapter),
     _serverAdapter(serverAdapter),
-    _logger(_clientAdapter->getCommunicator()->getLogger()),
-    _routingTable(routingTable),
-    _userId("todo")
+    _routingTable(new IceInternal::RoutingTable),
+    _routingTableTraceLevel(clientAdapter->getCommunicator()->getProperties()->
+			    getPropertyAsInt("Glacier2.Trace.RoutingTable")),
+    _clientBlobject(new ClientBlobject(clientAdapter->getCommunicator(), _routingTable, "")),
+    _serverBlobject(serverAdapter ? new ServerBlobject(serverAdapter->getCommunicator(), transport) : 0)
 {
-    CommunicatorPtr communicator = _clientAdapter->getCommunicator();
-    PropertiesPtr properties = communicator->getProperties();
-
-    _routingTableTraceLevel = properties->getPropertyAsInt("Glacier2.Trace.RoutingTable");
+    if(_serverAdapter)
+    {
+	assert(_serverBlobject);
+	ServantLocatorPtr serverLocator = new ServerServantLocator(_serverBlobject);
+	_serverAdapter->addServantLocator(serverLocator, "");
+	_serverAdapter->activate();
+    }
 }
 
-Glacier2::RouterI::~RouterI()
+Glacier2::ClientRouterI::~ClientRouterI()
 {
-    assert(!_clientAdapter);
 }
 
 void
-Glacier2::RouterI::destroy()
+Glacier2::ClientRouterI::destroy()
 {
-    //
-    // No mutex protection necessary, destroy is only called after all
-    // object adapters have shut down.
-    //
-    _clientAdapter = 0;
-    _serverAdapter = 0;
-    _logger = 0;
-    _routingTable = 0;
 }
 
 ObjectPrx
-Glacier2::RouterI::getClientProxy(const Current&) const
+Glacier2::ClientRouterI::getClientProxy(const Current&) const
 {
-    assert(_clientAdapter); // Destroyed?
-
     return _clientAdapter->createProxy(stringToIdentity("dummy"));
 }
 
 ObjectPrx
-Glacier2::RouterI::getServerProxy(const Current&) const
+Glacier2::ClientRouterI::getServerProxy(const Current&) const
 {
-    assert(_clientAdapter); // Destroyed?
-
     if(_serverAdapter)
     {
 	return _serverAdapter->createProxy(stringToIdentity("dummy"));
@@ -71,10 +65,8 @@ Glacier2::RouterI::getServerProxy(const Current&) const
 }
 
 void
-Glacier2::RouterI::addProxy(const ObjectPrx& proxy, const Current&)
+Glacier2::ClientRouterI::addProxy(const ObjectPrx& proxy, const Current&)
 {
-    assert(_clientAdapter); // Destroyed?
-
     if(_routingTableTraceLevel)
     {
 	Trace out(_logger, "Glacier2");
@@ -85,6 +77,124 @@ Glacier2::RouterI::addProxy(const ObjectPrx& proxy, const Current&)
 }
 
 void
-Glacier2::RouterI::createSession(const std::string&, const std::string&, const Ice::Current&)
+Glacier2::ClientRouterI::createSession(const std::string&, const std::string&, const Current&)
+{
+    assert(false); // Must not be called in this router implementation.
+}
+
+ClientBlobjectPtr
+Glacier2::ClientRouterI::getClientBlobject() const
+{
+    return _clientBlobject;
+}
+
+ServerBlobjectPtr
+Glacier2::ClientRouterI::getServerBlobject() const
+{
+    return _serverBlobject;
+}
+
+Glacier2::SessionRouterI::SessionRouterI(const ObjectAdapterPtr& clientAdapter) :
+    _logger(clientAdapter->getCommunicator()->getLogger()),
+    _clientAdapter(clientAdapter),
+    _traceLevel(clientAdapter->getCommunicator()->getProperties()->getPropertyAsInt("Glacier2.Trace.Session")),
+    _serverAdapterCount(0),
+    _clientRouterMapHint(_clientRouterMap.end())    
+{
+}
+
+Glacier2::SessionRouterI::~SessionRouterI()
+{
+}
+
+void
+Glacier2::SessionRouterI::destroy()
+{
+}
+
+ObjectPrx
+Glacier2::SessionRouterI::getClientProxy(const Current& current) const
+{
+    return getClientRouter(current.transport)->getClientProxy(current); // Forward to the per-client router.
+}
+
+ObjectPrx
+Glacier2::SessionRouterI::getServerProxy(const Current& current) const
+{
+    return getClientRouter(current.transport)->getServerProxy(current); // Forward to the per-client router.
+}
+
+void
+Glacier2::SessionRouterI::addProxy(const ObjectPrx& proxy, const Current& current)
+{
+    getClientRouter(current.transport)->addProxy(proxy, current); // Forward to the per-client router.
+}
+
+void
+Glacier2::SessionRouterI::createSession(const std::string&, const std::string&, const Current& current)
 {
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
+
+    //
+    // Create a server object adapter only if server endpoints are
+    // defined.
+    //
+    CommunicatorPtr communicator = _clientAdapter->getCommunicator();
+    PropertiesPtr properties = communicator->getProperties();
+    string endpoints = properties->getProperty("Glacier2.Server.Endpoints");
+
+    ObjectAdapterPtr serverAdapter;
+    if(!endpoints.empty())
+    {
+	ostringstream name;
+	name << "Glacier2.Server." << _serverAdapterCount++;
+	serverAdapter = communicator->createObjectAdapterWithEndpoints(name.str(), endpoints);
+    }
+    
+    //
+    // Add a new client router.
+    //
+    ClientRouterIPtr clientRouter = new ClientRouterI(_clientAdapter, serverAdapter, current.transport);
+    _clientRouterMapHint = _clientRouterMap.insert(_clientRouterMapHint,
+						   pair<const TransportInfoPtr, ClientRouterIPtr>(current.transport,
+												  clientRouter));
+    
+    if(_traceLevel >= 1)
+    {
+	Trace out(_logger, "Glacier2");
+	out << "added session for:\n";
+	out << current.transport->toString();
+	if(serverAdapter)
+	{
+	    Identity ident;
+	    ident.name = "dummy";
+	    string endpts = _clientAdapter->getCommunicator()->proxyToString(serverAdapter->createProxy(ident));
+	    endpts.erase(0, endpts.find(':') + 1);
+	    out << "\nserver adapter endpoints: " << endpts;
+	}
+    }
+}
+
+ClientRouterIPtr
+Glacier2::SessionRouterI::getClientRouter(const TransportInfoPtr& transport) const
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
+
+    if(_clientRouterMapHint != _clientRouterMap.end() && _clientRouterMapHint->first == transport)
+    {
+	return _clientRouterMapHint->second;
+    }
+    
+    map<TransportInfoPtr, ClientRouterIPtr>::iterator p =
+	const_cast<map<TransportInfoPtr, ClientRouterIPtr>&>(_clientRouterMap).find(transport);
+
+    if(p != _clientRouterMap.end())
+    {
+	_clientRouterMapHint = p;
+	return p->second;
+    }
+    else
+    {
+	return 0;
+    }
 }
diff --git a/cpp/src/Glacier2/RouterI.h b/cpp/src/Glacier2/RouterI.h
index a9bf1b852b6..b1c39603cd1 100644
--- a/cpp/src/Glacier2/RouterI.h
+++ b/cpp/src/Glacier2/RouterI.h
@@ -10,24 +10,55 @@
 #ifndef GLACIER2_ROUTER_I_H
 #define GLACIER2_ROUTER_I_H
 
-#include <Ice/RoutingTableF.h>
-#include <Glacier2/Router.h>
+#include <IceUtil/Thread.h>
+#include <IceUtil/Monitor.h>
 #include <Ice/Ice.h>
+#include <Glacier2/Router.h>
+#include <Glacier2/ClientBlobject.h>
+#include <Glacier2/ServerBlobject.h>
 
 namespace Glacier2
 {
 
-class RouterI;
-typedef IceUtil::Handle<RouterI> RouterIPtr;
+class ClientRouterI;
+typedef IceUtil::Handle<ClientRouterI> ClientRouterIPtr;
 
-class RouterI : public Router
+class ClientRouterI : public Router
 {
 public:
 
-    RouterI(const Ice::ObjectAdapterPtr&, const Ice::ObjectAdapterPtr&, const IceInternal::RoutingTablePtr&);
-	    
-    virtual ~RouterI();
+    ClientRouterI(const Ice::ObjectAdapterPtr&, const Ice::ObjectAdapterPtr&, const Ice::TransportInfoPtr& transport);
+    virtual ~ClientRouterI();
+    void destroy();
+
+    virtual Ice::ObjectPrx getClientProxy(const Ice::Current&) const;
+    virtual Ice::ObjectPrx getServerProxy(const Ice::Current&) const;
+    virtual void addProxy(const Ice::ObjectPrx&, const Ice::Current&);
+    virtual void createSession(const std::string&, const std::string&, const Ice::Current&);
+
+    Glacier2::ClientBlobjectPtr getClientBlobject() const;
+    Glacier2::ServerBlobjectPtr getServerBlobject() const;
 
+private:
+
+    const Ice::LoggerPtr _logger;
+    const Ice::ObjectAdapterPtr _clientAdapter;
+    const Ice::ObjectAdapterPtr _serverAdapter;
+    const IceInternal::RoutingTablePtr _routingTable;
+    const int _routingTableTraceLevel;
+    const Glacier2::ClientBlobjectPtr _clientBlobject;
+    const Glacier2::ServerBlobjectPtr _serverBlobject;
+};
+
+class SessionRouterI;
+typedef IceUtil::Handle<SessionRouterI> SessionRouterIPtr;
+
+class SessionRouterI : public Router, public IceUtil::Monitor<IceUtil::Mutex>
+{
+public:
+
+    SessionRouterI(const Ice::ObjectAdapterPtr&);
+    virtual ~SessionRouterI();
     void destroy();
 
     virtual Ice::ObjectPrx getClientProxy(const Ice::Current&) const;
@@ -35,15 +66,18 @@ public:
     virtual void addProxy(const Ice::ObjectPrx&, const Ice::Current&);
     virtual void createSession(const std::string&, const std::string&, const Ice::Current&);
 
+    ClientRouterIPtr getClientRouter(const Ice::TransportInfoPtr&) const;    
+
 private:
 
-    Ice::ObjectAdapterPtr _clientAdapter;
-    Ice::ObjectAdapterPtr _serverAdapter;
-    Ice::LoggerPtr _logger;
-    IceInternal::RoutingTablePtr _routingTable;
-    int _routingTableTraceLevel;
+    const Ice::LoggerPtr _logger;
+    const Ice::ObjectAdapterPtr _clientAdapter;
+    const int _traceLevel;
+
+    int _serverAdapterCount;
 
-    std::string _userId;
+    std::map<Ice::TransportInfoPtr, ClientRouterIPtr> _clientRouterMap;
+    mutable std::map<Ice::TransportInfoPtr, ClientRouterIPtr>::iterator _clientRouterMapHint;
 };
 
 }
diff --git a/cpp/src/Glacier2/ServantLocator.cpp b/cpp/src/Glacier2/ServantLocator.cpp
index a02dd2279b5..1ac8f56bfa7 100644
--- a/cpp/src/Glacier2/ServantLocator.cpp
+++ b/cpp/src/Glacier2/ServantLocator.cpp
@@ -7,127 +7,42 @@
 //
 // **********************************************************************
 
-#include <Ice/RoutingTable.h>
 #include <Glacier2/ServantLocator.h>
-#include <Glacier2/RouterI.h>
 
 using namespace std;
 using namespace Ice;
 using namespace Glacier2;
 
 Glacier2::ClientServantLocator::ClientServantLocator(const ObjectAdapterPtr& clientAdapter) :
-    _communicator(clientAdapter->getCommunicator()),
-    _properties(_communicator->getProperties()),
-    _logger(_communicator->getLogger()),
-    _clientAdapter(clientAdapter),
-    _routerId(stringToIdentity(_properties->getPropertyWithDefault("Glacier2.Identity", "Glacier2/router"))),
-    _serverEndpoints(_properties->getProperty("Glacier2.Server.Endpoints")),
-    _traceLevel(_properties->getPropertyAsInt("Glacier2.Trace.Session")),
-    _serverAdapterCount(0),
-    _clientMapHint(_clientMap.end())
+    _routerId(stringToIdentity(clientAdapter->getCommunicator()->getProperties()->
+			       getPropertyWithDefault("Glacier2.Identity", "Glacier2/router"))),
+    _sessionRouter(new SessionRouterI(clientAdapter))
 {
 }
 
 ObjectPtr
 Glacier2::ClientServantLocator::locate(const Current& current, LocalObjectPtr&)
 {
-    IceUtil::Mutex::Lock sync(*this);
-
     assert(current.transport);
-    
-    map<TransportInfoPtr, Client>::iterator p;
-    
-    if(_clientMapHint != _clientMap.end() && _clientMapHint->first == current.transport)
-    {
-	p = _clientMapHint;
-    }
-    else
-    {
-	p = _clientMap.find(current.transport);
-
-	if(p == _clientMap.end())
-	{
-	    //
-	    // Create a server object adapter and related objects if
-	    // server endpoints are defined.
-	    //
-	    ObjectAdapterPtr adapter;
-	    CommunicatorPtr communicator = _clientAdapter->getCommunicator();
-	    PropertiesPtr properties = communicator->getProperties();
-	    string endpoints = properties->getProperty("Glacier2.Server.Endpoints");
-	    if(!endpoints.empty())
-	    {
-		ostringstream name;
-		name << "Glacier2.Server." << _serverAdapterCount++;
-		adapter = communicator->createObjectAdapterWithEndpoints(name.str(), endpoints);
-		ServerBlobjectPtr blobject = new ServerBlobject(communicator, current.transport);
-		ServantLocatorPtr locator = new ServerServantLocator(blobject);
-		adapter->addServantLocator(locator, "");
-		adapter->activate();
-	    }
-
-	    //
-	    // Add a new client to our client map.
-	    //
-	    Client client;
-	    IceInternal::RoutingTablePtr routingTable = new IceInternal::RoutingTable;
-	    client.router = new RouterI(_clientAdapter, adapter, routingTable);
-	    client.clientBlobject = new ClientBlobject(_clientAdapter->getCommunicator(), routingTable, "");
-	    client.serverAdapter = adapter;
-	    p = _clientMap.insert(_clientMapHint, pair<const TransportInfoPtr, Client>(current.transport, client));
-
-	    if(_traceLevel >= 1)
-	    {
-		Trace out(_logger, "Glacier2");
-		out << "added session for:\n";
-		out << current.transport->toString();
-		if(client.serverAdapter)
-		{
-		    Identity ident;
-		    ident.name = "dummy";
-		    string endpts = communicator->proxyToString(client.serverAdapter->createProxy(ident));
-		    endpts.erase(0, endpts.find(':') + 1);
-		    out << "\nserver adapter endpoints: " << endpts;
-		}
-	    }
-	}
-	
-	_clientMapHint = p;
-    }
 
     if(current.id == _routerId)
     {
-	return p->second.router;
+	return _sessionRouter;
     }
     else
     {
-	return p->second.clientBlobject;
+	return _sessionRouter->getClientRouter(current.transport)->getClientBlobject();
     }
 }
 
 void
 Glacier2::ClientServantLocator::finished(const Current&, const ObjectPtr&, const LocalObjectPtr&)
 {
-    // Nothing to do
 }
 
 void
 Glacier2::ClientServantLocator::deactivate(const string&)
 {
-    IceUtil::Mutex::Lock sync(*this);
-
-    for(map<TransportInfoPtr, Client>::iterator p = _clientMap.begin(); p != _clientMap.end(); ++p)
-    {
-	p->second.clientBlobject->destroy();
-	RouterI* router = dynamic_cast<RouterI*>(p->second.router.get());
-	router->destroy();
-	if(p->second.serverAdapter)
-	{
-	    p->second.serverAdapter->deactivate();
-	}
-    };
-    _clientMap.clear();
-    _clientMapHint = _clientMap.end();
 }
 
 Glacier2::ServerServantLocator::ServerServantLocator(const ServerBlobjectPtr& serverBlobject) :
@@ -144,12 +59,9 @@ Glacier2::ServerServantLocator::locate(const Current& current, LocalObjectPtr&)
 void
 Glacier2::ServerServantLocator::finished(const Current&, const ObjectPtr&, const LocalObjectPtr&)
 {
-    // Nothing to do
 }
 
 void
 Glacier2::ServerServantLocator::deactivate(const string&)
 {
-    _serverBlobject->destroy();
-    _serverBlobject = 0;
 }
diff --git a/cpp/src/Glacier2/ServantLocator.h b/cpp/src/Glacier2/ServantLocator.h
index 208a76245ff..08b92f7be02 100644
--- a/cpp/src/Glacier2/ServantLocator.h
+++ b/cpp/src/Glacier2/ServantLocator.h
@@ -7,13 +7,12 @@
 //
 // **********************************************************************
 
-#include <Glacier2/ClientBlobject.h>
-#include <Glacier2/ServerBlobject.h>
+#include <Glacier2/RouterI.h>
 
 namespace Glacier2
 {
 
-class ClientServantLocator : public Ice::ServantLocator, public IceUtil::Mutex
+class ClientServantLocator : public Ice::ServantLocator
 {
 public:
 
@@ -25,25 +24,8 @@ public:
 
 private:
 
-    const Ice::CommunicatorPtr _communicator;
-    const Ice::PropertiesPtr _properties;
-    const Ice::LoggerPtr _logger;
-    const Ice::ObjectAdapterPtr _clientAdapter;
     const Ice::Identity _routerId;
-    const std::string _serverEndpoints;
-    const int _traceLevel;
-
-    struct Client
-    {
-	Ice::RouterPtr router;
-	Glacier2::ClientBlobjectPtr clientBlobject;
-	Ice::ObjectAdapterPtr serverAdapter;
-    };
-
-    int _serverAdapterCount;
-
-    std::map<Ice::TransportInfoPtr, Client> _clientMap;
-    std::map<Ice::TransportInfoPtr, Client>::iterator _clientMapHint;
+    const Glacier2::SessionRouterIPtr _sessionRouter;
 };
 
 class ServerServantLocator : public Ice::ServantLocator
@@ -58,7 +40,7 @@ public:
 
 private:
 
-    Glacier2::ServerBlobjectPtr _serverBlobject;
+    const Glacier2::ServerBlobjectPtr _serverBlobject;
 };
 
 }