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 "icinga/externalcommandprocessor.h"
  21 #include "icinga/host.h"
  22 #include "icinga/service.h"
  23 #include "icinga/user.h"
  24 #include "icinga/hostgroup.h"
  25 #include "icinga/servicegroup.h"
  26 #include "icinga/pluginchecktask.h"
  27 #include "base/convert.h"
  28 #include "base/logger_fwd.h"
  29 #include "base/objectlock.h"
  30 #include "base/application.h"
  31 #include <fstream>
  32 #include <boost/algorithm/string/classification.hpp>
  33 #include <boost/foreach.hpp>
  34 #include <boost/exception/diagnostic_information.hpp>
  35 #include <boost/algorithm/string/split.hpp>
  36
  37 using namespace icinga;
  38
  39 boost::once_flag ExternalCommandProcessor::m_InitializeOnce = BOOST_ONCE_INIT;
  40 boost::mutex ExternalCommandProcessor::m_Mutex;
  41 std::map<String, ExternalCommandProcessor::Callback> ExternalCommandProcessor::m_Commands;
  42
  43 /**
  44  * @threadsafety Always.
  45  */
  46 void ExternalCommandProcessor::Execute(const String& line)
  47 {
  48         if (line.IsEmpty())
  49                 return;
  50
  51         if (line[0] != '[')
  52                 BOOST_THROW_EXCEPTION(std::invalid_argument("Missing timestamp in command: " + line));
  53
  54         size_t pos = line.FindFirstOf("]");
  55
  56         if (pos == String::NPos)
  57                 BOOST_THROW_EXCEPTION(std::invalid_argument("Missing timestamp in command: " + line));
  58
  59         String timestamp = line.SubStr(1, pos - 1);
  60         String args = line.SubStr(pos + 2, String::NPos);
  61
  62         double ts = Convert::ToDouble(timestamp);
  63
  64         if (ts == 0)
  65                 BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid timestamp in command: " + line));
  66
  67         std::vector<String> argv;
  68         boost::algorithm::split(argv, args, boost::is_any_of(";"));
  69
  70         if (argv.empty())
  71                 BOOST_THROW_EXCEPTION(std::invalid_argument("Missing arguments in command: " + line));
  72
  73         std::vector<String> argvExtra(argv.begin() + 1, argv.end());
  74         Execute(ts, argv[0], argvExtra);
  75 }
  76
  77 /**
  78  * @threadsafety Always.
  79  */
  80 void ExternalCommandProcessor::Execute(double time, const String& command, const std::vector<String>& arguments)
  81 {
  82         boost::call_once(m_InitializeOnce, &ExternalCommandProcessor::Initialize);
  83
  84         Callback callback;
  85
  86         {
  87                 boost::mutex::scoped_lock lock(m_Mutex);
  88
  89                 std::map<String, ExternalCommandProcessor::Callback>::iterator it;
  90                 it = m_Commands.find(command);
  91
  92                 if (it == m_Commands.end())
  93                         BOOST_THROW_EXCEPTION(std::invalid_argument("The external command '" + command + "' does not exist."));
  94
  95                 callback = it->second;
  96         }
  97
  98         callback(time, arguments);
  99 }
 100
 101 /**
 102  * @threadsafety Always.
 103  */
 104 void ExternalCommandProcessor::Initialize(void)
 105 {
 106         RegisterCommand("PROCESS_HOST_CHECK_RESULT", &ExternalCommandProcessor::ProcessHostCheckResult);
 107         RegisterCommand("PROCESS_SERVICE_CHECK_RESULT", &ExternalCommandProcessor::ProcessServiceCheckResult);
 108         RegisterCommand("SCHEDULE_HOST_CHECK", &ExternalCommandProcessor::ScheduleHostCheck);
 109         RegisterCommand("SCHEDULE_FORCED_HOST_CHECK", &ExternalCommandProcessor::ScheduleForcedHostCheck);
 110         RegisterCommand("SCHEDULE_SVC_CHECK", &ExternalCommandProcessor::ScheduleSvcCheck);
 111         RegisterCommand("SCHEDULE_FORCED_SVC_CHECK", &ExternalCommandProcessor::ScheduleForcedSvcCheck);
 112         RegisterCommand("ENABLE_HOST_CHECK", &ExternalCommandProcessor::EnableHostCheck);
 113         RegisterCommand("DISABLE_HOST_CHECK", &ExternalCommandProcessor::DisableHostCheck);
 114         RegisterCommand("ENABLE_SVC_CHECK", &ExternalCommandProcessor::EnableSvcCheck);
 115         RegisterCommand("DISABLE_SVC_CHECK", &ExternalCommandProcessor::DisableSvcCheck);
 116         RegisterCommand("SHUTDOWN_PROCESS", &ExternalCommandProcessor::ShutdownProcess);
 117         RegisterCommand("SCHEDULE_FORCED_HOST_SVC_CHECKS", &ExternalCommandProcessor::ScheduleForcedHostSvcChecks);
 118         RegisterCommand("SCHEDULE_HOST_SVC_CHECKS", &ExternalCommandProcessor::ScheduleHostSvcChecks);
 119         RegisterCommand("ENABLE_HOST_SVC_CHECKS", &ExternalCommandProcessor::EnableHostSvcChecks);
 120         RegisterCommand("DISABLE_HOST_SVC_CHECKS", &ExternalCommandProcessor::DisableHostSvcChecks);
 121         RegisterCommand("ACKNOWLEDGE_SVC_PROBLEM", &ExternalCommandProcessor::AcknowledgeSvcProblem);
 122         RegisterCommand("ACKNOWLEDGE_SVC_PROBLEM_EXPIRE", &ExternalCommandProcessor::AcknowledgeSvcProblemExpire);
 123         RegisterCommand("REMOVE_SVC_ACKNOWLEDGEMENT", &ExternalCommandProcessor::RemoveSvcAcknowledgement);
 124         RegisterCommand("ACKNOWLEDGE_HOST_PROBLEM", &ExternalCommandProcessor::AcknowledgeHostProblem);
 125         RegisterCommand("ACKNOWLEDGE_HOST_PROBLEM_EXPIRE", &ExternalCommandProcessor::AcknowledgeHostProblemExpire);
 126         RegisterCommand("REMOVE_HOST_ACKNOWLEDGEMENT", &ExternalCommandProcessor::RemoveHostAcknowledgement);
 127         RegisterCommand("ENABLE_HOSTGROUP_SVC_CHECKS", &ExternalCommandProcessor::EnableHostgroupSvcChecks);
 128         RegisterCommand("DISABLE_HOSTGROUP_SVC_CHECKS", &ExternalCommandProcessor::DisableHostgroupSvcChecks);
 129         RegisterCommand("ENABLE_SERVICEGROUP_SVC_CHECKS", &ExternalCommandProcessor::EnableServicegroupSvcChecks);
 130         RegisterCommand("DISABLE_SERVICEGROUP_SVC_CHECKS", &ExternalCommandProcessor::DisableServicegroupSvcChecks);
 131         RegisterCommand("ENABLE_PASSIVE_HOST_CHECKS", &ExternalCommandProcessor::EnablePassiveHostChecks);
 132         RegisterCommand("DISABLE_PASSIVE_HOST_CHECKS", &ExternalCommandProcessor::DisablePassiveHostChecks);
 133         RegisterCommand("ENABLE_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::EnablePassiveSvcChecks);
 134         RegisterCommand("DISABLE_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::DisablePassiveSvcChecks);
 135         RegisterCommand("ENABLE_SERVICEGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::EnableServicegroupPassiveSvcChecks);
 136         RegisterCommand("DISABLE_SERVICEGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::DisableServicegroupPassiveSvcChecks);
 137         RegisterCommand("ENABLE_HOSTGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::EnableHostgroupPassiveSvcChecks);
 138         RegisterCommand("DISABLE_HOSTGROUP_PASSIVE_SVC_CHECKS", &ExternalCommandProcessor::DisableHostgroupPassiveSvcChecks);
 139         RegisterCommand("PROCESS_FILE", &ExternalCommandProcessor::ProcessFile);
 140         RegisterCommand("SCHEDULE_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleSvcDowntime);
 141         RegisterCommand("DEL_SVC_DOWNTIME", &ExternalCommandProcessor::DelSvcDowntime);
 142         RegisterCommand("SCHEDULE_HOST_DOWNTIME", &ExternalCommandProcessor::ScheduleHostDowntime);
 143         RegisterCommand("DEL_HOST_DOWNTIME", &ExternalCommandProcessor::DelHostDowntime);
 144         RegisterCommand("SCHEDULE_HOST_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleHostSvcDowntime);
 145         RegisterCommand("SCHEDULE_HOSTGROUP_HOST_DOWNTIME", &ExternalCommandProcessor::ScheduleHostgroupHostDowntime);
 146         RegisterCommand("SCHEDULE_HOSTGROUP_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleHostgroupSvcDowntime);
 147         RegisterCommand("SCHEDULE_SERVICEGROUP_HOST_DOWNTIME", &ExternalCommandProcessor::ScheduleServicegroupHostDowntime);
 148         RegisterCommand("SCHEDULE_SERVICEGROUP_SVC_DOWNTIME", &ExternalCommandProcessor::ScheduleServicegroupSvcDowntime);
 149         RegisterCommand("ADD_HOST_COMMENT", &ExternalCommandProcessor::AddHostComment);
 150         RegisterCommand("DEL_HOST_COMMENT", &ExternalCommandProcessor::DelHostComment);
 151         RegisterCommand("ADD_SVC_COMMENT", &ExternalCommandProcessor::AddSvcComment);
 152         RegisterCommand("DEL_SVC_COMMENT", &ExternalCommandProcessor::DelSvcComment);
 153         RegisterCommand("DEL_ALL_HOST_COMMENTS", &ExternalCommandProcessor::DelAllHostComments);
 154         RegisterCommand("DEL_ALL_SVC_COMMENTS", &ExternalCommandProcessor::DelAllSvcComments);
 155         RegisterCommand("SEND_CUSTOM_HOST_NOTIFICATION", &ExternalCommandProcessor::SendCustomHostNotification);
 156         RegisterCommand("SEND_CUSTOM_SVC_NOTIFICATION", &ExternalCommandProcessor::SendCustomSvcNotification);
 157         RegisterCommand("DELAY_HOST_NOTIFICATION", &ExternalCommandProcessor::DelayHostNotification);
 158         RegisterCommand("DELAY_SVC_NOTIFICATION", &ExternalCommandProcessor::DelaySvcNotification);
 159         RegisterCommand("ENABLE_HOST_NOTIFICATIONS", &ExternalCommandProcessor::EnableHostNotifications);
 160         RegisterCommand("DISABLE_HOST_NOTIFICATIONS", &ExternalCommandProcessor::DisableHostNotifications);
 161         RegisterCommand("ENABLE_SVC_NOTIFICATIONS", &ExternalCommandProcessor::EnableSvcNotifications);
 162         RegisterCommand("DISABLE_SVC_NOTIFICATIONS", &ExternalCommandProcessor::DisableSvcNotifications);
 163 }
 164
 165 /**
 166  * @threadsafety Always.
 167  */
 168 void ExternalCommandProcessor::RegisterCommand(const String& command, const ExternalCommandProcessor::Callback& callback)
 169 {
 170         boost::mutex::scoped_lock lock(m_Mutex);
 171         m_Commands[command] = callback;
 172 }
 173
 174 void ExternalCommandProcessor::ProcessHostCheckResult(double time, const std::vector<String>& arguments)
 175 {
 176         if (arguments.size() < 3)
 177                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
 178
 179         Host::Ptr host = Host::GetByName(arguments[0]);
 180
 181         Service::Ptr hc = host->GetHostCheckService();
 182
 183         if (!hc->GetEnablePassiveChecks())
 184                 BOOST_THROW_EXCEPTION(std::invalid_argument("Got passive check result for host '" + arguments[0] + "' which has passive checks disabled."));
 185
 186         int exitStatus = Convert::ToDouble(arguments[1]);
 187         Dictionary::Ptr result = PluginCheckTask::ParseCheckOutput(arguments[2]);
 188         result->Set("state", PluginCheckTask::ExitStatusToState(exitStatus));
 189
 190         result->Set("schedule_start", time);
 191         result->Set("schedule_end", time);
 192         result->Set("execution_start", time);
 193         result->Set("execution_end", time);
 194         result->Set("active", 0);
 195
 196         Log(LogInformation, "icinga", "Processing passive check result for host '" + arguments[0] + "'");
 197         hc->ProcessCheckResult(result);
 198
 199         {
 200                 ObjectLock olock(hc);
 201
 202                 /* Reschedule the next check. The side effect of this is that for as long
 203                  * as we receive passive results for a service we won't execute any
 204                  * active checks. */
 205                 hc->SetNextCheck(Utility::GetTime() + hc->GetCheckInterval());
 206         }
 207 }
 208
 209 void ExternalCommandProcessor::ProcessServiceCheckResult(double time, const std::vector<String>& arguments)
 210 {
 211         if (arguments.size() < 4)
 212                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 4 arguments."));
 213
 214         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 215
 216         if (!service->GetEnablePassiveChecks())
 217                 BOOST_THROW_EXCEPTION(std::invalid_argument("Got passive check result for service '" + arguments[1] + "' which has passive checks disabled."));
 218
 219         int exitStatus = Convert::ToDouble(arguments[2]);
 220         Dictionary::Ptr result = PluginCheckTask::ParseCheckOutput(arguments[3]);
 221         result->Set("state", PluginCheckTask::ExitStatusToState(exitStatus));
 222
 223         result->Set("schedule_start", time);
 224         result->Set("schedule_end", time);
 225         result->Set("execution_start", time);
 226         result->Set("execution_end", time);
 227         result->Set("active", 0);
 228
 229         Log(LogInformation, "icinga", "Processing passive check result for service '" + arguments[1] + "'");
 230         service->ProcessCheckResult(result);
 231
 232         {
 233                 ObjectLock olock(service);
 234
 235                 /* Reschedule the next check. The side effect of this is that for as long
 236                  * as we receive passive results for a service we won't execute any
 237                  * active checks. */
 238                 service->SetNextCheck(Utility::GetTime() + service->GetCheckInterval());
 239         }
 240 }
 241
 242 void ExternalCommandProcessor::ScheduleHostCheck(double, const std::vector<String>& arguments)
 243 {
 244         if (arguments.size() < 2)
 245                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 246
 247         Host::Ptr host = Host::GetByName(arguments[0]);
 248
 249         Service::Ptr hc = host->GetHostCheckService();
 250
 251         double planned_check = Convert::ToDouble(arguments[1]);
 252
 253         if (planned_check > hc->GetNextCheck()) {
 254                 Log(LogInformation, "icinga", "Ignoring reschedule request for host '" +
 255                     arguments[0] + "' (next check is already sooner than requested check time)");
 256                 return;
 257         }
 258
 259         Log(LogInformation, "icinga", "Rescheduling next check for host '" + arguments[0] + "'");
 260
 261         {
 262                 ObjectLock olock(hc);
 263
 264                 hc->SetNextCheck(planned_check);
 265         }
 266 }
 267
 268 void ExternalCommandProcessor::ScheduleForcedHostCheck(double, const std::vector<String>& arguments)
 269 {
 270         if (arguments.size() < 2)
 271                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 272
 273         Host::Ptr host = Host::GetByName(arguments[0]);
 274
 275         Service::Ptr hc = host->GetHostCheckService();
 276
 277         Log(LogInformation, "icinga", "Rescheduling next check for host '" + arguments[0] + "'");
 278
 279         {
 280                 ObjectLock olock(hc);
 281
 282                 hc->SetForceNextCheck(true);
 283                 hc->SetNextCheck(Convert::ToDouble(arguments[1]));
 284         }
 285 }
 286
 287 void ExternalCommandProcessor::ScheduleSvcCheck(double, const std::vector<String>& arguments)
 288 {
 289         if (arguments.size() < 3)
 290                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
 291
 292         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 293
 294         double planned_check = Convert::ToDouble(arguments[2]);
 295
 296         if (planned_check > service->GetNextCheck()) {
 297                 Log(LogInformation, "icinga", "Ignoring reschedule request for service '" +
 298                     arguments[1] + "' (next check is already sooner than requested check time)");
 299                 return;
 300         }
 301
 302         Log(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
 303
 304         {
 305                 ObjectLock olock(service);
 306
 307                 service->SetNextCheck(planned_check);
 308         }
 309 }
 310
 311 void ExternalCommandProcessor::ScheduleForcedSvcCheck(double, const std::vector<String>& arguments)
 312 {
 313         if (arguments.size() < 3)
 314                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
 315
 316         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 317
 318         Log(LogInformation, "icinga", "Rescheduling next check for service '" + arguments[1] + "'");
 319
 320         {
 321                 ObjectLock olock(service);
 322
 323                 service->SetForceNextCheck(true);
 324                 service->SetNextCheck(Convert::ToDouble(arguments[2]));
 325         }
 326 }
 327
 328 void ExternalCommandProcessor::EnableHostCheck(double, const std::vector<String>& arguments)
 329 {
 330         if (arguments.size() < 1)
 331                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 332
 333         Host::Ptr host = Host::GetByName(arguments[0]);
 334
 335         Log(LogInformation, "icinga", "Enabling active checks for host '" + arguments[0] + "'");
 336         Service::Ptr hc = host->GetHostCheckService();
 337
 338         if (!hc)
 339                 return;
 340
 341         {
 342                 ObjectLock olock(hc);
 343
 344                 hc->SetEnableActiveChecks(true);
 345         }
 346 }
 347
 348 void ExternalCommandProcessor::DisableHostCheck(double, const std::vector<String>& arguments)
 349 {
 350         if (arguments.size() < 1)
 351                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 352
 353         Host::Ptr host = Host::GetByName(arguments[0]);
 354
 355         Log(LogInformation, "icinga", "Disabling active checks for host '" + arguments[0] + "'");
 356         Service::Ptr hc = host->GetHostCheckService();
 357
 358         if (!hc)
 359                 return;
 360
 361         {
 362                 ObjectLock olock(hc);
 363
 364                 hc->SetEnableActiveChecks(false);
 365         }
 366 }
 367
 368 void ExternalCommandProcessor::EnableSvcCheck(double, const std::vector<String>& arguments)
 369 {
 370         if (arguments.size() < 2)
 371                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 372
 373         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 374
 375         Log(LogInformation, "icinga", "Enabling active checks for service '" + arguments[1] + "'");
 376
 377         {
 378                 ObjectLock olock(service);
 379
 380                 service->SetEnableActiveChecks(true);
 381         }
 382 }
 383
 384 void ExternalCommandProcessor::DisableSvcCheck(double, const std::vector<String>& arguments)
 385 {
 386         if (arguments.size() < 2)
 387                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 388
 389         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 390
 391         Log(LogInformation, "icinga", "Disabling active checks for service '" + arguments[1] + "'");
 392
 393         {
 394                 ObjectLock olock(service);
 395
 396                 service->SetEnableActiveChecks(false);
 397         }
 398 }
 399
 400 void ExternalCommandProcessor::ShutdownProcess(double, const std::vector<String>&)
 401 {
 402         Log(LogInformation, "icinga", "Shutting down Icinga via external command.");
 403         Application::RequestShutdown();
 404 }
 405
 406 void ExternalCommandProcessor::ScheduleForcedHostSvcChecks(double, const std::vector<String>& arguments)
 407 {
 408         if (arguments.size() < 2)
 409                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 410
 411         double planned_check = Convert::ToDouble(arguments[1]);
 412
 413         Host::Ptr host = Host::GetByName(arguments[0]);
 414
 415         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 416                 Log(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
 417
 418                 {
 419                         ObjectLock olock(service);
 420
 421                         service->SetNextCheck(planned_check);
 422                         service->SetForceNextCheck(true);
 423                 }
 424         }
 425 }
 426
 427 void ExternalCommandProcessor::ScheduleHostSvcChecks(double, const std::vector<String>& arguments)
 428 {
 429         if (arguments.size() < 2)
 430                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 431
 432         double planned_check = Convert::ToDouble(arguments[1]);
 433
 434         Host::Ptr host = Host::GetByName(arguments[0]);
 435
 436         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 437                 if (planned_check > service->GetNextCheck()) {
 438                         Log(LogInformation, "icinga", "Ignoring reschedule request for service '" +
 439                             service->GetName() + "' (next check is already sooner than requested check time)");
 440                         continue;
 441                 }
 442
 443                 Log(LogInformation, "icinga", "Rescheduling next check for service '" + service->GetName() + "'");
 444
 445                 {
 446                         ObjectLock olock(service);
 447
 448                         service->SetNextCheck(planned_check);
 449                 }
 450         }
 451 }
 452
 453 void ExternalCommandProcessor::EnableHostSvcChecks(double, const std::vector<String>& arguments)
 454 {
 455         if (arguments.size() < 1)
 456                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 457
 458         Host::Ptr host = Host::GetByName(arguments[0]);
 459
 460         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 461                 Log(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
 462                 service->SetEnableActiveChecks(true);
 463         }
 464 }
 465
 466 void ExternalCommandProcessor::DisableHostSvcChecks(double, const std::vector<String>& arguments)
 467 {
 468         if (arguments.size() < 1)
 469                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
 470
 471         Host::Ptr host = Host::GetByName(arguments[0]);
 472
 473         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 474                 Log(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
 475
 476                 {
 477                         ObjectLock olock(service);
 478
 479                         service->SetEnableActiveChecks(false);
 480                 }
 481         }
 482 }
 483
 484 void ExternalCommandProcessor::AcknowledgeSvcProblem(double, const std::vector<String>& arguments)
 485 {
 486         if (arguments.size() < 7)
 487                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 7 arguments."));
 488
 489         bool sticky = Convert::ToBool(arguments[2]);
 490
 491         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 492
 493         if (service->GetState() == StateOK)
 494                 BOOST_THROW_EXCEPTION(std::invalid_argument("The service '" + arguments[1] + "' is OK."));
 495
 496         Log(LogInformation, "icinga", "Setting acknowledgement for service '" + service->GetName() + "'");
 497
 498         service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal);
 499 }
 500
 501 void ExternalCommandProcessor::AcknowledgeSvcProblemExpire(double, const std::vector<String>& arguments)
 502 {
 503         if (arguments.size() < 8)
 504                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
 505
 506         bool sticky = Convert::ToBool(arguments[2]);
 507         double timestamp = Convert::ToDouble(arguments[5]);
 508
 509         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 510
 511         if (service->GetState() == StateOK)
 512                 BOOST_THROW_EXCEPTION(std::invalid_argument("The service '" + arguments[1] + "' is OK."));
 513
 514         Log(LogInformation, "icinga", "Setting timed acknowledgement for service '" + service->GetName() + "'");
 515
 516         service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal, timestamp);
 517 }
 518
 519 void ExternalCommandProcessor::RemoveSvcAcknowledgement(double, const std::vector<String>& arguments)
 520 {
 521         if (arguments.size() < 2)
 522                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 523
 524         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 525
 526         Log(LogInformation, "icinga", "Removing acknowledgement for service '" + service->GetName() + "'");
 527
 528         service->ClearAcknowledgement();
 529 }
 530
 531 void ExternalCommandProcessor::AcknowledgeHostProblem(double, const std::vector<String>& arguments)
 532 {
 533         if (arguments.size() < 6)
 534                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 6 arguments."));
 535
 536         bool sticky = Convert::ToBool(arguments[1]);
 537
 538         Host::Ptr host = Host::GetByName(arguments[0]);
 539
 540         Log(LogInformation, "icinga", "Setting acknowledgement for host '" + host->GetName() + "'");
 541         Service::Ptr service = host->GetHostCheckService();
 542         if (service) {
 543                 if (service->GetState() == StateOK)
 544                         BOOST_THROW_EXCEPTION(std::invalid_argument("The host '" + arguments[0] + "' is OK."));
 545
 546                 service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal);
 547         }
 548 }
 549
 550 void ExternalCommandProcessor::AcknowledgeHostProblemExpire(double, const std::vector<String>& arguments)
 551 {
 552         if (arguments.size() < 7)
 553                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 7 arguments."));
 554
 555         bool sticky = Convert::ToBool(arguments[1]);
 556         double timestamp = Convert::ToDouble(arguments[4]);
 557
 558         Host::Ptr host = Host::GetByName(arguments[0]);
 559
 560         Log(LogInformation, "icinga", "Setting timed acknowledgement for host '" + host->GetName() + "'");
 561         Service::Ptr service = host->GetHostCheckService();
 562         if (service) {
 563                 if (service->GetState() == StateOK)
 564                         BOOST_THROW_EXCEPTION(std::invalid_argument("The host '" + arguments[0] + "' is OK."));
 565
 566                 service->AcknowledgeProblem(sticky ? AcknowledgementSticky : AcknowledgementNormal, timestamp);
 567         }
 568 }
 569
 570 void ExternalCommandProcessor::RemoveHostAcknowledgement(double, const std::vector<String>& arguments)
 571 {
 572         if (arguments.size() < 1)
 573                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 574
 575         Host::Ptr host = Host::GetByName(arguments[0]);
 576
 577         Log(LogInformation, "icinga", "Removing acknowledgement for host '" + host->GetName() + "'");
 578         Service::Ptr service = host->GetHostCheckService();
 579         if (service)
 580                 service->ClearAcknowledgement();
 581 }
 582
 583 void ExternalCommandProcessor::EnableHostgroupSvcChecks(double, const std::vector<String>& arguments)
 584 {
 585         if (arguments.size() < 1)
 586                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 587
 588         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 589
 590         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 591                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 592                         Log(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
 593
 594                         {
 595                                 ObjectLock olock(service);
 596
 597                                 service->SetEnableActiveChecks(true);
 598                         }
 599                 }
 600         }
 601 }
 602
 603 void ExternalCommandProcessor::DisableHostgroupSvcChecks(double, const std::vector<String>& arguments)
 604 {
 605         if (arguments.size() < 1)
 606                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 607
 608         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 609
 610         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 611                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 612                         Log(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
 613
 614                         {
 615                                 ObjectLock olock(service);
 616
 617                                 service->SetEnableActiveChecks(false);
 618                         }
 619                 }
 620         }
 621 }
 622
 623 void ExternalCommandProcessor::EnableServicegroupSvcChecks(double, const std::vector<String>& arguments)
 624 {
 625         if (arguments.size() < 1)
 626                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 627
 628         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 629
 630         BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
 631                 Log(LogInformation, "icinga", "Enabling active checks for service '" + service->GetName() + "'");
 632
 633                 {
 634                         ObjectLock olock(service);
 635
 636                         service->SetEnableActiveChecks(true);
 637                 }
 638         }
 639 }
 640
 641 void ExternalCommandProcessor::DisableServicegroupSvcChecks(double, const std::vector<String>& arguments)
 642 {
 643         if (arguments.size() < 1)
 644                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 645
 646         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 647
 648         BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
 649                 Log(LogInformation, "icinga", "Disabling active checks for service '" + service->GetName() + "'");
 650
 651                 {
 652                         ObjectLock olock(service);
 653
 654                         service->SetEnableActiveChecks(false);
 655                 }
 656         }
 657 }
 658
 659 void ExternalCommandProcessor::EnablePassiveHostChecks(double, const std::vector<String>& arguments)
 660 {
 661         if (arguments.size() < 1)
 662                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 663
 664         Host::Ptr host = Host::GetByName(arguments[0]);
 665
 666         Log(LogInformation, "icinga", "Enabling passive checks for host '" + arguments[0] + "'");
 667         Service::Ptr hc = host->GetHostCheckService();
 668
 669         if (!hc)
 670                 return;
 671
 672         {
 673                 ObjectLock olock(hc);
 674
 675                 hc->SetEnablePassiveChecks(true);
 676         }
 677 }
 678
 679 void ExternalCommandProcessor::DisablePassiveHostChecks(double, const std::vector<String>& arguments)
 680 {
 681         if (arguments.size() < 1)
 682                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 arguments."));
 683
 684         Host::Ptr host = Host::GetByName(arguments[0]);
 685
 686         Log(LogInformation, "icinga", "Disabling passive checks for host '" + arguments[0] + "'");
 687         Service::Ptr hc = host->GetHostCheckService();
 688
 689         if (!hc)
 690                 return;
 691
 692         {
 693                 ObjectLock olock(hc);
 694
 695                 hc->SetEnablePassiveChecks(false);
 696         }
 697 }
 698
 699 void ExternalCommandProcessor::EnablePassiveSvcChecks(double, const std::vector<String>& arguments)
 700 {
 701         if (arguments.size() < 2)
 702                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 703
 704         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 705
 706         Log(LogInformation, "icinga", "Enabling passive checks for service '" + arguments[1] + "'");
 707
 708         {
 709                 ObjectLock olock(service);
 710
 711                 service->SetEnablePassiveChecks(true);
 712         }
 713 }
 714
 715 void ExternalCommandProcessor::DisablePassiveSvcChecks(double, const std::vector<String>& arguments)
 716 {
 717         if (arguments.size() < 2)
 718                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 719
 720         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 721
 722         Log(LogInformation, "icinga", "Disabling passive checks for service '" + arguments[1] + "'");
 723
 724         {
 725                 ObjectLock olock(service);
 726
 727                 service->SetEnablePassiveChecks(false);
 728         }
 729 }
 730
 731 void ExternalCommandProcessor::EnableServicegroupPassiveSvcChecks(double, const std::vector<String>& arguments)
 732 {
 733         if (arguments.size() < 1)
 734                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 735
 736         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 737
 738         BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
 739                 Log(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
 740
 741                 {
 742                         ObjectLock olock(service);
 743
 744                         service->SetEnablePassiveChecks(true);
 745                 }
 746         }
 747 }
 748
 749 void ExternalCommandProcessor::DisableServicegroupPassiveSvcChecks(double, const std::vector<String>& arguments)
 750 {
 751         if (arguments.size() < 1)
 752                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 753
 754         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 755
 756         BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
 757                 Log(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
 758
 759                 {
 760                         ObjectLock olock(service);
 761
 762                         service->SetEnablePassiveChecks(true);
 763                 }
 764         }
 765 }
 766
 767 void ExternalCommandProcessor::EnableHostgroupPassiveSvcChecks(double, const std::vector<String>& arguments)
 768 {
 769         if (arguments.size() < 1)
 770                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 771
 772         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 773
 774         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 775                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 776                         Log(LogInformation, "icinga", "Enabling passive checks for service '" + service->GetName() + "'");
 777
 778                         {
 779                                 ObjectLock olock(service);
 780
 781                                 service->SetEnablePassiveChecks(true);
 782                         }
 783                 }
 784         }
 785 }
 786
 787 void ExternalCommandProcessor::DisableHostgroupPassiveSvcChecks(double, const std::vector<String>& arguments)
 788 {
 789         if (arguments.size() < 1)
 790                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 791
 792         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 793
 794         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 795                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 796                         Log(LogInformation, "icinga", "Disabling passive checks for service '" + service->GetName() + "'");
 797
 798                         {
 799                                 ObjectLock olock(service);
 800
 801                                 service->SetEnablePassiveChecks(false);
 802                         }
 803                 }
 804         }
 805 }
 806
 807 void ExternalCommandProcessor::ProcessFile(double, const std::vector<String>& arguments)
 808 {
 809         if (arguments.size() < 2)
 810                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
 811
 812         String file = arguments[0];
 813         bool del = Convert::ToBool(arguments[1]);
 814
 815         std::ifstream ifp;
 816         ifp.exceptions(std::ifstream::badbit);
 817
 818         ifp.open(file.CStr(), std::ifstream::in);
 819
 820         while(ifp.good()) {
 821                 std::string line;
 822                 std::getline(ifp, line);
 823
 824                 try {
 825                         Log(LogInformation, "compat", "Executing external command: " + line);
 826
 827                         Execute(line);
 828                 } catch (const std::exception& ex) {
 829                         std::ostringstream msgbuf;
 830                         msgbuf << "External command failed: " << boost::diagnostic_information(ex);
 831                         Log(LogWarning, "icinga", msgbuf.str());
 832                 }
 833         }
 834
 835         ifp.close();
 836
 837         if (del)
 838                 (void) unlink(file.CStr());
 839 }
 840
 841 void ExternalCommandProcessor::ScheduleSvcDowntime(double, const std::vector<String>& arguments)
 842 {
 843         if (arguments.size() < 9)
 844                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 9 arguments."));
 845
 846         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
 847
 848         String triggeredBy;
 849         int triggeredByLegacy = Convert::ToLong(arguments[5]);
 850         if (triggeredByLegacy != 0)
 851                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 852
 853         Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 854         (void) service->AddDowntime(arguments[7], arguments[8],
 855             Convert::ToDouble(arguments[2]), Convert::ToDouble(arguments[3]),
 856             Convert::ToBool(arguments[4]), triggeredBy, Convert::ToDouble(arguments[6]));
 857 }
 858
 859 void ExternalCommandProcessor::DelSvcDowntime(double, const std::vector<String>& arguments)
 860 {
 861         if (arguments.size() < 1)
 862                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 863
 864         int id = Convert::ToLong(arguments[0]);
 865         Log(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
 866         String rid = Service::GetDowntimeIDFromLegacyID(id);
 867         Service::RemoveDowntime(rid);
 868 }
 869
 870 void ExternalCommandProcessor::ScheduleHostDowntime(double, const std::vector<String>& arguments)
 871 {
 872         if (arguments.size() < 8)
 873                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
 874
 875         Host::Ptr host = Host::GetByName(arguments[0]);
 876
 877         String triggeredBy;
 878         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 879         if (triggeredByLegacy != 0)
 880                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 881
 882         Log(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
 883         Service::Ptr service = host->GetHostCheckService();
 884         if (service) {
 885                 (void) service->AddDowntime(arguments[6], arguments[7],
 886                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 887                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 888         }
 889 }
 890
 891 void ExternalCommandProcessor::DelHostDowntime(double, const std::vector<String>& arguments)
 892 {
 893         if (arguments.size() < 1)
 894                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
 895
 896         int id = Convert::ToLong(arguments[0]);
 897         Log(LogInformation, "icinga", "Removing downtime ID " + arguments[0]);
 898         String rid = Service::GetDowntimeIDFromLegacyID(id);
 899         Service::RemoveDowntime(rid);
 900 }
 901
 902 void ExternalCommandProcessor::ScheduleHostSvcDowntime(double, const std::vector<String>& arguments)
 903 {
 904         if (arguments.size() < 8)
 905                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 argument."));
 906
 907         Host::Ptr host = Host::GetByName(arguments[0]);
 908
 909         String triggeredBy;
 910         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 911         if (triggeredByLegacy != 0)
 912                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 913
 914         BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 915                 Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 916                 (void) service->AddDowntime(arguments[6], arguments[7],
 917                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 918                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 919         }
 920 }
 921
 922 void ExternalCommandProcessor::ScheduleHostgroupHostDowntime(double, const std::vector<String>& arguments)
 923 {
 924         if (arguments.size() < 8)
 925                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
 926
 927         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 928
 929         String triggeredBy;
 930         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 931         if (triggeredByLegacy != 0)
 932                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 933
 934         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 935                 Log(LogInformation, "icinga", "Creating downtime for host " + host->GetName());
 936                 Service::Ptr service = host->GetHostCheckService();
 937                 if (service) {
 938                         (void) service->AddDowntime(arguments[6], arguments[7],
 939                             Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 940                             Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 941                 }
 942         }
 943 }
 944
 945 void ExternalCommandProcessor::ScheduleHostgroupSvcDowntime(double, const std::vector<String>& arguments)
 946 {
 947         if (arguments.size() < 8)
 948                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
 949
 950         HostGroup::Ptr hg = HostGroup::GetByName(arguments[0]);
 951
 952         String triggeredBy;
 953         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 954         if (triggeredByLegacy != 0)
 955                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 956
 957         /* Note: we can't just directly create downtimes for all the services by iterating
 958          * over all hosts in the host group - otherwise we might end up creating multiple
 959          * downtimes for some services. */
 960
 961         std::set<Service::Ptr> services;
 962
 963         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 964                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 965                         services.insert(service);
 966                 }
 967         }
 968
 969         BOOST_FOREACH(const Service::Ptr& service, services) {
 970                 Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
 971                 (void) service->AddDowntime(arguments[6], arguments[7],
 972                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
 973                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
 974         }
 975 }
 976
 977 void ExternalCommandProcessor::ScheduleServicegroupHostDowntime(double, const std::vector<String>& arguments)
 978 {
 979         if (arguments.size() < 8)
 980                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
 981
 982         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
 983
 984         String triggeredBy;
 985         int triggeredByLegacy = Convert::ToLong(arguments[4]);
 986         if (triggeredByLegacy != 0)
 987                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
 988
 989         /* Note: we can't just directly create downtimes for all the hosts by iterating
 990          * over all services in the service group - otherwise we might end up creating multiple
 991          * downtimes for some hosts. */
 992
 993         std::set<Service::Ptr> services;
 994
 995         BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
 996                 Host::Ptr host = service->GetHost();
 997                 Service::Ptr hcService = host->GetHostCheckService();
 998                 if (hcService)
 999                         services.insert(hcService);
1000         }
1001
1002         BOOST_FOREACH(const Service::Ptr& service, services) {
1003                 Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
1004                 (void) service->AddDowntime(arguments[6], arguments[7],
1005                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
1006                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
1007         }
1008 }
1009
1010 void ExternalCommandProcessor::ScheduleServicegroupSvcDowntime(double, const std::vector<String>& arguments)
1011 {
1012         if (arguments.size() < 8)
1013                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 8 arguments."));
1014
1015         ServiceGroup::Ptr sg = ServiceGroup::GetByName(arguments[0]);
1016
1017         String triggeredBy;
1018         int triggeredByLegacy = Convert::ToLong(arguments[4]);
1019         if (triggeredByLegacy != 0)
1020                 triggeredBy = Service::GetDowntimeIDFromLegacyID(triggeredByLegacy);
1021
1022         BOOST_FOREACH(const Service::Ptr& service, sg->GetMembers()) {
1023                 Log(LogInformation, "icinga", "Creating downtime for service " + service->GetName());
1024                 (void) service->AddDowntime(arguments[6], arguments[7],
1025                     Convert::ToDouble(arguments[1]), Convert::ToDouble(arguments[2]),
1026                     Convert::ToBool(arguments[3]), triggeredBy, Convert::ToDouble(arguments[5]));
1027         }
1028 }
1029
1030 void ExternalCommandProcessor::AddHostComment(double, const std::vector<String>& arguments)
1031 {
1032         if (arguments.size() < 4)
1033                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 4 arguments."));
1034
1035         Host::Ptr host = Host::GetByName(arguments[0]);
1036
1037         Log(LogInformation, "icinga", "Creating comment for host " + host->GetName());
1038         Service::Ptr service = host->GetHostCheckService();
1039         if (service)
1040                 (void) service->AddComment(CommentUser, arguments[2], arguments[3], 0);
1041 }
1042
1043 void ExternalCommandProcessor::DelHostComment(double, const std::vector<String>& arguments)
1044 {
1045         if (arguments.size() < 1)
1046                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
1047
1048         int id = Convert::ToLong(arguments[0]);
1049         Log(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
1050         String rid = Service::GetCommentIDFromLegacyID(id);
1051         Service::RemoveComment(rid);
1052 }
1053
1054 void ExternalCommandProcessor::AddSvcComment(double, const std::vector<String>& arguments)
1055 {
1056         if (arguments.size() < 5)
1057                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 5 arguments."));
1058
1059         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
1060
1061         Log(LogInformation, "icinga", "Creating comment for service " + service->GetName());
1062         (void) service->AddComment(CommentUser, arguments[3], arguments[4], 0);
1063 }
1064
1065 void ExternalCommandProcessor::DelSvcComment(double, const std::vector<String>& arguments)
1066 {
1067         if (arguments.size() < 1)
1068                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
1069
1070         int id = Convert::ToLong(arguments[0]);
1071         Log(LogInformation, "icinga", "Removing comment ID " + arguments[0]);
1072
1073         String rid = Service::GetCommentIDFromLegacyID(id);
1074         Service::RemoveComment(rid);
1075 }
1076
1077 void ExternalCommandProcessor::DelAllHostComments(double, const std::vector<String>& arguments)
1078 {
1079         if (arguments.size() < 1)
1080                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
1081
1082         Host::Ptr host = Host::GetByName(arguments[0]);
1083
1084         Log(LogInformation, "icinga", "Removing all comments for host " + host->GetName());
1085         Service::Ptr service = host->GetHostCheckService();
1086         if (service)
1087                 service->RemoveAllComments();
1088 }
1089
1090 void ExternalCommandProcessor::DelAllSvcComments(double, const std::vector<String>& arguments)
1091 {
1092         if (arguments.size() < 2)
1093                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
1094
1095         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
1096
1097         Log(LogInformation, "icinga", "Removing all comments for service " + service->GetName());
1098         service->RemoveAllComments();
1099 }
1100
1101 void ExternalCommandProcessor::SendCustomHostNotification(double, const std::vector<String>& arguments)
1102 {
1103         if (arguments.size() < 4)
1104                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 4 arguments."));
1105
1106         Host::Ptr host = Host::GetByName(arguments[0]);
1107
1108         Log(LogInformation, "icinga", "Sending custom notification for host " + host->GetName());
1109         Service::Ptr service = host->GetHostCheckService();
1110         if (service)
1111                 service->RequestNotifications(NotificationCustom, service->GetLastCheckResult());
1112 }
1113
1114 void ExternalCommandProcessor::SendCustomSvcNotification(double, const std::vector<String>& arguments)
1115 {
1116         if (arguments.size() < 5)
1117                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 5 arguments."));
1118
1119         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
1120
1121         Log(LogInformation, "icinga", "Sending custom notification for service " + service->GetName());
1122         service->RequestNotifications(NotificationCustom, service->GetLastCheckResult());
1123 }
1124
1125 void ExternalCommandProcessor::DelayHostNotification(double, const std::vector<String>& arguments)
1126 {
1127         if (arguments.size() < 2)
1128                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
1129
1130         Host::Ptr host = Host::GetByName(arguments[0]);
1131
1132         Log(LogInformation, "icinga", "Delaying notifications for host " + host->GetName());
1133         Service::Ptr hc = host->GetHostCheckService();
1134         if (!hc)
1135                 return;
1136
1137         {
1138                 ObjectLock olock(hc);
1139
1140                 hc->SetLastNotification(Convert::ToDouble(arguments[1]));
1141         }
1142 }
1143
1144 void ExternalCommandProcessor::DelaySvcNotification(double, const std::vector<String>& arguments)
1145 {
1146         if (arguments.size() < 3)
1147                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 3 arguments."));
1148
1149         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
1150
1151         Log(LogInformation, "icinga", "Delaying notifications for service " + service->GetName());
1152
1153         {
1154                 ObjectLock olock(service);
1155
1156                 service->SetLastNotification(Convert::ToDouble(arguments[2]));
1157         }
1158 }
1159
1160 void ExternalCommandProcessor::EnableHostNotifications(double, const std::vector<String>& arguments)
1161 {
1162         if (arguments.size() < 1)
1163                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
1164
1165         Host::Ptr host = Host::GetByName(arguments[0]);
1166
1167         Log(LogInformation, "icinga", "Enabling notifications for host '" + arguments[0] + "'");
1168         Service::Ptr hc = host->GetHostCheckService();
1169
1170         if (!hc)
1171                 return;
1172
1173         {
1174                 ObjectLock olock(hc);
1175
1176                 hc->SetEnableNotifications(true);
1177         }
1178 }
1179
1180 void ExternalCommandProcessor::DisableHostNotifications(double, const std::vector<String>& arguments)
1181 {
1182         if (arguments.size() < 1)
1183                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 1 argument."));
1184
1185         Host::Ptr host = Host::GetByName(arguments[0]);
1186
1187         Log(LogInformation, "icinga", "Disabling notifications for host '" + arguments[0] + "'");
1188         Service::Ptr hc = host->GetHostCheckService();
1189
1190         if (!hc)
1191                 return;
1192
1193         {
1194                 ObjectLock olock(hc);
1195
1196                 hc->SetEnableNotifications(false);
1197         }
1198 }
1199
1200 void ExternalCommandProcessor::EnableSvcNotifications(double, const std::vector<String>& arguments)
1201 {
1202         if (arguments.size() < 2)
1203                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
1204
1205         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
1206
1207         Log(LogInformation, "icinga", "Enabling notifications for service '" + arguments[1] + "'");
1208
1209         {
1210                 ObjectLock olock(service);
1211
1212                 service->SetEnableNotifications(true);
1213         }
1214 }
1215
1216 void ExternalCommandProcessor::DisableSvcNotifications(double, const std::vector<String>& arguments)
1217 {
1218         if (arguments.size() < 2)
1219                 BOOST_THROW_EXCEPTION(std::invalid_argument("Expected 2 arguments."));
1220
1221         Service::Ptr service = Service::GetByNamePair(arguments[0], arguments[1]);
1222
1223         Log(LogInformation, "icinga", "Disabling notifications for service '" + arguments[1] + "'");
1224
1225         {
1226                 ObjectLock olock(service);
1227
1228                 service->SetEnableNotifications(false);
1229         }
1230 }