zeroc-ice 3.6b1 → 3.6.0

data/ext/ice/cpp/src/Ice/CollocatedRequestHandler.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -43,15 +43,10 @@ public:
     CollocatedRequestHandler(const ReferencePtr&, const Ice::ObjectAdapterPtr&);
     virtual ~CollocatedRequestHandler();
 
-    virtual RequestHandlerPtr connect(const Ice::ObjectPrx&);
     virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&);
 
-    virtual void prepareBatchRequest(BasicStream*);
-    virtual void finishBatchRequest(BasicStream*);
-    virtual void abortBatchRequest();
-
-    virtual bool sendRequest(OutgoingBase*);
-    virtual AsyncStatus sendAsyncRequest(const OutgoingAsyncBasePtr&);
+    virtual bool sendRequest(ProxyOutgoingBase*);
+    virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&);
 
     virtual void requestCanceled(OutgoingBase*, const Ice::LocalException&);
     virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
@@ -66,15 +61,13 @@ public:
     virtual Ice::ConnectionIPtr getConnection();
     virtual Ice::ConnectionIPtr waitForConnection();
 
-    void invokeRequest(Outgoing*);
-    AsyncStatus invokeAsyncRequest(OutgoingAsync*);
-    void invokeBatchRequests(OutgoingBase*);
-    AsyncStatus invokeAsyncBatchRequests(OutgoingAsyncBase*);
+    void invokeRequest(OutgoingBase*, int);
+    AsyncStatus invokeAsyncRequest(OutgoingAsyncBase*, int);
 
     bool sent(OutgoingBase*);
     bool sentAsync(OutgoingAsyncBase*);
 
-    void invokeAll(BasicStream*, Ice::Int, Ice::Int, bool);
+    void invokeAll(BasicStream*, Ice::Int, Ice::Int);
 
 private:
 
@@ -84,20 +77,14 @@ private:
     const bool _dispatcher;
     const Ice::LoggerPtr _logger;
     const TraceLevelsPtr _traceLevels;
-    const size_t _batchAutoFlushSize;
 
     int _requestId;
 
     std::map<OutgoingBase*, Ice::Int> _sendRequests;
     std::map<OutgoingAsyncBasePtr, Ice::Int> _sendAsyncRequests;
 
-    std::map<Ice::Int, Outgoing*> _requests;
-    std::map<Ice::Int, OutgoingAsyncPtr> _asyncRequests;
-
-    bool _batchStreamInUse;
-    int _batchRequestNum;
-    BasicStream _batchStream;
-    size_t _batchMarker;
+    std::map<Ice::Int, OutgoingBase*> _requests;
+    std::map<Ice::Int, OutgoingAsyncBasePtr> _asyncRequests;
 };
 typedef IceUtil::Handle<CollocatedRequestHandler> CollocatedRequestHandlerPtr;
 

data/ext/ice/cpp/src/Ice/Communicator.cpp

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
 //
-// Ice version 3.6b
+// Ice version 3.6.0
 //
 // <auto-generated>
 //
@@ -32,8 +32,14 @@
 #include <IceUtil/PopDisableWarnings.h>
 
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION  != 30651
-#       error Ice version mismatch: an exact match is required for beta generated code
+#   if ICE_INT_VERSION / 100 != 306
+#       error Ice version mismatch!
+#   endif
+#   if ICE_INT_VERSION % 100 > 50
+#       error Beta header file detected
+#   endif
+#   if ICE_INT_VERSION % 100 < 0
+#       error Ice patch level mismatch!
 #   endif
 #endif
 
@@ -42,4 +48,4 @@ namespace
 
 }
 
-ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::upCast(::Ice::Communicator* p) { return p; }
+ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::Communicator* p) { return p; }

data/ext/ice/cpp/src/Ice/CommunicatorF.cpp

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
 //
-// Ice version 3.6b
+// Ice version 3.6.0
 //
 // <auto-generated>
 //
@@ -27,8 +27,14 @@
 #include <IceUtil/PopDisableWarnings.h>
 
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION  != 30651
-#       error Ice version mismatch: an exact match is required for beta generated code
+#   if ICE_INT_VERSION / 100 != 306
+#       error Ice version mismatch!
+#   endif
+#   if ICE_INT_VERSION % 100 > 50
+#       error Beta header file detected
+#   endif
+#   if ICE_INT_VERSION % 100 < 0
+#       error Ice patch level mismatch!
 #   endif
 #endif
 

data/ext/ice/cpp/src/Ice/CommunicatorI.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -279,11 +279,11 @@ Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePt
     // This callback object receives the results of all invocations
     // of Connection::begin_flushBatchRequests.
     //
