SessionScheduler.cpp File Reference

Go to the source code of this file.

Classes
class	SessionStateChangeTracer
class	SchedulingIssueDetector

Functions
TimeOfDay	operator+ (TimeOfDay time, Scheduling::Seconds seconds)
SessionSchedule	constructShortTimeActivitySchedule (int delayInSeconds=5)
void	waitUntilState (Session *session, SessionStateId::Enum state, unsigned pollMs=1000)
int	main (int argc, char *argv[])

Function Documentation

constructShortTimeActivitySchedule()

SessionSchedule constructShortTimeActivitySchedule

(

int

delayInSeconds = 5

)

Definition at line 74 of file SessionScheduler.cpp.

{
    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);
}

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 93 of file SessionScheduler.cpp.

{
    // `--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;
}

operator+()

TimeOfDay operator+	(	TimeOfDay	time,
		Scheduling::Seconds	seconds )

Definition at line 60 of file SessionScheduler.cpp.

{
    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);
}

waitUntilState()

void waitUntilState	(	Session *	session,
		SessionStateId::Enum	state,
		unsigned	pollMs = 1000 )

Definition at line 87 of file SessionScheduler.cpp.

{
    while (session->state() != state)
        Threading::ThisThread::sleep(pollMs);
}