icinga2/base/timer.cpp

163 lines
3.7 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-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;
}
/**
2012-06-22 11:19:58 +02:00
* Calls expired timers and returned when the next wake-up should happen.
*
* @returns Time when the next timer is due.
*/
2012-06-22 11:19:58 +02:00
long Timer::ProcessTimers(void)
2012-03-28 13:24:49 +02:00
{
2012-06-22 11:19:58 +02:00
long wakeup = 30;
2012-03-28 13:24:49 +02:00
2012-06-22 23:19:10 +02:00
time_t st;
time(&st);
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
2012-06-22 11:19:58 +02:00
time_t now;
time(&now);
2012-03-28 13:24:49 +02:00
if (timer->m_Next <= now) {
timer->Call();
2012-06-22 11:19:58 +02:00
/* time may have changed depending on how long the
* timer call took - we need to fetch the current time */
time(&now);
timer->Reschedule(now + timer->GetInterval());
2012-03-28 13:24:49 +02:00
}
2012-06-22 11:19:58 +02:00
assert(timer->m_Next > now);
if (timer->m_Next - now < wakeup)
wakeup = timer->m_Next - now;
2012-03-28 13:24:49 +02:00
}
2012-06-22 11:19:58 +02:00
assert(wakeup > 0);
2012-06-22 23:19:10 +02:00
time_t et;
time(&et);
stringstream msgbuf;
msgbuf << "Timers took " << et - st << " seconds";
Application::Log(LogDebug, "base", msgbuf.str());
2012-06-22 11:19:58 +02:00
return wakeup;
2012-03-28 13:24:49 +02:00
}
/**
* 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)
{
time_t st;
time(&st);
OnTimerExpired(GetSelf());
time_t et;
time(&et);
2012-06-21 00:10:10 +02:00
if (et - st > 3) {
stringstream msgbuf;
msgbuf << "Timer call took " << et - st << " seconds.";
2012-06-21 17:39:16 +02:00
Application::Log(LogWarning, "base", msgbuf.str());
}
2012-03-28 13:24:49 +02:00
}
/**
* Sets the interval for this timer.
*
* @param interval The new interval.
*/
2012-06-22 11:19:58 +02:00
void Timer::SetInterval(long interval)
2012-03-28 13:24:49 +02:00
{
2012-06-22 11:19:58 +02:00
if (interval <= 0)
throw invalid_argument("interval");
2012-03-28 13:24:49 +02:00
m_Interval = interval;
}
/**
* Retrieves the interval for this timer.
*
* @returns The interval.
*/
2012-06-22 11:19:58 +02:00
long Timer::GetInterval(void) const
2012-03-28 13:24:49 +02:00
{
return m_Interval;
}
/**
* Registers the timer and starts processing events for it.
*/
2012-03-28 13:24:49 +02:00
void Timer::Start(void)
{
Stop();
Timers.push_back(GetSelf());
2012-06-18 01:58:13 +02:00
Reschedule(time(NULL) + m_Interval);
2012-03-28 13:24:49 +02:00
}
/**
* 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;
}