AuditTrailDumper.cpp

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

#include <OnixS/SgxTitan/Trading/OUCH/Defines.h>
#include <OnixS/SgxTitan/Trading/OUCH/Messages.In.h>
#include <OnixS/SgxTitan/Trading/OUCH/Messages.Out.h>

#include "ProtocolFormatting.h"
#include "Utils.h"
#include "AuditTrailDumper.h"


ONIXS_SGXTITAN_OUCH_NAMESPACE_BEGIN
namespace Implementation {

namespace
{
    struct OutputMessageHelper : public OutgoingMessage
    {
        OutputMessageHelper(void* data, MessageSize size)
            : OutgoingMessage(data, size)
        {
        }
    };
}

AuditTrailDumper::AuditTrailDumper(
        const std::string& path,
        const Logging::LogFacility* parent,
        OnixS::HandlerCore::Common::HandlerLogger& logger,
        const OnixS::System::Thread::CpuIndexes& affinity,
        size_t auditTrailFileMaxSize)

    : AuditTrailDumperBase(path, parent, &logger, affinity, auditTrailFileMaxSize)
{
}

AuditTrailDumper::~AuditTrailDumper()
{
}

void AuditTrailDumper::serialize(const Record& record, OnixS::Util::TextBuilder& tb)
{
    BOOST_ASSERT(record.buffer);
    BOOST_ASSERT(record.bufferSize > 0);

    tb <<(record.direction == Record::In ? " IN " : "OUT ")
       << OnixS::Time::YYYYMMDDHHMMSSnsecFormatter()(record.timestamp) << ' ';

    const void* const dataPtr = record.buffer;

    BOOST_ASSERT(record.bufferSize <= std::numeric_limits<Binary2>::max());
    const Binary2 messageLength = static_cast<Binary2>(record.bufferSize);
    
    if(record.direction == Record::In)
    {
        const IncomingMessage message(dataPtr, messageLength);
        const InboundMessageTypes::Enum messageType = message.type();

        if(InboundMessageTypes::OrderAccepted == messageType)
        {
            OrderAccepted::validateSize(messageLength);
            tb << static_cast<const OrderAccepted&>(message) << '\n';
        }
        else if(InboundMessageTypes::OrderRejected == messageType)
        {
            OrderRejected::validateSize(messageLength);
            tb << static_cast<const OrderRejected&>(message) << '\n';
        }
        else if(InboundMessageTypes::OrderReplaced == messageType)
        {
            OrderReplaced::validateSize(messageLength);
            tb << static_cast<const OrderReplaced&>(message) << '\n';
        }
        else if(InboundMessageTypes::OrderCancelled == messageType)
        {
            OrderCancelled::validateSize(messageLength);
            tb << static_cast<const OrderCancelled&>(message) << '\n';
        }
        else if(InboundMessageTypes::OrderExecuted == messageType)
        {
            OrderExecuted::validateSize(messageLength);
            tb << static_cast<const OrderExecuted&>(message) << '\n';
        }
        else
            log(ONIXS_LOG_WARN[this] << "Received unknown message, type = " << static_cast<Binary1>(message.type()));
    }
    else if(record.direction == Record::Out)
    {
        const OutgoingMessage& message =
                OutputMessageHelper(const_cast<void*>(dataPtr), messageLength);
        
        const OutboundMessageTypes::Enum type = message.type();

        if(type == OutboundMessageTypes::EnterOrder)
        {
            tb << static_cast<const EnterOrder&>(message) << '\n';
        }
        else if(type == OutboundMessageTypes::ReplaceOrder)
        {
            tb << static_cast<const ReplaceOrder&>(message) << '\n';
        }
        else if(type == OutboundMessageTypes::CancelOrder)
        {
            tb << static_cast<const CancelOrder&>(message) << '\n';
        }
        else if(type == OutboundMessageTypes::CancelByOrderId)
        {
            tb << static_cast<const CancelByOrderId&>(message) << '\n';
        }
        else
            log(ONIXS_LOG_WARN[this] << "Sent unknown message, type = " << static_cast<Binary1>(message.type()));
    }
    else
        return;
}

void AuditTrailDumper::onOutboundMessage(const OutgoingMessage& msg, bool warmup)
{
    AuditTrailDumperBase::onOutboundMessage(static_cast <const char*>(msg.binary()), msg.binarySize(), warmup);
}

void AuditTrailDumper::onInboundMessage(const IncomingMessage& msg, bool warmup)
{
    AuditTrailDumperBase::onInboundMessage(static_cast <const char*>(msg.binary()), msg.binarySize(), warmup);
}

}}}}}