HandlerSettings.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 <string>

#include <OnixS/CME/MDH/Domain.h>

#include <OnixS/CME/MDH/FeedSettings.h>
#include <OnixS/CME/MDH/SessionSettings.h>
#include <OnixS/CME/MDH/BookManagement.h>
#include <OnixS/CME/MDH/TradeProcessing.h>
#include <OnixS/CME/MDH/LoggingSettings.h>
#include <OnixS/CME/MDH/HandlerListeners.h>

#include <OnixS/CME/MDH/SettingGroup.h>

ONIXS_CMEMDH_NAMESPACE_BEGIN

/// License configuration settings.
class ONIXS_CMEMDH_LTWT LicenseSettings : public SettingGroup
{
public:
    /// Folders that contain license file(s).
    typedef std::vector<std::string> LicenseStores;

    /// Initializes listeners with default values.
    LicenseSettings(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
    {
    }

    /// Re-initializes settings as copies of
    /// the other ones omitting group belonging.
    LicenseSettings(const LicenseSettings& other)
        : SettingGroup()
        , stores_(other.stores_)
        , licenseString_(other.licenseString_)
    {
    }

    /// Adds the path to the folder that contains license file(s).
    LicenseSettings& addLicenseStore(const std::string& value)
    {
        LicenseStores stores = stores_;
        stores.push_back(value);

        controlAssignment("License Store", stores_, stores);
        return *this;
    }

    /// Assigns the path to the folder that contains license file(s).
    LicenseSettings& licenseStore(const std::string& value)
    {
        LicenseStores stores;
        stores.push_back(value);

        controlAssignment("License Store", stores_, stores);
        return *this;
    }

    /// Assigns the license string.
    LicenseSettings& licenseString(const std::string& value)
    {
        controlAssignment("License String", licenseString_, value);
        return *this;
    }

    /// Returns the folders that contain license file(s).
    const LicenseStores& licenseStores() const
    {
        return stores_;
    }

    /// Returns the license string.
    const std::string& licenseString() const
    {
        return licenseString_;
    }

    /// Re-initializes as a copy of the other one.
    LicenseSettings& operator=(const LicenseSettings& other)
    {
        controlChange("Handler Settings", &LicenseSettings::assignNoControl, *this, other);

        return *this;
    }

private:
    void assignNoControl(const LicenseSettings& other)
    {
        stores_ = other.stores_;
        licenseString_ = other.licenseString_;
    }

    LicenseStores stores_;
    std::string licenseString_;

    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(HandlerSettings);
};

/// Handler's configuration settings.
class ONIXS_CMEMDH_LTWT HandlerSettings : public SettingGroup
{
public:
    /// Initializes parameters with default values.
    HandlerSettings(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
        , channel_(0)
        , feeds_(controller)
        , session_(controller)
        , tradeProcessing_(TradeProcessing::SummaryLevel)
        , bookManagement_(controller)
        , recoveryQueueMaxSize_(1000000)
        , instrumentCache_()
        , logging_(controller)
        , listeners_(controller)
        , licenseSettings_(controller)
        , dataCenter_(DataCenter::Primary)

    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    HandlerSettings(const HandlerSettings& other)
        : SettingGroup()
        , channel_(other.channel_)
        , feeds_(other.feeds_)
        , session_(other.session_)
        , tradeProcessing_(other.tradeProcessing_)
        , bookManagement_(other.bookManagement_)
        , recoveryQueueMaxSize_(other.recoveryQueueMaxSize_)
        , instrumentCache_(other.instrumentCache_)
        , logging_(other.logging_)
        , listeners_(other.listeners_)
        , licenseSettings_(other.licenseSettings_)
        , configurationFile_(other.configurationFile_)
        , dataCenter_(other.dataCenter_)
    {
    }

    /// Cleans everything up.
    ~HandlerSettings() {}

    /// Identifies CME market data channel.
    ChannelId channel() const
    {
        return channel_;
    }

    /// Identifies CME market data channel.
    HandlerSettings& channel(ChannelId value)
    {
        controlAssignment("Channel Id", channel_, value);

        return *this;
    }


    /// Path to the connectivity configuration file.
    const std::string& connectivityConfigurationFile() const
    {
        return configurationFile_;
    }

    /// Identifies the data center whose parameters are to
    /// be extracted from the connectivity configuration file.
    ///
    /// The connectivity configuration file may not include
    /// attributes for all kinds of data centers.
    DataCenter::Enum dataCenter() const
    {
        return dataCenter_;
    }

    /// Path to the connectivity configuration file from which
    /// to load feed connection settings.
    ///
    /// The given parameter allows retrieving connectivity settings
    /// from the connectivity configuration file published by CME
    /// instead of manual setup.
    ///
    /// \warning The given parameter has lower priority comparing
    /// to feed connection settings. E.g., if connection parameters
    /// are manually set up for any of feeds, the Handler will use
    /// those parameters to connect to or join multicast groups.
    /// The given parameter value is ignored in such a case and thus
    /// connectivity configuration is not loaded from the specified
    /// file.
    ///
    /// For certain environments CME provides additional data
    /// centers to be used in case of a disaster. The additional
    /// parameter allows specifying whether to load connection
    /// settings for either the primary or a disaster recovery
    /// data center.
    HandlerSettings& connectivityConfigurationFile(
        const std::string& configurationFile,
        DataCenter::Enum dataCenter = DataCenter::Primary
    )
    {
        controlChange(
            "Connectivity Configuration File",
            &HandlerSettings::assignConnectivityConfiguration,
            *this,
            configurationFile,
            dataCenter
        );

        return *this;
    }

    /// Reference to parameters related with feeds.
    const FeedSettings& feeds() const
    {
        return feeds_;
    }

    /// Reference to parameters related with feeds.
    FeedSettings& feeds()
    {
        return feeds_;
    }

    /// Settings affecting processing session.
    SessionSettings& session()
    {
        return session_;
    }

    /// Settings affecting processing session.
    const SessionSettings& session() const
    {
        return session_;
    }

    /// Listeners associated with the Handler.
    HandlerListeners& listeners()
    {
        return listeners_;
    }

    /// Listeners associated with the Handler.
    const HandlerListeners& listeners() const
    {
        return listeners_;
    }

    /// Indicates how trades are processed.
    TradeProcessing::Enum tradeProcessing() const
    {
        return tradeProcessing_;
    }

    /// Defines how trades are processed.
    HandlerSettings& tradeProcessing(TradeProcessing::Enum strategy)
    {
        controlAssignment("Trade Processing Strategy", tradeProcessing_, strategy);

        return *this;
    }

    /// Reference to parameters affecting book management.
    const BookManagement& bookManagement() const
    {
        return bookManagement_;
    }

    /// Reference to parameters affecting book management.
    BookManagement& bookManagement()
    {
        return bookManagement_;
    }

    /// Maximum number of packets transmitted via
    /// incremental feed to be hold in internal queue
    /// while market state is recovered from snapshots.
    ///
    /// When Handler recovers order books from snapshots,
    /// the given parameter limits the size of the internal
    /// queue used by the Handler to keep packets coming from
    /// incremental feeds. Upon reaching limit, newer packets
    /// substitute older ones.
    ///
    /// @note The default value is 1000000.
    UInt32 recoveryQueueMaxSize() const
    {
        return recoveryQueueMaxSize_;
    }

    /// Maximum number of packets to be hold in the internal
    /// queue used by the Handler while processing incoming data.
    HandlerSettings& recoveryQueueMaxSize(UInt32 queueMaxSize)
    {
        controlAssignment("Recovery Queue Max Size", recoveryQueueMaxSize_, queueMaxSize);

        return *this;
    }

    /// Path to the file where the Handler
    /// must store security definitions for
    /// further use instead of a live instrument
    /// feed while recovering definitions due
    /// to late join.
    ///
    /// If path is not defined, the Handler
    /// will not cache instrument definitions.
    ///
    /// @note The default value is empty string.
    ///
    /// @warning If this option is activated, then
    /// it is recommended to remove the cache file
    /// weekly to start the trading week with the
    /// fresh copy of security definitions.
    const std::string& instrumentCache() const
    {
        return instrumentCache_;
    }

    /// Defines path to a file to be used as instrument definition cache.
    ///
    /// Instrument definition cache is used to recover instrument
    /// definitions at the beginning of market data processing session
    /// without connecting to live instrument recovery feeds. Later,
    /// the Handler puts the incoming instrument definitions received
    /// via incremental feeds into the given file.
    ///
    /// @note The Handler may recover instrument definitions stored
    /// in FIX (tag=value) format in a 'secdef.dat' file exposed by
    /// the CME via public FTP. However, the file won't be updated
    /// during further market data processing.
    HandlerSettings& instrumentCache(const std::string& filename)
    {
        controlAssignment("Instrument Cache Path", instrumentCache_, filename);

        return *this;
    }

    /// Settings affecting logging.
    LoggingSettings& logging()
    {
        return logging_;
    }

    /// Settings affecting logging.
    const LoggingSettings& logging() const
    {
        return logging_;
    }

    /// Settings affecting licensing.
    LicenseSettings& licenseSettings()
    {
        return licenseSettings_;
    }

    /// Settings affecting licensing.
    const LicenseSettings& licenseSettings() const
    {
        return licenseSettings_;
    }

#if !defined(ONIXS_CMEMDH_NO_DEPRECATED)

    /// Parameters affecting logging at debug level.
    ///
    /// @warning The given member is deprecated.
    /// Use logging().debug() member to manipulate
    /// parameters affecting the debug level output.
    HandlerDebugLoggingSettings& debugLogging()
    {
        return logging_.debug();
    }

    /// Parameters affecting logging at debug level.
    ///
    /// @warning The given member is deprecated.
    /// Use logging().debug() member to manipulate
    /// parameters affecting the debug level output.
    const HandlerDebugLoggingSettings& debugLogging() const
    {
        return logging_.debug();
    }

#endif // ONIXS_CMEMDH_NO_DEPRECATED

    /// Re-initializes as a copy of the other one.
    HandlerSettings& operator=(const HandlerSettings& other)
    {
        controlChange("Handler Settings", &HandlerSettings::assignNoControl, *this, other);

        return *this;
    }

private:
    ChannelId channel_;

    FeedSettings feeds_;

    SessionSettings session_;

    TradeProcessing::Enum tradeProcessing_;
    BookManagement bookManagement_;

    UInt32 recoveryQueueMaxSize_;
    std::string instrumentCache_;

    LoggingSettings logging_;

    HandlerListeners listeners_;

    LicenseSettings licenseSettings_;

    std::string configurationFile_;

    DataCenter::Enum dataCenter_;

    void assignNoControl(const HandlerSettings& other)
    {
        channel_ = other.channel_;

        feeds_.assignNoControl(other.feeds_);

        session_.assignNoControl(other.session_);

        tradeProcessing_ = other.tradeProcessing_;

        bookManagement_.assignNoControl(other.bookManagement_);

        recoveryQueueMaxSize_ = other.recoveryQueueMaxSize_;

        instrumentCache_ = other.instrumentCache_;

        logging_.assignNoControl(other.logging_);

        listeners_.assignNoControl(other.listeners_);

        licenseSettings_.assignNoControl(other.licenseSettings_);

        configurationFile_ = other.configurationFile_;

        dataCenter_ = other.dataCenter_;
    }

    /// Loads connectivity parameters from the given configuration file.
    void assignConnectivityConfiguration(const std::string& configurationFile, DataCenter::Enum dataCenter)
    {
        configurationFile_ = configurationFile;

        dataCenter_ = dataCenter;
    }
};

/// Serializes BBA tracking parameters into string.
ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const HandlerSettings&);

/// Serializes BBA tracking parameters into string.
inline std::string toStr(const HandlerSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

/// Makes filename for instrument cache for the given channel.
ONIXS_CMEMDH_EXPORTED
std::string makeInstrumentCacheFilename(ChannelId);

ONIXS_CMEMDH_NAMESPACE_END