zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,159 +1,163 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_OBJECT_ADAPTER_I_H
 #define ICE_OBJECT_ADAPTER_I_H
 
-#include <IceUtil/Shared.h>
-#include <IceUtil/RecMutex.h>
-#include <IceUtil/Monitor.h>
-#include <Ice/ObjectAdapter.h>
-#include <Ice/InstanceF.h>
-#include <Ice/ObjectAdapterFactoryF.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/ConnectionFactoryF.h>
-#include <Ice/ServantManagerF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/ObjectF.h>
-#include <Ice/RouterInfoF.h>
-#include <Ice/EndpointIF.h>
-#include <Ice/LocatorInfoF.h>
-#include <Ice/ThreadPoolF.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/Exception.h>
-#include <Ice/BuiltinSequences.h>
-#include <Ice/Proxy.h>
-#include <Ice/ACM.h>
+#include "ConnectionFactoryF.h"
+#include "ConnectionI.h"
+#include "EndpointIF.h"
+#include "Ice/BuiltinSequences.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/InstanceF.h"
+#include "Ice/ObjectAdapter.h"
+#include "Ice/ObjectF.h"
+#include "Ice/Proxy.h"
+#include "Ice/SSL/ServerAuthenticationOptions.h"
+#include "LocatorInfoF.h"
+#include "ObjectAdapterFactoryF.h"
+#include "RouterInfoF.h"
+#include "ServantManagerF.h"
+#include "ThreadPoolF.h"
+
 #include <list>
+#include <mutex>
+#include <optional>
+#include <stack>
 
-namespace Ice
+namespace IceInternal
 {
+    class CommunicatorFlushBatchAsync;
+    using CommunicatorFlushBatchAsyncPtr = std::shared_ptr<CommunicatorFlushBatchAsync>;
+}
 
