Removed ice_flush() from proxy base class and implemented

    Communicator::flushBatchRequests().

16 files changed, 92 insertions, 52 deletions

diff --git a/java/CHANGES b/java/CHANGES
index e054a05b50a..903b9288456 100644
--- a/java/CHANGES
+++ b/java/CHANGES
@@ -1,6 +1,11 @@
 Changes since version 1.1.1
 ---------------------------
 
+- Removed ice_flush() on the proxy base class. Batch requests are
+  now flushed by calling Communicator::flushBatchRequests(). This
+  flushes all requests that are currently batched in the communicator,
+  (for all connections).
+
 - Added back the connection closure timeout, but only for misbehaving
   peers. If a timeout is set, and a peer does't react to a close
   connection message, the connection is forcefully closed after the
diff --git a/java/demo/Glacier/session/Client.java b/java/demo/Glacier/session/Client.java
index 9eed44215f2..4bb13e7f926 100644
--- a/java/demo/Glacier/session/Client.java
+++ b/java/demo/Glacier/session/Client.java
@@ -156,8 +156,7 @@ public class Client
                 }
                 else if(line.equals("f"))
                 {
-                    batchOneway.ice_flush();
-                    batchDatagram.ice_flush();
+		    communicator.flushBatchRequests();
                 }
                 else if(line.equals("T"))
                 {
diff --git a/java/demo/Ice/callback/CallbackClient.java b/java/demo/Ice/callback/CallbackClient.java
index 46f2c9e8bcc..81fba3f4697 100644
--- a/java/demo/Ice/callback/CallbackClient.java
+++ b/java/demo/Ice/callback/CallbackClient.java
@@ -130,8 +130,7 @@ class CallbackClient extends Ice.Application
                 }
                 else if(line.equals("f"))
                 {
-                    batchOneway.ice_flush();
-                    batchDatagram.ice_flush();
+		    communicator().flushBatchRequests();
                 }
                 else if(line.equals("S"))
                 {
diff --git a/java/demo/Ice/hello/Client.java b/java/demo/Ice/hello/Client.java
index c5a75693aba..f21fd38d1fd 100644
--- a/java/demo/Ice/hello/Client.java
+++ b/java/demo/Ice/hello/Client.java
@@ -97,8 +97,7 @@ public class Client
                 }
                 else if(line.equals("f"))
                 {
-                    batchOneway.ice_flush();
-                    batchDatagram.ice_flush();
+		    communicator.flushBatchRequests();
                 }
                 else if(line.equals("T"))
                 {
diff --git a/java/demo/IceBox/hello/Client.java b/java/demo/IceBox/hello/Client.java
index 191412c3ebc..ec2d75184a9 100644
--- a/java/demo/IceBox/hello/Client.java
+++ b/java/demo/IceBox/hello/Client.java
@@ -96,8 +96,7 @@ public class Client
                 }
                 else if(line.equals("f"))
                 {
-                    batchOneway.ice_flush();
-                    batchDatagram.ice_flush();
+		    communicator.flushBatchRequests();
                 }
                 else if(line.equals("T"))
                 {
diff --git a/java/src/Ice/CommunicatorI.java b/java/src/Ice/CommunicatorI.java
index 403b4bb9210..df1fda37f88 100644
--- a/java/src/Ice/CommunicatorI.java
+++ b/java/src/Ice/CommunicatorI.java
@@ -266,7 +266,7 @@ final class CommunicatorI extends LocalObjectImpl implements Communicator
     public void
     flushBatchRequests()
     {
-        // TODO: implement this.
+        _instance.flushBatchRequests();
     }
 
     CommunicatorI(StringSeqHolder args, Properties properties)
diff --git a/java/src/Ice/ObjectAdapterI.java b/java/src/Ice/ObjectAdapterI.java
index b91d8119198..4f67e8edc68 100644
--- a/java/src/Ice/ObjectAdapterI.java
+++ b/java/src/Ice/ObjectAdapterI.java
@@ -475,6 +475,21 @@ public final class ObjectAdapterI extends LocalObjectImpl implements ObjectAdapt
         return arr;
     }
 
