FeedSettings.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/MDH/Domain.h>
#include <OnixS/CME/MDH/messaging/Integral.h>
#include <OnixS/CME/MDH/PacketTraits.h>
#include <OnixS/CME/MDH/SettingGroup.h>
 
#include <OnixS/CME/MDH/Auxiliary/DeprecatedHeaderWarnings.Disable.h>
#include <OnixS/CME/MDH/Integral.h>
#include <OnixS/CME/MDH/Auxiliary/DeprecatedHeaderWarnings.Restore.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN
 
// A bit of forward declarations.
 
ONIXS_CMEMDH_EXPORTED_CLASS_DECL(NetFeedEngine);

typedef ListSetting<std::string> HostListSetting;

typedef HostListSetting NifListSetting;

ONIXS_CMEMDH_EXPORTED
void fromStr(HostListSetting&, const std::string&);

class ONIXS_CMEMDH_LTWT FeedConnectionSettings
{
public:
    // Makes assignment more flexible.
    template <class>
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(FeedSettingsBase);

    FeedConnectionSettings(const SettingGroup* group = nullptr)
        : group_(group ? *group : SettingGroup::null())
        , port_(0)
        , hosts_(group)
        , nifs_(group)
    {
    }

    FeedConnectionSettings(const FeedConnectionSettings& other)
        : group_(SettingGroup::null())
        , port_(other.port_)
        , ip_(other.ip_)
        , hosts_(other.hosts_)
        , nifs_(other.nifs_)
        , id_(other.id_)
    {
    }

    ~FeedConnectionSettings() {}

    Messaging::UInt32 port() const
    {
        return port_;
    }

    FeedConnectionSettings& port(Messaging::UInt32 port)
    {
        group_.controlAssignment("Port", port_, port);
 
        return *this;
    }

    const std::string& ip() const
    {
        return ip_;
    }

    FeedConnectionSettings& ip(const std::string& address)
    {
        group_.controlAssignment("IP Address", ip_, address);
 
        return *this;
    }

    const HostListSetting& hosts() const
    {
        return hosts_;
    }

    HostListSetting& hosts()
    {
        return hosts_;
    }

    FeedConnectionSettings& hosts(const std::string& hosts)
    {
        fromStr(hosts_, hosts);
 
        return *this;
    }

    const NifListSetting& networkInterfaces() const
    {
        return nifs_;
    }

    NifListSetting& networkInterfaces()
    {
        return nifs_;
    }

    FeedConnectionSettings& networkInterfaces(const std::string& interfaces)
    {
        fromStr(nifs_, interfaces);
 
        return *this;
    }

    const std::string& id() const
    {
        return id_;
    }

    FeedConnectionSettings& id(const std::string& id)
    {
        group_.controlAssignment("Identifier", id_, id);
 
        return *this;
    }

