Added support for object lookup by identity to the location mechanism.

6 files changed, 240 insertions, 130 deletions

diff --git a/java/src/Ice/ObjectAdapterI.java b/java/src/Ice/ObjectAdapterI.java
index 2979bf9a601..4ab37bda274 100644
--- a/java/src/Ice/ObjectAdapterI.java
+++ b/java/src/Ice/ObjectAdapterI.java
@@ -63,18 +63,17 @@ public class ObjectAdapterI extends LocalObjectImpl implements ObjectAdapter
 		{
 		    _locatorInfo.getLocatorRegistry().setAdapterDirectProxy(_id, newDirectProxy(ident));
 		}
-		catch(Ice.AdapterNotRegisteredException ex)
+		catch(Ice.AdapterNotFoundException ex)
 		{
 		    NotRegisteredException ex1 = new NotRegisteredException();
-		    ex1.id = Util.identityToString(ident);
+		    ex1.id = _id;
 		    ex1.kindOfObject = "object adapter";
 		    throw ex1;
 		}
 		catch(Ice.AdapterAlreadyActiveException ex)
 		{
-		    AlreadyRegisteredException ex1 = new AlreadyRegisteredException();
-		    ex1.id = _name;
-		    ex1.kindOfObject = "object adapter";
+		    ObjectAdapterIdInUseException ex1 = new ObjectAdapterIdInUseException();
+		    ex1.id = _id;
 		    throw ex1;
 		}
 	    }
diff --git a/java/src/Ice/ObjectPrxHelper.java b/java/src/Ice/ObjectPrxHelper.java
index bc5c6196c72..6b0cdc19e8c 100644
--- a/java/src/Ice/ObjectPrxHelper.java
+++ b/java/src/Ice/ObjectPrxHelper.java
@@ -497,6 +497,11 @@ public class ObjectPrxHelper implements ObjectPrx
 	    _delegate = null;
 	}
 
+	if(_reference.locatorInfo != null)
+	{
+	    _reference.locatorInfo.clearObjectCache(_reference);
+	}
+
 	++cnt;
 
         IceInternal.TraceLevels traceLevels = _reference.instance.traceLevels();
@@ -561,6 +566,11 @@ public class ObjectPrxHelper implements ObjectPrx
     {
         _delegate = null;
 
+	if(_reference.locatorInfo != null)
+	{
+	    _reference.locatorInfo.clearObjectCache(_reference);
+	}
+
         throw ex;
     }
 
diff --git a/java/src/IceInternal/LocatorAdapterTable.java b/java/src/IceInternal/LocatorAdapterTable.java
deleted file mode 100644
index f5bf2fbb8b1..00000000000
--- a/java/src/IceInternal/LocatorAdapterTable.java
+++ /dev/null
@@ -1,49 +0,0 @@
-// **********************************************************************
-//
-// Copyright (c) 2002
-// ZeroC, Inc.
-// Billerica, MA, USA
-//
-// All Rights Reserved.
-//
-// Ice is free software; you can redistribute it and/or modify it under
-// the terms of the GNU General Public License version 2 as published by
-// the Free Software Foundation.
-//
-// **********************************************************************
-
-package IceInternal;
-
-public final class LocatorAdapterTable
-{
-    LocatorAdapterTable()
-    {
-    }
-
-    synchronized void
-    clear()
-    {
-	_table.clear();
-    }
-
-    synchronized IceInternal.Endpoint[]
-    get(String adapter)
-    {
-	return (IceInternal.Endpoint[])_table.get(adapter);
-    }
-
-    synchronized void
-    add(String adapter, IceInternal.Endpoint[] endpoints)
-    {
-	_table.put(adapter, endpoints);
-    }
-
-    synchronized IceInternal.Endpoint[]
-    remove(String adapter)
-    {
-	return (IceInternal.Endpoint[])_table.remove(adapter);
-    }
-
-    private java.util.HashMap _table = new java.util.HashMap();
-};
-
diff --git a/java/src/IceInternal/LocatorInfo.java b/java/src/IceInternal/LocatorInfo.java
index 09e79609897..03d1d1f5691 100644
--- a/java/src/IceInternal/LocatorInfo.java
+++ b/java/src/IceInternal/LocatorInfo.java
@@ -16,10 +16,10 @@ package IceInternal;
 
 public final class LocatorInfo
 {
-    LocatorInfo(Ice.LocatorPrx locator, LocatorAdapterTable adapterTable)
+    LocatorInfo(Ice.LocatorPrx locator, LocatorTable table)
     {
 	_locator = locator;
-	_adapterTable = adapterTable;
+	_table = table;
     }
 
     synchronized public void
@@ -27,7 +27,7 @@ public final class LocatorInfo
     {
 	_locator = null;
 	_locatorRegistry = null;
-	_adapterTable.clear();
+	_table.clear();
     }
 
     public boolean
@@ -66,117 +66,198 @@ public final class LocatorInfo
 	return _locatorRegistry;
     }
 
