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/CboeCFE/Trading/BOE/Compiler.h>

#if ONIXS_BATS_BOE_HAS_GATEWAY_EMULATOR

#include <OnixS/CboeCFE/Trading/BOE/Testing/MessagePtr.h>
#include <OnixS/CboeCFE/Trading/BOE/Testing/ClientMessageListener.h>

#include <chrono>

namespace OnixS {
namespace CboeCFE {
namespace Trading {
namespace BOE {
namespace Testing {


class ONIXS_CBOE_CFE_BOE_API Gateway
{
public:
    explicit Gateway(int port, const char* host = "127.0.0.1", const std::chrono::seconds& acceptTimeout = std::chrono::seconds(10),
        const std::chrono::seconds& sendReceiveTimeout = std::chrono::seconds(10));

    ///
    virtual ~Gateway();

    /// Deleted.
    Gateway(const Gateway&) = delete;
    Gateway& operator=(const Gateway&) = delete;

    /// Move semantic.
    Gateway(Gateway&&) noexcept;
    Gateway& operator=(Gateway&&) noexcept;

    /// Swap with other.
    void swap(Gateway&) noexcept;

    /// @return listen host.
    const char * host() const noexcept;

    /// \return the listen port.
    int port() const noexcept;

    /// Accepts an incoming connection.
    /// If the `acceptTimeout` is zero, the `acceptTimeout` provided in the constructor is used.
    Gateway& acceptConnection(const std::chrono::seconds& acceptTimeout = std::chrono::seconds(0));

    /// Sends the given application-level message message.
    Gateway& sendApplicationMessage(const OutgoingMessage& msg, SeqNumber seqNumber = SeqNumberTraits::InvalidValue);

    /// Receives the message of the particular type.
    /// \throw std::logic_error if an unexpected type is received.
    template <BOE::MessageType::Enum Type>
    MessagePtr<typename MessageTypeTraits<Type>::MessageType> receiveTypedMessage() const;

    /// Send the ServerHeartbeat message
    void sendHeartbeat();

    /// Waits until the LogoutRequested message is received.
    ///
    /// If the listener is provided, then receives and reports application-level messages via the corresponding callback.
    /// Responds to the ClientHeartbeat message if received.
    LogoutRequestPtr waitUntilLogoutRequested(
        ClientMessageListener* listener = nullptr, ClientSessionMessageListener* sessionMessageListener = nullptr);

    /// Accepts an incoming connection and establishes the session.
    ///
    /// Receives and reports application-level messages via the corresponding callback.
    /// Responds to the ClientHeartbeat message if received.
    Gateway& run(ClientMessageListener& listener);

    /// Accepts an incoming connection and establishes the session.
    ///
    /// Receives and reports application-level messages via the corresponding callback.
    /// Receives and reports session-level messages via the corresponding callback.
    Gateway& run(ClientMessageListener& appMsgListener, ClientSessionMessageListener& sessionMsgListener);

protected:
    /// Checks whether the connection is closed by the counterparty.
    bool isConnectionClosed(const std::chrono::seconds& timeout) const;

    /// Checks whether the connection is closed by the counterparty
    /// using the default timeout (provided in the constructor).
    bool isConnectionClosed() const;

    /// Close the listening socket
    Gateway& close();

    /// Closes the accepted connection.
    Gateway& disconnect();

    /// Receives a message.
    MessageBasePtr receive() const;

    /// Receives a message into provided container
    MessageBasePtr receive(PacketContainer && container, MessageSize containerSize);

    /// Sends the given data
    Gateway& sendData(const void* data, size_t size);

    /// Sends the given session-level message message.
    Gateway& sendSessionMessage(const OutgoingMessage& msg);

    /// Receives the LoginRequest message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    LoginRequestPtr receiveLoginRequest();

    /// Receives the LogoutRequest message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    LogoutRequestPtr receiveLogoutRequest();

    /// Receives the ClientHeartbeat message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    ClientHeartbeatPtr receiveClientHeartbeat();

    /// Receives the LoginRequest and responds with the LoginResponse message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    LoginRequestPtr acceptLogin(SeqNumber clientSequence = 1);

    /// Receives the LoginRequest and responds with the LoginResponse message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    LoginRequestPtr rejectLogin();

    /// Receives the LogoutRequest and responds with the LogoutResponse message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    LogoutRequestPtr acceptLogout();

    /// Accepts the incoming connection, Receives the LoginRequest and responds with the LoginResponse message.
    ///
    /// \throw std::logic_error if an unexpected type is received.
    LoginRequestPtr acceptSession(SeqNumber clientSequence = 1);

    /// Send the LogoutResponse message
    void sendLogout(LogoutResponseReason::Enum reason);

    /// Send the ReplayComplete message
    void sendReplayComplete();

private:
    class Impl;
    Impl* impl_;
};

template <BOE::MessageType::Enum Type>
MessagePtr<typename MessageTypeTraits<Type>::MessageType> Gateway::receiveTypedMessage() const
{
    return cast<Type>(receive());
}


}}}}}

#endif