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