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         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastStateOK());
 485 }
 486
 487 Value ServicesTable::LastTimeWarningAccessor(const Value& row)
 488 {
 489         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastStateWarning());
 490 }
 491
 492 Value ServicesTable::LastTimeCriticalAccessor(const Value& row)
 493 {
 494         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastStateCritical());
 495 }
 496
 497 Value ServicesTable::LastTimeUnknownAccessor(const Value& row)
 498 {
 499         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastStateUnknown());
 500 }
 501
 502 Value ServicesTable::LastCheckAccessor(const Value& row)
 503 {
 504         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastCheck());
 505 }
 506
 507 Value ServicesTable::NextCheckAccessor(const Value& row)
 508 {
 509         return static_cast<int>(static_cast<Service::Ptr>(row)->GetNextCheck());
 510 }
 511
 512 Value ServicesTable::LastNotificationAccessor(const Value& row)
 513 {
 514         Service::Ptr service = static_cast<Service::Ptr>(row);
 515
 516         /* XXX Service -> Notifications, latest wins */
 517         double last_notification = 0;
 518         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 519                 if (notification->GetLastNotification() > last_notification)
 520                         last_notification = notification->GetLastNotification();
 521         }
 522
 523         return static_cast<int>(last_notification);
 524 }
 525
 526 Value ServicesTable::NextNotificationAccessor(const Value& row)
 527 {
 528         Service::Ptr service = static_cast<Service::Ptr>(row);
 529
 530         /* XXX Service -> Notifications, latest wins */
 531         double next_notification = 0;
 532         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 533                 if (notification->GetNextNotification() < next_notification)
 534                         next_notification = notification->GetNextNotification();
 535         }
 536
 537         return static_cast<int>(next_notification);
 538 }
 539
 540 Value ServicesTable::CurrentNotificationNumberAccessor(const Value& row)
 541 {
 542         Service::Ptr service = static_cast<Service::Ptr>(row);
 543
 544         /* XXX Service -> Notifications, biggest wins */
 545         int notification_number = 0;
 546         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 547                 if (notification->GetNotificationNumber() > notification_number)
 548                         notification_number = notification->GetNotificationNumber();
 549         }
 550
 551         return notification_number;
 552 }
 553
 554 Value ServicesTable::LastStateChangeAccessor(const Value& row)
 555 {
 556         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastStateChange());
 557 }
 558
 559 Value ServicesTable::LastHardStateChangeAccessor(const Value& row)
 560 {
 561         return static_cast<int>(static_cast<Service::Ptr>(row)->GetLastHardStateChange());
 562 }
 563
 564 Value ServicesTable::ScheduledDowntimeDepthAccessor(const Value& row)
 565 {
 566         return static_cast<Service::Ptr>(row)->GetDowntimeDepth();
 567 }
 568
 569 Value ServicesTable::IsFlappingAccessor(const Value& row)
 570 {
 571         return static_cast<Service::Ptr>(row)->IsFlapping();
 572 }
 573
 574 Value ServicesTable::ChecksEnabledAccessor(const Value& row)
 575 {
 576         return (static_cast<Service::Ptr>(row)->GetEnableActiveChecks() ? 1 : 0);
 577 }
 578
 579 Value ServicesTable::AcceptPassiveChecksAccessor(const Value& row)
 580 {
 581         return (static_cast<Service::Ptr>(row)->GetEnablePassiveChecks() ? 1 : 0);
 582 }
 583
 584 Value ServicesTable::EventHandlerEnabledAccessor(const Value& row)
 585 {
 586         /* TODO always enabled*/
 587         return Value(1);
 588 }
 589
 590 Value ServicesTable::NotificationsEnabledAccessor(const Value& row)
 591 {
 592         return (static_cast<Service::Ptr>(row)->GetEnableNotifications() ? 1 : 0);
 593 }
 594
 595 Value ServicesTable::ProcessPerformanceDataAccessor(const Value& row)
 596 {
 597         /* TODO always enabled */
 598         return Value(1);
 599 }
 600
 601 Value ServicesTable::IsExecutingAccessor(const Value& row)
 602 {
 603         /* TODO does that make sense with Icinga2? */
 604         return Empty;
 605 }
 606
 607 Value ServicesTable::ActiveChecksEnabledAccessor(const Value& row)
 608 {
 609         return (static_cast<Service::Ptr>(row)->GetEnableActiveChecks() ? 1 : 0);
 610 }
 611
 612 Value ServicesTable::CheckOptionsAccessor(const Value& row)
 613 {
 614         /* TODO - forcexec, freshness, orphan, none */
 615         return Empty;
 616 }
 617
 618 Value ServicesTable::FlapDetectionEnabledAccessor(const Value& row)
 619 {
 620         return (static_cast<Service::Ptr>(row)->GetEnableFlapping() ? 1 : 0);
 621 }
 622
 623 Value ServicesTable::CheckFreshnessAccessor(const Value& row)
 624 {
 625         /* TODO */
 626         return Empty;
 627 }
 628
 629 Value ServicesTable::ObsessOverServiceAccessor(const Value& row)
 630 {
 631         /* not supported */
 632         return Empty;
 633 }
 634
 635 Value ServicesTable::ModifiedAttributesAccessor(const Value& row)
 636 {
 637         /* not supported */
 638         return Empty;
 639 }
 640
 641 Value ServicesTable::ModifiedAttributesListAccessor(const Value& row)
 642 {
 643         /* not supported */
 644         return Empty;
 645 }
 646
 647 Value ServicesTable::PnpgraphPresentAccessor(const Value& row)
 648 {
 649         /* not supported */
 650         return Empty;
 651 }
 652
 653 Value ServicesTable::CheckIntervalAccessor(const Value& row)
 654 {
 655         return (static_cast<Service::Ptr>(row)->GetCheckInterval() / 60.0);
 656 }
 657
 658 Value ServicesTable::RetryIntervalAccessor(const Value& row)
 659 {
 660         return (static_cast<Service::Ptr>(row)->GetRetryInterval() / 60.0);
 661 }
 662
 663 Value ServicesTable::NotificationIntervalAccessor(const Value& row)
 664 {
 665         Service::Ptr service = static_cast<Service::Ptr>(row);
 666
 667         /* XXX take the smallest notification_interval */
 668         double notification_interval = -1;
 669         BOOST_FOREACH(const Notification::Ptr& notification, service->GetNotifications()) {
 670                 if (notification_interval == -1 || notification->GetNotificationInterval() < notification_interval)
 671                         notification_interval = notification->GetNotificationInterval();
 672         }
 673
 674         if (notification_interval == -1)
 675                 notification_interval = 60;
 676
 677         return (notification_interval / 60.0);
 678 }
 679
 680 Value ServicesTable::FirstNotificationDelayAccessor(const Value& row)
 681 {
 682         /* not supported */
 683         return Empty;
 684 }
 685
 686 Value ServicesTable::LowFlapThresholdAccessor(const Value& row)
 687 {
 688         /* TODO */
 689         return Empty;
 690 }
 691
 692 Value ServicesTable::HighFlapThresholdAccessor(const Value& row)
 693 {
 694         /* TODO */
 695         return Empty;
 696 }
 697
 698 Value ServicesTable::LatencyAccessor(const Value& row)
 699 {
 700         return (Service::CalculateLatency(static_cast<Service::Ptr>(row)->GetLastCheckResult()));
 701 }
 702
 703 Value ServicesTable::ExecutionTimeAccessor(const Value& row)
 704 {
 705         return (Service::CalculateExecutionTime(static_cast<Service::Ptr>(row)->GetLastCheckResult()));
 706 }
 707
 708 Value ServicesTable::PercentStateChangeAccessor(const Value& row)
 709 {
 710         return static_cast<Service::Ptr>(row)->GetFlappingCurrent();
 711 }
 712
 713 Value ServicesTable::InCheckPeriodAccessor(const Value& row)
 714 {
 715         TimePeriod::Ptr timeperiod = static_cast<Service::Ptr>(row)->GetCheckPeriod();
 716
 717         if (!timeperiod)
 718                 return Empty;
 719
 720         return (timeperiod->IsInside(Utility::GetTime()) ? 1 : 0);
 721 }
 722
 723 Value ServicesTable::InNotificationPeriodAccessor(const Value& row)
 724 {
 725         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
 726                 ObjectLock olock(notification);
 727
 728                 TimePeriod::Ptr timeperiod = notification->GetNotificationPeriod();
 729
 730                 /* XXX first notification wins */
 731                 if (timeperiod)
 732                         return (timeperiod->IsInside(Utility::GetTime()) ? 1 : 0);
 733         }
 734
 735         return 0;
 736 }
 737
 738 Value ServicesTable::ContactsAccessor(const Value& row)
 739 {
 740         /* XXX Service -> Notifications -> (Users + UserGroups -> Users) */
 741         std::set<User::Ptr> allUsers;
 742         std::set<User::Ptr> users;
 743         Array::Ptr contacts = boost::make_shared<Array>();
 744
 745         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
 746                 ObjectLock olock(notification);
 747
 748                 users = notification->GetUsers();
 749
 750                 std::copy(users.begin(), users.end(), std::inserter(allUsers, allUsers.begin()));
 751
 752                 BOOST_FOREACH(const UserGroup::Ptr& ug, notification->GetGroups()) {
 753                         std::set<User::Ptr> members = ug->GetMembers();
 754                         std::copy(members.begin(), members.end(), std::inserter(allUsers, allUsers.begin()));
 755                 }
 756         }
 757
 758         BOOST_FOREACH(const User::Ptr& user, allUsers) {
 759                 contacts->Add(user->GetName());
 760         }
 761
 762         return contacts;
 763 }
 764
 765 Value ServicesTable::DowntimesAccessor(const Value& row)
 766 {
 767         Dictionary::Ptr downtimes = static_cast<Service::Ptr>(row)->GetDowntimes();
 768
 769         if (!downtimes)
 770                 return Empty;
 771
 772         Array::Ptr ids = boost::make_shared<Array>();
 773
 774         ObjectLock olock(downtimes);
 775
 776         String id;
 777         Dictionary::Ptr downtime;
 778         BOOST_FOREACH(boost::tie(id, downtime), downtimes) {
 779
 780                 if (!downtime)
 781                         continue;
 782
 783                 if (Service::IsDowntimeExpired(downtime))
 784                         continue;
 785
 786                 ids->Add(downtime->Get("legacy_id"));
 787         }
 788
 789         return ids;
 790 }
 791
 792 Value ServicesTable::DowntimesWithInfoAccessor(const Value& row)
 793 {
 794         Dictionary::Ptr downtimes = static_cast<Service::Ptr>(row)->GetDowntimes();
 795
 796         if (!downtimes)
 797                 return Empty;
 798
 799         Array::Ptr ids = boost::make_shared<Array>();
 800
 801         ObjectLock olock(downtimes);
 802
 803         String id;
 804         Dictionary::Ptr downtime;
 805         BOOST_FOREACH(boost::tie(id, downtime), downtimes) {
 806
 807                 if (!downtime)
 808                         continue;
 809
 810                 if (Service::IsDowntimeExpired(downtime))
 811                         continue;
 812
 813                 Array::Ptr downtime_info = boost::make_shared<Array>();
 814                 downtime_info->Add(downtime->Get("legacy_id"));
 815                 downtime_info->Add(downtime->Get("author"));
 816                 downtime_info->Add(downtime->Get("comment"));
 817                 ids->Add(downtime_info);
 818         }
 819
 820         return ids;
 821 }
 822
 823 Value ServicesTable::CommentsAccessor(const Value& row)
 824 {
 825         Dictionary::Ptr comments = static_cast<Service::Ptr>(row)->GetComments();
 826
 827         if (!comments)
 828                 return Empty;
 829
 830         Array::Ptr ids = boost::make_shared<Array>();
 831
 832         ObjectLock olock(comments);
 833
 834         String id;
 835         Dictionary::Ptr comment;
 836         BOOST_FOREACH(boost::tie(id, comment), comments) {
 837
 838                 if (!comment)
 839                         continue;
 840
 841                 if (Service::IsCommentExpired(comment))
 842                         continue;
 843
 844                 ids->Add(comment->Get("legacy_id"));
 845         }
 846
 847         return ids;
 848 }
 849
 850 Value ServicesTable::CommentsWithInfoAccessor(const Value& row)
 851 {
 852         Dictionary::Ptr comments = static_cast<Service::Ptr>(row)->GetComments();
 853
 854         if (!comments)
 855                 return Empty;
 856
 857         Array::Ptr ids = boost::make_shared<Array>();
 858
 859         ObjectLock olock(comments);
 860
 861         String id;
 862         Dictionary::Ptr comment;
 863         BOOST_FOREACH(boost::tie(id, comment), comments) {
 864
 865                 if (!comment)
 866                         continue;
 867
 868                 if (Service::IsCommentExpired(comment))
 869                         continue;
 870
 871                 Array::Ptr comment_info = boost::make_shared<Array>();
 872                 comment_info->Add(comment->Get("legacy_id"));
 873                 comment_info->Add(comment->Get("author"));
 874                 comment_info->Add(comment->Get("text"));
 875                 ids->Add(comment_info);
 876         }
 877
 878         return ids;
 879 }
 880
 881 Value ServicesTable::CommentsWithExtraInfoAccessor(const Value& row)
 882 {
 883         Dictionary::Ptr comments = static_cast<Service::Ptr>(row)->GetComments();
 884
 885         if (!comments)
 886                 return Empty;
 887
 888         Array::Ptr ids = boost::make_shared<Array>();
 889
 890         ObjectLock olock(comments);
 891
 892         String id;
 893         Dictionary::Ptr comment;
 894         BOOST_FOREACH(boost::tie(id, comment), comments) {
 895
 896                 if (!comment)
 897                         continue;
 898
 899                 if (Service::IsCommentExpired(comment))
 900                         continue;
 901
 902                 Array::Ptr comment_info = boost::make_shared<Array>();
 903                 comment_info->Add(comment->Get("legacy_id"));
 904                 comment_info->Add(comment->Get("author"));
 905                 comment_info->Add(comment->Get("text"));
 906                 comment_info->Add(comment->Get("entry_type"));
 907                 comment_info->Add(static_cast<int>(comment->Get("entry_time")));
 908                 ids->Add(comment_info);
 909         }
 910
 911         return ids;
 912 }
 913
 914 Value ServicesTable::CustomVariableNamesAccessor(const Value& row)
 915 {
 916         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 917
 918         if (!custom)
 919                 return Empty;
 920
 921         Array::Ptr cv = boost::make_shared<Array>();
 922
 923         ObjectLock olock(custom);
 924         String key;
 925         Value value;
 926         BOOST_FOREACH(boost::tie(key, value), custom) {
 927                 if (key == "notes" ||
 928                     key == "action_url" ||
 929                     key == "notes_url" ||
 930                     key == "icon_image" ||
 931                     key == "icon_image_alt" ||
 932                     key == "statusmap_image" ||
 933                     key == "2d_coords")
 934                         continue;
 935
 936                 cv->Add(key);
 937         }
 938
 939         return cv;
 940 }
 941
 942 Value ServicesTable::CustomVariableValuesAccessor(const Value& row)
 943 {
 944         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 945
 946         if (!custom)
 947                 return Empty;
 948
 949         Array::Ptr cv = boost::make_shared<Array>();
 950
 951         ObjectLock olock(custom);
 952         String key;
 953         Value value;
 954         BOOST_FOREACH(boost::tie(key, value), custom) {
 955                 if (key == "notes" ||
 956                     key == "action_url" ||
 957                     key == "notes_url" ||
 958                     key == "icon_image" ||
 959                     key == "icon_image_alt" ||
 960                     key == "statusmap_image" ||
 961                     key == "2d_coords")
 962                         continue;
 963
 964                 cv->Add(value);
 965         }
 966
 967         return cv;
 968 }
 969
 970 Value ServicesTable::CustomVariablesAccessor(const Value& row)
 971 {
 972         Dictionary::Ptr custom = static_cast<Service::Ptr>(row)->GetCustom();
 973
 974         if (!custom)
 975                 return Empty;
 976
 977         Array::Ptr cv = boost::make_shared<Array>();
 978
 979         ObjectLock olock(custom);
 980         String key;
 981         Value value;
 982         BOOST_FOREACH(boost::tie(key, value), custom) {
 983                 if (key == "notes" ||
 984                     key == "action_url" ||
 985                     key == "notes_url" ||
 986                     key == "icon_image" ||
 987                     key == "icon_image_alt" ||
 988                     key == "statusmap_image" ||
 989                     key == "2d_coords")
 990                         continue;
 991
 992                 Array::Ptr key_val = boost::make_shared<Array>();
 993                 key_val->Add(key);
 994                 key_val->Add(value);
 995                 cv->Add(key_val);
 996         }
 997
 998         return cv;
 999 }
1000
1001 Value ServicesTable::GroupsAccessor(const Value& row)
1002 {
1003         Array::Ptr groups = static_cast<Service::Ptr>(row)->GetGroups();
1004
1005         if (!groups)
1006                 return Empty;
1007
1008         return groups;
1009 }
1010
1011 Value ServicesTable::ContactGroupsAccessor(const Value& row)
1012 {
1013         /* XXX Service -> Notifications -> UserGroups */
1014         Array::Ptr contactgroups = boost::make_shared<Array>();
1015
1016         BOOST_FOREACH(const Notification::Ptr& notification, static_cast<Service::Ptr>(row)->GetNotifications()) {
1017                 ObjectLock olock(notification);
1018
1019                 BOOST_FOREACH(const UserGroup::Ptr& ug, notification->GetGroups()) {
1020                         contactgroups->Add(ug->GetName());
1021                 }
1022         }
1023
1024         return contactgroups;
1025 }
1026
1027