+    public void
+    flushBatchRequests()
+    {
+	java.util.ArrayList f;
+	synchronized(this)
+	{
+	    f = new java.util.ArrayList(_incomingConnectionFactories);
+	}
+	java.util.Iterator i = f.iterator();
+	while(i.hasNext())
+	{
+	    ((IceInternal.IncomingConnectionFactory)i.next()).flushBatchRequests();
+	}
+    }
+
     public synchronized void
     incDirectCount()
     {
diff --git a/java/src/Ice/ObjectPrx.java b/java/src/Ice/ObjectPrx.java
index c83276dea20..93cc42b99cf 100644
--- a/java/src/Ice/ObjectPrx.java
+++ b/java/src/Ice/ObjectPrx.java
@@ -71,7 +71,5 @@ public interface ObjectPrx
     ObjectPrx ice_collocationOptimization(boolean b);
     ObjectPrx ice_default();
 
-    void ice_flush();
-
     boolean equals(java.lang.Object r);
 }
diff --git a/java/src/Ice/ObjectPrxHelper.java b/java/src/Ice/ObjectPrxHelper.java
index 0bb1e235f61..eeeb66bfbc5 100644
--- a/java/src/Ice/ObjectPrxHelper.java
+++ b/java/src/Ice/ObjectPrxHelper.java
@@ -527,33 +527,6 @@ public class ObjectPrxHelper implements ObjectPrx
         }
     }
 
-    public final void
-    ice_flush()
-    {
-	//
-	// Retry is necessary for ice_flush in case the current connection
-	// is closed. If that's the case we need to get a new connection.
-	//
-        int __cnt = 0;
-        while(true)
-        {
-            try
-            {
-                _ObjectDel __del = __getDelegate();
-                __del.ice_flush();
-                return;
-            }
-	    catch(Ice.DatagramLimitException ex)
-	    {
-	        throw ex; // DatagramLimitException is not repeatable.
-	    }
-            catch(LocalException __ex)
-            {
-                __cnt = __handleException(__ex, __cnt);
-            }
-        }
-    }
-
     public final boolean
     equals(java.lang.Object r)
     {
diff --git a/java/src/Ice/_ObjectDel.java b/java/src/Ice/_ObjectDel.java
index 5ed377ce3e5..5d929566123 100644
--- a/java/src/Ice/_ObjectDel.java
+++ b/java/src/Ice/_ObjectDel.java
@@ -37,6 +37,4 @@ public interface _ObjectDel
 
     void ice_invoke_async(AMI_Object_ice_invoke cb, String operation, Ice.OperationMode mode, byte[] inParams,
 			  java.util.Map context);
-
-    void ice_flush();
 }
diff --git a/java/src/Ice/_ObjectDelD.java b/java/src/Ice/_ObjectDelD.java
index 04007735242..cc18359fa7a 100644
--- a/java/src/Ice/_ObjectDelD.java
+++ b/java/src/Ice/_ObjectDelD.java
@@ -132,12 +132,6 @@ public class _ObjectDelD implements _ObjectDel
 	throw new CollocationOptimizationException();
     }
 
-    public void
-    ice_flush()
-    {
-        // Nothing to do for direct delegates.
-    }
-
     //
     // Only for use by ObjectPrx.
     //
diff --git a/java/src/Ice/_ObjectDelM.java b/java/src/Ice/_ObjectDelM.java
index 1bdc8e19e2e..cf3505fc3da 100644
--- a/java/src/Ice/_ObjectDelM.java
+++ b/java/src/Ice/_ObjectDelM.java
@@ -185,12 +185,6 @@ public class _ObjectDelM implements _ObjectDel
 	cb.__invoke();
     }
 
