FixClientSession.h

Go to the documentation of this file.

 
#pragma once
 
#include "fix_client/SeqNumStore.h"
#include "fix_client/FixMessageParser.h"
#include <asio.hpp>
#include <string>
#include <memory>
#include <functional>
#include <atomic>
 
namespace fix_client {
 
    enum class FixClientState {
        Disconnected,
        Connecting,
        Connected,    // TCP up, Logon not sent
        LogonSent,
        Active,       // Logon ACK received
        LoggingOut
    };
 
    class FixClientSession : public std::enable_shared_from_this<FixClientSession> {
    public:
        using MessageCallback = std::function<void(const ParsedFixMessage&)>;
 
        using StateChangeCallback = std::function<void(FixClientState)>;
 
        FixClientSession(asio::io_context& ioContext, 
                         const std::string& senderCompId,
                         const std::string& targetCompId,
                         const std::string& seqStoreDir = "seq_store");
 
        ~FixClientSession();
 
        void connect(const std::string& host, short port);
 
        void disconnect();
 
        void sendLogon(int heartbeatInterval = 30, bool forceReset = false);
 
        void sendLogout(const std::string& reason = "");
 
        void sendMessage(const std::string& msgType, const std::string& bodyStr);
 
        void sendAuthRequest(const std::string& username, const std::string& password);
        
        void sendNewOrder(const std::string& symbol, char side, double price, int qty, char type = '2', char tif = '0');
        void sendMarketDataRequest(const std::string& symbol, char subscriptionRequestType = '1');
 
        // --- Configuration & Callbacks ---
 
        void setMessageCallback(MessageCallback cb) { mMessageCb = std::move(cb); }
        void setStateChangeCallback(StateChangeCallback cb) { mStateChangeCb = std::move(cb); }
        void setHeartbeatInterval(int seconds) { mHeartbeatInterval = seconds; }
 
        FixClientState getState() const { return mState; }
        const std::string& getSenderCompId() const { return mSenderCompId; }
        
    private:
        void doRead();
        void doWrite(std::shared_ptr<std::string> message);
        
        void handleProtocolMessage(const std::string& msgStr);
        void handleLogonResponse(const std::string& msgStr, uint32_t inSeq);
        void handleLogoutResponse(const std::string& msgStr);
        void handleHeartbeat(const std::string& msgStr);
        void handleTestRequest(const std::string& msgStr);
        void handleResendRequest(const std::string& msgStr);
        void handleSequenceReset(const std::string& msgStr);
 
        void changeState(FixClientState newState);
        void startHeartbeatTimer();
        void startTestRequestTimer();
 
        // Dependencies
        asio::io_context& mIoContext;
        asio::ip::tcp::socket mSocket;
        asio::ip::tcp::resolver mResolver;
        asio::steady_timer mHeartbeatTimer;
        asio::steady_timer mTestReqTimer;
 
        // Configuration
        std::string mSenderCompId;
        std::string mTargetCompId;
        int mHeartbeatInterval = 30;
 
        // State Machine
        std::atomic<FixClientState> mState{FixClientState::Disconnected};
        SeqNumStore mSeqStore;
 
        // Buffers
        static constexpr size_t ChunkSize = 8192;
        std::vector<char> mReadChunk;
        std::string mReadBuffer;
 
        // Callbacks
        MessageCallback mMessageCb;
        StateChangeCallback mStateChangeCb;
 
        friend class FixClientSessionTests;
    };
 
} // namespace fix_client