granicus.if.org Git - icinga2/blob - components/livestatus/servicestable.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 "livestatus/servicestable.h"
  21 #include "livestatus/hoststable.h"
  22 #include "icinga/service.h"
  23 #include "icinga/checkcommand.h"
  24 #include "icinga/eventcommand.h"
  25 #include "icinga/timeperiod.h"
  26 #include "icinga/macroprocessor.h"
  27 #include "icinga/icingaapplication.h"
  28 #include "base/dynamictype.h"
  29 #include "base/objectlock.h"
  30 #include "base/convert.h"
  31 #include <boost/foreach.hpp>
  32 #include <boost/tuple/tuple.hpp>
  33
  34 using namespace icinga;
  35 using namespace livestatus;
  36
  37 ServicesTable::ServicesTable(void)
  38 {
  39         AddColumns(this);
  40 }
  41
  42 void ServicesTable::AddColumns(Table *table, const String& prefix,
  43     const Column::ObjectAccessor& objectAccessor)
  44 {
  45         table->AddColumn(prefix + "description", Column(&ServicesTable::ShortNameAccessor, objectAccessor));
  46         table->AddColumn(prefix + "display_name", Column(&ServicesTable::DisplayNameAccessor, objectAccessor));
  47         table->AddColumn(prefix + "check_command", Column(&ServicesTable::CheckCommandAccessor, objectAccessor));
  48         table->AddColumn(prefix + "check_command_expanded", Column(&ServicesTable::CheckCommandExpandedAccessor, objectAccessor));
  49         table->AddColumn(prefix + "event_handler", Column(&ServicesTable::EventHandlerAccessor, objectAccessor));
  50         table->AddColumn(prefix + "plugin_output", Column(&ServicesTable::PluginOutputAccessor, objectAccessor));
  51         table->AddColumn(prefix + "long_plugin_output", Column(&ServicesTable::LongPluginOutputAccessor, objectAccessor));
  52         table->AddColumn(prefix + "perf_data", Column(&ServicesTable::PerfDataAccessor, objectAccessor));
  53         table->AddColumn(prefix + "notification_period", Column(&ServicesTable::NotificationPeriodAccessor, objectAccessor));
  54         table->AddColumn(prefix + "check_period", Column(&ServicesTable::CheckPeriodAccessor, objectAccessor));
  55         table->AddColumn(prefix + "notes", Column(&ServicesTable::NotesAccessor, objectAccessor));
  56         table->AddColumn(prefix + "notes_expanded", Column(&ServicesTable::NotesExpandedAccessor, objectAccessor));
  57         table->AddColumn(prefix + "notes_url", Column(&ServicesTable::NotesUrlAccessor, objectAccessor));
  58         table->AddColumn(prefix + "notes_url_expanded", Column(&ServicesTable::NotesUrlExpandedAccessor, objectAccessor));
  59         table->AddColumn(prefix + "action_url", Column(&ServicesTable::ActionUrlAccessor, objectAccessor));
  60         table->AddColumn(prefix + "action_url_expanded", Column(&ServicesTable::ActionUrlExpandedAccessor, objectAccessor));
  61         table->AddColumn(prefix + "icon_image", Column(&ServicesTable::IconImageAccessor, objectAccessor));
  62         table->AddColumn(prefix + "icon_image_expanded", Column(&ServicesTable::IconImageExpandedAccessor, objectAccessor));
  63         table->AddColumn(prefix + "icon_image_alt", Column(&ServicesTable::IconImageAltAccessor, objectAccessor));
  64         table->AddColumn(prefix + "initial_state", Column(&ServicesTable::InitialStateAccessor, objectAccessor));
  65         table->AddColumn(prefix + "max_check_attempts", Column(&ServicesTable::MaxCheckAttemptsAccessor, objectAccessor));
  66         table->AddColumn(prefix + "current_attempt", Column(&ServicesTable::CurrentAttemptAccessor, objectAccessor));
  67         table->AddColumn(prefix + "state", Column(&ServicesTable::StateAccessor, objectAccessor));
  68         table->AddColumn(prefix + "has_been_checked", Column(&ServicesTable::HasBeenCheckedAccessor, objectAccessor));
  69         table->AddColumn(prefix + "last_state", Column(&ServicesTable::LastStateAccessor, objectAccessor));
  70         table->AddColumn(prefix + "last_hard_state", Column(&ServicesTable::LastHardStateAccessor, objectAccessor));
  71         table->AddColumn(prefix + "state_type", Column(&ServicesTable::StateTypeAccessor, objectAccessor));
  72         table->AddColumn(prefix + "check_type", Column(&ServicesTable::CheckTypeAccessor, objectAccessor));
  73         table->AddColumn(prefix + "acknowledged", Column(&ServicesTable::AcknowledgedAccessor, objectAccessor));
  74         table->AddColumn(prefix + "acknowledgement_type", Column(&ServicesTable::AcknowledgementTypeAccessor, objectAccessor));
  75         table->AddColumn(prefix + "no_more_notifications", Column(&ServicesTable::NoMoreNotificationsAccessor, objectAccessor));
  76         table->AddColumn(prefix + "last_time_ok", Column(&ServicesTable::LastTimeOkAccessor, objectAccessor));
  77         table->AddColumn(prefix + "last_time_warning", Column(&ServicesTable::LastTimeWarningAccessor, objectAccessor));
  78         table->AddColumn(prefix + "last_time_critical", Column(&ServicesTable::LastTimeCriticalAccessor, objectAccessor));
  79         table->AddColumn(prefix + "last_time_unknown", Column(&ServicesTable::LastTimeUnknownAccessor, objectAccessor));
  80         table->AddColumn(prefix + "last_check", Column(&ServicesTable::LastCheckAccessor, objectAccessor));
  81         table->AddColumn(prefix + "next_check", Column(&ServicesTable::NextCheckAccessor, objectAccessor));
  82         table->AddColumn(prefix + "last_notification", Column(&ServicesTable::LastNotificationAccessor, objectAccessor));
  83         table->AddColumn(prefix + "next_notification", Column(&ServicesTable::NextNotificationAccessor, objectAccessor));
  84         table->AddColumn(prefix + "current_notification_number", Column(&ServicesTable::CurrentNotificationNumberAccessor, objectAccessor));
  85         table->AddColumn(prefix + "last_state_change", Column(&ServicesTable::LastStateChangeAccessor, objectAccessor));
  86         table->AddColumn(prefix + "last_hard_state_change", Column(&ServicesTable::LastHardStateChangeAccessor, objectAccessor));
  87         table->AddColumn(prefix + "scheduled_downtime_depth", Column(&ServicesTable::ScheduledDowntimeDepthAccessor, objectAccessor));
  88         table->AddColumn(prefix + "is_flapping", Column(&ServicesTable::IsFlappingAccessor, objectAccessor));
  89         table->AddColumn(prefix + "checks_enabled", Column(&ServicesTable::ChecksEnabledAccessor, objectAccessor));
  90         table->AddColumn(prefix + "accept_passive_checks", Column(&ServicesTable::AcceptPassiveChecksAccessor, objectAccessor));
  91         table->AddColumn(prefix + "event_handler_enabled", Column(&ServicesTable::EventHandlerEnabledAccessor, objectAccessor));
  92         table->AddColumn(prefix + "notifications_enabled", Column(&ServicesTable::NotificationsEnabledAccessor, objectAccessor));
  93         table->AddColumn(prefix + "process_performance_data", Column(&ServicesTable::ProcessPerformanceDataAccessor, objectAccessor));
  94         table->AddColumn(prefix + "is_executing", Column(&ServicesTable::IsExecutingAccessor, objectAccessor));
  95         table->AddColumn(prefix + "active_checks_enabled", Column(&ServicesTable::ActiveChecksEnabledAccessor, objectAccessor));
  96         table->AddColumn(prefix + "check_options", Column(&ServicesTable::CheckOptionsAccessor, objectAccessor));
  97         table->AddColumn(prefix + "flap_detection_enabled", Column(&ServicesTable::FlapDetectionEnabledAccessor, objectAccessor));
  98         table->AddColumn(prefix + "check_freshness", Column(&ServicesTable::CheckFreshnessAccessor, objectAccessor));
  99         table->AddColumn(prefix + "obsess_over_service", Column(&ServicesTable::ObsessOverServiceAccessor, objectAccessor));
 100         table->AddColumn(prefix + "modified_attributes", Column(&ServicesTable::ModifiedAttributesAccessor, objectAccessor));
 101         table->AddColumn(prefix + "modified_attributes_list", Column(&ServicesTable::ModifiedAttributesListAccessor, objectAccessor));
 102         table->AddColumn(prefix + "pnpgraph_present", Column(&ServicesTable::PnpgraphPresentAccessor, objectAccessor));
 103         table->AddColumn(prefix + "check_interval", Column(&ServicesTable::CheckIntervalAccessor, objectAccessor));
 104         table->AddColumn(prefix + "retry_interval", Column(&ServicesTable::RetryIntervalAccessor, objectAccessor));
 105         table->AddColumn(prefix + "notification_interval", Column(&ServicesTable::NotificationIntervalAccessor, objectAccessor));
 106         table->AddColumn(prefix + "first_notification_delay", Column(&ServicesTable::FirstNotificationDelayAccessor, objectAccessor));
 107         table->AddColumn(prefix + "low_flap_threshold", Column(&ServicesTable::LowFlapThresholdAccessor, objectAccessor));
 108         table->AddColumn(prefix + "high_flap_threshold", Column(&ServicesTable::HighFlapThresholdAccessor, objectAccessor));
 109         table->AddColumn(prefix + "latency", Column(&ServicesTable::LatencyAccessor, objectAccessor));
 110         table->AddColumn(prefix + "execution_time", Column(&ServicesTable::ExecutionTimeAccessor, objectAccessor));
 111         table->AddColumn(prefix + "percent_state_change", Column(&ServicesTable::PercentStateChangeAccessor, objectAccessor));
 112         table->AddColumn(prefix + "in_check_period", Column(&ServicesTable::InCheckPeriodAccessor, objectAccessor));
 113         table->AddColumn(prefix + "in_notification_period", Column(&ServicesTable::InNotificationPeriodAccessor, objectAccessor));
 114         table->AddColumn(prefix + "contacts", Column(&ServicesTable::ContactsAccessor, objectAccessor));
 115         table->AddColumn(prefix + "downtimes", Column(&ServicesTable::DowntimesAccessor, objectAccessor));
 116         table->AddColumn(prefix + "downtimes_with_info", Column(&ServicesTable::DowntimesWithInfoAccessor, objectAccessor));
 117         table->AddColumn(prefix + "comments", Column(&ServicesTable::CommentsAccessor, objectAccessor));
 118         table->AddColumn(prefix + "comments_with_info", Column(&ServicesTable::CommentsWithInfoAccessor, objectAccessor));
 119         table->AddColumn(prefix + "comments_with_extra_info", Column(&ServicesTable::CommentsWithExtraInfoAccessor, objectAccessor));
 120         table->AddColumn(prefix + "custom_variable_names", Column(&ServicesTable::CustomVariableNamesAccessor, objectAccessor));
 121         table->AddColumn(prefix + "custom_variable_values", Column(&ServicesTable::CustomVariableValuesAccessor, objectAccessor));
 122         table->AddColumn(prefix + "custom_variables", Column(&ServicesTable::CustomVariablesAccessor, objectAccessor));
 123         table->AddColumn(prefix + "groups", Column(&ServicesTable::GroupsAccessor, objectAccessor));
 124         table->AddColumn(prefix + "contact_groups", Column(&ServicesTable::ContactGroupsAccessor, objectAccessor));
 125
 126         HostsTable::AddColumns(table, "host_", boost::bind(&ServicesTable::HostAccessor, _1, objectAccessor));
 127 }
 128
 129 String ServicesTable::GetName(void) const
 130 {
 131         return "services";
 132 }
 133
 134 void ServicesTable::FetchRows(const AddRowFunction& addRowFn)
 135 {
 136         BOOST_FOREACH(const DynamicObject::Ptr& object, DynamicType::GetObjects("Service")) {
 137                 addRowFn(object);
 138         }
 139 }
 140
 141 Object::Ptr ServicesTable::HostAccessor(const Value& row, const Column::ObjectAccessor& parentObjectAccessor)
 142 {
 143         Value service;
 144
 145         if (parentObjectAccessor)
 146                 service = parentObjectAccessor(row);
 147         else
 148                 service = row;
 149
 150         return static_cast<Service::Ptr>(service)->GetHost();
 151 }
 152
 153 Value ServicesTable::ShortNameAccessor(const Value& row)
 154 {
 155         return static_cast<Service::Ptr>(row)->GetShortName();
 156 }
 157
 158 Value ServicesTable::DisplayNameAccessor(const Value& row)
 159 {
 160         return static_cast<Service::Ptr>(row)->GetDisplayName();
 161 }
 162
 163 Value ServicesTable::CheckCommandAccessor(const Value& row)
 164 {
 165         CheckCommand::Ptr checkcommand = static_cast<Service::Ptr>(row)->GetCheckCommand();
 166
 167         if (checkcommand)
 168                 return checkcommand->GetName(); /* this is the name without '!' args */
 169
 170         return Empty;
 171 }
 172
 173 Value ServicesTable::CheckCommandExpandedAccessor(const Value& row)
 174 {
 175         Service::Ptr service = static_cast<Service::Ptr>(row);
 176
 177         CheckCommand::Ptr commandObj = service->GetCheckCommand();
 178
 179         if (!commandObj)
 180                 return Empty;
 181
 182         Value raw_command = commandObj->GetCommandLine();
 183
 184         std::vector<MacroResolver::Ptr> resolvers;
 185         resolvers.push_back(commandObj);
 186         resolvers.push_back(service);
 187         resolvers.push_back(service->GetHost());
 188         resolvers.push_back(IcingaApplication::GetInstance());
 189
 190         Value commandLine = MacroProcessor::ResolveMacros(raw_command, resolvers, Dictionary::Ptr(), Utility::EscapeShellCmd);
 191
 192         String buf;
 193         if (commandLine.IsObjectType<Array>()) {
 194                 Array::Ptr args = commandLine;
 195
 196                 ObjectLock olock(args);
 197                 String arg;
 198                 BOOST_FOREACH(arg, args) {
 199                         // This is obviously incorrect for non-trivial cases.
 200                         String argitem = " \"" + arg + "\"";
 201                         boost::algorithm::replace_all(argitem, "\n", "\\n");
 202                         buf += argitem;
 203                 }
 204         } else if (!commandLine.IsEmpty()) {
 205                 String args = Convert::ToString(commandLine);
 206                 boost::algorithm::replace_all(args, "\n", "\\n");
 207                 buf += args;
 208         } else {
 209                 buf += "<internal>";
 210         }
 211
 212         return buf;
 213 }
 214
 215 Value ServicesTable::EventHandlerAccessor(const Value& row)
 216 {
 217         EventCommand::Ptr eventcommand = static_cast<Service::Ptr>(row)->GetEventCommand();
 218
 219         if (eventcommand)
 220                 return eventcommand->GetName();
 221
 222         return Empty;
 223 }
 224
 225 Value ServicesTable::PluginOutputAccessor(const Value& row)
 226 {
 227         return static_cast<Service::Ptr>(row)->GetLastCheckOutput();
 228 }
 229
 230 Value ServicesTable::LongPluginOutputAccessor(const Value& row)
 231 {
 232         return static_cast<Service::Ptr>(row)->GetLastCheckLongOutput();
 233 }
 234
 235 Value ServicesTable::PerfDataAccessor(const Value& row)
 236 {
 237         return static_cast<Service::Ptr>(row)->GetLastCheckPerfData();
 238 }
 239
 240 Value ServicesTable::NotificationPeriodAccessor(const Value& row)
 241 {
 242         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
 243                 ObjectLock olock(notification);
 244
 245                 TimePeriod::Ptr timeperiod = notification->GetNotificationPeriod();
 246
 247                 /* XXX first notification wins */
 248                 if (timeperiod)
 249                         return timeperiod->GetName();
 250         }
 251
 252         return Empty;
 253 }
 254
 255 Value ServicesTable::CheckPeriodAccessor(const Value& row)
 256 {
 257         TimePeriod::Ptr timeperiod = static_cast<Service::Ptr>(row)->GetCheckPeriod();
 258
 259         if (!timeperiod)
 260                 return Empty;
 261
 262         return timeperiod->GetName();
 263 }
 264
 265 Value ServicesTable::NotesAccessor(const Value& row)
 266 {
 267         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 268
 269         if (!custom)
 270                 return Empty;
 271
 272         return custom->Get("notes");
 273 }
 274
 275 Value ServicesTable::NotesExpandedAccessor(const Value& row)
 276 {
 277         Service::Ptr service = static_cast<Service::Ptr>(row);
 278         Dictionary::Ptr custom = service->GetCustom();
 279
 280         if (!custom)
 281                 return Empty;
 282
 283         std::vector<MacroResolver::Ptr> resolvers;
 284         resolvers.push_back(service);
 285         resolvers.push_back(service->GetHost());
 286         resolvers.push_back(IcingaApplication::GetInstance());
 287
 288         Value value = custom->Get("notes");
 289
 290         Dictionary::Ptr cr;
 291         Value value_expanded = MacroProcessor::ResolveMacros(value, resolvers, cr, Utility::EscapeShellCmd);
 292
 293         return value_expanded;
 294 }
 295
 296 Value ServicesTable::NotesUrlAccessor(const Value& row)
 297 {
 298         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 299
 300         if (!custom)
 301                 return Empty;
 302
 303         return custom->Get("notes_url");
 304 }
 305
 306 Value ServicesTable::NotesUrlExpandedAccessor(const Value& row)
 307 {
 308         Service::Ptr service = static_cast<Service::Ptr>(row);
 309         Dictionary::Ptr custom = service->GetCustom();
 310
 311         if (!custom)
 312                 return Empty;
 313
 314         std::vector<MacroResolver::Ptr> resolvers;
 315         resolvers.push_back(service);
 316         resolvers.push_back(service->GetHost());
 317         resolvers.push_back(IcingaApplication::GetInstance());
 318
 319         Value value = custom->Get("notes_url");
 320
 321         Dictionary::Ptr cr;
 322         Value value_expanded = MacroProcessor::ResolveMacros(value, resolvers, cr, Utility::EscapeShellCmd);
 323
 324         return value_expanded;
 325 }
 326
 327 Value ServicesTable::ActionUrlAccessor(const Value& row)
 328 {
 329         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 330
 331         if (!custom)
 332                 return Empty;
 333
 334         return custom->Get("action_url");
 335 }
 336
 337 Value ServicesTable::ActionUrlExpandedAccessor(const Value& row)
 338 {
 339         Service::Ptr service = static_cast<Service::Ptr>(row);
 340         Dictionary::Ptr custom = service->GetCustom();
 341
 342         if (!custom)
 343                 return Empty;
 344
 345         std::vector<MacroResolver::Ptr> resolvers;
 346         resolvers.push_back(service);
 347         resolvers.push_back(service->GetHost());
 348         resolvers.push_back(IcingaApplication::GetInstance());
 349
 350         Value value = custom->Get("action_url");
 351
 352         Dictionary::Ptr cr;
 353         Value value_expanded = MacroProcessor::ResolveMacros(value, resolvers, cr, Utility::EscapeShellCmd);
 354
 355         return value_expanded;
 356 }
 357
 358 Value ServicesTable::IconImageAccessor(const Value& row)
 359 {
 360         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 361
 362         if (!custom)
 363                 return Empty;
 364
 365         return custom->Get("icon_image");
 366 }
 367
 368 Value ServicesTable::IconImageExpandedAccessor(const Value& row)
 369 {
 370         Service::Ptr service = static_cast<Service::Ptr>(row);
 371         Dictionary::Ptr custom = service->GetCustom();
 372
 373         if (!custom)
 374                 return Empty;
 375
 376         std::vector<MacroResolver::Ptr> resolvers;
 377         resolvers.push_back(service);
 378         resolvers.push_back(service->GetHost());
 379         resolvers.push_back(IcingaApplication::GetInstance());
 380
 381         Value value = custom->Get("icon_image");
 382
 383         Dictionary::Ptr cr;
 384         Value value_expanded = MacroProcessor::ResolveMacros(value, resolvers, cr, Utility::EscapeShellCmd);
 385
 386         return value_expanded;
 387 }
 388
 389 Value ServicesTable::IconImageAltAccessor(const Value& row)
 390 {
 391         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 392
 393         if (!custom)
 394                 return Empty;
 395
 396         return custom->Get("icon_image_alt");
 397 }
 398
 399 Value ServicesTable::InitialStateAccessor(const Value& row)
 400 {
 401         /* not supported */
 402         return Empty;
 403 }
 404
 405 Value ServicesTable::MaxCheckAttemptsAccessor(const Value& row)
 406 {
 407         return static_cast<Service::Ptr>(row)->GetMaxCheckAttempts();
 408 }
 409
 410 Value ServicesTable::CurrentAttemptAccessor(const Value& row)
 411 {
 412         return static_cast<Service::Ptr>(row)->GetCurrentCheckAttempt();
 413 }
 414
 415 Value ServicesTable::StateAccessor(const Value& row)
 416 {
 417         return static_cast<Service::Ptr>(row)->GetState();
 418 }
 419
 420 Value ServicesTable::HasBeenCheckedAccessor(const Value& row)
 421 {
 422         return (static_cast<Service::Ptr>(row)->HasBeenChecked() ? 1 : 0);
 423 }
 424
 425 Value ServicesTable::LastStateAccessor(const Value& row)
 426 {
 427         return static_cast<Service::Ptr>(row)->GetLastState();
 428 }
 429
 430 Value ServicesTable::LastHardStateAccessor(const Value& row)
 431 {
 432         return static_cast<Service::Ptr>(row)->GetLastHardState();
 433 }
 434
 435 Value ServicesTable::StateTypeAccessor(const Value& row)
 436 {
 437         return static_cast<Service::Ptr>(row)->GetStateType();
 438 }
 439
 440 Value ServicesTable::CheckTypeAccessor(const Value& row)
 441 {
 442         return (static_cast<Service::Ptr>(row)->GetEnableActiveChecks() ? 0 : 1);
 443 }
 444
 445 Value ServicesTable::AcknowledgedAccessor(const Value& row)
 446 {
 447         Service::Ptr service = static_cast<Service::Ptr>(row);
 448
 449         /* important: lock acknowledgements */
 450         ObjectLock olock(service);
 451
 452         return (service->IsAcknowledged() ? 1 : 0);
 453 }
 454
 455 Value ServicesTable::AcknowledgementTypeAccessor(const Value& row)
 456 {
 457         Service::Ptr service = static_cast<Service::Ptr>(row);
 458
 459         /* important: lock acknowledgements */
 460         ObjectLock olock(service);
 461
 462         return static_cast<int>(service->GetAcknowledgement());
 463 }
 464
 465 Value ServicesTable::NoMoreNotificationsAccessor(const Value& row)
 466 {
 467         Service::Ptr service = static_cast<Service::Ptr>(row);
 468
 469         /* XXX take the smallest notification_interval */
 470         double notification_interval = -1;
 471         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 472                 if (notification_interval == -1 || notification->GetNotificationInterval() < notification_interval)
 473                         notification_interval = notification->GetNotificationInterval();
 474         }
 475
 476         if (notification_interval == 0 && !service->IsVolatile())
 477                 return 1;
 478
 479         return 0;
 480 }
 481
 482 Value ServicesTable::LastTimeOkAccessor(const Value& row)
 483 {
 484         /* TODO */
 485         return Empty;
 486 }
 487
 488 Value ServicesTable::LastTimeWarningAccessor(const Value& row)
 489 {
 490         /* TODO */
 491         return Empty;
 492 }
 493
 494 Value ServicesTable::LastTimeCriticalAccessor(const Value& row)
 495 {
 496         /* TODO */
 497         return Empty;
 498 }
 499
 500 Value ServicesTable::LastTimeUnknownAccessor(const Value& row)
 501 {
 502         /* TODO */
 503         return Empty;
 504 }
 505
 506 Value ServicesTable::LastCheckAccessor(const Value& row)
 507 {
 508         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastCheck());
 509 }
 510
 511 Value ServicesTable::NextCheckAccessor(const Value& row)
 512 {
 513         return static_cast<int>(static_cast<Service::Ptr>(row)->GetNextCheck());
 514 }
 515
 516 Value ServicesTable::LastNotificationAccessor(const Value& row)
 517 {
 518         Service::Ptr service = static_cast<Service::Ptr>(row);
 519
 520         /* XXX Service -> Notifications, latest wins */
 521         double last_notification = 0;
 522         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 523                 if (notification->GetLastNotification() > last_notification)
 524                         last_notification = notification->GetLastNotification();
 525         }
 526
 527         return static_cast<int>(last_notification);
 528 }
 529
 530 Value ServicesTable::NextNotificationAccessor(const Value& row)
 531 {
 532         Service::Ptr service = static_cast<Service::Ptr>(row);
 533
 534         /* XXX Service -> Notifications, latest wins */
 535         double next_notification = 0;
 536         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 537                 if (notification->GetNextNotification() < next_notification)
 538                         next_notification = notification->GetNextNotification();
 539         }
 540
 541         return static_cast<int>(next_notification);
 542 }
 543
 544 Value ServicesTable::CurrentNotificationNumberAccessor(const Value& row)
 545 {
 546         /* TODO not implemented yet */
 547         return Empty;
 548 }
 549
 550 Value ServicesTable::LastStateChangeAccessor(const Value& row)
 551 {
 552         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastStateChange());
 553 }
 554
 555 Value ServicesTable::LastHardStateChangeAccessor(const Value& row)
 556 {
 557         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastHardStateChange());
 558 }
 559
 560 Value ServicesTable::ScheduledDowntimeDepthAccessor(const Value& row)
 561 {
 562         return static_cast<Service::Ptr>(row)->GetDowntimeDepth();
 563 }
 564
 565 Value ServicesTable::IsFlappingAccessor(const Value& row)
 566 {
 567         return static_cast<Service::Ptr>(row)->IsFlapping();
 568 }
 569
 570 Value ServicesTable::ChecksEnabledAccessor(const Value& row)
 571 {
 572         return (static_cast<Service::Ptr>(row)->GetEnableActiveChecks() ? 1 : 0);
 573 }
 574
 575 Value ServicesTable::AcceptPassiveChecksAccessor(const Value& row)
 576 {
 577         return (static_cast<Service::Ptr>(row)->GetEnablePassiveChecks() ? 1 : 0);
 578 }
 579
 580 Value ServicesTable::EventHandlerEnabledAccessor(const Value& row)
 581 {
 582         /* TODO always enabled*/
 583         return Value(1);
 584 }
 585
 586 Value ServicesTable::NotificationsEnabledAccessor(const Value& row)
 587 {
 588         return (static_cast<Service::Ptr>(row)->GetEnableNotifications() ? 1 : 0);
 589 }
 590
 591 Value ServicesTable::ProcessPerformanceDataAccessor(const Value& row)
 592 {
 593         /* TODO always enabled */
 594         return Value(1);
 595 }
 596
 597 Value ServicesTable::IsExecutingAccessor(const Value& row)
 598 {
 599         /* TODO does that make sense with Icinga2? */
 600         return Empty;
 601 }
 602
 603 Value ServicesTable::ActiveChecksEnabledAccessor(const Value& row)
 604 {
 605         return (static_cast<Service::Ptr>(row)->GetEnableActiveChecks() ? 1 : 0);
 606 }
 607
 608 Value ServicesTable::CheckOptionsAccessor(const Value& row)
 609 {
 610         /* TODO - forcexec, freshness, orphan, none */
 611         return Empty;
 612 }
 613
 614 Value ServicesTable::FlapDetectionEnabledAccessor(const Value& row)
 615 {
 616         return (static_cast<Service::Ptr>(row)->GetEnableFlapping() ? 1 : 0);
 617 }
 618
 619 Value ServicesTable::CheckFreshnessAccessor(const Value& row)
 620 {
 621         /* TODO */
 622         return Empty;
 623 }
 624
 625 Value ServicesTable::ObsessOverServiceAccessor(const Value& row)
 626 {
 627         /* not supported */
 628         return Empty;
 629 }
 630
 631 Value ServicesTable::ModifiedAttributesAccessor(const Value& row)
 632 {
 633         /* not supported */
 634         return Empty;
 635 }
 636
 637 Value ServicesTable::ModifiedAttributesListAccessor(const Value& row)
 638 {
 639         /* not supported */
 640         return Empty;
 641 }
 642
 643 Value ServicesTable::PnpgraphPresentAccessor(const Value& row)
 644 {
 645         /* not supported */
 646         return Empty;
 647 }
 648
 649 Value ServicesTable::CheckIntervalAccessor(const Value& row)
 650 {
 651         return (static_cast<Service::Ptr>(row)->GetCheckInterval() / 60.0);
 652 }
 653
 654 Value ServicesTable::RetryIntervalAccessor(const Value& row)
 655 {
 656         return (static_cast<Service::Ptr>(row)->GetRetryInterval() / 60.0);
 657 }
 658
 659 Value ServicesTable::NotificationIntervalAccessor(const Value& row)
 660 {
 661         Service::Ptr service = static_cast<Service::Ptr>(row);
 662
 663         /* XXX take the smallest notification_interval */
 664         double notification_interval = -1;
 665         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 666                 if (notification_interval == -1 || notification->GetNotificationInterval() < notification_interval)
 667                         notification_interval = notification->GetNotificationInterval();
 668         }
 669
 670         if (notification_interval == -1)
 671                 notification_interval = 60;
 672
 673         return (notification_interval / 60.0);
 674 }
 675
 676 Value ServicesTable::FirstNotificationDelayAccessor(const Value& row)
 677 {
 678         /* not supported */
 679         return Empty;
 680 }
 681
 682 Value ServicesTable::LowFlapThresholdAccessor(const Value& row)
 683 {
 684         /* TODO */
 685         return Empty;
 686 }
 687
 688 Value ServicesTable::HighFlapThresholdAccessor(const Value& row)
 689 {
 690         /* TODO */
 691         return Empty;
 692 }
 693
 694 Value ServicesTable::LatencyAccessor(const Value& row)
 695 {
 696         return (Service::CalculateLatency(static_cast<Service::Ptr>(row)->GetLastCheckResult()));
 697 }
 698
 699 Value ServicesTable::ExecutionTimeAccessor(const Value& row)
 700 {
 701         return (Service::CalculateExecutionTime(static_cast<Service::Ptr>(row)->GetLastCheckResult()));
 702 }
 703
 704 Value ServicesTable::PercentStateChangeAccessor(const Value& row)
 705 {
 706         return static_cast<Service::Ptr>(row)->GetFlappingCurrent();
 707 }
 708
 709 Value ServicesTable::InCheckPeriodAccessor(const Value& row)
 710 {
 711         TimePeriod::Ptr timeperiod = static_cast<Service::Ptr>(row)->GetCheckPeriod();
 712
 713         if (!timeperiod)
 714                 return Empty;
 715
 716         return (timeperiod->IsInside(Utility::GetTime()) ? 1 : 0);
 717 }
 718
 719 Value ServicesTable::InNotificationPeriodAccessor(const Value& row)
 720 {
 721         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
 722                 ObjectLock olock(notification);
 723
 724                 TimePeriod::Ptr timeperiod = notification->GetNotificationPeriod();
 725
 726                 /* XXX first notification wins */
 727                 if (timeperiod)
 728                         return (timeperiod->IsInside(Utility::GetTime()) ? 1 : 0);
 729         }
 730
 731         return 0;
 732 }
 733
 734 Value ServicesTable::ContactsAccessor(const Value& row)
 735 {
 736         /* XXX Service -> Notifications -> (Users + UserGroups -> Users) */
 737         std::set<User::Ptr> allUsers;
 738         std::set<User::Ptr> users;
 739         Array::Ptr contacts = boost::make_shared<Array>();
 740
 741         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
 742                 ObjectLock olock(notification);
 743
 744                 users = notification->GetUsers();
 745
 746                 std::copy(users.begin(), users.end(), std::inserter(allUsers, allUsers.begin()));
 747
 748                 BOOST_FOREACH(const UserGroup::Ptr& ug, notification->GetGroups()) {
 749                         std::set<User::Ptr> members = ug->GetMembers();
 750                         std::copy(members.begin(), members.end(), std::inserter(allUsers, allUsers.begin()));
 751                 }
 752         }
 753
 754         BOOST_FOREACH(const User::Ptr& user, allUsers) {
 755                 contacts->Add(user->GetName());
 756         }
 757
 758         return contacts;
 759 }
 760
 761 Value ServicesTable::DowntimesAccessor(const Value& row)
 762 {
 763         Dictionary::Ptr downtimes = static_cast<Service::Ptr>(row)->GetDowntimes();
 764
 765         if (!downtimes)
 766                 return Empty;
 767
 768         Array::Ptr ids = boost::make_shared<Array>();
 769
 770         ObjectLock olock(downtimes);
 771
 772         String id;
 773         Dictionary::Ptr downtime;
 774         BOOST_FOREACH(boost::tie(id, downtime), downtimes) {
 775
 776                 if (!downtime)
 777                         continue;
 778
 779                 if (Service::IsDowntimeExpired(downtime))
 780                         continue;
 781
 782                 ids->Add(downtime->Get("legacy_id"));
 783         }
 784
 785         return ids;
 786 }
 787
 788 Value ServicesTable::DowntimesWithInfoAccessor(const Value& row)
 789 {
 790         Dictionary::Ptr downtimes = static_cast<Service::Ptr>(row)->GetDowntimes();
 791
 792         if (!downtimes)
 793                 return Empty;
 794
 795         Array::Ptr ids = boost::make_shared<Array>();
 796
 797         ObjectLock olock(downtimes);
 798
 799         String id;
 800         Dictionary::Ptr downtime;
 801         BOOST_FOREACH(boost::tie(id, downtime), downtimes) {
 802
 803                 if (!downtime)
 804                         continue;
 805
 806                 if (Service::IsDowntimeExpired(downtime))
 807                         continue;
 808
 809                 Array::Ptr downtime_info = boost::make_shared<Array>();
 810                 downtime_info->Add(downtime->Get("legacy_id"));
 811                 downtime_info->Add(downtime->Get("author"));
 812                 downtime_info->Add(downtime->Get("comment"));
 813                 ids->Add(downtime_info);
 814         }
 815
 816         return ids;
 817 }
 818
 819 Value ServicesTable::CommentsAccessor(const Value& row)
 820 {
 821         Dictionary::Ptr comments = static_cast<Service::Ptr>(row)->GetComments();
 822
 823         if (!comments)
 824                 return Empty;
 825
 826         Array::Ptr ids = boost::make_shared<Array>();
 827
 828         ObjectLock olock(comments);
 829
 830         String id;
 831         Dictionary::Ptr comment;
 832         BOOST_FOREACH(boost::tie(id, comment), comments) {
 833
 834                 if (!comment)
 835                         continue;
 836
 837                 if (Service::IsCommentExpired(comment))
 838                         continue;
 839
 840                 ids->Add(comment->Get("legacy_id"));
 841         }
 842
 843         return ids;
 844 }
 845
 846 Value ServicesTable::CommentsWithInfoAccessor(const Value& row)
 847 {
 848         Dictionary::Ptr comments = static_cast<Service::Ptr>(row)->GetComments();
 849
 850         if (!comments)
 851                 return Empty;
 852
 853         Array::Ptr ids = boost::make_shared<Array>();
 854
 855         ObjectLock olock(comments);
 856
 857         String id;
 858         Dictionary::Ptr comment;
 859         BOOST_FOREACH(boost::tie(id, comment), comments) {
 860
 861                 if (!comment)
 862                         continue;
 863
 864                 if (Service::IsCommentExpired(comment))
 865                         continue;
 866
 867                 Array::Ptr comment_info = boost::make_shared<Array>();
 868                 comment_info->Add(comment->Get("legacy_id"));
 869                 comment_info->Add(comment->Get("author"));
 870                 comment_info->Add(comment->Get("text"));
 871                 ids->Add(comment_info);
 872         }
 873
 874         return ids;
 875 }
 876
 877 Value ServicesTable::CommentsWithExtraInfoAccessor(const Value& row)
 878 {
 879         Dictionary::Ptr comments = static_cast<Service::Ptr>(row)->GetComments();
 880
 881         if (!comments)
 882                 return Empty;
 883
 884         Array::Ptr ids = boost::make_shared<Array>();
 885
 886         ObjectLock olock(comments);
 887
 888         String id;
 889         Dictionary::Ptr comment;
 890         BOOST_FOREACH(boost::tie(id, comment), comments) {
 891
 892                 if (!comment)
 893                         continue;
 894
 895                 if (Service::IsCommentExpired(comment))
 896                         continue;
 897
 898                 Array::Ptr comment_info = boost::make_shared<Array>();
 899                 comment_info->Add(comment->Get("legacy_id"));
 900                 comment_info->Add(comment->Get("author"));
 901                 comment_info->Add(comment->Get("text"));
 902                 comment_info->Add(comment->Get("entry_type"));
 903                 comment_info->Add(static_cast<int>(comment->Get("entry_time")));
 904                 ids->Add(comment_info);
 905         }
 906
 907         return ids;
 908 }
 909
 910 Value ServicesTable::CustomVariableNamesAccessor(const Value& row)
 911 {
 912         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 913
 914         if (!custom)
 915                 return Empty;
 916
 917         Array::Ptr cv = boost::make_shared<Array>();
 918
 919         ObjectLock olock(custom);
 920         String key;
 921         Value value;
 922         BOOST_FOREACH(boost::tie(key, value), custom) {
 923                 if (key == "notes" ||
 924                     key == "action_url" ||
 925                     key == "notes_url" ||
 926                     key == "icon_image" ||
 927                     key == "icon_image_alt" ||
 928                     key == "statusmap_image" ||
 929                     key == "2d_coords")
 930                         continue;
 931
 932                 cv->Add(key);
 933         }
 934
 935         return cv;
 936 }
 937
 938 Value ServicesTable::CustomVariableValuesAccessor(const Value& row)
 939 {
 940         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 941
 942         if (!custom)
 943                 return Empty;
 944
 945         Array::Ptr cv = boost::make_shared<Array>();
 946
 947         ObjectLock olock(custom);
 948         String key;
 949         Value value;
 950         BOOST_FOREACH(boost::tie(key, value), custom) {
 951                 if (key == "notes" ||
 952                     key == "action_url" ||
 953                     key == "notes_url" ||
 954                     key == "icon_image" ||
 955                     key == "icon_image_alt" ||
 956                     key == "statusmap_image" ||
 957                     key == "2d_coords")
 958                         continue;
 959
 960                 cv->Add(value);
 961         }
 962
 963         return cv;
 964 }
 965
 966 Value ServicesTable::CustomVariablesAccessor(const Value& row)
 967 {
 968         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 969
 970         if (!custom)
 971                 return Empty;
 972
 973         Array::Ptr cv = boost::make_shared<Array>();
 974
 975         ObjectLock olock(custom);
 976         String key;
 977         Value value;
 978         BOOST_FOREACH(boost::tie(key, value), custom) {
 979                 if (key == "notes" ||
 980                     key == "action_url" ||
 981                     key == "notes_url" ||
 982                     key == "icon_image" ||
 983                     key == "icon_image_alt" ||
 984                     key == "statusmap_image" ||
 985                     key == "2d_coords")
 986                         continue;
 987
 988                 Array::Ptr key_val = boost::make_shared<Array>();
 989                 key_val->Add(key);
 990                 key_val->Add(value);
 991                 cv->Add(key_val);
 992         }
 993
 994         return cv;
 995 }
 996
 997 Value ServicesTable::GroupsAccessor(const Value& row)
 998 {
 999         Array::Ptr groups = static_cast<Service::Ptr>(row)->GetGroups();
1000
1001         if (!groups)
1002                 return Empty;
1003
1004         return groups;
1005 }
1006
1007 Value ServicesTable::ContactGroupsAccessor(const Value& row)
1008 {
1009         /* XXX Service -> Notifications -> UserGroups */
1010         Array::Ptr contactgroups = boost::make_shared<Array>();
1011
1012         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
1013                 ObjectLock olock(notification);
1014
1015                 BOOST_FOREACH(const UserGroup::Ptr& ug, notification->GetGroups()) {
1016                         contactgroups->Add(ug->GetName());
1017                 }
1018         }
1019
1020         return contactgroups;
1021 }
1022
1023