-    public void
-    ice_flush()
-    {
-        __connection.flushBatchRequest();
-    }
-
     //
     // Only for use by ObjectPrx
     //
diff --git a/java/src/IceInternal/IncomingConnectionFactory.java b/java/src/IceInternal/IncomingConnectionFactory.java
index 251e1d1ec5b..adb21c99db8 100644
--- a/java/src/IceInternal/IncomingConnectionFactory.java
+++ b/java/src/IceInternal/IncomingConnectionFactory.java
@@ -139,6 +139,16 @@ public class IncomingConnectionFactory extends EventHandler
         return arr;
     }
 
+    public void
+    flushBatchRequests()
+    {
+        Connection[] c = connections(); // connections() is synchronized, so no need to synchronize here.
+	for(int i = 0; i < c.length; i++)
+	{
+	    c[i].flushBatchRequest();
+	}
+    }
+
     //
     // Operations from EventHandler.
     //
diff --git a/java/src/IceInternal/Instance.java b/java/src/IceInternal/Instance.java
index 638eb2f69d7..99307251ed1 100644
--- a/java/src/IceInternal/Instance.java
+++ b/java/src/IceInternal/Instance.java
@@ -258,6 +258,23 @@ public class Instance
 	return _messageSizeMax;
     }
 
+    public void
+    flushBatchRequests()
+    {
+	OutgoingConnectionFactory f;
+	Ice.ObjectAdapterI adapters[];
+	synchronized(this)
+	{
+	    f = _outgoingConnectionFactory;
+	    adapters = _objectAdapterFactory.adapters();
+	}
+	f.flushBatchRequests();
+	for(int i = 0; i < adapters.length; i++)
+	{
+	    adapters[i].flushBatchRequests();
+	}
+    }
+
     public BufferManager
     bufferManager()
     {
diff --git a/java/src/IceInternal/ObjectAdapterFactory.java b/java/src/IceInternal/ObjectAdapterFactory.java
index 659017e0d51..2f139d16740 100644
--- a/java/src/IceInternal/ObjectAdapterFactory.java
+++ b/java/src/IceInternal/ObjectAdapterFactory.java
@@ -149,6 +149,20 @@ public final class ObjectAdapterFactory
         return null;
     }
 
+    public synchronized Ice.ObjectAdapterI[]
+    adapters()
+    {
+	java.util.LinkedList a = new java.util.LinkedList();
+	java.util.Iterator i = _adapters.values().iterator();
+	while(i.hasNext())
+	{
+	    a.add(i.next());
+	}
+	Ice.ObjectAdapterI[] arr = new Ice.ObjectAdapterI[a.size()];
+	a.toArray(arr);
+	return arr;
+    }
+
     //
     // Only for use by Instance.
     //
diff --git a/java/src/IceInternal/OutgoingConnectionFactory.java b/java/src/IceInternal/OutgoingConnectionFactory.java
index 052c6791dd3..ef4f4c30d2e 100644
--- a/java/src/IceInternal/OutgoingConnectionFactory.java
+++ b/java/src/IceInternal/OutgoingConnectionFactory.java
@@ -393,6 +393,32 @@ public class OutgoingConnectionFactory
 	}
     }
 
+    public void
+    flushBatchRequests()
+    {
+	java.util.LinkedList c = new java.util.LinkedList();
+
+        synchronized(this)
+	{
+	    java.util.Iterator p = _connections.values().iterator();
+	    while(p.hasNext())
+	    {
+		java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
+		java.util.Iterator q = connectionList.iterator();
+		while(q.hasNext())
+		{
+		    c.add(q.next());
+		}
+	    }
+	}
+
+	java.util.Iterator p = c.iterator();
+	while(p.hasNext())
+	{
+	    ((Connection)p.next()).flushBatchRequest();
+	}
+    }
+
     //
     // Only for use by Instance.
     //