zeroc-ice 3.7.9.1 → 3.8.0

data/dist/ice/cpp/src/Ice/ReferenceFactory.h

@@ -0,0 +1,58 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_REFERENCE_FACTORY_H
+#define ICE_REFERENCE_FACTORY_H
+
+#include "Ice/BuiltinSequences.h"
+#include "Ice/ConnectionIF.h"
+#include "Reference.h" // For Reference::Mode
+#include "ReferenceFactoryF.h"
+
+namespace IceInternal
+{
+    class ReferenceFactory : public std::enable_shared_from_this<ReferenceFactory>
+    {
+    public:
+        ReferenceFactory(InstancePtr, Ice::CommunicatorPtr);
+
+        // Create a direct reference.
+        ReferencePtr
+        create(Ice::Identity ident, std::string facet, const ReferencePtr& tmpl, std::vector<EndpointIPtr> endpoints);
+
+        // Create an indirect reference.
+        ReferencePtr create(Ice::Identity ident, std::string facet, const ReferencePtr& tmpl, std::string adapterId);
+
+        // Create a fixed reference.
+        ReferencePtr create(Ice::Identity ident, Ice::ConnectionIPtr connection);
+
+        // Create a reference from a string.
+        ReferencePtr create(std::string_view proxyString, const std::string& prefix);
+
+        // Create a reference by unmarshaling it from a stream.
+        ReferencePtr create(Ice::Identity ident, Ice::InputStream*);
+
+        ReferenceFactoryPtr setDefaultRouter(std::optional<Ice::RouterPrx>);
+        [[nodiscard]] std::optional<Ice::RouterPrx> getDefaultRouter() const;
+
+        ReferenceFactoryPtr setDefaultLocator(std::optional<Ice::LocatorPrx>);
+        [[nodiscard]] std::optional<Ice::LocatorPrx> getDefaultLocator() const;
+
+    private:
+        RoutableReferencePtr create(
+            Ice::Identity ident,
+            std::string facet,
+            Reference::Mode mode,
+            Ice::ProtocolVersion protocol,
+            Ice::EncodingVersion encoding,
+            std::vector<EndpointIPtr> endpoints,
+            std::string adapterId,
+            const std::string& propertyPrefix);
+
+        const InstancePtr _instance;
+        const Ice::CommunicatorPtr _communicator;
+        std::optional<Ice::RouterPrx> _defaultRouter;
+        std::optional<Ice::LocatorPrx> _defaultLocator;
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/ReferenceFactoryF.h

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_REFERENCE_FACTORY_F_H
+#define ICE_REFERENCE_FACTORY_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class ReferenceFactory;
+    using ReferenceFactoryPtr = std::shared_ptr<ReferenceFactory>;
+}
+
+#endif

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

@@ -0,0 +1,28 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "RequestHandler.h"
+#include "Reference.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+RetryException::RetryException(exception_ptr ex) { _ex = ex; }
+
+RetryException::RetryException(const RetryException& ex) { _ex = ex.get(); }
+
+exception_ptr
+RetryException::get() const
+{
+    return _ex;
+}
+
+CancellationHandler::~CancellationHandler() = default; // avoid weak vtable
+
+RequestHandler::RequestHandler(const ReferencePtr& reference)
+    : _reference(reference),
+      _response(reference->getMode() == Reference::ModeTwoway)
+{
+}
+
+RequestHandler::~RequestHandler() = default; // avoid weak vtable

data/dist/ice/cpp/src/Ice/RequestHandler.h

@@ -0,0 +1,53 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_REQUEST_HANDLER_H
+#define ICE_REQUEST_HANDLER_H
+
+#include "Ice/ConnectionIF.h"
+#include "Ice/OutgoingAsync.h"
+#include "Ice/ReferenceF.h"
+#include "Ice/RequestHandlerF.h"
+
+namespace IceInternal
+{
+    //
+    // An exception wrapper, which is used to notify that the request
+    // handler should be cleared and the invocation retried.
+    //
+    class RetryException
+    {
+    public:
+        RetryException(std::exception_ptr);
+        RetryException(const RetryException&);
+
+        [[nodiscard]] std::exception_ptr get() const;
+
+    private:
+        std::exception_ptr _ex;
+    };
+
+    class CancellationHandler
+    {
+    public:
+        virtual ~CancellationHandler();
+
+        virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) = 0;
+    };
+
+    class RequestHandler : public CancellationHandler
+    {
+    public:
+        RequestHandler(const ReferencePtr&);
+        ~RequestHandler() override;
+
+        virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
+
+        virtual Ice::ConnectionIPtr getConnection() = 0;
+
+    protected:
+        const ReferencePtr _reference;
+        const bool _response;
+    };
+}
+
+#endif

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

