FIX Session

Persistent session

Persistent session is a session with persistent storage.

Engine::Session* Engine::FixEngine::createSession(Engine::Application* apApp, const std::string& aSenderCompID, const std::string& aTargetCompID, 
    Engine::FIXVersion aVer = FIX42, Engine::SessionExtraParameters* pParam = NULL, const Engine::MessageStorageType storageType = persistent_storageType)

Session state is stored on disk and can be restored after failure. The following information is stored for session:

• Session parameters (SenderCompID, TargetCompID, FIX version, etc.)
• Session incoming sequence number
• Incoming messages (optional)
• Outgoing messages

Transient session

Transient session is a session with transient storage.

Engine::Session* Engine::FixEngine::createSession(Engine::Application* apApp, const std::string& aSenderCompID, const std::string& aTargetCompID, 
    Engine::FIXVersion aVer = FIX42, Engine::SessionExtraParameters* pParam = NULL, const Engine::MessageStorageType storageType = transient_storageType)

Session state is stored in memory, which highly increases performance. This is the recommended way in case when session is not required to provide fail-over by itself.

Session state

From the time session is created and till it is destroyed session uses state that dictates its reaction to events. Session state can be obtained using Engine::Session::getState() method, which returns Session::State.

• INITIAL The session has been created, but has not been connected yet
• WAIT_FOR_FIRST_LOGON The session has been connected as an Acceptor and is waiting for the first Logon message
• WAIT_FOR_CONFIRM_LOGON The session has been connected as an Initiator, the first Logon message has been sent and it is waiting for the conforming Logon message
• SWITCH_CONNECTION The session change connection from primary to backup (or back)
• ESTABLISHED The session is fully established
• RECONNECT The session-initiator has detected the telecommunication link error and is trying to re-establish the link
• CORRECTLY_TERMINATED The session has been correctly terminated
• NON_GRACEFULLY_TERMINATED The session has been non-gracefully terminated

To convert the Engine::Session::State enum value to a string value, use the Engine::Session::state2string() method.

Sequence number handling

Session is always assigned two sequence numbers:

• Incoming sequence number is a counter for incoming message
• OUtgoing sequence number is a counter for outgoing message

Both sides must maintains two values and control that they are in sync. There are two types of sequence numbers desync:

• Sequence number too high indicates messages loss and leads to resend procedure.
• Sequence number too low indicates some serios problem and must lead to immediate session terminatio and manual sequence number synchronization.

Both sequence numbers are started from 1 when session is created from scratch. After correct session termination sequence numbers are reset to 1. If connection is terminated non-gracefully then after restore sequence numbers continue. In fact a lot of service providers never reset sequence numbers during the day. The are also some, who reset sequence numbers once per week. There are several cases to handle such deviation from standard in FIX Antenna

• IntradayLogouttolerance mode makes session always go to the non-gracefully terminated state, which means the sequence numbers will continue on next connect. To reset sequence numbers it is enough to remove FIX session persistent files from logs directory. Since FIX Antenna stores session state in those files, absence of such file will be treated as session being created from scratch and thus sequence numbers will be set to 1. Files can be removed during the End-Of-Day or End-Of-Week procedure.
• ForceSeqNumReset mode make session to reset sequence number each time on logon and force counter-party to do the same (standard FIX mechanism). This is not recommended way since messages sent during inactivity time will be lost.
• Forcedly set sequence numbers to expected values. Methods Engine::Session::setInSeqNum and Engine::Session::setOutSeqNum can be used.

Resetting sequence number

It is recommended that a new FIX session is established once within each 24 hour period. The new set of sequence numbers can be set by sending a Logon message with the ResetSeqNumFlag set. FIX Antenna supports this feature via ResetSeqNumAfter24hours configuration option. It is also possible to reset sequence number manually using void Engine::Session::resetSeqNum() method.

Late delivery vs rejecting

When session connection is lost, the initiator tries to reconnect, which may take some time (or even infinity), acceptor waits for reconnect. For both sides message delivery is impossible. FIX Antenna provides two different approaches to the message handling in this state:

• Late delivery (default mode) means that all outgoing messages are stored in outgoing queue and sent once connection is established.
• Message rejecting means that after some reasonable period of time messages are rejected i.e. they are removed from outgoing queue and reject is sent in opposite direction.

The Engine::SessionExtraParameters::enableMessageRejecting_ parameter controlls if Message rejecting enabled or not (by default it is disabled). The configuration file's property MessageTimeToLive specifies how long session waits for connection restore (i.e. before reject the message). If connection is not restored during MessageTimeToLive interval - the session starts rejecting messages by calling Engine::Application::onMsgRejectEvent() for each rejected message.

Events

To monitor engine events (see the Engine::Event class), derive from the EventListener class and register an object of this class using the Engine::FixEngine::registerEventListener method.

It is vital to call the Engine::FixEngine::unregisterEventListener method before calling the Engine::FixEngine::destroy method.

To detect the exact type of the received event, use C++ RTTI or the Event::getType method.

For example:

class Listener : public Engine::EventListener {
    public:
        virtual void onNotification (const Engine::Notification &aNotification){
            clog << "Notification: " << *aNotification.what() << endl << endl;
        } 
   
        virtual void onWarning (const Engine::Warning &aWarning){
            clog << "Warning: " << *aWarning.what() << endl << endl;
        }
   
        virtual void onError (const Engine::Error &aError){
            clog << "Error: " << *aError.what() << endl << endl;
        }
};
   
Listener listener;
Engine::FixEngine::singleton()->registerEventListener(&listener);

// ... - business logic

// must be done before FixEngine::destroy()
Engine::FixEngine::singleton()->unregisterEventListener(&listener); 

Engine::FixEngine::destroy();