-class ObjectAdapterI;
-ICE_DEFINE_PTR(ObjectAdapterIPtr, ObjectAdapterI);
-
-class ObjectAdapterI : public ObjectAdapter,
-                       public IceUtil::Monitor<IceUtil::RecMutex>
-#ifdef ICE_CPP11_MAPPING
-                     , public std::enable_shared_from_this<ObjectAdapterI>
-#endif
-
+namespace Ice
 {
-public:
-
-    virtual std::string getName() const ICE_NOEXCEPT;
-
-    virtual CommunicatorPtr getCommunicator() const ICE_NOEXCEPT;
-
-    virtual void activate();
-    virtual void hold();
-    virtual void waitForHold();
-    virtual void deactivate() ICE_NOEXCEPT;
-    virtual void waitForDeactivate() ICE_NOEXCEPT;
-    virtual bool isDeactivated() const ICE_NOEXCEPT;
-    virtual void destroy() ICE_NOEXCEPT;
-
-    virtual ObjectPrxPtr add(const ObjectPtr&, const Identity&);
-    virtual ObjectPrxPtr addFacet(const ObjectPtr&, const Identity&, const std::string&);
-    virtual ObjectPrxPtr addWithUUID(const ObjectPtr&);
-    virtual ObjectPrxPtr addFacetWithUUID(const ObjectPtr&, const std::string&);
-    virtual void addDefaultServant(const ObjectPtr&, const std::string&);
-    virtual ObjectPtr remove(const Identity&);
-    virtual ObjectPtr removeFacet(const Identity&, const std::string&);
-    virtual FacetMap removeAllFacets(const Identity&);
-    virtual ObjectPtr removeDefaultServant(const std::string&);
-    virtual ObjectPtr find(const Identity&) const;
-    virtual ObjectPtr findFacet(const Identity&, const std::string&) const;
-    virtual FacetMap findAllFacets(const Identity&) const;
-    virtual ObjectPtr findByProxy(const ObjectPrxPtr&) const;
-    virtual ObjectPtr findDefaultServant(const std::string&) const;
-
-    virtual void addServantLocator(const ServantLocatorPtr&, const std::string&);
-    virtual ServantLocatorPtr removeServantLocator(const std::string&);
-    virtual ServantLocatorPtr findServantLocator(const std::string&) const;
-
-    virtual ObjectPrxPtr createProxy(const Identity&) const;
-    virtual ObjectPrxPtr createDirectProxy(const Identity&) const;
-    virtual ObjectPrxPtr createIndirectProxy(const Identity&) const;
-
-    virtual void setLocator(const LocatorPrxPtr&);
-    virtual Ice::LocatorPrxPtr getLocator() const ICE_NOEXCEPT;
-    virtual EndpointSeq getEndpoints() const ICE_NOEXCEPT;
-
-    virtual void refreshPublishedEndpoints();
-    virtual EndpointSeq getPublishedEndpoints() const ICE_NOEXCEPT;
-    virtual void setPublishedEndpoints(const EndpointSeq&);
-
-#ifdef ICE_SWIFT
-    virtual dispatch_queue_t getDispatchQueue() const;
-#endif
-
-    bool isLocal(const ObjectPrxPtr&) const;
-
-    void flushAsyncBatchRequests(const IceInternal::CommunicatorFlushBatchAsyncPtr&, CompressBatch);
-
-    void updateConnectionObservers();
-    void updateThreadObservers();
-
-    void incDirectCount();
-    void decDirectCount();
-
-    IceInternal::ThreadPoolPtr getThreadPool() const;
-    IceInternal::ServantManagerPtr getServantManager() const;
-    IceInternal::ACMConfig getACM() const;
-    void setAdapterOnConnection(const Ice::ConnectionIPtr&);
-    size_t messageSizeMax() const { return _messageSizeMax; }
-
-    ObjectAdapterI(const IceInternal::InstancePtr&, const CommunicatorPtr&,
-                   const IceInternal::ObjectAdapterFactoryPtr&, const std::string&, bool);
-    virtual ~ObjectAdapterI();
-
-private:
-
-    void initialize(const RouterPrxPtr&);
-    friend class IceInternal::ObjectAdapterFactory;
-
-    ObjectPrxPtr newProxy(const Identity&, const std::string&) const;
-    ObjectPrxPtr newDirectProxy(const Identity&, const std::string&) const;
-    ObjectPrxPtr newIndirectProxy(const Identity&, const std::string&, const std::string&) const;
-    void checkForDeactivation() const;
-    std::vector<IceInternal::EndpointIPtr> parseEndpoints(const std::string&, bool) const;
-    std::vector<IceInternal::EndpointIPtr> computePublishedEndpoints();
-    void updateLocatorRegistry(const IceInternal::LocatorInfoPtr&, const Ice::ObjectPrxPtr&);
-    bool filterProperties(Ice::StringSeq&);
-
-    enum State
+    class ObjectAdapterI final : public ObjectAdapter, public std::enable_shared_from_this<ObjectAdapterI>
     {
-        StateUninitialized,
-        StateHeld,
-        StateActivating,
-        StateActive,
-        StateDeactivating,
-        StateDeactivated,
-        StateDestroying,
-        StateDestroyed
+    public:
+        [[nodiscard]] const std::string& getName() const noexcept final;
+
+        [[nodiscard]] CommunicatorPtr getCommunicator() const noexcept final;
+
+        void activate() final;
+        void hold() final;
+        void waitForHold() final;
+        void deactivate() noexcept override;
+        void waitForDeactivate() noexcept final;
+        [[nodiscard]] bool isDeactivated() const noexcept final;
+        void destroy() noexcept final;
+
+        ObjectAdapterPtr use(std::function<ObjectPtr(ObjectPtr)> middlewareFactory) final;
+
+        ObjectPrx _add(ObjectPtr, Identity) final;
+        ObjectPrx _addFacet(ObjectPtr, Identity, std::string) final;
+        ObjectPrx _addWithUUID(ObjectPtr) final;
+        ObjectPrx _addFacetWithUUID(ObjectPtr, std::string) final;
+        void addDefaultServant(ObjectPtr, std::string) final;
+        ObjectPtr remove(const Identity&) final;
+        ObjectPtr removeFacet(const Identity&, std::string_view) final;
+        FacetMap removeAllFacets(const Identity&) final;
+        ObjectPtr removeDefaultServant(std::string_view) final;
+        [[nodiscard]] ObjectPtr find(const Identity&) const final;
+        [[nodiscard]] ObjectPtr findFacet(const Identity&, std::string_view) const final;
+        [[nodiscard]] FacetMap findAllFacets(const Identity&) const final;
+        [[nodiscard]] ObjectPtr findByProxy(const ObjectPrx&) const final;
+        [[nodiscard]] ObjectPtr findDefaultServant(std::string_view) const final;
+        void addServantLocator(ServantLocatorPtr, std::string) final;
+        ServantLocatorPtr removeServantLocator(std::string_view) final;
+        [[nodiscard]] ServantLocatorPtr findServantLocator(std::string_view) const final;
+
+        [[nodiscard]] const ObjectPtr& dispatchPipeline() const noexcept final;
+
+        [[nodiscard]] ObjectPrx _createProxy(Identity) const final;
+        [[nodiscard]] ObjectPrx _createDirectProxy(Identity) const final;
+        [[nodiscard]] ObjectPrx _createIndirectProxy(Identity) const final;
+
+        void setLocator(std::optional<LocatorPrx>) final;
+        [[nodiscard]] std::optional<LocatorPrx> getLocator() const noexcept override;
+        [[nodiscard]] EndpointSeq getEndpoints() const override;
+
+        [[nodiscard]] EndpointSeq getPublishedEndpoints() const override;
+        void setPublishedEndpoints(EndpointSeq) final;
+
+        [[nodiscard]] bool isLocal(const IceInternal::ReferencePtr&) const;
+
+        void flushAsyncBatchRequests(const IceInternal::CommunicatorFlushBatchAsyncPtr&, CompressBatch);
+
+        void updateConnectionObservers();
+        void updateThreadObservers();
+
+        void incDirectCount();
+        void decDirectCount();
+
+        [[nodiscard]] IceInternal::ThreadPoolPtr getThreadPool() const;
+        void setAdapterOnConnection(const ConnectionIPtr&);
+        [[nodiscard]] std::int32_t messageSizeMax() const { return _messageSizeMax; }
+
+        ObjectAdapterI(
+            IceInternal::InstancePtr,
+            CommunicatorPtr,
+            IceInternal::ObjectAdapterFactoryPtr,
+            std::string name,
+            bool,
+            std::optional<SSL::ServerAuthenticationOptions>);
+        ~ObjectAdapterI() override;
+
+        [[nodiscard]] const std::optional<SSL::ServerAuthenticationOptions>&
+        serverAuthenticationOptions() const noexcept
+        {
+            return _serverAuthenticationOptions;
+        }
+
+    private:
+        void initialize(std::optional<RouterPrx>);
+        friend class IceInternal::ObjectAdapterFactory;
+
+        [[nodiscard]] ObjectPrx newProxy(Identity, std::string) const;
+        [[nodiscard]] ObjectPrx newDirectProxy(Identity, std::string) const;
+        [[nodiscard]] ObjectPrx newIndirectProxy(Identity, std::string, std::string) const;
+        void checkForDeactivation() const;
+        void checkForDestruction() const;
+        [[nodiscard]] std::vector<IceInternal::EndpointIPtr> parseEndpoints(std::string_view, bool) const;
+        std::vector<IceInternal::EndpointIPtr> computePublishedEndpoints();
+        void updateLocatorRegistry(const IceInternal::LocatorInfoPtr&, const std::optional<ObjectPrx>&);
+
+        enum State
+        {
+            StateUninitialized,
+            StateHeld,
+            StateActivating,
+            StateActive,
+            StateDeactivating,
+            StateDeactivated,
+            StateDestroying,
+            StateDestroyed
+        };
+        State _state{StateUninitialized};
+        IceInternal::InstancePtr _instance;
+        CommunicatorPtr _communicator;
+        IceInternal::ObjectAdapterFactoryPtr _objectAdapterFactory;
+        IceInternal::ThreadPoolPtr _threadPool;
+        const IceInternal::ServantManagerPtr _servantManager;
+
+        mutable ObjectPtr _dispatchPipeline;
+        mutable std::stack<std::function<ObjectPtr(ObjectPtr)>> _middlewareFactoryStack;
+
+        const std::string _name;
+        const std::string _id;
+        const std::string _replicaGroupId;
+        IceInternal::ReferencePtr _reference;
+        std::vector<IceInternal::IncomingConnectionFactoryPtr> _incomingConnectionFactories;
+        IceInternal::RouterInfoPtr _routerInfo;
+        std::vector<IceInternal::EndpointIPtr> _publishedEndpoints;
+        IceInternal::LocatorInfoPtr _locatorInfo;
+        int _directCount{0}; // The number of direct proxies dispatching on this object adapter.
+        bool _noConfig;
+        std::int32_t _messageSizeMax{0};
+        mutable std::recursive_mutex _mutex;
+        std::condition_variable_any _conditionVariable;
+        const std::optional<SSL::ServerAuthenticationOptions> _serverAuthenticationOptions;
     };
-    State _state;
-    IceInternal::InstancePtr _instance;
-    CommunicatorPtr _communicator;
-    IceInternal::ObjectAdapterFactoryPtr _objectAdapterFactory;
-    IceInternal::ThreadPoolPtr _threadPool;
-    IceInternal::ACMConfig _acm;
-    IceInternal::ServantManagerPtr _servantManager;
-    const std::string _name;
-    const std::string _id;
-    const std::string _replicaGroupId;
-    IceInternal::ReferencePtr _reference;
-    std::vector<IceInternal::IncomingConnectionFactoryPtr> _incomingConnectionFactories;
-    IceInternal::RouterInfoPtr _routerInfo;
-    std::vector<IceInternal::EndpointIPtr> _publishedEndpoints;
-    IceInternal::LocatorInfoPtr _locatorInfo;
-    int _directCount; // The number of direct proxies dispatching on this object adapter.
-    bool _noConfig;
-    size_t _messageSizeMax;
-};
-
 }
 
 #endif

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