@@ -0,0 +1,76 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "RequestHandlerCache.h"
+#include "ConnectionI.h"
+#include "Reference.h"
+#include "RequestHandler.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+RequestHandlerCache::RequestHandlerCache(const ReferencePtr& reference)
+    : _reference(reference),
+      _cacheConnection(reference->getCacheConnection())
+{
+}
+
+IceInternal::RequestHandlerPtr
+RequestHandlerCache::getRequestHandler()
+{
+    if (_cacheConnection)
+    {
+        lock_guard<mutex> lock(_mutex);
+        if (_cachedRequestHandler)
+        {
+            return _cachedRequestHandler;
+        }
+    }
+
+    auto handler = _reference->getRequestHandler();
+    if (_cacheConnection)
+    {
+        lock_guard<mutex> lock(_mutex);
+        if (!_cachedRequestHandler)
+        {
+            _cachedRequestHandler = handler;
+        }
+        // else discard handler
+        return _cachedRequestHandler;
+    }
+    else
+    {
+        return handler;
+    }
+}
+
+ConnectionPtr
+RequestHandlerCache::getCachedConnection()
+{
+    if (_cacheConnection)
+    {
+        RequestHandlerPtr handler;
+        {
+            lock_guard<mutex> lock(_mutex);
+            handler = _cachedRequestHandler;
+        }
+        if (handler)
+        {
+            return handler->getConnection();
+        }
+    }
+    return nullptr;
+}
+
+void
+RequestHandlerCache::clearCachedRequestHandler(const RequestHandlerPtr& handler)
+{
+    if (_cacheConnection)
+    {
+        lock_guard<mutex> lock(_mutex);
+        if (handler == _cachedRequestHandler)
+        {
+            _cachedRequestHandler = nullptr;
+        }
+    }
+}

data/dist/ice/cpp/src/Ice/RequestHandlerCache.h

