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 <OnixS/Eurex/MarketData/ABI.h>
#include <OnixS/Eurex/MarketData/LogSettings.h>

#include <string>
#include <set>
#include <sstream>

namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            /// Service endpoint description
            struct ServiceDescriptor
            {
                ServiceDescriptor()
                    : port(0)
                {}

                /// Ip address
                std::string address;

                /// Port number
                unsigned port;


                /// clear config
                void clear()
                {
                    address.clear();
                    port = 0;
                }

                /// checks whether descriptor is empty
                bool empty() const
                {
                    return address.empty() || (port == 0);
                }

                /// Compares with another instance.
                bool operator == (const ServiceDescriptor& other) const
                {
                    return address == other.address && port == other.port;
                }

                /// Compares with another instance.
                bool operator != (const ServiceDescriptor& other) const
                {
                    return address != other.address || port != other.port;
                }
            };

            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const ServiceDescriptor& descriptor);

            /// Feed descriptor
            struct FeedDescriptor
            {
                /// Service A
                ServiceDescriptor serviceA;

                /// Service B
                ServiceDescriptor serviceB;

                /// clear config
                void clear()
                {
                    serviceA.clear();
                    serviceB.clear();
                }

                /// Compares with another instance.
                bool operator == (const FeedDescriptor& other) const
                {
                    return serviceA == other.serviceA && serviceB == other.serviceB;
                }

                /// Compares with another instance.
                bool operator != (const FeedDescriptor& other) const
                {
                    return serviceA != other.serviceA || serviceB != other.serviceB;
                }
            };

            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const FeedDescriptor& descriptor);

            /// Interface descriptor
            struct InterfaceDescriptor
            {
                FeedDescriptor incrementalFeed;
                FeedDescriptor snapshotFeed;
            };

            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const InterfaceDescriptor& descriptor);

            /// Handler base configuration settings.
            struct HandlerSettings
            {
                /// Constructor.
                HandlerSettings()
                    : licenseString("")
                    , licenseDirectory("")
                    , logDirectory("logs")
                    , logFileNamePrefix("log")
                    , logSettings(LogSettings::Default)
                    , logLevel(LogLevel::Info)
                    , useFeedA(true)
                    , useFeedB(true)
                    , heartbeatInterval(20)
                    , lostPacketWaitTime(500)
                    , outOfOrderPacketMaxInterval(3)
                    , messagePoolSize(512000)
                {
                }

                /// License string.
                std::string licenseString;

                /// Path to the license directory.
                std::string licenseDirectory;

                /// Log files are stored in this directory.
                std::string logDirectory;

                /// Template of log file name without extension.
                std::string logFileNamePrefix ;

                /// Combine LogSettings enum values to configure the logger.
                LogSettings::Enum logSettings;

                /// Log verbosity.
                ///
                /// @note The default value is LogLevel::Info
                LogLevel::Enum logLevel;

                /// Specifies one or more network interfaces to use while joining the multicast group;
                /// use semi-colon delimited list if more than one.
                ///
                /// On Linux the network interfaces is specified by its name, on Windows - by IP address.
                ///
                /// @note If the value is empty or absent then the default networking interface is used.
                std::string networkInterface;

                /// Specifies one or more network interfaces to use while joining the multicast group A;
                /// use semi-colon delimited list if more than one.
                ///
                /// On Linux the network interfaces is specified by its name, on Windows - by IP address.
                ///
                /// @note If the value is empty or absent then the networkInterface_ filled value is used.
                std::string networkInterfaceA;

                /// Specifies one or more network interfaces to use while joining the multicast group B;
                /// use semi-colon delimited list if more than one.
                ///
                /// On Linux the network interfaces is specified by its name, on Windows - by IP address.
                ///
                /// @note If the value is empty or absent then the networkInterface_ filled value is used.
                std::string networkInterfaceB;

                /// Option to use feed A.
                ///
                /// @note The default value is 'true'.
                bool useFeedA;

                /// Option to use feed B.
                ///
                /// @note The default value is 'true'.
                bool useFeedB;


                /// Specifies maximal time interval between two
                /// network packets. If no data is received during
                /// specified time frame, corresponding warning is raised.
                ///
                /// Interval is measured in seconds.
                ///
                /// @note The default value is '20'.
                unsigned int heartbeatInterval;

                /// Indicates for how long Handler should wait for
                /// the packet before it's considered as totally lost.
                ///
                /// Due to unreliable nature of multicast, data transmitted by the Eurex T7
                /// may come in order other than original or be completely lost. When
                /// Handler receives packet with sequence number greater than expected,
                /// it considers received data as out-of-order. If for a certain time
                /// interval Handler receives missing data, Handler resumes normal data
                /// processing. However, if no data is received for predefined time frame,
                /// Handler considers missing data as lost and raises packet gap event.
                /// Given parameter defines size of time interval Handler waits for missing
                /// data.
                /// @see 'outOfOrderPacketMaxInterval' parameter for more information.
                ///
                /// Time interval is measured in milliseconds.
                ///
                /// @note The default value is 500 milliseconds.
                unsigned int lostPacketWaitTime;

                /// Defines value of threshold used by Handler to differ
                /// out-of-order packets from gaps.
                ///
                /// Due to unreliable nature of multicast, packets transmitted by exchange
                /// may be received in the order different to original. To differ the
                /// case when Handler received out-of-order packets from the case when
                /// some of packets were completely lost, Handler uses given parameter.
                /// It defines size of interval for incoming packets starting from the
                /// last received. Packet is considered as out-of-order if its sequence
                /// number fits into interval [seqNumberOfLastReceivedPacket,
                /// seqNumberOfLastReceivedPacket + outOfOrderPacketsMaxInterval].
                /// In that case Handler waits for other packets to fulfill the incoming
                /// sequence. If received packet has greater sequence number than
                /// 'seqNumberOfLastReceivedPacket + outOfOrderPacketsMaxInterval',
                /// then Handler makes a decision on packets lost and gap is reported.
                ///
                /// @note When out-of-order packet is received, Handler makes a decision
                /// on data loss if either waiting time is over or if newly received packet
                /// has sequence number greater than 'seqNumberOfLastReceivedPacket +
                /// outOfOrderPacketMaxInterval'.
                ///
                /// @see 'lostPacketWaitTime' parameter for more information.
                ///
                /// @note The default value is '3'.
                unsigned int outOfOrderPacketMaxInterval;

                /// Defines size of buffer in bytes for message caching.
                ///
                /// @note Default value is 512000 bytes.
                unsigned int messagePoolSize;
            };

            struct RdiHandlerSettings;
            struct EmdiHandlerSettings;
            struct MdiHandlerSettings;
            struct EmdsHandlerSettings;

            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const RdiHandlerSettings& settings);
            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const EmdiHandlerSettings& settings);
            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const MdiHandlerSettings& settings);
            ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const EmdsHandlerSettings& settings);

            namespace EOBI
            {
                struct EobiHandlerSettings;
                ONIXS_EUREX_EMDI_API std::ostream& operator << (std::ostream& stream, const EobiHandlerSettings& settings);
            }

            /// RDI handler configuration settings.
            struct RdiHandlerSettings : public HandlerSettings
            {
                /// Constructor.
                RdiHandlerSettings()
                    : startRecoveryOnPacketGap(false)
                    , useFullSnapshotCycle(true)
                {
                    logFileNamePrefix = "OnixS.EurexRdiHandlerCpp";
                }

                /// Sets data interface technical configuration.
                InterfaceDescriptor interfaceDescriptor;

                /// Sets flag to start snasphot recovery on packet gap.
                ///
                /// @note Implementation of Pessimistic approach. Recovery is triggered immediately when observing
                /// a missing PacketSeqNum without
                /// decoding the entire message.
                bool startRecoveryOnPacketGap;

                /// Use full snapshot cycle.
                ///
                /// @note The default value is 'true'.
                bool useFullSnapshotCycle;

                /// Returns the string representation.
                std::string toString() const
                {
                    std::ostringstream out;
                    out << *this;
                    return out.str();
                }
            };

            /// EMDI handler configuration settings.
            struct EmdiHandlerSettings : public HandlerSettings
            {
                /// Constructor.
                EmdiHandlerSettings()
                    : buildInternalOrderBooks(true)
                    , startRecoveryOnPacketGap(false)
                {
                    logFileNamePrefix = "OnixS.EurexEmdiHandlerCpp";
                }

                /// Sets data interface technical configuration.
                InterfaceDescriptor interfaceDescriptor;

                /// Build internal books
                bool buildInternalOrderBooks;

                /// Sets flag to start snasphot recovery on packet gap.
                ///
                /// @note Implementation of Pessimistic approach. Recovery is triggered immediately when observing
                /// a missing PacketSeqNum without
                /// decoding the entire message.
                bool startRecoveryOnPacketGap;

                /// Returns the string representation.
                std::string toString() const
                {
                    std::ostringstream out;
                    out << *this;
                    return out.str();
                }
            };

            /// MDI handler configuration settings.
            struct MdiHandlerSettings : public HandlerSettings
            {
                /// Constructor.
                MdiHandlerSettings()
                    : buildInternalOrderBooks(true)
                    , startRecoveryOnPacketGap(false)
                {
                    logFileNamePrefix = "OnixS.EurexMdiHandlerCpp";
                }

                /// Sets data interface technical configuration.
                ///
                /// @note Snapshot feed is not used for MDI interface, parameters will be ignored.
                InterfaceDescriptor interfaceDescriptor;

                /// Build internal books
                bool buildInternalOrderBooks;

                /// Sets flag to start snasphot recovery on packet gap.
                ///
                /// @note Implementation of Pessimistic approach. Recovery is triggered immediately when observing
                /// a missing PacketSeqNum without
                /// decoding the entire message.
                bool startRecoveryOnPacketGap;

                /// Returns the string representation.
                std::string toString() const
                {
                    std::ostringstream out;
                    out << *this;
                    return out.str();
                }
            };

            /// EMDI handler configuration settings.
            struct EmdsHandlerSettings : public HandlerSettings
            {
                /// Constructor.
                EmdsHandlerSettings()
                {
                    logFileNamePrefix = "OnixS.EurexEmdsHandlerCpp";
                }

                /// Sets Settlement prices feed technical configuration.
                FeedDescriptor settlementFeedDescriptor;

                /// Sets Open Interest prices feed technical configuration.
                FeedDescriptor openInterestFeedDescriptor;

                /// Sets On-exchange trade prices feed technical configuration.
                FeedDescriptor exchangeTradeFeedDescriptor;

                /// Returns the string representation.
                std::string toString() const
                {
                    std::ostringstream out;
                    out << *this;
                    return out.str();
                }
            };

            namespace EOBI
            {
                /// EOBI handler configuration settings.
                struct EobiHandlerSettings : public HandlerSettings
                {
                    /// Constructor.
                    EobiHandlerSettings()
                    : HandlerSettings()
                        , buildInternalOrderBooks(true)
                        , startRecoveryOnPacketGap(false)
                        , maxBooksObjectAmount(100)
                        , bookDepth(10)
                    {
                        logFileNamePrefix = "OnixS.EurexEobiHandlerCpp";
                    }

                    /// Sets data interface technical configuration.
                    InterfaceDescriptor interfaceDescriptor;

                    /// Build internal books
                    bool buildInternalOrderBooks;

                    /// Sets flag to start snasphot recovery on packet gap.
                    ///
                    /// @note Implementation of Pessimistic approach. Recovery is triggered immediately when observing
                    /// a missing PacketSeqNum without
                    /// decoding the entire message.
                    bool startRecoveryOnPacketGap;

                    /// Defines size of preallocated memory for Order Book. Default value is 100
                    unsigned maxBooksObjectAmount;

                    /// Sets max book depth for order books. Default value is 10.
                    unsigned bookDepth;

                    /// Returns the string representation.
                    std::string toString() const
                    {
                        std::ostringstream out;
                        out << *this;
                        return out.str();
                    }
                };
            }
        }
    }
}