granicus.if.org Git - icinga2/blob - lib/icinga/externalcommandprocessor.cpp

   1 /******************************************************************************
   2  * Icinga 2                                                                   *
   3  * Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/)        *
   4  *                                                                            *
   5  * This program is free software; you can redistribute it and/or              *
   6  * modify it under the terms of the GNU General Public License                *
   7  * as published by the Free Software Foundation; either version 2             *
   8  * of the License, or (at your option) any later version.                     *
   9  *                                                                            *
  10  * This program is distributed in the hope that it will be useful,            *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
  13  * GNU General Public License for more details.                               *
  14  *                                                                            *
  15  * You should have received a copy of the GNU General Public License          *
  16  * along with this program; if not, write to the Free Software Foundation     *
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.             *
  18  ******************************************************************************/
  19
  20 #include "i2-icinga.h"
  21
  22 using namespace icinga;
  23
  24 boost::once_flag ExternalCommandProcessor::m_InitializeOnce = BOOST_ONCE_INIT;
  25 boost::mutex ExternalCommandProcessor::m_Mutex;
  26 map<String, ExternalCommandProcessor::Callback> ExternalCommandProcessor::m_Commands;
  27
  28 /**
  29  * @threadsafety Always.
  30  */
  31 void ExternalCommandProcessor::Execute(const String& line)
  32 {
  33         if (line.IsEmpty())
  34                 return;
  35
  36         if (line[0] != '[')
  37                 BOOST_THROW_EXCEPTION(invalid_argument("Missing timestamp in command: " + line));
  38
  39         size_t pos = line.FindFirstOf("]");
  40
  41         if (pos == String::NPos)
  42                 BOOST_THROW_EXCEPTION(invalid_argument("Missing timestamp in command: " + line));
  43
  44         String timestamp = line.SubStr(1, pos - 1);
  45         String args = line.SubStr(pos + 2, String::NPos);
  46
  47         double ts = Convert::ToDouble(timestamp);
  48
  49         if (ts == 0)
  50                 BOOST_THROW_EXCEPTION(invalid_argument("Invalid timestamp in command: " + line));
  51
  52         vector<String> argv = args.Split(is_any_of(";"));
  53
  54         if (argv.size() == 0)
  55                 BOOST_THROW_EXCEPTION(invalid_argument("Missing arguments in command: " + line));
  56
  57         vector<String> argvExtra(argv.begin() + 1, argv.end());
  58         Execute(ts, argv[0], argvExtra);
  59 }
  60
  61 /**
  62  * @threadsafety Always.
  63  */
  64 void ExternalCommandProcessor::Execute(double time, const String& command, const vector<String>& arguments)
  65 {
  66         boost::call_once(m_InitializeOnce, &ExternalCommandProcessor::Initialize);
  67
  68         Callback callback;
  69
  70         {
  71                 boost::mutex::scoped_lock lock(m_Mutex);
  72
  73                 map<String, ExternalCommandProcessor::Callback>::iterator it;
  74                 it = m_Commands.find(command);
  75
  76                 if (it == m_Commands.end())
  77                         BOOST_THROW_EXCEPTION(invalid_argument("The external command '" + command + "' does not exist."));
  78
  79                 callback = it->second;
  80         }
  81
  82         callback(time, arguments);
  83 }
  84
  85 /**
  86  * @threadsafety Always.
  87  */
  88 void ExternalCommandProcessor::Initialize(void)
  89 {
  90         RegisterCommand("PROCESS_SERVICE_CHECK_RESULT", &ExternalCommandProcessor::ProcessServiceCheckResult);
  91         RegisterCommand("SCHEDULE_SVC_CHECK", &ExternalCommandProcessor::ScheduleSvcCheck);
  92         RegisterCommand("SCHEDULE_FORCED_SVC_CHECK", &ExternalCommandProcessor::ScheduleForcedSvcCheck);
  93         RegisterCommand("ENABLE_SVC_CHECK", &ExternalCommandProcessor::EnableSvcCheck);
  94         RegisterCommand("DISABLE_SVC_CHECK", &ExternalCommandProcessor::DisableSvcCheck);
  95         RegisterCommand("SHUTDOWN_PROCESS", &ExternalCommandProcessor::ShutdownProcess);
  96         RegisterCommand("SCHEDULE_FORCED_HOST_SVC_CHECKS", &ExternalCommandProcessor::ScheduleForcedHostSvcChecks);
  97         RegisterCommand("SCHEDULE_HOST_SVC_CHECKS", &ExternalCommandProcessor::ScheduleHostSvcChecks);
  98         RegisterCommand("ENABLE_HOST_SVC_CHECKS", &ExternalCommandProcessor::EnableHostSvcChecks);
  99         RegisterCommand("DISABLE_HOST_SVC_CHECKS", &ExternalCommandProcessor::DisableHostSvcChecks);
 100         RegisterCommand("ACKNOWLEDGE_SVC_PROBLEM", &ExternalCommandProcessor::AcknowledgeSvcProblem);
 101         RegisterCommand("ACKNOWLEDGE_SVC_PROBLEM_EXPIRE", &ExternalCommandProcessor::AcknowledgeSvcProblemExpire);
 102         RegisterCommand("REMOVE_SVC_ACKNOWLEDGEMENT", &ExternalCommandProcessor::RemoveHostAcknowledgement);
 103         RegisterCommand("ACKNOWLEDGE_HOST_PROBLEM", &ExternalCommandProcessor::AcknowledgeHostProblem);
 104         RegisterCommand("ACKNOWLEDGE_HOST_PROBLEM_EXPIRE", &ExternalCommandProcessor::AcknowledgeHostProblemExpire);
 105         RegisterCommand("REMOVE_HOST_ACKNOWLEDGEMENT", &ExternalCommandProcessor::RemoveHostAcknowledgement);
 106         RegisterCommand("ENABLE_HOSTGROUP_SVC_CHECKS", &ExternalCommandProcessor::EnableHostgroupSvcChecks);
 107         RegisterCommand("DISABLE_HOSTGROUP_SVC_CHECKS", &ExternalCommandProcessor::DisableHostgroupSvcChecks);
 108         RegisterCommand("ENABLE_SERVICEGROUP_SVC_CHECKS", &ExternalCommandProcessor::EnableServicegroupSvcChecks);
 109         RegisterCommand("DISABLE_SERVICEGROUP_SVC_CHECKS", &ExternalCommandProcessor::DisableServicegroupSvcChecks);
 110         RegisterCommand("ENABLE_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::EnablePassiveSvcChecks);
 111         RegisterCommand("DISABLE_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::DisablePassiveSvcChecks);
 112         RegisterCommand("ENABLE_SERVICEGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::EnableServicegroupPassiveSvcChecks);
 113         RegisterCommand("DISABLE_SERVICEGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::DisableServicegroupPassiveSvcChecks);
 114         RegisterCommand("ENABLE_HOSTGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::EnableHostgroupPassiveSvcChecks);
 115         RegisterCommand("DISABLE_HOSTGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::DisableHostgroupPassiveSvcChecks);
 116         RegisterCommand("PROCESS_FILE", &ExternalCommandProcessor::ProcessFile);
 117         RegisterCommand("SCHEDULE_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleSvcDowntime);
 118         RegisterCommand("DEL_SVC_DOWNTIME", &ExternalCommandProcessor::DelSvcDowntime);
 119         RegisterCommand("SCHEDULE_HOST_DOWNTIME", &ExternalCommandProcessor::ScheduleHostDowntime);
 120         RegisterCommand("DEL_HOST_DOWNTIME", &ExternalCommandProcessor::DelHostDowntime);
 121         RegisterCommand("SCHEDULE_HOST_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleHostSvcDowntime);
 122         RegisterCommand("SCHEDULE_HOSTGROUP_HOST_DOWNTIME", &ExternalCommandProcessor::ScheduleHostgroupHostDowntime);
 123         RegisterCommand("SCHEDULE_HOSTGROUP_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleHostgroupSvcDowntime);
 124         RegisterCommand("SCHEDULE_SERVICEGROUP_HOST_DOWNTIME", &ExternalCommandProcessor::ScheduleServicegroupHostDowntime);
 125         RegisterCommand("SCHEDULE_SERVICEGROUP_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleServicegroupSvcDowntime);
 126         RegisterCommand("ADD_HOST_COMMENT", &ExternalCommandProcessor::AddHostComment);
 127         RegisterCommand("DEL_HOST_COMMENT", &ExternalCommandProcessor::DelHostComment);
 128         RegisterCommand("ADD_SVC_COMMENT", &ExternalCommandProcessor::AddSvcComment);
 129         RegisterCommand("DEL_SVC_COMMENT", &ExternalCommandProcessor::DelSvcComment);
 130         RegisterCommand("DEL_ALL_HOST_COMMENTS", &ExternalCommandProcessor::DelAllHostComments);
 131         RegisterCommand("DEL_ALL_SVC_COMMENTS", &ExternalCommandProcessor::DelAllSvcComments);
 132         RegisterCommand("SEND_CUSTOM_HOST_NOTIFICATION", &ExternalCommandProcessor::SendCustomHostNotification);
 133         RegisterCommand("SEND_CUSTOM_SVC_NOTIFICATION", &ExternalCommandProcessor::SendCustomSvcNotification);
 134 }
 135
 136 /**
 137  * @threadsafety Always.
 138  */
 139 void ExternalCommandProcessor::RegisterCommand(const String& command, const ExternalCommandProcessor::Callback& callback)
 140 {
 141         boost::mutex::scoped_lock lock(m_Mutex);
 142         m_Commands[command] = callback;
 143 }
 144
 145 void ExternalCommandProcessor::ProcessServiceCheckResult(double time, const vector<String>& arguments)
 146 {
 147         if (arguments.size() < 4)
 148                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 4 arguments."));
 149
 150         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 151
 152         if (!service->GetEnablePassiveChecks())
 153                 BOOST_THROW_EXCEPTION(invalid_argument("Got passive check result for service '" + arguments[1] + "' which has passive checks disabled."));
 154
 155         int exitStatus = Convert::ToDouble(arguments[2]);
 156         Dictionary::Ptr result = PluginCheckTask::ParseCheckOutput(arguments[3]);
 157         result->Set("state", PluginCheckTask::ExitStatusToState(exitStatus));
 158
 159         result->Set("schedule_start", time);
 160         result->Set("schedule_end", time);
 161         result->Set("execution_start", time);
 162         result->Set("execution_end", time);
 163         result->Set("active", 0);
 164
 165         Logger::Write(LogInformation, "icinga", "Processing passive check result for service '" + arguments[1] + "'");
 166         service->ProcessCheckResult(result);
 167
 168         /* Reschedule the next check. The side effect of this is that for as long
 169          * as we receive passive results for a service we won't execute any
 170          * active checks. */
 171         service->SetNextCheck(Utility::GetTime() + service->GetCheckInterval());
 172 }
 173
 174 void ExternalCommandProcessor::ScheduleSvcCheck(double, const vector<String>& arguments)
 175 {
 176         if (arguments.size() < 3)
 177                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 3 arguments."));
 178
 179         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 180
 181         double planned_check = Convert::ToDouble(arguments[2]);
 182
 183         if (planned_check > service->GetNextCheck()) {
 184                 Logger::Write(LogInformation, "icinga", "Ignoring reschedule request for service '" +
 185                     arguments[1] + "' (next check is already sooner than requested check time)");
 186                 return;
 187         }
 188
 189         Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
 190         service->SetNextCheck(planned_check);
 191 }
 192
 193 void ExternalCommandProcessor::ScheduleForcedSvcCheck(double, const vector<String>& arguments)
 194 {
 195         if (arguments.size() < 3)
 196                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 3 arguments."));
 197
 198         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 199
 200         Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
 201         service->SetForceNextCheck(true);
 202         service->SetNextCheck(Convert::ToDouble(arguments[2]));
 203 }
 204
 205 void ExternalCommandProcessor::EnableSvcCheck(double, const vector<String>& arguments)
 206 {
 207         if (arguments.size() < 2)
 208                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 209
 210         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 211
 212         Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + arguments[1] + "'");
 213         service->SetEnableActiveChecks(true);
 214 }
 215
 216 void ExternalCommandProcessor::DisableSvcCheck(double, const vector<String>& arguments)
 217 {
 218         if (arguments.size() < 2)
 219                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 220
 221         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 222
 223         Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + arguments[1] + "'");
 224         service->SetEnableActiveChecks(false);
 225 }
 226
 227 void ExternalCommandProcessor::ShutdownProcess(double, const vector<String>&)
 228 {
 229         Logger::Write(LogInformation, "icinga", "Shutting down Icinga via external command.");
 230         Application::RequestShutdown();
 231 }
 232
 233 void ExternalCommandProcessor::ScheduleForcedHostSvcChecks(double, const vector<String>& arguments)
 234 {
 235         if (arguments.size() < 2)
 236                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 237
 238         double planned_check = Convert::ToDouble(arguments[1]);
 239
 240         Host::Ptr host = Host::GetByName(arguments[0]);
 241
 242         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 243                 Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
 244                 service->SetNextCheck(planned_check);
 245                 service->SetForceNextCheck(true);
 246         }
 247 }
 248
 249 void ExternalCommandProcessor::ScheduleHostSvcChecks(double, const vector<String>& arguments)
 250 {
 251         if (arguments.size() < 2)
 252                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 253
 254         double planned_check = Convert::ToDouble(arguments[1]);
 255
 256         Host::Ptr host = Host::GetByName(arguments[0]);
 257
 258         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 259                 if (planned_check > service->GetNextCheck()) {
 260                         Logger::Write(LogInformation, "icinga", "Ignoring reschedule request for service '" +
 261                             service->GetName() + "' (next check is already sooner than requested check time)");
 262                         continue;
 263                 }
 264
 265                 Logger::Write(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
 266                 service->SetNextCheck(planned_check);
 267         }
 268 }
 269
 270 void ExternalCommandProcessor::EnableHostSvcChecks(double, const vector<String>& arguments)
 271 {
 272         if (arguments.size() < 1)
 273                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 274
 275         Host::Ptr host = Host::GetByName(arguments[0]);
 276
 277         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 278                 Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
 279                 service->SetEnableActiveChecks(true);
 280         }
 281 }
 282
 283 void ExternalCommandProcessor::DisableHostSvcChecks(double, const vector<String>& arguments)
 284 {
 285         if (arguments.size() < 1)
 286                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 arguments."));
 287
 288         Host::Ptr host = Host::GetByName(arguments[0]);
 289
 290         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 291                 Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
 292                 service->SetEnableActiveChecks(false);
 293         }
 294 }
 295
 296 void ExternalCommandProcessor::AcknowledgeSvcProblem(double, const vector<String>& arguments)
 297 {
 298         if (arguments.size() < 7)
 299                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 7 arguments."));
 300
 301         bool sticky = Convert::ToBool(arguments[2]);
 302
 303         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 304
 305         if (service->GetState() == StateOK)
 306                 BOOST_THROW_EXCEPTION(invalid_argument("The service '" + arguments[1] + "' is OK."));
 307
 308         Logger::Write(LogInformation, "icinga", "Setting acknowledgement for service '" + service->GetName() + "'");
 309         service->SetAcknowledgement(sticky ? AcknowledgementSticky : AcknowledgementNormal);
 310         service->SetAcknowledgementExpiry(0);
 311 }
 312
 313 void ExternalCommandProcessor::AcknowledgeSvcProblemExpire(double, const vector<String>& arguments)
 314 {
 315         if (arguments.size() < 8)
 316                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
 317
 318         bool sticky = Convert::ToBool(arguments[2]);
 319         double timestamp = Convert::ToDouble(arguments[5]);
 320
 321         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 322
 323         if (service->GetState() == StateOK)
 324                 BOOST_THROW_EXCEPTION(invalid_argument("The service '" + arguments[1] + "' is OK."));
 325
 326         Logger::Write(LogInformation, "icinga", "Setting timed acknowledgement for service '" + service->GetName() + "'");
 327         service->SetAcknowledgement(sticky ? AcknowledgementSticky : AcknowledgementNormal);
 328         service->SetAcknowledgementExpiry(timestamp);
 329 }
 330
 331 void ExternalCommandProcessor::RemoveSvcAcknowledgement(double, const vector<String>& arguments)
 332 {
 333         if (arguments.size() < 2)
 334                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 335
 336         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 337
 338         Logger::Write(LogInformation, "icinga", "Removing acknowledgement for service '" + service->GetName() + "'");
 339         service->SetAcknowledgement(AcknowledgementNone);
 340         service->SetAcknowledgementExpiry(0);
 341 }
 342
 343 void ExternalCommandProcessor::AcknowledgeHostProblem(double, const vector<String>& arguments)
 344 {
 345         if (arguments.size() < 6)
 346                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 6 arguments."));
 347
 348         bool sticky = Convert::ToBool(arguments[1]);
 349
 350         Host::Ptr host = Host::GetByName(arguments[0]);
 351
 352         Logger::Write(LogInformation, "icinga", "Setting acknowledgement for host '" + host->GetName() + "'");
 353         Service::Ptr service = host->GetHostCheckService();
 354         if (service) {
 355                 if (service->GetState() == StateOK)
 356                         BOOST_THROW_EXCEPTION(invalid_argument("The host '" + arguments[0] + "' is OK."));
 357
 358                 service->SetAcknowledgement(sticky ? AcknowledgementSticky : AcknowledgementNormal);
 359                 service->SetAcknowledgementExpiry(0);
 360         }
 361 }
 362
 363 void ExternalCommandProcessor::AcknowledgeHostProblemExpire(double, const vector<String>& arguments)
 364 {
 365         if (arguments.size() < 7)
 366                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 7 arguments."));
 367
 368         bool sticky = Convert::ToBool(arguments[1]);
 369         double timestamp = Convert::ToDouble(arguments[4]);
 370
 371         Host::Ptr host = Host::GetByName(arguments[0]);
 372
 373         Logger::Write(LogInformation, "icinga", "Setting timed acknowledgement for host '" + host->GetName() + "'");
 374         Service::Ptr service = host->GetHostCheckService();
 375         if (service) {
 376                 if (service->GetState() == StateOK)
 377                         BOOST_THROW_EXCEPTION(invalid_argument("The host '" + arguments[0] + "' is OK."));
 378
 379                 service->SetAcknowledgement(sticky ? AcknowledgementSticky : AcknowledgementNormal);
 380                 service->SetAcknowledgementExpiry(timestamp);
 381         }
 382 }
 383
 384 void ExternalCommandProcessor::RemoveHostAcknowledgement(double, const vector<String>& arguments)
 385 {
 386         if (arguments.size() < 1)
 387                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 388
 389         Host::Ptr host = Host::GetByName(arguments[0]);
 390
 391         Logger::Write(LogInformation, "icinga", "Removing acknowledgement for host '" + host->GetName() + "'");
 392         Service::Ptr service = host->GetHostCheckService();
 393         if (service) {
 394                 service->SetAcknowledgement(AcknowledgementNone);
 395                 service->SetAcknowledgementExpiry(0);
 396         }
 397 }
 398
 399 void ExternalCommandProcessor::EnableHostgroupSvcChecks(double, const vector<String>& arguments)
 400 {
 401         if (arguments.size() < 1)
 402                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 403
 404         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 405
 406         BOOST_FOREACH(const Host::Ptr& host, HostGroup::GetMembers(hg)) {
 407                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 408                         Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
 409                         service->SetEnableActiveChecks(true);
 410                 }
 411         }
 412 }
 413
 414 void ExternalCommandProcessor::DisableHostgroupSvcChecks(double, const vector<String>& arguments)
 415 {
 416         if (arguments.size() < 1)
 417                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 418
 419         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 420
 421         BOOST_FOREACH(const Host::Ptr& host, HostGroup::GetMembers(hg)) {
 422                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 423                         Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
 424                         service->SetEnableActiveChecks(false);
 425                 }
 426         }
 427 }
 428
 429 void ExternalCommandProcessor::EnableServicegroupSvcChecks(double, const vector<String>& arguments)
 430 {
 431         if (arguments.size() < 1)
 432                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 433
 434         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 435
 436         BOOST_FOREACH(const Service::Ptr& service, ServiceGroup::GetMembers(sg)) {
 437                 Logger::Write(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
 438                 service->SetEnableActiveChecks(true);
 439         }
 440 }
 441
 442 void ExternalCommandProcessor::DisableServicegroupSvcChecks(double, const vector<String>& arguments)
 443 {
 444         if (arguments.size() < 1)
 445                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 446
 447         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 448
 449         BOOST_FOREACH(const Service::Ptr& service, ServiceGroup::GetMembers(sg)) {
 450                 Logger::Write(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
 451                 service->SetEnableActiveChecks(false);
 452         }
 453 }
 454
 455 void ExternalCommandProcessor::EnablePassiveSvcChecks(double, const vector<String>& arguments)
 456 {
 457         if (arguments.size() < 2)
 458                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 459
 460         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 461
 462         Logger::Write(LogInformation, "icinga", "Enabling passive checks for service '" + arguments[1] + "'");
 463         service->SetEnablePassiveChecks(true);
 464 }
 465
 466 void ExternalCommandProcessor::DisablePassiveSvcChecks(double, const vector<String>& arguments)
 467 {
 468         if (arguments.size() < 2)
 469                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 470
 471         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 472
 473         Logger::Write(LogInformation, "icinga", "Disabling passive checks for service '" + arguments[1] + "'");
 474         service->SetEnablePassiveChecks(false);
 475 }
 476
 477 void ExternalCommandProcessor::EnableServicegroupPassiveSvcChecks(double, const vector<String>& arguments)
 478 {
 479         if (arguments.size() < 1)
 480                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 481
 482         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 483
 484         BOOST_FOREACH(const Service::Ptr& service, ServiceGroup::GetMembers(sg)) {
 485                 Logger::Write(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
 486                 service->SetEnablePassiveChecks(true);
 487         }
 488 }
 489
 490 void ExternalCommandProcessor::DisableServicegroupPassiveSvcChecks(double, const vector<String>& arguments)
 491 {
 492         if (arguments.size() < 1)
 493                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 494
 495         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 496
 497         BOOST_FOREACH(const Service::Ptr& service, ServiceGroup::GetMembers(sg)) {
 498                 Logger::Write(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
 499                 service->SetEnablePassiveChecks(true);
 500         }
 501 }
 502
 503 void ExternalCommandProcessor::EnableHostgroupPassiveSvcChecks(double, const vector<String>& arguments)
 504 {
 505         if (arguments.size() < 1)
 506                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 507
 508         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 509
 510         BOOST_FOREACH(const Host::Ptr& host, HostGroup::GetMembers(hg)) {
 511                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 512                         Logger::Write(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
 513                         service->SetEnablePassiveChecks(true);
 514                 }
 515         }
 516 }
 517
 518 void ExternalCommandProcessor::DisableHostgroupPassiveSvcChecks(double, const vector<String>& arguments)
 519 {
 520         if (arguments.size() < 1)
 521                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 522
 523         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 524
 525         BOOST_FOREACH(const Host::Ptr& host, HostGroup::GetMembers(hg)) {
 526                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 527                         Logger::Write(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
 528                         service->SetEnablePassiveChecks(false);
 529                 }
 530         }
 531 }
 532
 533 void ExternalCommandProcessor::ProcessFile(double, const vector<String>& arguments)
 534 {
 535         if (arguments.size() < 2)
 536                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 537
 538         String file = arguments[0];
 539         bool del = Convert::ToBool(arguments[1]);
 540
 541         ifstream ifp;
 542         ifp.exceptions(ifstream::badbit);
 543
 544         ifp.open(file.CStr(), ifstream::in);
 545
 546         while(ifp.good()) {
 547                 std::string line;
 548                 std::getline(ifp, line);
 549
 550                 try {
 551                         Logger::Write(LogInformation, "compat", "Executing external command: " + line);
 552
 553                         Execute(line);
 554                 } catch (const exception& ex) {
 555                         stringstream msgbuf;
 556                         msgbuf << "External command failed: " << diagnostic_information(ex);
 557                         Logger::Write(LogWarning, "icinga", msgbuf.str());
 558                 }
 559         }
 560
 561         ifp.close();
 562
 563         if (del)
 564                 (void) unlink(file.CStr());
 565 }
 566
 567 void ExternalCommandProcessor::ScheduleSvcDowntime(double, const vector<String>& arguments)
 568 {
 569         if (arguments.size() < 9)
 570                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 9 arguments."));
 571
 572         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 573
 574         String triggeredBy;
 575         int triggeredByLegacy = Convert::ToLong(arguments[5]);
 576         if (triggeredByLegacy != 0)
 577                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 578
 579         Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 580         (void) service->AddDowntime(arguments[7], arguments[8],
 581             Convert::ToDouble(arguments[2]), Convert::ToDouble(arguments[3]),
 582             Convert::ToBool(arguments[4]), triggeredBy, Convert::ToDouble(arguments[6]));
 583 }
 584
 585 void ExternalCommandProcessor::DelSvcDowntime(double, const vector<String>& arguments)
 586 {
 587         if (arguments.size() < 1)
 588                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 589
 590         int id = Convert::ToLong(arguments[0]);
 591         Logger::Write(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
 592         String rid = Service::GetDowntimeIDFromLegacyID(id);
 593         Service::RemoveDowntime(rid);
 594 }
 595
 596 void ExternalCommandProcessor::ScheduleHostDowntime(double, const vector<String>& arguments)
 597 {
 598         if (arguments.size() < 8)
 599                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
 600
 601         Host::Ptr host = Host::GetByName(arguments[0]);
 602
 603         String triggeredBy;
 604         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 605         if (triggeredByLegacy != 0)
 606                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 607
 608         Logger::Write(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
 609         Service::Ptr service = host->GetHostCheckService();
 610         if (service) {
 611                 (void) service->AddDowntime(arguments[6], arguments[7],
 612                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 613                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 614         }
 615 }
 616
 617 void ExternalCommandProcessor::DelHostDowntime(double, const vector<String>& arguments)
 618 {
 619         if (arguments.size() < 1)
 620                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 621
 622         int id = Convert::ToLong(arguments[0]);
 623         Logger::Write(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
 624         String rid = Service::GetDowntimeIDFromLegacyID(id);
 625         Service::RemoveDowntime(rid);
 626 }
 627
 628 void ExternalCommandProcessor::ScheduleHostSvcDowntime(double, const vector<String>& arguments)
 629 {
 630         if (arguments.size() < 8)
 631                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 argument."));
 632
 633         Host::Ptr host = Host::GetByName(arguments[0]);
 634
 635         String triggeredBy;
 636         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 637         if (triggeredByLegacy != 0)
 638                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 639
 640         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 641                 Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 642                 (void) service->AddDowntime(arguments[6], arguments[7],
 643                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 644                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 645         }
 646 }
 647
 648 void ExternalCommandProcessor::ScheduleHostgroupHostDowntime(double, const vector<String>& arguments)
 649 {
 650         if (arguments.size() < 8)
 651                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
 652
 653         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 654
 655         String triggeredBy;
 656         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 657         if (triggeredByLegacy != 0)
 658                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 659
 660         BOOST_FOREACH(const Host::Ptr& host, HostGroup::GetMembers(hg)) {
 661                 Logger::Write(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
 662                 Service::Ptr service = host->GetHostCheckService();
 663                 if (service) {
 664                         (void) service->AddDowntime(arguments[6], arguments[7],
 665                             Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 666                             Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 667                 }
 668         }
 669 }
 670
 671 void ExternalCommandProcessor::ScheduleHostgroupSvcDowntime(double, const vector<String>& arguments)
 672 {
 673         if (arguments.size() < 8)
 674                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
 675
 676         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 677
 678         String triggeredBy;
 679         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 680         if (triggeredByLegacy != 0)
 681                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 682
 683         /* Note: we can't just directly create downtimes for all the services by iterating
 684          * over all hosts in the host group - otherwise we might end up creating multiple
 685          * downtimes for some services. */
 686
 687         set<Service::Ptr> services;
 688
 689         BOOST_FOREACH(const Host::Ptr& host, HostGroup::GetMembers(hg)) {
 690                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 691                         services.insert(service);
 692                 }
 693         }
 694
 695         BOOST_FOREACH(const Service::Ptr& service, services) {
 696                 Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 697                 (void) service->AddDowntime(arguments[6], arguments[7],
 698                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 699                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 700         }
 701 }
 702
 703 void ExternalCommandProcessor::ScheduleServicegroupHostDowntime(double, const vector<String>& arguments)
 704 {
 705         if (arguments.size() < 8)
 706                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
 707
 708         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 709
 710         String triggeredBy;
 711         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 712         if (triggeredByLegacy != 0)
 713                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 714
 715         /* Note: we can't just directly create downtimes for all the hosts by iterating
 716          * over all services in the service group - otherwise we might end up creating multiple
 717          * downtimes for some hosts. */
 718
 719         set<Service::Ptr> services;
 720
 721         BOOST_FOREACH(const Service::Ptr& service, ServiceGroup::GetMembers(sg)) {
 722                 Host::Ptr host = service->GetHost();
 723                 Service::Ptr hcService = host->GetHostCheckService();
 724                 if (hcService)
 725                         services.insert(hcService);
 726         }
 727
 728         BOOST_FOREACH(const Service::Ptr& service, services) {
 729                 Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 730                 (void) service->AddDowntime(arguments[6], arguments[7],
 731                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 732                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 733         }
 734 }
 735
 736 void ExternalCommandProcessor::ScheduleServicegroupSvcDowntime(double, const vector<String>& arguments)
 737 {
 738         if (arguments.size() < 8)
 739                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 8 arguments."));
 740
 741         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 742
 743         String triggeredBy;
 744         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 745         if (triggeredByLegacy != 0)
 746                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 747
 748         BOOST_FOREACH(const Service::Ptr& service, ServiceGroup::GetMembers(sg)) {
 749                 Logger::Write(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 750                 (void) service->AddDowntime(arguments[6], arguments[7],
 751                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 752                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 753         }
 754 }
 755
 756 void ExternalCommandProcessor::AddHostComment(double, const vector<String>& arguments)
 757 {
 758         if (arguments.size() < 4)
 759                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 4 arguments."));
 760
 761         Host::Ptr host = Host::GetByName(arguments[0]);
 762
 763         Logger::Write(LogInformation, "icinga", "Creating comment for host " + host->GetName());
 764         Service::Ptr service = host->GetHostCheckService();
 765         if (service)
 766                 (void) service->AddComment(CommentUser, arguments[2], arguments[3], 0);
 767 }
 768
 769 void ExternalCommandProcessor::DelHostComment(double, const vector<String>& arguments)
 770 {
 771         if (arguments.size() < 1)
 772                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 773
 774         int id = Convert::ToLong(arguments[0]);
 775         Logger::Write(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
 776         String rid = Service::GetCommentIDFromLegacyID(id);
 777         Service::RemoveComment(rid);
 778 }
 779
 780 void ExternalCommandProcessor::AddSvcComment(double, const vector<String>& arguments)
 781 {
 782         if (arguments.size() < 5)
 783                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 5 arguments."));
 784
 785         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 786
 787         Logger::Write(LogInformation, "icinga", "Creating comment for service " + service->GetName());
 788         (void) service->AddComment(CommentUser, arguments[3], arguments[4], 0);
 789 }
 790
 791 void ExternalCommandProcessor::DelSvcComment(double, const vector<String>& arguments)
 792 {
 793         if (arguments.size() < 1)
 794                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 795
 796         int id = Convert::ToLong(arguments[0]);
 797         Logger::Write(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
 798
 799         String rid = Service::GetCommentIDFromLegacyID(id);
 800         Service::RemoveComment(rid);
 801 }
 802
 803 void ExternalCommandProcessor::DelAllHostComments(double, const vector<String>& arguments)
 804 {
 805         if (arguments.size() < 1)
 806                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 1 argument."));
 807
 808         Host::Ptr host = Host::GetByName(arguments[0]);
 809
 810         Logger::Write(LogInformation, "icinga", "Removing all comments for host " + host->GetName());
 811         Service::Ptr service = host->GetHostCheckService();
 812         if (service)
 813                 service->RemoveAllComments();
 814 }
 815
 816 void ExternalCommandProcessor::DelAllSvcComments(double, const vector<String>& arguments)
 817 {
 818         if (arguments.size() < 2)
 819                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 2 arguments."));
 820
 821         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 822
 823         Logger::Write(LogInformation, "icinga", "Removing all comments for service " + service->GetName());
 824         service->RemoveAllComments();
 825 }
 826
 827 void ExternalCommandProcessor::SendCustomHostNotification(double time, const vector<String>& arguments)
 828 {
 829         if (arguments.size() < 4)
 830                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 4 arguments."));
 831
 832         Host::Ptr host = Host::GetByName(arguments[0]);
 833
 834         Logger::Write(LogInformation, "icinga", "Sending custom notification for host " + host->GetName());
 835         Service::Ptr service = host->GetHostCheckService();
 836         if (service) {
 837                 service->RequestNotifications(NotificationCustom);
 838         }
 839 }
 840
 841 void ExternalCommandProcessor::SendCustomSvcNotification(double time, const vector<String>& arguments)
 842 {
 843         if (arguments.size() < 5)
 844                 BOOST_THROW_EXCEPTION(invalid_argument("Expected 5 arguments."));
 845
 846         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 847
 848         Logger::Write(LogInformation, "icinga", "Sending custom notification for service " + service->GetName());
 849         service->RequestNotifications(NotificationCustom);
 850 }