Session Scheduler Sample

This sample demonstrates the usage of the Session Scheduler functionality.

Source code

/*
* 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.
*/
 
#include <OnixS/ICE/BOE/Session.h>
#include <OnixS/ICE/BOE/scheduling/SessionScheduler.h>
 
#include <OnixS/ICE/BOE/threading/Thread.h>
 
#include <Common/Helpers.h>
#include <Common/Settings.h>
#include <Common/Emulator.h>
 
using namespace OnixS::ICE;
using namespace OnixS::ICE::BOE;
using namespace OnixS::ICE::BOE::Scheduling;
using namespace Samples;
 
class SessionStateChangeTracer : public SessionListener
{
    void onStateChange(SessionStateId::Enum newState, SessionStateId::Enum /*prevState*/, Session * session) override
    {
        std::cout << session->toString() << " changed its state to " << SessionStateId::toString(newState) << '.' << std::endl;
    }
};
 
class SchedulingIssueDetector : public SessionSchedulerListener
{
public:
    SchedulingIssueDetector() = default;
 
    ~SchedulingIssueDetector() override = default;
 
    void onWarning(const SessionScheduler & /*scheduler*/, Session * session, const std::string & warningReason) override
    {
        std::cout << "Scheduler reported a warning for the session " << session->toString() << ": " << warningReason;
    }
 
    void onError(const SessionScheduler & /*scheduler*/, Session * session, const std::string & errorReason) override
    {
        std::cout << "Error occurred while scheduling session " << session->toString() << ": " << errorReason;
    }
};
 
TimeOfDay operator+ (TimeOfDay time, Scheduling::Seconds seconds)
{
    const Scheduling::Seconds SecondsPerMinute = 60;
    const int MinutesPerHour = 60;
    const Scheduling::Seconds SecondsPerHour = SecondsPerMinute * MinutesPerHour;
 
    const Scheduling::Seconds sinceMidnight = time.sinceMidnight() + seconds;
 
    return TimeOfDay(
        sinceMidnight / SecondsPerHour,
        (sinceMidnight / SecondsPerMinute) % MinutesPerHour,
        sinceMidnight % SecondsPerMinute);
}
 
SessionSchedule constructShortTimeActivitySchedule(int delayInSeconds = 5)
{
    const int sessionActivityTimeInSeconds = 30;
 
    const TimeOfDay now = TimeOfDay::now();
 
    const TimeOfDay logonTime = now + Scheduling::Seconds(delayInSeconds);
 
    const TimeOfDay logoutTime = logonTime + Scheduling::Seconds(sessionActivityTimeInSeconds);
 
    return SessionSchedule(DayOfWeek::now(), DayOfWeek::now(), logonTime, logoutTime);
}
 
void waitUntilState(Session* session, SessionStateId::Enum state, unsigned pollMs = 1000)
{
    while (session->state() != state)
        Threading::ThisThread::sleep(pollMs);
}
 
int main(int argc, char * argv[])
{
    // `--help` to show options.
    const AppConfiguration<
        SettingsConfiguration
        , ConnectivityConfiguration
        , LogonConfiguration
        , StorageConfiguration<SessionStorageType::FileBased>
    > cfg{ "Session Scheduler", argc, argv };
 
    try
    {
        auto sessionSettings = fillSettings(cfg);
 
        const auto emulator = createEmulator(sessionSettings, cfg);
 
        SessionStateChangeTracer sessionStateChangeTracer_;
 
        // Construct a BUS session.
        BusSession busSession(sessionSettings, &sessionStateChangeTracer_);
 
        // Construct a BGW session.
        BgwSession bgwSession(sessionSettings, &sessionStateChangeTracer_);
 
        // Construct a scheduler.
        SchedulingIssueDetector schedulingIssueDetector_;
        SessionSchedulerOptions schedulerOptions;
        schedulerOptions.eventListener(&schedulingIssueDetector_);
        SessionScheduler scheduler(schedulerOptions);
 
        // Start a thread to dispatch events for the scheduler.
        std::atomic<bool> stopSchedulerThread{ false };
        std::thread schedulerThread([&]()
            {
                const int spinWaitMicrosecondPause = 1000;
                while (!stopSchedulerThread)
                {
                    scheduler.dispatchEvents();
                    Threading::ThisThread::spinWait(spinWaitMicrosecondPause);
                }
            });
 
        std::cout << "Scheduling BUS session " << busSession.toString() << " for automatic connection." << std::endl;
        const SessionSchedule sessionScheduleForBus = constructShortTimeActivitySchedule(5);
        const SessionConnectionSettings sessionConnectivityForBus(cfg.host(), cfg.port());
        scheduler.add(&busSession, sessionScheduleForBus, sessionConnectivityForBus);
 
        std::cout << "Scheduling BGW session " << bgwSession.toString() << " for automatic connection." << std::endl;
        //Give BGW session additional 5 seconds to ensure BUS session started
        const SessionSchedule sessionScheduleForBgw = constructShortTimeActivitySchedule(10);
        scheduler.add(&bgwSession, sessionScheduleForBgw, &busSession);
 
        std::cout << "Waiting for activity on scheduled sessions " << bgwSession.toString() << '.' << std::endl << std::endl;
 
        // Should sleep for a while to let Scheduler connect session.
        waitUntilState(&bgwSession, SessionStateId::Established);
 
        waitUntilState(&bgwSession, SessionStateId::Disconnected);
 
        std::cout << std::endl << "Removing sessions from scheduling service." << std::endl;
 
        // The sessions have to 'pulse' connection till this time so that scheduling could be destroyed.
        scheduler.remove(&busSession);
        scheduler.remove(&bgwSession);
 
        stopSchedulerThread = true;
        schedulerThread.join();
 
        std::cout << std::endl << "Done." << std::endl;
    }
    catch(const std::exception & ex)
    {
        std::cerr << "Error: " << ex.what() << std::endl;
        return 1;
    }
 
    return 0;
}