    FeedConnectionSettings& operator=(const FeedConnectionSettings& other)
    {
        group_.controlChange("Feed Connection Settings", &FeedConnectionSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    const SettingGroup& group_;
 
    Messaging::UInt32 port_;
    std::string ip_;
 
    HostListSetting hosts_;
    NifListSetting nifs_;
 
    std::string id_;
 
    // Non-guarded assignment.
    void assignNoControl(const FeedConnectionSettings& other)
    {
        port_ = other.port_;
        ip_ = other.ip_;
 
        hosts_.assignNoControl(other.hosts_);
        nifs_.assignNoControl(other.nifs_);
 
        id_ = other.id_;
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const FeedConnectionSettings&);

inline std::string toStr(const FeedConnectionSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

template <typename Layout>
class FeedSettingsBase
{
public:
    Layout layout() const
    {
        return layout_;
    }

    FeedSettingsBase& layout(Layout value)
    {
        group_.controlAssignment("Layout", layout_, value);
 
        return *this;
    }

    Messaging::UInt32 heartbeatInterval() const
    {
        return heartbeatInterval_;
    }

    FeedSettingsBase& heartbeatInterval(Messaging::UInt32 interval)
    {
        group_.controlAssignment("Heartbeat Interval", heartbeatInterval_, interval);
 
        return *this;
    }

    FeedConnectionSettings& A()
    {
        return A_;
    }

    const FeedConnectionSettings& A() const
    {
        return A_;
    }

    FeedConnectionSettings& B()
    {
        return B_;
    }

    const FeedConnectionSettings& B() const
    {
        return B_;
    }
 
#if !defined(ONIXS_CMEMDH_NO_DEPRECATED)

    FeedSettingsBase& feedANetworkInterfaces(const std::string& interfaces)
    {
        A_.networkInterfaces(interfaces);
 
        return *this;
    }

    FeedSettingsBase& feedBNetworkInterfaces(const std::string& interfaces)
    {
        B_.networkInterfaces(interfaces);
 
        return *this;
    }
#endif // !ONIXS_CMEMDH_NO_DEPRECATED
 
protected:
    // Makes assignment more flexible.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(FeedSettings);

    FeedSettingsBase(const SettingGroup* group, Layout layout, Messaging::UInt32 heartbeat)
        : group_(group ? *group : SettingGroup::null())
        , layout_(layout)
        , heartbeatInterval_(heartbeat)
        , A_(group)
        , B_(group)
    {
    }

    FeedSettingsBase(const FeedSettingsBase& other)
        : group_(SettingGroup::null())
        , layout_(other.layout_)
        , heartbeatInterval_(other.heartbeatInterval_)
        , A_(other.A_)
        , B_(other.B_)
    {
    }
 
    // Finalizes the instance.
    ~FeedSettingsBase() {}

    const SettingGroup& group() const
    {
        return group_;
    }

    void assignNoControl(const FeedSettingsBase& other)
    {
        layout_ = other.layout_;
 
        heartbeatInterval_ = other.heartbeatInterval_;
 
        A_.assignNoControl(other.A_);
        B_.assignNoControl(other.B_);
    }
 
private:
    const SettingGroup& group_;
 
    Layout layout_;
    Messaging::UInt32 heartbeatInterval_;
 
    FeedConnectionSettings A_;
    FeedConnectionSettings B_;
 
    FeedSettingsBase& operator=(const FeedSettingsBase& other);
};

struct ONIXS_CMEMDH_LTWT RecoveryFeedLayout
{
    typedef Messaging::UInt32 Base;
 
    enum Enum
    {
        FeedAOnly,

        FeedBOnly,

        FeedAWithFailoverToFeedB,

        FeedBWithFailoverToFeedA
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, RecoveryFeedLayout::Enum);

inline std::string toStr(RecoveryFeedLayout::Enum layout)
{
    std::string str;
 
    toStr(str, layout);
 
    return str;
}

class ONIXS_CMEMDH_LTWT MulticastRecoveryFeedSettings : public FeedSettingsBase<RecoveryFeedLayout::Enum>
{
public:
    MulticastRecoveryFeedSettings(const SettingGroup* group = nullptr)
        : Base(group, RecoveryFeedLayout::FeedAWithFailoverToFeedB, 30)
    {
    }

    MulticastRecoveryFeedSettings(const MulticastRecoveryFeedSettings& other)
        : Base(static_cast<const Base&>(other))
    {
    }

    ~MulticastRecoveryFeedSettings() {}

    MulticastRecoveryFeedSettings& operator=(const MulticastRecoveryFeedSettings& other)
    {
        group().controlChange(
            "Multicast Recovery Feed Settings", &MulticastRecoveryFeedSettings::assignNoControl, *this, other
        );
 
        return *this;
    }
 
private:
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(FeedSettings);
 
    typedef FeedSettingsBase<RecoveryFeedLayout::Enum> Base;
 
    void assignNoControl(const MulticastRecoveryFeedSettings& other)
    {
        Base::assignNoControl(other);
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const MulticastRecoveryFeedSettings&);

inline std::string toStr(const MulticastRecoveryFeedSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

class ONIXS_CMEMDH_LTWT TcpRecoveryFeedSettings : public FeedSettingsBase<RecoveryFeedLayout::Enum>
{
public:
    TcpRecoveryFeedSettings(const SettingGroup* group = nullptr)
        : Base(group, RecoveryFeedLayout::FeedAOnly, 2)
        , connectionAttempts_(3)
        , connectionTimeout_(500)
        , sendTimeout_(5000)
    {
    }

    TcpRecoveryFeedSettings(const TcpRecoveryFeedSettings& other)
        : Base(static_cast<const Base&>(other))
        , connectionAttempts_(other.connectionAttempts_)
        , connectionTimeout_(other.connectionTimeout_)
        , sendTimeout_(other.sendTimeout_)
    {
    }

    ~TcpRecoveryFeedSettings() {}

    Messaging::UInt32 connectionAttempts() const
    {
        return connectionAttempts_;
    }

    TcpRecoveryFeedSettings& connectionAttempts(Messaging::UInt32 attemptQty)
    {
        group().controlAssignment("Connection Attempts", connectionAttempts_, attemptQty);
 
        return *this;
    }

    Messaging::UInt32 connectionTimeout() const
    {
        return connectionTimeout_;
    }

    TcpRecoveryFeedSettings& connectionTimeout(Messaging::UInt32 connectionTimeout)
    {
        group().controlAssignment("Connection Timeout", connectionTimeout_, connectionTimeout);
 
        return *this;
    }

    Messaging::UInt32 sendTimeout() const
    {
        return sendTimeout_;
    }

    TcpRecoveryFeedSettings& sendTimeout(Messaging::UInt32 sendTimeout)
    {
        group().controlAssignment("Send Timeout", sendTimeout_, sendTimeout);
 
        return *this;
    }

    TcpRecoveryFeedSettings& operator=(const TcpRecoveryFeedSettings& other)
    {
        group().controlChange("TCP Recovery Feed Settings", &TcpRecoveryFeedSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    // Makes assignment more flexible.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(FeedSettings);
 
    typedef FeedSettingsBase<RecoveryFeedLayout::Enum> Base;
 
    Messaging::UInt32 connectionAttempts_;
    Messaging::UInt32 connectionTimeout_;
    Messaging::UInt32 sendTimeout_;
 
    void assignNoControl(const TcpRecoveryFeedSettings& other)
    {
        Base::assignNoControl(other);
 
        connectionAttempts_ = other.connectionAttempts_;
 
        connectionTimeout_ = other.connectionTimeout_;
 
        sendTimeout_ = other.sendTimeout_;
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const TcpRecoveryFeedSettings&);

inline std::string toStr(const TcpRecoveryFeedSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

struct ONIXS_CMEMDH_LTWT RealtimeFeedLayout
{
    typedef Messaging::UInt32 Base;
 
    enum Enum
    {
        FeedAOnly,

        FeedBOnly,

        FeedAWithFailoverToFeedB,

        FeedBWithFailoverToFeedA,

        BothFeedsWithArbitrage
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, RealtimeFeedLayout::Enum);

inline std::string toStr(RealtimeFeedLayout::Enum layout)
{
    std::string str;
 
    toStr(str, layout);
 
    return str;
}

class ONIXS_CMEMDH_LTWT RealtimeFeedSettings : public FeedSettingsBase<RealtimeFeedLayout::Enum>
{
public:
    RealtimeFeedSettings(const SettingGroup* group = nullptr)
        : Base(group, RealtimeFeedLayout::BothFeedsWithArbitrage, 30)
        , outOfOrderPacketMaxInterval_(3)
        , lostPacketWaitTime_(100000)
    {
    }

    RealtimeFeedSettings(const RealtimeFeedSettings& other)
        : Base(static_cast<const Base&>(other))
        , outOfOrderPacketMaxInterval_(other.outOfOrderPacketMaxInterval_)
        , lostPacketWaitTime_(other.lostPacketWaitTime_)
    {
    }

    ~RealtimeFeedSettings() {}

    Messaging::UInt32 outOfOrderPacketMaxInterval() const
    {
        return outOfOrderPacketMaxInterval_;
    }

    RealtimeFeedSettings& outOfOrderPacketMaxInterval(Messaging::UInt32 intervalLength)
    {
        group().controlAssignment("Out Of Order Packet Max Interval", outOfOrderPacketMaxInterval_, intervalLength);
 
        return *this;
    }

    Messaging::UInt32 lostPacketWaitTime() const
    {
        return lostPacketWaitTime_;
    }

    RealtimeFeedSettings& lostPacketWaitTime(Messaging::UInt32 waitTime)
    {
        group().controlAssignment("Lost Packet Wait Time", lostPacketWaitTime_, waitTime);
 
        return *this;
    }

    RealtimeFeedSettings& operator=(const RealtimeFeedSettings& other)
    {
        group().controlChange("Realtime Feed Settings", &RealtimeFeedSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(FeedSettings);
 
    typedef FeedSettingsBase<RealtimeFeedLayout::Enum> Base;
 
    Messaging::UInt32 outOfOrderPacketMaxInterval_;
    Messaging::UInt32 lostPacketWaitTime_;
 
    void assignNoControl(const RealtimeFeedSettings& other)
    {
        Base::assignNoControl(other);
 
        outOfOrderPacketMaxInterval_ = other.outOfOrderPacketMaxInterval_;
 
        lostPacketWaitTime_ = other.lostPacketWaitTime_;
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const RealtimeFeedSettings&);

inline std::string toStr(const RealtimeFeedSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

struct ONIXS_CMEMDH_LTWT DataCenter
{
    typedef Messaging::UInt32 Base;

    enum Enum
    {
        Primary,

        DisasterRecovery
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, DataCenter::Enum);

inline std::string toStr(DataCenter::Enum layout)
{
    std::string str;
 
    toStr(str, layout);
 
    return str;
}

class ONIXS_CMEMDH_LTWT FeedSettings : public SettingGroup
{
public:
    FeedSettings(SettingChangeController* controller = nullptr)
        : SettingGroup(controller)
        , packetMaxSize_(1420)
        , incrementalFeeds_(&group())
        , instrumentFeeds_(&group())
        , snapshotFeeds_(&group())
        , mboSnapshotFeeds_(&group())
        , historicalFeeds_(&group())
        , engine_()
    {
    }

    FeedSettings(const FeedSettings& other)
        : SettingGroup()
        , packetMaxSize_(other.packetMaxSize_)
        , incrementalFeeds_(other.incrementalFeeds_)
        , instrumentFeeds_(other.instrumentFeeds_)
        , snapshotFeeds_(other.snapshotFeeds_)
        , mboSnapshotFeeds_(other.mboSnapshotFeeds_)
        , historicalFeeds_(other.historicalFeeds_)
        , engine_(other.engine_)
    {
    }

    FeedSettings& feedANetworkInterfaces(const std::string& interfaces)
    {
        group().controlChange(
            "Feed A Network Interfaces for All Feeds", &FeedSettings::assignFeedAInterfaces, *this, interfaces
        );
 
        return *this;
    }

    FeedSettings& feedBNetworkInterfaces(const std::string& interfaces)
    {
        group().controlChange(
            "Feed B Network Interfaces for All Feeds", &FeedSettings::assignFeedBInterfaces, *this, interfaces
        );
 
        return *this;
    }

    PacketSize packetMaxSize() const
    {
        return packetMaxSize_;
    }

    FeedSettings& packetMaxSize(PacketSize value)
    {
        group().controlAssignment("Packet Max Size", packetMaxSize_, value);
 
        return *this;
    }

    const RealtimeFeedSettings& incrementalFeeds() const
    {
        return incrementalFeeds_;
    }

    RealtimeFeedSettings& incrementalFeeds()
    {
        return incrementalFeeds_;
    }

    const MulticastRecoveryFeedSettings& instrumentFeeds() const
    {
        return instrumentFeeds_;
    }

    MulticastRecoveryFeedSettings& instrumentFeeds()
    {
        return instrumentFeeds_;
    }

    const MulticastRecoveryFeedSettings& snapshotFeeds() const
    {
        return snapshotFeeds_;
    }

    MulticastRecoveryFeedSettings& snapshotFeeds()
    {
        return snapshotFeeds_;
    }

    const MulticastRecoveryFeedSettings& mboSnapshotFeeds() const
    {
        return mboSnapshotFeeds_;
    }

    MulticastRecoveryFeedSettings& mboSnapshotFeeds()
    {
        return mboSnapshotFeeds_;
    }

    const TcpRecoveryFeedSettings& historicalFeeds() const
    {
        return historicalFeeds_;
    }

    TcpRecoveryFeedSettings& historicalFeeds()
    {
        return historicalFeeds_;
    }

    NetFeedEngine* engine() const
    {
        return engine_.get();
    }

    FeedSettings& engine(NetFeedEngine* engine)
    {
        group().controlAssignment("Feed Engine", engine_, NetFeedEngineController(engine));
 
        return *this;
    }

    FeedSettings& operator=(const FeedSettings& other)
    {
        group().controlChange("Feed Settings", &FeedSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(PcapReplayHelper);
 
    // To let assignment be controlled
    // by the master container.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(HandlerSettings);

    class ONIXS_CMEMDH_EXPORTED NetFeedEngineController
    {
    public:
        NetFeedEngineController();

        explicit NetFeedEngineController(NetFeedEngine*);

        NetFeedEngineController(const NetFeedEngineController&);

        ~NetFeedEngineController();

        NetFeedEngineController& operator=(const NetFeedEngineController& other)
        {
            NetFeedEngineController tmp(other);
            tmp.swap(*this);
            return *this;
        }

        NetFeedEngine* get() const
        {
            return engine_;
        }

        void swap(NetFeedEngineController& other)
        {
            std::swap(engine_, other.engine_);
            std::swap(owned_, other.owned_);
        }
 
    private:
        NetFeedEngine* engine_;
        bool owned_;
    };
 
    PacketSize packetMaxSize_;
 
    RealtimeFeedSettings incrementalFeeds_;
 
    MulticastRecoveryFeedSettings instrumentFeeds_;
    MulticastRecoveryFeedSettings snapshotFeeds_;
    MulticastRecoveryFeedSettings mboSnapshotFeeds_;
 
    TcpRecoveryFeedSettings historicalFeeds_;
 
    NetFeedEngineController engine_;
 
    // Casts the given instance to an
    // instance of SettingGroup class.
    const SettingGroup& group() const
    {
        return *this;
    }
 
    // Re-initializes the given instance
    // as a copy of the other one without
    // involving assignment control service.
    void assignNoControl(const FeedSettings& other)
    {
        packetMaxSize_ = other.packetMaxSize_;
 
        incrementalFeeds_.assignNoControl(other.incrementalFeeds_);
 
        instrumentFeeds_.assignNoControl(other.instrumentFeeds_);
 
        snapshotFeeds_.assignNoControl(other.snapshotFeeds_);
 
        mboSnapshotFeeds_.assignNoControl(other.mboSnapshotFeeds_);
 
        historicalFeeds_.assignNoControl(other.historicalFeeds_);
 
        engine_ = other.engine_;
    }
 
    // Updates interfaces for all primary feeds
    // without involving assignment control services.
    void assignFeedAInterfaces(const std::string& interfaces)
    {
        NifListSetting nifs;
 
        fromStr(nifs, interfaces);
 
        incrementalFeeds_.A().networkInterfaces().assignNoControl(nifs);
 
        instrumentFeeds_.A().networkInterfaces().assignNoControl(nifs);
 
        snapshotFeeds_.A().networkInterfaces().assignNoControl(nifs);
 
        mboSnapshotFeeds_.A().networkInterfaces().assignNoControl(nifs);
 
        historicalFeeds_.A().networkInterfaces().assignNoControl(nifs);
    }
 
    // Updates interfaces for all primary feeds
    // without involving assignment control services.
    void assignFeedBInterfaces(const std::string& interfaces)
    {
        NifListSetting nifs;
 
        fromStr(nifs, interfaces);
 
        incrementalFeeds_.B().networkInterfaces().assignNoControl(nifs);
 
        instrumentFeeds_.B().networkInterfaces().assignNoControl(nifs);
 
        snapshotFeeds_.B().networkInterfaces().assignNoControl(nifs);
 
        mboSnapshotFeeds_.B().networkInterfaces().assignNoControl(nifs);
 
        historicalFeeds_.B().networkInterfaces().assignNoControl(nifs);
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const FeedSettings&);

inline std::string toStr(const FeedSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

ONIXS_CMEMDH_EXPORTED
void connectivityFromConfiguration(
    FeedSettings&,
    const std::string&,
    ChannelId,
    DataCenter::Enum = DataCenter::Primary
);
 
ONIXS_CMEMDH_NAMESPACE_END