Page tree

Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

Table of Contents

Group Ticker Plant Connectivity Overview

Below is a brief overview of the Group Ticker Plant market data connectivity.

Services

The GTP market data adaptor currently supports two services.

Level 1 service provides the best bid and offers data, the trade report messages, and the group statistics information. Level 2 service provides instrument definition, instrument status, order book (market by order), opening/closing statistics, and trades data.

Market Data Groups

A market feed is load-balanced by market data groups. A market data group includes one or more instruments. Each instrument is assigned to just one market data group.

Sites

A market data group includes two sites disseminating identical data – the primary (A) and secondary (a).

Channels

A site includes up to three channels.

...

Optional Recovery TCP channel is used to recover from a large message loss in the Real-Time channel or a late join to the Real-Time channel. The Recovery channel allows the recipient to request a snapshot of the current market data.

Accounts

The recipient must have a valid account to login to the Replay and Recovery channels.

GTP Market Data Adaptor Overview

GTP Market Data Adaptor is a module that allows communicating with the GTP market feeds.

Interfaces

Two sets of interfaces are exposed to the client.

...

  • Lse::Gtp::ConnectionManager
  • Lse::Gtp::UdpConnection
  • Lse::Gtp::UdpConnectionListener
  • Lse::Gtp::TcpConnection

Configuration

Group Ticker Plant Market Data Adaptor is configured via the XML configuration file that sets up the application options, the services, the service options, filtering by segments, and instruments.

Application

Application stores services and provides access to them by index and by name. The application also stores resources shared across services such as a connection manager.

It is possible to have several applications created at the same time. The client can choose to have either a single application for all the services of all the market feeds or have a separate application for each service. All the IO operations of all the services of an application are processed by the same connection manager.

Service

Service provides common tasks such as Real-Time channel management, Replay channel management, Recovery channel management, statistics management, status management, etc.

GTP Service

GTP service is a specialized service that processes tasks such as unit parsing, message replay, and message recovery.

Parser

GTP parser defines structures for the units and the messages and the general-purpose functions to construct, parse, validate, and dump the units and messages.

Sequence Processor

Sequence processor processes message losses, message reorders and message duplications that may occur in the Real-Time channel.  

...

In the case of a late join or a reset detected the sequence processor executes a recovery procedure. The sequence processor automatically arbitrates between the primary and secondary sites of the Recovery channel.

Service Statistics

Two types of service statistics are maintained - connection statistics and date statistics.

...

The date statistics are persisted and is reset on each new date.

Service Status

The status of each service channel is tracked and available via the service connection statistics.

...

The recovery channel is considered inactive if the last recovery procedure failed.

Asio Connection Manager

Asio connection manager serves as a factory for UDP and TCP connections.

...

The size of the thread pool is configurable.

Asio UDP Connection

Asio UDP connection asynchronously receives UDP packets from a multicast group.

Asio TCP Connection

Asio TCP connection synchronously sends and receives data to and from a TCP endpoint.

Logging

All the data sent and received can be optionally logged at three levels for later analysis and troubleshooting.

...

Error, warning, and trace events are logged to the FIXAntenna log subsystem.

Appendix A. Interfaces

Lse::Gtp::Application

Code Block
languagecpp
// Releasing
virtual void release() const = 0;

// Name
virtual std::string getName() const = 0;

// Opening / closing
virtual bool opened() const = 0;

// Initializes the application, creates and adds services from the configuration file.
// The services are created in the disconnected state and should be connected explicitly.
// applicationListener should stay alive until close() is called.
virtual void open(ApplicationListener* applicationListener) = 0;

// Removes the services and finalizes the application.
// Should only be called if open() succeeded.
virtual void close() = 0;       

// Services

// Returns the number of existing services.
virtual size_t getServiceCount() const = 0;

// Returns a service by index.
virtual Service* getService(size_t index) = 0;

// Finds a service by name. Returns 0 if the service does not exist.
virtual Service* findService(const std::string& name) = 0;

// Creates and adds a new service to the application.
// The service is created in the disconnected state and should be connected explicitly.
virtual Lse::Gtp::Service* addService
(
    const std::string& name,
    const ServiceOptions& serviceOptions
) = 0;

// Removes the service from the application and destroys it.
virtual void removeService(const std::string& name) = 0;

// Removes all the services from the application and destroys them.
virtual void removeAllServices() = 0;

Lse::Gtp::ApplicationListener

Code Block
languagecpp
// Services

// Called after a service is created and added to the application
virtual void onServiceAdded(Application* application, Service* service) = 0;

// Called before a service is removed from the application and destroyed
virtual void onServiceRemoving(Application* application, Service* service) = 0;

Lse::Gtp::Service

Code Block
languagecpp
// Application
virtual Application* getApplication() const = 0;

// Name
virtual std::string getName() const = 0;

// Returns the state of the service
virtual bool connected() const = 0;

// Connects the service to the mutlicast group.
// serviceListener should stay alive until disconnect() is called.
virtual void connect(ServiceListener* serviceListener) = 0;

// Disconnects the service from the mutlicast group.
// Should only be called if connect() succeeded.
virtual void disconnect() = 0;

// Statistics

// Returns service statistics snapshot.
// connectionStatistics can be 0.
// dateStatistics can be 0.
virtual void getStatistics
(
    ServiceConnectionStatistics* connectionStatistics,
    ServiceDateStatistics* dateStatistics
) const = 0;

Lse::Gtp::ServiceListener

Code Block
languagecpp
// Messages