@@ -1,42 +1,40 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/ObserverHelper.h>
-#include <Ice/Reference.h>
-#include <Ice/Instance.h>
-#include <Ice/Proxy.h>
+#include "Ice/ObserverHelper.h"
+#include "Ice/Proxy.h"
+#include "Instance.h"
+#include "Reference.h"
 
 using namespace std;
 using namespace Ice;
 using namespace Ice::Instrumentation;
 
-IceInternal::InvocationObserver::InvocationObserver(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx)
+IceInternal::InvocationObserver::InvocationObserver(const Ice::ObjectPrx& proxy, string_view op, const Context& ctx)
 {
     const CommunicatorObserverPtr& obsv = proxy->_getReference()->getInstance()->initializationData().observer;
-    if(!obsv)
+    if (!obsv)
     {
         return;
     }
     attach(obsv->getInvocationObserver(proxy, op, ctx));
 }
 
-IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* instance, const string& op)
+IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* instance, string_view op)
 {
     const CommunicatorObserverPtr& obsv = instance->initializationData().observer;
-    if(!obsv)
+    if (!obsv)
     {
         return;
     }
 
-    attach(obsv->getInvocationObserver(0, op, noExplicitContext));
+    attach(obsv->getInvocationObserver(nullopt, op, noExplicitContext));
 }
 
 void
