/** * @file include/ActivMiddleware/ActivFramework/RouterService.h * * @brief Header file for router service class. */ #if (!defined ACTIV_FRAMEWORK_ROUTER_SERVICE_H) #define ACTIV_FRAMEWORK_ROUTER_SERVICE_H #include "ActivMiddleware/ActivFramework/External.h" #include "ActivMiddleware/ActivBase/Ip/INetworkAffinityHelper.h" #include "ActivMiddleware/ActivBase/Ip/IpManager.h" #include "ActivMiddleware/ActivBase/Ip/NetworkAffinityFilter.h" #include "ActivMiddleware/ActivBase/Uuid.h" #include "ActivMiddleware/ActivFramework/Component.h" #include "ActivMiddleware/ActivFramework/HeapPool.h" #include "ActivMiddleware/ActivFramework/ManagedEndPoint.h" #include "ActivMiddleware/ActivFramework/PostMessageHelper.h" #include "ActivMiddleware/ActivFramework/UiComponent.h" #if (defined ACTIV_PLATFORM_LINUX) #include "ActivMiddleware/ActivBase/Linux/OnloadHelper.h" #endif #include "ActivMiddleware/CxxYZ/vector.h" //! Activ namespace. namespace Activ { class UiIo; /** * @brief Router service class. */ class RouterService : private ManagedEndPoint, public Component { public: using Component::GetApplication; using ManagedEndPoint::GetEndPointName; /** * @brief Settings. */ class Settings : public IpManager::Settings { public: /** * @brief Constructor. * * @param defaultServiceName */ ACTIV_FRAMEWORK_API Settings(const String &defaultServiceName); /** * @brief Read settings from an ini file section. * * @param sectionIterator iterator to an ini file section. * * @throw Exception */ ACTIV_FRAMEWORK_API void Read(const IniFileParser::ConstSectionIterator §ionIterator); /** * @brief How to distribute sockets across threads. */ enum ThreadDistributionMode { THREAD_DISTRIBUTION_MODE_BY_HEAP_ID, ///< Distribute sockets across threads by user's heap id. THREAD_DISTRIBUTION_MODE_BY_ENDPOINT_ID, ///< Distribute sockets across threads by user's endpoint id. THREAD_DISTRIBUTION_MODE_LEAST_REQUESTS, ///< Distribute to thread that has handled the least number of user requests. THREAD_DISTRIBUTION_MODE_DEFINED_THREAD, ///< Distribute to the thread defined by url parameter or DefaultDistributionThread if configured in settings. THREAD_DISTRIBUTION_MODE_DEFAULT = THREAD_DISTRIBUTION_MODE_BY_HEAP_ID }; String m_serviceName; ManagedEndPoint::Settings m_managerManagedEndPointSettings; ///< Settings for the main RouterService endpoint. ManagedEndPoint::Settings m_managedEndPointSettings; ///< Settings for the impl RouterService endpoints. /** * @brief Default: true. When true the ProcessorAffinity in @a m_managedEndPointSettings will be used to tie each * IpManager to a single core. When false all IpManagers will be bound to the same set of cores. */ bool m_assignPerCoreAffinity; IHeap::Settings m_serviceHeapSettings; ///< Properties for main heap. IHeap::Settings m_notificationHeapSettings; ///< Properties for notification heaps. IHeap::Settings m_implNotificationHeapSettings; ///< Properties for impl notification heaps. bool m_useHardwareZlib; ///< Use hardware zlib card if available? (default: true). uint32_t m_lazyTimerInterval; ///< Interval of the lazy timer. size_t m_numberOfIpManagers; ///< How many ip managers to use. ThreadDistributionMode m_threadDistributionMode; ///< How to distribute sockets across threads. size_t m_defaultDistributionThread; ///< Default: 0. If using THREAD_DISTRIBUTION_MODE_DEFINED_THREAD, use this thread for all connections unless overridden. PostMessageHelper::Settings m_rxPostMessageHelperSettings; ///< Settings for buffering of received messages. UInt m_noHeartbeatBreakInterval; ///< Default: uninitialized. Break a connection if a heartbeat isn't received in this number of seconds (on supported protocols). bool m_shouldAllowLocalCircuitShortcut; ///< Default: true. If two TCP connected components are in the same system use endpoint comms and avoid the IP layer. size_t m_serverConnectionCircuitLimit; ///< Default: 1000. Maximum number of circuits allowed on a single server connection. // Proxy configuration. enum ProxyMode { PROXY_MODE_NONE, ///< No proxy for HTTP tunnelling. PROXY_MODE_AUTO_CONFIGURE_FROM_DEFAULT_BROWSER, ///< Attempt to determine proxy settings from default browser. PROXY_MODE_AUTO_CONFIGURE_FROM_IE, ///< Attempt to determine proxy settings from Internet Explorer. PROXY_MODE_MANUAL ///< From m_proxyAddress. }; ProxyMode m_proxyMode; String m_proxyAddress; ///< For PROXY_MODE_MANUAL. String m_proxyUser; ///< Optional for other than PROXY_MODE_NONE. String m_proxyPassword; ///< Ditto. bool m_shouldTryHttpConnect; ///< Whether to try HTTP CONNECT in automatic tunnelling protocols. Requires a proxy. Default: false. String m_clientAccessPolicyFilename; ///< For Silverlight clients. size_t m_heartbeatInterval; ///< Interval (in ms) between heartbeats for pure connections. Default 10000. size_t m_heartbeatIntervalHttpT2; ///< Interval (in ms) between heartbeats for HTTP t2 tunnelled connections from the client-side. Default 60000. size_t m_connectTimeout; ///< Time (in ms) to give client-side connections to establish. 0 to leave as OS default. Default 0. NetworkAffinityFilter::Settings m_networkAffinityFilterSettings; ///< Default network affinity filter to apply to all RouterService sockets. }; /** * @brief Router service ui component. */ class UiComponent ACTIV_FINAL : public Activ::UiComponent { public: /** * @brief Constructor for system-wide RouterService ui. * * @param routerService the router service to have the ui. * @param uiServiceName name of the ui service. * * @throw Exception. */ ACTIV_FRAMEWORK_API UiComponent(RouterService &routerService, const String &uiServiceName); /** * @brief Constructor for process-local RouterService ui. * * @param routerService the router service to have the ui. * @param parentUiComponent UiComponent to contain this component. * @param uiServiceName name of the ui service. * * @throw Exception. */ ACTIV_FRAMEWORK_API UiComponent(RouterService &routerService, const Activ::UiComponent &parentUiComponent, const String &uiServiceName); private: virtual void Run(UiUser &uiUser) ACTIV_OVERRIDE; RouterService & m_routerService; CxxYZ::vector > m_implUiComponentList; // Last member. Component::Enabler m_componentEnabler; }; /** * @brief Constructor. * * @param application the application to run in. * @param settings settings for service. * * @throw Exception */ ACTIV_FRAMEWORK_API RouterService(Application &application, const Settings &settings); /** * @brief Destructor. */ ACTIV_FRAMEWORK_API ~RouterService(); /** * @brief Subscribe all implementation objects to endpoint notification messages. */ ACTIV_FRAMEWORK_API void SubscribeToEndPointMessages(); /** * @brief Unsubscribe all implementation objects from endpoint notification messages. */ ACTIV_FRAMEWORK_API void UnsubscribeFromEndPointMessages(); class Impl; protected: virtual StatusCode OnMessage(HeapMessage &message) ACTIV_OVERRIDE; virtual StatusCode OnRequest(HeapMessage &request) ACTIV_OVERRIDE; virtual void OnThreadStart() ACTIV_OVERRIDE; private: /** * @brief Process endpoint die message. * * @param message * @param type string to display ("shutdown" or "died"). */ void ProcessSystemEndPointIdSetMessage(HeapMessage &message, const char * const type); /** * @brief Process a request and distribute it to a worker thread based on heap id in the request. * * @param request * * @throw Exception. */ template void ProcessRequest(HeapMessage &request); /** * @brief Process a start listening request. * * @param request * * @throw Exception. */ void ProcessStartListenRequest(HeapMessage &request); /** * @brief Forward a request to an Impl determined by heap or endpoint id. * * @param heapMessage * @param heapId * @param threadDistributionMode */ void ForwardRequest(HeapMessage &heapMessage, const HeapId heapId, const Settings::ThreadDistributionMode threadDistributionMode); /** * @brief Forward a request to a specified Impl index. * * @param heapMessage * @param impleIndex */ void ForwardRequest(HeapMessage &heapMessage, const size_t implIndex); /** * @brief Process a get endpoint id set request from the user. * * @param request */ void ProcessUserGetEndPointIdSetRequest(HeapMessage &request) const; /** * @brief Process an add network affinity filter request from the user. * * @param request * @param isRequest */ void ProcessUserAddNetworkAffinityFilterRequest(HeapMessage &request, const bool isRequest); /** * @brief Process a remove network affinity filter request from the user. * * @param request * @param isRequest */ void ProcessUserRemoveNetworkAffinityFilterRequest(HeapMessage &request, const bool isRequest); /** * @brief Get the Impl to use based on heap or endpoint id. * * @param heapId * @param endPointId * @param threadDistributionMode * * @return Index of the Impl. */ size_t GetImplIndex(const HeapId heapId, const EndPointId endPointId, const Settings::ThreadDistributionMode threadDistributionMode); //! Display statistics. void UiDisplayStatistics(const UiIo &uiIo) const; #if (defined ACTIV_PLATFORM_POSIX) //! Display servers summary. void UiDisplayServersSummary(const UiIo &uiIo) const; //! Display server details. void UiDisplayServerDetails(const UiIo &uiIo) const; #endif //! Display network affinity filters. void UiDisplayNetworkAffinityFilters(const UiIo &uiIo) const; //! Display unsupported affinity filters. void UiDisplayUnsupportedNetworkAffinityFilters(const UiIo &uiIo) const; class ServerComponent; /** * @brief Info about the Impl objects maintained in the main thread. */ class ImplInfo { public: /** * @brief Default constructor. */ ImplInfo(); size_t m_numberOfForwardedRequests; }; typedef CxxYZ::shared_ptr ImplPtr; typedef std::pair ImplPair; typedef std::vector ImplList; typedef std::map ImplIndexMap; typedef CxxYZ::shared_ptr ServerComponentPtr; typedef std::map ServerComponentMap; const Uuid m_uuid; ///< Unique ID of this router. const Settings::ThreadDistributionMode m_threadDistributionMode; ///< How to distribute sockets across threads. const size_t m_defaultDistributionThread; ///< If using THREAD_DISTRIBUTION_MODE_DEFINED_THREAD, use this thread for all connections unless overridden. ImplList m_implList; ImplIndexMap m_implIndexMap; ///< Heap/endpoint id to Impl index map. ServerComponentMap m_serverComponentMap; typedef std::set NetworkAffinityFilterSet; NetworkAffinityFilterSet m_networkAffinityFilterSet; ///< Set of active network affinity filters. NetworkAffinityFilterSet m_unsupportedNetworkAffinityFilterSet; ///< Set of requested but unsupported network affinity filters. const CxxYZ::unique_ptr m_pNetworkAffinityHelper; #if (defined ACTIV_PLATFORM_POSIX) IpManager m_ipManager; HeapPool m_implNotificationHeapPool; ///< Pool of heaps for critical impl notifications. #if (defined ACTIV_PLATFORM_LINUX) OnloadHelper m_onloadHelper; #endif // (defined ACTIV_PLATFORM_LINUX) #endif // (defined ACTIV_PLATFORM_POSIX) // Last member. Component::Enabler m_componentEnabler; }; } // namespace Activ #endif // (!defined ACTIV_FRAMEWORK_ROUTER_SERVICE_H)