// Called on service reset. The client should reset all its message derived data.
virtual void onReset(Service* service, ResetReason resetReason) = 0;

// Called on GTP message received.
virtual void onGtpMessage(Service* service, const Lse::Itch::MessageHeader* messageHeader) {}

// Called when either the recovery or the replay request has been completed.
virtual void onRequestComplete(RequestType request, bool success) {}

// Called on a service resynchronization. Informs the client about an out-of-order message
virtual void onResync(Service* service) {}

Lse::Gtp::ConnectionManager

Code Block
languagecpp
// Releasing
virtual void release() const = 0;

// Returns the state of the connection manager
virtual bool opened() const = 0;

// Initializes connection manager
virtual void open() = 0;

// Finalizes connection manager
virtual void close() = 0;       

// Connections

// Creates a UDP connection.
// The connection is created in the disconnected state and should be connected explicitly.
// The connection should be destroyed with UdpConnection::release().       
// It is possible to have several connections created at the same time.
virtual UdpConnection* createUdpConnection(const std::string& name, bool logData) = 0;

// Creates a TCP connection.
// The connection is created in the disconnected state and should be connected explicitly.
// The connection should be destroyed with TcpConnection::release().       
// It is possible to have several connections created at the same time.
virtual TcpConnection* createTcpConnection(const std::string& name, bool logData) = 0;

// Tasks

// Posts the task for asynchronous execution in the context of another thread.
// connectionManagerListener should stay alive until ConnectionManagerListener::onTask() is called.
virtual void postTask
(
    const std::string& name,
    void* parameters,
    ConnectionManagerListener* connectionManagerListener
) = 0;

Lse::Gtp::UdpConnection

Code Block
languagecpp
// Releasing
virtual void release() const = 0;

// Connection manager
virtual ConnectionManager* getConnectionManager() const = 0;

// Name
virtual std::string getName() const = 0;

// Returns the state of the connection
virtual bool connected() const = 0;

// Connects to the multicast group.
// connectionListener should stay alive until disconnect() is called.
virtual void connect
(
    const std::string& localAddress,
    const std::string& groupAddress,
    System::u16 port,
    UdpConnectionListener* connectionListener
) = 0;

// Disconnects from the multicast group.
// Should only be called if connect() succeeded.
virtual void disconnect() = 0;

Lse::Gtp::UdpConnectionListener

Code Block
languagecpp
// Data

// Returns the size of data to receive and pass to onDataReceived() or 0.
virtual size_t getDataSize(UdpConnection* connection, const void* data, size_t size) = 0;

// Called on data received.
virtual void onDataReceived(UdpConnection* connection, const void* data, size_t size) = 0;

// Called to notify no more data is available.
virtual void onNoData(UdpConnection* connection) = 0;

Lse::Gtp::TcpConnection

Code Block
// Releasing
virtual void release() const = 0;

// Connection manager
virtual ConnectionManager* getConnectionManager() const = 0;

// Name
virtual std::string getName() const = 0;

// Returns the state of the connection
virtual bool connected() const = 0;

// Connects to the remote endpoint.
virtual void connect(const std::string& localAddress, const std::string& remoteAddress, System::u16 port) = 0;

// Disconnects from the remote endpoint.
// Should only be called if connect() succeeded.
virtual void disconnect() = 0;

// Sending / receiving

// Sends the data synchronously.
virtual void sendData(const void* data, size_t size) = 0;

// Receives the size of data synchronously.
virtual void receiveData(void* data, size_t size) = 0;

Appendix B. Configuration file example

Code Block
languagexml
<?xml version="1.0"?>
<Application Name="GTP" LocalAddress="10.4.233.34" LogMessages="true" LogClientMessages="true" LogData="false" ThreadCount="8">
  <Services>
    <Service Name="Level 1" UserName="INEL01" ConnectInterval="3000" ConnectAttempts="3" MaxConnectAttempts="6" ReplayDelay="0">
      <RealTime>
        <Primary Address="224.0.112.9" Port="21679"/>
        <Secondary Address="224.0.112.10" Port="21680"/>
      </RealTime>
      <Replay DateLoginLimit="1000" DateRequestLimit="1000">
        <Primary Address="196.216.153.13" Port="21681"/>
        <Secondary Address="196.216.153.19" Port="21681"/>
      </Replay>
      <Recovery DateLoginLimit="500" DateRequestLimit="500">
        <Primary Address="196.216.153.13" Port="21682"/>
        <Secondary Address="196.216.153.19" Port="21682"/>
      </Recovery>
      <Instruments>
        <Instrument Id="6656671337" />
      </Instruments>
    </Service>
    <Service Name="Level 2" UserName="INEL01" ConnectInterval="3000" ConnectAttempts="3" MaxConnectAttempts="6" ReplayDelay="0">
      <RealTime>
        <Primary Address="224.0.112.5" Port="21651"/>
        <Secondary Address="224.0.112.6" Port="21652"/>
      </RealTime>
      <Replay DateLoginLimit="1000" DateRequestLimit="1000">
        <Primary Address="196.216.153.19" Port="21653"/>
        <Secondary Address="196.216.153.12" Port="21653"/>
      </Replay>
      <Recovery DateLoginLimit="500" DateRequestLimit="500">
        <Primary Address="196.216.153.19" Port="21654"/>
        <Secondary Address="196.216.153.12" Port="21654"/>
      </Recovery>
      <Segments>
        <Segment Code="TEST" />
      </Segments>
    </Service>
  </Services>
</Application>