-IceInternal::InvocationObserver::attach(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx)
+IceInternal::InvocationObserver::attach(const Ice::ObjectPrx& proxy, string_view op, const Context& ctx)
 {
     const CommunicatorObserverPtr& obsv = proxy->_getReference()->getInstance()->initializationData().observer;
-    if(!obsv)
+    if (!obsv)
     {
         return;
     }
@@ -44,13 +42,34 @@ IceInternal::InvocationObserver::attach(const Ice::ObjectPrxPtr& proxy, const st
 }
 
 void
-IceInternal::InvocationObserver::attach(IceInternal::Instance* instance, const string& op)
+IceInternal::InvocationObserver::attach(IceInternal::Instance* instance, string_view op)
 {
     const CommunicatorObserverPtr& obsv = instance->initializationData().observer;
-    if(!obsv)
+    if (!obsv)
     {
         return;
     }
 
-    attach(obsv->getInvocationObserver(0, op, Ice::noExplicitContext));
+    attach(obsv->getInvocationObserver(nullopt, op, Ice::noExplicitContext));
+}
+
+std::string
+IceInternal::getExceptionId(std::exception_ptr eptr)
+{
+    try
+    {
+        std::rethrow_exception(eptr);
+    }
+    catch (const Ice::Exception& ex)
+    {
+        return ex.ice_id();
+    }
+    catch (const std::exception& ex)
+    {
+        return ex.what();
+    }
+    catch (...)
+    {
+        return "unknown";
+    }
 }

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

@@ -0,0 +1,96 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "ObserverMiddleware.h"
+#include "Ice/UserException.h"
+
+using namespace std;
+using namespace Ice;
+using namespace Ice::Instrumentation;
+using namespace IceInternal;
+
+ObserverMiddleware::ObserverMiddleware(Ice::ObjectPtr next, CommunicatorObserverPtr communicatorObserver)
+    : _next(std::move(next)),
+      _communicatorObserver(std::move(communicatorObserver))
+{
+    assert(_next);
+    assert(_communicatorObserver);
+}
+
+void
+ObserverMiddleware::dispatch(Ice::IncomingRequest& request, function<void(OutgoingResponse)> sendResponse)
+{
+    DispatchObserverPtr observerPtr = _communicatorObserver->getDispatchObserver(request.current(), request.size());
+    if (observerPtr)
+    {
+        observerPtr->attach();
+        exception_ptr exception;
+
+        try
+        {
+            // We can't move sendResponse as we need it when we catch an exception; so we copy it.
+            _next->dispatch(
+                request,
+                [sendResponse, observerPtr](OutgoingResponse response)
+                {
+                    switch (response.replyStatus())
+                    {
+                        case ReplyStatus::Ok:
+                            // don't do anything
+                            break;
+                        case ReplyStatus::UserException:
+                            observerPtr->userException();
+                            break;
+                        default:
+                            observerPtr->failed(response.exceptionId());
+                            break;
+                    }
+
+                    if (response.current().requestId != 0)
+                    {
+                        observerPtr->reply(response.size());
+                    }
+
+                    observerPtr->detach();
+                    sendResponse(std::move(response));
+                });
+        }
+        catch (const UserException&)
+        {
+            observerPtr->userException();
+            exception = current_exception();
+        }
+        catch (const Ice::Exception& ex)
+        {
+            observerPtr->failed(ex.ice_id());
+            exception = current_exception();
+        }
+        catch (const std::exception& ex)
+        {
+            observerPtr->failed(ex.what());
+            exception = current_exception();
+        }
+        catch (...)
+        {
+            observerPtr->failed("unknown");
+            exception = current_exception();
+        }
+
+        if (exception)
+        {
+            OutgoingResponse response = makeOutgoingResponse(exception, request.current());
+            if (response.current().requestId != 0)
+            {
+                observerPtr->reply(response.size());
+            }
+            observerPtr->detach();
+
+            // If we get a synchronous exception, sendResponse was not called.
+            sendResponse(std::move(response));
+        }
+    }
+    else
+    {
+        // Not observing dispatches.
+        _next->dispatch(request, std::move(sendResponse));
+    }
+}

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

@@ -0,0 +1,25 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_OBSERVER_MIDDLEWARE_H
+#define ICE_OBSERVER_MIDDLEWARE_H
+
+#include "Ice/Instrumentation.h"
+#include "Ice/Object.h"
+
+namespace IceInternal
+{
+    // A middleware that observes dispatches.
+    class ObserverMiddleware final : public Ice::Object
+    {
+    public:
+        ObserverMiddleware(Ice::ObjectPtr next, Ice::Instrumentation::CommunicatorObserverPtr communicatorObserver);
+
+        void dispatch(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) final;
+
+    private:
+        Ice::ObjectPtr _next;
+        Ice::Instrumentation::CommunicatorObserverPtr _communicatorObserver;
+    };
+}
+
+#endif