-    public IceInternal.Endpoint[]
+    public Endpoint[]
     getEndpoints(Reference ref, Ice.BooleanHolder cached)
     {
-	IceInternal.Endpoint[] endpoints = null;
+	assert(ref.endpoints.length == 0);
 
-	if(ref.adapterId.length() > 0)
-	{
-	    cached.value = true;
+	Endpoint[] endpoints = null;
+	Ice.ObjectPrx object = null;
+	cached.value = true;
 	
-	    endpoints = _adapterTable.get(ref.adapterId);
-	    if(endpoints == null)
+	try
+	{
+	    if(ref.adapterId.length() > 0)
 	    {
-		cached.value = false;
-
-		//
-		// Search the adapter in the location service if we didn't
-		// find it in the cache.
-		//
-		try
+		endpoints = _table.getAdapterEndpoints(ref.adapterId);
+		if(endpoints == null)
 		{
-		    Ice.ObjectPrx object = _locator.findAdapterById(ref.adapterId);
+		    cached.value = false;
+		    
+		    //
+		    // Search the adapter in the location service if we didn't
+		    // find it in the cache.
+		    //
+		    object = _locator.findAdapterById(ref.adapterId);
 		    if(object != null)
 		    {
 			endpoints = ((Ice.ObjectPrxHelper)object).__reference().endpoints;
+			
+			if(endpoints != null && endpoints.length > 0)
+			{
+			    _table.addAdapterEndpoints(ref.adapterId, endpoints);
+			}
 		    }
 		}
-		catch(Ice.AdapterNotRegisteredException ex)
+	    }
+	    else
+	    {
+		object = _table.getProxy(ref.identity);
+		if(object == null)
 		{
-		    if(ref.instance.traceLevels().location >= 1)
-		    {
-			StringBuffer s = new StringBuffer();
-			s.append("adapter `" + ref.adapterId + "' is not registered");
-			ref.instance.logger().trace(ref.instance.traceLevels().locationCat, s.toString());
-		    }
+		    cached.value = false;
+
+		    object = _locator.findObjectById(ref.identity);
 		}
-		catch(Ice.LocalException ex)
+
+		if(object != null)
 		{
-		    //
-		    // Just trace the failure. The proxy will most
-		    // likely get empty endpoints and raise a
-		    // NoEndpointException().
-		    //
-		    if(ref.instance.traceLevels().location >= 1)
+		    if(((Ice.ObjectPrxHelper)object).__reference().endpoints.length > 0)
 		    {
-			StringBuffer s = new StringBuffer();
-			s.append("couldn't contact the locator to retrieve adapter endpoints\n");
-			s.append("adapter = " + ref.adapterId + "\n");
-			s.append("reason = " + ex);
-			ref.instance.logger().trace(ref.instance.traceLevels().locationCat, s.toString());
+			endpoints = ((Ice.ObjectPrxHelper)object).__reference().endpoints;
+		    }
+		    else if(((Ice.ObjectPrxHelper)object).__reference().adapterId.length() > 0)
+		    {
+			endpoints = getEndpoints(((Ice.ObjectPrxHelper)object).__reference(), cached);
 		    }
 		}
 		
-		if(endpoints != null && endpoints.length > 0)
+		if(!cached.value && endpoints != null && endpoints.length > 0)
 		{
-		    _adapterTable.add(ref.adapterId, endpoints);
+		    _table.addProxy(ref.identity, object);
 		}
 	    }
-
-	    if(endpoints != null && endpoints.length > 0)
+	}
+	catch(Ice.AdapterNotFoundException ex)
+	{
+	    Ice.NotRegisteredException e = new Ice.NotRegisteredException();
+	    e.kindOfObject = "object adapter";
+	    e.id = ref.adapterId;
+	    throw e;
+	}
+	catch(Ice.ObjectNotFoundException ex)
+	{
+	    Ice.NotRegisteredException e = new Ice.NotRegisteredException();
+	    e.kindOfObject = "object";
+	    e.id = Ice.Util.identityToString(ref.identity);
+	    throw e;
+	}
+	catch(Ice.NotRegisteredException ex)
+	{
+	    throw ex;
+	}
+	catch(Ice.LocalException ex)
+	{
+	    if(ref.instance.traceLevels().location >= 1)
 	    {
-		if(ref.instance.traceLevels().location >= 1)
+		StringBuffer s = new StringBuffer();
+		s.append("couldn't contact the locator to retrieve adapter endpoints\n");
+		if(ref.adapterId.length() > 0)
 		{
-		    StringBuffer s = new StringBuffer();
-		    if(cached.value)
-			s.append("found endpoints in locator table\n");
-		    else
-			s.append("retrieved endpoints from locator, adding to locator table\n");
 		    s.append("adapter = " + ref.adapterId + "\n");
- 		    s.append("endpoints = ");
-		    final int sz = endpoints.length;
-		    for(int i = 0; i < sz; i++)
-		    {
-			s.append(endpoints[i].toString());
-			if(i + 1 < sz)
-			    s.append(":");
-		    }
-		    ref.instance.logger().trace(ref.instance.traceLevels().locationCat, s.toString());
 		}
+		else
+		{
+		    s.append("object = " + Ice.Util.identityToString(ref.identity) + "\n");
+		}
+		s.append("reason = " + ex);
+		ref.instance.logger().trace(ref.instance.traceLevels().locationCat, s.toString());
+	    }
+	}
+
+	if(ref.instance.traceLevels().location >= 1 && endpoints != null && endpoints.length > 0)
+	{
+	    if(cached.value)
+	    {
+		trace("found endpoints in locator table", ref, endpoints);
+	    }
+	    else
+	    {
+		trace("retrieved endpoints from locator, adding to locator table", ref, endpoints);
 	    }
 	}
 
-	return endpoints == null ? new IceInternal.Endpoint[0] : endpoints;
+	return endpoints == null ? new Endpoint[0] : endpoints;
     }
 
     public void
+    clearObjectCache(Reference ref)
+    {
+	if(ref.adapterId.length() == 0 && ref.endpoints.length == 0)
+	{
+	    Ice.ObjectPrx object = _table.removeProxy(ref.identity);
+	    if(object != null && ref.instance.traceLevels().location >= 2)
+	    {
+		Reference r = ((Ice.ObjectPrxHelper)object).__reference();
+		if(r.endpoints.length > 0)
+		{
+		    trace("removed endpoints from locator table", ref, r.endpoints);
+		}
+	    }
+	}
+    }
+    
+    public void
     clearCache(Reference ref)
     {
 	if(ref.adapterId.length() > 0)
 	{
-	    IceInternal.Endpoint[] endpoints = _adapterTable.remove(ref.adapterId);
+	    Endpoint[] endpoints = _table.removeAdapterEndpoints(ref.adapterId);
 
 	    if(ref.instance.traceLevels().location >= 2)
 	    {
-		StringBuffer s = new StringBuffer();
-		s.append("removed endpoints from locator table\n");
-		s.append("adapter = " + ref.adapterId + "\n");
-		s.append("endpoints = ");
-		final int sz = endpoints.length;
-		for(int i = 0; i < sz; i++)
+		trace("removed endpoints from locator table\n", ref, endpoints);
+	    }
+	}
+	else if(ref.endpoints.length == 0)
+	{
+	    Ice.ObjectPrx object = _table.getProxy(ref.identity);
+	    if(object != null)
+	    {
+		Reference r = ((Ice.ObjectPrxHelper)object).__reference();
+		if(r.adapterId.length() > 0)
 		{
-		    s.append(endpoints[i].toString());
-		    if(i + 1 < sz)
-			s.append(":");
+		    clearCache(r);
+		}
+		else if(r.endpoints.length > 0)
+		{
+		    if(ref.instance.traceLevels().location >= 2)
+		    {
+			trace("removed endpoints from locator table", ref, r.endpoints);
+		    }
 		}
-		ref.instance.logger().trace(ref.instance.traceLevels().locationCat, s.toString());
 	    }
 	}
     }
 
+    private void
+    trace(String msg, Reference ref, Endpoint[] endpoints)
+    {
+	StringBuffer s = new StringBuffer();
+	s.append(msg + "\n");
+	if(ref.adapterId.length() > 0)
+	{
+	    s.append("adapter = " + ref.adapterId + "\n");
+	}
+	else
+	{
+	    s.append("object = " + Ice.Util.identityToString(ref.identity) + "\n");
+	}
+
+	s.append("endpoints = ");
+	final int sz = endpoints.length;
+	for(int i = 0; i < sz; i++)
+	{
+	    s.append(endpoints[i].toString());
+	    if(i + 1 < sz)
+		s.append(":");
+	}
+
+	ref.instance.logger().trace(ref.instance.traceLevels().locationCat, s.toString());
+    }
+
     private Ice.LocatorPrx _locator; // Immutable.
     private Ice.LocatorRegistryPrx _locatorRegistry;
-    private LocatorAdapterTable _adapterTable; // Immutable.
+    private LocatorTable _table; // Immutable.
 };
 
