zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/CollocatedRequestHandler.cpp

@@ -1,16 +1,16 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/CollocatedRequestHandler.h>
-#include <Ice/ObjectAdapterI.h>
-#include <Ice/ThreadPool.h>
-#include <Ice/Reference.h>
-#include <Ice/Instance.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/OutgoingAsync.h>
+#include "CollocatedRequestHandler.h"
+#include "Endian.h"
+#include "Ice/OutgoingAsync.h"
+#include "Instance.h"
+#include "ObjectAdapterI.h"
+#include "Reference.h"
+#include "ThreadPool.h"
+#include "TraceLevels.h"
+#include "TraceUtil.h"
 
-#include <Ice/TraceUtil.h>
+#include <algorithm>
 
 using namespace std;
 using namespace Ice;
@@ -18,70 +18,31 @@ using namespace IceInternal;
 
 namespace
 {
-
-class InvokeAllAsync : public DispatchWorkItem
-{
-public:
-
-    InvokeAllAsync(const OutgoingAsyncBasePtr& outAsync,
-                   OutputStream* os,
-                   const CollocatedRequestHandlerPtr& handler,
-                   Int requestId,
-                   Int batchRequestNum) :
-        _outAsync(outAsync), _os(os), _handler(handler), _requestId(requestId), _batchRequestNum(batchRequestNum)
-    {
-    }
-
-    virtual void
-    run()
+    void fillInValue(OutputStream* os, int pos, int32_t value)
     {
-        if(_handler->sentAsync(_outAsync.get()))
+        const byte* p = reinterpret_cast<const byte*>(&value);
+        if constexpr (endian::native == endian::big)
         {
-            _handler->invokeAll(_os, _requestId, _batchRequestNum);
+            reverse_copy(p, p + sizeof(std::int32_t), os->b.begin() + pos);
+        }
+        else
+        {
+            copy(p, p + sizeof(std::int32_t), os->b.begin() + pos);
         }
     }
-
-private:
-
-    OutgoingAsyncBasePtr _outAsync;
-    OutputStream* _os;
-    CollocatedRequestHandlerPtr _handler;
-    Int _requestId;
-    Int _batchRequestNum;
-};
-
-void
-fillInValue(OutputStream* os, int pos, Int value)
-{
-    const Byte* p = reinterpret_cast<const Byte*>(&value);
-#ifdef ICE_BIG_ENDIAN
-    reverse_copy(p, p + sizeof(Int), os->b.begin() + pos);
-#else
-    copy(p, p + sizeof(Int), os->b.begin() + pos);
-#endif
-}
-
 }
 
-CollocatedRequestHandler::CollocatedRequestHandler(const ReferencePtr& ref, const ObjectAdapterPtr& adapter) :
-    RequestHandler(ref),
-    _adapter(ICE_DYNAMIC_CAST(ObjectAdapterI, adapter)),
-    _dispatcher(_reference->getInstance()->initializationData().dispatcher),
-    _logger(_reference->getInstance()->initializationData().logger), // Cached for better performance.
-    _traceLevels(_reference->getInstance()->traceLevels()), // Cached for better performance.
-    _requestId(0)
+CollocatedRequestHandler::CollocatedRequestHandler(const ReferencePtr& ref, const ObjectAdapterPtr& adapter)
+    : RequestHandler(ref),
+      _adapter(dynamic_pointer_cast<ObjectAdapterI>(adapter)),
+      _hasExecutor(
+          _reference->getInstance()->initializationData().executor != nullptr), // Cached for better performance.
+      _logger(_reference->getInstance()->initializationData().logger),          // Cached for better performance.
+      _traceLevels(_reference->getInstance()->traceLevels())
 {
 }
 
-CollocatedRequestHandler::~CollocatedRequestHandler()
-{
-}
-
-RequestHandlerPtr
-CollocatedRequestHandler::update(const RequestHandlerPtr& previousHandler, const RequestHandlerPtr& newHandler)
-{
-    return previousHandler.get() == this ? newHandler : ICE_SHARED_FROM_THIS;
-}
+CollocatedRequestHandler::~CollocatedRequestHandler() = default;
 
 AsyncStatus
 CollocatedRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& outAsync)