-    CommunicatorFlushBatchPtr result = new CommunicatorFlushBatch(this, 
-                                                                  _instance, 
-                                                                  __flushBatchRequests_name, 
-                                                                  cb, 
-                                                                  cookie);
+    CommunicatorFlushBatchAsyncPtr result = new CommunicatorFlushBatchAsync(this,
+                                                                            _instance,
+                                                                            __flushBatchRequests_name,
+                                                                            cb,
+                                                                            cookie);
 
     connectionFactory->flushAsyncBatchRequests(result);
     adapterFactory->flushAsyncBatchRequests(result);

data/ext/ice/cpp/src/Ice/CommunicatorI.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.

data/ext/ice/cpp/src/Ice/ConnectRequestHandler.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -23,14 +23,13 @@
 using namespace std;
 using namespace IceInternal;
 
+IceUtil::Shared* IceInternal::upCast(ConnectRequestHandler* p) { return p; }
+
 ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref, const Ice::ObjectPrx& proxy) :
     RequestHandler(ref),
-    _connect(true),
     _proxy(proxy),
     _initialized(false),
-    _flushing(false),
-    _batchRequestInProgress(false),
-    _batchStream(ref->getInstance().get(), Ice::currentProtocolEncoding)
+    _flushing(false)
 {
 }
 
@@ -41,39 +40,27 @@ ConnectRequestHandler::~ConnectRequestHandler()
 RequestHandlerPtr
 ConnectRequestHandler::connect(const Ice::ObjectPrx& proxy)
 {
-    //
-    // Initiate the connection if connect() is called by the proxy that
-    // created the handler.
-    //
-    if(proxy.get() == _proxy.get() && _connect) 
-    {
-        _connect = false; // Call getConnection only once
-        _reference->getConnection(this);
-    }
-
+    Lock sync(*this);
     try
     {
-        Lock sync(*this);
         if(!initialized())
         {
             _proxies.insert(proxy);
-            return this;
         }
     }
     catch(const Ice::LocalException&)
     {
-        throw;
-    }
-
-    if(_connectionRequestHandler)
-    {
-        proxy->__setRequestHandler(this, _connectionRequestHandler);
-        return _connectionRequestHandler;
-    }
-    else
-    {
-        return this;
+        //
+        // Only throw if the connection didn't get established. If
+        // it died after being established, we allow the caller to
+        // retry the connection establishment by not throwing here.
+        //
+        if(!_connection)
+        {
+            throw;
+        }
     }
+    return _requestHandler ? _requestHandler : this;
 }
 
 RequestHandlerPtr
@@ -82,93 +69,24 @@ ConnectRequestHandler::update(const RequestHandlerPtr& previousHandler, const Re
     return previousHandler.get() == this ? newHandler : this;
 }
 
-void
-ConnectRequestHandler::prepareBatchRequest(BasicStream* os)
+bool
+ConnectRequestHandler::sendRequest(ProxyOutgoingBase* out)
 {
     {
         Lock sync(*this);
-        while(_batchRequestInProgress)
-        {
-            wait();
-        }
-
         if(!initialized())
         {
-            _batchRequestInProgress = true;
-            _batchStream.swap(*os);
-            return;
-        }
-    }
-    _connection->prepareBatchRequest(os);
-}
-
-void
-ConnectRequestHandler::finishBatchRequest(BasicStream* os)
-{
-    {
-        Lock sync(*this);
-        if(!initialized()) // This can't throw until _batchRequestInProgress = false
-        {
-            assert(_batchRequestInProgress);
-            _batchRequestInProgress = false;
-            notifyAll();
-
-            _batchStream.swap(*os);
-
             Request req;
-            req.os = new BasicStream(_reference->getInstance().get(), Ice::currentProtocolEncoding);
-            req.os->swap(_batchStream);
+            req.out = out;
             _requests.push_back(req);
-            return;
-        }
-    }
-    _connection->finishBatchRequest(os, _compress);
-}
-
-void
-ConnectRequestHandler::abortBatchRequest()
-{
-    {
-        Lock sync(*this);
-        if(!initialized()) // This can't throw until _batchRequestInProgress = false
-        {
-            assert(_batchRequestInProgress);
-            _batchRequestInProgress = false;
-            notifyAll();
-
-            BasicStream dummy(_reference->getInstance().get(), Ice::currentProtocolEncoding);
-            _batchStream.swap(dummy);
-            return;
+            return false; // Not sent
         }
     }
-    _connection->abortBatchRequest();
-}
-
-bool
-ConnectRequestHandler::sendRequest(OutgoingBase* out)
-{
-    {
-        Lock sync(*this);
-        try
-        {
-            if(!initialized())
-            {
-                Request req;
-                req.out = out;
-                _requests.push_back(req);
-                return false; // Not sent
-            }
-        }
-        catch(const Ice::LocalException& ex)
-        {
-            throw RetryException(ex);
-        }
-    }
-    return out->send(_connection, _compress, _response) && !_response; // Finished if sent and no response.
+    return out->invokeRemote(_connection, _compress, _response) && !_response; // Finished if sent and no response.
 }
 
 AsyncStatus