diff --git a/java/src/IceInternal/LocatorManager.java b/java/src/IceInternal/LocatorManager.java
index 51404b74ab3..e61a9711417 100644
--- a/java/src/IceInternal/LocatorManager.java
+++ b/java/src/IceInternal/LocatorManager.java
@@ -30,7 +30,7 @@ public final class LocatorManager
             info.destroy();
         }
         _table.clear();
-	_adapterTables.clear();
+	_locatorTables.clear();
     }
 
     //
@@ -59,14 +59,14 @@ public final class LocatorManager
 		// have only one table per locator (not one per locator
 		// proxy).
 		//
-		LocatorAdapterTable adapterTable = (LocatorAdapterTable)_adapterTables.get(locator.ice_getIdentity());
-		if(adapterTable == null)
+		LocatorTable table = (LocatorTable)_locatorTables.get(locator.ice_getIdentity());
+		if(table == null)
 		{
-		    adapterTable = new LocatorAdapterTable();
-		    _adapterTables.put(locator.ice_getIdentity(), adapterTable);
+		    table = new LocatorTable();
+		    _locatorTables.put(locator.ice_getIdentity(), table);
 		}
 
-                info = new LocatorInfo(locator, adapterTable);
+                info = new LocatorInfo(locator, table);
                 _table.put(locator, info);
             }
 
