Bugfixes for the *:Invalidate*Cache() calls.

components/checker/checkercomponent.cpp

@@ -109,6 +109,11 @@ void CheckerComponent::CheckThreadProc(void)
 			continue;
 		}
 
+		m_IdleServices.erase(service);
+		m_PendingServices.insert(service);
+
+		lock.unlock();
+
 		{
 			ObjectLock olock(service);
 			service->SetForceNextCheck(false);
@@ -116,15 +121,14 @@ void CheckerComponent::CheckThreadProc(void)
 
 		Logger::Write(LogDebug, "checker", "Executing service check for '" + service->GetName() + "'");
 
-		m_IdleServices.erase(service);
-		m_PendingServices.insert(service);
-
 		try {
 			CheckerComponent::Ptr self = GetSelf();
 			service->BeginExecuteCheck(boost::bind(&CheckerComponent::CheckCompletedHandler, self, service));
 		} catch (const exception& ex) {
 			Logger::Write(LogCritical, "checker", "Exception occured while checking service '" + service->GetName() + "': " + diagnostic_information(ex));
 		}
+
+		lock.lock();
 	}
 }
 

lib/base/timer.cpp

@@ -173,15 +173,8 @@ void Timer::Reschedule(double next)
 
 	boost::mutex::scoped_lock lock(m_Mutex);
 
-	if (next < 0) {
+	if (next < 0)
-		double now = Utility::GetTime();
+		next = Utility::GetTime() + m_Interval;
-		next = m_Next + m_Interval;
-
-		if (next < now)
-			next = now + m_Interval;
-		else
-			next = next;
-	}
 
 	m_Next = next;
 

lib/icinga/host.cpp

@@ -333,9 +333,9 @@ void Host::InvalidateServicesCache(void)
 			m_ServicesCacheTimer = boost::make_shared<Timer>();
 			m_ServicesCacheTimer->SetInterval(0.5);
 			m_ServicesCacheTimer->OnTimerExpired.connect(boost::bind(&Host::RefreshServicesCache));
+			m_ServicesCacheTimer->Start();
 		}
 
-		m_ServicesCacheTimer->Start();
 		m_ServicesCacheNeedsUpdate = true;
 	}
 }
@@ -345,12 +345,13 @@ void Host::RefreshServicesCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_ServiceMutex);
 
-		assert(m_ServicesCacheNeedsUpdate);
+		if (!m_ServicesCacheNeedsUpdate)
-		m_ServicesCacheTimer->Stop();
+			return;
+
 		m_ServicesCacheNeedsUpdate = false;
 	}
 
-	Logger::Write(LogInformation, "icinga", "Updating services cache.");
+	Logger::Write(LogInformation, "icinga", "Updating Host services cache.");
 
 	map<String, map<String, Service::WeakPtr> > newServicesCache;
 

lib/icinga/hostgroup.cpp

@@ -128,9 +128,9 @@ void HostGroup::InvalidateMembersCache(void)
 		m_MembersCacheTimer = boost::make_shared<Timer>();
 		m_MembersCacheTimer->SetInterval(0.5);
 		m_MembersCacheTimer->OnTimerExpired.connect(boost::bind(&HostGroup::RefreshMembersCache));
+		m_MembersCacheTimer->Start();
 	}
 
-	m_MembersCacheTimer->Start();
 	m_MembersCacheNeedsUpdate = true;
 }
 
@@ -142,11 +142,14 @@ void HostGroup::RefreshMembersCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_Mutex);
 
-		assert(m_MembersCacheNeedsUpdate);
+		if (!m_MembersCacheNeedsUpdate)
-		m_MembersCacheTimer->Stop();
+			return;
+
 		m_MembersCacheNeedsUpdate = false;
 	}
 
+	Logger::Write(LogInformation, "icinga", "Updating HostGroup members cache.");
+
 	map<String, vector<Host::WeakPtr> > newMembersCache;
 
 	BOOST_FOREACH(const DynamicObject::Ptr& object, DynamicType::GetObjects("Host")) {

lib/icinga/service-comment.cpp

@@ -184,9 +184,9 @@ void Service::InvalidateCommentsCache(void)
 		m_CommentsCacheTimer = boost::make_shared<Timer>();
 		m_CommentsCacheTimer->SetInterval(0.5);
 		m_CommentsCacheTimer->OnTimerExpired.connect(boost::bind(&Service::RefreshCommentsCache));
+		m_CommentsCacheTimer->Start();
 	}
 
-	m_CommentsCacheTimer->Start();
 	m_CommentsCacheNeedsUpdate = true;
 }
 
@@ -198,11 +198,14 @@ void Service::RefreshCommentsCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_CommentMutex);
 
-		assert(m_CommentsCacheNeedsUpdate);
+		if (!m_CommentsCacheNeedsUpdate)
-		m_CommentsCacheTimer->Stop();
+			return;
+
 		m_CommentsCacheNeedsUpdate = false;
 	}
 
+	Logger::Write(LogInformation, "icinga", "Updating Service comments cache.");
+
 	map<int, String> newLegacyCommentsCache;
 	map<String, Service::WeakPtr> newCommentsCache;
 

lib/icinga/service-downtime.cpp

@@ -258,9 +258,9 @@ void Service::InvalidateDowntimesCache(void)
 		m_DowntimesCacheTimer = boost::make_shared<Timer>();
 		m_DowntimesCacheTimer->SetInterval(0.5);
 		m_DowntimesCacheTimer->OnTimerExpired.connect(boost::bind(&Service::RefreshNotificationsCache));
+		m_DowntimesCacheTimer->Start();
 	}
 
