Fixed ICE-6142: oneway batch operations didn't throw

1 files changed, 49 insertions, 67 deletions

diff --git a/cpp/src/Ice/ConnectRequestHandler.cpp b/cpp/src/Ice/ConnectRequestHandler.cpp
index cab236aa9e5..ecdf1e86782 100644
--- a/cpp/src/Ice/ConnectRequestHandler.cpp
+++ b/cpp/src/Ice/ConnectRequestHandler.cpp
@@ -92,18 +92,11 @@ ConnectRequestHandler::prepareBatchRequest(BasicStream* os)
             wait();
         }
 
-        try
-        {
-            if(!initialized())
-            {
-                _batchRequestInProgress = true;
-                _batchStream.swap(*os);
-                return;
-            }
-        }
-        catch(const Ice::LocalException& ex)
+        if(!initialized())
         {
-            throw RetryException(ex);
+            _batchRequestInProgress = true;
+            _batchStream.swap(*os);
+            return;
         }
     }
     _connection->prepareBatchRequest(os);
@@ -433,92 +426,81 @@ ConnectRequestHandler::flushRequests()
         _flushing = true;
     }
 
+    IceUtil::UniquePtr<Ice::LocalException> exception;
     while(!_requests.empty()) // _requests is immutable when _flushing = true
     {
         Request& req = _requests.front();
-        if(req.out)
+        try
         {
-            try
+            if(req.out)
             {
                 req.out->send(_connection, _compress, _response);
             }
-            catch(const RetryException& ex)
+            else if(req.os)
             {
+                BasicStream os(req.os->instance(), Ice::currentProtocolEncoding);
+                _connection->prepareBatchRequest(&os);
                 try
                 {
-                    // Remove the request handler before retrying.
-                    _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
+                    const Ice::Byte* bytes;
+                    req.os->i = req.os->b.begin();
+                    req.os->readBlob(bytes, req.os->b.size());
+                    os.writeBlob(bytes, req.os->b.size());
                 }
-                catch(const Ice::CommunicatorDestroyedException&)
+                catch(const Ice::LocalException&)
                 {
-                    // Ignore
+                    _connection->abortBatchRequest();
+                    throw;
                 }
-                req.out->retryException(*ex.get());
+
+                _connection->finishBatchRequest(&os, _compress);
+                delete req.os;
             }
-            catch(const Ice::Exception& ex)
+            else if(req.outAsync->send(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
             {
-                req.out->completed(ex);
+                req.outAsync->invokeSentAsync();
             }
         }
-        else if(req.outAsync)
+        catch(const RetryException& ex)
         {
+            exception.reset(ex.get()->ice_clone());
             try
             {
-                if(req.outAsync->send(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
-                {
-                    req.outAsync->invokeSentAsync();
-                }
+                // Remove the request handler before retrying.
+                _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
             }
-            catch(const RetryException& ex)
+            catch(const Ice::CommunicatorDestroyedException&)
             {
-                try
-                {
-                    // Remove the request handler before retrying.
-                    _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
-                }
-                catch(const Ice::CommunicatorDestroyedException&)
-                {
-                    // Ignore
-                }
-                req.outAsync->retryException(*ex.get());
+                // Ignore
             }
-            catch(const Ice::Exception& ex)
+
+            if(req.out)
             {
-                if(req.outAsync->completed(ex))
-                {
-                    req.outAsync->invokeCompletedAsync();
-                }
+                req.out->retryException(*ex.get());
+            }
+            else if(req.os)
+            {
+                delete req.os;
+            }
+            else
+            {
+                req.outAsync->retryException(*ex.get());
             }
         }
-        else
+        catch(const Ice::LocalException& ex)
         {
-            try
+            exception.reset(ex.ice_clone());
+            if(req.out)
             {
-                BasicStream os(req.os->instance(), Ice::currentProtocolEncoding);
-                _connection->prepareBatchRequest(&os);
-                try
-                {
-                    const Ice::Byte* bytes;
-                    req.os->i = req.os->b.begin();
-                    req.os->readBlob(bytes, req.os->b.size());
-                    os.writeBlob(bytes, req.os->b.size());
-                }
-                catch(const Ice::LocalException&)
-                {
-                    _connection->abortBatchRequest();
-                    throw;
-                }
-
-                _connection->finishBatchRequest(&os, _compress);
-                delete req.os;
+                req.out->completed(ex);
             }
-            catch(const RetryException&)
+            else if(req.os)
             {
                 delete req.os;
             }
-            catch(const Ice::Exception&)
+            else if(req.outAsync->completed(ex))
             {
-                delete req.os;
+                req.outAsync->invokeCompletedAsync();
             }
         }
         _requests.pop_front();
@@ -530,7 +512,7 @@ ConnectRequestHandler::flushRequests()
     // request handler to use the more efficient connection request
     // handler.
     //
-    if(_reference->getCacheConnection())
+    if(_reference->getCacheConnection() && !exception.get())
     {
         _connectionRequestHandler = new ConnectionRequestHandler(_reference, _connection, _compress);
         for(set<Ice::ObjectPrx>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
@@ -542,7 +524,8 @@ ConnectRequestHandler::flushRequests()
     {
         Lock sync(*this);
         assert(!_initialized);
-        _initialized = true;
+        _exception.swap(exception);
+        _initialized = !_exception.get();
         _flushing = false;
         try
         {
@@ -561,4 +544,3 @@ ConnectRequestHandler::flushRequests()
         notifyAll();
     }
 }
-