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

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

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

                    ///
                    ServiceDescriptor (const std::string& a, unsigned int port)
                        : address (a)
                        , port (port)
                    {}

                    ///
                    ServiceDescriptor (const ServiceDescriptor& descriptor)
                        : address (descriptor.address), port (descriptor.port)
                    {}

                    /// Ip address
                    std::string address;

                    /// Port number
                    unsigned port;

                    /// 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 !operator==(other);
                    }

                    /// Returns true if the descriptor points to valid ip address
                    bool valid() const
                    {
                        return !address.empty() && port > 0;
                    }
                };

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

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

                    /// Service B
                    ServiceDescriptor serviceB;

                    /// 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 !operator==(other);
                    }
                };

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

                /// Describse GTP services such as replay or recovery
                struct TcpServiceDescriptor : ServiceDescriptor
                {
                    ///
                    TcpServiceDescriptor() {}

                    /// 
                    TcpServiceDescriptor (
                            const std::string& addr, unsigned int port, const std::string& ssn)
                        : ServiceDescriptor(addr, port)
                        , session(ssn)
                    {}

                    ///
                    TcpServiceDescriptor (const TcpServiceDescriptor& other)
                        : ServiceDescriptor(other)
                        , session(other.session)
                    {}

                    /// Returns true if the descriptor is valid
                    bool valid() const
                    {
                        return
                            ServiceDescriptor::valid() && !session.empty();
                    }

                    /// Compares with another instance.
                    bool operator == (const TcpServiceDescriptor& other) const
                    {
                        return
                            ServiceDescriptor::operator==(other) && session == other.session;
                    }

                    /// Compares with another instance.
                    bool operator != (const TcpServiceDescriptor& other) const
                    {
                        return !operator==(other);
                    }

                    /// Session supplied by LSEG
                    std::string session;
                };

                ///
                ONIXS_EUROTLX_GTP_API std::ostream& operator << (std::ostream& stream, const TcpServiceDescriptor& descriptor);


                ///
                struct TcpFeedDescriptor
                {
                    /// Service A
                    TcpServiceDescriptor serviceA;

                    /// Service B
                    TcpServiceDescriptor serviceB;
                };

                ///
                ONIXS_EUROTLX_GTP_API std::ostream& operator << (std::ostream& stream, const TcpFeedDescriptor& descriptor);


                /// Alias for symbol list
                typedef std::set<std::string> Symbols;

                struct HandlerSettings;

                ONIXS_EUROTLX_GTP_API std::ostream& operator << (std::ostream& stream, const HandlerSettings& settings);

                /// Handler configuration settings.
                struct HandlerSettings
                {
                    /// Constructor.
                    HandlerSettings()
                        : licenseDirectory("")
                        , logDirectory("logs")
                        , logFileNamePrefix("EuroTlxGtp")
                        , logSettings(LogSettings::Default)
                        , logLevel(LogLevel::Info)
                        , logFilePermissions(LogFilePermission::Default)
                        , heartbeatInterval(3)
                        , outOfOrderPacketMaxInterval(3)
                        , lostPacketWaitTime(100000)
                        , useFeedA(true)
                        , useFeedB(true)
                        , maxPacketSize(1500)
                        , maxConnectingAttempts(3)
                        , minReconnectingTimeout(3)
                        , receivingTimeout(10)
                        , sendingTimeout(10)
                        , replayMaxPacketsNumber(65000)
                        , sequenceResetThreshold(5000)
                    {}

                    /// 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;

                    /// Log file permissions.
                    ///
                    /// @note The default value is ReadAll | WriteOwnerOnly
                    LogFilePermission::Enum logFilePermissions;

                    /**
                    * 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;

                    /// 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 '3'.
                    UInt32 heartbeatInterval;

                    /// 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'.
                    UInt32 outOfOrderPacketMaxInterval;
 
                    /// 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 MDP
                    /// 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.
                    ///
                    /// @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 'outOfOrderPacketMaxInterval' parameter for more information.
                    ///
                    /// Time interval is measured in microseconds (uSec).
                    ///
                    /// @note The default value is '100000' (100 milliseconds).
                    UInt32 lostPacketWaitTime;

                    /// 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;

                    /// Realtime feed
                    FeedDescriptor realtimeMulticastFeed;

                    /// Replay TCP service credentials
                    TcpFeedDescriptor replayTcpService;

                    /// Recovery TCP service credentials
                    TcpFeedDescriptor recoveryTcpService;

                    /**
                    * Specifies network interfaces to use while establishing tcp connection.
                    *
                    * 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 networkInterfaceForTcpServices;

                    /// Max size for network packet transmitted by GTP.
                    unsigned short maxPacketSize;

                    /// Max number of attempts to connect replay and recovery services, default value is 3
                    unsigned int maxConnectingAttempts;

                    /// Minimum timeout value between attempts to connect replay and recovery services (sec), default value is 3 sec.
                    unsigned int minReconnectingTimeout;

                    /// Minimum timeout value to wait for a response from replay and recovery services (sec), default value is 10 sec.
                    unsigned int receivingTimeout;

                    /// Heartbeat interval for sending packets to replay and recovery services (sec), default value is 10 sec.
                    unsigned int sendingTimeout;

                    /// Lost packets threshold when the Handler prefers replay, must not exceed 65000
                    unsigned int replayMaxPacketsNumber;

                    /// Threshold to detect sequence reset
                    unsigned int sequenceResetThreshold;

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

            }
        }
    }
}