-ConnectRequestHandler::sendAsyncRequest(const OutgoingAsyncBasePtr& out)
+ConnectRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& out)
 {
     {
         Lock sync(*this);
@@ -177,22 +95,15 @@ ConnectRequestHandler::sendAsyncRequest(const OutgoingAsyncBasePtr& out)
             out->cancelable(this); // This will throw if the request is canceled
         }
 
-        try
-        {
-            if(!initialized())
-            {
-                Request req;
-                req.outAsync = out;
-                _requests.push_back(req);
-                return AsyncStatusQueued;
-            }
-        }
-        catch(const Ice::LocalException& ex)
+        if(!initialized())
         {
-            throw RetryException(ex);
+            Request req;
+            req.outAsync = out;
+            _requests.push_back(req);
+            return AsyncStatusQueued;
         }
     }
-    return out->send(_connection, _compress, _response);
+    return out->invokeRemote(_connection, _compress, _response);
 }
 
 void
@@ -350,18 +261,13 @@ ConnectRequestHandler::setException(const Ice::LocalException& ex)
         {
             p->out->completed(*_exception.get());
         }
-        else if(p->outAsync)
+        else
         {
             if(p->outAsync->completed(*_exception.get()))
             {
                 p->outAsync->invokeCompletedAsync();
             }
         }
-        else
-        {
-            assert(p->os);
-            delete p->os;
-        }
     }
     _requests.clear();
     notifyAll();
@@ -413,11 +319,6 @@ ConnectRequestHandler::flushRequests()
         Lock sync(*this);
         assert(_connection && !_initialized);
 
-        while(_batchRequestInProgress)
-        {
-            wait();
-        }
-
         //
         // We set the _flushing flag to true to prevent any additional queuing. Callers
         // might block for a little while as the queued requests are being sent but this
@@ -434,29 +335,9 @@ ConnectRequestHandler::flushRequests()
         {
             if(req.out)
             {
-                req.out->send(_connection, _compress, _response);
-            }
-            else if(req.os)
-            {
-                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->invokeRemote(_connection, _compress, _response);
             }
-            else if(req.outAsync->send(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
+            else if(req.outAsync->invokeRemote(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
             {
                 req.outAsync->invokeSentAsync();
             }
@@ -464,24 +345,14 @@ ConnectRequestHandler::flushRequests()
         catch(const RetryException& ex)
         {
             exception.reset(ex.get()->ice_clone());
-            try
-            {
-                // Remove the request handler before retrying.
-                _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
-            }
-            catch(const Ice::CommunicatorDestroyedException&)
-            {
-                // Ignore
-            }
+
+            // Remove the request handler before retrying.
+            _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
 
             if(req.out)
             {
                 req.out->retryException(*ex.get());
             }
-            else if(req.os)
-            {
-                delete req.os;
-            }
             else
             {
                 req.outAsync->retryException(*ex.get());
@@ -494,10 +365,6 @@ ConnectRequestHandler::flushRequests()
             {
                 req.out->completed(ex);
             }
-            else if(req.os)
-            {
-                delete req.os;
-            }
             else if(req.outAsync->completed(ex))
             {
                 req.outAsync->invokeCompletedAsync();
@@ -514,10 +381,10 @@ ConnectRequestHandler::flushRequests()
     //
     if(_reference->getCacheConnection() && !exception.get())
     {
-        _connectionRequestHandler = new ConnectionRequestHandler(_reference, _connection, _compress);
+        _requestHandler = new ConnectionRequestHandler(_reference, _connection, _compress);
         for(set<Ice::ObjectPrx>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
         {
-            (*p)->__setRequestHandler(this, _connectionRequestHandler);
+            (*p)->__updateRequestHandler(this, _requestHandler);
         }
     }
 
@@ -527,18 +394,13 @@ ConnectRequestHandler::flushRequests()
         _exception.swap(exception);
         _initialized = !_exception.get();
         _flushing = false;
-        try
-        {
-            //
-            // Only remove once all the requests are flushed to
-            // guarantee serialization.
-            //
-            _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
-        }
-        catch(const Ice::CommunicatorDestroyedException&)
-        {
-            // Ignore
-        }
+
+        //
+        // Only remove once all the requests are flushed to
+        // guarantee serialization.
+        //
+        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
+
         _proxies.clear();
         _proxy = 0; // Break cyclic reference count.
         notifyAll();