HandlerImpl.h

Go to the documentation of this file.

#pragma once

/*
* 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. 
*/
#include <licensing/LicenseChecker.h>

#include <OnixS/HandlerCore/MulticastFeedHandler.h>

#include <OnixS/ItchCore/Types.h>

#include <OnixS/SgxTitan/MarketData/Itch/ErrorListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/Handler.h>
#include <OnixS/SgxTitan/MarketData/Itch/HandlerSettings.h>
#include <OnixS/ItchCore/MoldUDP64/PacketProcessor.h>


#include "RetransmissionPacketProcessor.h"
#include "GlimpsePacketProcessor.h"

#include "NamespaceHelper.h"

namespace OnixS {

namespace HandlerCore { namespace Common {
    class HandlerLogger;
}}

namespace ItchCore { namespace MoldUDP64 {
    class RetransmissionService;
}}

}

ONIXS_HANDLER_NAMESPACE_BEGIN

struct ReplayOptions;
class GlimpseService;

class ListenerHolder;
class MessageRepository;
class OrderBookAllocator;


class HandlerImpl;
typedef OnixS::ItchCore::MoldUDP64::PacketProcessor<HandlerImpl> RealtimePacketProcessor;

class HandlerImpl : public Licensing::LicenseChecker, public HandlerCore::MarketData::MulticastFeedHandler
{
    typedef HandlerCore::MarketData::MulticastFeedHandler base;

public:
    explicit
    HandlerImpl(const HandlerSettings & settings);

    virtual ~HandlerImpl();
    
    void bindFeedEngine(FeedEngine& feedEngine);

    /// Start handler.
    void start();

    /// Starts replaying previously logged data.
    void start(const ReplayOptions& options);

    /// Stop handler.
    void stop(bool wait);

    /// Returns commons services as shared object.
    ListenerHolder& listenerHolder();

    /// Invoke helpers
    void invokeError(const std::string& description) override;
    void invokeWarning(const std::string& description) override;

    /// User's common log 
    void commonLog (int logLevel, const char * msg, size_t length);

    void setOrderBookIdFilter(const std::set<OrderBookId>& orderBookIdFilter);

protected:
    virtual void onStateChanged(State::Enum newState);
    void onPrepareLogPlayer(HandlerCore::Common::LogPlayer* logPlayer);
    bool parseGlimpseStart(const std::string& logLine, HandlerCore::Common::LogEntry&);

private:
    void onStarting() override;
    void onStopping() override;

    void initLogger(const HandlerSettings &settings);
    static std::string os();

    void onPacket(OnixS::HandlerCore::MarketData::FE::PacketContainer& packetContainer, bool fromCache);
    void onHeartbeat(OnixS::HandlerCore::MarketData::FE::PacketContainer& packetContainer);
    void onMulticastPacketGap(const OnixS::ItchCore::SessionType&, SequenceNumber expectedSeqNum, SequenceNumber receivedSeqNum);
    void onMulticastInactivity();


    void onReplayPacket(OnixS::HandlerCore::MarketData::FE::PacketContainer& packetContainer);

    void onReplayFailure(const ItchCore::SessionType&, SequenceNumber begin, ItchCore::Binary8 count);

    void onGlimpseFailure(const std::string& what);
    void onGlimpseWarning(const std::string& what);
    void onGlimpseMessage(const DataSource& dataSource, const IncomingMessage* message);
    void onGlimpseRestarted();

    void initRetransmissionService();

private:
    HandlerSettings settings_;

    boost::scoped_ptr<OrderBookAllocator> bookAllocator_;
    boost::scoped_ptr<HandlerCore::Common::HandlerLogger> logger_;

    boost::scoped_ptr<ListenerHolder> listenerHolder_;

    MulticastFeedClusterPtr realtimeFeeds_;
    UnicastFeedClusterPtr gapResponseFeeds_;

    boost::scoped_ptr<RealtimePacketProcessor> realtimePacketProcessor_;

    boost::scoped_ptr<MessageRepository> messageRepository_;

    boost::scoped_ptr<OnixS::ItchCore::MoldUDP64::RetransmissionService> retransmissionService_;

    boost::scoped_ptr<GlimpseService> glimpseService_;

    bool backtestingMode_;
    boost::scoped_ptr<RetransmissionPacketProcessor> retransmissionPacketProcessor_;
    boost::scoped_ptr<GlimpsePacketProcessor> glimpsePacketProcessor_;

    friend class OnixS::ItchCore::MoldUDP64::PacketProcessor<HandlerImpl>;
};

struct Handler::Impl : public HandlerImpl
{
typedef HandlerImpl base;

public:
Impl(const HandlerSettings & settings) 
    : base(settings)
{}
};

ONIXS_HANDLER_NAMESPACE_END