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

class SessionSettings
{
public:
    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings();

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

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

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

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

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

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

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

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

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

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

    static const unsigned MaxSpinningTimeoutUsec = 1000000; //1 sec

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned receiveSpinningTimeout() const {
        return receiveSpinningTimeout_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& receiveSpinningTimeout(unsigned usecTimeout);

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned sendSpinningTimeout() const
    {
        return sendSpinningTimeout_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& sendSpinningTimeout(unsigned usecTimeout);

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned messageGrouping() const {
        return messageGrouping_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& messageGrouping(unsigned value);

    SessionSettings& resetToDefaults();

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

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

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

    ONIXS_CONFLATEDTCP_NODISCARD
    const LicenseStores& licenseStores() const
    {
        return licenseStores_;
    }

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned licenseAlertingDaysBeforeExpiration() const {
        return licenseAlertingDaysBeforeExpiration_;
    }

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

    ONIXS_CONFLATEDTCP_EXPORTED ONIXS_CONFLATEDTCP_NODISCARD
    const std::string & localNetworkInterface() const {
        return localNetworkInterface_;
    }

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

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

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

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

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

    ONIXS_CONFLATEDTCP_NODISCARD
    bool localTimeUsage() const {
        return localTimeUsage_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& localTimeUsage(bool);

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

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

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned asyncFileBasedStorageQueueMaxSize() const {
        return asyncFileBasedStorageQueueMaxSize_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& asyncFileBasedStorageQueueMaxSize(unsigned value);

    ONIXS_CONFLATEDTCP_NODISCARD
    const CpuIndexes & asyncFileBasedStorageThreadAffinity() const {
        return asyncFileBasedStorageThreadAffinity_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& asyncFileBasedStorageThreadAffinity(const CpuIndexes & cpuIndexes);

    ONIXS_CONFLATEDTCP_NODISCARD
    bool ignoreFileBasedStorageIntegrityErrors() const {
        return ignoreFileBasedStorageIntegrityErrors_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& ignoreFileBasedStorageIntegrityErrors(bool);

    ONIXS_CONFLATEDTCP_NODISCARD
    bool logBeforeSending() const {
        return logBeforeSending_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& logBeforeSending(bool before);

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned reconnectAttempts() const {
        return reconnectAttempts_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& reconnectAttempts(unsigned reconnectAttempts);

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned reconnectInterval() const {
        return reconnectInterval_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& reconnectInterval(unsigned value);

    static const int UseOsDefaultSocketBufferSize = -1;

    ONIXS_CONFLATEDTCP_NODISCARD
    int socketReceiveBufferSize() const {
        return socketReceiveBufferSize_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& socketReceiveBufferSize(int bufferSize);

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned reasonableTransmissionTime() const {
        return reasonableTransmissionTime_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& reasonableTransmissionTime(unsigned percentage);

    ONIXS_CONFLATEDTCP_NODISCARD
    int socketSendBufferSize() const {
        return socketSendBufferSize_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& socketSendBufferSize(int bufferSize);

    ONIXS_CONFLATEDTCP_NODISCARD
    const CpuIndexes & threadPoolAffinity() const {
        return threadPoolAffinity_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& threadPoolAffinity(const CpuIndexes & cpuIndexes);

    ONIXS_CONFLATEDTCP_NODISCARD
    int threadPoolPriority() const {
        return threadPoolPriority_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& threadPoolPriority(int priority);

    ONIXS_CONFLATEDTCP_NODISCARD
    int threadPoolPolicy() const {
        return threadPoolPolicy_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& threadPoolPolicy(int policy);

    ONIXS_CONFLATEDTCP_NODISCARD
    bool tcpNoDelayOption() const {
        return tcpNoDelayOption_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& tcpNoDelayOption(bool value);

    ONIXS_CONFLATEDTCP_NODISCARD
    unsigned threadPoolSize() const {
        return threadPoolSize_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& threadPoolSize(unsigned numberOfThreads);

    ONIXS_CONFLATEDTCP_EXPORTED ONIXS_CONFLATEDTCP_NODISCARD
    unsigned keepAliveInterval() const
    {
        return keepAliveInterval_;
    }

    ONIXS_CONFLATEDTCP_EXPORTED
    SessionSettings& keepAliveInterval(unsigned milliseconds);

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

    ONIXS_CONFLATEDTCP_EXPORTED ONIXS_CONFLATEDTCP_NODISCARD
    std::string toString() const;

    struct ONIXS_CONFLATEDTCP_EXPORTED Default {
        static const ThreadingModel::Enum ThreadingModelValue = ThreadingModel::DedicatedThreads;
        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 unsigned AsyncFileBasedStorageQueueMaxSize = UINT_MAX;
    };

    struct ONIXS_CONFLATEDTCP_EXPORTED Key {
        static const char * SessionId;                                      
        static const char * FirmId;                                         
        static const char * AccessKey;                                      
        static const char * SecretKey;                                      
 
        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;                               
    };
 
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_;
 
    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_;
};
 
}
}
}