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/CME/iLink3/ABI.h>
#include <OnixS/CME/iLink3/Messaging.h>
#include <OnixS/CME/iLink3/ThreadingModel.h>
#include <OnixS/CME/iLink3/LogSettings.h>
 
#include <climits>
#include <set>
#include <string>
#include <vector>
 
namespace OnixS {
namespace CME {
namespace iLink3 {

class SessionSettings
{
public:
    ONIXS_ILINK3_EXPORTED
    SessionSettings();

    ONIXS_ILINK3_NODISCARD
    const std::string & sessionId() const noexcept {
        return sessionId_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& sessionId(const std::string & value);

    ONIXS_ILINK3_NODISCARD
    const std::string & firmId() const noexcept {
        return firmId_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& firmId(const std::string & value);

    ONIXS_ILINK3_NODISCARD
    const std::string & accessKey() const noexcept {
        return accessKey_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& accessKey(const std::string & value);

    ONIXS_ILINK3_NODISCARD
    const std::string & secretKey() const noexcept {
        return secretKey_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& secretKey(const std::string & value);

    ONIXS_ILINK3_NODISCARD
    const std::string & tradingSystemName() const noexcept {
        return tradingSystemName_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& tradingSystemName(const std::string & value);

    ONIXS_ILINK3_NODISCARD
    const std::string & tradingSystemVersion() const noexcept {
        return tradingSystemVersion_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& tradingSystemVersion(const std::string & value);

    ONIXS_ILINK3_NODISCARD
    const std::string & tradingSystemVendor() const noexcept {
        return tradingSystemVendor_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& tradingSystemVendor(const std::string & value);

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

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

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& receiveSpinningTimeout(unsigned usecTimeout);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& sendSpinningTimeout(unsigned usecTimeout);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& messageGrouping(unsigned value);

    SessionSettings& resetToDefaults();

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

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

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

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

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

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

    ONIXS_ILINK3_EXPORTED ONIXS_ILINK3_NODISCARD
    const std::string & localNetworkInterface() const noexcept {
        return localNetworkInterface_;
    }

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

    ONIXS_ILINK3_NODISCARD
    const std::string & logFileName() const noexcept {
        return logFileName_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& logFileName(const std::string & value);

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

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

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& localTimeUsage(bool);

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

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

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& asyncFileBasedStorageQueueMaxSize(unsigned value);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& asyncFileBasedStorageThreadAffinity(const CpuIndexes & cpuIndexes);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& ignoreFileBasedStorageIntegrityErrors(bool);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& logBeforeSending(bool before);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& reconnectAttempts(unsigned reconnectAttempts);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& reconnectInterval(unsigned value);

    static const int UseOsDefaultSocketBufferSize = -1;

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& socketReceiveBufferSize(int bufferSize);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& reasonableTransmissionTime(unsigned percentage);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& socketSendBufferSize(int bufferSize);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& threadPoolAffinity(const CpuIndexes & cpuIndexes);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& threadPoolPriority(int priority);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& threadPoolPolicy(int policy);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& tcpNoDelayOption(bool value);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& threadPoolSize(unsigned numberOfThreads);

    ONIXS_ILINK3_EXPORTED ONIXS_ILINK3_NODISCARD
    unsigned keepAliveInterval() const noexcept {
        return keepAliveInterval_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& keepAliveInterval(unsigned milliseconds);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& reportNewMessagesWhileWaitingForMissedMessages(bool report);

    ONIXS_ILINK3_EXPORTED
    SessionSettings& localPortRange(PortRange range);

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

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

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

    ONIXS_ILINK3_NODISCARD
    bool detectMessageGapForPreviousUuid() const noexcept {
        return detectMessageGapForPreviousUuid_;
    }

    ONIXS_ILINK3_EXPORTED
    SessionSettings& detectMessageGapForPreviousUuid(bool detectGap);

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& useSpinLock(bool value);

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

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

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

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

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

    ONIXS_ILINK3_EXPORTED
    SessionSettings& enableRxTimestamp(bool value);

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

    ONIXS_ILINK3_EXPORTED ONIXS_ILINK3_NODISCARD
    std::string toString() const;

    struct ONIXS_ILINK3_EXPORTED Default {
        static const ThreadingModel::Enum ThreadingModelValue = ThreadingModel::Dedicated;
        static const bool CreateLogFile = true;
        static const int KeepAliveInterval = 30000;
        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 char LogFileName[];
        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 DetectMessageGapForPreviousUuid = true;
        static const bool UseSpinLock = false;
        static const bool EnableRxTimestamp = false;
        static const LogLevel::Enum LogSeverity = LogLevel::Info;
        static const LogSettings::Enum LoggerOptions = LogSettings::Default;
    };

    struct ONIXS_ILINK3_EXPORTED Key {
        static const char * SessionId;                                      
        static const char * FirmId;                                         
        static const char * AccessKey;                                      
        static const char * SecretKey;                                      
        static const char * TradingSystemName;                              
        static const char * TradingSystemVersion;                           
        static const char * TradingSystemVendor;                            
 
        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 * LicenseFile;                                    
        static const char * LicenseStore;                                   
        static const char * LicenseAlertingDaysBeforeExpiration;            
        static const char * LocalNetworkInterface;                          
        static const char * LogFileName;                                    
        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 * DetectMessageGapForPreviousUuid;                
        static const char * UseSpinLock;                                    
        static const char * EnableRxTimestamp;                              
        static const char * LogSeverity;                                    
        static const char * LoggerOptions;                                  
    };
 
private:
    void processLicenseStores(const std::string& licenseStore);
 
    std::string accessKey_;
 
    unsigned asyncFileBasedStorageQueueMaxSize_;
 
    CpuIndexes asyncFileBasedStorageThreadAffinity_;
 
    bool createEngineLogFile_;
 
    Messaging::UInt64 fileBasedStorageSegmentSize_;
 
    std::string firmId_;
 
    bool ignoreFileBasedStorageIntegrityErrors_;
 
    unsigned keepAliveInterval_;
 
    unsigned licenseAlertingDaysBeforeExpiration_;
 
    std::string licenseFilePath_;
 
    LicenseStores licenseStores_;
 
    std::string localNetworkInterface_;
 
    bool localTimeUsage_;
 
    bool logBeforeSending_;
 
    std::string logFileName_;
 
    unsigned messageGrouping_;
 
    unsigned reasonableTransmissionTime_;
 
    int receiveSpinningTimeout_;
 
    unsigned reconnectAttempts_;
 
    unsigned reconnectInterval_;
 
    bool reportNewMessagesWhileWaitingForMissedMessages_;
 
    std::string secretKey_;
 
    int sendSpinningTimeout_;
 
    std::string sessionId_;
 
    int socketReceiveBufferSize_;
 
    int socketSendBufferSize_;
 
    std::string storageDirectory_;
 
    bool tcpNoDelayOption_;
 
    ThreadingModel::Enum threadingModel_;
 
    CpuIndexes threadPoolAffinity_;
 
    int threadPoolPolicy_;
 
    int threadPoolPriority_;
 
    unsigned threadPoolSize_;
 
    std::string tradingSystemName_;
 
    std::string tradingSystemVendor_;
 
    std::string tradingSystemVersion_;
 
    std::pair<Port, Port> localPortRange_;
 
    Messaging::SchemaVersion messagingSchemaVersion_;
 
    bool detectMessageGapForPreviousUuid_;
 
    bool useSpinLock_;
 
    bool enableRxTimestamp_;
 
    LogLevel::Enum logLevel_;
 
    LogSettings::Enum loggerOptions_;
};
 
}
}
}