@@ -0,0 +1,33 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_REQUEST_HANDLER_CACHE_H
+#define ICE_REQUEST_HANDLER_CACHE_H
+
+#include "Ice/ConnectionF.h"
+#include "RequestHandler.h"
+#include <mutex>
+
+namespace IceInternal
+{
+    // Represents a holder/cache for a request handler. It's tied to a single Reference, and can be shared by multiple
+    // proxies (all with the same Reference).
+    class RequestHandlerCache final
+    {
+    public:
+        RequestHandlerCache(const ReferencePtr&);
+
+        RequestHandlerPtr getRequestHandler();
+
+        Ice::ConnectionPtr getCachedConnection();
+
+        void clearCachedRequestHandler(const RequestHandlerPtr& handler);
+
+    private:
+        const ReferencePtr _reference;
+        const bool _cacheConnection;
+        std::mutex _mutex;                       // protects _cachedRequestHandler
+        RequestHandlerPtr _cachedRequestHandler; // set only when _cacheConnection is true.
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/ResourceConfig.h

@@ -0,0 +1,27 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_RESOURCE_CONFIG_H
+#define ICE_RESOURCE_CONFIG_H
+
+#include "winver.h"
+
+#define ICE_VERSION 3, 8, 0, 0
+#define ICE_STRING_VERSION "3.8.0\0"
+#define ICE_SO_VERSION "38\0"
+#define ICE_COMPANY_NAME "ZeroC, Inc.\0"
+#define ICE_COPYRIGHT "\251 ZeroC, Inc.\0"
+#define ICE_PRODUCT_NAME "Ice\0"
+
+#if defined(_DEBUG)
+#    define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION "D"
+#else
+#    define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION ""
+#endif
+
+#ifndef DEBUG
+#    define VER_DEBUG 0
+#else
+#    define VER_DEBUG VS_FF_DEBUG
+#endif
+
+#endif

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

@@ -0,0 +1,151 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "RetryQueue.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/OutgoingAsync.h"
+#include "Instance.h"
+#include "TraceLevels.h"
+
+#include <stdexcept>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceInternal::RetryTask::RetryTask(InstancePtr instance, RetryQueuePtr queue, ProxyOutgoingAsyncBasePtr outAsync)
+    : _instance(std::move(instance)),
+      _queue(std::move(queue)),
+      _outAsync(std::move(outAsync))
+{
+}
+
+void
+IceInternal::RetryTask::runTimerTask()
+{
+    _outAsync->retry(); // Retry again the invocation.
+
+    //
+    // NOTE: this must be called last, destroy() blocks until all task
+    // are removed to prevent the client thread pool to be destroyed
+    // (we still need the client thread pool at this point to call
+    // exception callbacks with CommunicatorDestroyedException).
+    //
+    _queue->remove(shared_from_this());
+}
+
+void
+IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& /*outAsync*/, exception_ptr ex)
+{
+    if (_queue->cancel(shared_from_this()))
+    {
+        if (_instance->traceLevels()->retry >= 1)
+        {
+            try
+            {
+                rethrow_exception(ex);
+            }
+            catch (const std::exception& e)
+            {
+                Trace out(_instance->initializationData().logger, _instance->traceLevels()->retryCat);
+                out << "operation retry canceled\n" << e;
+            }
+        }
+        if (_outAsync->exception(ex))
+        {
+            _outAsync->invokeExceptionAsync();
+        }
+    }
+}
+
+void
+IceInternal::RetryTask::destroy()
+{
+    try
+    {
+        _outAsync->abort(make_exception_ptr(CommunicatorDestroyedException(__FILE__, __LINE__)));
+    }
+    catch (const CommunicatorDestroyedException&)
+    {
+        // Abort can throw if there's no callback, ignore.
+    }
+}
+
+IceInternal::RetryQueue::RetryQueue(InstancePtr instance) : _instance(std::move(instance)) {}
+
+void
+IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
+{
+    lock_guard<mutex> lock(_mutex);
+    if (!_instance)
+    {
+        throw CommunicatorDestroyedException(__FILE__, __LINE__);
+    }
+    RetryTaskPtr task = make_shared<RetryTask>(_instance, shared_from_this(), out);
+    out->cancelable(task); // This will throw if the request is canceled.
+    try
+    {
+        _instance->timer()->schedule(task, chrono::milliseconds(interval));
+    }
+    catch (const invalid_argument&) // Expected if the communicator destroyed the timer.
+    {
+        throw CommunicatorDestroyedException(__FILE__, __LINE__);
+    }
+    _requests.insert(task);
+}
+
+void
+IceInternal::RetryQueue::destroy()
+{
+    unique_lock<mutex> lock(_mutex);
+    assert(_instance);
+
+    auto p = _requests.begin();
+    while (p != _requests.end())
+    {
+        if (_instance->timer()->cancel(*p))
+        {
+            (*p)->destroy();
+            _requests.erase(p++);
+        }
+        else
+        {
+            ++p;
+        }
+    }
+
+    _instance = nullptr;
+    _conditionVariable.wait(lock, [this] { return _requests.empty(); });
+}
+
+void
+IceInternal::RetryQueue::remove(const RetryTaskPtr& task)
+{
+    lock_guard<mutex> lock(_mutex);
+    assert(_requests.find(task) != _requests.end());
+    _requests.erase(task);
+    if (!_instance && _requests.empty())
+    {
+        // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+        _conditionVariable.notify_one();
+    }
+}
+
+bool
+IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
+{
+    lock_guard<mutex> lock(_mutex);
+    if (_requests.erase(task) > 0)
+    {
+        if (_instance)
+        {
+            return _instance->timer()->cancel(task);
+        }
+        else if (_requests.empty())
+        {
+            // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+            _conditionVariable.notify_one();
+        }
+    }
+    return false;
+}

data/dist/ice/cpp/src/Ice/RetryQueue.h

@@ -0,0 +1,59 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_RETRY_QUEUE_H
+#define ICE_RETRY_QUEUE_H
+
+#include "Ice/InstanceF.h"
+#include "RequestHandler.h" // For CancellationHandler
+#include "RetryQueueF.h"
+#include "Timer.h"
+
+#include <mutex>
+
+namespace IceInternal
+{
+    class OutgoingAsyncBase;
+    class ProxyOutgoingAsyncBase;
+
+    using OutgoingAsyncBasePtr = std::shared_ptr<OutgoingAsyncBase>;
+    using ProxyOutgoingAsyncBasePtr = std::shared_ptr<ProxyOutgoingAsyncBase>;
+
+    class RetryTask : public TimerTask, public CancellationHandler, public std::enable_shared_from_this<RetryTask>
+    {
+    public:
+        RetryTask(InstancePtr, RetryQueuePtr, ProxyOutgoingAsyncBasePtr);
+
+        void runTimerTask() override;
+
+        void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) override;
+
+        void destroy();
+
+    private:
+        const InstancePtr _instance;
+        const RetryQueuePtr _queue;
+        const ProxyOutgoingAsyncBasePtr _outAsync;
+    };
+    using RetryTaskPtr = std::shared_ptr<RetryTask>;
+
+    class RetryQueue : public std::enable_shared_from_this<RetryQueue>
+    {
+    public:
+        RetryQueue(InstancePtr);
+
+        void add(const ProxyOutgoingAsyncBasePtr&, int);
+        void destroy();
+
+    private:
+        void remove(const RetryTaskPtr&);
+        bool cancel(const RetryTaskPtr&);
+        friend class RetryTask;
+
+        InstancePtr _instance;
+        std::set<RetryTaskPtr> _requests;
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/RetryQueueF.h

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_RETRY_QUEUE_F_H
+#define ICE_RETRY_QUEUE_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class RetryQueue;
+    using RetryQueuePtr = std::shared_ptr<RetryQueue>;
+}
+
+#endif