tyler.durden
/
icinga2
mirror of https://github.com/Icinga/icinga2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Implement modified attributes check_interval and retry_interval.

This commit is contained in:
Gunnar Beutner 2013-10-16 13:02:21 +02:00
parent 20fbce9c9c
commit 3596ee577b
5 changed files with 131 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
lib/icinga/externalcommandprocessor.cpp
View File

@ -182,6 +182,10 @@ void ExternalCommandProcessor::Initialize(void)
RegisterCommand("STOP_EXECUTING_SVC_CHECKS", &ExternalCommandProcessor::StopExecutingSvcChecks);
RegisterCommand("CHANGE_SVC_MODATTR", &ExternalCommandProcessor::ChangeSvcModattr);
RegisterCommand("CHANGE_HOST_MODATTR", &ExternalCommandProcessor::ChangeHostModattr);
RegisterCommand("CHANGE_NORMAL_SVC_CHECK_INTERVAL", &ExternalCommandProcessor::ChangeNormalSvcCheckInterval);
RegisterCommand("CHANGE_NORMAL_HOST_CHECK_INTERVAL", &ExternalCommandProcessor::ChangeNormalHostCheckInterval);
RegisterCommand("CHANGE_RETRY_SVC_CHECK_INTERVAL", &ExternalCommandProcessor::ChangeRetrySvcCheckInterval);
RegisterCommand("CHANGE_RETRY_HOST_CHECK_INTERVAL", &ExternalCommandProcessor::ChangeRetryHostCheckInterval);
}
void ExternalCommandProcessor::RegisterCommand(const String& command, const ExternalCommandProcessor::Callback& callback)
@ -1852,11 +1856,97 @@ void ExternalCommandProcessor::ChangeHostModattr(double time, const std::vector<
Log(LogInformation, "icinga", "Updating modified attributes for for host '" + arguments[0] + "'");
Service::Ptr hc = host->GetCheckService();
int modifiedAttributes = Convert::ToLong(arguments[2]);
int modifiedAttributes = Convert::ToLong(arguments[1]);
{
ObjectLock olock(hc);
hc->SetModifiedAttributes(modifiedAttributes);
}
}
void ExternalCommandProcessor::ChangeNormalSvcCheckInterval(double time, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
if (!service)
BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot update check interval for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
int interval = Convert::ToLong(arguments[2]);
Log(LogInformation, "icinga", "Updating check interval for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
service->SetCheckInterval(interval * 60);
}
}
void ExternalCommandProcessor::ChangeNormalHostCheckInterval(double time, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
if (!host)
BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot update check interval for non-existent host '" + arguments[0] + "'"));
Log(LogInformation, "icinga", "Updating check interval for for host '" + arguments[0] + "'");
Service::Ptr hc = host->GetCheckService();
int interval = Convert::ToLong(arguments[1]);
{
ObjectLock olock(hc);
hc->SetModifiedAttributes(interval * 60);
}
}
void ExternalCommandProcessor::ChangeRetrySvcCheckInterval(double time, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
if (!service)
BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot update retry interval for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
int interval = Convert::ToLong(arguments[2]);
Log(LogInformation, "icinga", "Updating retry interval for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
service->SetRetryInterval(interval * 60);
}
}
void ExternalCommandProcessor::ChangeRetryHostCheckInterval(double time, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
if (!host)
BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot update retry interval for non-existent host '" + arguments[0] + "'"));
Log(LogInformation, "icinga", "Updating check interval for for host '" + arguments[0] + "'");
Service::Ptr hc = host->GetCheckService();
int interval = Convert::ToLong(arguments[1]);
{
ObjectLock olock(hc);
hc->SetRetryInterval(interval * 60);
}
}

4
lib/icinga/externalcommandprocessor.h
View File

