zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,235 +1,225 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_INSTANCE_H
 #define ICE_INSTANCE_H
 
-#include <IceUtil/Config.h>
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/RecMutex.h>
-#include <IceUtil/Timer.h>
-#include <Ice/StringConverter.h>
-#include <Ice/InstanceF.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/InstrumentationF.h>
-#include <Ice/TraceLevelsF.h>
-#include <Ice/DefaultsAndOverridesF.h>
-#include <Ice/RouterInfoF.h>
-#include <Ice/LocatorInfoF.h>
-#include <Ice/ReferenceFactoryF.h>
-#include <Ice/ProxyFactoryF.h>
-#include <Ice/ThreadPoolF.h>
-#include <Ice/ConnectionFactoryF.h>
-#include <Ice/ACM.h>
-#include <Ice/ObjectFactory.h>
-#include <Ice/ObjectAdapterFactoryF.h>
-#include <Ice/EndpointFactoryManagerF.h>
-#include <Ice/IPEndpointIF.h>
-#include <Ice/RetryQueueF.h>
-#include <Ice/DynamicLibraryF.h>
-#include <Ice/PluginF.h>
-#include <Ice/NetworkF.h>
-#include <Ice/NetworkProxyF.h>
-#include <Ice/Initialize.h>
-#include <Ice/ImplicitContextI.h>
-#include <Ice/FacetMap.h>
-#include <Ice/Process.h>
-#include <list>
-
-namespace Ice
-{
-
-class CommunicatorI;
+#include "ConnectionFactoryF.h"
+#include "ConnectionOptions.h"
+#include "DefaultsAndOverridesF.h"
+#include "EndpointFactoryManagerF.h"
+#include "IPEndpointIF.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/Config.h"
+#include "Ice/FacetMap.h"
+#include "Ice/ImplicitContext.h"
+#include "Ice/Initialize.h"
+#include "Ice/InstanceF.h"
+#include "Ice/Instrumentation.h"
+#include "Ice/Plugin.h"
+#include "Ice/Process.h"
+#include "Ice/StringConverter.h"
+#include "LocatorInfoF.h"
+#include "NetworkF.h"
+#include "NetworkProxyF.h"
+#include "ObjectAdapterFactoryF.h"
+#include "Protocol.h"
+#include "ReferenceFactoryF.h"
+#include "RetryQueueF.h"
+#include "RouterInfoF.h"
+#include "SSL/SSLEngineF.h"
+#include "ThreadPoolF.h"
+#include "Timer.h"
+#include "TraceLevelsF.h"
 
-}
+#include <list>
+#include <thread>
+#include <vector>
 
 namespace IceInternal
 {
+    class ThreadObserverTimer;
+    using ThreadObserverTimerPtr = std::shared_ptr<ThreadObserverTimer>;
 
-class Timer;
-typedef IceUtil::Handle<Timer> TimerPtr;
-
-class MetricsAdminI;
-ICE_DEFINE_PTR(MetricsAdminIPtr, MetricsAdminI);
-
-class RequestHandlerFactory;
-typedef IceUtil::Handle<RequestHandlerFactory> RequestHandlerFactoryPtr;
+    class MetricsAdminI;
+    using MetricsAdminIPtr = std::shared_ptr<MetricsAdminI>;
 
-//
-// Structure to track warnings for attempts to set socket buffer sizes
-//
-struct BufSizeWarnInfo
-{
-    // Whether send size warning has been emitted
-    bool sndWarn;
-
-    // The send size for which the warning wwas emitted
-    int sndSize;
-
-    // Whether receive size warning has been emitted
-    bool rcvWarn;
-
-    // The receive size for which the warning wwas emitted
-    int rcvSize;
-};
-
-class Instance : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::RecMutex>
-{
-public:
-
-    bool destroyed() const;
-    const Ice::InitializationData& initializationData() const { return _initData; }
-    TraceLevelsPtr traceLevels() const;
-    DefaultsAndOverridesPtr defaultsAndOverrides() const;
-    RouterManagerPtr routerManager() const;
-    LocatorManagerPtr locatorManager() const;
-    ReferenceFactoryPtr referenceFactory() const;
-    RequestHandlerFactoryPtr requestHandlerFactory() const;
-    ProxyFactoryPtr proxyFactory() const;
-    OutgoingConnectionFactoryPtr outgoingConnectionFactory() const;
-    ObjectAdapterFactoryPtr objectAdapterFactory() const;
-    ProtocolSupport protocolSupport() const;
-    bool preferIPv6() const;
-    NetworkProxyPtr networkProxy() const;
-    ThreadPoolPtr clientThreadPool();
-    ThreadPoolPtr serverThreadPool();
-    EndpointHostResolverPtr endpointHostResolver();
-    RetryQueuePtr retryQueue();
-    IceUtil::TimerPtr timer();
-    EndpointFactoryManagerPtr endpointFactoryManager() const;
-    DynamicLibraryListPtr dynamicLibraryList() const;
-    Ice::PluginManagerPtr pluginManager() const;
-    size_t messageSizeMax() const { return _messageSizeMax; }
-    size_t batchAutoFlushSize() const { return _batchAutoFlushSize; }
-    size_t classGraphDepthMax() const { return _classGraphDepthMax; }
-    bool collectObjects() const { return _collectObjects; }
-    Ice::ToStringMode toStringMode() const { return _toStringMode; }
-    bool acceptClassCycles() const { return _acceptClassCycles; }
-    const ACMConfig& clientACM() const;
-    const ACMConfig& serverACM() const;
-
-    Ice::ObjectPrxPtr createAdmin(const Ice::ObjectAdapterPtr&, const Ice::Identity&);
-    Ice::ObjectPrxPtr getAdmin();
-    void addAdminFacet(const Ice::ObjectPtr&, const std::string&);
-    Ice::ObjectPtr removeAdminFacet(const std::string&);
-    Ice::ObjectPtr findAdminFacet(const std::string&);
-    Ice::FacetMap findAllAdminFacets();
-
-    const Ice::ImplicitContextIPtr& getImplicitContext() const
+    /// Structure to track warnings for attempts to set socket buffer sizes.
+    struct BufSizeWarnInfo
     {
-        return _implicitContext;
-    }
-
-    void setDefaultLocator(const Ice::LocatorPrxPtr&);
-    void setDefaultRouter(const Ice::RouterPrxPtr&);
+        /// Whether send size warning has been emitted.
+        bool sndWarn;
 
-    void setLogger(const Ice::LoggerPtr&);
-#ifdef ICE_CPP11_MAPPING
-    void setThreadHook(std::function<void()>, std::function<void()>);
-#else
-    void setThreadHook(const Ice::ThreadNotificationPtr&);
-#endif
-
-    const Ice::StringConverterPtr& getStringConverter() const { return _stringConverter; }
-    const Ice::WstringConverterPtr& getWstringConverter() const { return _wstringConverter; }
-
-    BufSizeWarnInfo getBufSizeWarn(Ice::Short type);
-    void setSndBufSizeWarn(Ice::Short type, int size);
-    void setRcvBufSizeWarn(Ice::Short type, int size);
-
-    void addObjectFactory(const Ice::ObjectFactoryPtr&, const std::string&);
-    Ice::ObjectFactoryPtr findObjectFactory(const std::string&) const;
-
-    typedef std::map<std::string, Ice::ObjectFactoryPtr> ObjectFactoryMap;
-
-private:
-
-    Instance(const Ice::CommunicatorPtr&, const Ice::InitializationData&);
-    virtual ~Instance();
-    void finishSetup(int&, const char*[], const Ice::CommunicatorPtr&);
-    void destroy();
-    friend class Ice::CommunicatorI;
-
-    void updateConnectionObservers();
-    void updateThreadObservers();
-    friend class ObserverUpdaterI;
+        /// The send size for which the warning was emitted.
+        int sndSize;
 
-    void addAllAdminFacets();
-    void setServerProcessProxy(const Ice::ObjectAdapterPtr&, const Ice::Identity&);
+        /// Whether receive size warning has been emitted.
+        bool rcvWarn;
 
-    BufSizeWarnInfo getBufSizeWarnInternal(Ice::Short type);
+        /// The receive size for which the warning was emitted.
+        int rcvSize;
+    };
 
-    enum State
+    class Instance : public std::enable_shared_from_this<Instance>
     {
-        StateActive,
-        StateDestroyInProgress,
-        StateDestroyed
+    public:
+        static InstancePtr create(const Ice::CommunicatorPtr&, Ice::InitializationData);
+        virtual ~Instance();
+        [[nodiscard]] bool destroyed() const;
+        [[nodiscard]] const Ice::InitializationData& initializationData() const { return _initData; }
+        [[nodiscard]] TraceLevelsPtr traceLevels() const;
+        [[nodiscard]] DefaultsAndOverridesPtr defaultsAndOverrides() const;
+        [[nodiscard]] RouterManagerPtr routerManager() const;
+        [[nodiscard]] LocatorManagerPtr locatorManager() const;
+        [[nodiscard]] ReferenceFactoryPtr referenceFactory() const;
+        [[nodiscard]] OutgoingConnectionFactoryPtr outgoingConnectionFactory() const;
+        [[nodiscard]] ObjectAdapterFactoryPtr objectAdapterFactory() const;
+        [[nodiscard]] ProtocolSupport protocolSupport() const;
+        [[nodiscard]] bool preferIPv6() const;
+        [[nodiscard]] NetworkProxyPtr networkProxy() const;
+        ThreadPoolPtr clientThreadPool();
+        ThreadPoolPtr serverThreadPool();
+        EndpointHostResolverPtr endpointHostResolver();
+        RetryQueuePtr retryQueue();
+        [[nodiscard]] const std::vector<int>& retryIntervals() const { return _retryIntervals; }
+        IceInternal::TimerPtr timer();
+        [[nodiscard]] EndpointFactoryManagerPtr endpointFactoryManager() const;
+        [[nodiscard]] Ice::PluginManagerPtr pluginManager() const;
+        [[nodiscard]] std::int32_t messageSizeMax() const { return _messageSizeMax; }
+        [[nodiscard]] std::int32_t batchAutoFlushSize() const { return _batchAutoFlushSize; }
+        [[nodiscard]] std::int32_t classGraphDepthMax() const { return _classGraphDepthMax; }
+        [[nodiscard]] Ice::ToStringMode toStringMode() const { return _toStringMode; }
+        [[nodiscard]] bool acceptClassCycles() const { return _acceptClassCycles; }
+
+        void addSliceLoader(Ice::SliceLoaderPtr loader) noexcept { _applicationSliceLoader->add(std::move(loader)); }
+        [[nodiscard]] const Ice::SliceLoaderPtr& sliceLoader() const noexcept { return _initData.sliceLoader; }
+
+        [[nodiscard]] const Ice::ConnectionOptions& clientConnectionOptions() const noexcept
+        {
+            return _clientConnectionOptions;
+        }
+        [[nodiscard]] Ice::ConnectionOptions serverConnectionOptions(const std::string& adapterName) const;
+
+        Ice::ObjectPrx createAdmin(const Ice::ObjectAdapterPtr&, const Ice::Identity&);
+        std::optional<Ice::ObjectPrx> getAdmin();
+        void addAdminFacet(Ice::ObjectPtr, std::string);
+        Ice::ObjectPtr removeAdminFacet(std::string_view);
+        Ice::ObjectPtr findAdminFacet(std::string_view);
+        Ice::FacetMap findAllAdminFacets();
+
+        [[nodiscard]] const Ice::ImplicitContextPtr& getImplicitContext() const;
+
+        void setDefaultLocator(const std::optional<Ice::LocatorPrx>&);
+        void setDefaultRouter(const std::optional<Ice::RouterPrx>&);
+
+        void setLogger(const Ice::LoggerPtr&);
+        void setThreadHook(std::function<void()>, std::function<void()>);
+
+        [[nodiscard]] const Ice::StringConverterPtr& getStringConverter() const { return _stringConverter; }
+        [[nodiscard]] const Ice::WstringConverterPtr& getWstringConverter() const { return _wstringConverter; }
+
+        BufSizeWarnInfo getBufSizeWarn(std::int16_t type);
+        void setSndBufSizeWarn(std::int16_t type, int size);
+        void setRcvBufSizeWarn(std::int16_t type, int size);
+
+        [[nodiscard]] Ice::SSL::SSLEnginePtr sslEngine() const { return _sslEngine; }
+
+    private:
+        Instance(Ice::InitializationData);
+        void initialize(const Ice::CommunicatorPtr&);
+        void finishSetup(const Ice::CommunicatorPtr&);
+        void destroy() noexcept;
+        void destroyAsync(std::function<void()> completed) noexcept;
+
+        friend class Ice::Communicator;
+
+        void updateConnectionObservers();
+        void updateThreadObservers();
+        friend class ObserverUpdaterI;
+
+        void addAllAdminFacets();
+        void setServerProcessProxy(const Ice::ObjectAdapterPtr&, const Ice::Identity&);
+
+        BufSizeWarnInfo getBufSizeWarnInternal(std::int16_t type);
+
+        [[nodiscard]] Ice::ConnectionOptions readConnectionOptions(const std::string& propertyPrefix) const;
+
+        enum State
+        {
+            StateActive,
+            StateDestroyInProgress,
+            StateDestroyed
+        };
+        State _state{StateActive};
+        Ice::InitializationData _initData;
+        const TraceLevelsPtr _traceLevels;                                 // Immutable, not reset by destroy().
+        const DefaultsAndOverridesPtr _defaultsAndOverrides;               // Immutable, not reset by destroy().
+        const std::int32_t _messageSizeMax{0};                             // Immutable, not reset by destroy().
+        const std::int32_t _batchAutoFlushSize{0};                         // Immutable, not reset by destroy().
+        const std::int32_t _classGraphDepthMax{0};                         // Immutable, not reset by destroy().
+        const Ice::ToStringMode _toStringMode{Ice::ToStringMode::Unicode}; // Immutable, not reset by destroy().
+        const bool _acceptClassCycles{false};                              // Immutable, not reset by destroy().
+        Ice::ConnectionOptions _clientConnectionOptions;
+        Ice::ConnectionOptions _serverConnectionOptions;
+        RouterManagerPtr _routerManager;
+        LocatorManagerPtr _locatorManager;
+        ReferenceFactoryPtr _referenceFactory;
+        OutgoingConnectionFactoryPtr _outgoingConnectionFactory;
+        ObjectAdapterFactoryPtr _objectAdapterFactory;
+        ProtocolSupport _protocolSupport;
+        bool _preferIPv6;
+        NetworkProxyPtr _networkProxy;
+        ThreadPoolPtr _clientThreadPool;
+        ThreadPoolPtr _serverThreadPool;
+        EndpointHostResolverPtr _endpointHostResolver;
+        std::thread _endpointHostResolverThread;
+        RetryQueuePtr _retryQueue;
+        std::vector<int> _retryIntervals;
+        ThreadObserverTimerPtr _timer;
+        EndpointFactoryManagerPtr _endpointFactoryManager;
+        Ice::PluginManagerPtr _pluginManager;
+        const Ice::ImplicitContextPtr _implicitContext;
+        Ice::StringConverterPtr _stringConverter;
+        Ice::WstringConverterPtr _wstringConverter;
+        bool _adminEnabled{false};
+        Ice::ObjectAdapterPtr _adminAdapter;
+        Ice::FacetMap _adminFacets;
+        Ice::Identity _adminIdentity;
+        std::set<std::string, std::less<>> _adminFacetFilter;
+        IceInternal::MetricsAdminIPtr _metricsAdmin;
+        std::map<std::int16_t, BufSizeWarnInfo> _setBufSizeWarn;
+        std::mutex _setBufSizeWarnMutex;
+        mutable std::recursive_mutex _mutex;
+        std::condition_variable_any _conditionVariable;
+
+        std::vector<std::thread> _destroyThreads;
+
+        enum ImplicitContextKind
+        {
+            None,
+            PerThread,
+            Shared
+        };
+        ImplicitContextKind _implicitContextKind;
+        // Only set when _implicitContextKind == Shared.
+        Ice::ImplicitContextPtr _sharedImplicitContext;
+        Ice::SSL::SSLEnginePtr _sslEngine;
+
+        // The Slice loader(s) added by the application: initData.sliceLoader followed by the loaders added by
+        // addSliceLoader.
+        const Ice::CompositeSliceLoaderPtr _applicationSliceLoader;
     };
-    State _state;
-    Ice::InitializationData _initData;
-    const TraceLevelsPtr _traceLevels; // Immutable, not reset by destroy().
-    const DefaultsAndOverridesPtr _defaultsAndOverrides; // Immutable, not reset by destroy().
-    const size_t _messageSizeMax; // Immutable, not reset by destroy().
-    const size_t _batchAutoFlushSize; // Immutable, not reset by destroy().
-    const size_t _classGraphDepthMax; // Immutable, not reset by destroy().
-    const bool _collectObjects; // Immutable, not reset by destroy().
-    const Ice::ToStringMode _toStringMode; // Immutable, not reset by destroy()
-    const bool _acceptClassCycles; // Immutable, not reset by destroy()
-    ACMConfig _clientACM;
-    ACMConfig _serverACM;
-    RouterManagerPtr _routerManager;
-    LocatorManagerPtr _locatorManager;
-    ReferenceFactoryPtr _referenceFactory;
-    RequestHandlerFactoryPtr _requestHandlerFactory;
-    ProxyFactoryPtr _proxyFactory;
-    OutgoingConnectionFactoryPtr _outgoingConnectionFactory;
-    ObjectAdapterFactoryPtr _objectAdapterFactory;
-    ProtocolSupport _protocolSupport;
-    bool _preferIPv6;
-    NetworkProxyPtr _networkProxy;
-    ThreadPoolPtr _clientThreadPool;
-    ThreadPoolPtr _serverThreadPool;
-    EndpointHostResolverPtr _endpointHostResolver;
-    RetryQueuePtr _retryQueue;
-    TimerPtr _timer;
-    EndpointFactoryManagerPtr _endpointFactoryManager;
-    DynamicLibraryListPtr _dynamicLibraryList;
-    Ice::PluginManagerPtr _pluginManager;
-    const Ice::ImplicitContextIPtr _implicitContext;
-    Ice::StringConverterPtr _stringConverter;
-    Ice::WstringConverterPtr _wstringConverter;
-    bool _adminEnabled;
-    Ice::ObjectAdapterPtr _adminAdapter;
-    Ice::FacetMap _adminFacets;
-    Ice::Identity _adminIdentity;
-    std::set<std::string> _adminFacetFilter;
-    IceInternal::MetricsAdminIPtr _metricsAdmin;
-    std::map<Ice::Short, BufSizeWarnInfo> _setBufSizeWarn;
-    IceUtil::Mutex _setBufSizeWarnMutex;
-    ObjectFactoryMap _objectFactoryMap;
-    mutable ObjectFactoryMap::iterator _objectFactoryMapHint;
-};
-
-class ProcessI : public Ice::Process
-{
-public:
 
-    ProcessI(const Ice::CommunicatorPtr&);
-
-    virtual void shutdown(const Ice::Current&);
-#ifdef ICE_CPP11_MAPPING
-    virtual void writeMessage(std::string, Ice::Int, const Ice::Current&);
-#else
-    virtual void writeMessage(const std::string&, Ice::Int, const Ice::Current&);
-#endif
-
-private:
+    class ProcessI final : public Ice::Process
+    {
+    public:
+        ProcessI(Ice::CommunicatorPtr);
 
-    const Ice::CommunicatorPtr _communicator;
-};
+        void shutdown(const Ice::Current&) final;
+        void writeMessage(std::string message, std::int32_t fd, const Ice::Current&) final;
 
+    private:
+        const Ice::CommunicatorPtr _communicator;
+    };
 }
 
 #endif