icinga2/base/timer.cpp

177 lines
4.1 KiB
C++
Raw Normal View History

/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
2012-05-11 13:33:57 +02:00
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
2012-03-28 13:24:49 +02:00
#include "i2-base.h"
using namespace icinga;
2012-03-30 19:56:54 +02:00
time_t Timer::NextCall;
2012-04-19 08:46:41 +02:00
Timer::CollectionType Timer::Timers;
2012-03-28 13:24:49 +02:00
/**
* Constructor for the Timer class.
*/
2012-03-28 13:24:49 +02:00
Timer::Timer(void)
{
m_Interval = 0;
}
/**
* Retrieves when the next timer is due.
*
* @returns Time when the next timer is due.
*/
2012-03-28 13:24:49 +02:00
time_t Timer::GetNextCall(void)
{
2012-03-30 19:56:54 +02:00
if (NextCall < time(NULL))
2012-03-28 13:24:49 +02:00
Timer::RescheduleTimers();
2012-03-30 19:56:54 +02:00
return NextCall;
2012-03-28 13:24:49 +02:00
}
/**
* Reschedules all timers, thereby updating the NextCall
* timestamp used by the GetNextCall() function.
*/
2012-03-28 13:24:49 +02:00
void Timer::RescheduleTimers(void)
{
/* Make sure we wake up at least once every 30 seconds */
2012-03-30 19:56:54 +02:00
NextCall = time(NULL) + 30;
2012-03-28 13:24:49 +02:00
2012-04-19 08:46:41 +02:00
for (Timer::CollectionType::iterator i = Timers.begin(); i != Timers.end(); i++) {
Timer::Ptr timer = i->lock();
2012-03-28 13:24:49 +02:00
if (timer == NULL)
continue;
2012-03-30 19:56:54 +02:00
if (timer->m_Next < NextCall)
NextCall = timer->m_Next;
2012-03-28 13:24:49 +02:00
}
}
/**
* Calls all expired timers and reschedules them.
*/
2012-03-28 13:24:49 +02:00
void Timer::CallExpiredTimers(void)
{
time_t now;
time(&now);
2012-04-20 16:21:43 +02:00
Timer::CollectionType::iterator prev, i;
for (i = Timers.begin(); i != Timers.end(); ) {
Timer::Ptr timer = i->lock();
prev = i;
2012-03-28 13:24:49 +02:00
i++;
2012-04-20 16:21:43 +02:00
if (!timer) {
Timers.erase(prev);
2012-03-28 13:24:49 +02:00
continue;
2012-04-20 16:21:43 +02:00
}
2012-03-28 13:24:49 +02:00
if (timer->m_Next <= now) {
timer->Call();
timer->Reschedule(now + timer->GetInterval());
}
}
}
/**
* Calls this timer. Note: the timer delegate must not call
* Disable() on any other timers than the timer that originally
* invoked the delegate.
*/
2012-03-28 13:24:49 +02:00
void Timer::Call(void)
{
2012-04-18 15:22:25 +02:00
TimerEventArgs tea;
tea.Source = shared_from_this();
tea.UserArgs = m_UserArgs;
OnTimerExpired(tea);
2012-03-28 13:24:49 +02:00
}
/**
* Sets the interval for this timer.
*
* @param interval The new interval.
*/
2012-03-28 13:24:49 +02:00
void Timer::SetInterval(unsigned int interval)
{
m_Interval = interval;
}
/**
* Retrieves the interval for this timer.
*
* @returns The interval.
*/
2012-03-28 13:24:49 +02:00
unsigned int Timer::GetInterval(void) const
{
return m_Interval;
}
/**
* Sets user arguments for the timer callback.
*
* @param userArgs The user arguments.
*/
2012-04-18 15:22:25 +02:00
void Timer::SetUserArgs(const EventArgs& userArgs)
{
m_UserArgs = userArgs;
}
/**
* Retrieves the user arguments for the timer callback.
*
* @returns The user arguments.
*/
2012-04-18 15:22:25 +02:00
EventArgs Timer::GetUserArgs(void) const
{
return m_UserArgs;
}
/**
* Registers the timer and starts processing events for it.
*/
2012-03-28 13:24:49 +02:00
void Timer::Start(void)
{
Timers.push_back(static_pointer_cast<Timer>(shared_from_this()));
2012-03-28 13:24:49 +02:00
Reschedule(time(NULL) + m_Interval);
}
/**
* Unregisters the timer and stops processing events for it.
*/
2012-03-28 13:24:49 +02:00
void Timer::Stop(void)
{
Timers.remove_if(WeakPtrEqual<Timer>(this));
2012-03-28 13:24:49 +02:00
}
/**
* Reschedules this timer.
*
* @param next The time when this timer should be called again.
*/
2012-03-28 13:24:49 +02:00
void Timer::Reschedule(time_t next)
{
m_Next = next;
RescheduleTimers();
}