Gateway.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/ICE/BOE/testing/ABI.h>
#include <OnixS/ICE/BOE/SessionSettings.h>
 
#include <OnixS/ICE/BOE/messaging/Messages.h>
#include <OnixS/ICE/BOE/testing/MessagePtr.h>
#include <OnixS/ICE/BOE/testing/ClientMessageListener.h>
 
#include <chrono>
#include <atomic>
 
ONIXS_ICEBOE_NAMESPACE_BEGIN
namespace Testing {
 
//  Type aliases
using LogonReportContainer = MessageHolder<LogonReport>;
using IPReportContainer = MessageHolder<IPReport>;
using TraderLogonReportContainer = MessageHolder<TraderLogonReport>;
using TraderLogoutReportContainer = MessageHolder<TraderLogoutReport>;
using LogoutReportContainer = MessageHolder<LogoutReport>;
using HeartBeatContainer = MessageHolder<HeartBeat>;
 
using MessageBasePtr = MessagePtr<SbeMessage>;
using LogonRequestPtr = MessagePtr<LogonRequest>;
using LogoutRequestPtr = MessagePtr<LogoutRequest>;
using IPRequestPtr = MessagePtr<IPRequest>;
using TraderLogonRequestPtr = MessagePtr<TraderLogonRequest>;
using TraderLogoutRequestPtr = MessagePtr<TraderLogoutRequest>;
using HeartBeatPtr = MessagePtr<HeartBeat>;

class ONIXS_ICEBOE_EXPORTED Gateway
{
public:
    using Timeout = std::chrono::milliseconds;
 
    Gateway(const SessionSettings::LicenseStores& licenseStores, int port, const char* host = "127.0.0.1",
            const Timeout& acceptTimeout = defaultTimeout(),
            const Timeout& sendReceiveTimeout = defaultTimeout());

    virtual ~Gateway();

    Gateway(const Gateway&) = delete;
    Gateway& operator=(const Gateway&) = delete;

    Gateway(Gateway&&) noexcept;
    Gateway& operator=(Gateway&&) noexcept;

    void swap(Gateway&) noexcept;

    Gateway& acceptConnection(const Timeout& acceptTimeout = defaultTimeout());

    ONIXS_ICEBOE_NODISCARD
    bool tryAcceptConnection(const Timeout& acceptTimeout = defaultTimeout());

    Gateway& acceptSession(SeqNumber outgoingSequenceNumber = 1);

    LogoutRequestPtr waitUntilTerminate(
        ClientMessageListener* listener = nullptr, ClientSessionMessageListener* sessionMessageListener = nullptr,
        std::atomic<bool>* stopRequested = nullptr);

    Gateway& sendSequence();

    Gateway& disconnect();

    ONIXS_ICEBOE_NODISCARD
    std::string host() const;

    ONIXS_ICEBOE_NODISCARD
    int port() const noexcept;

    Gateway& enableLogger(const std::string& logFileName, unsigned int logLevel = 3);

    template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
    Gateway& send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>& msg);

    template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
    Gateway& send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>&& msg);

    template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
    Gateway& send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>& msg, SeqNumber num);

    template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
    Gateway& send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>&& msg, SeqNumber num);

    template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
    Gateway& send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>& msg, std::initializer_list<SeqNumber> numbers);

    template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
    Gateway& send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>&& msg, std::initializer_list<SeqNumber> numbers);

    template <typename TMsg>
    ONIXS_ICEBOE_NODISCARD
    MessagePtr<TMsg> receiveTypedMessage();

    Gateway& run(ClientMessageListener& listener, std::atomic<bool>* stopRequested = nullptr);

    Gateway& run(ClientMessageListener& appMsgListener, ClientSessionMessageListener& sessionMsgListener, std::atomic<bool>* stopRequested = nullptr);

    ONIXS_ICEBOE_NODISCARD
    SeqNumber outSeqNum() const noexcept;

    Gateway& outSeqNum(SeqNumber nextOutSeqNum) noexcept;

    Gateway& tcpNoDelayOption(bool noDelay);

    ONIXS_ICEBOE_NODISCARD
    bool tcpNoDelayOption() const noexcept ;

    ONIXS_ICEBOE_NODISCARD
    int socketReceiveBufferSize() const noexcept;

    Gateway& socketReceiveBufferSize(int bufferSize) ;

    ONIXS_ICEBOE_NODISCARD
    int socketSendBufferSize() const noexcept;

    Gateway& socketSendBufferSize(int bufferSize);

    ONIXS_ICEBOE_NODISCARD
    LogonReportContainer createLogonReport(Int32NULL exchangeCode = NullInt32NULL(), std::string text = {});

    ONIXS_ICEBOE_NODISCARD
    static IPReportContainer createIpReport(StrRef userId, StrRef host, Int16NULL port, StrRef ipSessionToken, Int32NULL exchangeCode = NullInt32NULL(), std::string text = {});

    ONIXS_ICEBOE_NODISCARD
    static TraderLogonReportContainer createTraderLogonReport(StrRef traderId, int clientId, Int32NULL exchangeCode = NullInt32NULL(), std::string text = {});

    ONIXS_ICEBOE_NODISCARD
    static TraderLogoutReportContainer createTraderLogoutReport(StrRef traderId, Int32NULL exchangeCode = NullInt32NULL(), std::string text = {});

    ONIXS_ICEBOE_NODISCARD
    static LogoutReportContainer createLogoutReport(StrRef userId, Int32NULL exchangeCode = NullInt32NULL(), std::string text = {});

    ONIXS_ICEBOE_NODISCARD
    static HeartBeatContainer createHeartBeat();
 
