Reference Implementation of FastScpSession

QWFIX currently doesn't include a standard FAST session implementation in our officially released package.

The FastSessionContext class provides API to perform all possible FAST session operations.

The reason we didn't have an official release of FAST session is that we feel currently even the latest FAST SCP 1.1 is still in very early stage and there still exists several customized solutions.

However, we do provide a reference implementation of FAST SCP session in one of our SDK sample projects, the FastSession project. Even better, because it's a sample project, full source code is included.

FastSession Project

FastSession project is one of our SDK sample projects. It provides a reference implementation of FAST SCP 1.1 session, with full source code.

The SCP session implementation is provided as the FastScpSession class.

The reference implementation is used by two other sample projects in SDK, the TestFastScpClient and TestFastScpServer project. The TestFastScpServer is a general purpose "echo server" which can be used to test other FAST implementations. Below describes how TestFastScpClient and TestFastScpServer work, step by step:

•  TestFastScpClient connects to TestFastScpServer through a TCP connection described by IP address and port.
•  TestFastScpClient and TestFastScpServer exchange "Hello" messages and TestFastScpClient sends the dynamic template definition message to TestFastScpServer.
•  TestFastScpClient then sends a message with randomly filled fields to TestFastScpServer. TestFastScpServer receives the message and aends back a duplicated message.
•  TestFastScpClient received the duplicated message, compare it to the original composed message. If there is a difference, reports error; otherwise, repeat the testing by sending another randomly composed message.

FastScpSession Class

FastScpSession class is very easy to use.

Construction

FastScpSession constructor takes 4 parameters, an instance of FastSessionContext, an indicator of the template exchange method, and two queue sizes for sending and receiving messages.

• FastSessionContext
  FastSessionContext can be created by two schemas, an application template schema and a SCP template schema. Application template schema can be null if the session is designed to accept dynamic template definition from the counter party.
• Template Exchange Method
  Template Exchange is the tricky part. In our reference implementation we only provided the very basic logics. Since we published the source code, users are encouraged to customize it to fit their own requirement.
• Queue Sizes for Incoming and Outgoing Messages
  Those two parameters that correspond to the sending and receiving queue sizes are used for flow control. The minimum queue size is 1. The maximum is infinite, which is -1.
  Those parameters are used for flow control, which will affect the performance and quality-of-service.
  Generally, the larger the queue size is, the better throughput can be achieved. However, the smaller the queue size, the lower latency can be achieved. Application developer can find a balance between throughput and latency by manipulate those two queue sizes.

Start and Stopping

Start() and Stop() methods are provided to start and stop the SCP session. Both methods returns immediately. FastScpSession creates two threads, one thread dedicated for encoder and another one dedicated for decoder. Developers are welcome to modify the threading model if they don't like the current implementation.

Error Handling

If anything went wrong during session establishing, message encoding/decoding, FastScpSession.ErrorOccurs event will be triggered. Hook up to that event to receive the proper notification.

Sending and Receiving Messages

SendMessage and ReceiveMessage methods are used to send and receive FAST messages. Those methods can be either blocking or non-blocking operations, depending on the messages in outgoing queue and incoming queue and the queue sizes.

For outgoing messages (sender), if number of messages in queue is less than queue size, the message will be enqueued and method will return immediately. However if the queue is full, the method will block until the encoder thread retrieves a message from queue for encoding-over-the-wire.

For imcoming messages (receiver), if the incoming queue is not empty, the ReceiveMessage method will dequeue a message from the queue and return the message immediately. However if the queue is empty, it will wait until the reader thread receives a message from the counter-party and enqueues it into the queue.