Added support for invocation timeouts and ACM heartbeats

1 files changed, 70 insertions, 22 deletions

diff --git a/java/src/IceInternal/BatchOutgoing.java b/java/src/IceInternal/BatchOutgoing.java
index 2bbfe3a5ca9..65795d25c92 100644
--- a/java/src/IceInternal/BatchOutgoing.java
+++ b/java/src/IceInternal/BatchOutgoing.java
@@ -38,50 +38,98 @@ public final class BatchOutgoing implements OutgoingMessageCallback
     {
         assert(_handler != null || _connection != null);
 
-        if(_handler != null && !_handler.flushBatchRequests(this) || 
-           _connection != null && !_connection.flushBatchRequests(this))
+        int timeout;
+        if(_connection != null)
         {
-            synchronized(this)
+            if(_connection.flushBatchRequests(this))
             {
-                while(_exception == null && !_sent)
+                return;
+            }
+            timeout = -1;
+        }
+        else
+        {
+            try
+            {
+                if(_handler.sendRequest(this))
+                {
+                    return;
+                }
+            }
+            catch(IceInternal.LocalExceptionWrapper ex)
+            {
+                throw ex.get();
+            }
+            timeout = _handler.getReference().getInvocationTimeout();
+        }
+
+        boolean timedOut = false;
+        synchronized(this)
+        {
+            if(timeout > 0)
+            {
+                long now = Time.currentMonotonicTimeMillis();
+                long deadline = now + timeout;
+                while(_exception == null && !_sent && !timedOut)
                 {
                     try
                     {
-                        wait();
+                        wait(deadline - now);
+                        if(_exception == null && !_sent)
+                        {
+                            now = Time.currentMonotonicTimeMillis();
+                            timedOut = now >= deadline;
+                        }
                     }
-                    catch(java.lang.InterruptedException ex)
+                    catch(InterruptedException ex)
                     {
                     }
                 }
-                
-                if(_exception != null)
+            }
+            else
+            {
+                while(_exception == null && !_sent)
                 {
-                    throw _exception;
+                    try
+                    {
+                        wait();
+                    }
+                    catch(InterruptedException ex)
+                    {
+                    }
                 }
             }
         }
-    }
-
-    public void
-    sent(boolean async)
-    {
-        if(async)
+        
+        if(timedOut)
         {
-            synchronized(this)
-            {
-                _sent = true;
-                notify();
-            }
+            _handler.requestTimedOut(this);
+            assert(_exception != null);
         }
-        else
+
+        if(_exception != null)
         {
-            _sent = true;
+            _exception.fillInStackTrace();
+            throw _exception;
         }
+    }
+
+    public boolean
+    send(Ice.ConnectionI connection, boolean compress, boolean response)
+    {
+        return connection.flushBatchRequests(this);
+    }
+
+    synchronized public void
+    sent()
+    {
         if(_remoteObserver != null)
         {
             _remoteObserver.detach();
             _remoteObserver = null;
         }
+        _sent = true;
+        notify();
     }
     
     public synchronized void