@@ -90,35 +51,35 @@ CollocatedRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& outA
 }
 
 void
-CollocatedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const LocalException& ex)
+CollocatedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, exception_ptr ex)
 {
-    Lock sync(*this);
+    lock_guard<mutex> lock(_mutex);
 
-    map<OutgoingAsyncBasePtr, Int>::iterator p = _sendAsyncRequests.find(outAsync);
-    if(p != _sendAsyncRequests.end())
+    auto p = _sendAsyncRequests.find(outAsync);
+    if (p != _sendAsyncRequests.end())
     {
-        if(p->second > 0)
+        if (p->second > 0)
         {
             _asyncRequests.erase(p->second);
         }
         _sendAsyncRequests.erase(p);
-        if(outAsync->exception(ex))
+        if (outAsync->exception(ex))
         {
             outAsync->invokeExceptionAsync();
         }
-        _adapter->decDirectCount(); // invokeAll won't be called, decrease the direct count.
+        _adapter->decDirectCount(); // dispatchAll won't be called, decrease the direct count.
         return;
     }
 
-    OutgoingAsyncPtr o = ICE_DYNAMIC_CAST(OutgoingAsync, outAsync);
-    if(o)
+    OutgoingAsyncPtr o = dynamic_pointer_cast<OutgoingAsync>(outAsync);
+    if (o)
     {
-        for(map<Int, OutgoingAsyncBasePtr>::iterator q = _asyncRequests.begin(); q != _asyncRequests.end(); ++q)
+        for (auto q = _asyncRequests.begin(); q != _asyncRequests.end(); ++q)
         {
-            if(q->second.get() == o.get())
+            if (q->second.get() == o.get())
             {
                 _asyncRequests.erase(q);
-                if(outAsync->exception(ex))
+                if (outAsync->exception(ex))
                 {
                     outAsync->invokeExceptionAsync();
                 }
@@ -129,171 +90,141 @@ CollocatedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAs
 }
 
 AsyncStatus
-CollocatedRequestHandler::invokeAsyncRequest(OutgoingAsyncBase* outAsync, int batchRequestNum, bool synchronous)
+CollocatedRequestHandler::invokeAsyncRequest(OutgoingAsyncBase* outAsync, int batchRequestCount, bool synchronous)
 {
-    //
-    // Increase the direct count to prevent the thread pool from being destroyed before
-    // invokeAll is called. This will also throw if the object adapter has been deactivated.
-    //
+    // Increase the direct count to prevent the thread pool from being destroyed before dispatchAll is called. This will
+    // also throw if the object adapter has been deactivated.
     _adapter->incDirectCount();
 
     int requestId = 0;
     try
     {
-        Lock sync(*this);
+        {
+            lock_guard<mutex> lock(_mutex);
 
-        //
-        // This will throw if the request is canceled
-        //
-        outAsync->cancelable(ICE_SHARED_FROM_THIS);
+            //
+            // This will throw if the request is canceled
+            //
+            outAsync->cancelable(shared_from_this());
+
+            if (_response)
+            {
+                requestId = ++_requestId;
+                _asyncRequests.insert(make_pair(requestId, outAsync->shared_from_this()));
+            }
 
-        if(_response)
+            _sendAsyncRequests.insert(make_pair(outAsync->shared_from_this(), requestId));
+        }
+
+        OutputStream* os = outAsync->getOs();
+        if (_traceLevels->protocol >= 1)
         {
-            requestId = ++_requestId;
-            _asyncRequests.insert(make_pair(requestId, ICE_GET_SHARED_FROM_THIS(outAsync)));
+            fillInValue(os, 10, static_cast<int32_t>(os->b.size()));
+            if (requestId > 0)
+            {
+                fillInValue(os, headerSize, requestId);
+            }
+            else if (batchRequestCount > 0)
+            {
+                fillInValue(os, headerSize, batchRequestCount);
+            }
+            traceSend(*os, _reference->getInstance(), nullptr, _logger, _traceLevels);
         }
 
-        _sendAsyncRequests.insert(make_pair(ICE_GET_SHARED_FROM_THIS(outAsync), requestId));
-    }
-    catch(...)
-    {
-         _adapter->decDirectCount();
-         throw;
-    }
+        outAsync->attachCollocatedObserver(_adapter, requestId);
 
-    outAsync->attachCollocatedObserver(_adapter, requestId);
+        InputStream is{_reference->getInstance().get(), os->getEncoding(), *os, false};
+
+        if (batchRequestCount > 0)
+        {
+            is.pos(sizeof(requestBatchHdr));
+        }
+        else
+        {
+            is.pos(sizeof(requestHdr));
+        }
+
+        int dispatchCount = batchRequestCount == 0 ? 1 : batchRequestCount;
 
-    if(!synchronous || !_response || _reference->getInvocationTimeout() > 0)
-    {
-        // Don't invoke from the user thread if async or invocation timeout is set
-        _adapter->getThreadPool()->dispatch(new InvokeAllAsync(ICE_GET_SHARED_FROM_THIS(outAsync),
-                                                               outAsync->getOs(),
-                                                               ICE_SHARED_FROM_THIS,
-                                                               requestId,
-                                                               batchRequestNum));
-    }
-    else if(_dispatcher)
-    {
-        _adapter->getThreadPool()->dispatchFromThisThread(new InvokeAllAsync(ICE_GET_SHARED_FROM_THIS(outAsync),
-                                                                             outAsync->getOs(),
-                                                                             ICE_SHARED_FROM_THIS,
-                                                                             requestId,
-                                                                             batchRequestNum));
-    }
-    else // Optimization: directly call invokeAll if there's no dispatcher.
-    {
         //
         // Make sure to hold a reference on this handler while the call is being
         // dispatched. Otherwise, the handler could be deleted during the dispatch
         // if a retry occurs.
         //
+        auto self = shared_from_this();
 
-        CollocatedRequestHandlerPtr self(ICE_SHARED_FROM_THIS);
-        if(sentAsync(outAsync))
+        if (!synchronous || !_response || _reference->getInvocationTimeout() > 0ms)
         {
-            invokeAll(outAsync->getOs(), requestId, batchRequestNum);
-        }
-    }
-    return AsyncStatusQueued;
-}
+            auto stream = make_shared<InputStream>(_reference->getInstance().get(), currentProtocolEncoding);
+            is.swap(*stream);
 
-void
-CollocatedRequestHandler::sendResponse(Int requestId, OutputStream* os, Byte, bool amd)
-{
-    OutgoingAsyncBasePtr outAsync;
-    {
-        Lock sync(*this);
-        assert(_response);
-
-        if(_traceLevels->protocol >= 1)
-        {
-            fillInValue(os, 10, static_cast<Int>(os->b.size()));
+            // Don't invoke from the user thread if async or invocation timeout is set
+            _adapter->getThreadPool()->execute(
+                [self, outAsync = outAsync->shared_from_this(), stream, requestId, dispatchCount]()
+                {
+                    if (self->sentAsync(outAsync.get()))
+                    {
+                        self->dispatchAll(*stream, requestId, dispatchCount);
+                    }
+                },
+                nullptr);
         }
-
-        InputStream is(os->instance(), os->getEncoding(), *os, true); // Adopting the OutputStream's buffer.
-        is.pos(sizeof(replyHdr) + 4);
-
-        if(_traceLevels->protocol >= 1)
+        else if (_hasExecutor)
         {
-            traceRecv(is, _logger, _traceLevels);
-        }
+            auto stream = make_shared<InputStream>(_reference->getInstance().get(), currentProtocolEncoding);
+            is.swap(*stream);
 
-        map<int, OutgoingAsyncBasePtr>::iterator q = _asyncRequests.find(requestId);
-        if(q != _asyncRequests.end())
+            _adapter->getThreadPool()->executeFromThisThread(
+                [self, outAsync = outAsync->shared_from_this(), stream, requestId, dispatchCount]()
+                {
+                    if (self->sentAsync(outAsync.get()))
+                    {
+                        self->dispatchAll(*stream, requestId, dispatchCount);
+                    }
+                },
+                nullptr);
+        }
+        else // Optimization: directly call dispatchAll if there's no custom executor.
         {
-            is.swap(*q->second->getIs());
-            if(q->second->response())
+            if (sentAsync(outAsync))
             {
-                outAsync = q->second;
+                dispatchAll(is, requestId, dispatchCount);
             }
-            _asyncRequests.erase(q);
         }
     }
-
-    if(outAsync)
+    catch (...)
     {
-        //
-        // If called from an AMD dispatch, invoke asynchronously
-        // the completion callback since this might be called from
-        // the user code.
-        //
-        if(amd)
-        {
-            outAsync->invokeResponseAsync();
-        }
-        else
-        {
-            outAsync->invokeResponse();
-        }
+        // Decrement the direct count if any exception is thrown synchronously.
+        _adapter->decDirectCount();
+        throw;
     }
-
-    _adapter->decDirectCount();
-}
-
-void
-CollocatedRequestHandler::sendNoResponse()
-{
-    _adapter->decDirectCount();
-}
-
-bool
-CollocatedRequestHandler::systemException(Int requestId, const SystemException& ex, bool amd)
-{
-    handleException(requestId, ex, amd);
-    _adapter->decDirectCount();
-    return true;
+    return AsyncStatusQueued;
 }
 
 void
-CollocatedRequestHandler::invokeException(Int requestId, const LocalException& ex, int /*invokeNum*/, bool amd)
+CollocatedRequestHandler::dispatchException(int32_t requestId, exception_ptr ex)
 {
-    handleException(requestId, ex, amd);
+    handleException(requestId, ex);
     _adapter->decDirectCount();
 }
 
 ConnectionIPtr
 CollocatedRequestHandler::getConnection()
 {
-    return 0;
-}
-
-ConnectionIPtr
-CollocatedRequestHandler::waitForConnection()
-{
-    return 0;
+    return nullptr;
 }
 
 bool
 CollocatedRequestHandler::sentAsync(OutgoingAsyncBase* outAsync)
 {
     {
-        Lock sync(*this);
-        if(_sendAsyncRequests.erase(ICE_GET_SHARED_FROM_THIS(outAsync)) == 0)
+        lock_guard<mutex> lock(_mutex);
+        if (_sendAsyncRequests.erase(outAsync->shared_from_this()) == 0)
         {
             return false; // The request timed-out.
         }
 
-        if(!outAsync->sent())
+        if (!outAsync->sent())
         {
             return true;
         }
@@ -303,84 +234,67 @@ CollocatedRequestHandler::sentAsync(OutgoingAsyncBase* outAsync)
 }
 
 void
-CollocatedRequestHandler::invokeAll(OutputStream* os, Int requestId, Int batchRequestNum)
+CollocatedRequestHandler::dispatchAll(InputStream& is, int32_t requestId, int32_t requestCount)
 {
-    if(_traceLevels->protocol >= 1)
-    {
-        fillInValue(os, 10, static_cast<Int>(os->b.size()));
-        if(requestId > 0)
-        {
-            fillInValue(os, headerSize, requestId);
-        }
-        else if(batchRequestNum > 0)
-        {
-            fillInValue(os, headerSize, batchRequestNum);
-        }
-        traceSend(*os, _logger, _traceLevels);
-    }
-
-    InputStream is(os->instance(), os->getEncoding(), *os);
-
-    if(batchRequestNum > 0)
-    {
-        is.pos(sizeof(requestBatchHdr));
-    }
-    else
-    {
-        is.pos(sizeof(requestHdr));
-    }
-
-    int invokeNum = batchRequestNum > 0 ? batchRequestNum : 1;
-    ServantManagerPtr servantManager = _adapter->getServantManager();
     try
     {
-        while(invokeNum > 0)
+        while (requestCount > 0)
         {
-            //
             // Increase the direct count for the dispatch. We increase it again here for
             // each dispatch. It's important for the direct count to be > 0 until the last
             // collocated request response is sent to make sure the thread pool isn't
-            // destroyed before.
-            //
+            // destroyed before. It's decremented when processing the response.
             try
             {
                 _adapter->incDirectCount();
             }
-            catch(const ObjectAdapterDeactivatedException& ex)
+            catch (const ObjectAdapterDestroyedException&)
             {
-                handleException(requestId, ex, false);
+                handleException(requestId, current_exception());
                 break;
             }
 
-            Incoming in(_reference->getInstance().get(), this, 0, _adapter, _response, 0, requestId);
-            in.invoke(servantManager, &is);
-            --invokeNum;
+            IncomingRequest request{requestId, nullptr, _adapter, is, requestCount};
+
+            try
+            {
+                _adapter->dispatchPipeline()->dispatch(
+                    request,
+                    [self = shared_from_this()](OutgoingResponse response)
+                    { self->sendResponse(std::move(response)); });
+            }
+            catch (...)
+            {
+                sendResponse(makeOutgoingResponse(current_exception(), request.current()));
+            }
+
+            --requestCount;
         }
     }
-    catch(const LocalException& ex)
+    catch (...)
     {
-        invokeException(requestId, ex, invokeNum, false); // Fatal invocation exception
+        dispatchException(requestId, current_exception()); // Fatal invocation exception
     }
 
     _adapter->decDirectCount();
 }
 
 void
-CollocatedRequestHandler::handleException(int requestId, const Exception& ex, bool amd)
+CollocatedRequestHandler::handleException(int32_t requestId, std::exception_ptr ex)
 {
-    if(requestId == 0)
+    if (requestId == 0)
     {
         return; // Ignore exception for oneway messages.
     }
 
     OutgoingAsyncBasePtr outAsync;
     {
-        Lock sync(*this);
+        lock_guard<mutex> lock(_mutex);
 
-        map<int, OutgoingAsyncBasePtr>::iterator q = _asyncRequests.find(requestId);
-        if(q != _asyncRequests.end())
+        auto q = _asyncRequests.find(requestId);
+        if (q != _asyncRequests.end())
         {
-            if(q->second->exception(ex))
+            if (q->second->exception(ex))
             {
                 outAsync = q->second;
             }
@@ -388,20 +302,72 @@ CollocatedRequestHandler::handleException(int requestId, const Exception& ex, bo
         }
     }
 
-    if(outAsync)
+    if (outAsync)
     {
-        //
-        // If called from an AMD dispatch, invoke asynchronously
-        // the completion callback since this might be called from
-        // the user code.
-        //
-        if(amd)
-        {
-            outAsync->invokeExceptionAsync();
-        }
-        else
+        // We invoke the exception using a thread-pool thread. If the invocation is a lambda async invocation, we want
+        // the callbacks to execute in a thread-pool thread - never in the application thread that sent the exception
+        // via AMD.
+        outAsync->invokeExceptionAsync();
+    }
+}
+
+void
+CollocatedRequestHandler::sendResponse(OutgoingResponse response)
+{
+    try
+    {
+        if (_response)
         {
-            outAsync->invokeException();
+            OutgoingAsyncBasePtr outAsync;
+            {
+                lock_guard<mutex> lock(_mutex);
+                assert(_response);
+
+                auto os = &response.outputStream();
+
+                if (_traceLevels->protocol >= 1)
+                {
+                    fillInValue(os, 10, static_cast<int32_t>(os->b.size()));
+                }
+
+                InputStream is(
+                    _reference->getInstance().get(),
+                    os->getEncoding(),
+                    *os,
+                    true); // Adopting the OutputStream's buffer.
+                is.pos(sizeof(replyHdr) + 4);
+
+                if (_traceLevels->protocol >= 1)
+                {
+                    traceRecv(is, nullptr, _logger, _traceLevels);
+                }
+
+                auto q = _asyncRequests.find(response.current().requestId);
+                if (q != _asyncRequests.end())
+                {
+                    is.swap(*q->second->getIs());
+                    if (q->second->response())
+                    {
+                        outAsync = q->second;
+                    }
+                    _asyncRequests.erase(q);
+                }
+            }
+
+            if (outAsync)
+            {
+                // We invoke the response using a thread-pool thread. If the invocation is a lambda async invocation, we
+                // want the callbacks to execute in a thread-pool thread - never in the application thread that sent the
+                // response via AMD.
+                outAsync->invokeResponseAsync();
+            }
         }
+
+        _adapter->decDirectCount();
+    }
+    catch (...)
+    {
+        // Fatal invocation exception
+        dispatchException(response.current().requestId, current_exception());
     }
 }