/******************************************************************************
* Icinga 2 *
- * Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/) *
+ * Copyright (C) 2012-2013 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 *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
-#include "i2-icinga.h"
+#include "icinga/externalcommandprocessor.h"
+#include "icinga/host.h"
+#include "icinga/service.h"
+#include "icinga/user.h"
+#include "icinga/hostgroup.h"
+#include "icinga/servicegroup.h"
+#include "icinga/pluginchecktask.h"
+#include "base/convert.h"
+#include "base/logger_fwd.h"
+#include "base/objectlock.h"
+#include "base/application.h"
+#include "base/utility.h"
+#include <fstream>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/foreach.hpp>
+#include <boost/exception/diagnostic_information.hpp>
+#include <boost/algorithm/string/split.hpp>
using namespace icinga;
boost::once_flag ExternalCommandProcessor::m_InitializeOnce = BOOST_ONCE_INIT;
boost::mutex ExternalCommandProcessor::m_Mutex;
-map<String, ExternalCommandProcessor::Callback> ExternalCommandProcessor::m_Commands;
+std::map<String, ExternalCommandProcessor::Callback> ExternalCommandProcessor::m_Commands;
-/**
- * @threadsafety Always.
- */
void ExternalCommandProcessor::Execute(const String& line)
{
if (line.IsEmpty())
return;
if (line[0] != '[')
- BOOST_THROW_EXCEPTION(invalid_argument("Missing timestamp in command: " + line));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Missing timestamp in command: " + line));
size_t pos = line.FindFirstOf("]");
if (pos == String::NPos)
- BOOST_THROW_EXCEPTION(invalid_argument("Missing timestamp in command: " + line));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Missing timestamp in command: " + line));
String timestamp = line.SubStr(1, pos - 1);
String args = line.SubStr(pos + 2, String::NPos);
double ts = Convert::ToDouble(timestamp);
if (ts == 0)
- BOOST_THROW_EXCEPTION(invalid_argument("Invalid timestamp in command: " + line));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid timestamp in command: " + line));
- vector<String> argv = args.Split(is_any_of(";"));
+ std::vector<String> argv;
+ boost::algorithm::split(argv, args, boost::is_any_of(";"));
if (argv.empty())
- BOOST_THROW_EXCEPTION(invalid_argument("Missing arguments in command: " + line));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Missing arguments in command: " + line));
- vector<String> argvExtra(argv.begin() + 1, argv.end());
+ std::vector<String> argvExtra(argv.begin() + 1, argv.end());
Execute(ts, argv[0], argvExtra);
}
-/**
- * @threadsafety Always.
- */
-void ExternalCommandProcessor::Execute(double time, const String& command, const vector<String>& arguments)
+void ExternalCommandProcessor::Execute(double time, const String& command, const std::vector<String>& arguments)
{
boost::call_once(m_InitializeOnce, &ExternalCommandProcessor::Initialize);
{
boost::mutex::scoped_lock lock(m_Mutex);
- map<String, ExternalCommandProcessor::Callback>::iterator it;
+ std::map<String, ExternalCommandProcessor::Callback>::iterator it;
it = m_Commands.find(command);
if (it == m_Commands.end())
- BOOST_THROW_EXCEPTION(invalid_argument("The external command '" + command + "' does not exist."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("The external command '" + command + "' does not exist."));
callback = it->second;
}
callback(time, arguments);
}
-/**
- * @threadsafety Always.
- */
void ExternalCommandProcessor::Initialize(void)
{
RegisterCommand("PROCESS_HOST_CHECK_RESULT", &ExternalCommandProcessor::ProcessHostCheckResult);
RegisterCommand("ENABLE_SVC_CHECK", &ExternalCommandProcessor::EnableSvcCheck);
RegisterCommand("DISABLE_SVC_CHECK", &ExternalCommandProcessor::DisableSvcCheck);
RegisterCommand("SHUTDOWN_PROCESS", &ExternalCommandProcessor::ShutdownProcess);
+ RegisterCommand("RESTART_PROCESS", &ExternalCommandProcessor::RestartProcess);
RegisterCommand("SCHEDULE_FORCED_HOST_SVC_CHECKS", &ExternalCommandProcessor::ScheduleForcedHostSvcChecks);
RegisterCommand("SCHEDULE_HOST_SVC_CHECKS", &ExternalCommandProcessor::ScheduleHostSvcChecks);
RegisterCommand("ENABLE_HOST_SVC_CHECKS", &ExternalCommandProcessor::EnableHostSvcChecks);
RegisterCommand("ACKNOWLEDGE_HOST_PROBLEM", &ExternalCommandProcessor::AcknowledgeHostProblem);
RegisterCommand("ACKNOWLEDGE_HOST_PROBLEM_EXPIRE", &ExternalCommandProcessor::AcknowledgeHostProblemExpire);
RegisterCommand("REMOVE_HOST_ACKNOWLEDGEMENT", &ExternalCommandProcessor::RemoveHostAcknowledgement);
+ RegisterCommand("DISABLE_HOST_FLAP_DETECTION", &ExternalCommandProcessor::DisableHostFlapping);
+ RegisterCommand("ENABLE_HOST_FLAP_DETECTION", &ExternalCommandProcessor::EnableHostFlapping);
+ RegisterCommand("DISABLE_SVC_FLAP_DETECTION", &ExternalCommandProcessor::DisableSvcFlapping);
+ RegisterCommand("ENABLE_SVC_FLAP_DETECTION", &ExternalCommandProcessor::EnableSvcFlapping);
RegisterCommand("ENABLE_HOSTGROUP_SVC_CHECKS", &ExternalCommandProcessor::EnableHostgroupSvcChecks);
RegisterCommand("DISABLE_HOSTGROUP_SVC_CHECKS", &ExternalCommandProcessor::DisableHostgroupSvcChecks);
RegisterCommand("ENABLE_SERVICEGROUP_SVC_CHECKS", &ExternalCommandProcessor::EnableServicegroupSvcChecks);
RegisterCommand("DISABLE_HOST_NOTIFICATIONS", &ExternalCommandProcessor::DisableHostNotifications);
RegisterCommand("ENABLE_SVC_NOTIFICATIONS", &ExternalCommandProcessor::EnableSvcNotifications);
RegisterCommand("DISABLE_SVC_NOTIFICATIONS", &ExternalCommandProcessor::DisableSvcNotifications);
+ RegisterCommand("DISABLE_HOSTGROUP_HOST_CHECKS", &ExternalCommandProcessor::DisableHostgroupHostChecks);
+ RegisterCommand("DISABLE_HOSTGROUP_PASSIVE_HOST_CHECKS", &ExternalCommandProcessor::DisableHostgroupPassiveHostChecks);
+ RegisterCommand("DISABLE_SERVICEGROUP_HOST_CHECKS", &ExternalCommandProcessor::DisableServicegroupHostChecks);
+ RegisterCommand("DISABLE_SERVICEGROUP_PASSIVE_HOST_CHECKS", &ExternalCommandProcessor::DisableServicegroupPassiveHostChecks);
+ RegisterCommand("ENABLE_HOSTGROUP_HOST_CHECKS", &ExternalCommandProcessor::EnableHostgroupHostChecks);
+ RegisterCommand("ENABLE_HOSTGROUP_PASSIVE_HOST_CHECKS", &ExternalCommandProcessor::EnableHostgroupPassiveHostChecks);
+ RegisterCommand("ENABLE_SERVICEGROUP_HOST_CHECKS", &ExternalCommandProcessor::EnableServicegroupHostChecks);
+ RegisterCommand("ENABLE_SERVICEGROUP_PASSIVE_HOST_CHECKS", &ExternalCommandProcessor::EnableServicegroupPassiveHostChecks);
}
-/**
- * @threadsafety Always.
- */
void ExternalCommandProcessor::RegisterCommand(const String& command, const ExternalCommandProcessor::Callback& callback)
{
boost::mutex::scoped_lock lock(m_Mutex);
m_Commands[command] = callback;
}
-void ExternalCommandProcessor::ProcessHostCheckResult(double time, const vector<String>& arguments)
+void ExternalCommandProcessor::ProcessHostCheckResult(double time, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 3 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot passive host check result for non-existent host '" + arguments[0] + "'"));
+
+ Service::Ptr hc = host->GetCheckService();
if (!hc->GetEnablePassiveChecks())
- BOOST_THROW_EXCEPTION(invalid_argument("Got passive check result for host '" + arguments[0] + "' which has passive checks disabled."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Got passive check result for host '" + arguments[0] + "' which has passive checks disabled."));
int exitStatus = Convert::ToDouble(arguments[1]);
Dictionary::Ptr result = PluginCheckTask::ParseCheckOutput(arguments[2]);
result->Set("execution_end", time);
result->Set("active", 0);
- Logger::Write(LogInformation, "icinga", "Processing passive check result for host '" + arguments[0] + "'");
+ Log(LogInformation, "icinga", "Processing passive check result for host '" + arguments[0] + "'");
hc->ProcessCheckResult(result);
{
}
}
-void ExternalCommandProcessor::ProcessServiceCheckResult(double time, const vector<String>& arguments)
+void ExternalCommandProcessor::ProcessServiceCheckResult(double time, const std::vector<String>& arguments)
{
if (arguments.size() < 4)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 4 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 4 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot process passive service check result for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
if (!service->GetEnablePassiveChecks())
- BOOST_THROW_EXCEPTION(invalid_argument("Got passive check result for service '" + arguments[1] + "' which has passive checks disabled."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Got passive check result for service '" + arguments[1] + "' which has passive checks disabled."));
int exitStatus = Convert::ToDouble(arguments[2]);
Dictionary::Ptr result = PluginCheckTask::ParseCheckOutput(arguments[3]);
result->Set("execution_end", time);
result->Set("active", 0);
- Logger::Write(LogInformation, "icinga", "Processing passive check result for service '" + arguments[1] + "'");
+ Log(LogInformation, "icinga", "Processing passive check result for service '" + arguments[1] + "'");
service->ProcessCheckResult(result);
{
}
}
-void ExternalCommandProcessor::ScheduleHostCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleHostCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot reschedule host check for non-existent host '" + arguments[0] + "'"));
+
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc) {
+ Log(LogInformation, "icinga", "Ignoring request request for host '" +
+ arguments[0] + "' (does not have a host check)");
+ return;
+ }
double planned_check = Convert::ToDouble(arguments[1]);
if (planned_check > hc->GetNextCheck()) {
- Logger::Write(LogInformation, "icinga", "Ignoring reschedule request for host '" +
+ Log(LogInformation, "icinga", "Ignoring reschedule request for host '" +
arguments[0] + "' (next check is already sooner than requested check time)");
return;
}
- Logger::Write(LogInformation, "icinga", "Rescheduling next check for host '" + arguments[0] + "'");
+ Log(LogInformation, "icinga", "Rescheduling next check for host '" + arguments[0] + "'");
+
+ if (planned_check < Utility::GetTime())
+ planned_check = Utility::GetTime();
{
ObjectLock olock(hc);
}
}
-void ExternalCommandProcessor::ScheduleForcedHostCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleForcedHostCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot reschedule forced host check for non-existent host '" + arguments[0] + "'"));
+
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc) {
+ Log(LogInformation, "icinga", "Ignoring request request for host '" +
+ arguments[0] + "' (does not have a host check)");
+ return;
+ }
- Logger::Write(LogInformation, "icinga", "Rescheduling next check for host '" + arguments[0] + "'");
+ Log(LogInformation, "icinga", "Rescheduling next check for host '" + arguments[0] + "'");
{
ObjectLock olock(hc);
}
}
-void ExternalCommandProcessor::ScheduleSvcCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleSvcCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 3 arguments."));
+ 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 reschedule service check for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
double planned_check = Convert::ToDouble(arguments[2]);
if (planned_check > service->GetNextCheck()) {
- Logger::Write(LogInformation, "icinga", "Ignoring reschedule request for service '" +
+ Log(LogInformation, "icinga", "Ignoring reschedule request for service '" +
arguments[1] + "' (next check is already sooner than requested check time)");
return;
}
- Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
+ Log(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
+
+ if (planned_check < Utility::GetTime())
+ planned_check = Utility::GetTime();
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::ScheduleForcedSvcCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleForcedSvcCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 3 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot reschedule forced service check for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::EnableHostCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableHostCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Enabling active checks for host '" + arguments[0] + "'");
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable host check non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling active checks for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
}
}
-void ExternalCommandProcessor::DisableHostCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableHostCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Disabling active checks for host '" + arguments[0] + "'");
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable host check non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling active checks for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
}
}
-void ExternalCommandProcessor::EnableSvcCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableSvcCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable service check for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling active checks for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisableSvcCheck(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableSvcCheck(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable service check for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling active checks for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::ShutdownProcess(double, const vector<String>&)
+void ExternalCommandProcessor::ShutdownProcess(double, const std::vector<String>&)
{
- Logger::Write(LogInformation, "icinga", "Shutting down Icinga via external command.");
+ Log(LogInformation, "icinga", "Shutting down Icinga via external command.");
Application::RequestShutdown();
}
-void ExternalCommandProcessor::ScheduleForcedHostSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::RestartProcess(double, const std::vector<String>&)
+{
+ Log(LogInformation, "icinga", "Restarting Icinga via external command.");
+ Application::RequestRestart();
+}
+
+void ExternalCommandProcessor::ScheduleForcedHostSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
double planned_check = Convert::ToDouble(arguments[1]);
Host::Ptr host = Host::GetByName(arguments[0]);
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot reschedule forced host service checks for non-existent host '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::ScheduleHostSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleHostSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
double planned_check = Convert::ToDouble(arguments[1]);
Host::Ptr host = Host::GetByName(arguments[0]);
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot reschedule host service checks for non-existent host '" + arguments[0] + "'"));
+
+ if (planned_check < Utility::GetTime())
+ planned_check = Utility::GetTime();
+
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
if (planned_check > service->GetNextCheck()) {
- Logger::Write(LogInformation, "icinga", "Ignoring reschedule request for service '" +
+ Log(LogInformation, "icinga", "Ignoring reschedule request for service '" +
service->GetName() + "' (next check is already sooner than requested check time)");
continue;
}
- Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::EnableHostSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableHostSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable host service checks for non-existent host '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
service->SetEnableActiveChecks(true);
}
}
-void ExternalCommandProcessor::DisableHostSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableHostSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable host service checks for non-existent host '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::AcknowledgeSvcProblem(double, const vector<String>& arguments)
+void ExternalCommandProcessor::AcknowledgeSvcProblem(double, const std::vector<String>& arguments)
{
if (arguments.size() < 7)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 7 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 7 arguments."));
bool sticky = Convert::ToBool(arguments[2]);
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot acknowledge service problem for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
if (service->GetState() == StateOK)
- BOOST_THROW_EXCEPTION(invalid_argument("The service '" + arguments[1] + "' is OK."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("The service '" + arguments[1] + "' is OK."));
- Logger::Write(LogInformation, "icinga", "Setting acknowledgement for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Setting acknowledgement for service '" + service->GetName() + "'");
- service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal);
+ service->AddComment(CommentAcknowledgement, arguments[5], arguments[6], 0);
+ service->AcknowledgeProblem(arguments[5], arguments[6], sticky ? AcknowledgementSticky : AcknowledgementNormal);
}
-void ExternalCommandProcessor::AcknowledgeSvcProblemExpire(double, const vector<String>& arguments)
+void ExternalCommandProcessor::AcknowledgeSvcProblemExpire(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
bool sticky = Convert::ToBool(arguments[2]);
double timestamp = Convert::ToDouble(arguments[5]);
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot acknowledge service problem with expire time for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
if (service->GetState() == StateOK)
- BOOST_THROW_EXCEPTION(invalid_argument("The service '" + arguments[1] + "' is OK."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("The service '" + arguments[1] + "' is OK."));
- Logger::Write(LogInformation, "icinga", "Setting timed acknowledgement for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Setting timed acknowledgement for service '" + service->GetName() + "'");
- service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal, timestamp);
+ service->AddComment(CommentAcknowledgement, arguments[6], arguments[7], 0);
+ service->AcknowledgeProblem(arguments[6], arguments[7], sticky ? AcknowledgementSticky : AcknowledgementNormal, timestamp);
}
-void ExternalCommandProcessor::RemoveSvcAcknowledgement(double, const vector<String>& arguments)
+void ExternalCommandProcessor::RemoveSvcAcknowledgement(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Removing acknowledgement for service '" + service->GetName() + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot remove service acknowledgement for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Removing acknowledgement for service '" + service->GetName() + "'");
service->ClearAcknowledgement();
}
-void ExternalCommandProcessor::AcknowledgeHostProblem(double, const vector<String>& arguments)
+void ExternalCommandProcessor::AcknowledgeHostProblem(double, const std::vector<String>& arguments)
{
if (arguments.size() < 6)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 6 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 6 arguments."));
bool sticky = Convert::ToBool(arguments[1]);
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Setting acknowledgement for host '" + host->GetName() + "'");
- Service::Ptr service = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot acknowledge host problem for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Setting acknowledgement for host '" + host->GetName() + "'");
+ Service::Ptr service = host->GetCheckService();
if (service) {
if (service->GetState() == StateOK)
- BOOST_THROW_EXCEPTION(invalid_argument("The host '" + arguments[0] + "' is OK."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("The host '" + arguments[0] + "' is OK."));
- service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal);
+ service->AddComment(CommentAcknowledgement, arguments[4], arguments[5], 0);
+ service->AcknowledgeProblem(arguments[4], arguments[5], sticky ? AcknowledgementSticky : AcknowledgementNormal);
}
}
-void ExternalCommandProcessor::AcknowledgeHostProblemExpire(double, const vector<String>& arguments)
+void ExternalCommandProcessor::AcknowledgeHostProblemExpire(double, const std::vector<String>& arguments)
{
if (arguments.size() < 7)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 7 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 7 arguments."));
bool sticky = Convert::ToBool(arguments[1]);
double timestamp = Convert::ToDouble(arguments[4]);
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Setting timed acknowledgement for host '" + host->GetName() + "'");
- Service::Ptr service = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot acknowledge host problem with expire time for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Setting timed acknowledgement for host '" + host->GetName() + "'");
+ Service::Ptr service = host->GetCheckService();
if (service) {
if (service->GetState() == StateOK)
- BOOST_THROW_EXCEPTION(invalid_argument("The host '" + arguments[0] + "' is OK."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("The host '" + arguments[0] + "' is OK."));
- service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal, timestamp);
+ service->AddComment(CommentAcknowledgement, arguments[5], arguments[6], 0);
+ service->AcknowledgeProblem(arguments[5], arguments[6], sticky ? AcknowledgementSticky : AcknowledgementNormal, timestamp);
}
}
-void ExternalCommandProcessor::RemoveHostAcknowledgement(double, const vector<String>& arguments)
+void ExternalCommandProcessor::RemoveHostAcknowledgement(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Removing acknowledgement for host '" + host->GetName() + "'");
- Service::Ptr service = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot remove acknowledgement for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Removing acknowledgement for host '" + host->GetName() + "'");
+ Service::Ptr service = host->GetCheckService();
if (service)
service->ClearAcknowledgement();
}
-void ExternalCommandProcessor::EnableHostgroupSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableHostgroupSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable hostgroup service checks for non-existent hostgroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisableHostgroupSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableHostgroupSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable hostgroup service checks for non-existent hostgroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::EnableServicegroupSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableServicegroupSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable servicegroup service checks for non-existent servicegroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
- Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisableServicegroupSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableServicegroupSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable servicegroup service checks for non-existent servicegroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
- Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::EnablePassiveHostChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnablePassiveHostChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Enabling passive checks for host '" + arguments[0] + "'");
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable passive host checks for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling passive checks for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
}
}
-void ExternalCommandProcessor::DisablePassiveHostChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisablePassiveHostChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Disabling passive checks for host '" + arguments[0] + "'");
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable passive host checks for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling passive checks for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
}
}
-void ExternalCommandProcessor::EnablePassiveSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnablePassiveSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Enabling passive checks for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable service checks for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling passive checks for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisablePassiveSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisablePassiveSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Disabling passive checks for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable service checks for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling passive checks for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::EnableServicegroupPassiveSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableServicegroupPassiveSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable servicegroup passive service checks for non-existent servicegroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
- Logger::Write(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisableServicegroupPassiveSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableServicegroupPassiveSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable servicegroup passive service checks for non-existent servicegroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
- Logger::Write(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::EnableHostgroupPassiveSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableHostgroupPassiveSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable hostgroup passive service checks for non-existent hostgroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisableHostgroupPassiveSvcChecks(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableHostgroupPassiveSvcChecks(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable hostgroup passive service checks for non-existent hostgroup '" + arguments[0] + "'"));
+
BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
+ Log(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::ProcessFile(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ProcessFile(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
String file = arguments[0];
bool del = Convert::ToBool(arguments[1]);
- ifstream ifp;
- ifp.exceptions(ifstream::badbit);
+ std::ifstream ifp;
+ ifp.exceptions(std::ifstream::badbit);
- ifp.open(file.CStr(), ifstream::in);
+ ifp.open(file.CStr(), std::ifstream::in);
while(ifp.good()) {
std::string line;
std::getline(ifp, line);
try {
- Logger::Write(LogInformation, "compat", "Executing external command: " + line);
+ Log(LogInformation, "compat", "Executing external command: " + line);
Execute(line);
- } catch (const exception& ex) {
- stringstream msgbuf;
- msgbuf << "External command failed: " << diagnostic_information(ex);
- Logger::Write(LogWarning, "icinga", msgbuf.str());
+ } catch (const std::exception& ex) {
+ std::ostringstream msgbuf;
+ msgbuf << "External command failed: " << boost::diagnostic_information(ex);
+ Log(LogWarning, "icinga", msgbuf.str());
}
}
(void) unlink(file.CStr());
}
-void ExternalCommandProcessor::ScheduleSvcDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleSvcDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 9)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 9 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 9 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule service downtime for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[5]);
if (triggeredByLegacy != 0)
triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
- Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
- (void) service->AddDowntime(arguments[7], arguments[8],
+ Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
+ String comment_id = service->AddComment(CommentDowntime, arguments[7], arguments[8], Convert::ToDouble(arguments[3]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[2]), Convert::ToDouble(arguments[3]),
Convert::ToBool(arguments[4]), triggeredBy, Convert::ToDouble(arguments[6]));
}
-void ExternalCommandProcessor::DelSvcDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelSvcDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
int id = Convert::ToLong(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
+ Log(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
String rid = Service::GetDowntimeIDFromLegacyID(id);
- Service::RemoveDowntime(rid);
+ Service::RemoveDowntime(rid, true);
}
-void ExternalCommandProcessor::ScheduleHostDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleHostDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule host downtime for non-existent host '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[4]);
if (triggeredByLegacy != 0)
triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
- Logger::Write(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
- Service::Ptr service = host->GetHostCheckService();
+ Log(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
+ Service::Ptr service = host->GetCheckService();
if (service) {
- (void) service->AddDowntime(arguments[6], arguments[7],
+ String comment_id = service->AddComment(CommentDowntime, arguments[6], arguments[7], Convert::ToDouble(arguments[2]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
}
}
-void ExternalCommandProcessor::DelHostDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelHostDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
int id = Convert::ToLong(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
+ Log(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
String rid = Service::GetDowntimeIDFromLegacyID(id);
- Service::RemoveDowntime(rid);
+ Service::RemoveDowntime(rid, true);
}
-void ExternalCommandProcessor::ScheduleHostSvcDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleHostSvcDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule host services downtime for non-existent host '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[4]);
if (triggeredByLegacy != 0)
triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
- Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
- (void) service->AddDowntime(arguments[6], arguments[7],
+ Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
+ String comment_id = service->AddComment(CommentDowntime, arguments[6], arguments[7], Convert::ToDouble(arguments[2]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
}
}
-void ExternalCommandProcessor::ScheduleHostgroupHostDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleHostgroupHostDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule hostgroup host downtime for non-existent hostgroup '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[4]);
if (triggeredByLegacy != 0)
triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
- Logger::Write(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
- Service::Ptr service = host->GetHostCheckService();
+ Log(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
+ Service::Ptr service = host->GetCheckService();
if (service) {
- (void) service->AddDowntime(arguments[6], arguments[7],
+ String comment_id = service->AddComment(CommentDowntime, arguments[6], arguments[7], Convert::ToDouble(arguments[2]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
}
}
}
-void ExternalCommandProcessor::ScheduleHostgroupSvcDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleHostgroupSvcDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule hostgroup service downtime for non-existent hostgroup '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[4]);
if (triggeredByLegacy != 0)
* over all hosts in the host group - otherwise we might end up creating multiple
* downtimes for some services. */
- set<Service::Ptr> services;
+ std::set<Service::Ptr> services;
BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
}
BOOST_FOREACH(const Service::Ptr& service, services) {
- Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
- (void) service->AddDowntime(arguments[6], arguments[7],
+ Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
+ String comment_id = service->AddComment(CommentDowntime, arguments[6], arguments[7], Convert::ToDouble(arguments[2]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
}
}
-void ExternalCommandProcessor::ScheduleServicegroupHostDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleServicegroupHostDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule servicegroup host downtime for non-existent servicegroup '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[4]);
if (triggeredByLegacy != 0)
* over all services in the service group - otherwise we might end up creating multiple
* downtimes for some hosts. */
- set<Service::Ptr> services;
+ std::set<Service::Ptr> services;
BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
Host::Ptr host = service->GetHost();
- Service::Ptr hcService = host->GetHostCheckService();
+ Service::Ptr hcService = host->GetCheckService();
if (hcService)
services.insert(hcService);
}
BOOST_FOREACH(const Service::Ptr& service, services) {
- Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
- (void) service->AddDowntime(arguments[6], arguments[7],
+ Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
+ String comment_id = service->AddComment(CommentDowntime, arguments[6], arguments[7], Convert::ToDouble(arguments[2]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
}
}
-void ExternalCommandProcessor::ScheduleServicegroupSvcDowntime(double, const vector<String>& arguments)
+void ExternalCommandProcessor::ScheduleServicegroupSvcDowntime(double, const std::vector<String>& arguments)
{
if (arguments.size() < 8)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot schedule servicegroup service downtime for non-existent servicegroup '" + arguments[0] + "'"));
+
String triggeredBy;
int triggeredByLegacy = Convert::ToLong(arguments[4]);
if (triggeredByLegacy != 0)
triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
- Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
- (void) service->AddDowntime(arguments[6], arguments[7],
+ Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
+ String comment_id = service->AddComment(CommentDowntime, arguments[6], arguments[7], Convert::ToDouble(arguments[2]));
+ (void) service->AddDowntime(comment_id,
Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
}
}
-void ExternalCommandProcessor::AddHostComment(double, const vector<String>& arguments)
+void ExternalCommandProcessor::AddHostComment(double, const std::vector<String>& arguments)
{
if (arguments.size() < 4)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 4 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 4 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Creating comment for host " + host->GetName());
- Service::Ptr service = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot add host comment for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Creating comment for host " + host->GetName());
+ Service::Ptr service = host->GetCheckService();
if (service)
(void) service->AddComment(CommentUser, arguments[2], arguments[3], 0);
}
-void ExternalCommandProcessor::DelHostComment(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelHostComment(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
int id = Convert::ToLong(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
+ Log(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
String rid = Service::GetCommentIDFromLegacyID(id);
Service::RemoveComment(rid);
}
-void ExternalCommandProcessor::AddSvcComment(double, const vector<String>& arguments)
+void ExternalCommandProcessor::AddSvcComment(double, const std::vector<String>& arguments)
{
if (arguments.size() < 5)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 5 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 5 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Creating comment for service " + service->GetName());
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot add service comment for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Creating comment for service " + service->GetName());
(void) service->AddComment(CommentUser, arguments[3], arguments[4], 0);
}
-void ExternalCommandProcessor::DelSvcComment(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelSvcComment(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
int id = Convert::ToLong(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
+ Log(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
String rid = Service::GetCommentIDFromLegacyID(id);
Service::RemoveComment(rid);
}
-void ExternalCommandProcessor::DelAllHostComments(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelAllHostComments(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Removing all comments for host " + host->GetName());
- Service::Ptr service = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot delete all host comments for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Removing all comments for host " + host->GetName());
+ Service::Ptr service = host->GetCheckService();
if (service)
service->RemoveAllComments();
}
-void ExternalCommandProcessor::DelAllSvcComments(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelAllSvcComments(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Removing all comments for service " + service->GetName());
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot delete all service comments for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Removing all comments for service " + service->GetName());
service->RemoveAllComments();
}
-void ExternalCommandProcessor::SendCustomHostNotification(double, const vector<String>& arguments)
+void ExternalCommandProcessor::SendCustomHostNotification(double, const std::vector<String>& arguments)
{
if (arguments.size() < 4)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 4 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 4 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Sending custom notification for host " + host->GetName());
- Service::Ptr service = host->GetHostCheckService();
- if (service)
- service->RequestNotifications(NotificationCustom, service->GetLastCheckResult());
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot send custom host notification for non-existent host '" + arguments[0] + "'"));
+
+ int options = Convert::ToLong(arguments[1]);
+
+ Log(LogInformation, "icinga", "Sending custom notification for host " + host->GetName());
+ Service::Ptr service = host->GetCheckService();
+ if (service) {
+ if (options & 2) {
+ ObjectLock olock(service);
+ service->SetForceNextNotification(true);
+ }
+
+ Service::OnNotificationsRequested(service, NotificationCustom, service->GetLastCheckResult(), arguments[2], arguments[3]);
+ }
}
-void ExternalCommandProcessor::SendCustomSvcNotification(double, const vector<String>& arguments)
+void ExternalCommandProcessor::SendCustomSvcNotification(double, const std::vector<String>& arguments)
{
if (arguments.size() < 5)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 5 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 5 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Sending custom notification for service " + service->GetName());
- service->RequestNotifications(NotificationCustom, service->GetLastCheckResult());
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot send custom service notification for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ int options = Convert::ToLong(arguments[2]);
+
+ Log(LogInformation, "icinga", "Sending custom notification for service " + service->GetName());
+
+ if (options & 2) {
+ ObjectLock olock(service);
+ service->SetForceNextNotification(true);
+ }
+
+ Service::OnNotificationsRequested(service, NotificationCustom, service->GetLastCheckResult(), arguments[3], arguments[4]);
}
-void ExternalCommandProcessor::DelayHostNotification(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelayHostNotification(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Delaying notifications for host " + host->GetName());
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot delay host notification for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Delaying notifications for host " + host->GetName());
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
- {
- ObjectLock olock(hc);
+ BOOST_FOREACH(const Notification::Ptr& notification, hc->GetNotifications()) {
+ ObjectLock olock(notification);
- hc->SetLastNotification(Convert::ToDouble(arguments[1]));
+ notification->SetNextNotification(Convert::ToDouble(arguments[1]));
}
}
-void ExternalCommandProcessor::DelaySvcNotification(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DelaySvcNotification(double, const std::vector<String>& arguments)
{
if (arguments.size() < 3)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 3 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Delaying notifications for service " + service->GetName());
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot delay service notification for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
- {
- ObjectLock olock(service);
+ Log(LogInformation, "icinga", "Delaying notifications for service " + service->GetName());
+
+ BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
+ ObjectLock olock(notification);
- service->SetLastNotification(Convert::ToDouble(arguments[2]));
+ notification->SetNextNotification(Convert::ToDouble(arguments[2]));
}
}
-void ExternalCommandProcessor::EnableHostNotifications(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableHostNotifications(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Enabling notifications for host '" + arguments[0] + "'");
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable host notifications for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling notifications for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
}
}
-void ExternalCommandProcessor::DisableHostNotifications(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableHostNotifications(double, const std::vector<String>& arguments)
{
if (arguments.size() < 1)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
Host::Ptr host = Host::GetByName(arguments[0]);
- Logger::Write(LogInformation, "icinga", "Disabling notifications for host '" + arguments[0] + "'");
- Service::Ptr hc = host->GetHostCheckService();
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable host notifications for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling notifications for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
if (!hc)
return;
}
}
-void ExternalCommandProcessor::EnableSvcNotifications(double, const vector<String>& arguments)
+void ExternalCommandProcessor::EnableSvcNotifications(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Enabling notifications for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable service notifications for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling notifications for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
}
}
-void ExternalCommandProcessor::DisableSvcNotifications(double, const vector<String>& arguments)
+void ExternalCommandProcessor::DisableSvcNotifications(double, const std::vector<String>& arguments)
{
if (arguments.size() < 2)
- BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
- Logger::Write(LogInformation, "icinga", "Disabling notifications for service '" + arguments[1] + "'");
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable service notifications for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling notifications for service '" + arguments[1] + "'");
{
ObjectLock olock(service);
service->SetEnableNotifications(false);
}
}
+
+void ExternalCommandProcessor::DisableHostgroupHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable hostgroup host checks for non-existent hostgroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Disabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnableActiveChecks(false);
+ }
+ }
+}
+
+void ExternalCommandProcessor::DisableHostgroupPassiveHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable hostgroup passive host checks for non-existent hostgroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Disabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnablePassiveChecks(false);
+ }
+ }
+}
+
+void ExternalCommandProcessor::DisableServicegroupHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable servicegroup host checks for non-existent servicegroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
+ Host::Ptr host = service->GetHost();
+
+ if (!host)
+ continue;
+
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Disabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnableActiveChecks(false);
+ }
+ }
+}
+
+void ExternalCommandProcessor::DisableServicegroupPassiveHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable servicegroup passive host checks for non-existent servicegroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
+ Host::Ptr host = service->GetHost();
+
+ if (!host)
+ continue;
+
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Disabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnablePassiveChecks(false);
+ }
+ }
+}
+
+void ExternalCommandProcessor::EnableHostgroupHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
+
+ if (!hg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable hostgroup host checks for non-existent hostgroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Enabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnableActiveChecks(true);
+ }
+ }
+}
+
+void ExternalCommandProcessor::EnableHostgroupPassiveHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+}
+
+void ExternalCommandProcessor::EnableServicegroupHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable servicegroup host checks for non-existent servicegroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
+ Host::Ptr host = service->GetHost();
+
+ if (!host)
+ continue;
+
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Enabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnableActiveChecks(true);
+ }
+ }
+}
+
+void ExternalCommandProcessor::EnableServicegroupPassiveHostChecks(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
+
+ ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
+
+ if (!sg)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable servicegroup passive host checks for non-existent servicegroup '" + arguments[0] + "'"));
+
+ BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
+ Host::Ptr host = service->GetHost();
+
+ if (!host)
+ continue;
+
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ continue;
+
+ Log(LogInformation, "icinga", "Enabling active checks for host '" + host->GetName() + "'");
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnablePassiveChecks(false);
+ }
+ }
+}
+
+void ExternalCommandProcessor::EnableHostFlapping(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
+
+ Host::Ptr host = Host::GetByName(arguments[0]);
+
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable host flapping for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling flapping detection for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ return;
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnableFlapping(true);
+ }
+}
+
+void ExternalCommandProcessor::DisableHostFlapping(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 1)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
+
+ Host::Ptr host = Host::GetByName(arguments[0]);
+
+ if (!host)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable host flapping for non-existent host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling flapping detection for host '" + arguments[0] + "'");
+ Service::Ptr hc = host->GetCheckService();
+
+ if (!hc)
+ return;
+
+ {
+ ObjectLock olock(hc);
+
+ hc->SetEnableFlapping(false);
+ }
+}
+
+void ExternalCommandProcessor::EnableSvcFlapping(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 2)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
+
+ Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
+
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot enable service flapping for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Enabling flapping detection for service '" + arguments[1] + "'");
+
+ {
+ ObjectLock olock(service);
+
+ service->SetEnableFlapping(true);
+ }
+}
+
+void ExternalCommandProcessor::DisableSvcFlapping(double, const std::vector<String>& arguments)
+{
+ if (arguments.size() < 2)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
+
+ Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
+
+ if (!service)
+ BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot disable service flapping for non-existent service '" + arguments[1] + "' on host '" + arguments[0] + "'"));
+
+ Log(LogInformation, "icinga", "Disabling flapping detection for service '" + arguments[1] + "'");
+
+ {
+ ObjectLock olock(service);
+
+ service->SetEnableFlapping(false);
+ }
+}
projects / icinga2 / blobdiff