SessionScheduler.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/

#pragma once

#include <string>
#include <set>

#include <OnixS/FIXEngine/ABI.h>

#include <OnixS/FIXEngine/Threading/Thread.h>

namespace OnixS {
namespace FIX {
ONIXS_FIXENGINE_API_DECL(class, Session);

namespace Scheduling {
ONIXS_FIXENGINE_API_DECL(class, SessionScheduler);

ONIXS_FIXENGINE_API_DECL(class, SessionSchedule);
ONIXS_FIXENGINE_API_DECL(class, SessionConnectionSettings);
ONIXS_FIXENGINE_API_DECL(class, Counterparty);

typedef std::string SessionScheduleId;
typedef std::string SessionConnectionSettingsId;

/// SessionScheduler events notifications.
class
    ONIXS_FIXENGINE_API
    SessionSchedulerListener
{
public:
    /// Notifies FIX session is about to be closed.
    /// @param scheduler identifies instance of session
    /// scheduler which is about to close scheduled session.
    /// @param session which is about to be closed.
    /// @param allowLogout defines whether the session
    /// scheduler must perform logout. To prohibit
    /// session logout it's necessary to set to 'false'.
    virtual
    void
    onLoggingOut(
        const SessionScheduler & scheduler,
        Session * session,
        bool * allowLogout) = 0;

    /// Allows scheduler's users to be notified when initiator will try
    /// to connect to the next counterparty.
    /// The parameter `Counterparty` provides a counterparty,
    /// to which session will connect.
    virtual
    void
    onInitiatorConnecting(
        const SessionScheduler &,
        Session *,
        const Counterparty &) {}

    /// Notifies about non-critical issue occurred
    /// while maintaining state for the given session.
    virtual
    void
    onWarning(
        const SessionScheduler & scheduler,
        Session * session,
        const std::string & warningReason) = 0;

    /// Notifies about error occurred while
    /// maintaining state for the given session.
    virtual
    void
    onError(
        const SessionScheduler & scheduler,
        Session * session,
        const std::string & errorReason) = 0;

protected:
    /// Class is not used for object life time managing.
    /// Therefore, destructor is in protected area.
    virtual ~SessionSchedulerListener() ONIXS_FIXENGINE_DEFAULT;
};

/// Collection of miscellaneous parameters
/// which affect session scheduler behavior.
class
    ONIXS_FIXENGINE_API
    SessionSchedulerOptions
{
public:
    /// Initializes parameters with default values.
    SessionSchedulerOptions();

    /// Initializes clone of the given instance.
    SessionSchedulerOptions(const SessionSchedulerOptions &);

    /// Cleans everything up.
    ~SessionSchedulerOptions();

    /// Path to scheduler configuration file.
    const std::string & configurationFile() const;

    /// Updates path to scheduler configuration file.
    void configurationFile(const std::string & file);

    /// Instance of event listener to notify about events.
    SessionSchedulerListener * eventListener() const;

    /// Associates given event listener with the scheduler.
    void eventListener(SessionSchedulerListener * listener);

    /// Reinitializes instance from the other one.
    SessionSchedulerOptions &
    operator = (const SessionSchedulerOptions & other);

private:
    std::string * configurationFile_;
    SessionSchedulerListener * eventListener_;
};

/// Scheduler performs session connection maintenance according
/// to the specified schedule for session activities. It monitors
/// whenever criteria to log a particular session either on or off
/// is triggered and automatically executes appropriate action.
class ONIXS_FIXENGINE_API SessionScheduler
{
public:
    /// Initializes Scheduler instance according to the options
    /// specified in given configuration file.
    ///
    /// If specified, Scheduler extracts from configuration a set
    /// of predefined session schedules and connection settings later
    /// available through Schedules and ConnectionSettings properties.
    SessionScheduler(
        const SessionSchedulerOptions & options);

    /// Performs graceful shutdown of scheduling services.
    ~SessionScheduler();

    /// Looks for the predefined session schedule
    /// associated with given unique names (ids) as it
    /// was specified in Scheduler's configuration file.
    /// @return NULL if no schedule available under given id.
    const
    SessionSchedule *
    findSchedule(const SessionScheduleId & id) const;

    /// Looks for the predefined session connection settings
    /// associated with given unique names (ids) as it was
    /// specified in Scheduler's configuration file.
    /// @return NULL if no settings available under given id.
    const
    SessionConnectionSettings *
    findConnectionSettings(
        const SessionConnectionSettingsId & id) const;

    /// Adds session to automatic connection management.
    ///
    /// If session is being added during active time frame,
    /// it will be connected immediately. If session is being
    /// registered during inactive time frame and has active state,
    /// it will be disconnected. If session already registered,
    /// exception will be thrown.
    ///
    /// @param session Instance of session to be maintained.
    /// @param schedule Schedule which defines session connection
    /// time, periodicity as well as other attributes.
    /// @param connection settings for given session to
    /// be used when session must be connected.
    void
    add(
        Session * session,
        const SessionSchedule & schedule,
        const SessionConnectionSettings & connection);

    /// Adds session to automatic connection management.
    ///
    /// If session is being added during active time frame,
    /// it will be connected immediately. If session is being
    /// registered during inactive time frame and has active state,
    /// it will be disconnected. If session already registered,
    /// exception will be thrown.
    ///
    /// @param session Instance of session to be maintained.
    /// @param scheduleId Id of predefined schedule
    /// to use for given session.
    /// @param connectionId Id of predefined connection
    /// settings to use for given session.
    void
    add(
        Session * session,
        const SessionScheduleId & scheduleId,
        const SessionConnectionSettingsId & connectionId);

    /// Removes session from automatic connection management services.
    /// If session were not registered before, does actually nothing.
    void remove(Session * session);

    /**
    * Sets the CPU affinity of the Scheduller service thread.
    */
    void serviceThreadAffinity(const OnixS::Threading::CpuIndexes & cpuIndexes);

    /**
    * Returns the CPU affinity of the Scheduller service thread.
    */
    const OnixS::Threading::CpuIndexes & serviceThreadAffinity() const;

    /**
    * Sets the number of logon attempts in case of a logon failure.
    */
    void reconnectAttempts(int value);

    /**
    * Returns the number of logon attempts in case of a logon failure.
    * By default, the option value is equal to 3.
    */
    int reconnectAttempts() const;

    /**
    * Sets the time interval between the logon attempts in case of a logon failure. (in seconds).
    */
    void reconnectInterval(int value);

    /**
    * Returns the time interval between the logon attempts in case of a logon failure. (in seconds).
    * By default, the option value is equal to 180 second.
    */
    int reconnectInterval() const;

    /**
    * This property allows switching local time to UTC time usage.
    */
    void utcTimeUsage(bool value);

    /**
    * Returns true if the UTC time is used otherwise false.
    * By default, the option value is false.
    */
    bool utcTimeUsage() const;

private:
    class Impl;
    Impl * impl_;
};
}
}
}