Fault Tolerance

Backup Session

The backup session must use the same Universally Unique Identifier (UUID) as the primary session.

Before establishing the connection with the backup Market Segment Gateway, call OnixS::CME::iLink3::Session::faultToleranceIndicator(..) with the OnixS::CME::iLink3::Messaging::FTI::Backup argument.

Note

A backup session must be ready to activate in the same data state as the previous primary session being replaced. For example, inbound and outbound sequence numbers for a UUID must be maintained in a consistent state during failover between both sessions.

See also

The Fault Tolerance CME article.

Primary Session Failure

If the exchange does not receive a message from the primary session within two times the OnixS::CME::iLink3::SessionSettings::keepAliveInterval() value, then the exchange designates the primary session as failed and initiates the failover:

• Both the primary and backup sessions will be disconnected from the exchange, the backup session will receive the Terminate message with the OnixS::CME::iLink3::TerminateErrorCode::DisconnectFromPrimary error code.
• The backup session will be expected to connect to the primary Market Segment Gateway.

Primary Market Segment Gateway Failure

If the primary Market Segment Gateway Gateway fails, then the exchange initiates failover by electing the backup Market Segment Gateway to assume the primary role.

The backup session connected to this newly chosen Market Segment Gateway must act as the primary one. It is notified about the failover via the OnixS::CME::iLink3::SessionListener::onFailover callback.

After the failover the OnixS::CME::iLink3::Session::faultToleranceIndicator() method returns OnixS::CME::iLink3::Messaging::FTI::Primary.

Example

class MySessionListener : public OnixS::CME::iLink3::SessionListener
{
public:
    void onFailover(
        OnixS::CME::iLink3::Messaging::FTI::Enum faultToleranceIndicator,
        OnixS::CME::iLink3::Session* session
            ) override
    {
        std::clog << "Primary Market Segment Gateway Failure, faultToleranceIndicator=" << faultToleranceIndicator << std::endl;

        assert(FTI::Primary == faultToleranceIndicator);

        session->inSeqNum(lastKnownPrimarySessionInSeqNum);
        session->outSeqNum(lastKnownPrimarySessionOutSeqNum);
    }

    void onTerminate(const Messaging::Terminate507& message, Session* /* session */) override
    {
        if (TerminateErrorCode::DisconnectFromPrimary == message.errorCodes())
        {
            std::clog << "Primary Session Failure." << std::endl;
        }
    }

    ~MySessionListener() override {};
};

settings.licenseStore("../../license")
    .sessionId("SessionId")
    .secretKey("secretKey")
    .accessKey("accessKey")
    .firmId("firmId");

const int MarketSegmentId = 54;

MySessionListener listener;

Session primary(settings, MarketSegmentId, &listener);

primary.connect(PrimaryGateway, GatewayPort);

Session backup(
    settings,
    MarketSegmentId,
    &listener,
    SessionStorageType::FileBased,
    nullptr,
    primary.uuid(),
    "BackupSession");

backup.faultToleranceIndicator(FTI::Backup);

backup.connect(BackupGateway, GatewayPort);