protected:
    ONIXS_ICEBOE_NODISCARD
    bool isConnectionClosed(const Timeout& timeout) const;

    ONIXS_ICEBOE_NODISCARD
    bool isConnectionClosed() const;

    ONIXS_ICEBOE_NODISCARD
    MessageBasePtr receive() const;

    ONIXS_ICEBOE_NODISCARD
    MessageBasePtr tryReceive(const std::chrono::microseconds& timeout = defaultTimeout()) const;

    ONIXS_ICEBOE_NODISCARD
    LogonRequestPtr receiveLogonRequest();

    ONIXS_ICEBOE_NODISCARD
    LogonRequestPtr acceptLogonRequest(UInt32 sequenceId);

    ONIXS_ICEBOE_NODISCARD
    LogoutRequestPtr receiveLogoutRequest();

    ONIXS_ICEBOE_NODISCARD
    LogoutRequestPtr acceptLogoutRequest();

    Gateway& sendLogoutRequest(StrRef userId, Int32NULL exchangeCode = NullInt32NULL(), std::string text = {});

    ONIXS_ICEBOE_NODISCARD
    LogoutRequestPtr terminate(StrRef userId);

    Gateway& send(Messaging::SbeMessage, Messaging::SimpleOpenFramingHeader&);

    Gateway& sendData(const void* data, size_t size);

    Gateway& close();

    static Timeout defaultTimeout()
    {
        return Timeout(30000);
    }
 
private:
    class Impl;
    std::unique_ptr<Impl> impl_;
 
    friend class ClientMessageListener;
    friend class ClientSessionMessageListener;
};
 
 
template <typename TMsg>
MessagePtr<TMsg> Gateway::receiveTypedMessage()
{
    return cast<TMsg>(receive());
}
 
template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
Gateway& Gateway::send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>& msg)
{
    const auto messageSize = msg.setHeader();
    auto* const header = msg.header();
    assert(header);
 
    return send(Messaging::SbeMessage(header + 1, messageSize), *header);
}
 
template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
Gateway& Gateway::send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>&& msg)
{
    return send(msg);
}
 
template <typename Holder>
typename std::enable_if<std::is_base_of<TagBased::Message, typename Holder::MessageType>::value>::type
    setSeqNum(Holder&, SeqNumber)
{
    throw std::runtime_error("Not implemented.");
}
 
template <typename Holder>
typename std::enable_if<!std::is_base_of<TagBased::Message, typename Holder::MessageType>::value>::type
    setSeqNum(Holder& msg, SeqNumber num)
{
    msg->sequenceId(num);
}
 
template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
Gateway& Gateway::send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>& msg, SeqNumber num)
{
    setSeqNum(msg, num);
    return send(msg);
}
 
template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
Gateway& Gateway::send(MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>&& msg, SeqNumber num)
{
    setSeqNum(msg, num);
    return send(msg);
}
 
template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
Gateway& Gateway::send(
    MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>& msg, std::initializer_list<SeqNumber> numbers)
{
    for(auto seqNum : numbers)
    {
        send(msg, seqNum);
    }
 
    return *this;
}
 
template <typename SbeMessageType, size_t MaxMessageSize, typename MessageInitializer>
Gateway& Gateway::send(
    MessageHolder<SbeMessageType, MaxMessageSize, MessageInitializer>&& msg, std::initializer_list<SeqNumber> numbers)
{
    for(auto seqNum : numbers)
    {
        send(msg, seqNum);
    }
 
    return *this;
}
 
}
ONIXS_ICEBOE_NAMESPACE_END