SessionSettings.h

Go to the documentation of this file.

/*
 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
 *
 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
 * and international copyright treaties.
 *
 * Access to and use of the software is governed by the terms of the applicable OnixS Software
 * Services Agreement (the Agreement) and Customer end user license agreements granting
 * a non-assignable, non-transferable and non-exclusive license to use the software
 * for it's own data processing purposes under the terms defined in the Agreement.
 *
 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
 * of this source code or associated reference material to any other location for further reproduction
 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
 *
 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
 * the terms of the Agreement is a violation of copyright law.
 */
 
#pragma once
 
#include <OnixS/ICE/BOE/ABI.h>
#include <OnixS/ICE/BOE/Messaging.h>
#include <OnixS/ICE/BOE/ThreadingModel.h>
#include <OnixS/ICE/BOE/LogSettings.h>
 
#include <climits>
#include <set>
#include <string>
#include <vector>
 
ONIXS_ICEBOE_NAMESPACE_BEGIN

class SessionSettings
{
public:
    ONIXS_ICEBOE_EXPORTED
    SessionSettings();

    ONIXS_ICEBOE_NODISCARD
    const std::string & userId() const noexcept
    {
        return userId_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& userId(const std::string & value);

    ONIXS_ICEBOE_NODISCARD
    Messaging::Int32 clientId() const noexcept
    {
        return clientId_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& clientId(Messaging::Int32 value);

    ONIXS_ICEBOE_NODISCARD
    const std::string& rawData() const noexcept
    {
        return rawData_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& rawData(const std::string& value);

    ONIXS_ICEBOE_NODISCARD
    ThreadingModel::Enum threadingModel() const noexcept
    {
        return threadingModel_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& threadingModel(ThreadingModel::Enum value);

    ONIXS_ICEBOE_NODISCARD
    unsigned receiveSpinningTimeout() const noexcept
    {
        return receiveSpinningTimeout_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& receiveSpinningTimeout(unsigned usecTimeout);

    ONIXS_ICEBOE_NODISCARD
    unsigned sendSpinningTimeout() const noexcept
    {
        return sendSpinningTimeout_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& sendSpinningTimeout(unsigned usecTimeout);

    ONIXS_ICEBOE_NODISCARD
    unsigned messageGrouping() const noexcept
    {
        return messageGrouping_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& messageGrouping(unsigned value);

    SessionSettings& resetToDefaults();

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& addLicenseStore(const std::string& value);

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& licenseStore(const std::string & value);

    typedef std::vector<std::string> LicenseStores;

    ONIXS_ICEBOE_NODISCARD
    const LicenseStores& licenseStores() const noexcept
    {
        return licenseStores_;
    }

    ONIXS_ICEBOE_NODISCARD
    unsigned licenseAlertingDaysBeforeExpiration() const noexcept
    {
        return licenseAlertingDaysBeforeExpiration_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& licenseAlertingDaysBeforeExpiration(unsigned days)
    {
        licenseAlertingDaysBeforeExpiration_ = days;
        return *this;
    }

    ONIXS_ICEBOE_EXPORTED ONIXS_ICEBOE_NODISCARD
    const std::string & localNetworkInterface() const noexcept
    {
        return localNetworkInterface_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& localNetworkInterface(const std::string & value);

    ONIXS_ICEBOE_NODISCARD
    const std::string & storageDirectory() const noexcept
    {
        return storageDirectory_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& storageDirectory(const std::string & value);

    ONIXS_ICEBOE_NODISCARD
    bool localTimeUsage() const noexcept
    {
        return localTimeUsage_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& localTimeUsage(bool);

    ONIXS_ICEBOE_NODISCARD
    Messaging::UInt64 fileBasedStorageSegmentSize() const noexcept
    {
        return fileBasedStorageSegmentSize_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& fileBasedStorageSegmentSize(Messaging::UInt64 value);

    ONIXS_ICEBOE_NODISCARD
    unsigned asyncFileBasedStorageQueueMaxSize() const noexcept
    {
        return asyncFileBasedStorageQueueMaxSize_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& asyncFileBasedStorageQueueMaxSize(unsigned value);

    ONIXS_ICEBOE_NODISCARD
    const CpuIndexes & asyncFileBasedStorageThreadAffinity() const noexcept
    {
        return asyncFileBasedStorageThreadAffinity_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& asyncFileBasedStorageThreadAffinity(const CpuIndexes & cpuIndexes);

    ONIXS_ICEBOE_NODISCARD
    bool ignoreFileBasedStorageIntegrityErrors() const noexcept
    {
        return ignoreFileBasedStorageIntegrityErrors_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& ignoreFileBasedStorageIntegrityErrors(bool);

    ONIXS_ICEBOE_NODISCARD
    bool logBeforeSending() const noexcept
    {
        return logBeforeSending_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& logBeforeSending(bool before);

    ONIXS_ICEBOE_NODISCARD
    unsigned reconnectAttempts() const noexcept
    {
        return reconnectAttempts_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& reconnectAttempts(unsigned reconnectAttempts);

    ONIXS_ICEBOE_NODISCARD
    unsigned reconnectInterval() const noexcept
    {
        return reconnectInterval_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& reconnectInterval(unsigned value);

    static const int UseOsDefaultSocketBufferSize = -1;

    ONIXS_ICEBOE_NODISCARD
    int socketReceiveBufferSize() const noexcept
    {
        return socketReceiveBufferSize_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& socketReceiveBufferSize(int bufferSize);

    ONIXS_ICEBOE_NODISCARD
    unsigned reasonableTransmissionTime() const noexcept
    {
        return reasonableTransmissionTime_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& reasonableTransmissionTime(unsigned percentage);

    ONIXS_ICEBOE_NODISCARD
    int socketSendBufferSize() const noexcept
    {
        return socketSendBufferSize_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& socketSendBufferSize(int bufferSize);

    ONIXS_ICEBOE_NODISCARD
    const CpuIndexes & threadPoolAffinity() const noexcept
    {
        return threadPoolAffinity_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& threadPoolAffinity(const CpuIndexes & cpuIndexes);

    ONIXS_ICEBOE_NODISCARD
    int threadPoolPriority() const noexcept
    {
        return threadPoolPriority_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& threadPoolPriority(int priority);

    ONIXS_ICEBOE_NODISCARD
    int threadPoolPolicy() const noexcept
    {
        return threadPoolPolicy_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& threadPoolPolicy(int policy);

    ONIXS_ICEBOE_NODISCARD
    bool tcpNoDelayOption() const noexcept
    {
        return tcpNoDelayOption_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& tcpNoDelayOption(bool value);

    ONIXS_ICEBOE_NODISCARD
    unsigned threadPoolSize() const noexcept
    {
        return threadPoolSize_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& threadPoolSize(unsigned numberOfThreads);

    ONIXS_ICEBOE_EXPORTED ONIXS_ICEBOE_NODISCARD
    unsigned short keepAliveInterval() const noexcept
    {
        return keepAliveInterval_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& keepAliveInterval(unsigned short seconds);

    ONIXS_ICEBOE_NODISCARD
    bool reportNewMessagesWhileWaitingForMissedMessages() const noexcept
    {
        return reportNewMessagesWhileWaitingForMissedMessages_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& reportNewMessagesWhileWaitingForMissedMessages(bool report);

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& localPortRange(PortRange range);

    ONIXS_ICEBOE_NODISCARD
    PortRange localPortRange() const noexcept
    {
        return localPortRange_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& messagingSchemaVersion(Messaging::SchemaVersion schema);

    ONIXS_ICEBOE_NODISCARD
    Messaging::SchemaVersion messagingSchemaVersion() const noexcept
    {
        return messagingSchemaVersion_;
    }

    ONIXS_ICEBOE_NODISCARD
    bool useSpinLock() const noexcept
    {
        return useSpinLock_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& useSpinLock(bool value);

    ONIXS_ICEBOE_NODISCARD
    bool enableRxTimestamp() const noexcept
    {
        return enableRxTimestamp_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& enableRxTimestamp(bool value);

    ONIXS_ICEBOE_NODISCARD
    bool useTLS() const noexcept
    {
        return useTLS_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& useTLS(bool value);

    ONIXS_ICEBOE_NODISCARD
    LogLevel::Enum logLevel() const noexcept
    {
        return logLevel_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& logLevel(LogLevel::Enum value);

    ONIXS_ICEBOE_NODISCARD
    LogSettings::Enum loggerOptions() const noexcept
    {
        return loggerOptions_;
    }

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& loggerOptions(LogSettings::Enum value);

    ONIXS_ICEBOE_EXPORTED
    SessionSettings& load(const std::string& configFile);

    ONIXS_ICEBOE_EXPORTED ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    struct ONIXS_ICEBOE_EXPORTED Default
    {
        static const ThreadingModel::Enum ThreadingModelValue = ThreadingModel::Dedicated;
        static const unsigned short KeepAliveInterval = 30;
        static const bool LogBeforeSending = true;
        static const int SocketSendBufferSize = UseOsDefaultSocketBufferSize;
        static const int SocketReceiveBufferSize = UseOsDefaultSocketBufferSize;
        static const bool TcpNoDelayOption = true;
        static const int ReceiveSpinningTimeout = 0;
        static const int SendSpinningTimeout = 0;
        static const char LicenseStore[];
        static const unsigned LicenseAlertingDaysBeforeExpiration = 0;
        static const char LogDir[];
        static const bool LocalTimeUsage = false;
        static const unsigned MessageGrouping = 0;
        static const int ReasonableTransmissionTime = 20;
        static const int ReconnectAttempts = 3;
        static const int ReconnectInterval = 180;
        static const unsigned long long FileBasedStorageSegmentSize = 0;
        static const bool IgnoreFileBasedStorageIntegrityErrors = false;
        static const int ThreadPoolSize = 0;
        static const bool ReportNewMessagesWhileWaitingForMissedMessages = false;
        static const unsigned AsyncFileBasedStorageQueueMaxSize = UINT_MAX;
        static const bool UseSpinLock = false;
        static const bool EnableRxTimestamp = false;
        static const bool UseTLS = false;
        static const LogLevel::Enum LogSeverity = LogLevel::Info;
        static const LogSettings::Enum LoggerOptions = LogSettings::Default;
    };

    struct ONIXS_ICEBOE_EXPORTED Key
    {
        static const char * UserId;                                         
        static const char * ClientId;                                       
        static const char * RawData;                                        
        static const char * AsyncFileBasedStorageQueueMaxSize;              
        static const char * AsyncFileBasedStorageThreadAffinity;            
        static const char * ThreadingModel;                                 
        static const char * TcpNoDelayOption;                               
        static const char * MessageGrouping;                                
        static const char * FileBasedStorageSegmentSize;                    
        static const char * IgnoreFileBasedStorageIntegrityErrors;          
        static const char * KeepAliveInterval;                              
        static const char * LicenseStore;                                   
        static const char * LicenseAlertingDaysBeforeExpiration;            
        static const char * LocalNetworkInterface;                          
        static const char * LocalTimeUsage;                                 
        static const char * LogBeforeSending;                               
        static const char * ReasonableTransmissionTime;                     
        static const char * ReceiveSpinningTimeout;                         
        static const char * ReconnectAttempts;                              
        static const char * ReconnectInterval;                              
        static const char * SendSpinningTimeout;                            
        static const char * ThreadPoolAffinity;                             
        static const char * ThreadPoolSize;                                 
        static const char * ThreadPoolPriority;                             
        static const char * ThreadPoolPolicy;                               
        static const char * SocketReceiveBufferSize;                        
        static const char * SocketSendBufferSize;                           
        static const char * StorageDirectory;                               
        static const char * ReportNewMessagesWhileWaitingForMissedMessages; 
        static const char * MessagingSchemaVersion;                         
        static const char * LocalPortRange;                                 
        static const char * UseSpinLock;                                    
        static const char * EnableRxTimestamp;                              
        static const char * UseTLS;                                         
        static const char * LogSeverity;                                    
        static const char * LoggerOptions;                                  
    };
 
private:
    void processLicenseStores(const std::string& licenseStore);
 
    unsigned asyncFileBasedStorageQueueMaxSize_;
 
    CpuIndexes asyncFileBasedStorageThreadAffinity_;
 
    Messaging::UInt64 fileBasedStorageSegmentSize_;
 
    Messaging::Int32 clientId_;
 
    bool ignoreFileBasedStorageIntegrityErrors_;
 
    unsigned short keepAliveInterval_;
 
    unsigned licenseAlertingDaysBeforeExpiration_;
 
    LicenseStores licenseStores_;
 
    std::string localNetworkInterface_;
 
    bool localTimeUsage_;
 
    bool logBeforeSending_;
 
    unsigned messageGrouping_;
 
    unsigned reasonableTransmissionTime_;
 
    int receiveSpinningTimeout_;
 
    unsigned reconnectAttempts_;
 
    unsigned reconnectInterval_;
 
    bool reportNewMessagesWhileWaitingForMissedMessages_;
 
    std::string rawData_;
 
    int sendSpinningTimeout_;
 
    std::string userId_;
 
    int socketReceiveBufferSize_;
 
    int socketSendBufferSize_;
 
    std::string storageDirectory_;
 
    bool tcpNoDelayOption_;
 
    ThreadingModel::Enum threadingModel_;
 
    CpuIndexes threadPoolAffinity_;
 
    int threadPoolPolicy_;
 
    int threadPoolPriority_;
 
    unsigned threadPoolSize_;
 
    std::pair<Port, Port> localPortRange_;
 
    Messaging::SchemaVersion messagingSchemaVersion_;
 
    bool useSpinLock_;
 
    bool enableRxTimestamp_;
 
    bool useTLS_;
 
    LogLevel::Enum logLevel_;
 
    LogSettings::Enum loggerOptions_;
};
 
ONIXS_ICEBOE_NAMESPACE_END