-	m_DowntimesCacheTimer->Start();
 	m_DowntimesCacheNeedsUpdate = true;
 }
 
@@ -272,11 +272,14 @@ void Service::RefreshDowntimesCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_DowntimeMutex);
 
-		assert(m_DowntimesCacheNeedsUpdate);
+		if (!m_DowntimesCacheNeedsUpdate)
-		m_DowntimesCacheTimer->Stop();
+			return;
+
 		m_DowntimesCacheNeedsUpdate = false;
 	}
 
+	Logger::Write(LogInformation, "icinga", "Updating Service downtimes cache.");
+
 	map<int, String> newLegacyDowntimesCache;
 	map<String, Service::WeakPtr> newDowntimesCache;
 

lib/icinga/service-notification.cpp

@@ -94,9 +94,9 @@ void Service::InvalidateNotificationsCache(void)
 		m_NotificationsCacheTimer = boost::make_shared<Timer>();
 		m_NotificationsCacheTimer->SetInterval(0.5);
 		m_NotificationsCacheTimer->OnTimerExpired.connect(boost::bind(&Service::RefreshNotificationsCache));
+		m_NotificationsCacheTimer->Start();
 	}
 
-	m_NotificationsCacheTimer->Start();
 	m_NotificationsCacheNeedsUpdate = true;
 }
 
@@ -108,11 +108,14 @@ void Service::RefreshNotificationsCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_NotificationMutex);
 
-		assert(m_NotificationsCacheNeedsUpdate);
+		if (!m_NotificationsCacheNeedsUpdate)
-		m_NotificationsCacheTimer->Stop();
+			return;
+
 		m_NotificationsCacheNeedsUpdate = false;
 	}
 
+	Logger::Write(LogInformation, "icinga", "Updating Service notifications cache.");
+
 	map<String, set<Notification::WeakPtr> > newNotificationsCache;
 
 	BOOST_FOREACH(const DynamicObject::Ptr& object, DynamicType::GetObjects("Notification")) {

lib/icinga/servicegroup.cpp

@@ -128,9 +128,9 @@ void ServiceGroup::InvalidateMembersCache(void)
 		m_MembersCacheTimer = boost::make_shared<Timer>();
 		m_MembersCacheTimer->SetInterval(0.5);
 		m_MembersCacheTimer->OnTimerExpired.connect(boost::bind(&ServiceGroup::RefreshMembersCache));
+		m_MembersCacheTimer->Start();
 	}
 
-	m_MembersCacheTimer->Start();
 	m_MembersCacheNeedsUpdate = true;
 }
 
@@ -142,11 +142,14 @@ void ServiceGroup::RefreshMembersCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_Mutex);
 
-		assert(m_MembersCacheNeedsUpdate);
+		if (!m_MembersCacheNeedsUpdate)
-		m_MembersCacheTimer->Stop();
+			return;
+
 		m_MembersCacheNeedsUpdate = false;
 	}
 
+	Logger::Write(LogInformation, "icinga", "Updating ServiceGroup members cache.");
+
 	map<String, vector<Service::WeakPtr> > newMembersCache;
 
 	BOOST_FOREACH(const DynamicObject::Ptr& object, DynamicType::GetObjects("Service")) {

lib/icinga/usergroup.cpp

@@ -23,7 +23,8 @@ using namespace icinga;
 
 boost::mutex UserGroup::m_Mutex;
 map<String, vector<User::WeakPtr> > UserGroup::m_MembersCache;
-bool UserGroup::m_MembersCacheValid = true;
+bool UserGroup::m_MembersCacheNeedsUpdate = false;
+Timer::Ptr UserGroup::m_MembersCacheTimer;
 
 REGISTER_TYPE(UserGroup);
 
@@ -102,10 +103,17 @@ void UserGroup::InvalidateMembersCache(void)
 {
 	boost::mutex::scoped_lock lock(m_Mutex);
 
-	if (m_MembersCacheValid)
+	if (m_MembersCacheNeedsUpdate)
-		Utility::QueueAsyncCallback(boost::bind(&UserGroup::RefreshMembersCache));
+		return; /* Someone else has already requested a refresh. */
 
-	m_MembersCacheValid = false;
+	if (!m_MembersCacheTimer) {
+		m_MembersCacheTimer = boost::make_shared<Timer>();
+		m_MembersCacheTimer->SetInterval(0.5);
+		m_MembersCacheTimer->OnTimerExpired.connect(boost::bind(&UserGroup::RefreshMembersCache));
+		m_MembersCacheTimer->Start();
+	}
+
+	m_MembersCacheNeedsUpdate = true;
 }
 
 /**
@@ -116,12 +124,14 @@ void UserGroup::RefreshMembersCache(void)
 	{
 		boost::mutex::scoped_lock lock(m_Mutex);
 
-		if (m_MembersCacheValid)
+		if (!m_MembersCacheNeedsUpdate)
 			return;
 
-		m_MembersCacheValid = true;
+		m_MembersCacheNeedsUpdate = false;
 	}
 
+	Logger::Write(LogInformation, "icinga", "Updating UserGroup members cache.");
+
 	map<String, vector<User::WeakPtr> > newMembersCache;
 
 	BOOST_FOREACH(const DynamicObject::Ptr& object, DynamicType::GetObjects("User")) {

lib/icinga/usergroup.h

@@ -53,7 +53,8 @@ private:
 
 	static boost::mutex m_Mutex;
 	static map<String, vector<User::WeakPtr> > m_MembersCache;
-	static bool m_MembersCacheValid;
+	static bool m_MembersCacheNeedsUpdate;
+	static Timer::Ptr m_MembersCacheTimer;
 
 	static void RefreshMembersCache(void);
 };