@@ -75,5 +75,5 @@ public final class LocatorManager
     }
 
     private java.util.HashMap _table = new java.util.HashMap();
-    private java.util.HashMap _adapterTables = new java.util.HashMap();
+    private java.util.HashMap _locatorTables = new java.util.HashMap();
 }
diff --git a/java/src/IceInternal/LocatorTable.java b/java/src/IceInternal/LocatorTable.java
new file mode 100644
index 00000000000..a98843d75bc
--- /dev/null
+++ b/java/src/IceInternal/LocatorTable.java
@@ -0,0 +1,69 @@
+// **********************************************************************
+//
+// Copyright (c) 2002
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+package IceInternal;
+
+final class LocatorTable
+{
+    LocatorTable()
+    {
+    }
+
+    synchronized void
+    clear()
+    {
+	_adapterEndpointsTable.clear();
+	_objectTable.clear();
+    }
+
+    synchronized IceInternal.Endpoint[]
+    getAdapterEndpoints(String adapter)
+    {
+	return (IceInternal.Endpoint[])_adapterEndpointsTable.get(adapter);
+    }
+
+    synchronized void
+    addAdapterEndpoints(String adapter, IceInternal.Endpoint[] endpoints)
+    {
+	_adapterEndpointsTable.put(adapter, endpoints);
+    }
+
+    synchronized IceInternal.Endpoint[]
+    removeAdapterEndpoints(String adapter)
+    {
+	return (IceInternal.Endpoint[])_adapterEndpointsTable.remove(adapter);
+    }
+
+    synchronized Ice.ObjectPrx
+    getProxy(Ice.Identity id)
+    {
+	return (Ice.ObjectPrx)_objectTable.get(id);
+    }
+
+    synchronized void
+    addProxy(Ice.Identity id, Ice.ObjectPrx proxy)
+    {
+	_objectTable.put(id, proxy);
+    }
+
+    synchronized Ice.ObjectPrx
+    removeProxy(Ice.Identity id)
+    {
+	return (Ice.ObjectPrx)_objectTable.remove(id);
+    }
+
+    private java.util.HashMap _adapterEndpointsTable = new java.util.HashMap();
+    private java.util.HashMap _objectTable = new java.util.HashMap();
+};
+