@ -133,6 +133,10 @@ private:
static void StopExecutingSvcChecks(double time, const std::vector<String>& arguments);
static void ChangeSvcModattr(double time, const std::vector<String>& arguments);
static void ChangeHostModattr(double time, const std::vector<String>& arguments);
static void ChangeNormalSvcCheckInterval(double time, const std::vector<String>& arguments);
static void ChangeNormalHostCheckInterval(double time, const std::vector<String>& arguments);
static void ChangeRetrySvcCheckInterval(double time, const std::vector<String>& arguments);
static void ChangeRetryHostCheckInterval(double time, const std::vector<String>& arguments);
};
}

25
lib/icinga/service-check.cpp
View File

@ -69,18 +69,33 @@ TimePeriod::Ptr Service::GetCheckPeriod(void) const
double Service::GetCheckInterval(void) const
{
if (m_CheckInterval.IsEmpty())
if (!m_OverrideCheckInterval.IsEmpty())
return m_OverrideCheckInterval;
else if (!m_CheckInterval.IsEmpty())
return m_CheckInterval;
else
return DefaultCheckInterval;
return m_CheckInterval;
}
void Service::SetCheckInterval(double interval)
{
m_OverrideCheckInterval = interval;
}
double Service::GetRetryInterval(void) const
{
if (m_RetryInterval.IsEmpty())
if (!m_OverrideRetryInterval.IsEmpty())
return m_OverrideRetryInterval;
if (!m_RetryInterval.IsEmpty())
return m_RetryInterval;
else
return GetCheckInterval() / CheckIntervalDivisor;
}
return m_RetryInterval;
void Service::SetRetryInterval(double interval)
{
m_OverrideRetryInterval = interval;
}
void Service::SetSchedulingOffset(long offset)

10
lib/icinga/service.cpp
View File

@ -343,6 +343,12 @@ int Service::GetModifiedAttributes(void) const
if (!m_OverrideEnablePassiveChecks.IsEmpty())
attrs |= ModAttrPassiveChecksEnabled;
if (!m_OverrideCheckInterval)
attrs |= ModAttrNormalCheckInterval;
if (!m_OverrideRetryInterval.IsEmpty())
attrs |= ModAttrRetryCheckInterval;
// TODO: finish
return attrs;
@ -493,6 +499,8 @@ void Service::InternalSerialize(const Dictionary::Ptr& bag, int attributeTypes)
bag->Set("enable_event_handlers", m_EnableEventHandlers);
bag->Set("override_enable_active_checks", m_OverrideEnableActiveChecks);
bag->Set("override_enable_passive_checks", m_OverrideEnablePassiveChecks);
bag->Set("override_check_interval", m_OverrideCheckInterval);
bag->Set("override_retry_interval", m_OverrideRetryInterval);
}
}
@ -555,5 +563,7 @@ void Service::InternalDeserialize(const Dictionary::Ptr& bag, int attributeTypes
m_EnableEventHandlers = bag->Get("enable_event_handlers");
m_OverrideEnableActiveChecks = bag->Get("override_enable_active_checks");
m_OverrideEnablePassiveChecks = bag->Get("override_enable_passive_checks");
m_OverrideCheckInterval = bag->Get("override_check_interval");
m_OverrideRetryInterval = bag->Get("override_retry_interval");
}
}

6
lib/icinga/service.h
View File

@ -172,8 +172,12 @@ public:
shared_ptr<CheckCommand> GetCheckCommand(void) const;
long GetMaxCheckAttempts(void) const;
TimePeriod::Ptr GetCheckPeriod(void) const;
double GetCheckInterval(void) const;
void SetCheckInterval(double interval);
double GetRetryInterval(void) const;
void SetRetryInterval(double interval);
long GetSchedulingOffset(void);
void SetSchedulingOffset(long offset);
@ -392,7 +396,9 @@ private:
Value m_MaxCheckAttempts;
String m_CheckPeriod;
Value m_CheckInterval;
Value m_OverrideCheckInterval;
Value m_RetryInterval;
Value m_OverrideRetryInterval;
double m_NextCheck;
String m_CurrentChecker;
Value m_CheckAttempt;