| 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
// 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 | ||
|---|---|---|
| ||
<?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> |