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 <sstream>
#include <string>
#include <set>
#include <vector>

#include <OnixS/SgxTitan/MarketData/Itch/ABI.h>
#include <OnixS/SgxTitan/MarketData/Itch/Defines.h>
#include <OnixS/SgxTitan/MarketData/Itch/LogSettings.h>


ONIXS_SGXTITAN_ITCH_NAMESPACE_BEGIN

/// Service endpoint description
struct ServiceDescriptor
{
    ServiceDescriptor()
        : port (0)
    {}

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

    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 address != other.address || port != other.port;
    }

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

ONIXS_SGXTITAN_ITCH_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 serviceA != other.serviceA || serviceB != other.serviceB;
    }
};

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

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

struct HandlerSettings;

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

/// Handler configuration settings.
struct HandlerSettings
{
    /// Constructor.
    HandlerSettings()
            : licenseDirectory("")
            , logDirectory("logs")
            , logFileNamePrefix("SgxTitanItch")
            , logSettings(LogSettings::Default)
            , logLevel(LogLevel::Info)
            , logFilePermissions(LogFilePermission::Default)
            , heartbeatInterval(1)
            , outOfOrderPacketMaxInterval(3)
            , lostPacketWaitTime(100000)
            , useFeedA(true)
            , useFeedB(true)
            , maxRetransmissionResponseTime(30)
            , maxBooksObjectAmount(1000)
            , buildInternalOrderBooks(false)
            , maxPacketSize(1500)
            , maxConnectingAttempts(3)
            , minReconnectingTimeout(3)
            , retransmissionMaxPacketNumber(10000)
    {}

    /// 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 '1'.
    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;

    /// ITCH Live feed
    FeedDescriptor itchFeed;

    ///Retransmission feed
    FeedDescriptor retransmissionFeed;

    /// Maximum timeout to wait retransmission responses (sec), default value is 30 sec.
    unsigned int maxRetransmissionResponseTime;

    /// Defines size of prea-llocated memory for Order Book. Default value is 1000
    unsigned int maxBooksObjectAmount;

    /// Build internal books
    bool buildInternalOrderBooks;

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

    /// GLIMPSE feed
    FeedDescriptor glimpseFeed;

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

    /// Username assigned for GLIMPSE
    std::string glimpseUsername;

    /// Password assigned for GLIMPSE
    std::string glimpsePassword;

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

    /// Lost packets threshold when the Handler prefers retransmission
    unsigned int retransmissionMaxPacketNumber;

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

ONIXS_SGXTITAN_ITCH_NAMESPACE_END