External Thread Sample

This sample connects to the pre-defined host and port (acts as a FIX Initiator). When the session is established, the SingleOrder - New FIX message is sent to the counterparty. This is done using the ExternalThread threading model.

Source code

• Listener.h
• Listener.cpp
• ExternalThread.cpp

Listener.h

 
#include <OnixS/FIXEngine/FIX/ISessionListener.h>
 
class Listener : public OnixS::FIX::ISessionListener
{
public:
    Listener() noexcept : finished_(false), failed_(false) {}
    ~Listener() override = default;
 
    bool finished() const noexcept
    {
        return finished_;
    }
 
    bool failed() const noexcept
    {
        return failed_;
    }

    void onInboundApplicationMsg(OnixS::FIX::Message & msg, OnixS::FIX::Session * sn) final;

    void onInboundSessionMsg(OnixS::FIX::Message & msg, OnixS::FIX::Session * sn) final;
 
    void onStateChange(OnixS::FIX::SessionState::Enum newState, OnixS::FIX::SessionState::Enum prevState, OnixS::FIX::Session * sn) final;
 
    void onError(OnixS::FIX::ErrorReason::Enum reason, const std::string & description, OnixS::FIX::Session * sn) final;
    void onWarning(OnixS::FIX::WarningReason::Enum reason, const std::string & description, OnixS::FIX::Session * sn) final;
 
private:
    bool finished_;
    bool failed_;
};
 

Listener.cpp

 
#include "Listener.h"
 
#include <OnixS/FIXEngine/FIX/Message.h>
 
#include <iostream>
#include <string>
 
using namespace OnixS::FIX;
 
void Listener::onInboundApplicationMsg(Message & msg, Session *)
{
    std::clog << "\nIncoming application-level message:\n" << msg << std::endl;
}
 
void Listener::onInboundSessionMsg(Message & msg, Session *)
{
    std::clog << "\nIncoming session-level message:\n" << msg << std::endl;
}
 
void Listener::onStateChange(SessionState::Enum newState, SessionState::Enum prevState, Session *)
{
    std::clog
        << "\nSession's state is changed, prevState="
        << SessionState::toString(prevState)
        << ", newState="
        << SessionState::toString(newState)
        << std::endl;
 
    if(newState == SessionState::Disconnected)
        finished_ = true;
}
 
void Listener::onError(ErrorReason::Enum, const std::string & description, Session *)
{
    std::cerr << "\nSession-level error:" << description << std::endl;
    failed_ = true;
    finished_ = true;
}
 
void Listener::onWarning(WarningReason::Enum, const std::string & description, Session *)
{
    std::cerr << "\nSession-level warning:" << description << std::endl;
}
 

ExternalThread.cpp

#include <OnixS/FIXEngine.h>
 
#include "Listener.h"
 
#include "../../Common/Helpers.h"
#include "../../Common/Settings.h"
 
using namespace Settings;
using namespace OnixS::FIX;
using namespace OnixS::Threading;
 
int main()
{
    std::clog << "ExternalThread sample." << std::endl << std::endl;
 
    try
    {
        manageLinuxSignals();
 
        EngineSettings settings;
 
        settings.listenPort(ListenPort)
                .licenseStore(LicenseStore);
 
        TCPStandard::Stack stack;
 
        Engine::init(settings, &stack);
        EngineShutdownGuard engineShutdownGuard(&stack);
 
        Listener acceptorListener;
        Session acceptor(&stack, TargetCompId, SenderCompId, FixProtocolVersion, &acceptorListener);
        acceptor.logonAsAcceptor();
 
        Listener initiatorListener;
        Session initiator(&stack, SenderCompId, TargetCompId, FixProtocolVersion, &initiatorListener);
 
        const bool SetResetSeqNumFlagOnLogon = true;
        const int HeartBtInt = 30;
        SecondSpan BigTimeout(HeartBtInt * 2);
 
        {
            TimeoutTimer timer(BigTimeout);
            SharedFuture<void> logonTask = initiator.logonAsInitiatorAsync("localhost", ListenPort, HeartBtInt, nullptr, SetResetSeqNumFlagOnLogon);
 
            while(!logonTask.isReady() && !timer.elapsed())
                stack.dispatchEvents();
 
            if(timer.elapsed())
            {
                std::clog << std::endl << "Cannot logon during the timeout." << std::endl;
                initiator.breakConnection();
                throw std::runtime_error("Cannot logon during the timeout.");
            }
 
            if(logonTask.hasException())
                logonTask.get();
        }
 
        if(acceptorListener.failed() || initiatorListener.failed())
            throw std::runtime_error("External-thread session failed.");
 
        std::clog << "Press any key to send an order, disconnect the session and terminate the application." << std::endl;
 
        while(!acceptorListener.finished() && !initiatorListener.finished() && !keyPressed())
            stack.dispatchEvents();
 
        Message order("D", FixProtocolVersion);
        setOrderFields(&order);
 
        initiator.send(&order);
 
        {
            TimeoutTimer timer(BigTimeout);
            SharedFuture<void> logoutTask = initiator.logoutAsync("The session is disconnected");
 
            while((!logoutTask.isReady() || !initiatorListener.finished()) && !timer.elapsed())
                stack.dispatchEvents();
 
            if(timer.elapsed())
            {
                std::clog << std::endl << "Cannot logout during the timeout." << std::endl;
                initiator.breakConnection();
                throw std::runtime_error("Cannot logout during the timeout.");
            }
 
            if(logoutTask.hasException())
                logoutTask.get();
        }
 
        if(acceptorListener.failed() || initiatorListener.failed())
            throw std::runtime_error("External-thread session failed.");
 
        initiator.shutdown();
        acceptor.shutdown();
    }
    catch(const std::exception & ex)
    {
        processSampleException(ex.what());
        return 1;
    }
 
    return 0;
}